decord/beta/source/utils/native/UploadUtils.tsx

// Module ID: 7769
// Function ID: 7770
// Name: utils/UploadUtils
// Dependencies: [109, 5, 17, 1207, 5282, 1390, 1085, 7483, 3, 7500, 7770, 7760, 7776, 1382, 4808, 1126, 1445, 4769, 7759, 1162, 7777, 7779, 7780, 7765, 5068, 38, 7781, 7782, 7783, 1388, 7784, 7785, 7786, 5444, 7787, 2]
// Exports: cancelGetFileInfo, getAppDir, getCaptionLabel, getFileFromUploadItem, getFileInfo, getFileSize, getImageCompressionQuality, getImageDimensionsIfMissing, getType, openImagePicker, resolveModeToVideoQualityForFreeUser, resolveModeToVideoQualityForUserWithFeature, shouldResolveToMediaFilePath

// Module 7769 (utils/UploadUtils)
import LoggerDefault from "Logger" /* 3 */;
import react_native from "react-native" /* 17 */;
import react_nativeDefault from "react-native" /* 1162 */;
import PlatformUtils from "PlatformUtils" /* 1382 */;
import react_nativeDefault2 from "react-native" /* 1445 */;
import PremiumUtilsDefault from "PremiumUtils" /* 4769 */;
import NativePermissionConstants from "NativePermissionConstants" /* 7483 */;
import NativePermissionUtilsDefault from "NativePermissionUtils" /* 7500 */;
import UploadPlatform from "UploadPlatform" /* 7759 */;
import FileUtils from "FileUtils" /* 7765 */;
import ImageConversionDecision from "ImageConversionDecision" /* 7777 */;
import VideoUploadUtils from "VideoUploadUtils" /* 7779 */;
import UploadLimits from "UploadLimits" /* 7780 */;
import utils_TimeUtils from "utils/TimeUtils" /* 7787 */;
import _objectWithoutProperties from "_objectWithoutProperties" /* 109 */;
import _asyncToGenerator from "_asyncToGenerator" /* 5 */;
import UnsyncedUserSettingsStore_mod from "UnsyncedUserSettingsStore" /* 1207 */;
import NetworkStore from "NetworkStore" /* 5282 */;
import UserStore from "UserStore" /* 1390 */;
import Constants from "Constants" /* 1085 */;
import size_mod from "module_2" /* 2 */;

const require = globalThis.__r;
let c13, catchPromise, closure_11;

let Base64GIFPrefix;
let Base64JPEGPrefix;
let closure_12;
let closure_14;
let closure_15;
let closure_16;
let closure_17;
let metroImportAll;
let metroImportDefault;
let tmp;
const DeviceUtils = tmp(5068);
const UploadUtils = tmp(7760);
function openImagePickerUnhandled() {
  return obj(...arguments);
}
let obj = function _openImagePickerUnhandled() {
  obj = _asyncToGenerator(async (arg0) => {
    const styles = arg0;
    let c11 = 0;
    let c12 = 0;
    let c9 = 0;
    return (async function(arg0, value) {
      let logger;
      let obj35;
      if (c12 === 2) {
        c12 = 3;
        let str = "Generator functions may not be called on executing generators";
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          let width;
          let height;
          let cleanPickedImage;
          c12 = 2;
          switch (c11) {
            case 0:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c12 = 3;
                return { value, done: true };
              } else {
                closure_6 = tmp;
                width = undefined;
                height = undefined;
                obj13 = undefined;
                obj11 = undefined;
                catchPromise = undefined;
                obj9 = undefined;
                cleanPickedImage = function cleanPickedImage() {
                  let uri;
                  obj = styles(obj22[13]);
                  if (obj.isIOS()) {
                    const nextPromise = catchPromise.then(() => {
                      obj = catchPromise(width[10]);
                      const str = uri.uri;
                      return obj.cleanSingle(decodeURIComponent(str.replace(/^file:\/\//, "")));
                    });
                    catchPromise = nextPromise.catch((error) => logger.warn("Failed to remove picked image", error));
                  }
                };
                c11 = 1;
                c12 = 1;
                const obj4 = { value: obj35.requestPermission(constants.PHOTOS), done: false };
                obj35 = NativePermissionUtilsDefault;
                return obj4;
              }
              break;
            }
            case 1:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c12 = 3;
                return { value, done: true };
              } else if (value) {
                catchPromise = "size" in styles;
                size = { width: null, height: null };
                if (catchPromise) {
                  size.width = styles.size;
                  size.height = styles.size;
                  catchPromise = size;
                } else {
                  size.width = styles.width;
                  size.height = styles.height;
                  catchPromise = size;
                }
                width = catchPromise.width;
                height = catchPromise.height;
                catchPromise = this;
                let self2 = this;
                c11 = 2;
                c12 = 1;
                const obj6 = {
                  value: new Promise((arg0, arg1) => {
                              let closure_0 = arg0;
                              let closure_1 = arg1;
                              obj = closure_1(closure_2[10]);
                              obj.launchImageLibrary({ mediaType: "photo", includeBase64: true, disableNewIOSPicker: true }, function(assets) {
                                let first = null;
                                if (null != assets.assets) {
                                  first = null;
                                  if (assets.assets.length > 0) {
                                    first = assets.assets[0];
                                  }
                                }
                                if (assets.didCancel) {
                                  const _Error2 = Error;
                                  const self3 = this;
                                  const self4 = this;
                                  const error = new Error(closure_2_22);
                                  closure_1(error);
                                } else {
                                  if (null == assets.errorCode) {
                                    let uri;
                                    if (first != null) {
                                      uri = first.uri;
                                    }
                                    if (null != uri) {
                                      obj = { uri: null, base64: null };
                                      ({ uri: obj.uri, base64: obj.base64 } = first);
                                      closure_0(obj);
                                    }
                                  }
                                  const _Error = Error;
                                  const self = this;
                                  const self2 = this;
                                  const error1 = new Error(assets.errorMessage);
                                  closure_1(error1);
                                }
                              });
                            }),
                  done: false
                };
                return obj6;
              } else {
                let _Error = Error;
                catchPromise = this;
                let self = this;
                let error = new Error(closure_134_23);
                throw error;
              }
              break;
            }
            case 2:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c12 = 3;
                return { value, done: true };
              } else {
                obj13 = value;
                const obj8 = { uri: obj13.uri, i: "" };
                const obj32 = closure_134_0(closure_134_2[11]);
                obj11 = obj32.getFile(obj8);
                const obj34 = closure_134_1(closure_134_2[12]);
                const fromFileUriResult = obj34.fromFileUri(obj13.uri);
                catchPromise = fromFileUriResult.catch(() => null);
                if (null != obj13.base64) {
                  catchPromise = closure_134_0(closure_134_2[13]);
                  if (catchPromise.isAndroid()) {
                    const base64 = obj13.base64;
                    catchPromise = base64.startsWith("UklGR");
                    if (catchPromise) {
                      obj9 = { base64: closure_134_16 + obj13.base64, mimeType: "image/webp" };
                      c11 = 3;
                      c12 = 1;
                      return { value: catchPromise, done: false };
                    } else {
                      const base641 = obj13.base64;
                      catchPromise = base641.indexOf("ZnR5cA==");
                      if (4 === catchPromise) {
                        const base642 = obj13.base64;
                        catchPromise = base642.indexOf("YXZpZg==");
                        if (8 !== catchPromise) {
                          const base643 = obj13.base64;
                          catchPromise = base643.indexOf("YXZpcw==");
                        }
                        obj11 = { base64: closure_134_17 + obj13.base64, mimeType: "image/avif" };
                        c11 = 4;
                        c12 = 1;
                        return { value: catchPromise, done: false };
                      }
                    }
                  }
                }
                catchPromise = obj11.type;
                if ("image/gif" === catchPromise) {
                  cleanPickedImage();
                  obj13 = { base64: closure_134_13 + obj13.base64, mimeType: "image/gif" };
                  c11 = 5;
                  c12 = 1;
                  return { value: catchPromise, done: false };
                } else {
                  c9 = 2;
                  catchPromise = { uri: obj13.uri, width, height, includeBase64: true, mimeType: type };
                  const preferredMimeType = styles.preferredMimeType;
                  type = preferredMimeType;
                  const launchCropper = closure_134_1(closure_134_2[10]).launchCropper;
                  closure_134_1(closure_134_2[10]);
                  if (preferredMimeType == null) {
                    type = obj11.type;
                  }
                  c11 = 8;
                  c12 = 1;
                  const obj15 = { value: launchCropper(catchPromise), done: false };
                  return obj15;
                }
              }
              break;
            }
            case 3:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c12 = 3;
                return { value, done: true };
              } else {
                obj9.originalMd5 = value;
                c12 = 3;
                return { value: obj9, done: true };
              }
              break;
            }
            case 4:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c12 = 3;
                return { value, done: true };
              } else {
                obj11.originalMd5 = value;
                c12 = 3;
                return { value: obj11, done: true };
              }
              break;
            }
            case 5:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c12 = 3;
                return { value, done: true };
              } else {
                obj13.originalMd5 = value;
                c12 = 3;
                return { value: obj13, done: true };
              }
              break;
            }
            case 6:
            {
              c9 = 0;
              catchPromise = cleanPickedImage();
              throw closure_10;
            }
            case 7:
            {
              catchPromise = closure_10;
              c9 = 1;
              let closure_9 = closure_10;
              if ("E_PICKER_CANCELLED" === closure_9.code) {
                throw closure_9;
              } else {
                obj22 = { base64: closure_134_12 + obj13.base64, mimeType: obj11.type, errorStr: closure_9.message };
                c11 = 10;
                c12 = 1;
                return { value: catchPromise, done: false };
              }
              break;
            }
            case 8:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c9 = 0;
                cleanPickedImage();
                c12 = 3;
                return { value, done: true };
              } else {
                obj9 = value;
                const obj30 = closure_134_1(closure_134_2[10]);
                const cleanSingleResult = obj30.cleanSingle(obj9.path);
                cleanSingleResult.catch((error) => logger.warn("Failed to remove cropped image", error));
                obj25 = { base64: "data:" + obj9.mime + ";base64," + obj9.data, mimeType: obj9.mime };
                const _HermesInternal = HermesInternal;
                c11 = 9;
                c12 = 1;
                return { value: catchPromise, done: false };
              }
              break;
            }
            case 9:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c9 = 0;
                cleanPickedImage();
                c12 = 3;
                return { value, done: true };
              } else {
                obj25.originalMd5 = value;
                c9 = 0;
                cleanPickedImage();
                c12 = 3;
                obj = { value: obj25, done: true };
                return obj;
              }
              break;
            }
            default:
            {
              if (arg0 === 1) {
                c12 = 3;
                throw value;
              } else if (arg0 === 2) {
                c9 = 0;
                cleanPickedImage();
                c12 = 3;
                return { value, done: true };
              } else {
                obj22.originalMd5 = value;
                c9 = 0;
                cleanPickedImage();
                c12 = 3;
                return { value: obj22, done: true };
              }
              break;
            }
          }
        } catch (tmp82) {
          closure_10 = tmp82;
          if (0 === c9) {
            c12 = 3;
            throw tmp82;
          } else if (1 === tmp84) {
            c11 = 6;
          } else {
            c11 = 7;
          }
        }
      }
    })();
  });
  return obj(...arguments);
};
function openImagePicker() {
  return obj(...arguments);
}
obj = function _openImagePicker() {
  obj = _asyncToGenerator(async (value) => {
    let c5 = 0;
    let c6 = 0;
    let c4 = 0;
    return (async (arg0, value) => {
      if (c6 === 2) {
        c6 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          c6 = 2;
          if (0 === c5) {
            if (arg0 === 1) {
              c6 = 3;
              throw value;
            } else if (arg0 === 2) {
              c6 = 3;
              return { value, done: true };
            } else {
              closure_2 = tmp;
              closure_1 = tmp4;
              value = undefined;
              c4 = 1;
              c5 = 2;
              c6 = 1;
              const obj5 = { value: openImagePickerUnhandled(value), done: false };
              return obj5;
            }
          } else if (1 === c5) {
            c4 = 0;
            closure_1 = closure_3;
            if ("E_PICKER_CANCELLED" !== closure_1.code) {
              let obj7;
              if (closure_1.message !== closure_130_22) {
                if (closure_1.message === closure_130_23) {
                  obj7 = { errorStr: closure_130_23 };
                  const obj6 = { errorStr: closure_130_23 };
                } else if ("E_CROPPER_IMAGE_NOT_FOUND" === closure_1.code) {
                  const presentFailedToast2 = closure_130_0(closure_130_2[14]).presentFailedToast;
                  closure_130_0(closure_130_2[14]);
                  const intl2 = closure_130_0(closure_130_2[15]).intl;
                  presentFailedToast2(intl2.string(closure_130_0(closure_130_2[15]).t.TTzyzW));
                  obj7 = { errorStr: "No select photo access" };
                } else {
                  const obj4 = closure_130_0(closure_130_2[14]);
                  obj4.presentFailedToast(closure_1.message);
                  obj7 = { errorStr: closure_1.message };
                }
              }
              c6 = 3;
              return { value: obj7, done: true };
            }
            obj7 = { errorStr: closure_130_22 };
            const obj9 = { errorStr: closure_130_22 };
          } else if (arg0 === 1) {
            c6 = 3;
            throw value;
          } else if (arg0 === 2) {
            c4 = 0;
            c6 = 3;
            return { value, done: true };
          } else {
            if (null != value.errorStr) {
              const presentFailedToast = closure_130_0(closure_130_2[14]).presentFailedToast;
              closure_130_0(closure_130_2[14]);
              const intl = closure_130_0(closure_130_2[15]).intl;
              obj = { reason: value.errorStr };
              presentFailedToast(intl.formatToPlainString(closure_130_0(closure_130_2[15]).t.Ex162J, obj));
            }
            c4 = 0;
            c6 = 3;
            return { value, done: true };
          }
        } catch (tmp43) {
          closure_3 = tmp43;
          if (0 === c4) {
            c6 = 3;
            throw tmp43;
          } else {
            c5 = 1;
          }
        }
      }
    })();
  });
  return obj(...arguments);
};
function mediaManager() {
  return obj(...arguments);
}
obj = function _mediaManager() {
  obj = _asyncToGenerator(async (arg0) => {
    let applyResult;
    let closure_0 = arg0;
    let closure_1 = [...arguments].slice();
    let c6 = 0;
    let c7 = 0;
    let c5 = 0;
    const iter = (async (arg0, value) => {
      if (c7 === 2) {
        c7 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          c7 = 2;
          if (0 === c6) {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              return { value, done: true };
            } else {
              closure_3 = tmp;
              c6 = 1;
              c7 = 1;
              return { value: "Set", done: true };
            }
          } else if (1 === c6) {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              return { value, done: true };
            } else {
              c5 = 1;
              c6 = 3;
              c7 = 1;
              const obj5 = { value: closure_0.apply(closure_131_1(closure_131_2[16]), closure_1), done: false };
              return obj5;
            }
          } else if (2 === c6) {
            c5 = 0;
            let closure_2 = closure_4;
            closure_131_19.warn(closure_2);
            c7 = 3;
            return { value: "IconComponent", done: null };
          } else if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c5 = 0;
            c7 = 3;
            return { value, done: true };
          } else {
            c5 = 0;
            c7 = 3;
            return { value, done: true };
          }
        } catch (tmp21) {
          closure_4 = tmp21;
          if (0 === c5) {
            c7 = 3;
            throw tmp21;
          } else {
            c6 = 2;
          }
        }
      }
    })();
    iter.next();
    return iter;
  });
  return obj(...arguments);
};
function getVideoQuality() {
  let LOW;
  const tmp = UnsyncedUserSettingsStore;
  if (UnsyncedUserSettingsStore.dataSavingMode) {
    if (NetworkStore.getType() === constants3.CELLULAR) {
      return metroImportDefault.LOW;
    }
  }
  const videoUploadQuality = tmp.videoUploadQuality;
  const currentUser = UserStore.getCurrentUser();
  const DATA_SAVER = metroImportAll.DATA_SAVER;
  obj = PremiumUtilsDefault;
  if (obj.canUseHighVideoUploadQuality(currentUser)) {
    let MEDIUM;
    if (DATA_SAVER === videoUploadQuality) {
      MEDIUM = metroImportDefault.LOW;
    } else if (metroImportAll.STANDARD === videoUploadQuality) {
      MEDIUM = metroImportDefault.HIGH;
    } else if (metroImportAll.BEST === videoUploadQuality) {
      MEDIUM = metroImportDefault.VERY_HIGH;
    } else {
      MEDIUM = metroImportDefault.MEDIUM;
    }
    LOW = MEDIUM;
  } else if (DATA_SAVER === videoUploadQuality) {
    LOW = metroImportDefault.LOW;
  } else if (metroImportAll.STANDARD === videoUploadQuality) {
    LOW = metroImportDefault.MEDIUM;
  } else if (metroImportAll.BEST === videoUploadQuality) {
    LOW = metroImportDefault.HIGH;
  } else {
    LOW = metroImportDefault.LOW;
  }
  return LOW;
}
function getAppDir() {
  obj = PlatformUtils;
  const isAndroidResult = obj.isAndroid();
  const obj2 = react_nativeDefault;
  if (isAndroidResult) {
    if (null == obj2) {
      const _Error = Error;
      const self = this;
      const self2 = this;
      const error = new Error("RTNFileManager doesn't exist?");
      throw error;
    } else {
      const tmp3Result = react_nativeDefault;
      const str4 = tmp3Result.getConstants().CacheDirPath;
      return str4.replace(/cache$/, "");
    }
  } else {
    const str = obj2.getConstants().DocumentsDirPath;
    return "/private" + str.replace(/Documents$/, "");
  }
}
function getFileInfo(c1, arg1) {
  let allowOptimization;
  let description;
  let filename;
  let item;
  let mimeType;
  let mimeType2;
  let originalUri;
  let spoiler;
  function processVideoUpload(arg0) {
    return obj(...arguments);
  }
  function processImageOrFileUpload(size) {
    return obj(...arguments);
  }
  ({ item, spoiler, description } = c1);
  let str = arg1;
  ({ mimeType, allowOptimization } = c1);
  if (arg1 === undefined) {
    str = "";
  }
  if (item.platform !== UploadPlatform.UploadPlatform.REACT_NATIVE) {
    const _Error = Error;
    const self = this;
    const self2 = this;
    const error = new Error("Try to get file info for unsupported upload item");
    throw error;
  } else {
    let tmp3;
    ({ originalUri, filename, mimeType: mimeType2 } = item);
    if (mimeType2 == null) {
      mimeType2 = mimeType;
    }
    obj = { uri: originalUri, overrideType: mimeType2 };
    const tmpResult = UploadUtils;
    if (tmpResult.getFile(obj).isVideo) {
      const obj2 = { originalUri, filename, mimeType: mimeType2, fileSize: item.size, spoiler, description, i: str };
      tmp3 = processVideoUpload(obj2);
    } else {
      size = { originalUri, filename, mimeType: mimeType2, spoiler, description, i: str, width: null, height: null, allowOptimization };
      ({ width: obj3.width, height: obj3.height } = item);
      tmp3 = processImageOrFileUpload(size);
    }
    return tmp3;
  }
}
obj = function _getPhotoKitDataUTI() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let obj4;
    let closure_0 = arg0;
    if (c7 === 2) {
      c7 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      let c5;
      try {
        c7 = 2;
        if (0 === c6) {
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_3 = tmp;
            let closure_2 = tmp4;
            const obj9 = PlatformUtils;
            const tmp22 = dependencyMap;
            if (obj9.isIOS()) {
              if (closure_0.startsWith("ph://")) {
                c5 = 1;
                c6 = 2;
                c7 = 1;
                const obj5 = { value: obj4.getImageContentType(closure_0), done: false };
                obj4 = require("react-native");
                return obj5;
              }
            }
            c7 = 3;
            return { value: "IconComponent", done: null };
          }
        } else if (1 === c6) {
          c5 = 0;
          closure_0 = closure_4;
          const _HermesInternal = HermesInternal;
          closure_131_19.warn("getImageContentType failed: " + closure_0);
          c7 = 3;
          const obj6 = { value: undefined, done: true };
          return obj6;
        } else if (arg0 === 1) {
          c7 = 3;
          throw value;
        } else if (arg0 === 2) {
          c5 = 0;
          c7 = 3;
          const obj7 = { value, done: true };
          return obj7;
        } else {
          if (value == null) {
            value = undefined;
          }
          c5 = 0;
          c7 = 3;
          obj = { value, done: true };
          return obj;
        }
      } catch (tmp13) {
        closure_4 = tmp13;
        if (0 === c5) {
          c7 = 3;
          throw tmp13;
        } else {
          c6 = 1;
        }
      }
    }
  });
  return obj(...arguments);
};
obj = function _shouldConvertToPNG() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let obj4;
    let closure_0 = arg0;
    let closure_1 = value;
    if (c7 === 2) {
      c7 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      let c5;
      try {
        c7 = 2;
        if (0 === c6) {
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_3 = tmp;
            let closure_2 = tmp4;
            const obj8 = PlatformUtils;
            const tmp22 = require;
            if (obj8.isIOS()) {
              const tmp22Result = tmp22(dependencyMap[20]);
              if (tmp22Result.isPhotoKitAsset(closure_0, closure_1)) {
                let match;
                if (closure_1 != null) {
                  match = str4.match(/\.png$/i);
                }
                if (null == match) {
                  c7 = 3;
                  return { value: false, done: true };
                }
              } else if (null == closure_0.match(/^(assets-library|file):\/\/.+(&ext=|\.)png$/i)) {
                c7 = 3;
                return { value: false, done: true };
              }
              c5 = 1;
              c6 = 2;
              c7 = 1;
              const obj5 = { value: obj4.imageHasTransparency(closure_0), done: false };
              obj4 = react_nativeDefault2;
              return obj5;
            } else {
              c7 = 3;
              return { value: false, done: true };
            }
          }
        } else if (1 === c6) {
          c5 = 0;
          closure_0 = closure_4;
          const _HermesInternal = HermesInternal;
          closure_131_19.error("shouldConvertToPNG: imageHasTransparency failed: " + closure_0);
          c7 = 3;
          return { value: false, done: true };
        } else if (arg0 === 1) {
          c7 = 3;
          throw value;
        } else if (arg0 === 2) {
          c5 = 0;
          c7 = 3;
          const obj6 = { value, done: true };
          return obj6;
        } else {
          c5 = 0;
          c7 = 3;
          obj = { value, done: true };
          return obj;
        }
      } catch (tmp14) {
        closure_4 = tmp14;
        if (0 === c5) {
          c7 = 3;
          throw tmp14;
        } else {
          c6 = 1;
        }
      }
    }
  });
  return obj(...arguments);
};
function isVideo(uri, overrideType) {
  obj = UploadUtils;
  const obj2 = { uri, overrideType };
  return obj.getFile(obj2).isVideo;
}
function isImage(uri, overrideType) {
  obj = UploadUtils;
  const obj2 = { uri, overrideType };
  return obj.getFile(obj2).isImage;
}
function getType(uri) {
  obj = UploadUtils;
  const obj2 = { uri };
  return obj.getFile(obj2).type;
}
function convertVideo(videoMetadata) {
  let compressionQuality;
  let isLowQuality;
  let result3;
  let videoQualitySetting;
  ({ uri: require, filename: importDefault, isLowQuality: dependencyMap, compressionQuality: closure_3, videoQualitySetting } = videoMetadata);
  videoMetadata = videoMetadata.videoMetadata;
  let c7;
  let tmp = require;
  const tmp2 = dependencyMap;
  const fileSize = videoMetadata.fileSize;
  const VideoQualityTarget = VideoUploadUtils.VideoQualityTarget;
  const result = VideoQualityTarget.fromCompressionQuality(videoQualitySetting);
  let tmp4 = VideoUploadUtils;
  const canSkipVideoTranscode = tmp4.canSkipVideoTranscode;
  let tmp5 = UploadLimits;
  const getEffectiveUploadLimit = tmp5.getEffectiveUploadLimit;
  obj = FileUtils;
  const result1 = canSkipVideoTranscode(result, videoMetadata, fileSize, getEffectiveUploadLimit(obj.maxFileSize()));
  let obj2 = VideoUploadUtils;
  const result2 = obj2.calculateTargetDimensions(videoMetadata, result.targetResolution);
  let obj3 = VideoUploadUtils;
  let obj6 = { videoQuality: result, targetBitrate: result3 };
  result3 = obj3.calculateOptimalBitrate(videoMetadata, result, VideoUploadUtils.DEFAULT_VIDEO_ENCODING_CONFIG.bitrateFloor);
  const merged = Object.assign(VideoUploadUtils.DEFAULT_VIDEO_ENCODING_CONFIG);
  ({ width: obj4.targetWidth, height: obj4.targetHeight } = result2);
  let obj5 = PlatformUtils;
  if (obj5.isAndroid()) {
    let frameRate;
    let num = 34;
    const tmpResult = DeviceUtils;
    if (tmpResult.getSystemVersionMajor() > 34) {
      let _Math = Math;
      frameRate = Math.min(videoMetadata.frameRate, VideoUploadUtils.DEFAULT_VIDEO_ENCODING_CONFIG.frameRate);
    }
    obj6.frameRate = frameRate;
    obj6.skipVideoTranscode = result1;
    ({ isHDRContent: obj4.createHDR, rotationDegrees: obj4.rotationDegrees } = videoMetadata);
    let num2 = 0;
    c7 = 0;
    let tmp11 = globalThis;
    let self = this;
    let self2 = this;
    let promise = new Promise((arg0, arg1) => {
      let attempts;
      let logger;
      function findCompatibleConfig() {
        return obj(...arguments);
      }
      let closure_0 = arg0;
      let closure_1 = arg1;
      obj = function _findCompatibleConfig() {
        obj = _asyncToGenerator(async (arg0, value) => {
          let _undefined;
          let iter7;
          if (c13 === 2) {
            c13 = 3;
            throw new TypeError("Generator functions may not be called on executing generators");
          } else {
            if (tmp3 === 3) {
              if (arg0 === 1) {
                throw value;
              } else if (arg0 === 2) {
                const obj2 = { value, done: true };
                return obj2;
              } else {
                return { value: "IconComponent", done: null };
              }
            } else {
              let c10;
              try {
                let _loop;
                let iter;
                let next;
                let c0;
                let tmp30;
                let iter6;
                c13 = 2;
                const tmp4 = c12;
                if (0 === c12) {
                  if (arg0 === 1) {
                    c13 = 3;
                    throw value;
                  } else if (arg0 === 2) {
                    c13 = 3;
                    const obj3 = { value, done: true };
                    return obj3;
                  } else {
                    let closure_8 = tmp;
                    _loop = function* _loop() {
                      let c3;
                      let closure_2;
                      let min2 = yield closure_3_42(config);
                      if (min2.isSupported) {
                        return { v: true };
                      }
                      if (null != min2) {
                        if (null != min2.capabilities) {
                          if (null != min2.failures) {
                            if (0 !== min2.failures.length) {
                              let c1 = false;
                              const failures = min2.failures;
                              if (null != failures.find((type) => "codec_not_found" === type.type)) {
                                logger.error("No supported video encoder found");
                                const _Error3 = Error;
                                const self5 = this;
                                const self6 = this;
                                const error = new Error("No supported video encoder found");
                                tmp2(error);
                                let c4 = 3;
                                const obj7 = { value: { v: false }, done: true };
                                return obj7;
                              } else {
                                const failures1 = min2.failures;
                                if (null != failures1.find((type) => "resolution" === type.type || "resolution_alignment" === type.type)) {
                                  if (null != min2.capabilities.resolution) {
                                    if (0 !== config.targetHeight) {
                                      if (0 !== config.targetWidth) {
                                        const maxWidth = min2.capabilities.resolution.maxWidth;
                                        const maxHeight = min2.capabilities.resolution.maxHeight;
                                        let closure_4 = config.targetWidth / config.targetHeight;
                                        const _Math6 = Math;
                                        let targetWidth = Math.min(config.targetWidth, maxWidth);
                                        const _Math7 = Math;
                                        let targetHeight = Math.min(config.targetHeight, maxHeight);
                                        if (targetWidth !== config.targetWidth) {
                                          const _Math = Math;
                                          targetHeight = Math.round(targetWidth / closure_4);
                                        }
                                        if (targetHeight !== config.targetHeight) {
                                          const _Math2 = Math;
                                          targetWidth = Math.round(targetHeight * closure_4);
                                        }
                                        const str = "Missing video encoder block size";
                                        iter6(_undefined[25])(null != min2.capabilities.blockSize, "Missing video encoder block size");
                                        const blockSize = min2.capabilities.blockSize;
                                        const widthAlignment = blockSize.widthAlignment;
                                        const heightAlignment = blockSize.heightAlignment;
                                        const _Math3 = Math;
                                        targetWidth = Math.floor(targetWidth / widthAlignment) * widthAlignment;
                                        const _Math4 = Math;
                                        targetHeight = Math.floor(targetHeight / heightAlignment) * heightAlignment;
                                        const tmp36 = targetWidth === config.targetWidth && targetHeight === config.targetHeight;
                                        if (!tmp36) {
                                          config.targetWidth = targetWidth;
                                          config.targetHeight = targetHeight;
                                          c1 = true;
                                        }
                                      }
                                    }
                                    const _Error2 = Error;
                                    const self3 = this;
                                    const self4 = this;
                                    const error1 = new Error("Invalid video dimensions: width or height is 0");
                                    tmp2(error1);
                                    c4 = 3;
                                    const obj8 = { value: { v: false }, done: true };
                                    return obj8;
                                  }
                                }
                                const failures2 = min2.failures;
                                let message = failures2.find((type) => "frameRate" === type.type);
                                let frameRate = min2.capabilities.frameRate;
                                if (null != message) {
                                  let min;
                                  if (frameRate != null) {
                                    min = frameRate.min;
                                  }
                                  if (null != min) {
                                    let max;
                                    if (frameRate != null) {
                                      max = frameRate.max;
                                    }
                                    if (null != max) {
                                      frameRate = config.frameRate;
                                      message = message.message;
                                      if (message.includes("not supported at resolution")) {
                                        const items = [60, 30, 29.97, 24, 15];
                                        const sorted = items.sort((arg0, arg1) => arg1 - arg0);
                                        const found = sorted.find((item) => item < targetHeight.frameRate && item >= min.min);
                                        min2 = found;
                                        if (found == null) {
                                          min2 = frameRate.min;
                                        }
                                        frameRate = min2;
                                      } else {
                                        const _Math5 = Math;
                                        frameRate = Math.min(config.frameRate, frameRate.max);
                                      }
                                      if (frameRate !== config.frameRate) {
                                        config.frameRate = frameRate;
                                        c1 = true;
                                      }
                                    }
                                  }
                                }
                                if (c1) {
                                  closure_7 = closure_7 + 1;
                                  c4 = 3;
                                  return { value: "IconComponent", done: null };
                                } else {
                                  obj = { currentFailures: min2.failures, config, capabilities: min2.capabilities, attempt: closure_7 + 1 };
                                  logger.error("No adjustments possible for current failures", obj);
                                  const _Error = Error;
                                  const self = this;
                                  const self2 = this;
                                  const error2 = new Error("No adjustments possible for current failures");
                                  tmp2(error2);
                                  c4 = 3;
                                  const obj9 = { value: { v: false }, done: true };
                                  return obj9;
                                }
                              }
                            }
                          }
                        }
                      }
                      const obj10 = { config, attempt: closure_7 + 1 };
                      logger.warn("Unable to determine device capabilities or adjust parameters", obj10);
                      return 0;
                    };
                    iter = iter7;
                    if (iter7 < 4) {
                      const _loopResult = _loop();
                      iter7 = _loopResult[isArray.iterator]();
                      iter = HermesBuiltin.ensureObject("iterator is not an object");
                      next = iter7.next;
                      c0 = undefined;
                    }
                    c13 = 3;
                    return { value: false, done: true };
                  }
                } else {
                  if (1 === tmp4) {
                    c10 = 1;
                    if (arg0 === 1) {
                      c13 = 3;
                      throw value;
                    } else {
                      c0 = value;
                      if (arg0 === 2) {
                        c0 = value;
                        c10 = 0;
                        const method = HermesBuiltin.getMethod("return");
                        if (method === undefined) {
                          c13 = 3;
                          const obj4 = { value, done: true };
                          return obj4;
                        } else {
                          const iter5 = method(c0);
                          HermesBuiltin.ensureObject("iterator.return() did not return an object");
                          iter = iter5.done;
                          if (iter) {
                            c13 = 3;
                            const obj5 = { value: iter5.value, done: true };
                            return obj5;
                          } else {
                            c12 = 1;
                            c13 = 1;
                            return iter5;
                          }
                        }
                      } else {
                        c10 = 0;
                        tmp30 = value;
                      }
                    }
                  } else {
                    let tmp14;
                    if (2 === tmp4) {
                      c10 = 0;
                      const str8 = "throw";
                      const tmp22 = closure_11;
                      iter = HermesBuiltin.getMethod("throw");
                      if (iter === undefined) {
                        iter = HermesBuiltin.getMethod("return");
                        if (iter !== undefined) {
                          HermesBuiltin.ensureObject("iterator.return() did not return an object");
                        }
                        throw new TypeError("yield* delegate must have a .throw() method");
                      } else {
                        const iter4 = iter(tmp22);
                        const str9 = "iterator.throw() did not return an object";
                        HermesBuiltin.ensureObject("iterator.throw() did not return an object");
                        iter = iter4.done;
                        if (iter) {
                          iter6 = iter4;
                        } else {
                          c12 = 1;
                          c13 = 1;
                          return iter4;
                        }
                      }
                    } else {
                      let c2;
                      if (3 === tmp4) {
                        c10 = 2;
                        if (arg0 === 1) {
                          c13 = 3;
                          throw value;
                        } else {
                          c2 = value;
                          if (arg0 === 2) {
                            c2 = value;
                            c10 = 0;
                            const str6 = "return";
                            const method1 = HermesBuiltin.getMethod("return");
                            if (method1 === undefined) {
                              c13 = 3;
                              obj6 = { value, done: true };
                              return obj6;
                            } else {
                              const iter3 = method1(c2);
                              const str7 = "iterator.return() did not return an object";
                              HermesBuiltin.ensureObject("iterator.return() did not return an object");
                              iter = iter3.done;
                              if (iter) {
                                c13 = 3;
                                obj = { value: iter3.value, done: true };
                                return obj;
                              } else {
                                c12 = 3;
                                c13 = 1;
                                return iter3;
                              }
                            }
                          } else {
                            c10 = 0;
                            tmp14 = value;
                          }
                        }
                      } else {
                        c10 = 0;
                        let str = "throw";
                        const tmp6 = closure_11;
                        iter = HermesBuiltin.getMethod("throw");
                        if (iter === undefined) {
                          const str3 = "return";
                          iter = HermesBuiltin.getMethod("return");
                          if (iter !== undefined) {
                            const str4 = "iterator.return() did not return an object";
                            HermesBuiltin.ensureObject("iterator.return() did not return an object");
                          }
                          const str5 = "yield* delegate must have a .throw() method";
                          throw new TypeError("yield* delegate must have a .throw() method");
                        } else {
                          const iter2 = iter(tmp6);
                          const str2 = "iterator.throw() did not return an object";
                          HermesBuiltin.ensureObject("iterator.throw() did not return an object");
                          iter = iter2.done;
                          if (iter) {
                            iter = iter2;
                          } else {
                            c12 = 3;
                            c13 = 1;
                            return iter2;
                          }
                        }
                      }
                      iter = iter.value;
                      if (0 !== iter) {
                        const tmp42 = iter;
                        if (tmp42) {
                          c13 = 3;
                          let obj7 = { value: iter.v, done: true };
                          return obj7;
                        } else {
                          iter = iter7;
                          if (iter7 < 4) {
                            const tmp60 = _loop();
                            const iter8 = tmp60[isArray.iterator]();
                            HermesBuiltin.ensureObject("iterator is not an object");
                            next = iter8.next;
                            c2 = undefined;
                          }
                        }
                      }
                    }
                    iter = next(tmp14);
                    HermesBuiltin.ensureObject("iterator.next() did not return an object");
                    if (!iter.done) {
                      c12 = 3;
                      c13 = 1;
                      return iter;
                    }
                  }
                  value = iter6.value;
                  iter = value;
                }
                iter6 = next(tmp30);
                HermesBuiltin.ensureObject("iterator.next() did not return an object");
                iter = iter6.done;
                if (!iter) {
                  c12 = 1;
                  c13 = 1;
                  return iter6;
                }
              } catch (tmp51) {
                closure_11 = tmp51;
                if (0 === c10) {
                  c13 = 3;
                  throw tmp51;
                } else if (1 === tmp53) {
                  c12 = 2;
                } else {
                  c12 = 4;
                }
              }
            }
          }
        });
        return obj(...arguments);
      };
      function resolveWithConfig(path) {
        obj = { path, encodingConfig: obj6 };
        return closure_0(obj);
      }
      const promise = findCompatibleConfig();
      let nextPromise = promise.then(function(result) {
        let endsWithResult1;
        let tmp11;
        const tmp = result;
        if (tmp) {
          let nextPromise;
          const obj2 = PlatformUtils;
          const isAndroidResult = obj2.isAndroid() && null != str3.match(/^content:\/\/.+$/i);
          if (isAndroidResult) {
            const obj3 = { encodingConfig: obj6, compressionQuality, isLowQuality: dependencyMap, videoQuality: videoQualitySetting, skipVideoTranscode: result1 };
            const promise4 = mediaManager(react_nativeDefault2.resolveToMediaFilePath, require, obj3);
            nextPromise = promise4.then(resolveWithConfig, closure_1);
          } else {
            const tmp12Result = PlatformUtils;
            let isIOSResult1 = tmp12Result.isIOS();
            if (isIOSResult1) {
              const tmp12Result7 = ImageConversionDecision;
              if (tmp12Result7.isPhotoKitAsset(require, importDefault)) {
                let match;
                if (importDefault != null) {
                  match = str4.match(/\.(mov|qt)$/i);
                }
                isVideo = null != match;
              } else {
                isVideo = null != str3.match(/^assets-library:\/\/.+&ext=(mov|qt)$/i);
                if (isVideo) {
                  const obj4 = { uri: require, overrideType: "r" };
                  const tmp12Result8 = UploadUtils;
                  isVideo = tmp12Result8.getFile(obj4).isVideo;
                }
              }
              isIOSResult1 = isVideo;
            }
            if (isIOSResult1) {
              const obj5 = { encodingConfig: obj6, videoQuality: videoQualitySetting, isMov: true, skipVideoTranscode: result1 };
              const promise3 = mediaManager(react_nativeDefault2.compressVideo, require, obj5);
              nextPromise = promise3.then(resolveWithConfig, closure_1);
            } else {
              const tmp12Result9 = PlatformUtils;
              let isIOSResult2 = tmp12Result9.isIOS();
              if (isIOSResult2) {
                let isVideo2;
                const tmp12Result10 = ImageConversionDecision;
                if (tmp12Result10.isPhotoKitAsset(require, importDefault)) {
                  let match1;
                  if (importDefault != null) {
                    match1 = str4.match(/\.mp4$/i);
                  }
                  isVideo2 = null != match1;
                } else {
                  isVideo2 = null != str3.match(/^assets-library:\/\/.+&ext=mp4$/i);
                  if (isVideo2) {
                    obj6 = { uri: require, overrideType: "r" };
                    const tmp12Result11 = UploadUtils;
                    isVideo2 = tmp12Result11.getFile(obj6).isVideo;
                  }
                }
                isIOSResult2 = isVideo2;
              }
              if (isIOSResult2) {
                const obj7 = { encodingConfig: obj6, videoQuality: videoQualitySetting, skipVideoTranscode: result1 };
                const promise2 = mediaManager(react_nativeDefault2.compressVideo, require, obj7);
                nextPromise = promise2.then(resolveWithConfig, closure_1);
              } else {
                const formatted = str3.toLowerCase();
                const tmp12Result12 = PlatformUtils;
                let isIOSResult = tmp12Result12.isIOS() && str3.startsWith("file");
                if (isIOSResult) {
                  isIOSResult = formatted.endsWith("mov") || formatted.endsWith("mp4") || formatted.endsWith("qt");
                  const endsWithResult = formatted.endsWith("mov") || formatted.endsWith("mp4") || formatted.endsWith("qt");
                }
                if (isIOSResult) {
                  const obj8 = { encodingConfig: obj6, videoQuality: videoQualitySetting, isMov: endsWithResult1, skipVideoTranscode: result1 };
                  const compressVideo = react_nativeDefault2.compressVideo;
                  const formatted1 = str3.toLowerCase();
                  endsWithResult1 = formatted1.endsWith("mov");
                  const tmp32 = mediaManager;
                  if (!endsWithResult1) {
                    const formatted2 = str3.toLowerCase();
                    endsWithResult1 = formatted2.endsWith("qt");
                  }
                  const tmp32Result = tmp32(compressVideo, require, obj8);
                  nextPromise = tmp32Result.then(resolveWithConfig, closure_1);
                } else {
                  const obj9 = { uri: require, filename: importDefault };
                  logger.error("Unsupported video URI format", obj9);
                  const _Error2 = Error;
                  const _HermesInternal = HermesInternal;
                  const self3 = this;
                  const self4 = this;
                  const error = new Error("Unsupported video URI format: " + str3);
                  closure_1(error);
                }
              }
            }
          }
          tmp11 = nextPromise;
        } else {
          obj = { finalConfig: obj6, attempts };
          logger.error("Could not find compatible encoding configuration after multiple attempts", obj);
          const _Error = Error;
          const self = this;
          const self2 = this;
          const error1 = new Error("Could not find compatible encoding configuration after multiple attempts");
          closure_1(error1);
        }
        return tmp11;
      });
      nextPromise.catch(arg1);
    });
    return promise;
  }
  frameRate = videoMetadata.frameRate;
}
function buildResolvedUpload(arg0) {
  return obj(...arguments);
}
obj = function _buildResolvedUpload() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let closure_0 = arg0;
    if (c3 === 2) {
      c3 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let filename;
        let closure_2;
        c3 = 2;
        if (0 === c2) {
          if (arg0 === 1) {
            c3 = 3;
            throw value;
          } else if (arg0 === 2) {
            c3 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            let closure_1 = tmp;
            const obj4 = { uri: null, i: null, overrideType: null, overrideFilename: null };
            ({ path: obj8.uri, i: obj8.i, mimeType: obj8.overrideType, filename: obj8.overrideFilename } = closure_0);
            const obj7 = UploadUtils;
            const file = obj7.getFile(obj4);
            filename = file.filename;
            closure_2 = _objectWithoutProperties(file, closure_2_3);
            closure_3 = {};
            isImage = closure_0.isImage && tmp32.path !== tmp32.originalUri;
            if (isImage) {
              c2 = 1;
              c3 = 1;
              const obj5 = { value: calculateImageQualityMetrics(closure_0.originalUri, closure_0.path, closure_0.filename, closure_0.attachmentQualityMetricsEnabled, closure_0.attachmentOriginDetectionEnabled), done: false };
              return obj5;
            }
          }
        } else if (arg0 === 1) {
          c3 = 3;
          throw value;
        } else if (arg0 === 2) {
          c3 = 3;
          obj = { value, done: true };
          return obj;
        } else {
          closure_3 = value;
        }
        const obj6 = { name: filename, spoiler: closure_0.spoiler, description: closure_0.description, imageCompressionQuality: closure_0.compressionQuality, imageEncoderType: closure_0.imageEncoderType, videoCompressionQuality: closure_0.videoQualitySetting, videoMetadata: closure_0.videoMetadata, encodingConfig: closure_0.encodingConfig, sourceWidth: closure_0.sourceImageDimensions.width, sourceHeight: closure_0.sourceImageDimensions.height, uploadedImageWidth: closure_0.uploadedImageWidth, uploadedImageHeight: closure_0.uploadedImageHeight, psnr: closure_3.psnr, ssim: closure_3.ssim, origin: closure_3.origin, psnrMeasurementLatencyMs: closure_3.psnrMeasurementLatencyMs, ssimMeasurementLatencyMs: closure_3.ssimMeasurementLatencyMs };
        const merged = Object.assign(closure_2);
        c3 = 3;
        const obj14 = { value: obj6, done: true };
        return obj14;
      } catch (tmp28) {
        c3 = 3;
        throw tmp28;
      }
    }
  });
  return obj(...arguments);
};
obj = function _processVideoUpload() {
  obj = _asyncToGenerator(async function(arg0, value) {
    let c0;
    let c1;
    let c2;
    let c3;
    let c4;
    let c5;
    let c6;
    let closure_6;
    let fileSize;
    let spoiler;
    function fetchVideoMetadata(c0, c2) {
      return closure_1_40(...arguments);
    }
    let closure_0 = arg0;
    if (spoiler === 2) {
      spoiler = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let originalUri;
        let filename;
        let mimeType;
        let description;
        let i;
        let videoQualitySetting;
        let dataSavingMode;
        let videoMetadata;
        let closure_10;
        let path;
        let encodingConfig;
        spoiler = 2;
        if (0 === fileSize) {
          if (arg0 === 1) {
            spoiler = 3;
            throw value;
          } else if (arg0 === 2) {
            spoiler = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            let closure_2 = tmp4;
            let closure_1 = tmp;
            originalUri = undefined;
            filename = undefined;
            mimeType = undefined;
            description = undefined;
            i = undefined;
            ({ originalUri: c0, filename: c1, mimeType: c2, fileSize: c3, spoiler: c4, description: c5, i: c6 } = closure_0);
            videoQualitySetting = undefined;
            dataSavingMode = undefined;
            videoMetadata = undefined;
            closure_10 = undefined;
            path = undefined;
            encodingConfig = undefined;
            fileSize = 1;
            spoiler = 1;
            return { value: "Set", done: true };
          }
        } else if (1 === fileSize) {
          if (arg0 === 1) {
            spoiler = 3;
            throw value;
          } else if (arg0 === 2) {
            spoiler = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            videoQualitySetting = closure_130_29();
            dataSavingMode = closure_130_9.dataSavingMode && closure_130_10.getType() === closure_130_14.CELLULAR;
            fileSize = 2;
            spoiler = 1;
            const obj5 = { value: fetchVideoMetadata(originalUri, mimeType), done: false };
            return obj5;
          }
        } else if (2 === fileSize) {
          if (arg0 === 1) {
            spoiler = 3;
            throw value;
          } else if (arg0 === 2) {
            spoiler = 3;
            const obj6 = { value, done: true };
            return obj6;
          } else {
            videoMetadata = value;
            if (null == videoMetadata) {
              const _Error3 = Error;
              const self5 = this;
              const self6 = this;
              const error = new Error("Video metadata is required for video conversion");
              throw error;
            } else {
              const obj11 = closure_130_0(closure_130_2[26]);
              if (obj11.getVideoFrameRateValidationExperimentConfig({ location: "upload_utils.process_video_upload" }).enableFrameRateValidation) {
                if (null != videoMetadata.frameRate) {
                  const _Number = Number;
                }
                const _Error2 = Error;
                const _HermesInternal = HermesInternal;
                const self3 = this;
                const self4 = this;
                const error1 = new Error("Invalid video frame rate: " + videoMetadata.frameRate);
                throw error1;
              }
              const obj7 = { uri: originalUri, filename, isLowQuality: dataSavingMode, compressionQuality: closure_130_15.LOW, videoQualitySetting, videoMetadata, fileSize };
              fileSize = 3;
              spoiler = 1;
              const obj8 = { value: closure_130_34(obj7), done: false };
              return obj8;
            }
          }
        } else if (arg0 === 1) {
          spoiler = 3;
          throw value;
        } else if (arg0 === 2) {
          spoiler = 3;
          const obj9 = { value, done: true };
          return obj9;
        } else {
          closure_10 = value;
          path = closure_10.path;
          encodingConfig = closure_10.encodingConfig;
          if (null == path) {
            const _Error = Error;
            const self = this;
            const self2 = this;
            const error2 = new Error("Failed to get video file path");
            throw error2;
          } else {
            const obj10 = { path, i, mimeType, filename, originalUri, spoiler, description, compressionQuality: closure_130_15.LOW, videoQualitySetting, videoMetadata, encodingConfig, sourceImageDimensions: {}, isImage: false };
            spoiler = 3;
            obj = { value: closure_130_35(obj10), done: true };
            return obj;
          }
        }
      } catch (tmp36) {
        spoiler = 3;
        throw tmp36;
      }
    }
  });
  return obj(...arguments);
};
obj = function _processImageOrFileUpload() {
  obj = _asyncToGenerator(async function(arg0, value) {
    let c0;
    let c1;
    let c2;
    let c3;
    let c4;
    let c5;
    let c6;
    let c7;
    let c8;
    let closure_5;
    let i;
    let tmp;
    let width;
    function tryConvertImage(arg0) {
      return closure_1_39(...arguments);
    }
    function resolveFileUri(c0, compressionQuality, dataSavingMode, c15, c8) {
      let flag = c8;
      if (c8 === undefined) {
        flag = true;
      }
      obj = closure_1_0(mimeType[13]);
      let isAndroidResult = obj.isAndroid();
      const tmp = mimeType;
      if (isAndroidResult) {
        isAndroidResult = null != c0.match(/^content:\/\/.+$/i);
      }
      if (isAndroidResult) {
        const obj2 = { compressionQuality, isLowQuality: dataSavingMode, skipVideoTranscode: true, useOriginalIfSmaller: c15, allowOptimization: flag };
        return closure_1_27(filename(tmp[16]).resolveToMediaFilePath, c0, obj2);
      } else {
        return Promise.resolve(c0);
      }
    }
    let closure_0 = arg0;
    if (width === 2) {
      width = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        let obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      try {
        let originalUri;
        let filename;
        let mimeType;
        let spoiler;
        let description;
        let height;
        let allowOptimization;
        let targetWidth;
        let targetHeight;
        let dataSavingMode;
        let obj5;
        let compressionQuality;
        let useOriginalIfSmaller;
        let useEnhancedConversion;
        let enabled;
        let enableQualityMetrics;
        let enableOriginDetection;
        let config;
        let useJpegliEncoder;
        let closure_23;
        let path;
        let encoderUsed;
        let closure_26;
        width = 2;
        const tmp4 = i;
        if (0 === i) {
          if (arg0 === 1) {
            width = 3;
            throw value;
          } else if (arg0 === 2) {
            width = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            let closure_4 = tmp4;
            closure_3 = tmp;
            originalUri = undefined;
            filename = undefined;
            mimeType = undefined;
            spoiler = undefined;
            description = undefined;
            height = undefined;
            allowOptimization = undefined;
            ({ originalUri: c0, filename: c1, mimeType: c2, spoiler: c3, description: c4, i: c5, width: c6, height: c7, allowOptimization: c8 } = closure_0);
            targetWidth = undefined;
            targetHeight = undefined;
            dataSavingMode = undefined;
            isImage = undefined;
            obj5 = undefined;
            compressionQuality = undefined;
            useOriginalIfSmaller = undefined;
            useEnhancedConversion = undefined;
            enabled = undefined;
            enableQualityMetrics = undefined;
            enableOriginDetection = undefined;
            config = undefined;
            useJpegliEncoder = undefined;
            closure_23 = undefined;
            path = undefined;
            encoderUsed = undefined;
            closure_26 = undefined;
            i = 1;
            width = 1;
            return { value: "Set", done: true };
          }
        } else if (1 === tmp4) {
          if (arg0 === 1) {
            width = 3;
            throw value;
          } else if (arg0 === 2) {
            width = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            dataSavingMode = closure_132_9.dataSavingMode && closure_132_10.getType() === closure_132_14.CELLULAR;
            isImage = closure_132_33(originalUri, mimeType);
            const tmp41 = isImage;
            if (tmp41) {
              size = { width, height };
              obj5 = size;
            } else {
              obj5 = {};
            }
            compressionQuality = closure_132_15.LOW;
            let flag = false;
            useOriginalIfSmaller = false;
            const tmp48 = isImage && !dataSavingMode;
            if (tmp48) {
              useOriginalIfSmaller = closure_132_0(closure_132_2[27]).ADAPTIVE_COMPRESSION_CONFIG.useOriginalIfSmaller;
              const obj7 = closure_132_0(closure_132_2[27]);
              compressionQuality = obj7.getAdaptiveImageCompressionQuality(obj5, closure_132_0(closure_132_2[27]).ADAPTIVE_COMPRESSION_CONFIG);
              const _HermesInternal = HermesInternal;
              closure_132_19.log("Got image compression quality: " + compressionQuality + " for " + originalUri + " with dimensions: " + width + "x" + height + " and useOriginalIfSmaller: " + useOriginalIfSmaller);
            }
            const obj8 = closure_132_0(closure_132_2[13]);
            const isIOSResult = obj8.isIOS() && originalUri.startsWith("ph://");
            useEnhancedConversion = isIOSResult;
            enabled = false;
            if (isImage) {
              const obj9 = closure_132_0(closure_132_2[28]);
              enabled = obj9.useMobileLosslessImageUploadV2Experiment({ location: "upload_utils.process_image_upload" });
              const obj10 = closure_132_0(closure_132_2[29]);
              enabled = obj10.isDiscordFrontendDevelopment() || enabled.enabled;
            }
            enableQualityMetrics = false;
            enableOriginDetection = false;
            const tmp86 = isImage;
            if (tmp86) {
              const AttachmentQualityMetricsExperiment = closure_132_0(closure_132_2[30]).AttachmentQualityMetricsExperiment;
              config = AttachmentQualityMetricsExperiment.getConfig({ location: "upload_utils.process_image_upload" });
              enableQualityMetrics = config.enableQualityMetrics;
              enableOriginDetection = config.enableOriginDetection;
            }
            useJpegliEncoder = false;
            const obj11 = closure_132_0(closure_132_2[13]);
            if (obj11.isIOS()) {
              const tmp97 = isImage;
              if (tmp97) {
                const obj12 = closure_132_0(closure_132_2[29]);
                if (obj12.isDiscordFrontendDevelopment()) {
                  useJpegliEncoder = true;
                } else {
                  const obj13 = closure_132_0(closure_132_2[31]);
                  useJpegliEncoder = obj13.getIosJpegliConfig({ location: "upload_utils.process_image_upload" }).useJpegliEncoder;
                }
                const tmp106 = dataSavingMode;
                if (!tmp106) {
                  if (null != obj5.width) {
                    if (null != obj5.height) {
                      const obj21 = closure_132_0(closure_132_2[32]);
                      if (obj21.getMobileImageEncodingLadderConfig({ location: "upload_utils.process_image_upload" }).useImageEncodingLadder) {
                        const ImageEncodingLadder = closure_132_0(closure_132_2[27]).ImageEncodingLadder;
                        const size1 = { width: obj5.width, height: obj5.height };
                        closure_23 = ImageEncodingLadder.selectEncodingConfig(size1);
                        useOriginalIfSmaller = true;
                        compressionQuality = closure_23.compressionQuality / 100;
                        targetWidth = closure_23.targetWidth;
                        targetHeight = closure_23.targetHeight;
                      }
                    }
                  }
                }
              }
            }
            const obj6 = { uri: originalUri, filename, isLowQuality: dataSavingMode, compressionQuality, mobileLosslessImageEnabled: enabled, useEnhancedConversion, useJpegliEncoder, allowOptimization, targetWidth, targetHeight };
            i = 2;
            width = 1;
            const obj14 = { value: tryConvertImage(obj6), done: false };
            return obj14;
          }
        } else {
          if (2 === tmp4) {
            if (arg0 === 1) {
              width = 3;
              throw value;
            } else if (arg0 === 2) {
              width = 3;
              const obj15 = { value, done: true };
              return obj15;
            } else {
              closure_26 = value;
              if (null != closure_26) {
                path = closure_26.path;
                encoderUsed = closure_26.encoderUsed;
              } else {
                i = 3;
                width = 1;
                const obj16 = { value: resolveFileUri(originalUri, compressionQuality, dataSavingMode, useOriginalIfSmaller, allowOptimization), done: false };
                return obj16;
              }
            }
          } else if (arg0 === 1) {
            width = 3;
            throw value;
          } else if (arg0 === 2) {
            width = 3;
            obj = { value, done: true };
            return obj;
          } else {
            path = value;
          }
          if (null == path) {
            const _Error = Error;
            const self = this;
            const self2 = this;
            const error = new Error("Failed to get image file path");
            throw error;
          } else {
            const obj17 = { path, i, mimeType, filename, originalUri, spoiler, description, compressionQuality, sourceImageDimensions: obj5, isImage, imageEncoderType: encoderUsed, uploadedImageWidth: width, uploadedImageHeight: height, attachmentQualityMetricsEnabled: enableQualityMetrics, attachmentOriginDetectionEnabled: enableOriginDetection };
            let outputWidth;
            const tmp138 = closure_132_35;
            if (closure_26 != null) {
              outputWidth = closure_26.outputWidth;
            }
            width = outputWidth;
            if (outputWidth == null) {
              width = obj5.width;
            }
            let outputHeight;
            if (closure_26 != null) {
              outputHeight = closure_26.outputHeight;
            }
            height = outputHeight;
            if (outputHeight == null) {
              height = obj5.height;
            }
            width = 3;
            const obj18 = { value: tmp138(obj17), done: true };
            return obj18;
          }
        }
      } catch (tmp129) {
        width = 3;
        throw tmp129;
      }
    }
  });
  return obj(...arguments);
};
obj = function _tryConvertImage() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let obj17;
    let obj6;
    let tmp;
    let useJpegliEncoder;
    function getPhotoKitDataUTI() {
      return closure_1_30(...arguments);
    }
    function shouldConvertBase64ToJPG(c0) {
      obj = closure_1_0(closure_1_2[13]);
      const isIOSResult = obj.isIOS() && null != c0.match(closure_1_20);
      return isIOSResult;
    }
    function shouldConvertBase64ToGIF(c0) {
      obj = closure_1_0(closure_1_2[13]);
      const isIOSResult = obj.isIOS() && null != c0.match(closure_1_21);
      return isIOSResult;
    }
    function shouldConvertToPNG() {
      return closure_1_31(...arguments);
    }
    function shouldConvertToGifFilepath(c0, c1) {
      obj = closure_1_0(closure_1_2[13]);
      let isIOSResult = obj.isIOS();
      const tmp = closure_1_0;
      const tmp2 = closure_1_2;
      if (isIOSResult) {
        let tmp7;
        const tmpResult = tmp(tmp2[20]);
        if (tmpResult.isPhotoKitAsset(c0, c1)) {
          let match;
          if (c1 != null) {
            match = c1.match(/\.gif$/i);
          }
          tmp7 = null != match;
        } else {
          tmp7 = null != c0.match(/^assets-library:\/\/.+&ext=gif$/i);
        }
        isIOSResult = tmp7;
      }
      return isIOSResult;
    }
    let closure_0 = arg0;
    if (c7 === 2) {
      c7 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      let c4;
      try {
        let c0;
        let c1;
        let c2;
        let compressionQuality;
        let useEnhancedConversion;
        let targetWidth;
        let targetHeight;
        let closure_10;
        let path2;
        let forceConvertToJPG;
        let closure_14;
        let path;
        let encoderUsed;
        let outputWidth;
        let outputHeight;
        let path3;
        c7 = 2;
        switch (useJpegliEncoder) {
          case 0:
          {
            let c3;
            let c5;
            let c6;
            let c7;
            let c8;
            let c9;
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj3 = { value, done: true };
              return obj3;
            } else {
              closure_3 = tmp;
              let closure_2 = tmp4;
              c0 = undefined;
              c1 = undefined;
              c2 = undefined;
              compressionQuality = undefined;
              c4 = undefined;
              useEnhancedConversion = undefined;
              targetWidth = undefined;
              targetHeight = undefined;
              ({ uri: c0, filename: c1, isLowQuality: c2, compressionQuality: c3, mobileLosslessImageEnabled: c4, useEnhancedConversion: c5, useJpegliEncoder: c6, allowOptimization: c7, targetWidth: c8, targetHeight: c9 } = closure_0);
              closure_10 = undefined;
              path2 = undefined;
              forceConvertToJPG = undefined;
              closure_14 = undefined;
              path = undefined;
              encoderUsed = undefined;
              outputWidth = undefined;
              outputHeight = undefined;
              path3 = undefined;
              useJpegliEncoder = 1;
              c7 = 1;
              return { value: "Set", done: true };
            }
            break;
          }
          case 1:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj4 = { value, done: true };
              return obj4;
            } else {
              useJpegliEncoder = 2;
              c7 = 1;
              const obj5 = { value: getPhotoKitDataUTI(c0), done: false };
              return obj5;
            }
            break;
          }
          case 2:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj7 = { value, done: true };
              return obj7;
            } else {
              closure_10 = value;
              if (shouldConvertBase64ToJPG(c0)) {
                const obj8 = { compressionQuality };
                useJpegliEncoder = 3;
                c7 = 1;
                const obj9 = { value: closure_131_27(closure_131_1(closure_131_2[16]).convertBase64ToJPEG, c0.replace(closure_131_20, ""), obj8), done: false };
                return obj9;
              } else if (shouldConvertBase64ToGIF(c0)) {
                useJpegliEncoder = 4;
                c7 = 1;
                const obj10 = { value: closure_131_27(closure_131_1(closure_131_2[16]).convertBase64ToGIF, c0.replace(closure_131_21, ""), null), done: false };
                return obj10;
              } else {
                const tmp62 = c4;
                if (tmp62) {
                  useJpegliEncoder = 6;
                  c7 = 1;
                  const obj11 = { value: shouldConvertToPNG(c0, c1), done: false };
                  return obj11;
                } else {
                  const obj15 = closure_131_0(closure_131_2[20]);
                  forceConvertToJPG = obj15.shouldForceConvertToJPG(c0, c1, closure_10);
                  const tmp70 = forceConvertToJPG;
                  if (!tmp70) {
                    const obj16 = closure_131_0(closure_131_2[20]);
                    if (!obj16.shouldConvertToJPG(c0, c1, c2, c4, c7)) {
                      if (shouldConvertToGifFilepath(c0, c1)) {
                        c4 = 2;
                        useJpegliEncoder = 10;
                        c7 = 1;
                        const obj12 = { value: obj17.convertToGIFFilePath(c0), done: false };
                        obj17 = closure_131_1(closure_131_2[16]);
                        return obj12;
                      } else {
                        c7 = 3;
                        return { value: null, done: true };
                      }
                    }
                  }
                  const obj13 = { compressionQuality, forceConvertToJPG, useEnhancedConversion, useJpegliEncoder, targetWidth, targetHeight };
                  useJpegliEncoder = 8;
                  c7 = 1;
                  const obj14 = { value: closure_131_27(closure_131_1(closure_131_2[16]).convertToJPEG, c0, obj13), done: false };
                  return obj14;
                }
              }
            }
            break;
          }
          case 3:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj18 = { value, done: true };
              return obj18;
            } else {
              path = value;
              let tmp54 = null;
              if (null != path) {
                tmp54 = null;
                if (path.length > 0) {
                  const obj19 = { path, encoderUsed: closure_131_0(closure_131_2[33]).ImageEncoder.NATIVE };
                  tmp54 = obj19;
                }
              }
              c7 = 3;
              const obj20 = { value: tmp54, done: true };
              return obj20;
            }
            break;
          }
          case 4:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj21 = { value, done: true };
              return obj21;
            } else {
              path2 = value;
              let tmp47 = null;
              if (null != path2) {
                tmp47 = null;
                if (path2.length > 0) {
                  const obj22 = { path: path2 };
                  tmp47 = obj22;
                }
              }
              c7 = 3;
              const obj23 = { value: tmp47, done: true };
              return obj23;
            }
            break;
          }
          case 5:
          {
            c4 = 0;
            let closure_20 = closure_5;
            const _HermesInternal = HermesInternal;
            closure_131_19.error("getLosslessImageData failed, falling through to JPEG conversion: " + closure_20);
            break;
          }
          case 6:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj24 = { value, done: true };
              return obj24;
            } else if (value) {
              c4 = 1;
              value = {};
              useJpegliEncoder = 7;
              c7 = 1;
              const obj25 = { value: obj6.getLosslessImageData(c0), done: false };
              obj6 = closure_131_1(closure_131_2[16]);
              return obj25;
            }
            break;
          }
          case 7:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c4 = 0;
              c7 = 3;
              const obj26 = { value, done: true };
              return obj26;
            } else {
              value.path = value;
              value.encoderUsed = closure_131_0(closure_131_2[33]).ImageEncoder.PASSTHROUGH;
              c4 = 0;
              c7 = 3;
              const obj27 = { value, done: true };
              return obj27;
            }
            break;
          }
          case 8:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 3;
              const obj28 = { value, done: true };
              return obj28;
            } else {
              closure_14 = value;
              if (typeof closure_14 === "string") {
                path = closure_14;
              } else if (closure_14 != null) {
                path = closure_14.path;
              }
              encoderUsed = undefined;
              if (closure_14 != null) {
                encoderUsed = closure_14.encoderUsed;
              }
              outputWidth = undefined;
              if (closure_14 != null) {
                outputWidth = closure_14.outputWidth;
              }
              outputHeight = undefined;
              if (closure_14 != null) {
                outputHeight = closure_14.outputHeight;
              }
              let tmp20 = null;
              if (null != path) {
                tmp20 = null;
                if (path.length > 0) {
                  obj = { path, encoderUsed, outputWidth, outputHeight };
                  tmp20 = obj;
                }
              }
              c7 = 3;
              const obj29 = { value: tmp20, done: true };
              return obj29;
            }
            break;
          }
          case 9:
          {
            let tmp7 = closure_5;
            c4 = 0;
            let closure_21 = closure_5;
            closure_131_19.warn(closure_21);
            break;
          }
          default:
          {
            if (arg0 === 1) {
              c7 = 3;
              throw value;
            } else if (arg0 === 2) {
              c4 = 0;
              c7 = 3;
              const obj30 = { value, done: true };
              return obj30;
            } else {
              path3 = value;
              let tmp120 = null;
              if (null != path3) {
                tmp120 = null;
                if (path3.length > 0) {
                  const obj31 = { path: path3 };
                  tmp120 = obj31;
                }
              }
              c4 = 0;
              c7 = 3;
              const obj32 = { value: tmp120, done: true };
              return obj32;
            }
            break;
          }
        }
      } catch (tmp125) {
        closure_5 = tmp125;
        if (0 === c4) {
          c7 = 3;
          throw tmp125;
        } else if (1 === tmp127) {
          useJpegliEncoder = 5;
        } else {
          useJpegliEncoder = 9;
        }
      }
    }
  });
  return obj(...arguments);
};
obj = function _fetchVideoMetadata() {
  obj = _asyncToGenerator(async (uri, value) => {
    let c2;
    let c7 = 0;
    let c8 = 0;
    let c6 = 0;
    return (async (arg0, value) => {
      if (c8 === 2) {
        c8 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          c8 = 2;
          if (0 === c7) {
            if (arg0 === 1) {
              c8 = 3;
              throw value;
            } else if (arg0 === 2) {
              c8 = 3;
              return { value, done: true };
            } else {
              closure_4 = tmp;
              closure_3 = tmp4;
              value = undefined;
              const tmp28 = uri;
              if (isVideo(uri, value)) {
                c6 = 1;
                c7 = 2;
                c8 = 1;
                const obj4 = { value: mediaManager(react_nativeDefault2.getVideoMetadata, tmp28, null), done: false };
                return obj4;
              }
            }
          } else if (1 === c7) {
            c6 = 0;
            const error = closure_5;
            const obj5 = { uri, error };
            closure_132_19.warn("Failed to fetch video metadata", obj5);
          } else if (arg0 === 1) {
            c8 = 3;
            throw value;
          } else if (arg0 === 2) {
            c6 = 0;
            c8 = 3;
            return { value, done: true };
          } else {
            let rotationDegrees = value.rotationDegrees;
            const tmp6 = value;
            if (rotationDegrees == null) {
              rotationDegrees = 0;
            }
            tmp6.rotationDegrees = rotationDegrees;
            c6 = 0;
            c8 = 3;
            return { value, done: true };
          }
          c8 = 3;
          return { value: "IconComponent", done: null };
        } catch (tmp21) {
          closure_5 = tmp21;
          if (0 === c6) {
            c8 = 3;
            throw tmp21;
          } else {
            c7 = 1;
          }
        }
      }
    })();
  });
  return obj(...arguments);
};
function getCaptionLabel(type, isVideo, playableDuration) {
  let str2;
  const tmp = isVideo;
  if (tmp) {
    let str3 = "VIDEO";
    if (null != playableDuration.playableDuration) {
      obj = utils_TimeUtils;
      str3 = obj.getTimeFormat(playableDuration.playableDuration);
    }
    str2 = str3;
  } else {
    str2 = null;
    if ("image/gif" === type) {
      str2 = "GIF";
    }
  }
  return str2;
}
function getImageDimensionsIfMissing(c0, c1, c2, c12) {
  return obj(...arguments);
}
obj = function _getImageDimensionsIfMissing() {
  obj = _asyncToGenerator(async (uri, width, height, value) => {
    let closure_6;
    let c8 = 0;
    let c9 = 0;
    let c7 = 0;
    return (async (arg0, value, arg2, arg3) => {
      let obj3;
      function getImageDimensionByUri(arg0) {
        let closure_0 = arg0;
        const promise = new Promise((arg0, arg1) => {
          closure_0 = arg0;
          return size.getSize(closure_0, (width, height) => {
            size = { width, height };
            return closure_0(size);
          }, arg1);
        });
        return promise;
      }
      if (c9 === 2) {
        c9 = 3;
        throw new TypeError("Generator functions may not be called on executing generators");
      } else if (tmp3 === 3) {
        if (arg0 === 1) {
          throw value;
        } else if (arg0 === 2) {
          return { value, done: true };
        } else {
          return { value: "IconComponent", done: null };
        }
      } else {
        try {
          let file;
          c9 = 2;
          if (0 === c8) {
            if (arg0 === 1) {
              c9 = 3;
              throw value;
            } else if (arg0 === 2) {
              c9 = 3;
              return { value, done: true };
            } else {
              closure_5 = tmp;
              file = undefined;
              value = undefined;
              size = { width, height };
              const tmp43 = value;
              if (null != width) {
                if (null != height) {
                  c9 = 3;
                  return { value: size, done: true };
                }
              }
              const obj6 = { uri, overrideFilename: tmp43 };
              const obj7 = UploadUtils;
              file = obj7.getFile(obj6);
              isImage = file.isImage;
              if (!isImage) {
                if (!file.isVideo) {
                  c9 = 3;
                  return { value: size, done: true };
                }
              }
              c7 = 1;
              c8 = 2;
              c9 = 1;
              const obj9 = { value: getImageDimensionByUri(uri), done: false };
              return obj9;
            }
          } else if (1 === c8) {
            c7 = 0;
            let closure_4 = size;
            const _HermesInternal = HermesInternal;
            closure_133_19.warn("Unable to get width and height of media file: " + uri, closure_4);
            c9 = 3;
            return { value: size, done: true };
          } else {
            if (2 === c8) {
              if (arg0 === 1) {
                c9 = 3;
                throw value;
              } else if (arg0 === 2) {
                c7 = 0;
                c9 = 3;
                return { value, done: true };
              } else {
                const obj14 = closure_133_0(closure_133_2[13]);
                isVideo = obj14.isIOS() && file.isVideo && 0 === value.width && 0 === value.height;
                if (isVideo) {
                  c8 = 3;
                  c9 = 1;
                  const obj12 = { value: obj3.getVideoDimensions(uri), done: false };
                  obj3 = closure_133_1(closure_133_2[19]);
                  return obj12;
                }
              }
            } else if (arg0 === 1) {
              c9 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 0;
              c9 = 3;
              return { value, done: true };
            }
            c7 = 0;
            c9 = 3;
            return { value, done: true };
          }
        } catch (tmp29) {
          size = tmp29;
          if (0 === c7) {
            c9 = 3;
            throw tmp29;
          } else {
            c8 = 1;
          }
        }
      }
    })();
  });
  return obj(...arguments);
};
function checkVideoEncodingSupport(arg0) {
  return obj(...arguments);
}
obj = function _checkVideoEncodingSupport() {
  obj = _asyncToGenerator(async (arg0, value) => {
    let obj4;
    let closure_0 = arg0;
    if (c6 === 2) {
      c6 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      let c4;
      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 {
            let closure_2 = tmp;
            let closure_1 = tmp4;
            c4 = 1;
            size = { width: null, height: null, frameRate: null };
            ({ targetWidth: obj5.width, targetHeight: obj5.height, frameRate: obj5.frameRate } = closure_0);
            c5 = 2;
            c6 = 1;
            const obj6 = { value: obj4.isVideoEncodingSupported(size), done: false };
            obj4 = react_nativeDefault2;
            return obj6;
          }
        } else if (1 === c5) {
          c4 = 0;
          closure_0 = closure_3;
          closure_130_19.warn("Error checking video encoding support:", closure_0);
          c6 = 3;
          const obj7 = { value: { isSupported: true }, done: true };
          return obj7;
        } else if (arg0 === 1) {
          c6 = 3;
          throw value;
        } else if (arg0 === 2) {
          c4 = 0;
          c6 = 3;
          const obj8 = { value, done: true };
          return obj8;
        } else {
          c4 = 0;
          c6 = 3;
          obj = { value, done: true };
          return obj;
        }
      } catch (tmp15) {
        closure_3 = tmp15;
        if (0 === c4) {
          c6 = 3;
          throw tmp15;
        } else {
          c5 = 1;
        }
      }
    }
  });
  return obj(...arguments);
};
function calculateImageQualityMetrics(arg0, combined, arg2, arg3, arg4) {
  return obj(...arguments);
}
obj = function _calculateImageQualityMetrics() {
  obj = _asyncToGenerator(async (arg0, value, arg2, arg3, arg4) => {
    let closure_6;
    let obj5;
    let closure_0 = arg0;
    let closure_1 = value;
    let closure_2 = arg3;
    closure_3 = arg4;
    if (c9 === 2) {
      c9 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp3 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "IconComponent", done: null };
      }
    } else {
      let tmp46;
      let c7;
      try {
        let combined;
        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 {
            let closure_5 = tmp;
            calculateImageQualityMetrics = undefined;
            combined = undefined;
            tmp46 = undefined;
            closure_3 = {};
            if (closure_3) {
              c7 = 1;
              c8 = 2;
              c9 = 1;
              const obj4 = { value: obj5.getMediaOrigin(tmp67), done: false };
              obj5 = react_nativeDefault2;
              return obj4;
            }
          }
        } else {
          if (1 === c8) {
            c7 = 0;
            let closure_7 = tmp46;
            closure_133_19.warn("Failed to detect media origin", closure_7);
          } else if (2 === c8) {
            if (arg0 === 1) {
              c9 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 0;
              c9 = 3;
              const obj6 = { value, done: true };
              return obj6;
            } else {
              calculateImageQualityMetrics = value;
              closure_3.origin = calculateImageQualityMetrics.source;
              c7 = 0;
            }
          } else if (3 === c8) {
            c7 = 0;
            let closure_8 = tmp46;
            closure_133_19.warn("Error in quality metrics calculation", closure_8);
          } else if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 0;
            c9 = 3;
            obj = { value, done: true };
            return obj;
          } else {
            tmp46 = value;
            closure_3.psnr = tmp46.psnr;
            closure_3.ssim = tmp46.ssim;
            closure_3.psnrMeasurementLatencyMs = tmp46.psnrCalculationTimeMs;
            closure_3.ssimMeasurementLatencyMs = tmp46.ssimCalculationTimeMs;
            const _HermesInternal3 = HermesInternal;
            closure_133_19.log("Quality metrics calculated: PSNR=" + tmp46.psnr + "dB, SSIM=" + tmp46.ssim);
            c7 = 0;
          }
          calculateImageQualityMetrics = closure_3;
          c9 = 3;
          const obj7 = { value: calculateImageQualityMetrics, done: true };
          return obj7;
        }
        const tmp23 = closure_2;
        if (tmp23) {
          c7 = 2;
          combined = closure_1;
          if (!closure_1.includes("://")) {
            if (!closure_1.includes("/")) {
              if (!closure_1.includes("\\")) {
                calculateImageQualityMetrics = closure_1;
                const _HermesInternal = HermesInternal;
                if (closure_0.startsWith("ph://")) {
                  combined = concat(calculateImageQualityMetrics);
                } else {
                  combined = concat(calculateImageQualityMetrics);
                }
              }
            }
            calculateImageQualityMetrics = closure_1;
            const _HermesInternal2 = HermesInternal;
            combined = "file://" + closure_1;
          }
          calculateImageQualityMetrics = closure_133_1(closure_133_2[16]).calculateImageQualityMetrics;
          c8 = 4;
          c9 = 1;
          const obj8 = { value: calculateImageQualityMetrics(closure_0, combined), done: false };
          const tmp41 = closure_133_1(closure_133_2[16]);
          return obj8;
        }
      } catch (tmp46) {
        if (0 === c7) {
          c9 = 3;
          throw tmp46;
        } else if (1 === tmp48) {
          c8 = 1;
        } else {
          c8 = 3;
        }
      }
    }
  });
  return obj(...arguments);
};
let closure_3 = ["filename"];
const Image = react_native.Image;
let UnsyncedUserSettingsStore = UnsyncedUserSettingsStore_mod;
({ VideoCompressionQuality: metroImportDefault, VideoQualitySettings: metroImportAll } = UnsyncedUserSettingsStore);
UnsyncedUserSettingsStore = UnsyncedUserSettingsStore_mod;
({ Base64PNGPrefix: closure_12, Base64GIFPrefix } = Constants);
({ NetworkConnectionTypes: closure_14, CompressionQuality: closure_15, Base64WEBPPrefix: closure_16, Base64AVIFPrefix: closure_17, Base64JPEGPrefix } = Constants);
const NativePermissionTypes = NativePermissionConstants.NativePermissionTypes;
let tmp4 = new LoggerDefault("UploadUtils.tsx");
let closure_19 = tmp4;
const regExp = new RegExp("^" + Base64JPEGPrefix, "i");
const regExp1 = new RegExp("^" + Base64GIFPrefix, "i");
const Cancelled = "Cancelled";
let c23 = "Missing permission";
let size = size_mod;
let result = size.fileFinishedImporting("utils/native/UploadUtils.tsx");

export default { getFileInfo, isVideo, getType, openImagePickerUnhandled, openImagePicker, getCaptionLabel, getImageDimensionsIfMissing, getAppDir };
export const base64JPEGRegex = regExp;
export const base64GIFRegex = regExp1;
export { openImagePicker };
export { mediaManager };
export const getImageCompressionQuality = function getImageCompressionQuality() {
  if (UnsyncedUserSettingsStore.dataSavingMode) {
    let HIGH;
    if (NetworkStore.getType() === constants3.CELLULAR) {
      HIGH = constants4.LOW;
    }
    return HIGH;
  }
  HIGH = constants4.HIGH;
};
export { getVideoQuality };
export const resolveModeToVideoQualityForUserWithFeature = function resolveModeToVideoQualityForUserWithFeature(arg0) {
  if (metroImportAll.DATA_SAVER === arg0) {
    return metroImportDefault.LOW;
  } else if (metroImportAll.STANDARD === arg0) {
    return metroImportDefault.HIGH;
  } else if (metroImportAll.BEST === arg0) {
    return metroImportDefault.VERY_HIGH;
  } else {
    return metroImportDefault.MEDIUM;
  }
};
export const resolveModeToVideoQualityForFreeUser = function resolveModeToVideoQualityForFreeUser(arg0) {
  if (metroImportAll.DATA_SAVER === arg0) {
    return metroImportDefault.LOW;
  } else if (metroImportAll.STANDARD === arg0) {
    return metroImportDefault.MEDIUM;
  } else if (metroImportAll.BEST === arg0) {
    return metroImportDefault.HIGH;
  } else {
    return metroImportDefault.LOW;
  }
};
export const cancelGetFileInfo = function cancelGetFileInfo(item) {
  item = item.item;
  let promise = new Promise((fn, arg1) => {
    obj = PlatformUtils;
    if (obj.isAndroid()) {
      const tmp3 = item;
      if (item.platform === UploadPlatform.UploadPlatform.REACT_NATIVE) {
        const promise = mediaManager(react_nativeDefault2.cancelResolveToMediaFilePath, tmp3.uri, null);
        promise.then(fn, arg1);
      }
    }
    fn();
  });
  return promise;
};
export const getFileSize = function getFileSize(uri) {
  let replaced = uri;
  obj = PlatformUtils;
  if (obj.isIOS()) {
    replaced = uri.replace(/file:\/\//, "");
  }
  const obj2 = react_nativeDefault;
  return obj2.getSize(replaced);
};
export { getAppDir };
export { getFileInfo };
export const shouldConvertToJPG = ImageConversionDecision.shouldConvertToJPG;
export const shouldForceConvertToJPG = ImageConversionDecision.shouldForceConvertToJPG;
export const shouldResolveToMediaFilePath = function shouldResolveToMediaFilePath(str) {
  obj = PlatformUtils;
  const isAndroidResult = obj.isAndroid() && null != str.match(/^content:\/\/.+$/i);
  return isAndroidResult;
};
export { isVideo };
export { isImage };
export { getType };
export { getCaptionLabel };
export { getImageDimensionsIfMissing };
export { checkVideoEncodingSupport };
export { calculateImageQualityMetrics };
export const getFileFromUploadItem = function getFileFromUploadItem(result1) {
  obj = UploadUtils;
  const obj2 = { uri: result1.uri, overrideFilename: result1.filename, overrideType: result1.mimeType };
  return obj.getFile(obj2);
};