// Module ID: 20
// Function ID: 21
// Dependencies: []
// Exports: cache, cacheSignal, cloneElement, createContext, createElement, createRef, forwardRef, isValidElement, lazy, memo, startTransition, unstable_useCacheRefresh, use, useActionState, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useEffectEvent, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useOptimistic, useReducer, useRef, useState, useSyncExternalStore, useTransition

// Module 20
class Component {
  constructor(arg0, arg1, arg2) {
    obj = { props: arg0, context: arg1, refs: closure_10 };
    tmp = arg2;
    if (!arg2) {
      tmp = closure_8;
    }
    obj.updater = tmp;
    return;
  }
  setState(arg0, arg1) {
    if (typeof arg0 !== "object") {
      if (typeof arg0 !== "function") {
        tmp3 = null;
        if (null != arg0) {
          tmp2 = globalThis;
          _Error = Error;
          str = "takes an object of state variables to update or a function which returns an object of state variables.";
          throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
        }
      }
    }
    updater = this.updater;
    enqueueSetStateResult = updater.enqueueSetState(this, arg0, arg1, "setState");
    return;
  }
  forceUpdate(arg0) {
    updater = this.updater;
    enqueueForceUpdateResult = updater.enqueueForceUpdate(this, arg0, "forceUpdate");
    return;
  }
}
class ComponentDummy {
  constructor() {
    return;
  }
}
class PureComponent {
  constructor(arg0, arg1, arg2) {
    obj = { props: arg0, context: arg1, refs: closure_10 };
    tmp = arg2;
    if (!arg2) {
      tmp = closure_8;
    }
    obj.updater = tmp;
    return;
  }
}
function noop() {

}
function mapIntoArray(element, items, arg2, arg3, fn) {
  let tmp = typeof element !== "undefined";
  if (typeof element !== "undefined") {
    tmp = typeof element !== "boolean";
  }
  let tmp2 = element;
  if (!tmp) {
    tmp2 = null;
  }
  let flag = true;
  if (null !== tmp2) {
    if ("bigint" !== typeof element) {
      if ("string" !== tmp4) {
        if ("number" !== tmp4) {
          flag = false;
          if ("object" === tmp4) {
            const $$typeof = tmp2.$$typeof;
            flag = true;
            if (_typeof !== $$typeof) {
              flag = true;
              if (closure_1 !== $$typeof) {
                flag = false;
                if (closure_6 === $$typeof) {
                  return mapIntoArray(tmp2._init(tmp2._payload), items, arg2, arg3, fn);
                }
              }
            }
          }
        }
      }
    }
    flag = true;
  }
  if (flag) {
    element = fn(tmp2);
    if ("" !== arg3) {
      if (isArray(element)) {
        mapIntoArray(element, items, `${arg3.replace(re15, "$&/")}/`, "", (arg0) => arg0);
      } else if (null != element) {
        let tmp51 = typeof element === "object";
        if (typeof element === "object") {
          tmp51 = null !== element;
        }
        if (tmp51) {
          tmp51 = element.$$typeof === _typeof;
        }
        let tmp52 = element;
        if (tmp51) {
          let str18 = "";
          if (null != element.key) {
            if (!tmp2) {
              const text = `${element.key}`;
              str18 = `${`${element.key}`.replace(re15, "$&/")}/`;
            } else {
              str18 = "";
            }
          }
          const _HermesInternal = HermesInternal;
          const props = element.props;
          const element1 = { $$typeof: _typeof, type: element.type, key: arg2 + str18 + arg3, ref: null, props: null };
          let tmp57 = null;
          if (undefined !== props.ref) {
            tmp57 = ref;
          }
          element1.ref = tmp57;
          element1.props = props;
          tmp52 = element1;
        }
        items.push(tmp52);
      }
      return 1;
    } else {
      if (typeof tmp2 === "object") {
        if (null !== tmp2) {
          const text1 = `.${tmp46}`;
        }
        const text2 = `${tmp2.key}`;
        c0 = { "=": "=0", ":": "=2" };
        let text3 = `$${`${tmp2.key}`.replace(/[=:]/g, (arg0) => _null[arg0])}`;
      }
      text3 = 0.toString(36);
    }
  } else {
    let str5 = ".";
    if ("" !== arg3) {
      str5 = `${arg3}:`;
    }
    if (isArray(tmp2)) {
      let num12 = 0;
      let num13 = 0;
      let num7 = 0;
      if (0 < tmp2.length) {
        while (true) {
          let tmp36 = tmp2[num12];
          if (typeof tmp36 === "object") {
            if (null !== tmp36) {
              if (null != tmp36.key) {
                let text4 = `${tmp36.key}`;
                c0 = { "=": "=0", ":": "=2" };
                let text5 = `$${`${tmp36.key}`.replace(/[=:]/g, (arg0) => _null[arg0])}`;
                num13 = num13 + tmp35(tmp36, items, arg2, str5 + `$${`${tmp36.key}`.replace(/[=:]/g, (arg0) => _null[arg0])}`, fn);
                num12 = num12 + 1;
                num7 = num13;
                if (num12 >= tmp2.length) {
                  break;
                }
              }
            }
          }
          text5 = num12.toString(36);
        }
      }
    } else {
      let tmp14 = null;
      if (!tmp3) {
        tmp14 = null;
        if (typeof tmp2 === "object") {
          let prop = iterator;
          if (iterator) {
            prop = tmp2[iterator];
          }
          if (!prop) {
            prop = tmp2[Symbol.iterator];
          }
          let tmp16 = null;
          if (typeof prop === "function") {
            tmp16 = prop;
          }
          tmp14 = tmp16;
        }
      }
      if (typeof tmp14 === "function") {
        const call = tmp14.call;
        const iter = typeof call === "unknown" ? tmp14() : call(tmp2);
        let iter2 = iter.next();
        let num5 = 0;
        let num6 = 0;
        num7 = 0;
        if (!iter2.done) {
          while (true) {
            let value3 = iter2.value;
            if (typeof value3 === "object") {
              if (null !== value3) {
                if (null != value3.key) {
                  let text6 = `${value2.key}`;
                  c0 = { "=": "=0", ":": "=2" };
                  let text7 = `$${`${value2.key}`.replace(/[=:]/g, (arg0) => _null[arg0])}`;
                  num5 = num5 + 1;
                  num6 = num6 + tmp26(value3, items, arg2, str5 + `$${`${value2.key}`.replace(/[=:]/g, (arg0) => _null[arg0])}`, fn);
                  let iter3 = iter.next();
                  iter2 = iter3;
                  num7 = num6;
                  if (iter3.done) {
                    break;
                  }
                }
              }
            }
            text7 = num5.toString(36);
          }
        }
      } else {
        num7 = 0;
        if (typeof element === "object") {
          if (typeof tmp2.then === "function") {
            c0 = tmp2;
            const status = tmp2.status;
            if ("fulfilled" === status) {
              value = tmp2.value;
            } else if ("rejected" === status) {
              throw tmp2.reason;
            } else {
              if (typeof tmp2.status === "string") {
                tmp2.then(noop, noop);
              } else {
                tmp2.status = "pending";
                tmp2.then((value) => {
                  if ("pending" === _null.status) {
                    tmp.status = "fulfilled";
                    tmp.value = value;
                  }
                }, (reason) => {
                  if ("pending" === _null.status) {
                    tmp.status = "rejected";
                    tmp.reason = reason;
                  }
                });
              }
              const status2 = tmp2.status;
              if ("fulfilled" === status2) {
                value = tmp2.value;
              } else if ("rejected" === status2) {
                throw tmp2.reason;
              } else {
                throw tmp2;
              }
            }
            return mapIntoArray(value, items, arg2, arg3, fn);
          } else {
            const _String = String;
            let StringResult = String(tmp2);
            if ("[object Object]" === StringResult) {
              const _Object = Object;
              const keys = Object.keys(tmp2);
              StringResult = `${"object with keys {" + obj.join(", ")}}`;
            }
            throw Error("Objects are not valid as a React child (found: " + StringResult + "). If you meant to render a collection of children, use an array instead.");
          }
        }
      }
    }
    return num7;
  }
}
function lazyInitializer(_status) {
  if (-1 === _status._status) {
    const _resultResult = _status._result();
    _resultResult.then((_result) => {
      let tmp2 = 0 !== _status._status;
      if (tmp2) {
        tmp2 = -1 !== tmp._status;
      }
      if (!tmp2) {
        tmp._status = 1;
        tmp._result = _result;
      }
    }, (_result) => {
      let tmp2 = 0 !== _status._status;
      if (tmp2) {
        tmp2 = -1 !== tmp._status;
      }
      if (!tmp2) {
        tmp._status = 2;
        tmp._result = _result;
      }
    });
    if (-1 === _status._status) {
      _status._status = 0;
      _status._result = _resultResult;
    }
  }
  if (1 === _status._status) {
    return _status._result.default;
  } else {
    throw _status._result;
  }
}
const _typeof = Symbol.for("react.transitional.element");
let closure_1 = Symbol.for("react.portal");
const forResult = Symbol.for("react.fragment");
const forResult1 = Symbol.for("react.strict_mode");
const _typeof2 = Symbol.for("react.consumer");
const _typeof3 = Symbol.for("react.context");
const _typeof4 = Symbol.for("react.forward_ref");
const forResult2 = Symbol.for("react.profiler");
const _typeof5 = Symbol.for("react.memo");
const _typeof6 = Symbol.for("react.lazy");
let closure_8 = {
  isMounted() {
    return false;
  },
  enqueueForceUpdate() {

  },
  enqueueReplaceState() {

  },
  enqueueSetState() {

  }
};
const refs = {};
Component.prototype.isReactComponent = {};
ComponentDummy.prototype = Component.prototype;
const forResult3 = Symbol.for("react.suspense");
const obj2 = Object.create(ComponentDummy.prototype);
PureComponent.prototype = obj2;
obj2.constructor = PureComponent;
assign(obj2, Component.prototype);
obj2.isPureReactComponent = true;
let obj = { H: null, A: null, T: null, S: null };
const re15 = /\/+/g;
let closure_18 = typeof reportError === "function" ? reportError : ((message) => {
  if (typeof window === "object") {
    const _window3 = window;
    if (typeof window.ErrorEvent === "function") {
      const _window = window;
      if (typeof message === "object") {
        if (null !== message) {
          if (typeof message.message === "string") {
            const _String2 = String;
            let StringResult = String(message.message);
          }
          obj = { bubbles: true, cancelable: true, message: StringResult, error: message };
          const tmp2 = new tmp("error", obj);
          const _window2 = window;
        }
      }
      const _String = String;
      StringResult = String(message);
    }
    const _console = console;
    console.error(message);
  }
  if (typeof process === "object") {
    const _process = process;
    if (typeof process.emit === "function") {
      const _process2 = process;
      process.emit("uncaughtException", message);
    }
  }
});
function isValidElement(icon) {
  let tmp = typeof icon === "object";
  if (typeof icon === "object") {
    tmp = null !== icon;
  }
  if (tmp) {
    tmp = icon.$$typeof === closure_0;
  }
  return tmp;
}
const merged = Object.assign({ c: null });
merged[0] = function c(arg0) {
  const H = obj.H;
  return H.useMemoCache(arg0);
};

export const Activity = Symbol.for("react.activity");
export const Children = {
  map: function mapChildren(element, arg1, arg2) {
    closure_0 = arg1;
    closure_1 = arg2;
    if (null == element) {
      return element;
    } else {
      const items = [];
      c2 = 0;
      mapIntoArray(element, items, "", "", (arg0) => {
        const call = f69410.call;
        closure_2 = tmp3 + 1;
        return typeof call === "unknown" ? f69410(arg0, +closure_2) : call(closure_1_1, arg0, +closure_2);
      });
      return items;
    }
  },
  forEach(element, arg1, arg2) {
    const f69408 = function() {
      const self = this;
      const apply = f69408.apply;
      if (typeof apply === "unknown") {
        HermesBuiltin.applyArguments(self);
      } else {
        apply(self, arguments);
      }
    };
    closure_1 = arg2;
    if (null != element) {
      c2 = 0;
      mapIntoArray(element, [], "", "", (arg0) => {
        const call = f69410.call;
        closure_2 = tmp3 + 1;
        return typeof call === "unknown" ? f69410(arg0, +closure_2) : call(closure_1_1, arg0, +closure_2);
      });
    }
  },
  count(element) {
    closure_0 = () => {
      closure_0 = closure_0 + 1;
    };
    if (null != element) {
      c2 = 0;
      mapIntoArray(element, [], "", "", (arg0) => {
        const call = f69410.call;
        closure_2 = tmp3 + 1;
        return typeof call === "unknown" ? f69410(arg0, +closure_2) : call(closure_1_1, arg0, +closure_2);
      });
    }
    return closure_0;
  },
  toArray(element) {
    const f69410 = (arg0) => arg0;
    let items1 = element;
    if (null != element) {
      const items = [];
      closure_2 = 0;
      mapIntoArray(element, items, "", "", (arg0) => {
        const call = f69410.call;
        closure_2 = tmp3 + 1;
        return typeof call === "unknown" ? f69410(arg0, +closure_2) : call(closure_1_1, arg0, +closure_2);
      });
      items1 = items;
    }
    if (!items1) {
      items1 = [];
    }
    return items1;
  },
  only(children) {
    let tmp = typeof children === "object";
    if (typeof children === "object") {
      tmp = null !== children;
    }
    if (tmp) {
      tmp = children.$$typeof === closure_0;
    }
    if (tmp) {
      return children;
    } else {
      const _Error = Error;
      throw Error("React.Children.only expected to receive a single React element child.");
    }
  }
};
export { Component };
export const Fragment = forResult;
export const Profiler = forResult2;
export { PureComponent };
export const StrictMode = forResult1;
export const Suspense = forResult3;
export const __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = obj;
export const __COMPILER_RUNTIME = merged;
export (arg0) => {
  closure_0 = arg0;
  return () => {
    const apply = closure_0.apply;
    if (typeof apply === "unknown") {
      let applyArgumentsResult = HermesBuiltin.applyArguments(null);
    } else {
      applyArgumentsResult = apply(null, arguments);
    }
    return applyArgumentsResult;
  };
}
export () => null
export const cloneElement = (props, key, children) => {
  if (null == props) {
    const _Error = Error;
    throw Error("The argument must be a React element, but you passed " + props + ".");
  } else {
    const tmp18 = assign({}, props.props);
    key = props.key;
    let tmp3 = key;
    if (null != key) {
      if (undefined !== key.key) {
        key = `${key.key}`;
      }
      tmp3 = key;
      const keys = Object.keys();
      if (keys !== undefined) {
        tmp3 = key;
        while (keys[tmp] !== undefined) {
          let tmp20 = hasOwnProperty;
          let call = hasOwnProperty.call;
          let tmp6 = typeof call === "unknown" ? tmp20(tmp5) : call(key, tmp5);
          let tmp7 = !tmp6;
          if (tmp6) {
            tmp7 = "key" === tmp5;
          }
          if (!tmp7) {
            tmp7 = "__self" === tmp5;
          }
          if (!tmp7) {
            tmp7 = "__source" === tmp5;
          }
          if (!tmp7) {
            let tmp8 = "ref" === tmp5 && undefined === key.ref;
            tmp7 = tmp8;
          }
          if (tmp7) {
            continue;
          } else {
            tmp18[tmp5] = key[tmp5];
            continue;
          }
          continue;
        }
      }
    }
    const diff = arguments.length - 2;
    if (1 === diff) {
      tmp18.children = children;
    } else if (1 < diff) {
      const _Array = Array;
      const ArrayResult = Array(diff);
      let num3 = 0;
      if (0 < diff) {
        do {
          ArrayResult[num3] = arguments[num3 + 2];
          num3 = num3 + 1;
        } while (num3 < diff);
      }
      tmp18.children = ArrayResult;
    }
    const element = { $$typeof: _typeof, type: props.type, key: tmp3, ref: null, props: null };
    let tmp14 = null;
    if (undefined !== tmp18.ref) {
      tmp14 = ref;
    }
    element.ref = tmp14;
    element.props = tmp18;
    return element;
  }
};
export const createContext = (_currentValue) => {
  _context = { $$typeof: _typeof3, _currentValue, _currentValue2: _currentValue, _threadCount: 0, Provider: _context, Consumer: { $$typeof: _typeof2, _context } };
  return _context;
};
export const createElement = (defaultProps, key, children) => {
  const props = {};
  let tmp2 = null;
  if (null != key) {
    let text = null;
    if (undefined !== key.key) {
      text = `${key.key}`;
    }
    tmp2 = text;
    const keys = Object.keys();
    if (keys !== undefined) {
      tmp2 = text;
      while (keys[tmp] !== undefined) {
        let tmp17 = hasOwnProperty;
        let call = hasOwnProperty.call;
        let tmp7 = (typeof call === "unknown" ? tmp17(tmp6) : call(key, tmp6)) && "key" !== tmp6 && "__self" !== tmp6 && "__source" !== tmp6;
        if (!tmp7) {
          continue;
        } else {
          props[tmp6] = key[tmp6];
          continue;
        }
        continue;
      }
    }
  }
  const diff = arguments.length - 2;
  if (1 === diff) {
    props.children = children;
  } else if (1 < diff) {
    const _Array = Array;
    const ArrayResult = Array(diff);
    let num = 0;
    if (0 < diff) {
      do {
        ArrayResult[num] = arguments[num + 2];
        num = num + 1;
      } while (num < diff);
    }
    props.children = ArrayResult;
  }
  if (defaultProps) {
    if (defaultProps.defaultProps) {
      defaultProps = defaultProps.defaultProps;
      const keys1 = Object.keys();
      if (keys1 !== undefined) {
        while (keys1[1] !== undefined) {
          if (undefined !== props[tmp14]) {
            continue;
          } else {
            props[tmp14] = defaultProps[tmp14];
            continue;
          }
          continue;
        }
      }
    }
  }
  const element = { $$typeof: _typeof, type: defaultProps, key: tmp2, ref: null, props: null };
  let tmp15 = null;
  if (undefined !== props.ref) {
    tmp15 = ref;
  }
  element.ref = tmp15;
  element.props = props;
  return element;
};
export () => ({ current: null })
export (render) => ({ $$typeof: _typeof4, render })
export { isValidElement };
export (_result) => {
  obj = { $$typeof: _typeof6, _payload: { _status: -1, _result }, _init: lazyInitializer };
  return obj;
}
export (type, arg1) => {
  obj = { $$typeof: _typeof5, type, compare: null };
  let tmp = null;
  if (undefined !== arg1) {
    tmp = arg1;
  }
  obj.compare = tmp;
  return obj;
}
export const startTransition = (fn) => {
  const T = {};
  T.T = T;
  try {
    const promise = fn();
    const S = tmp4.S;
    if (null !== S) {
      tmp6(T, promise);
    }
    let tmp12 = typeof promise === "object";
    if (typeof promise === "object") {
      tmp12 = null !== promise;
    }
    if (tmp12) {
      tmp12 = typeof promise.then === "function";
    }
    if (tmp12) {
      promise.then(noop, closure_18);
    }
    let tmp19 = null !== T;
    if (tmp19) {
      tmp19 = null !== T.types;
    }
    if (tmp19) {
      T.types = T.types;
    }
    tmp4.T = T;
  } catch (tmp20) {
    let tmp22 = null !== tmp;
    if (tmp22) {
      tmp22 = null !== tmp3.types;
    }
    if (tmp22) {
      tmp.types = tmp3.types;
    }
    tmp2.T = tmp;
    throw tmp20;
  }
};
export const unstable_useCacheRefresh = () => {
  const H = obj.H;
  return H.useCacheRefresh();
};
export const use = (arg0) => {
  const H = obj.H;
  return H.use(arg0);
};
export const useActionState = (arg0, arg1, arg2) => {
  const H = obj.H;
  return H.useActionState(arg0, arg1, arg2);
};
export const useCallback = (fn, items) => {
  const H = obj.H;
  return H.useCallback(fn, items);
};
export const useContext = (context) => {
  const H = obj.H;
  return H.useContext(context);
};
export () => {

}
export const useDeferredValue = (arg0, arg1) => {
  const H = obj.H;
  return H.useDeferredValue(arg0, arg1);
};
export const useEffect = (arg0, arg1) => {
  const H = obj.H;
  return H.useEffect(arg0, arg1);
};
export const useEffectEvent = (impl) => {
  const H = obj.H;
  return H.useEffectEvent(impl);
};
export const useId = () => {
  const H = obj.H;
  return H.useId();
};
export const useImperativeHandle = (ref, chatInputRefObjectCallback, items) => {
  const H = obj.H;
  return H.useImperativeHandle(ref, chatInputRefObjectCallback, items);
};
export const useInsertionEffect = (create, items) => {
  const H = obj.H;
  return H.useInsertionEffect(create, items);
};
export const useLayoutEffect = (create, items) => {
  const H = obj.H;
  return H.useLayoutEffect(create, items);
};
export const useMemo = (getNextRenewalDateLabel, items) => {
  const H = obj.H;
  return H.useMemo(getNextRenewalDateLabel, items);
};
export const useOptimistic = (arg0, arg1) => {
  const H = obj.H;
  return H.useOptimistic(arg0, arg1);
};
export const useReducer = (lastRenderedReducer, arg1, fn) => {
  const H = obj.H;
  return H.useReducer(lastRenderedReducer, arg1, fn);
};
export const useRef = (set) => {
  const H = obj.H;
  return H.useRef(set);
};
export const useState = (arg0) => {
  const H = obj.H;
  return H.useState(arg0);
};
export const useSyncExternalStore = (subscribe, get, get2) => {
  const H = obj.H;
  return H.useSyncExternalStore(subscribe, get, get2);
};
export const useTransition = () => {
  const H = obj.H;
  return H.useTransition();
};
export const version = "19.2.3";