668 lines
21 KiB
JavaScript
668 lines
21 KiB
JavaScript
// Module ID: 12247
|
|
// Function ID: 12248
|
|
// Dependencies: [5, 12246, 12248, 12249]
|
|
|
|
// Module 12247
|
|
import asyncGeneratorStep from "asyncGeneratorStep";
|
|
|
|
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 tmp8 = key10009;
|
|
let tmp9 = "default" !== key10009;
|
|
if (!tmp9) {
|
|
if (!tmp9) {
|
|
continue;
|
|
} else {
|
|
let tmp5 = self2;
|
|
let tmp6 = self2(obj, arg0, key10009);
|
|
continue;
|
|
}
|
|
continue;
|
|
} else {
|
|
let _Object = Object;
|
|
let call = hasOwnProperty.call;
|
|
if (typeof call === "unknown") {
|
|
let hasOwnPropertyResult = hasOwnProperty(key10009);
|
|
} else {
|
|
hasOwnPropertyResult = call(arg0, key10009);
|
|
}
|
|
let tmp4 = hasOwnPropertyResult;
|
|
}
|
|
}
|
|
}
|
|
__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(require("_isNativeReflectConstruct"));
|
|
const fnResult = fn(require("toDotPath"));
|
|
let c5 = fnResult;
|
|
let closure_6 = fn(require("mergeDefs"));
|
|
exports._parse = (arg0) => {
|
|
let closure_0 = arg0;
|
|
return (_zod, value, arg2, Err) => {
|
|
let obj = { async: false };
|
|
if (arg2) {
|
|
const _Object = Object;
|
|
let merged = Object.assign(arg2, obj);
|
|
} else {
|
|
merged = obj;
|
|
}
|
|
_zod = _zod._zod;
|
|
obj = { value, issues: [] };
|
|
const iter = _zod.run(obj, merged);
|
|
if (iter instanceof Promise) {
|
|
const ZodAsyncError = new outer1_4.$ZodAsyncError();
|
|
throw ZodAsyncError;
|
|
} else if (iter.issues.length) {
|
|
Err = undefined;
|
|
if (Err != null) {
|
|
Err = Err.Err;
|
|
}
|
|
if (Err == null) {
|
|
Err = merged;
|
|
}
|
|
const issues = iter.issues;
|
|
const err = new Err(issues.map((path) => outer1_6.finalizeIssue(path, merged, outer1_4.config())));
|
|
let callee;
|
|
if (Err != null) {
|
|
callee = Err.callee;
|
|
}
|
|
outer1_6.captureStackTrace(err, callee);
|
|
throw err;
|
|
} else {
|
|
return iter.value;
|
|
}
|
|
};
|
|
};
|
|
exports.parse = exports._parse(fnResult.$ZodRealError);
|
|
exports._parseAsync = (arg0) => {
|
|
let closure_0 = arg0;
|
|
closure_0 = asyncGeneratorStep((arg0, arg1, arg2, arg3) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let closure_3 = arg3;
|
|
let c7 = 0;
|
|
let c8 = 0;
|
|
return (function*(arg0, arg1, arg2, arg3) {
|
|
if (c8 === 2) {
|
|
c8 = 3;
|
|
HermesBuiltin.throwTypeError();
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "T", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c8 = 2;
|
|
if (0 === c7) {
|
|
if (arg0 === 1) {
|
|
c8 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c8 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
let closure_6 = tmp4;
|
|
let closure_5 = tmp4;
|
|
let closure_0 = c3;
|
|
let merged;
|
|
let closure_2;
|
|
c3 = undefined;
|
|
const obj1 = { async: true };
|
|
if (closure_2) {
|
|
const _Object = Object;
|
|
merged = Object.assign(tmp40, obj1);
|
|
} else {
|
|
merged = obj1;
|
|
}
|
|
const _zod = closure_0._zod;
|
|
const obj2 = { value: null, issues: null };
|
|
obj2[0] = merged;
|
|
obj2[1] = [];
|
|
closure_2 = _zod.run(obj2, merged);
|
|
if (closure_2 instanceof Promise) {
|
|
c7 = 1;
|
|
c8 = 1;
|
|
const obj3 = { value: null, done: false };
|
|
obj3[0] = closure_2;
|
|
return obj3;
|
|
}
|
|
const tmp38 = closure_0;
|
|
const tmp39 = merged;
|
|
}
|
|
} else if (arg0 === 1) {
|
|
c8 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c8 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
closure_2 = arg1;
|
|
}
|
|
if (closure_2.issues.length) {
|
|
let Err;
|
|
if (closure_0 != null) {
|
|
Err = closure_0.Err;
|
|
}
|
|
let closure_4 = Err;
|
|
if (Err == null) {
|
|
closure_4 = closure_0;
|
|
}
|
|
const issues = closure_2.issues;
|
|
const tmp24 = new closure_4(issues.map((path) => tmp4.finalizeIssue(path, merged, closure_4.config())));
|
|
let closure_3 = tmp24;
|
|
let callee;
|
|
if (closure_0 != null) {
|
|
callee = closure_0.callee;
|
|
}
|
|
outer2_6.captureStackTrace(closure_3, callee);
|
|
throw closure_3;
|
|
} else {
|
|
c8 = 3;
|
|
const obj4 = { value: null, done: true };
|
|
obj4[0] = closure_2.value;
|
|
return obj4;
|
|
}
|
|
} 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) => {
|
|
let closure_0 = arg0;
|
|
return (_zod, value) => {
|
|
if (arg2) {
|
|
let obj = {};
|
|
const merged = Object.assign(arg2);
|
|
obj.async = false;
|
|
} else {
|
|
obj = { async: false };
|
|
}
|
|
_zod = _zod._zod;
|
|
obj = { value, issues: [] };
|
|
const iter = _zod.run(obj, obj);
|
|
if (iter instanceof Promise) {
|
|
const ZodAsyncError = new outer1_4.$ZodAsyncError();
|
|
throw ZodAsyncError;
|
|
} else {
|
|
if (iter.issues.length) {
|
|
let $ZodError = obj;
|
|
if (obj == null) {
|
|
$ZodError = outer1_5.$ZodError;
|
|
}
|
|
const obj1 = { success: false, error: null };
|
|
const issues = iter.issues;
|
|
const ZodError = new $ZodError(issues.map((path) => outer1_6.finalizeIssue(path, obj, outer1_4.config())));
|
|
obj1[1] = ZodError;
|
|
let obj2 = obj1;
|
|
} else {
|
|
obj2 = { success: true, data: null };
|
|
obj2[1] = iter.value;
|
|
}
|
|
return obj2;
|
|
}
|
|
};
|
|
};
|
|
exports.safeParse = exports._safeParse(fnResult.$ZodRealError);
|
|
exports._safeParseAsync = (arg0) => {
|
|
let closure_0 = arg0;
|
|
closure_0 = asyncGeneratorStep((arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let c5 = 0;
|
|
let c6 = 0;
|
|
return (function*(arg0, arg1, arg2) {
|
|
if (c6 === 2) {
|
|
c6 = 3;
|
|
HermesBuiltin.throwTypeError();
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "T", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c6 = 2;
|
|
if (0 === c5) {
|
|
if (arg0 === 1) {
|
|
c6 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c6 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
let closure_4 = tmp4;
|
|
let closure_3 = tmp4;
|
|
let merged;
|
|
let closure_1;
|
|
const obj1 = { async: true };
|
|
if (closure_2) {
|
|
const _Object = Object;
|
|
merged = Object.assign(tmp30, obj1);
|
|
} else {
|
|
merged = obj1;
|
|
}
|
|
const _zod = merged._zod;
|
|
const obj2 = { value: null, issues: null };
|
|
obj2[0] = closure_1;
|
|
obj2[1] = [];
|
|
closure_1 = _zod.run(obj2, merged);
|
|
if (closure_1 instanceof Promise) {
|
|
c5 = 1;
|
|
c6 = 1;
|
|
const obj3 = { value: null, done: false };
|
|
obj3[0] = closure_1;
|
|
return obj3;
|
|
}
|
|
const tmp28 = merged;
|
|
const tmp29 = closure_1;
|
|
}
|
|
} else if (arg0 === 1) {
|
|
c6 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c6 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
closure_1 = arg1;
|
|
}
|
|
if (closure_1.issues.length) {
|
|
const obj4 = { success: false, error: null };
|
|
const issues = closure_1.issues;
|
|
const tmp19 = new closure_0(issues.map((path) => c6.finalizeIssue(path, merged, tmp4.config())));
|
|
obj4[1] = tmp19;
|
|
} else {
|
|
{ success: true, data: null }[1] = closure_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) => {
|
|
let 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 closure_0._parse(closure_0)(arg0, arg1, merged);
|
|
};
|
|
};
|
|
exports.encode = exports._encode(fnResult.$ZodRealError);
|
|
exports._decode = (arg0) => {
|
|
let closure_0 = arg0;
|
|
return (arg0, arg1, arg2) => closure_0._parse(closure_0)(arg0, arg1, arg2);
|
|
};
|
|
exports.decode = exports._decode(fnResult.$ZodRealError);
|
|
exports._encodeAsync = (arg0) => {
|
|
let closure_0 = arg0;
|
|
closure_0 = asyncGeneratorStep((arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let c3 = 0;
|
|
return (function*(arg0, arg1, arg2) {
|
|
if (c3 === 2) {
|
|
c3 = 3;
|
|
HermesBuiltin.throwTypeError();
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "T", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c3 = 2;
|
|
if (arg0 === 1) {
|
|
c3 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c3 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
let _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;
|
|
const tmp4 = _parseAsync;
|
|
const tmp5 = closure_1;
|
|
}
|
|
} 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) => {
|
|
let closure_0 = arg0;
|
|
closure_0 = asyncGeneratorStep((arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let c3 = 0;
|
|
return (function*(arg0, arg1, arg2) {
|
|
if (c3 === 2) {
|
|
c3 = 3;
|
|
HermesBuiltin.throwTypeError();
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "T", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c3 = 2;
|
|
if (arg0 === 1) {
|
|
c3 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c3 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
c3 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = closure_0._parseAsync(closure_0)(closure_0, closure_1, closure_2);
|
|
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) => {
|
|
let 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 closure_0._safeParse(closure_0)(arg0, arg1, merged);
|
|
};
|
|
};
|
|
exports.safeEncode = exports._safeEncode(fnResult.$ZodRealError);
|
|
exports._safeDecode = (arg0) => {
|
|
let closure_0 = arg0;
|
|
return (arg0, arg1, arg2) => closure_0._safeParse(closure_0)(arg0, arg1, arg2);
|
|
};
|
|
exports.safeDecode = exports._safeDecode(fnResult.$ZodRealError);
|
|
exports._safeEncodeAsync = (arg0) => {
|
|
let closure_0 = arg0;
|
|
closure_0 = asyncGeneratorStep((arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let c3 = 0;
|
|
return (function*(arg0, arg1, arg2) {
|
|
if (c3 === 2) {
|
|
c3 = 3;
|
|
HermesBuiltin.throwTypeError();
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "T", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c3 = 2;
|
|
if (arg0 === 1) {
|
|
c3 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c3 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
let _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;
|
|
const tmp4 = _safeParseAsync;
|
|
const tmp5 = closure_1;
|
|
}
|
|
} 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) => {
|
|
let closure_0 = arg0;
|
|
closure_0 = asyncGeneratorStep((arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let c3 = 0;
|
|
return (function*(arg0, arg1, arg2) {
|
|
if (c3 === 2) {
|
|
c3 = 3;
|
|
HermesBuiltin.throwTypeError();
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "T", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c3 = 2;
|
|
if (arg0 === 1) {
|
|
c3 = 3;
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
c3 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
c3 = 3;
|
|
obj = { value: null, done: true };
|
|
obj[0] = closure_0._safeParseAsync(closure_0)(closure_0, closure_1, closure_2);
|
|
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;
|
|
}
|