decord/source/__helpers/11xxx/11364__pick.js

// Module ID: 11364
// Function ID: 11365
// Name: _pick
// Dependencies: [5, 17, 11361, 11359, 11365]
// Exports: pick

// Module 11364 (_pick)
import _mod11359 from "module_11359" /* 11359 */;
import _mod11361 from "module_11361" /* 11361 */;
import asyncGeneratorStep from "asyncGeneratorStep" /* 5 */;

require = fn;
let closure_3 = async function _pick(arg0, value) {
  if (c8 === 2) {
    c8 = 3;
    throw new TypeError("Generator functions may not be called on executing generators");
  } else if (tmp3 === 3) {
    if (arg0 === 1) {
      throw value;
    } else if (arg0 === 2) {
      const obj2 = { value, done: true };
      return obj2;
    } else {
      return { value: "HermesInternal", done: null };
    }
  } else {
    while (true) {
      c8 = 2;
      let tmp4 = c7;
      if (0 === c7) {
        if (arg0 === 1) {
          c8 = 3;
          throw value;
        } else if (arg0 === 2) {
          c8 = 3;
          let obj3 = { value, done: true };
          return obj3;
        } else {
          closure_4 = tmp;
          closure_3 = tmp4;
          let tmp44 = closure_0;
          closure_131_0 = undefined;
          closure_131_1 = undefined;
          closure_131_2 = undefined;
          let type1;
          if (closure_0 != null) {
            type1 = tmp44.type;
          }
          if (type1) {
            let _Array = Array;
            let fn = tmp44.type;
            if (Array.isArray(tmp44.type)) {
              let items = fn;
            } else {
              items = [fn];
            }
            let flatResult = items.flat();
            fn = (str) => str.trim();
            let mapped = flatResult.map(fn);
          } else {
            let items1 = [_mod11361.types.allFiles];
            let obj4 = { mode: "import", allowMultiSelection: false, allowVirtualFiles: false };
            let merged = Object.assign(tmp44);
            obj4.type = items1;
            closure_131_0 = obj4;
            let type = obj4.type;
            if (type.every((item) => typeof item === "string")) {
              if ("mode" in obj4) {
                let items2 = ["import", "open"];
                if (!items2.includes(obj4.mode)) {
                  let _TypeError2 = TypeError;
                  let tmp30 = new.target;
                  let tmp31 = new.target;
                  let typeError = new TypeError("Invalid mode option: " + obj4.mode);
                  throw typeError;
                }
              }
              let NativeDocumentPicker = _mod11359.NativeDocumentPicker;
              c7 = 1;
              c8 = 1;
              let obj5 = { value: NativeDocumentPicker.pick(obj4), done: false };
              return obj5;
            } else {
              let _TypeError = TypeError;
              let _HermesInternal = HermesInternal;
              let tmp26 = new.target;
              let tmp27 = new.target;
              let typeError1 = new TypeError("Unexpected type option in " + obj4.type + ", did you try using a DocumentPicker.types.* that does not exist?");
              throw typeError1;
            }
          }
        }
      } else if (1 === tmp4) {
        if (arg0 === 1) {
          c8 = 3;
          throw value;
        } else if (arg0 === 2) {
          c8 = 3;
          let obj6 = { value, done: true };
          return obj6;
        } else {
          closure_131_1 = value;
          closure_2 = closure_131_1;
          dependencyMap = closure_131_1[Symbol.iterator]();
          while (dependencyMap !== undefined) {
            closure_131_2 = tmp10;
            let obj = closure_132_0(closure_132_1[4]);
            closure_131_2.hasRequestedType = obj.safeValidate(closure_131_0.type, closure_131_2);
            c6 = 0;
            continue;
          }
          c8 = 3;
          let obj7 = { value: closure_131_1, done: true };
          return obj7;
        }
      } else {
        c6 = 0;
        dependencyMap.return();
        throw hasOwnProperty;
      }
    }
  }
};
const Platform = fn(17).Platform;

export const pick = function pick(arg0) {
  const self = this;
  const apply = closure_3.apply;
  if (typeof apply === "unknown") {
    let applyArgumentsResult = HermesBuiltin.applyArguments(self);
  } else {
    applyArgumentsResult = apply(self, arguments);
  }
  return applyArgumentsResult;
};