// Module ID: 9066
// Function ID: 9067
// Dependencies: [5, 9065, 9067, 9068]

// Module 9066
import _mod9065 from "module_9065" /* 9065 */;
import _mod9067 from "module_9067" /* 9067 */;
import _mod9068 from "module_9068" /* 9068 */;
import asyncGeneratorStep from "asyncGeneratorStep" /* 5 */;

let self = this;
let self2 = this;
if (this) {
  self2 = self.__createBinding;
}
if (self2) {
  let __setModuleDefault = self;
  if (self) {
    __setModuleDefault = self.__setModuleDefault;
  }
  if (__setModuleDefault) {
    let fn = self;
    if (self) {
      fn = self.__importStar;
    }
    if (!fn) {
      fn = (__esModule) => {
        if (__esModule) {
          if (__esModule.__esModule) {
            return __esModule;
          }
        }
        const obj = {};
        if (null != __esModule) {
          for (const key10009 in arg0) {
            let tmp9 = "default" !== key10009;
            if (!tmp9) {
              if (!tmp9) {
                continue;
              } else {
                let tmp6 = self2(obj, arg0, key10009);
                continue;
              }
              continue;
            } else {
              let _Object = Object;
              hasOwnProperty = Object.prototype.hasOwnProperty;
              let call = hasOwnProperty.call;
              if (typeof call === "unknown") {
                let hasOwnPropertyResult = hasOwnProperty(key10009);
              } else {
                hasOwnPropertyResult = call(arg0, key10009);
              }
            }
          }
        }
        __setModuleDefault(obj, __esModule);
        return obj;
      };
    }
    const _Object3 = Object;
    exports._parse = undefined;
    exports.parse = undefined;
    exports._parseAsync = undefined;
    exports.parseAsync = undefined;
    exports._safeParse = undefined;
    exports.safeParse = undefined;
    exports._safeParseAsync = undefined;
    exports.safeParseAsync = undefined;
    exports._encode = undefined;
    exports.encode = undefined;
    exports._decode = undefined;
    exports.decode = undefined;
    exports._encodeAsync = undefined;
    exports.encodeAsync = undefined;
    exports._decodeAsync = undefined;
    exports.decodeAsync = undefined;
    exports._safeEncode = undefined;
    exports.safeEncode = undefined;
    exports._safeDecode = undefined;
    exports.safeDecode = undefined;
    exports._safeEncodeAsync = undefined;
    exports.safeEncodeAsync = undefined;
    exports._safeDecodeAsync = undefined;
    exports.safeDecodeAsync = undefined;
    let closure_4 = fn(_mod9065);
    const fnResult = fn(_mod9067);
    let hasOwnProperty = fnResult;
    let closure_6 = fn(_mod9068);
    exports._parse = (arg0) => {
      closure_0 = arg0;
      return (_zod, value, arg2, Err) => {
        const obj = { async: false };
        if (arg2) {
          const _Object = Object;
          let merged = Object.assign(arg2, obj);
        } else {
          merged = obj;
        }
        _zod = _zod._zod;
        const iter = _zod.run({ value, issues: [] }, merged);
        if (iter instanceof Promise) {
          const ZodAsyncError = new closure_4.$ZodAsyncError();
          throw ZodAsyncError;
        } else if (iter.issues.length) {
          Err = undefined;
          if (Err != null) {
            Err = Err.Err;
          }
          if (Err == null) {
            Err = closure_0;
          }
          const issues = iter.issues;
          const err = new Err(issues.map((item) => closure_2_6.finalizeIssue(item, merged, closure_2_4.config())));
          let callee;
          if (Err != null) {
            callee = Err.callee;
          }
          closure_6.captureStackTrace(err, callee);
          throw err;
        } else {
          return iter.value;
        }
        const obj2 = { value, issues: [] };
      };
    };
    exports.parse = exports._parse(fnResult.$ZodRealError);
    exports._parseAsync = (arg0) => {
      let _zod = asyncGeneratorStep(async (arg0, value, arg2, arg3) => {
        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 {
          try {
            c8 = 2;
            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_6 = tmp4;
                closure_5 = tmp4;
                closure_133_0 = closure_3;
                closure_133_1 = undefined;
                closure_133_2 = undefined;
                closure_133_3 = undefined;
                const obj4 = { async: true };
                if (closure_2) {
                  const _Object = Object;
                  let merged = Object.assign(tmp39, obj4);
                } else {
                  merged = obj4;
                }
                closure_133_1 = merged;
                _zod = _zod._zod;
                const obj5 = { value, issues: [] };
                closure_133_2 = _zod.run(obj5, merged);
                if (closure_133_2 instanceof Promise) {
                  c7 = 1;
                  c8 = 1;
                  const obj6 = { value: closure_133_2, done: false };
                  return obj6;
                }
              }
            } else if (arg0 === 1) {
              c8 = 3;
              throw value;
            } else if (arg0 === 2) {
              c8 = 3;
              const obj = { value, done: true };
              return obj;
            } else {
              closure_133_2 = value;
            }
            if (closure_133_2.issues.length) {
              let Err;
              if (closure_133_0 != null) {
                Err = closure_133_0.Err;
              }
              closure_4 = Err;
              if (Err == null) {
                closure_4 = _zod;
              }
              const issues = closure_133_2.issues;
              const tmp24 = new closure_4(issues.map((item) => closure_6.finalizeIssue(item, closure_1_1, closure_4.config())));
              closure_133_3 = tmp24;
              let callee;
              if (closure_133_0 != null) {
                callee = closure_133_0.callee;
              }
              closure_2_6.captureStackTrace(closure_133_3, callee);
              throw closure_133_3;
            } else {
              c8 = 3;
              const obj7 = { value: closure_133_2.value, done: true };
              return obj7;
            }
          } catch (tmp32) {
            c8 = tmp;
            throw tmp32;
          }
        }
      });
      return function(arg0, arg1, arg2, arg3) {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
    };
    exports.parseAsync = exports._parseAsync(fnResult.$ZodRealError);
    exports._safeParse = (arg0) => {
      closure_0 = arg0;
      return (_zod, value, arg2) => {
        if (arg2) {
          const obj2 = {};
          const merged = Object.assign(arg2);
          obj2.async = false;
          let obj = obj2;
        } else {
          obj = { async: false };
        }
        _zod = _zod._zod;
        const iter = _zod.run({ value, issues: [] }, obj);
        if (iter instanceof Promise) {
          const ZodAsyncError = new closure_4.$ZodAsyncError();
          throw ZodAsyncError;
        } else {
          if (iter.issues.length) {
            let $ZodError = closure_0;
            if (closure_0 == null) {
              $ZodError = fnResult.$ZodError;
            }
            const obj4 = { success: false, error: null };
            const issues = iter.issues;
            const ZodError = new $ZodError(issues.map((item) => closure_2_6.finalizeIssue(item, obj, closure_2_4.config())));
            obj4.error = ZodError;
            let obj5 = obj4;
          } else {
            obj5 = { success: true, data: iter.value };
          }
          return obj5;
        }
        const obj3 = { value, issues: [] };
      };
    };
    exports.safeParse = exports._safeParse(fnResult.$ZodRealError);
    exports._safeParseAsync = (arg0) => {
      let _zod = asyncGeneratorStep(async (arg0, value, arg2) => {
        if (c6 === 2) {
          c6 = 3;
          throw new TypeError("Generator functions may not be called on executing generators");
        } else if (tmp3 === 3) {
          if (arg0 === 1) {
            throw value;
          } else if (arg0 === 2) {
            const obj2 = { value, done: true };
            return obj2;
          } else {
            return { value: "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_4 = tmp4;
                closure_3 = tmp4;
                closure_131_0 = undefined;
                closure_131_1 = undefined;
                const obj4 = { async: true };
                if (closure_2) {
                  const _Object = Object;
                  let merged = Object.assign(tmp29, obj4);
                } else {
                  merged = obj4;
                }
                closure_131_0 = merged;
                _zod = _zod._zod;
                const obj5 = { value, issues: [] };
                closure_131_1 = _zod.run(obj5, merged);
                if (closure_131_1 instanceof Promise) {
                  c5 = 1;
                  c6 = 1;
                  const obj6 = { value: closure_131_1, done: false };
                  return obj6;
                }
              }
            } else if (arg0 === 1) {
              c6 = 3;
              throw value;
            } else if (arg0 === 2) {
              c6 = 3;
              const obj = { value, done: true };
              return obj;
            } else {
              closure_131_1 = value;
            }
            if (closure_131_1.issues.length) {
              const obj7 = { success: false, error: null };
              const issues = closure_131_1.issues;
              const tmp19 = new _zod(issues.map((item) => c6.finalizeIssue(item, closure_1_0, closure_4.config())));
              obj7.error = tmp19;
            } else {
              { success: true, data: null }[1] = closure_131_1.value;
            }
            c6 = 3;
          } catch (tmp22) {
            c6 = tmp;
            throw tmp22;
          }
        }
      });
      return function(arg0, arg1, arg2) {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
    };
    exports.safeParseAsync = exports._safeParseAsync(fnResult.$ZodRealError);
    exports._encode = (arg0) => {
      closure_0 = arg0;
      return (arg0, arg1, arg2) => {
        const obj = { direction: "backward" };
        if (arg2) {
          const _Object = Object;
          let merged = Object.assign(arg2, obj);
        } else {
          merged = obj;
        }
        return exports._parse(closure_0)(arg0, arg1, merged);
      };
    };
    exports.encode = exports._encode(fnResult.$ZodRealError);
    exports._decode = (arg0) => {
      closure_0 = arg0;
      return (arg0, arg1, arg2) => exports._parse(closure_0)(arg0, arg1, arg2);
    };
    exports.decode = exports._decode(fnResult.$ZodRealError);
    exports._encodeAsync = (arg0) => {
      closure_0 = asyncGeneratorStep(async (arg0, arg1, arg2) => {
        let _parseAsync = arg0;
        closure_1 = arg1;
        closure_2 = arg2;
        c3 = 0;
        return (async (arg0, value, arg2) => {
          if (c3 === 2) {
            c3 = 3;
            throw new TypeError("Generator functions may not be called on executing generators");
          } else if (tmp3 === 3) {
            if (arg0 === 1) {
              throw value;
            } else if (arg0 === 2) {
              const obj = { value, done: true };
              return obj;
            } else {
              return { value: "HermesInternal", done: null };
            }
          } else {
            try {
              c3 = 2;
              if (arg0 === 1) {
                c3 = 3;
                throw value;
              } else if (arg0 === 2) {
                c3 = 3;
                const obj2 = { value, done: true };
                return obj2;
              } else {
                _parseAsync = { direction: "backward" };
                if (closure_2) {
                  const _Object = Object;
                  let merged = Object.assign(tmp6, _parseAsync);
                } else {
                  merged = _parseAsync;
                }
                _parseAsync = _parseAsync._parseAsync;
                _parseAsync(_parseAsync)(_parseAsync, closure_1, merged);
                c3 = 3;
              }
            } catch (tmp12) {
              c3 = tmp;
              throw tmp12;
            }
          }
        })();
      });
      return function(arg0, arg1, arg2) {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
    };
    exports.encodeAsync = exports._encodeAsync(fnResult.$ZodRealError);
    exports._decodeAsync = (arg0) => {
      closure_0 = asyncGeneratorStep(async (arg0, value, arg2) => {
        if (c3 === 2) {
          c3 = 3;
          throw new TypeError("Generator functions may not be called on executing generators");
        } else if (tmp3 === 3) {
          if (arg0 === 1) {
            throw value;
          } else if (arg0 === 2) {
            const obj2 = { value, done: true };
            return obj2;
          } else {
            return { value: "HermesInternal", done: null };
          }
        } else {
          try {
            c3 = 2;
            if (arg0 === 1) {
              c3 = 3;
              throw value;
            } else if (arg0 === 2) {
              c3 = 3;
              const obj3 = { value, done: true };
              return obj3;
            } else {
              c3 = 3;
              const obj = { value: closure_0._parseAsync(closure_0)(closure_0, closure_1, closure_2), done: true };
              return obj;
            }
          } catch (tmp9) {
            c3 = tmp;
            throw tmp9;
          }
        }
      });
      return function(arg0, arg1, arg2) {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
    };
    exports.decodeAsync = exports._decodeAsync(fnResult.$ZodRealError);
    exports._safeEncode = (arg0) => {
      closure_0 = arg0;
      return (arg0, arg1, arg2) => {
        const obj = { direction: "backward" };
        if (arg2) {
          const _Object = Object;
          let merged = Object.assign(arg2, obj);
        } else {
          merged = obj;
        }
        return exports._safeParse(closure_0)(arg0, arg1, merged);
      };
    };
    exports.safeEncode = exports._safeEncode(fnResult.$ZodRealError);
    exports._safeDecode = (arg0) => {
      closure_0 = arg0;
      return (arg0, arg1, arg2) => exports._safeParse(closure_0)(arg0, arg1, arg2);
    };
    exports.safeDecode = exports._safeDecode(fnResult.$ZodRealError);
    exports._safeEncodeAsync = (arg0) => {
      closure_0 = asyncGeneratorStep(async (arg0, arg1, arg2) => {
        let _safeParseAsync = arg0;
        closure_1 = arg1;
        closure_2 = arg2;
        c3 = 0;
        return (async (arg0, value, arg2) => {
          if (c3 === 2) {
            c3 = 3;
            throw new TypeError("Generator functions may not be called on executing generators");
          } else if (tmp3 === 3) {
            if (arg0 === 1) {
              throw value;
            } else if (arg0 === 2) {
              const obj = { value, done: true };
              return obj;
            } else {
              return { value: "HermesInternal", done: null };
            }
          } else {
            try {
              c3 = 2;
              if (arg0 === 1) {
                c3 = 3;
                throw value;
              } else if (arg0 === 2) {
                c3 = 3;
                const obj2 = { value, done: true };
                return obj2;
              } else {
                _safeParseAsync = { direction: "backward" };
                if (closure_2) {
                  const _Object = Object;
                  let merged = Object.assign(tmp6, _safeParseAsync);
                } else {
                  merged = _safeParseAsync;
                }
                _safeParseAsync = _safeParseAsync._safeParseAsync;
                _safeParseAsync(_safeParseAsync)(_safeParseAsync, closure_1, merged);
                c3 = 3;
              }
            } catch (tmp12) {
              c3 = tmp;
              throw tmp12;
            }
          }
        })();
      });
      return function(arg0, arg1, arg2) {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
    };
    exports.safeEncodeAsync = exports._safeEncodeAsync(fnResult.$ZodRealError);
    exports._safeDecodeAsync = (arg0) => {
      closure_0 = asyncGeneratorStep(async (arg0, value, arg2) => {
        if (c3 === 2) {
          c3 = 3;
          throw new TypeError("Generator functions may not be called on executing generators");
        } else if (tmp3 === 3) {
          if (arg0 === 1) {
            throw value;
          } else if (arg0 === 2) {
            const obj2 = { value, done: true };
            return obj2;
          } else {
            return { value: "HermesInternal", done: null };
          }
        } else {
          try {
            c3 = 2;
            if (arg0 === 1) {
              c3 = 3;
              throw value;
            } else if (arg0 === 2) {
              c3 = 3;
              const obj3 = { value, done: true };
              return obj3;
            } else {
              c3 = 3;
              const obj = { value: closure_0._safeParseAsync(closure_0)(closure_0, closure_1, closure_2), done: true };
              return obj;
            }
          } catch (tmp9) {
            c3 = tmp;
            throw tmp9;
          }
        }
      });
      return function(arg0, arg1, arg2) {
        const self = this;
        const apply = closure_0.apply;
        if (typeof apply === "unknown") {
          let applyArgumentsResult = HermesBuiltin.applyArguments(self);
        } else {
          applyArgumentsResult = apply(self, arguments);
        }
        return applyArgumentsResult;
      };
    };
    exports.safeDecodeAsync = exports._safeDecodeAsync(fnResult.$ZodRealError);
  } else {
    const _Object2 = Object;
  }
} else {
  let _Object = Object;
}