// Module ID: 5636
// Function ID: 5637
// Name: utils/UploadUtils
// Dependencies: [109, 5, 17, 1184, 4894, 1372, 1074, 5054, 3, 5637, 5648, 5627, 5654, 1364, 4556, 1115, 1427, 4517, 5626, 1151, 5657, 5659, 5660, 5632, 4821, 38, 5661, 5662, 5663, 1370, 5664, 5665, 5666, 5075, 5667, 2]
// Exports: cancelGetFileInfo, getAppDir, getCaptionLabel, getFileFromUploadItem, getFileInfo, getFileSize, getImageCompressionQuality, getImageDimensionsIfMissing, getType, openImagePicker, resolveModeToVideoQualityForFreeUser, resolveModeToVideoQualityForUserWithFeature, shouldResolveToMediaFilePath

// Module 5636 (utils/UploadUtils)
import LoggerDefault from "Logger" /* 3 */;
import NativeFileModuleDefault from "NativeFileModule" /* 1151 */;
import PlatformUtils from "PlatformUtils" /* 1364 */;
import NativeMediaManagerModuleDefault from "NativeMediaManagerModule" /* 1427 */;
import Upload from "Upload" /* 5626 */;
import UploadUtils from "UploadUtils" /* 5627 */;
import FileUtils from "FileUtils" /* 5632 */;
import NativePermissionUtilsDefault from "NativePermissionUtils" /* 5637 */;
import VideoUploadUtils from "VideoUploadUtils" /* 5659 */;
import UploadLimits from "UploadLimits" /* 5660 */;
import utils_TimeUtils from "utils/TimeUtils" /* 5667 */;
import _objectWithoutProperties from "_objectWithoutProperties" /* 109 */;
import asyncGeneratorStep from "asyncGeneratorStep" /* 5 */;
import UnsyncedUserSettingsStore_mod from "UnsyncedUserSettingsStore" /* 1184 */;
import NetworkStore from "NetworkStore" /* 4894 */;
import UserStore from "UserStore" /* 1372 */;

require = fn;
function openImagePickerUnhandled() {
  const self = this;
  const apply = closure_24.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_24 = async function _openImagePickerUnhandled(arg0, value) {
  if (c12 === 2) {
    c12 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp9 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c12 = 2;
      switch (c11) {
        case 0:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c12 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_7 = tmp7;
            closure_135_0 = closure_0;
            closure_135_1 = undefined;
            let width;
            let height;
            closure_135_4 = undefined;
            let file;
            closure_135_6 = undefined;
            closure_135_8 = undefined;
            closure_135_7 = function cleanPickedImage() {
              if (obj.isIOS()) {
                promise.then(() => type(5648).cleanSingle(decodeURIComponent(uri.uri.replace(/^file:\/\//, "")))).catch((error) => logger.warn("Failed to remove picked image", error));
                const nextPromise = promise.then(() => type(5648).cleanSingle(decodeURIComponent(uri.uri.replace(/^file:\/\//, ""))));
              }
            };
            c11 = 1;
            c12 = 1;
            const obj4 = { value: NativePermissionUtilsDefault.requestPermission(constants.PHOTOS), done: false };
            return obj4;
          }
        break;
        case 1:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c12 = 3;
            const obj5 = { value, done: true };
            return obj5;
          } else if (value) {
            let size1 = { width: null, height: null };
            let size = closure_135_0;
            if ("size" in closure_135_0) {
              size = size.size;
              size1.width = size;
              size1.height = closure_135_0.size;
              let tmp77 = size1;
            } else {
              size1.width = size.width;
              size1.height = closure_135_0.height;
              tmp77 = size1;
            }
            closure_135_1 = tmp77;
            width = closure_135_1.width;
            height = closure_135_1.height;
            size1 = new Promise((arg0, arg1) => {
              closure_0 = arg0;
              closure_1 = arg1;
              closure_1(5648).launchImageLibrary({ mediaType: "photo", includeBase64: true, disableNewIOSPicker: true }, (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 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) {
                      const obj = { uri: null, base64: null };
                      ({ uri: obj.uri, base64: obj.base64 } = first);
                      closure_0(obj);
                    }
                  }
                  const _Error = Error;
                  const error1 = new Error(assets.errorMessage);
                  closure_1(error1);
                }
              });
            });
            c11 = 2;
            c12 = 1;
          } else {
            let _Error = Error;
            let error = new Error("Missing permission");
            throw error;
          }
        break;
        case 2:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c12 = 3;
            const obj6 = { value, done: true };
            return obj6;
          } else {
            closure_135_4 = value;
            const obj7 = { uri: closure_135_4.uri, i: "" };
            file = closure_134_0(closure_134_2[11]).getFile(obj7);
            const obj30 = closure_134_0(closure_134_2[11]);
            const obj32 = closure_134_1(closure_134_2[12]);
            closure_135_6 = closure_134_1(closure_134_2[12]).fromFileUri(closure_135_4.uri).catch(() => null);
            if (null != closure_135_4.base64) {
              if (obj33.isAndroid()) {
                const base64 = closure_135_4.base64;
                if (base64.startsWith("UklGR")) {
                  const obj8 = { base64: closure_134_16 + closure_135_4.base64, mimeType: "image/webp" };
                  c11 = 3;
                  c12 = 1;
                  const obj9 = { value: closure_135_6, done: false };
                  return obj9;
                } else {
                  const base641 = closure_135_4.base64;
                  if (4 === base641.indexOf("ZnR5cA==")) {
                    const base642 = closure_135_4.base64;
                    if (8 !== base642.indexOf("YXZpZg==")) {
                      const base643 = closure_135_4.base64;
                    }
                    const obj10 = { base64: closure_134_17 + closure_135_4.base64, mimeType: "image/avif" };
                    c11 = 4;
                    c12 = 1;
                    const obj11 = { value: closure_135_6, done: false };
                    return obj11;
                  }
                }
              }
              obj33 = closure_134_0(closure_134_2[13]);
            }
            if ("image/gif" === file.type) {
              closure_135_7();
              const obj12 = { base64: closure_134_13 + closure_135_4.base64, mimeType: "image/gif" };
              c11 = 5;
              c12 = 1;
              const obj13 = { value: closure_135_6, done: false };
              return obj13;
            } else {
              c9 = 2;
              const size2 = { uri: closure_135_4.uri, width, height, includeBase64: true, mimeType: null };
              const preferredMimeType = closure_135_0.preferredMimeType;
              let type = preferredMimeType;
              if (preferredMimeType == null) {
                type = file.type;
              }
              size2.mimeType = type;
              c11 = 8;
              c12 = 1;
              const obj14 = { value: closure_134_1(closure_134_2[10]).launchCropper(size2), done: false };
              return obj14;
            }
            const fromFileUriResult = closure_134_1(closure_134_2[12]).fromFileUri(closure_135_4.uri);
          }
        break;
        case 3:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c12 = 3;
            const obj15 = { value, done: true };
            return obj15;
          } else {
            obj8.originalMd5 = value;
            c12 = 3;
            const obj16 = { value: obj8, done: true };
            return obj16;
          }
        break;
        case 4:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c12 = 3;
            const obj17 = { value, done: true };
            return obj17;
          } else {
            obj10.originalMd5 = value;
            c12 = 3;
            const obj18 = { value: obj10, done: true };
            return obj18;
          }
        break;
        case 5:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c12 = 3;
            const obj19 = { value, done: true };
            return obj19;
          } else {
            obj12.originalMd5 = value;
            c12 = 3;
            const obj20 = { value: obj12, done: true };
            return obj20;
          }
        break;
        case 6:
          c9 = 0;
          closure_135_7();
          throw closure_10;
        case 7:
          c9 = 1;
          closure_135_9 = closure_10;
          if ("E_PICKER_CANCELLED" === closure_135_9.code) {
            throw closure_135_9;
          } else {
            const obj21 = { base64: closure_134_12 + closure_135_4.base64, mimeType: file.type, errorStr: closure_135_9.message };
            c11 = 10;
            c12 = 1;
            const obj22 = { value: closure_135_6, done: false };
            return obj22;
          }
        break;
        case 8:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c9 = 0;
            closure_135_7();
            c12 = 3;
            const obj23 = { value, done: true };
            return obj23;
          } else {
            closure_135_8 = value;
            const obj28 = closure_134_1(closure_134_2[10]);
            closure_134_1(closure_134_2[10]).cleanSingle(closure_135_8.path).catch((error) => logger.warn("Failed to remove cropped image", error));
            const obj24 = {};
            const _HermesInternal = HermesInternal;
            obj24.base64 = "data:" + closure_135_8.mime + ";base64," + closure_135_8.data;
            obj24.mimeType = closure_135_8.mime;
            c11 = 9;
            c12 = 1;
            const obj25 = { value: closure_135_6, done: false };
            return obj25;
          }
        break;
        case 9:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c9 = 0;
            closure_135_7();
            c12 = 3;
            const obj26 = { value, done: true };
            return obj26;
          } else {
            obj24.originalMd5 = value;
            c9 = 0;
            closure_135_7();
            c12 = 3;
            let obj = { value: obj24, done: true };
            return obj;
          }
        break;
        default:
          if (arg0 === 1) {
            c12 = 3;
            throw value;
          } else if (arg0 === 2) {
            c9 = 0;
            closure_135_7();
            c12 = 3;
            const obj27 = { value, done: true };
            return obj27;
          } else {
            obj21.originalMd5 = value;
            c9 = 0;
            closure_135_7();
            c12 = 3;
            const obj29 = { value: obj21, done: true };
            return obj29;
          }
      }
    } catch (tmp92) {
      closure_10 = tmp92;
      if (tmp4 === c9) {
        c12 = tmp2;
        throw tmp92;
      } else if (tmp === tmp94) {
        c11 = tmp6;
      } else {
        c11 = tmp5;
      }
    }
  }
};
function openImagePicker() {
  const self = this;
  const apply = closure_25.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_25 = async function _openImagePicker(arg0, value) {
  if (c6 === 2) {
    c6 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp6 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c6 = 2;
      if (0 === c5) {
        if (arg0 === 1) {
          c6 = 3;
          throw value;
        } else if (arg0 === 2) {
          c6 = 3;
          const obj3 = { value, done: true };
          return obj3;
        } else {
          closure_2 = tmp3;
          closure_1 = tmp7;
          closure_129_0 = closure_0;
          closure_129_1 = undefined;
          c5 = 1;
          c6 = 1;
          const obj4 = { value: NativePermissionUtilsDefault.requestPermission(constants.PHOTOS), done: false };
          return obj4;
        }
      } else if (1 === tmp7) {
        if (arg0 === 1) {
          c6 = 3;
          throw value;
        } else if (arg0 === 2) {
          c6 = 3;
          const obj7 = { value, done: true };
          return obj7;
        } else if (value) {
          c4 = 1;
          c5 = 3;
          c6 = 1;
          const obj8 = { value: closure_130_23(closure_129_0), done: false };
          return obj8;
        } else {
          c6 = 3;
          const obj9 = { value: { errorStr: "Missing permission" }, done: true };
          return obj9;
        }
      } else if (2 === tmp7) {
        c4 = 0;
        closure_129_2 = closure_3;
        if ("E_PICKER_CANCELLED" !== closure_129_2.code) {
          if (closure_129_2.message !== closure_130_22) {
            if ("E_CROPPER_IMAGE_NOT_FOUND" === closure_129_2.code) {
              const intl2 = closure_130_0(closure_130_2[15]).intl;
              closure_130_0(closure_130_2[14]).presentFailedToast(intl2.string(closure_130_0(closure_130_2[15]).t.TTzyzW));
              const obj6 = closure_130_0(closure_130_2[14]);
            } else {
              closure_130_0(closure_130_2[14]).presentFailedToast(closure_129_2.message);
              { errorStr: null }[0] = closure_129_2.message;
              const obj5 = closure_130_0(closure_130_2[14]);
            }
          }
          c6 = 3;
        }
      } else if (arg0 === 1) {
        c6 = 3;
        throw value;
      } else if (arg0 === 2) {
        c4 = 0;
        c6 = 3;
        const obj13 = { value, done: true };
        return obj13;
      } else {
        closure_129_1 = value;
        if (null != closure_129_1.errorStr) {
          const intl = closure_130_0(closure_130_2[15]).intl;
          const obj14 = { reason: closure_129_1.errorStr };
          closure_130_0(closure_130_2[14]).presentFailedToast(intl.formatToPlainString(closure_130_0(closure_130_2[15]).t.Ex162J, obj14));
          const obj = closure_130_0(closure_130_2[14]);
        }
        c4 = 0;
        c6 = 3;
        const obj15 = { value: closure_129_1, done: true };
        return obj15;
      }
    } catch (tmp46) {
      closure_3 = tmp46;
      if (tmp4 === c4) {
        c6 = tmp2;
        throw tmp46;
      } else {
        c5 = tmp;
      }
    }
  }
};
function mediaManager() {
  const self = this;
  const apply = closure_27.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_27 = async function _mediaManager(arg0) {
  closure_0 = arg0;
  closure_1 = [...arguments].slice();
  c6 = 0;
  c7 = 0;
  c5 = 0;
  let iter = (async (arg0, value) => {
    closure_3 = tmp3;
    closure_2 = tmp5;
    closure_130_0 = closure_0;
    closure_130_1 = closure_1;
    await "flex";
    await closure_130_0.apply(closure_131_1(closure_131_2[16]), closure_130_1);
    closure_130_2 = closure_4;
    closure_131_19.warn(closure_130_2);
    await "HermesInternal";
    return value;
  })();
  iter.next();
  return iter;
};
function getVideoQuality() {
  if (UnsyncedUserSettingsStore.dataSavingMode) {
    if (NetworkStore.getType() === constants3.CELLULAR) {
      return constants.LOW;
    }
  }
  const videoUploadQuality = UnsyncedUserSettingsStore.videoUploadQuality;
  const currentUser = UserStore.getCurrentUser();
  const DATA_SAVER = constants2.DATA_SAVER;
  if (obj.canUseHighVideoUploadQuality(currentUser)) {
    if (DATA_SAVER === videoUploadQuality) {
      let VERY_HIGH = constants.LOW;
    } else {
      if (tmp5.STANDARD === videoUploadQuality) {
        VERY_HIGH = constants.HIGH;
      } else if (tmp5.BEST !== videoUploadQuality) {
        VERY_HIGH = constants.MEDIUM;
      }
      VERY_HIGH = constants.VERY_HIGH;
    }
  } else {
    if (DATA_SAVER === videoUploadQuality) {
      let LOW = constants.LOW;
    } else if (tmp5.STANDARD === videoUploadQuality) {
      LOW = constants.MEDIUM;
    } else if (tmp5.BEST === videoUploadQuality) {
      LOW = constants.HIGH;
    } else {
      LOW = constants.LOW;
    }
    return LOW;
  }
}
function getAppDir() {
  const obj2 = NativeFileModuleDefault;
  if (isAndroidResult) {
    if (null == obj2) {
      const _Error = Error;
      const error = new Error("RTNFileManager doesn't exist?");
      throw error;
    } else {
      const tmp3Result = NativeFileModuleDefault;
      return NativeFileModuleDefault.getConstants().CacheDirPath.replace(/cache$/, "");
    }
  } else {
    return "/private" + obj2.getConstants().DocumentsDirPath.replace(/Documents$/, "");
  }
  isAndroidResult = PlatformUtils.isAndroid();
}
function getFileInfo(arg0, arg1) {
  ({ item, spoiler, description } = arg0);
  let str = arg1;
  ({ mimeType, allowOptimization } = arg0);
  if (arg1 === undefined) {
    str = "";
  }
  if (item.platform !== Upload.UploadPlatform.REACT_NATIVE) {
    const _Error = Error;
    const error = new Error("Try to get file info for unsupported upload item");
    throw error;
  } else {
    ({ originalUri, filename, mimeType: mimeType2 } = item);
    if (mimeType2 == null) {
      mimeType2 = mimeType;
    }
    const obj = { uri: originalUri, overrideType: mimeType2 };
    if (tmpResult.getFile(obj).isVideo) {
      const obj2 = { originalUri, filename, mimeType: mimeType2, fileSize: item.size, spoiler, description, i: str };
      let tmp3 = (function processVideoUpload(arg0) {
        const self = this;
        const apply = closure_1_36.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      })(obj2);
    } else {
      const size = { originalUri, filename, mimeType: mimeType2, spoiler, description, i: str, width: null, height: null, allowOptimization: null };
      ({ width: obj3.width, height: obj3.height } = item);
      size.allowOptimization = allowOptimization;
      tmp3 = (function processImageOrFileUpload(size) {
        const self = this;
        const apply = closure_1_37.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      })(size);
    }
    return tmp3;
  }
}
let closure_29 = async function _getPhotoKitDataUTI(arg0, value) {
  if (c7 === 2) {
    c7 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp6 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      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 = tmp3;
          closure_2 = tmp7;
          if (obj9.isIOS()) {
            if (obj8.startsWith("ph://")) {
              c5 = 1;
              c6 = 2;
              c7 = 1;
              const obj5 = { value: NativeMediaManagerModuleDefault.getImageContentType(obj8), done: false };
              return obj5;
            }
          }
          c7 = 3;
          return { value: "HermesInternal", done: null };
        }
      } else if (1 === tmp7) {
        c5 = 0;
        closure_130_0 = closure_4;
        const _HermesInternal = HermesInternal;
        closure_131_19.warn("getImageContentType failed: " + closure_130_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;
        const obj = { value, done: true };
        return obj;
      }
    } catch (tmp16) {
      closure_4 = tmp16;
      if (tmp4 === c5) {
        c7 = tmp2;
        throw tmp16;
      } else {
        c6 = tmp;
      }
    }
  }
};
let closure_30 = async function _shouldConvertToPNG(arg0, value) {
  if (c7 === 2) {
    c7 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp6 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      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 = tmp3;
          closure_2 = tmp7;
          if (obj8.isIOS()) {
            if (tmp26Result.isPhotoKitAsset(str3, str4)) {
              let match;
              if (str4 != null) {
                match = str4.match(/\.png$/i);
              }
              if (null == match) {
                c7 = 3;
                return { value: false, done: true };
              }
            } else if (null == str3.match(/^(assets-library|file):\/\/.+(&ext=|\.)png$/i)) {
              c7 = 3;
              return { value: false, done: true };
            }
            c5 = 1;
            tmp26Result = tmp26(tmp27[20]);
            c6 = 2;
            c7 = 1;
            const obj5 = { value: require("NativeMediaManagerModule").imageHasTransparency(str3), done: false };
            return obj5;
          } else {
            c7 = 3;
            return { value: false, done: true };
          }
          obj8 = PlatformUtils;
          tmp26 = require;
        }
      } else if (1 === tmp7) {
        c5 = 0;
        closure_130_0 = closure_4;
        const _HermesInternal = HermesInternal;
        closure_131_19.error("shouldConvertToPNG: imageHasTransparency failed: " + closure_130_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;
        const obj = { value, done: true };
        return obj;
      }
    } catch (tmp17) {
      closure_4 = tmp17;
      if (tmp4 === c5) {
        c7 = tmp2;
        throw tmp17;
      } else {
        c6 = tmp;
      }
    }
  }
};
function isVideo(uri, overrideType) {
  return UploadUtils.getFile({ uri, overrideType }).isVideo;
}
function isImage(uri, overrideType) {
  return UploadUtils.getFile({ uri, overrideType }).isImage;
}
function getType(uri) {
  return UploadUtils.getFile({ uri }).type;
}
function convertVideo(videoMetadata) {
  ({ uri: require, filename: importDefault, isLowQuality: dependencyMap, compressionQuality: closure_3, videoQualitySetting } = videoMetadata);
  videoMetadata = videoMetadata.videoMetadata;
  c7 = undefined;
  const VideoQualityTarget = VideoUploadUtils.VideoQualityTarget;
  const result = VideoQualityTarget.fromCompressionQuality(videoQualitySetting);
  let obj = VideoUploadUtils;
  let obj2 = UploadLimits;
  const result1 = obj.canSkipVideoTranscode(result, videoMetadata, videoMetadata.fileSize, obj2.getEffectiveUploadLimit(FileUtils.maxFileSize()));
  const result2 = VideoUploadUtils.calculateTargetDimensions(videoMetadata, result.targetResolution);
  let obj8 = {};
  const result3 = VideoUploadUtils.calculateOptimalBitrate(videoMetadata, result, VideoUploadUtils.DEFAULT_VIDEO_ENCODING_CONFIG.bitrateFloor);
  const merged = Object.assign(VideoUploadUtils.DEFAULT_VIDEO_ENCODING_CONFIG);
  obj8.videoQuality = result;
  ({ width: obj6.targetWidth, height: obj6.targetHeight } = result2);
  obj8.targetBitrate = result3;
  if (obj7.isAndroid()) {
    if (tmpResult.getSystemVersionMajor() > 34) {
      let _Math = Math;
      let frameRate = Math.min(videoMetadata.frameRate, tmp(5659).DEFAULT_VIDEO_ENCODING_CONFIG.frameRate);
    }
    obj8.frameRate = frameRate;
    obj8.skipVideoTranscode = result1;
    ({ isHDRContent: obj6.createHDR, rotationDegrees: obj6.rotationDegrees } = videoMetadata);
    c7 = 0;
    let promise = new Promise((arg0, arg1) => {
      closure_0 = arg0;
      closure_1 = arg1;
      closure_2 = async function _findCompatibleConfig(arg0, value) {
        if (c13 === 2) {
          c13 = 3;
          throw new TypeError("Generator functions may not be called on executing generators");
        } else {
          if (tmp9 === 3) {
            if (arg0 === 1) {
              throw value;
            } else if (arg0 === 2) {
              const obj2 = { value, done: true };
              return obj2;
            } else {
              return { value: "HermesInternal", done: null };
            }
          } else {
            try {
              c13 = 2;
              if (0 === c12) {
                if (arg0 === 1) {
                  c13 = 3;
                  throw value;
                } else if (arg0 === 2) {
                  c13 = 3;
                  const obj3 = { value, done: true };
                  return obj3;
                } else {
                  closure_8 = tmp4;
                  closure_9 = tmp7;
                  closure_137_0 = undefined;
                  async function _loop() {
                    closure_2 = tmp2;
                    closure_129_0 = await closure_3_41(config);
                    if (closure_129_0.isSupported) {
                      return { v: true };
                    }
                    if (null != closure_129_0) {
                      if (null != closure_129_0.capabilities) {
                        if (null != closure_129_0.failures) {
                          if (0 !== closure_129_0.failures.length) {
                            closure_129_1 = false;
                            const failures = closure_129_0.failures;
                            if (null != failures.find((type) => "codec_not_found" === type.type)) {
                              logger.error("No supported video encoder found");
                              const _Error3 = Error;
                              const error = new Error("No supported video encoder found");
                              tmp3(error);
                              c4 = 3;
                              return { value: { v: false }, done: true };
                            } else {
                              const failures1 = closure_129_0.failures;
                              if (null != failures1.find((type) => {
                                let tmp = "resolution" === type.type;
                                if (!tmp) {
                                  tmp = "resolution_alignment" === type.type;
                                }
                                return tmp;
                              })) {
                                if (null != closure_129_0.capabilities.resolution) {
                                  if (0 !== config.targetHeight) {
                                    if (0 !== config.targetWidth) {
                                      const maxWidth = closure_129_0.capabilities.resolution.maxWidth;
                                      const maxHeight = closure_129_0.capabilities.resolution.maxHeight;
                                      closure_129_4 = config.targetWidth / config.targetHeight;
                                      const _Math6 = Math;
                                      closure_129_5 = Math.min(config.targetWidth, maxWidth);
                                      const _Math7 = Math;
                                      closure_129_6 = Math.min(config.targetHeight, maxHeight);
                                      if (closure_129_5 !== config.targetWidth) {
                                        const _Math = Math;
                                        closure_129_6 = Math.round(closure_129_5 / closure_129_4);
                                      }
                                      if (closure_129_6 !== config.targetHeight) {
                                        const _Math2 = Math;
                                        closure_129_5 = Math.round(closure_129_6 * closure_129_4);
                                      }
                                      iter5(tmp2[25])(null != closure_129_0.capabilities.blockSize, "Missing video encoder block size");
                                      const blockSize = closure_129_0.capabilities.blockSize;
                                      const widthAlignment = blockSize.widthAlignment;
                                      const heightAlignment = blockSize.heightAlignment;
                                      const _Math3 = Math;
                                      closure_129_5 = Math.floor(closure_129_5 / widthAlignment) * widthAlignment;
                                      const _Math4 = Math;
                                      closure_129_6 = Math.floor(closure_129_6 / heightAlignment) * heightAlignment;
                                      let tmp37 = closure_129_5 === config.targetWidth;
                                      if (tmp37) {
                                        tmp37 = closure_129_6 === config.targetHeight;
                                      }
                                      if (!tmp37) {
                                        config.targetWidth = closure_129_5;
                                        config.targetHeight = closure_129_6;
                                        closure_129_1 = true;
                                      }
                                    }
                                  }
                                  const _Error2 = Error;
                                  const error1 = new Error("Invalid video dimensions: width or height is 0");
                                  tmp3(error1);
                                  c4 = 3;
                                  return { value: { v: false }, done: true };
                                }
                              }
                              const failures2 = closure_129_0.failures;
                              closure_129_10 = failures2.find((type) => "frameRate" === type.type);
                              const frameRate = closure_129_0.capabilities.frameRate;
                              if (null != closure_129_10) {
                                let min;
                                if (frameRate != null) {
                                  min = frameRate.min;
                                }
                                if (null != min) {
                                  let max;
                                  if (frameRate != null) {
                                    max = frameRate.max;
                                  }
                                  if (null != max) {
                                    let frameRate2 = config.frameRate;
                                    const message = closure_129_10.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) => {
                                        let tmp = item < frameRate.frameRate;
                                        if (tmp) {
                                          tmp = item >= min.min;
                                        }
                                        return tmp;
                                      });
                                      min = found;
                                      if (found == null) {
                                        min = frameRate.min;
                                      }
                                      frameRate2 = min;
                                    } else {
                                      const _Math5 = Math;
                                      frameRate2 = Math.min(config.frameRate, frameRate.max);
                                    }
                                    if (frameRate2 !== config.frameRate) {
                                      config.frameRate = frameRate2;
                                      closure_129_1 = true;
                                    }
                                  }
                                }
                              }
                              if (closure_129_1) {
                                closure_7 = closure_7 + 1;
                                c4 = 3;
                                return { value: "HermesInternal", done: null };
                              } else {
                                logger.error("No adjustments possible for current failures", { currentFailures: closure_129_0.failures, config, capabilities: closure_129_0.capabilities, attempt: closure_7 + 1 });
                                const _Error = Error;
                                const error2 = new Error("No adjustments possible for current failures");
                                tmp3(error2);
                                c4 = 3;
                                return { value: { v: false }, done: true };
                              }
                            }
                          }
                        }
                      }
                    }
                    logger.warn("Unable to determine device capabilities or adjust parameters", { config, attempt: closure_7 + 1 });
                    return 0;
                  }
                  closure_137_1 = _loop;
                  if (iter7 < 4) {
                    iter7 = _loop()[isArray.iterator]();
                    HermesBuiltin.ensureObject("iterator is not an object");
                    let next = iter7.next;
                    closure_0 = undefined;
                    const _loopResult = _loop();
                  }
                  c13 = 3;
                  return { value: false, done: true };
                }
              } else {
                if (1 === tmp10) {
                  c10 = 1;
                  if (arg0 === 1) {
                    c13 = 3;
                    throw value;
                  } else {
                    closure_0 = value;
                    if (arg0 === 2) {
                      closure_0 = value;
                      c10 = 0;
                      const method = HermesBuiltin.getMethod("return");
                      if (method === undefined) {
                        c13 = 3;
                        const obj4 = { value, done: true };
                        return obj4;
                      } else {
                        const iter4 = method(closure_0);
                        HermesBuiltin.ensureObject("iterator.return() did not return an object");
                        if (iter4.done) {
                          c13 = 3;
                          const obj5 = { value: iter4.value, done: true };
                          return obj5;
                        } else {
                          c12 = 1;
                          c13 = 1;
                          return iter4;
                        }
                      }
                    } else {
                      c10 = 0;
                      const tmp40 = value;
                    }
                  }
                } else {
                  if (2 === tmp10) {
                    c10 = 0;
                    const method1 = HermesBuiltin.getMethod("throw");
                    if (method1 === undefined) {
                      const method2 = HermesBuiltin.getMethod("return");
                      if (method2 !== undefined) {
                        HermesBuiltin.ensureObject("iterator.return() did not return an object");
                      }
                      throw new TypeError("yield* delegate must have a .throw() method");
                    } else {
                      const iter3 = method1(tmp30);
                      HermesBuiltin.ensureObject("iterator.throw() did not return an object");
                      if (iter3.done) {
                        let iter5 = iter3;
                      } else {
                        c12 = 1;
                        c13 = 1;
                        return iter3;
                      }
                    }
                    tmp30 = closure_11;
                  } else {
                    if (3 === tmp10) {
                      c10 = 2;
                      if (arg0 === 1) {
                        c13 = 3;
                        throw value;
                      } else {
                        c2 = value;
                        if (arg0 === 2) {
                          c2 = value;
                          c10 = 0;
                          const method3 = HermesBuiltin.getMethod("return");
                          if (method3 === undefined) {
                            c13 = 3;
                            const obj6 = { value, done: true };
                            return obj6;
                          } else {
                            const iter2 = method3(c2);
                            HermesBuiltin.ensureObject("iterator.return() did not return an object");
                            if (iter2.done) {
                              c13 = 3;
                              const obj = { value: iter2.value, done: true };
                              return obj;
                            } else {
                              c12 = 3;
                              c13 = 1;
                              return iter2;
                            }
                          }
                        } else {
                          c10 = 0;
                          const tmp22 = value;
                        }
                      }
                    } else {
                      c10 = 0;
                      const method4 = HermesBuiltin.getMethod("throw");
                      if (method4 === undefined) {
                        const method5 = HermesBuiltin.getMethod("return");
                        if (method5 !== undefined) {
                          HermesBuiltin.ensureObject("iterator.return() did not return an object");
                        }
                        throw new TypeError("yield* delegate must have a .throw() method");
                      } else {
                        const iter = method4(tmp12);
                        HermesBuiltin.ensureObject("iterator.throw() did not return an object");
                        if (iter.done) {
                          let iter6 = iter;
                        } else {
                          c12 = 3;
                          c13 = 1;
                          return iter;
                        }
                      }
                      tmp12 = closure_11;
                    }
                    value2 = iter6.value;
                    closure_137_0 = value2;
                    if (0 !== value2) {
                      if (closure_137_0) {
                        c13 = 3;
                        const obj7 = { value: closure_137_0.v, done: true };
                        return obj7;
                      } else if (iter7 < 4) {
                        const iter8 = closure_137_1()[isArray.iterator]();
                        HermesBuiltin.ensureObject("iterator is not an object");
                        next = iter8.next;
                        c2 = undefined;
                        const tmp76 = closure_137_1();
                      }
                    }
                  }
                  iter6 = next(tmp22);
                  HermesBuiltin.ensureObject("iterator.next() did not return an object");
                  if (!iter6.done) {
                    c12 = 3;
                    c13 = 1;
                    return iter6;
                  }
                }
                value = iter5.value;
                closure_137_0 = value;
              }
              iter5 = next(tmp40);
              HermesBuiltin.ensureObject("iterator.next() did not return an object");
              if (!iter5.done) {
                c12 = 1;
                c13 = 1;
                return iter5;
              }
            } catch (tmp64) {
              closure_11 = tmp64;
              if (tmp5 === c10) {
                c13 = tmp3;
                throw tmp64;
              } else if (tmp2 === tmp66) {
                c12 = tmp;
              } else {
                c12 = tmp6;
              }
            }
          }
        }
      };
      function resolveWithConfig(path) {
        return closure_0({ path, encodingConfig: obj8 });
      }
      const promise = (function findCompatibleConfig() {
        const self = this;
        const apply = closure_2.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      })();
      (function findCompatibleConfig() {
        const self = this;
        const apply = closure_2.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      })().then((result) => {
        if (result) {
          let isAndroidResult = PlatformUtils.isAndroid();
          if (isAndroidResult) {
            isAndroidResult = null != str3.match(/^content:\/\/.+$/i);
          }
          if (isAndroidResult) {
            const obj3 = { encodingConfig: obj8, compressionQuality, isLowQuality, videoQuality: videoQualitySetting, skipVideoTranscode: result1 };
            let nextPromise = mediaManager(NativeMediaManagerModuleDefault.resolveToMediaFilePath, str3, obj3).then(resolveWithConfig, closure_1);
            const promise4 = mediaManager(NativeMediaManagerModuleDefault.resolveToMediaFilePath, str3, obj3);
          } else {
            const isIOSResult1 = tmp12(1364).isIOS();
            if (!isIOSResult1) {
              if (isIOSResult1) {
                const obj4 = { encodingConfig: obj8, videoQuality: videoQualitySetting, isMov: true, skipVideoTranscode: result1 };
                nextPromise = mediaManager(NativeMediaManagerModuleDefault.compressVideo, str3, obj4).then(resolveWithConfig, closure_1);
                const promise3 = mediaManager(NativeMediaManagerModuleDefault.compressVideo, str3, obj4);
              } else {
                const isIOSResult2 = tmp12(1364).isIOS();
                if (!isIOSResult2) {
                  if (isIOSResult2) {
                    const obj5 = { encodingConfig: obj8, videoQuality: videoQualitySetting, skipVideoTranscode: result1 };
                    nextPromise = mediaManager(NativeMediaManagerModuleDefault.compressVideo, str3, obj5).then(resolveWithConfig, closure_1);
                    const promise2 = mediaManager(NativeMediaManagerModuleDefault.compressVideo, str3, obj5);
                  } else {
                    const formatted = str3.toLowerCase();
                    let isIOSResult = tmp12(1364).isIOS();
                    if (isIOSResult) {
                      isIOSResult = str3.startsWith("file");
                    }
                    if (isIOSResult) {
                      let endsWithResult = formatted.endsWith("mov");
                      if (!endsWithResult) {
                        endsWithResult = formatted.endsWith("mp4");
                      }
                      if (!endsWithResult) {
                        endsWithResult = formatted.endsWith("qt");
                      }
                      isIOSResult = endsWithResult;
                    }
                    if (isIOSResult) {
                      const obj6 = { encodingConfig: obj8, videoQuality: videoQualitySetting, isMov: null, skipVideoTranscode: null };
                      const formatted1 = str3.toLowerCase();
                      let endsWithResult1 = formatted1.endsWith("mov");
                      if (!endsWithResult1) {
                        const formatted2 = str3.toLowerCase();
                        endsWithResult1 = formatted2.endsWith("qt");
                      }
                      obj6.isMov = endsWithResult1;
                      obj6.skipVideoTranscode = result1;
                      nextPromise = mediaManager(NativeMediaManagerModuleDefault.compressVideo, str3, obj6).then(resolveWithConfig, closure_1);
                      const tmp36Result = mediaManager(NativeMediaManagerModuleDefault.compressVideo, str3, obj6);
                    } else {
                      const obj7 = { uri: str3, filename: str4 };
                      logger.error("Unsupported video URI format", obj7);
                      const _Error2 = Error;
                      const _HermesInternal = HermesInternal;
                      const error = new Error("Unsupported video URI format: " + str3);
                      closure_1(error);
                    }
                    const tmp12Result8 = tmp12(1364);
                  }
                } else {
                  if (tmp12Result9.isPhotoKitAsset(str3, str4)) {
                    let match;
                    if (str4 != null) {
                      match = str4.match(/\.mp4$/i);
                    }
                    let isVideo2 = null != match;
                  } else {
                    isVideo2 = null != str3.match(/^assets-library:\/\/.+&ext=mp4$/i);
                    if (isVideo2) {
                      obj8 = { uri: str3, overrideType: "Array" };
                      isVideo2 = tmp12(5627).getFile(obj8).isVideo;
                      const tmp12Result10 = tmp12(5627);
                    }
                  }
                  tmp12Result9 = tmp12(5657);
                }
                const tmp12Result7 = tmp12(1364);
              }
            } else {
              if (tmp12Result11.isPhotoKitAsset(str3, str4)) {
                let match1;
                if (str4 != null) {
                  match1 = str4.match(/\.(mov|qt)$/i);
                }
                isVideo = null != match1;
              } else {
                isVideo = null != str3.match(/^assets-library:\/\/.+&ext=(mov|qt)$/i);
                if (isVideo) {
                  const obj9 = { uri: str3, overrideType: "Array" };
                  isVideo = tmp12(5627).getFile(obj9).isVideo;
                  const tmp12Result12 = tmp12(5627);
                }
              }
              tmp12Result11 = tmp12(5657);
            }
            const tmp12Result = tmp12(1364);
          }
        } else {
          const obj = { finalConfig: obj8, attempts };
          logger.error("Could not find compatible encoding configuration after multiple attempts", obj);
          const _Error = Error;
          const error1 = new Error("Could not find compatible encoding configuration after multiple attempts");
          closure_1(error1);
        }
      }).catch(arg1);
    });
    return promise;
  }
  frameRate = videoMetadata.frameRate;
}
function buildResolvedUpload(arg0) {
  const self = this;
  const apply = closure_35.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_35 = async function _buildResolvedUpload(arg0) {
  isImage = arg0;
  c2 = 0;
  c3 = 0;
  return (async (arg0, value) => {
    if (c3 === 2) {
      c3 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp4 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj2 = { value, done: true };
        return obj2;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        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 {
            closure_1 = tmp2;
            closure_129_0 = isImage;
            let filename;
            closure_129_2 = undefined;
            closure_129_3 = undefined;
            ({ path: obj7.uri, i: obj7.i, mimeType: obj7.overrideType, filename: obj7.overrideFilename } = isImage);
            const file = UploadUtils.getFile({ uri: null, i: null, overrideType: null, overrideFilename: null });
            filename = file.filename;
            closure_129_2 = _objectWithoutProperties(file, closure_2_3);
            closure_129_3 = {};
            isImage = isImage.isImage;
            if (isImage) {
              isImage = tmp34.path !== tmp34.originalUri;
            }
            if (isImage) {
              c2 = 1;
              c3 = 1;
              const obj5 = { value: calculateImageQualityMetrics(tmp34.originalUri, tmp34.path, tmp34.filename, tmp34.attachmentQualityMetricsEnabled, tmp34.attachmentOriginDetectionEnabled), done: false };
              return obj5;
            } else {
              const obj12 = {};
              const merged = Object.assign(closure_129_2);
              obj12.name = filename;
              obj12.spoiler = closure_129_0.spoiler;
              obj12.description = closure_129_0.description;
              obj12.imageCompressionQuality = closure_129_0.compressionQuality;
              obj12.imageEncoderType = closure_129_0.imageEncoderType;
              obj12.videoCompressionQuality = closure_129_0.videoQualitySetting;
              obj12.videoMetadata = closure_129_0.videoMetadata;
              obj12.encodingConfig = closure_129_0.encodingConfig;
              obj12.sourceWidth = closure_129_0.sourceImageDimensions.width;
              obj12.sourceHeight = closure_129_0.sourceImageDimensions.height;
              obj12.uploadedImageWidth = closure_129_0.uploadedImageWidth;
              obj12.uploadedImageHeight = closure_129_0.uploadedImageHeight;
              obj12.psnr = closure_129_3.psnr;
              obj12.ssim = closure_129_3.ssim;
              obj12.origin = closure_129_3.origin;
              obj12.psnrMeasurementLatencyMs = closure_129_3.psnrMeasurementLatencyMs;
              obj12.ssimMeasurementLatencyMs = closure_129_3.ssimMeasurementLatencyMs;
              c3 = 3;
            }
            const obj4 = { uri: null, i: null, overrideType: null, overrideFilename: null };
          }
        } else if (arg0 === 1) {
          c3 = 3;
          throw value;
        } else if (arg0 !== 2) {
          closure_129_3 = value;
        }
        c3 = 3;
        const obj = { value, done: true };
        return obj;
      } catch (tmp29) {
        c3 = tmp;
        throw tmp29;
      }
    }
  })();
};
let closure_36 = async function _processVideoUpload() {
  closure_1 = tmp2;
  ({ originalUri: closure_129_0, filename: closure_129_1, mimeType: closure_129_2, fileSize: closure_129_3, spoiler: closure_129_4, description: closure_129_5, i: closure_129_6 } = closure_0);
  await "flex";
  closure_129_7 = closure_130_28();
  let dataSavingMode = closure_130_9.dataSavingMode;
  if (dataSavingMode) {
    dataSavingMode = closure_130_10.getType() === closure_130_14.CELLULAR;
  }
  closure_129_8 = dataSavingMode;
  closure_129_9 = await (function fetchVideoMetadata(arg0, arg1) {
    const self = this;
    const apply = closure_1_39.apply;
    if (typeof apply === "unknown") {
      let applyArgumentsResult = HermesBuiltin.applyArguments(self);
    } else {
      applyArgumentsResult = apply(self, arguments);
    }
    return applyArgumentsResult;
  })(closure_129_0, closure_129_2);
  if (null == closure_129_9) {
    const _Error3 = Error;
    const error = new Error("Video metadata is required for video conversion");
    throw error;
  }
  if (obj11.getVideoFrameRateValidationExperimentConfig({ location: "upload_utils.process_video_upload" }).enableFrameRateValidation) {
    if (null != closure_129_9.frameRate) {
      const _Number = Number;
    }
    const _Error2 = Error;
    const _HermesInternal = HermesInternal;
    const error1 = new Error("Invalid video frame rate: " + closure_129_9.frameRate);
    throw error1;
  }
  closure_129_10 = await closure_130_33({ uri: closure_129_0, filename: closure_129_1, isLowQuality: closure_129_8, compressionQuality: closure_130_15.LOW, videoQualitySetting: closure_129_7, videoMetadata: closure_129_9, fileSize: closure_129_3 });
  const path = closure_129_10.path;
  const encodingConfig = closure_129_10.encodingConfig;
  if (null == path) {
    const _Error = Error;
    const error2 = new Error("Failed to get video file path");
    throw error2;
  }
  return closure_130_34({ path, i: closure_129_6, mimeType: closure_129_2, filename: closure_129_1, originalUri: closure_129_0, spoiler: closure_129_4, description: closure_129_5, compressionQuality: closure_130_15.LOW, videoQualitySetting: closure_129_7, videoMetadata: closure_129_9, encodingConfig, sourceImageDimensions: {}, isImage: false });
};
let closure_37 = async function _processImageOrFileUpload(arg0, value) {
  closure_3 = tmp2;
  ({ originalUri: closure_131_0, filename: closure_131_1, mimeType: closure_131_2, spoiler: closure_131_3, description: closure_131_4, i: closure_131_5, width: closure_131_6, height: closure_131_7, allowOptimization: closure_131_8 } = closure_0);
  await "flex";
  let dataSavingMode = closure_132_9.dataSavingMode;
  if (dataSavingMode) {
    dataSavingMode = closure_132_10.getType() === closure_132_14.CELLULAR;
  }
  closure_131_11 = dataSavingMode;
  closure_131_12 = closure_132_32(closure_131_0, closure_131_2);
  if (closure_131_12) {
    const size = { width: closure_131_6, height: closure_131_7 };
    let obj5 = size;
  } else {
    obj5 = {};
  }
  closure_131_13 = obj5;
  let LOW = closure_132_15.LOW;
  let useOriginalIfSmaller = false;
  let tmp51 = closure_131_12;
  if (closure_131_12) {
    tmp51 = !closure_131_11;
  }
  if (tmp51) {
    useOriginalIfSmaller = closure_132_0(closure_132_2[27]).ADAPTIVE_COMPRESSION_CONFIG.useOriginalIfSmaller;
    LOW = closure_132_0(closure_132_2[27]).getAdaptiveImageCompressionQuality(closure_131_13, closure_132_0(closure_132_2[27]).ADAPTIVE_COMPRESSION_CONFIG);
    const _HermesInternal = HermesInternal;
    closure_132_19.log("Got image compression quality: " + LOW + " for " + closure_131_0 + " with dimensions: " + closure_131_6 + "x" + closure_131_7 + " and useOriginalIfSmaller: " + useOriginalIfSmaller);
    closure_132_0(closure_132_2[27]);
  }
  let isIOSResult = closure_132_0(closure_132_2[13]).isIOS();
  if (isIOSResult) {
    isIOSResult = closure_131_0.startsWith("ph://");
  }
  closure_131_16 = isIOSResult;
  closure_131_17 = false;
  if (closure_131_12) {
    closure_131_18 = closure_132_0(closure_132_2[28]).useMobileLosslessImageUploadV2Experiment({ location: "upload_utils.process_image_upload" });
    closure_132_0(closure_132_2[28]);
    let enabled = closure_132_0(closure_132_2[29]).isDiscordFrontendDevelopment();
    if (!enabled) {
      enabled = closure_131_18.enabled;
    }
    closure_131_17 = enabled;
    closure_132_0(closure_132_2[29]);
  }
  let enableQualityMetrics = false;
  closure_131_20 = false;
  if (closure_131_12) {
    const AttachmentQualityMetricsExperiment = closure_132_0(closure_132_2[30]).AttachmentQualityMetricsExperiment;
    const config = AttachmentQualityMetricsExperiment.getConfig({ location: "upload_utils.process_image_upload" });
    enableQualityMetrics = config.enableQualityMetrics;
    closure_131_20 = config.enableOriginDetection;
  }
  let useJpegliEncoder = false;
  closure_132_0(closure_132_2[13]);
  if (obj11.isIOS()) {
    if (closure_131_12) {
      if (obj12.isDiscordFrontendDevelopment()) {
        useJpegliEncoder = true;
      } else {
        useJpegliEncoder = closure_132_0(closure_132_2[31]).getIosJpegliConfig({ location: "upload_utils.process_image_upload" }).useJpegliEncoder;
        closure_132_0(closure_132_2[31]);
      }
      if (!closure_131_11) {
        if (null != closure_131_13.width) {
          if (null != closure_131_13.height) {
            if (obj21.getMobileImageEncodingLadderConfig({ location: "upload_utils.process_image_upload" }).useImageEncodingLadder) {
              const ImageEncodingLadder = closure_132_0(closure_132_2[27]).ImageEncodingLadder;
              const size1 = { width: closure_131_13.width, height: closure_131_13.height };
              closure_131_23 = ImageEncodingLadder.selectEncodingConfig(size1);
              useOriginalIfSmaller = true;
              LOW = closure_131_23.compressionQuality / 100;
              const targetWidth = closure_131_23.targetWidth;
              const targetHeight = closure_131_23.targetHeight;
            }
            obj21 = closure_132_0(closure_132_2[32]);
          }
        }
      }
      obj12 = closure_132_0(closure_132_2[29]);
    }
  }
  await (function tryConvertImage(arg0) {
    const self = this;
    const apply = closure_1_38.apply;
    if (typeof apply === "unknown") {
      let applyArgumentsResult = HermesBuiltin.applyArguments(self);
    } else {
      applyArgumentsResult = apply(self, arguments);
    }
    return applyArgumentsResult;
  })({ uri: closure_131_0, filename: closure_131_1, isLowQuality: closure_131_11, compressionQuality: LOW, mobileLosslessImageEnabled: closure_131_17, useEnhancedConversion: closure_131_16, useJpegliEncoder, allowOptimization: closure_131_8, targetWidth, targetHeight });
  if (2 === tmp5) {
    if (arg0 === 1) {
      c6 = 3;
      throw value;
    } else if (arg0 === 2) {
      c6 = 3;
      return { value, done: true };
    } else {
      closure_131_26 = value;
      if (null != closure_131_26) {
        let path = closure_131_26.path;
        const encoderUsed = closure_131_26.encoderUsed;
      } else {
        c5 = 3;
        c6 = 1;
        return {
          value: (function resolveFileUri(str, compressionQuality, isLowQuality, useOriginalIfSmaller, arg4) {
                  let flag = arg4;
                  if (arg4 === undefined) {
                    flag = true;
                  }
                  let isAndroidResult = closure_1_0(height[13]).isAndroid();
                  if (isAndroidResult) {
                    isAndroidResult = null != str.match(/^content:\/\/.+$/i);
                  }
                  if (isAndroidResult) {
                    const obj2 = { compressionQuality, isLowQuality, skipVideoTranscode: true, useOriginalIfSmaller, allowOptimization: flag };
                    return closure_1_26(width(tmp[16]).resolveToMediaFilePath, str, obj2);
                  } else {
                    return Promise.resolve(str);
                  }
                  const obj = closure_1_0(height[13]);
                  tmp = height;
                })(closure_131_0, LOW, closure_131_11, useOriginalIfSmaller, closure_131_8),
          done: false
        };
      }
    }
  } else if (arg0 === 1) {
    c6 = 3;
    throw value;
  } else if (arg0 === 2) {
    c6 = 3;
    return { value, done: true };
  } else {
    path = value;
  }
  if (null == path) {
    const _Error = Error;
    const error = new Error("Failed to get image file path");
    throw error;
  }
  const obj17 = { path, i: closure_131_5, mimeType: closure_131_2, filename: closure_131_1, originalUri: closure_131_0, spoiler: closure_131_3, description: closure_131_4, compressionQuality: LOW, sourceImageDimensions: closure_131_13, isImage: closure_131_12, imageEncoderType: encoderUsed, uploadedImageWidth: null, uploadedImageHeight: null, attachmentQualityMetricsEnabled: null, attachmentOriginDetectionEnabled: null };
  if (closure_131_26 != null) {
    const outputWidth = closure_131_26.outputWidth;
  }
  let width = outputWidth;
  if (outputWidth == null) {
    width = closure_131_13.width;
  }
  obj17.uploadedImageWidth = width;
  if (closure_131_26 != null) {
    const outputHeight = closure_131_26.outputHeight;
  }
  let height = outputHeight;
  if (outputHeight == null) {
    height = closure_131_13.height;
  }
  obj17.uploadedImageHeight = height;
  obj17.attachmentQualityMetricsEnabled = enableQualityMetrics;
  obj17.attachmentOriginDetectionEnabled = closure_131_20;
  return closure_132_34(obj17);
};
let closure_38 = async function _tryConvertImage(arg0, value) {
  if (c7 === 2) {
    c7 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp8 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c7 = 2;
      switch (c6) {
        case 0:
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj3 = { value, done: true };
            return obj3;
          } else {
            closure_3 = tmp3;
            dependencyMap = tmp9;
            closure_130_0 = undefined;
            closure_130_1 = undefined;
            closure_130_2 = undefined;
            closure_130_3 = undefined;
            closure_130_4 = undefined;
            closure_130_5 = undefined;
            closure_130_6 = undefined;
            closure_130_7 = undefined;
            closure_130_8 = undefined;
            closure_130_9 = undefined;
            ({ uri: closure_130_0, filename: closure_130_1, isLowQuality: closure_130_2, compressionQuality: closure_130_3, mobileLosslessImageEnabled: closure_130_4, useEnhancedConversion: closure_130_5, useJpegliEncoder: closure_130_6, allowOptimization: closure_130_7, targetWidth: closure_130_8, targetHeight: closure_130_9 } = closure_0);
            closure_130_10 = undefined;
            closure_130_11 = undefined;
            closure_130_12 = undefined;
            closure_130_13 = undefined;
            closure_130_14 = undefined;
            closure_130_15 = undefined;
            closure_130_16 = undefined;
            closure_130_17 = undefined;
            closure_130_18 = undefined;
            closure_130_19 = undefined;
            c6 = 1;
            c7 = 1;
            return { value: "flex", done: null };
          }
        break;
        case 1:
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            c6 = 2;
            c7 = 1;
            const obj5 = {
              value: (function getPhotoKitDataUTI() {
                          const self = this;
                          const apply = closure_1_29.apply;
                          if (typeof apply === "unknown") {
                            let applyArgumentsResult = HermesBuiltin.applyArguments(self);
                          } else {
                            applyArgumentsResult = apply(self, arguments);
                          }
                          return applyArgumentsResult;
                        })(closure_130_0),
              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_130_10 = value;
            if ((function shouldConvertBase64ToJPG(str) {
              let isIOSResult = closure_1_0(1364).isIOS();
              if (isIOSResult) {
                isIOSResult = null != str.match(closure_1_20);
              }
              return isIOSResult;
            })(closure_130_0)) {
              const obj8 = { compressionQuality: closure_130_3 };
              c6 = 3;
              c7 = 1;
              const obj9 = { value: closure_131_26(closure_131_1(closure_131_2[16]).convertBase64ToJPEG, closure_130_0.replace(closure_131_20, ""), obj8), done: false };
              return obj9;
            } else if ((function shouldConvertBase64ToGIF(str) {
              let isIOSResult = closure_1_0(1364).isIOS();
              if (isIOSResult) {
                isIOSResult = null != str.match(closure_1_21);
              }
              return isIOSResult;
            })(closure_130_0)) {
              c6 = 4;
              c7 = 1;
              const obj10 = { value: closure_131_26(closure_131_1(closure_131_2[16]).convertBase64ToGIF, closure_130_0.replace(closure_131_21, ""), null), done: false };
              return obj10;
            } else if (closure_130_4) {
              c6 = 6;
              c7 = 1;
              const obj11 = {
                value: (function shouldConvertToPNG() {
                              const self = this;
                              const apply = closure_1_30.apply;
                              if (typeof apply === "unknown") {
                                let applyArgumentsResult = HermesBuiltin.applyArguments(self);
                              } else {
                                applyArgumentsResult = apply(self, arguments);
                              }
                              return applyArgumentsResult;
                            })(closure_130_0, closure_130_1),
                done: false
              };
              return obj11;
            } else {
              closure_130_13 = closure_131_0(closure_131_2[20]).shouldForceConvertToJPG(closure_130_0, closure_130_1, closure_130_10);
              if (!closure_130_13) {
                const obj16 = closure_131_0(closure_131_2[20]);
                if (!obj16.shouldConvertToJPG(closure_130_0, closure_130_1, closure_130_2, closure_130_4, closure_130_7)) {
                  if ((function shouldConvertToGifFilepath(str, str2) {
                    const isIOSResult = closure_1_0(1364).isIOS();
                    if (!isIOSResult) {
                      return isIOSResult;
                    } else {
                      if (tmpResult.isPhotoKitAsset(str, str2)) {
                        let match;
                        if (str2 != null) {
                          match = str2.match(/\.gif$/i);
                        }
                        let tmp7 = null != match;
                      } else {
                        tmp7 = null != str.match(/^assets-library:\/\/.+&ext=gif$/i);
                      }
                      tmpResult = closure_1_0(5657);
                    }
                  })(closure_130_0, closure_130_1)) {
                    c4 = 2;
                    c6 = 10;
                    c7 = 1;
                    const obj12 = { value: closure_131_1(closure_131_2[16]).convertToGIFFilePath(closure_130_0), done: false };
                    return obj12;
                  } else {
                    c7 = 3;
                    if (arg0 === 1) {
                      c7 = 3;
                      throw value;
                    } else if (arg0 === 2) {
                      c7 = 3;
                      const obj13 = { value, done: true };
                      return obj13;
                    } else {
                      closure_130_14 = value;
                      if (typeof closure_130_14 === "string") {
                        let path = closure_130_14;
                      } else if (closure_130_14 != null) {
                        path = closure_130_14.path;
                      }
                      closure_130_15 = path;
                      let encoderUsed;
                      if (closure_130_14 != null) {
                        encoderUsed = closure_130_14.encoderUsed;
                      }
                      closure_130_16 = encoderUsed;
                      let outputWidth;
                      if (closure_130_14 != null) {
                        outputWidth = closure_130_14.outputWidth;
                      }
                      closure_130_17 = outputWidth;
                      let outputHeight;
                      if (closure_130_14 != null) {
                        outputHeight = closure_130_14.outputHeight;
                      }
                      closure_130_18 = outputHeight;
                      let tmp25 = null;
                      if (null != closure_130_15) {
                        tmp25 = null;
                        if (closure_130_15.length > 0) {
                          const obj = { path: closure_130_15, encoderUsed: closure_130_16, outputWidth: closure_130_17, outputHeight: closure_130_18 };
                          tmp25 = obj;
                        }
                      }
                      c7 = 3;
                      const obj14 = { value: tmp25, done: true };
                      return obj14;
                    }
                  }
                }
              }
              const obj18 = { compressionQuality: closure_130_3, forceConvertToJPG: closure_130_13, useEnhancedConversion: closure_130_5, useJpegliEncoder: closure_130_6, targetWidth: closure_130_8, targetHeight: closure_130_9 };
              c6 = 8;
              c7 = 1;
              const obj19 = { value: closure_131_26(closure_131_1(closure_131_2[16]).convertToJPEG, closure_130_0, obj18), done: false };
              return obj19;
            }
          }
        break;
        case 3:
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj20 = { value, done: true };
            return obj20;
          } else {
            closure_130_11 = value;
            let tmp59 = null;
            if (null != closure_130_11) {
              tmp59 = null;
              if (closure_130_11.length > 0) {
                const obj21 = { path: closure_130_11, encoderUsed: closure_131_0(closure_131_2[33]).ImageEncoder.NATIVE };
                tmp59 = obj21;
              }
            }
            c7 = 3;
            const obj22 = { value: tmp59, done: true };
            return obj22;
          }
        break;
        case 4:
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj23 = { value, done: true };
            return obj23;
          } else {
            closure_130_12 = value;
            let tmp52 = null;
            if (null != closure_130_12) {
              tmp52 = null;
              if (closure_130_12.length > 0) {
                const obj24 = { path: closure_130_12 };
                tmp52 = obj24;
              }
            }
            c7 = 3;
            const obj25 = { value: tmp52, done: true };
            return obj25;
          }
        break;
        case 5:
          c4 = 0;
          closure_130_20 = closure_5;
          const _HermesInternal = HermesInternal;
          closure_131_19.error("getLosslessImageData failed, falling through to JPEG conversion: " + closure_130_20);
        break;
        case 6:
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 3;
            const obj26 = { value, done: true };
            return obj26;
          } else if (value) {
            c4 = 1;
            value = {};
            c6 = 7;
            c7 = 1;
            const obj27 = { value: closure_131_1(closure_131_2[16]).getLosslessImageData(closure_130_0), done: false };
            return obj27;
          }
        break;
        case 7:
          if (arg0 === 1) {
            c7 = 3;
            throw value;
          } else if (arg0 === 2) {
            c4 = 0;
            c7 = 3;
            const obj28 = { value, done: true };
            return obj28;
          } else {
            value.path = value;
            value.encoderUsed = closure_131_0(closure_131_2[33]).ImageEncoder.PASSTHROUGH;
            c4 = 0;
            c7 = 3;
            const obj29 = { value, done: true };
            return obj29;
          }
        break;
        case 8:
        break;
        case 9:
          c4 = 0;
          closure_130_21 = closure_5;
          closure_131_19.warn(closure_130_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 {
            closure_130_19 = value;
            let tmp125 = null;
            if (null != closure_130_19) {
              tmp125 = null;
              if (closure_130_19.length > 0) {
                const obj31 = { path: closure_130_19 };
                tmp125 = obj31;
              }
            }
            c4 = 0;
            c7 = 3;
            const obj32 = { value: tmp125, done: true };
            return obj32;
          }
      }
    } catch (tmp130) {
      closure_5 = tmp130;
      if (tmp4 === c4) {
        c7 = tmp2;
        throw tmp130;
      } else if (tmp === tmp132) {
        c6 = tmp6;
      } else {
        c6 = tmp5;
      }
    }
  }
};
let closure_39 = async function _fetchVideoMetadata(arg0, value) {
  if (c8 === 2) {
    c8 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp6 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c8 = 2;
      let warnResult = c7;
      if (0 === c7) {
        if (arg0 === 1) {
          c8 = 3;
          throw value;
        } else if (arg0 === 2) {
          c8 = 3;
          const obj3 = { value, done: true };
          return obj3;
        } else {
          closure_4 = tmp3;
          closure_131_0 = closure_0;
          closure_131_1 = undefined;
          warnResult = isVideo(closure_0, closure_1);
          if (warnResult) {
            c6 = 1;
            c7 = 2;
            c8 = 1;
            const obj4 = { value: mediaManager(NativeMediaManagerModuleDefault.getVideoMetadata, tmp31, null), done: false };
            return obj4;
          }
          tmp31 = closure_0;
        }
      } else if (1 === warnResult) {
        c6 = 0;
        closure_131_2 = closure_5;
        const obj5 = { uri: closure_131_0, error: closure_131_2 };
        warnResult = 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;
        const obj6 = { value, done: true };
        return obj6;
      } else {
        closure_131_1 = value;
        let rotationDegrees = closure_131_1.rotationDegrees;
        if (rotationDegrees == null) {
          rotationDegrees = 0;
        }
        closure_131_1.rotationDegrees = rotationDegrees;
        c6 = 0;
        c8 = 3;
        const obj = { value: closure_131_1, done: true };
        return obj;
      }
      c8 = 3;
    } catch (tmp23) {
      closure_5 = tmp23;
      if (tmp4 === c6) {
        c8 = tmp2;
        throw tmp23;
      } else {
        c7 = tmp;
      }
    }
  }
};
function getCaptionLabel(type, isVideo, playableDuration) {
  if (isVideo) {
    let str3 = "VIDEO";
    if (null != playableDuration.playableDuration) {
      str3 = utils_TimeUtils.getTimeFormat(playableDuration.playableDuration);
    }
    let str2 = str3;
  } else {
    str2 = null;
    if ("image/gif" === type) {
      str2 = "GIF";
    }
  }
  return str2;
}
function getImageDimensionsIfMissing(uri, arg1, arg2, c1) {
  const self = this;
  const apply = closure_40.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_40 = async function _getImageDimensionsIfMissing(arg0, width, height, arg3) {
  closure_0 = arg0;
  closure_3 = arg3;
  c8 = 0;
  c9 = 0;
  c7 = 0;
  return (async (arg0, value, arg2, arg3) => {
    if (c9 === 2) {
      c9 = 3;
      throw new TypeError("Generator functions may not be called on executing generators");
    } else if (tmp7 === 3) {
      if (arg0 === 1) {
        throw value;
      } else if (arg0 === 2) {
        const obj3 = { value, done: true };
        return obj3;
      } else {
        return { value: "HermesInternal", done: null };
      }
    } else {
      try {
        c9 = 2;
        if (0 === c8) {
          if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 === 2) {
            c9 = 3;
            const obj4 = { value, done: true };
            return obj4;
          } else {
            closure_5 = tmp3;
            closure_4 = tmp5;
            closure_132_0 = uri;
            closure_132_2 = undefined;
            closure_132_3 = undefined;
            let size = { width, height };
            closure_132_1 = size;
            if (null != width) {
              if (null != height) {
                c9 = 3;
                const obj5 = { value: size, done: true };
                return obj5;
              }
            }
            const obj7 = { uri, overrideFilename };
            const file = UploadUtils.getFile(obj7);
            closure_132_2 = file;
            if (!file.isImage) {
              if (!file.isVideo) {
                c9 = 3;
                const obj8 = { value: size, done: true };
                return obj8;
              }
            }
            c7 = 1;
            c8 = 2;
            c9 = 1;
            const obj9 = {
              value: (function getImageDimensionByUri(arg0) {
                        closure_0 = arg0;
                        return new Promise((arg0, arg1) => {
                          closure_0 = arg0;
                          return size.getSize(closure_0, (width, height) => {
                            size = { width, height };
                            return closure_0(size);
                          }, arg1);
                        });
                      })(uri),
              done: false
            };
            return obj9;
          }
        } else if (1 === tmp8) {
          c7 = 0;
          closure_132_4 = size;
          const _HermesInternal = HermesInternal;
          closure_133_19.warn("Unable to get width and height of media file: " + closure_132_0, closure_132_4);
          c9 = 3;
          const obj10 = { value: closure_132_1, done: true };
          return obj10;
        } else {
          if (2 === tmp8) {
            if (arg0 === 1) {
              c9 = 3;
              throw value;
            } else if (arg0 === 2) {
              c7 = 0;
              c9 = 3;
              const obj11 = { value, done: true };
              return obj11;
            } else {
              closure_132_3 = value;
              isVideo = closure_133_0(closure_133_2[13]).isIOS();
              if (isVideo) {
                isVideo = closure_132_2.isVideo;
              }
              if (isVideo) {
                isVideo = 0 === closure_132_3.width;
              }
              if (isVideo) {
                isVideo = 0 === closure_132_3.height;
              }
              if (isVideo) {
                c8 = 3;
                c9 = 1;
                const obj12 = { value: closure_133_1(closure_133_2[19]).getVideoDimensions(closure_132_0), done: false };
                return obj12;
              } else {
                c7 = 0;
                c9 = 3;
              }
              const obj13 = closure_133_0(closure_133_2[13]);
            }
          } else if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 !== 2) {
            closure_132_3 = value;
          }
          c7 = 0;
          c9 = 3;
          const obj = { value, done: true };
          return obj;
        }
      } catch (tmp34) {
        size = tmp34;
        if (tmp4 === c7) {
          c9 = tmp2;
          throw tmp34;
        } else {
          c8 = tmp;
        }
      }
    }
  })();
};
function checkVideoEncodingSupport(arg0) {
  const self = this;
  const apply = closure_42.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_42 = async function _checkVideoEncodingSupport(arg0, value) {
  if (c6 === 2) {
    c6 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp6 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c6 = 2;
      if (0 === c5) {
        if (arg0 === 1) {
          c6 = 3;
          throw value;
        } else if (arg0 === 2) {
          c6 = 3;
          const obj3 = { value, done: true };
          return obj3;
        } else {
          closure_2 = tmp3;
          closure_1 = tmp7;
          c4 = 1;
          const 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: NativeMediaManagerModuleDefault.isVideoEncodingSupported(size), done: false };
          return obj6;
        }
      } else if (1 === tmp7) {
        c4 = 0;
        closure_129_0 = closure_3;
        closure_130_19.warn("Error checking video encoding support:", closure_129_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;
        const obj = { value, done: true };
        return obj;
      }
    } catch (tmp18) {
      closure_3 = tmp18;
      if (tmp4 === c4) {
        c6 = tmp2;
        throw tmp18;
      } else {
        c5 = tmp;
      }
    }
  }
};
function calculateImageQualityMetrics(arg0, arg1, arg2, arg3, arg4) {
  const self = this;
  const apply = closure_44.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
}
let closure_44 = async function _calculateImageQualityMetrics(arg0, value) {
  if (c9 === 2) {
    c9 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp7 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    try {
      c9 = 2;
      if (0 === c8) {
        if (arg0 === 1) {
          c9 = 3;
          throw value;
        } else if (arg0 === 2) {
          c9 = 3;
          const obj4 = { value, done: true };
          return obj4;
        } else {
          closure_5 = tmp3;
          closure_4 = tmp5;
          closure_132_0 = closure_0;
          closure_132_1 = closure_1;
          closure_132_2 = closure_2;
          closure_132_4 = undefined;
          closure_132_5 = undefined;
          closure_132_6 = undefined;
          closure_132_3 = {};
          if (closure_3) {
            c7 = 1;
            c8 = 2;
            c9 = 1;
            const obj6 = { value: NativeMediaManagerModuleDefault.getMediaOrigin(tmp74), done: false };
            return obj6;
          }
        }
      } else {
        if (1 === tmp8) {
          c7 = 0;
          closure_132_7 = closure_6;
          closure_133_19.warn("Failed to detect media origin", closure_132_7);
        } else if (2 === tmp8) {
          if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 === 2) {
            c7 = 0;
            c9 = 3;
            const obj7 = { value, done: true };
            return obj7;
          } else {
            closure_132_4 = value;
            closure_132_3.origin = closure_132_4.source;
            c7 = 0;
          }
        } else {
          if (3 === tmp8) {
            c7 = 0;
            closure_132_8 = closure_6;
            closure_133_19.warn("Error in quality metrics calculation", closure_132_8);
          } else if (arg0 === 1) {
            c9 = 3;
            throw value;
          } else if (arg0 !== 2) {
            closure_132_6 = value;
            closure_132_3.psnr = closure_132_6.psnr;
            closure_132_3.ssim = closure_132_6.ssim;
            closure_132_3.psnrMeasurementLatencyMs = closure_132_6.psnrCalculationTimeMs;
            closure_132_3.ssimMeasurementLatencyMs = closure_132_6.ssimCalculationTimeMs;
            const _HermesInternal3 = HermesInternal;
            closure_133_19.log("Quality metrics calculated: PSNR=" + closure_132_6.psnr + "dB, SSIM=" + closure_132_6.ssim);
            c7 = 0;
          }
          c7 = 0;
          c9 = 3;
          const obj = { value, done: true };
          return obj;
        }
        c9 = 3;
      }
      if (closure_132_2) {
        c7 = 2;
        closure_132_5 = closure_132_1;
        if (closure_132_1.includes("://")) {
          c8 = 4;
          c9 = 1;
          const obj8 = { value: closure_133_1(closure_133_2[16]).calculateImageQualityMetrics(closure_132_0, closure_132_5), done: false };
          return obj8;
        } else {
          if (!closure_132_1.includes("/")) {
            if (!closure_132_1.includes("\\")) {
              const _HermesInternal = HermesInternal;
              if (closure_132_0.startsWith("ph://")) {
                let combined = concat(tmp39);
              } else {
                combined = concat(tmp39);
              }
            }
            closure_132_5 = combined;
          }
          const _HermesInternal2 = HermesInternal;
          combined = "file://" + closure_132_1;
        }
      }
    } catch (tmp52) {
      closure_6 = tmp52;
      if (tmp4 === c7) {
        c9 = tmp2;
        throw tmp52;
      } else if (tmp === tmp54) {
        c8 = tmp;
      } else {
        c8 = tmp2;
      }
    }
  }
};
let closure_3 = ["filename"];
const Image = fn(17).Image;
let UnsyncedUserSettingsStore = fn(1184);
({ VideoCompressionQuality: closure_7, VideoQualitySettings: closure_8 } = UnsyncedUserSettingsStore);
let UnsyncedUserSettingsStore = UnsyncedUserSettingsStore_mod;
const Constants = fn(1074);
({ Base64PNGPrefix: closure_12, Base64GIFPrefix } = Constants);
({ NetworkConnectionTypes: closure_14, CompressionQuality: closure_15, Base64WEBPPrefix: closure_16, Base64AVIFPrefix: closure_17, Base64JPEGPrefix } = Constants);
const NativePermissionTypes = fn(5054).NativePermissionTypes;
let closure_19 = new LoggerDefault("UploadUtils.tsx");
const regExp = new RegExp("^" + Base64JPEGPrefix, "i");
const regExp1 = new RegExp("^" + Base64GIFPrefix, "i");
const Canceled = "Canceled";
let size = fn(2);
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) {
    if (NetworkStore.getType() === constants3.CELLULAR) {
      let HIGH = constants4.LOW;
    }
    return HIGH;
  }
  HIGH = constants4.HIGH;
};
export { getVideoQuality };
export const resolveModeToVideoQualityForUserWithFeature = function resolveModeToVideoQualityForUserWithFeature(arg0) {
  if (constants2.DATA_SAVER === arg0) {
    return constants.LOW;
  } else if (tmp.STANDARD === arg0) {
    return constants.HIGH;
  } else if (tmp.BEST === arg0) {
    return constants.VERY_HIGH;
  } else {
    return constants.MEDIUM;
  }
};
export const resolveModeToVideoQualityForFreeUser = function resolveModeToVideoQualityForFreeUser(arg0) {
  if (constants2.DATA_SAVER === arg0) {
    return constants.LOW;
  } else if (tmp.STANDARD === arg0) {
    return constants.MEDIUM;
  } else if (tmp.BEST === arg0) {
    return constants.HIGH;
  } else {
    return constants.LOW;
  }
};
export const cancelGetFileInfo = function cancelGetFileInfo(item) {
  item = item.item;
  return new Promise((fn, arg1) => {
    if (obj.isAndroid()) {
      if (item.platform === Upload.UploadPlatform.REACT_NATIVE) {
        mediaManager(NativeMediaManagerModuleDefault.cancelResolveToMediaFilePath, item.uri, null).then(fn, arg1);
        const promise = mediaManager(NativeMediaManagerModuleDefault.cancelResolveToMediaFilePath, item.uri, null);
      }
    }
    fn();
  });
};
export const getFileSize = function getFileSize(uri) {
  let replaced = uri;
  if (obj.isIOS()) {
    replaced = uri.replace(/file:\/\//, "");
  }
  obj = PlatformUtils;
  return NativeFileModuleDefault.getSize(replaced);
};
export { getAppDir };
export { getFileInfo };
export const shouldConvertToJPG = fn(5657).shouldConvertToJPG;
export const shouldForceConvertToJPG = fn(5657).shouldForceConvertToJPG;
export const shouldResolveToMediaFilePath = function shouldResolveToMediaFilePath(str) {
  let isAndroidResult = PlatformUtils.isAndroid();
  if (isAndroidResult) {
    isAndroidResult = 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) {
  return UploadUtils.getFile({ uri: result1.uri, overrideFilename: result1.filename, overrideType: result1.mimeType });
};