e510164e6b
Skipped 1 file(s) >100MB (GitHub limit): source/__polyfill/04xxx/module_4759.js (118.4 MB)
607 lines
20 KiB
JavaScript
607 lines
20 KiB
JavaScript
// Module ID: 8969
|
|
// Function ID: 8970
|
|
// Dependencies: [5, 8968, 8970, 8971]
|
|
|
|
// Module 8969
|
|
import _mod8968 from "module_8968" /* 8968 */;
|
|
import _mod8970 from "module_8970" /* 8970 */;
|
|
import _mod8971 from "module_8971" /* 8971 */;
|
|
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(_mod8968);
|
|
const fnResult = fn(_mod8970);
|
|
let hasOwnProperty = fnResult;
|
|
let closure_6 = fn(_mod8971);
|
|
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;
|
|
}
|