// Module ID: 4126
// Function ID: 34313
// Name: _createForOfIteratorHelperLoose
// Dependencies: []
// Exports: createAnimatedThemedStyles, createLegacyClassComponentStyles, createNativeStyleProperties, createStyleProperties, createStyles, experimental_createToken, useLegacyClassComponentStyles

// Module 4126 (_createForOfIteratorHelperLoose)
function _createForOfIteratorHelperLoose(@@iterator) {
  let arg1 = Symbol_iterator;
  @@iterator = "undefined" !== typeof Symbol;
  if (Symbol_iterator) {
    const _Symbol = Symbol;
    @@iterator = Symbol_iterator[Symbol.iterator];
  }
  if (!Symbol_iterator) {
    @@iterator = Symbol_iterator[Symbol.iterator];
  }
  if (Symbol_iterator) {
    const iter = Symbol_iterator.call(Symbol_iterator);
    const next = iter.next;
    return next.bind(iter);
  } else {
    const _Array = Array;
    let tmp = Symbol_iterator;
    if (!Array.isArray(Symbol_iterator)) {
      let tmp2;
      if (Symbol_iterator) {
        if ("string" === typeof Symbol_iterator) {
          tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
        } else {
          const toString = {}.toString;
          const substr = toString.call(Symbol_iterator).slice(8, -1);
          let name = substr;
          if (tmp3) {
            name = Symbol_iterator.constructor.name;
          }
          if ("Map" !== name) {
            if ("Set" !== name) {
              if ("Arguments" === name) {
                let arr = _arrayLikeToArray(Symbol_iterator, undefined);
              } else {
                const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
              }
            }
            tmp2 = arr;
          }
          const _Array2 = Array;
          arr = Array.from(Symbol_iterator);
          const callResult = toString.call(Symbol_iterator);
          const tmp3 = "Object" === substr && Symbol_iterator.constructor;
        }
      }
      tmp = tmp2;
      if (!tmp2) {
        const _TypeError = TypeError;
        const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
        throw typeError;
      }
    }
    if (tmp) {
      arg1 = tmp;
    }
    let closure_1 = 0;
    return () => {
      if (closure_1 >= tmp.length) {
        let obj = { done: true };
      } else {
        obj = { done: false };
        closure_1 = tmp3 + 1;
        obj.value = tmp[+closure_1];
      }
      return obj;
    };
  }
}
function _arrayLikeToArray(arg0, arg1) {
  let length;
  if (tmp) {
    length = arg0.length;
  }
  const ArrayResult = Array(length);
  for (let num = 0; num < length; num = num + 1) {
    ArrayResult[num] = arg0[num];
  }
  return ArrayResult;
}
function createCacheKey(arg0) {
  const items = [...arguments];
  return items.join("");
}
function processColorOrThrow(arg0) {
  const tmp = processColor(arg0);
  if (null == tmp) {
    const _Error = Error;
    const _HermesInternal = HermesInternal;
    const error = new Error("Unable to parse color: \"" + arg0 + "\"");
    throw error;
  } else {
    return tmp;
  }
}
function parseThemedStyles(arg0, enabledExperiments) {
  let contrast;
  let saturation;
  let theme;
  ({ theme, saturation, contrast } = enabledExperiments);
  let obj = {};
  const keys = Object.keys();
  if (keys !== undefined) {
    while (keys[tmp] !== undefined) {
      let tmp32 = tmp8;
      let obj6 = arg0[tmp8];
      let hasOwnPropertyResult = null != obj6;
      if (hasOwnPropertyResult) {
        let tmp9 = closure_7;
        hasOwnPropertyResult = obj6.hasOwnProperty(closure_7);
      }
      let obj2 = obj6;
      if (hasOwnPropertyResult) {
        let tmp11 = closure_7;
        obj2 = obj6[closure_7](enabledExperiments);
      }
      if (null != obj2) {
        if (obj2.hasOwnProperty("resolve")) {
          obj = { theme };
          let tmp30 = enabledExperiments;
          let tmp31 = dependencyMap;
          let obj5 = enabledExperiments(dependencyMap[5]);
          obj.isAndroid = obj5.isAndroid();
          enabledExperiments = enabledExperiments.enabledExperiments;
          let items = enabledExperiments;
          if (null == enabledExperiments) {
            items = [];
          }
          obj.enabledExperiments = items;
          let density = enabledExperiments.density;
          let str4 = "compact";
          if (null != density) {
            str4 = density;
          }
          obj.density = str4;
          obj[tmp8] = obj2.resolve(obj);
          // continue
        }
      }
      let tmp12 = importDefault;
      let tmp13 = dependencyMap;
      let internal = importDefault(dependencyMap[6]).internal;
      if (internal.isSemanticColor(obj2)) {
        let tmp26 = enabledExperiments;
        let tmp27 = dependencyMap;
        let obj3 = enabledExperiments(dependencyMap[7]);
        let tmp29 = importDefault;
        let semanticColorContextFromThemeContext = obj3.getSemanticColorContextFromThemeContext(enabledExperiments);
        let internal4 = importDefault(dependencyMap[6]).internal;
        obj[tmp8] = internal4.resolveSemanticColor(theme, obj2, semanticColorContextFromThemeContext);
        // continue
      } else {
        if (tmp2) {
          let tmp14 = obj2;
          if ("string" === typeof obj2) {
            tmp14 = obj2;
            let tmp3 = tmp6;
            let tmp4 = tmp7;
            if ("#" === obj2[0]) {
              let str3 = "background";
              if ("backgroundColor" !== tmp8) {
                let str = "border";
                if ("borderColor" !== tmp8) {
                  let str2 = "generic";
                  if ("color" === tmp8) {
                    str2 = "text";
                  }
                  str = str2;
                }
                str3 = str;
              }
              let result = obj2;
              if (tmp2) {
                let tmp16 = importDefault;
                let tmp17 = dependencyMap;
                let internal2 = importDefault(dependencyMap[6]).internal;
                result = internal2.adjustColorSaturation(obj2, saturation, str3);
              }
              let adjustColorContrastResult = result;
              if (1 !== contrast) {
                let tmp19 = importDefault;
                let tmp20 = dependencyMap;
                let internal3 = importDefault(dependencyMap[6]).internal;
                let tmp21 = internal3;
                let tmp22 = result;
                let tmp23 = contrast;
                let tmp24 = str3;
                let tmp25 = theme;
                adjustColorContrastResult = internal3.adjustColorContrast(result, contrast, str3, theme);
              }
              tmp14 = adjustColorContrastResult;
              tmp3 = str3;
              tmp4 = adjustColorContrastResult;
            }
          }
        } else {
          tmp14 = obj2;
        }
        obj[tmp8] = tmp14;
        // continue
      }
      continue;
    }
  }
  return obj;
}
let closure_3 = importDefault(dependencyMap[0]);
const processColor = arg1(dependencyMap[1]).processColor;
let closure_5 = importDefault(dependencyMap[2]);
let closure_6 = importDefault(dependencyMap[3]);
new Set(["isArray", "x", "withSpring", "icon", "Array", "isArray", "push", "intl", "r", "isArray", "x", "context", "formatToPlainString", "Array", "isArray", "Path", "ti"]);
let closure_7 = Symbol.for("dynamicToken");
let closure_8 = [false, false, false];
let closure_9 = { code: "function createStylesTsx1(){const{resolvedStyles,withTiming,interpolateColor,themeIndex,stops,timingStandard}=this.__closure;const result={};for(const propertyName in resolvedStyles){const value=resolvedStyles[propertyName];if(Array.isArray(value)){result[propertyName]=withTiming(interpolateColor(themeIndex.get(),stops,value),timingStandard);}else{result[propertyName]=value;}}return result;}" };
const result = arg1(dependencyMap[13]).fileFinishedImporting("design/components/Styles/native/createStyles.tsx");

export const experimental_createToken = function experimental_createToken(arg0) {
  const arg1 = arg0;
  return { [closure_7]: (arg0) => arg0(arg0) };
};
export const createStyles = function createStyles(result) {
  const arg1 = result;
  const importDefault = new Map();
  let closure_2 = "function" === typeof result;
  return (arg0) => {
    const items = [...arguments];
    arg0 = items;
    let closure_2;
    let obj = arg0(closure_2[4]);
    const themeContext = obj.useThemeContext();
    const tmp2 = callback(...items, themeContext.key);
    const value = map.get(tmp2);
    if (null != value) {
      return value;
    } else {
      obj = {};
      closure_2 = obj;
      const _Object3 = Object;
      if (closure_2) {
        const items1 = [];
        HermesBuiltin.arraySpread(items, 0);
        keys = keys(HermesBuiltin.apply(items1, undefined));
      } else {
        keys = keys(tmp14);
      }
      const _Object = Object;
      const _Object2 = Object;
      Object.defineProperties(obj, Object.fromEntries(keys.map((arg0) => {
        let items = arg0;
        items = [arg0, ];
        const obj = {
          "Bool(true)": null,
          "Bool(true)": null,
          get() {
            if (closure_2) {
              const items = [];
              HermesBuiltin.arraySpread(arg0, 0);
              let applyResult = HermesBuiltin.apply(items, undefined);
            } else {
              applyResult = tmp2;
            }
            const tmpResult = closure_14(applyResult[closure_0], closure_1);
            Object.defineProperty(closure_2, arg0, { value: tmpResult, enumerable: true });
            return tmpResult;
          }
        };
        items[1] = obj;
        return items;
      })));
      const result = map.set(tmp2, obj);
      return obj;
    }
  };
};
export const createLegacyClassComponentStyles = function createLegacyClassComponentStyles(result) {
  const arg1 = result;
  const importDefault = new Map();
  return (key) => {
    const FALLBACK_THEME_CONTEXT_VALUE = key(closure_2[4]).FALLBACK_THEME_CONTEXT_VALUE;
    const value = map.get(key.key);
    if (null != value) {
      return value;
    } else {
      const obj = {};
      const _Object = Object;
      const keys = Object.keys(key);
      const _Object2 = Object;
      const _Object3 = Object;
      Object.defineProperties(obj, Object.fromEntries(keys.map((arg0) => {
        const items = [arg0, ];
        const obj = {
          "Bool(true)": null,
          "Bool(true)": null,
          get() {
            const tmp = callback(arg0[closure_0], arg0);
            Object.defineProperty(closure_1, arg0, { value: tmp, enumerable: true });
            return tmp;
          }
        };
        items[1] = obj;
        return items;
      })));
      const result = map.set(key.key, obj);
      return obj;
    }
  };
};
export const useLegacyClassComponentStyles = function useLegacyClassComponentStyles(closure_22) {
  return closure_22(arg1(dependencyMap[4]).useThemeContext());
};
export const createStyleProperties = function createStyleProperties(arg0) {
  const arg1 = arg0;
  const importDefault = new Map();
  return (arg0) => {
    const items = [...arguments];
    const themeContext = arg0(closure_2[4]).useThemeContext();
    const tmp2 = callback(...items, themeContext.key);
    const value = map.get(tmp2);
    if (null != value) {
      return value;
    } else {
      if ("function" === typeof arg0) {
        const items1 = [];
        HermesBuiltin.arraySpread(items, 0);
        let applyResult = HermesBuiltin.apply(items1, undefined);
      } else {
        applyResult = arg0;
      }
      const tmp4Result = closure_14(applyResult, themeContext);
      const result = map.set(tmp2, tmp4Result);
      return tmp4Result;
    }
    const obj = arg0(closure_2[4]);
  };
};
export { processColorOrThrow };
export const createNativeStyleProperties = function createNativeStyleProperties(arg0) {
  const arg1 = arg0;
  const importDefault = new Map();
  return (arg0, arg1) => {
    const substr = [...arguments].slice();
    let obj = arg0(closure_2[11]);
    let gradientPreset = obj.getCustomBackgroundGradient();
    if (null == gradientPreset) {
      gradientPreset = gradientPreset.gradientPreset;
    }
    let tmp3 = null;
    if (null != gradientPreset) {
      tmp3 = gradientPreset;
    }
    if (null == tmp3) {
      const items = [];
      if (obj3.isMobileVisualRefreshEnabled("createFakeThemedContext")) {
        items.push("mobile-visual-refresh");
      }
      let tmp14;
      if (items.length > 0) {
        tmp14 = items;
      }
      obj = {};
      const merged = Object.assign(arg0(closure_2[4]).FALLBACK_THEME_CONTEXT_VALUE);
      obj["flags"] = 0;
      obj["saturation"] = saturation.saturation;
      obj["theme"] = arg0;
      obj["enabledExperiments"] = tmp14;
      obj["gradient"] = tmp3;
      const _JSON = JSON;
      obj = {};
      const json = JSON.stringify(obj);
      const merged1 = Object.assign(obj);
      obj["key"] = json;
      const items1 = [];
      let arraySpreadResult = HermesBuiltin.arraySpread(substr, 0);
      items1[arraySpreadResult] = obj.key;
      const sum = arraySpreadResult + 1;
      const applyResult = HermesBuiltin.apply(items1, undefined);
      const value = map.get(applyResult);
      if (null != value) {
        return value;
      } else {
        let items2 = "function";
        if ("function" === typeof arg0) {
          items2 = [];
          arraySpreadResult = HermesBuiltin.arraySpread(substr, 0);
          let applyResult1 = HermesBuiltin.apply(items2, undefined);
        } else {
          applyResult1 = arg0;
        }
        const tmp46Result = closure_14(applyResult1, obj);
        for (const key10107 in tmp46Result) {
          let tmp48 = key10107;
          let tmp49 = closure_13;
          tmp46Result[key10107] = closure_13(tmp46Result[key10107]);
        }
        const result = map.set(applyResult, tmp46Result);
        return tmp46Result;
      }
      const obj3 = arg0(closure_2[12]);
    } else {
      if ("light" === tmp3.theme) {
        let MOBILE_DARK_GRADIENT_THEME_ENABLED = arg0(closure_2[4]).ThemeContextFlags.MOBILE_LIGHT_GRADIENT_THEME_ENABLED;
      } else {
        MOBILE_DARK_GRADIENT_THEME_ENABLED = arg0(closure_2[4]).ThemeContextFlags.MOBILE_DARK_GRADIENT_THEME_ENABLED;
      }
      arg0(closure_2[4]).setThemeFlag(0, MOBILE_DARK_GRADIENT_THEME_ENABLED);
      const obj2 = arg0(closure_2[4]);
    }
  };
};
export const createAnimatedThemedStyles = function createAnimatedThemedStyles(obj, items) {
  let arr = items;
  if (items === undefined) {
    arr = closure_8;
  }
  items = arr;
  let closure_3;
  let processColor;
  items = [];
  const importDefault = items;
  obj = {};
  const dependencyMap = obj;
  for (const key10008 in arg0) {
    let tmp3 = key10008;
    let tmp4 = arg0[key10008];
    let tmp5 = closure_1;
    let tmp6 = closure_2;
    let internal = closure_1(closure_2[6]).internal;
    if (internal.isSemanticColor(tmp4)) {
      let items1 = [key10008, tmp4];
      arr = items.push(items1);
      // continue
    } else {
      obj[key10008] = tmp4;
      // continue
    }
    continue;
  }
  closure_3 = arr.map((arg0, arg1) => arg1);
  processColor = new Map();
  return (themeIndex) => {
    let done;
    let obj = arr(obj[4]);
    const themeContext = obj.useThemeContext();
    const value = map.get(themeContext.key);
    let items = value;
    let tmp3 = value;
    if (null == value) {
      obj = {};
      let enabledExperiments = themeContext.enabledExperiments;
      if (null == enabledExperiments) {
        enabledExperiments = [];
      }
      obj.enabledExperiments = enabledExperiments;
      let num2 = 1;
      if (null == themeContext.primaryColor) {
        const saturation = themeContext.saturation;
        let num3 = 1;
        if (null != saturation) {
          num3 = saturation;
        }
        num2 = num3;
      }
      obj.saturation = num2;
      let num4 = 1;
      if (null == themeContext.primaryColor) {
        const contrast = themeContext.contrast;
        let num5 = 1;
        if (null != contrast) {
          num5 = contrast;
        }
        num4 = num5;
      }
      obj.contrast = num4;
      obj = {};
      const merged = Object.assign(obj);
      items = obj;
      function _loop(arg0) {
        obj[closure_3] = arg0.map((theme) => {
          const internal = callback(closure_2[6]).internal;
          return internal.resolveSemanticColor(theme, theme, closure_2);
        });
      }
      const tmp9 = callback(items);
      let iter = tmp9();
      if (!iter.done) {
        do {
          let tmp10 = closure_3;
          let tmp11 = closure_3(iter.value, 2);
          closure_3 = tmp11[0];
          let _loopResult = _loop(tmp11[1]);
          let iter2 = tmp9();
          iter = iter2;
          done = iter2.done;
        } while (!done);
      }
      const result = map.set(themeContext.key, obj);
      tmp3 = obj;
    }
    const fn = function _() {
      const obj = {};
      for (const key10008 in closure_4) {
        let tmp6 = key10008;
        let tmp7 = closure_4;
        let tmp8 = closure_4[key10008];
        let _Array = Array;
        if (Array.isArray(tmp8)) {
          let tmp = closure_0;
          let tmp2 = closure_2;
          let obj2 = closure_0(closure_2[9]);
          let obj3 = closure_0(closure_2[8]);
          let tmp3 = closure_0;
          let tmp4 = closure_3;
          let interpolateColorResult = obj3.interpolateColor(closure_0.get(), closure_3, tmp8);
          obj[key10008] = obj2.withTiming(interpolateColorResult, closure_0(closure_2[10]).timingStandard);
          // continue
        } else {
          obj[key10008] = tmp8;
          // continue
        }
        continue;
      }
      return obj;
    };
    const obj1 = { resolvedStyles: tmp3, withTiming: themeIndex(obj[9]).withTiming, interpolateColor: themeIndex(obj[8]).interpolateColor, themeIndex, stops: closure_3, timingStandard: themeIndex(obj[10]).timingStandard };
    fn.__closure = obj1;
    fn.__workletHash = 6815805628278;
    fn.__initData = closure_9;
    return themeIndex(obj[8]).useAnimatedStyle(fn);
  };
};