PHP WebShell
Текущая директория: /usr/lib/node_modules/bitgo/node_modules/valibot/dist
Просмотр файла: index.cjs
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
BIC_REGEX: () => BIC_REGEX,
CUID2_REGEX: () => CUID2_REGEX,
DECIMAL_REGEX: () => DECIMAL_REGEX,
EMAIL_REGEX: () => EMAIL_REGEX,
EMOJI_REGEX: () => EMOJI_REGEX,
HEXADECIMAL_REGEX: () => HEXADECIMAL_REGEX,
HEX_COLOR_REGEX: () => HEX_COLOR_REGEX,
IMEI_REGEX: () => IMEI_REGEX,
IPV4_REGEX: () => IPV4_REGEX,
IPV6_REGEX: () => IPV6_REGEX,
IP_REGEX: () => IP_REGEX,
ISO_DATE_REGEX: () => ISO_DATE_REGEX,
ISO_DATE_TIME_REGEX: () => ISO_DATE_TIME_REGEX,
ISO_TIMESTAMP_REGEX: () => ISO_TIMESTAMP_REGEX,
ISO_TIME_REGEX: () => ISO_TIME_REGEX,
ISO_TIME_SECOND_REGEX: () => ISO_TIME_SECOND_REGEX,
ISO_WEEK_REGEX: () => ISO_WEEK_REGEX,
MAC48_REGEX: () => MAC48_REGEX,
MAC64_REGEX: () => MAC64_REGEX,
MAC_REGEX: () => MAC_REGEX,
OCTAL_REGEX: () => OCTAL_REGEX,
ULID_REGEX: () => ULID_REGEX,
UUID_REGEX: () => UUID_REGEX,
ValiError: () => ValiError,
_addIssue: () => _addIssue,
_isLuhnAlgo: () => _isLuhnAlgo,
_isValidObjectKey: () => _isValidObjectKey,
_stringify: () => _stringify,
any: () => any,
array: () => array,
arrayAsync: () => arrayAsync,
awaitAsync: () => awaitAsync,
bic: () => bic,
bigint: () => bigint,
blob: () => blob,
boolean: () => boolean,
brand: () => brand,
bytes: () => bytes,
check: () => check,
checkAsync: () => checkAsync,
checkItems: () => checkItems,
config: () => config,
creditCard: () => creditCard,
cuid2: () => cuid2,
custom: () => custom,
customAsync: () => customAsync,
date: () => date,
decimal: () => decimal,
deleteGlobalConfig: () => deleteGlobalConfig,
deleteGlobalMessage: () => deleteGlobalMessage,
deleteSchemaMessage: () => deleteSchemaMessage,
deleteSpecificMessage: () => deleteSpecificMessage,
email: () => email,
emoji: () => emoji,
empty: () => empty,
endsWith: () => endsWith,
entriesFromList: () => entriesFromList,
enum: () => enum_,
enum_: () => enum_,
everyItem: () => everyItem,
excludes: () => excludes,
fallback: () => fallback,
fallbackAsync: () => fallbackAsync,
file: () => file,
filterItems: () => filterItems,
findItem: () => findItem,
finite: () => finite,
flatten: () => flatten,
forward: () => forward,
forwardAsync: () => forwardAsync,
function: () => function_,
function_: () => function_,
getDefault: () => getDefault,
getDefaults: () => getDefaults,
getDefaultsAsync: () => getDefaultsAsync,
getDotPath: () => getDotPath,
getFallback: () => getFallback,
getFallbacks: () => getFallbacks,
getFallbacksAsync: () => getFallbacksAsync,
getGlobalConfig: () => getGlobalConfig,
getGlobalMessage: () => getGlobalMessage,
getSchemaMessage: () => getSchemaMessage,
getSpecificMessage: () => getSpecificMessage,
hash: () => hash,
hexColor: () => hexColor,
hexadecimal: () => hexadecimal,
imei: () => imei,
includes: () => includes,
instance: () => instance,
integer: () => integer,
intersect: () => intersect,
intersectAsync: () => intersectAsync,
ip: () => ip,
ipv4: () => ipv4,
ipv6: () => ipv6,
is: () => is,
isOfKind: () => isOfKind,
isOfType: () => isOfType,
isValiError: () => isValiError,
isoDate: () => isoDate,
isoDateTime: () => isoDateTime,
isoTime: () => isoTime,
isoTimeSecond: () => isoTimeSecond,
isoTimestamp: () => isoTimestamp,
isoWeek: () => isoWeek,
keyof: () => keyof,
lazy: () => lazy,
lazyAsync: () => lazyAsync,
length: () => length,
literal: () => literal,
looseObject: () => looseObject,
looseObjectAsync: () => looseObjectAsync,
looseTuple: () => looseTuple,
looseTupleAsync: () => looseTupleAsync,
mac: () => mac,
mac48: () => mac48,
mac64: () => mac64,
map: () => map,
mapAsync: () => mapAsync,
mapItems: () => mapItems,
maxBytes: () => maxBytes,
maxLength: () => maxLength,
maxSize: () => maxSize,
maxValue: () => maxValue,
mimeType: () => mimeType,
minBytes: () => minBytes,
minLength: () => minLength,
minSize: () => minSize,
minValue: () => minValue,
multipleOf: () => multipleOf,
nan: () => nan,
never: () => never,
nonEmpty: () => nonEmpty,
nonNullable: () => nonNullable,
nonNullableAsync: () => nonNullableAsync,
nonNullish: () => nonNullish,
nonNullishAsync: () => nonNullishAsync,
nonOptional: () => nonOptional,
nonOptionalAsync: () => nonOptionalAsync,
normalize: () => normalize,
notBytes: () => notBytes,
notLength: () => notLength,
notSize: () => notSize,
notValue: () => notValue,
null: () => null_,
null_: () => null_,
nullable: () => nullable,
nullableAsync: () => nullableAsync,
nullish: () => nullish,
nullishAsync: () => nullishAsync,
number: () => number,
object: () => object,
objectAsync: () => objectAsync,
objectWithRest: () => objectWithRest,
objectWithRestAsync: () => objectWithRestAsync,
octal: () => octal,
omit: () => omit,
optional: () => optional,
optionalAsync: () => optionalAsync,
parse: () => parse,
parseAsync: () => parseAsync,
parser: () => parser,
parserAsync: () => parserAsync,
partial: () => partial,
partialAsync: () => partialAsync,
partialCheck: () => partialCheck,
partialCheckAsync: () => partialCheckAsync,
pick: () => pick,
picklist: () => picklist,
pipe: () => pipe,
pipeAsync: () => pipeAsync,
promise: () => promise,
rawCheck: () => rawCheck,
rawCheckAsync: () => rawCheckAsync,
rawTransform: () => rawTransform,
rawTransformAsync: () => rawTransformAsync,
readonly: () => readonly,
record: () => record,
recordAsync: () => recordAsync,
reduceItems: () => reduceItems,
regex: () => regex,
required: () => required,
requiredAsync: () => requiredAsync,
safeInteger: () => safeInteger,
safeParse: () => safeParse,
safeParseAsync: () => safeParseAsync,
safeParser: () => safeParser,
safeParserAsync: () => safeParserAsync,
set: () => set,
setAsync: () => setAsync,
setGlobalConfig: () => setGlobalConfig,
setGlobalMessage: () => setGlobalMessage,
setSchemaMessage: () => setSchemaMessage,
setSpecificMessage: () => setSpecificMessage,
size: () => size,
someItem: () => someItem,
sortItems: () => sortItems,
startsWith: () => startsWith,
strictObject: () => strictObject,
strictObjectAsync: () => strictObjectAsync,
strictTuple: () => strictTuple,
strictTupleAsync: () => strictTupleAsync,
string: () => string,
symbol: () => symbol,
toLowerCase: () => toLowerCase,
toMaxValue: () => toMaxValue,
toMinValue: () => toMinValue,
toUpperCase: () => toUpperCase,
transform: () => transform,
transformAsync: () => transformAsync,
trim: () => trim,
trimEnd: () => trimEnd,
trimStart: () => trimStart,
tuple: () => tuple,
tupleAsync: () => tupleAsync,
tupleWithRest: () => tupleWithRest,
tupleWithRestAsync: () => tupleWithRestAsync,
ulid: () => ulid,
undefined: () => undefined_,
undefined_: () => undefined_,
union: () => union,
unionAsync: () => unionAsync,
unknown: () => unknown,
unwrap: () => unwrap,
url: () => url,
uuid: () => uuid,
value: () => value,
variant: () => variant,
variantAsync: () => variantAsync,
void: () => void_,
void_: () => void_
});
module.exports = __toCommonJS(src_exports);
// src/actions/await/awaitAsync.ts
function awaitAsync() {
return {
kind: "transformation",
type: "await",
reference: awaitAsync,
async: true,
async _run(dataset) {
dataset.value = await dataset.value;
return dataset;
}
};
}
// src/regex.ts
var BIC_REGEX = /^[A-Z]{6}(?!00)[A-Z\d]{2}(?:[A-Z\d]{3})?$/u;
var CUID2_REGEX = /^[a-z][\da-z]*$/u;
var DECIMAL_REGEX = /^\d+$/u;
var EMAIL_REGEX = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
var EMOJI_REGEX = /^[\p{Extended_Pictographic}\p{Emoji_Component}]+$/u;
var HEXADECIMAL_REGEX = /^(?:0h|0x)?[\da-f]+$/iu;
var HEX_COLOR_REGEX = /^#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu;
var IMEI_REGEX = /^\d{15}$|^\d{2}-\d{6}-\d{6}-\d$/u;
var IPV4_REGEX = (
// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive
/^(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])(?:\.(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])){3}$/u
);
var IPV6_REGEX = /^(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:|(?:[\da-f]{1,4}:){1,6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,5}(?::[\da-f]{1,4}){1,2}|(?:[\da-f]{1,4}:){1,4}(?::[\da-f]{1,4}){1,3}|(?:[\da-f]{1,4}:){1,3}(?::[\da-f]{1,4}){1,4}|(?:[\da-f]{1,4}:){1,2}(?::[\da-f]{1,4}){1,5}|[\da-f]{1,4}:(?::[\da-f]{1,4}){1,6}|:(?:(?::[\da-f]{1,4}){1,7}|:)|fe80:(?::[\da-f]{0,4}){0,4}%[\da-z]+|::(?:f{4}(?::0{1,4})?:)?(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d)|(?:[\da-f]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d))$/iu;
var IP_REGEX = /^(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])(?:\.(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])){3}$|^(?:(?:[\da-f]{1,4}:){7}[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,7}:|(?:[\da-f]{1,4}:){1,6}:[\da-f]{1,4}|(?:[\da-f]{1,4}:){1,5}(?::[\da-f]{1,4}){1,2}|(?:[\da-f]{1,4}:){1,4}(?::[\da-f]{1,4}){1,3}|(?:[\da-f]{1,4}:){1,3}(?::[\da-f]{1,4}){1,4}|(?:[\da-f]{1,4}:){1,2}(?::[\da-f]{1,4}){1,5}|[\da-f]{1,4}:(?::[\da-f]{1,4}){1,6}|:(?:(?::[\da-f]{1,4}){1,7}|:)|fe80:(?::[\da-f]{0,4}){0,4}%[\da-z]+|::(?:f{4}(?::0{1,4})?:)?(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d)|(?:[\da-f]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1?\d)?\d)\.){3}(?:25[0-5]|(?:2[0-4]|1?\d)?\d))$/iu;
var ISO_DATE_REGEX = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])$/u;
var ISO_DATE_TIME_REGEX = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])T(?:0\d|1\d|2[0-3]):[0-5]\d$/u;
var ISO_TIME_REGEX = /^(?:0\d|1\d|2[0-3]):[0-5]\d$/u;
var ISO_TIME_SECOND_REGEX = /^(?:0\d|1\d|2[0-3])(?::[0-5]\d){2}$/u;
var ISO_TIMESTAMP_REGEX = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])T(?:0\d|1\d|2[0-3])(?::[0-5]\d){2}(?:\.\d{1,9})?(?:Z|[+-](?:0\d|1\d|2[0-3])(?::?[0-5]\d)?)$/u;
var ISO_WEEK_REGEX = /^\d{4}-W(?:0[1-9]|[1-4]\d|5[0-3])$/u;
var MAC48_REGEX = /^(?:[\da-f]{2}:){5}[\da-f]{2}$|^(?:[\da-f]{2}-){5}[\da-f]{2}$|^(?:[\da-f]{4}\.){2}[\da-f]{4}$/iu;
var MAC64_REGEX = /^(?:[\da-f]{2}:){7}[\da-f]{2}$|^(?:[\da-f]{2}-){7}[\da-f]{2}$|^(?:[\da-f]{4}\.){3}[\da-f]{4}$|^(?:[\da-f]{4}:){3}[\da-f]{4}$/iu;
var MAC_REGEX = /^(?:[\da-f]{2}:){5}[\da-f]{2}$|^(?:[\da-f]{2}-){5}[\da-f]{2}$|^(?:[\da-f]{4}\.){2}[\da-f]{4}$|^(?:[\da-f]{2}:){7}[\da-f]{2}$|^(?:[\da-f]{2}-){7}[\da-f]{2}$|^(?:[\da-f]{4}\.){3}[\da-f]{4}$|^(?:[\da-f]{4}:){3}[\da-f]{4}$/iu;
var OCTAL_REGEX = /^(?:0o)?[0-7]+$/iu;
var ULID_REGEX = /^[\da-hjkmnp-tv-z]{26}$/iu;
var UUID_REGEX = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu;
// src/storages/globalConfig/globalConfig.ts
var store;
function setGlobalConfig(config2) {
store = { ...store, ...config2 };
}
function getGlobalConfig(config2) {
return {
lang: config2?.lang ?? store?.lang,
message: config2?.message,
abortEarly: config2?.abortEarly ?? store?.abortEarly,
abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
};
}
function deleteGlobalConfig() {
store = void 0;
}
// src/storages/globalMessage/globalMessage.ts
var store2;
function setGlobalMessage(message, lang) {
if (!store2) store2 = /* @__PURE__ */ new Map();
store2.set(lang, message);
}
function getGlobalMessage(lang) {
return store2?.get(lang);
}
function deleteGlobalMessage(lang) {
store2?.delete(lang);
}
// src/storages/schemaMessage/schemaMessage.ts
var store3;
function setSchemaMessage(message, lang) {
if (!store3) store3 = /* @__PURE__ */ new Map();
store3.set(lang, message);
}
function getSchemaMessage(lang) {
return store3?.get(lang);
}
function deleteSchemaMessage(lang) {
store3?.delete(lang);
}
// src/storages/specificMessage/specificMessage.ts
var store4;
function setSpecificMessage(reference, message, lang) {
if (!store4) store4 = /* @__PURE__ */ new Map();
if (!store4.get(reference)) store4.set(reference, /* @__PURE__ */ new Map());
store4.get(reference).set(lang, message);
}
function getSpecificMessage(reference, lang) {
return store4?.get(reference)?.get(lang);
}
function deleteSpecificMessage(reference, lang) {
store4?.get(reference)?.delete(lang);
}
// src/utils/_stringify/_stringify.ts
function _stringify(input) {
const type = typeof input;
if (type === "string") {
return `"${input}"`;
}
if (type === "number" || type === "bigint" || type === "boolean") {
return `${input}`;
}
if (type === "object" || type === "function") {
return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
}
return type;
}
// src/utils/_addIssue/_addIssue.ts
function _addIssue(context, label, dataset, config2, other) {
const input = other && "input" in other ? other.input : dataset.value;
const expected = other?.expected ?? context.expects ?? null;
const received = other?.received ?? _stringify(input);
const issue = {
kind: context.kind,
type: context.type,
input,
expected,
received,
message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
// @ts-expect-error
requirement: context.requirement,
path: other?.path,
issues: other?.issues,
lang: config2.lang,
abortEarly: config2.abortEarly,
abortPipeEarly: config2.abortPipeEarly
};
const isSchema = context.kind === "schema";
const message = other?.message ?? // @ts-expect-error
context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
if (message) {
issue.message = typeof message === "function" ? message(issue) : message;
}
if (isSchema) {
dataset.typed = false;
}
if (dataset.issues) {
dataset.issues.push(issue);
} else {
dataset.issues = [issue];
}
}
// src/utils/_isLuhnAlgo/_isLuhnAlgo.ts
var NON_DIGIT_REGEX = /\D/gu;
function _isLuhnAlgo(input) {
const number2 = input.replace(NON_DIGIT_REGEX, "");
let length2 = number2.length;
let bit = 1;
let sum = 0;
while (length2) {
const value2 = +number2[--length2];
bit ^= 1;
sum += bit ? [0, 2, 4, 6, 8, 1, 3, 5, 7, 9][value2] : value2;
}
return sum % 10 === 0;
}
// src/utils/_isValidObjectKey/_isValidObjectKey.ts
function _isValidObjectKey(object2, key) {
return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
}
// src/utils/entriesFromList/entriesFromList.ts
function entriesFromList(list, schema) {
const entries = {};
for (const key of list) {
entries[key] = schema;
}
return entries;
}
// src/utils/getDotPath/getDotPath.ts
function getDotPath(issue) {
if (issue.path) {
let key = "";
for (const item of issue.path) {
if (typeof item.key === "string" || typeof item.key === "number") {
if (key) {
key += `.${item.key}`;
} else {
key += item.key;
}
} else {
return null;
}
}
return key;
}
return null;
}
// src/utils/isOfKind/isOfKind.ts
function isOfKind(kind, object2) {
return object2.kind === kind;
}
// src/utils/isOfType/isOfType.ts
function isOfType(type, object2) {
return object2.type === type;
}
// src/utils/isValiError/isValiError.ts
function isValiError(error) {
return error instanceof ValiError;
}
// src/utils/ValiError/ValiError.ts
var ValiError = class extends Error {
/**
* The error issues.
*/
issues;
/**
* Creates a Valibot error with useful information.
*
* @param issues The error issues.
*/
constructor(issues) {
super(issues[0].message);
this.name = "ValiError";
this.issues = issues;
}
};
// src/actions/bic/bic.ts
function bic(message) {
return {
kind: "validation",
type: "bic",
reference: bic,
async: false,
expects: null,
requirement: BIC_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "BIC", dataset, config2);
}
return dataset;
}
};
}
// src/actions/brand/brand.ts
function brand(name) {
return {
kind: "transformation",
type: "brand",
reference: brand,
async: false,
name,
_run(dataset) {
return dataset;
}
};
}
// src/actions/bytes/bytes.ts
function bytes(requirement, message) {
return {
kind: "validation",
type: "bytes",
reference: bytes,
async: false,
expects: `${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed) {
const length2 = new TextEncoder().encode(dataset.value).length;
if (length2 !== this.requirement) {
_addIssue(this, "bytes", dataset, config2, {
received: `${length2}`
});
}
}
return dataset;
}
};
}
// src/actions/check/check.ts
function check(requirement, message) {
return {
kind: "validation",
type: "check",
reference: check,
async: false,
expects: null,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "input", dataset, config2);
}
return dataset;
}
};
}
// src/actions/check/checkAsync.ts
function checkAsync(requirement, message) {
return {
kind: "validation",
type: "check",
reference: checkAsync,
async: true,
expects: null,
requirement,
message,
async _run(dataset, config2) {
if (dataset.typed && !await this.requirement(dataset.value)) {
_addIssue(this, "input", dataset, config2);
}
return dataset;
}
};
}
// src/actions/checkItems/checkItems.ts
function checkItems(requirement, message) {
return {
kind: "validation",
type: "check_items",
reference: checkItems,
async: false,
expects: null,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed) {
for (let index = 0; index < dataset.value.length; index++) {
const item = dataset.value[index];
if (!this.requirement(item, index, dataset.value)) {
_addIssue(this, "item", dataset, config2, {
input: item,
path: [
{
type: "array",
origin: "value",
input: dataset.value,
key: index,
value: item
}
]
});
}
}
}
return dataset;
}
};
}
// src/actions/creditCard/creditCard.ts
var CREDIT_CARD_REGEX = /^(?:\d{14,19}|\d{4}(?: \d{3,6}){2,4}|\d{4}(?:-\d{3,6}){2,4})$/u;
var SANITIZE_REGEX = /[- ]/gu;
var PROVIDER_REGEX_LIST = [
// American Express
/^3[47]\d{13}$/u,
// Diners Club
/^3(?:0[0-5]|[68]\d)\d{11,13}$/u,
// Discover
/^6(?:011|5\d{2})\d{12,15}$/u,
// JCB
/^(?:2131|1800|35\d{3})\d{11}$/u,
// Mastercard
/^5[1-5]\d{2}|(?:222\d|22[3-9]\d|2[3-6]\d{2}|27[01]\d|2720)\d{12}$/u,
// UnionPay
/^(?:6[27]\d{14,17}|81\d{14,17})$/u,
// Visa
/^4\d{12}(?:\d{3,6})?$/u
];
function creditCard(message) {
return {
kind: "validation",
type: "credit_card",
reference: creditCard,
async: false,
expects: null,
requirement(input) {
let sanitized;
return CREDIT_CARD_REGEX.test(input) && // Remove any hyphens and blanks
(sanitized = input.replace(SANITIZE_REGEX, "")) && // Check if it matches a provider
PROVIDER_REGEX_LIST.some((regex2) => regex2.test(sanitized)) && // Check if passes luhn algorithm
_isLuhnAlgo(sanitized);
},
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "credit card", dataset, config2);
}
return dataset;
}
};
}
// src/actions/cuid2/cuid2.ts
function cuid2(message) {
return {
kind: "validation",
type: "cuid2",
reference: cuid2,
async: false,
expects: null,
requirement: CUID2_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "Cuid2", dataset, config2);
}
return dataset;
}
};
}
// src/actions/decimal/decimal.ts
function decimal(message) {
return {
kind: "validation",
type: "decimal",
reference: decimal,
async: false,
expects: null,
requirement: DECIMAL_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "decimal", dataset, config2);
}
return dataset;
}
};
}
// src/actions/email/email.ts
function email(message) {
return {
kind: "validation",
type: "email",
reference: email,
expects: null,
async: false,
requirement: EMAIL_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "email", dataset, config2);
}
return dataset;
}
};
}
// src/actions/emoji/emoji.ts
function emoji(message) {
return {
kind: "validation",
type: "emoji",
reference: emoji,
async: false,
expects: null,
requirement: EMOJI_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "emoji", dataset, config2);
}
return dataset;
}
};
}
// src/actions/empty/empty.ts
function empty(message) {
return {
kind: "validation",
type: "empty",
reference: empty,
async: false,
expects: "0",
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.length > 0) {
_addIssue(this, "length", dataset, config2, {
received: `${dataset.value.length}`
});
}
return dataset;
}
};
}
// src/actions/endsWith/endsWith.ts
function endsWith(requirement, message) {
return {
kind: "validation",
type: "ends_with",
reference: endsWith,
async: false,
expects: `"${requirement}"`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !dataset.value.endsWith(this.requirement)) {
_addIssue(this, "end", dataset, config2, {
received: `"${dataset.value.slice(-this.requirement.length)}"`
});
}
return dataset;
}
};
}
// src/actions/everyItem/everyItem.ts
function everyItem(requirement, message) {
return {
kind: "validation",
type: "every_item",
reference: everyItem,
async: false,
expects: null,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !dataset.value.every(this.requirement)) {
_addIssue(this, "item", dataset, config2);
}
return dataset;
}
};
}
// src/actions/excludes/excludes.ts
function excludes(requirement, message) {
const received = _stringify(requirement);
return {
kind: "validation",
type: "excludes",
reference: excludes,
async: false,
expects: `!${received}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.includes(this.requirement)) {
_addIssue(this, "content", dataset, config2, { received });
}
return dataset;
}
};
}
// src/actions/filterItems/filterItems.ts
function filterItems(operation) {
return {
kind: "transformation",
type: "filter_items",
reference: filterItems,
async: false,
operation,
_run(dataset) {
dataset.value = dataset.value.filter(this.operation);
return dataset;
}
};
}
// src/actions/findItem/findItem.ts
function findItem(operation) {
return {
kind: "transformation",
type: "find_item",
reference: findItem,
async: false,
operation,
_run(dataset) {
dataset.value = dataset.value.find(this.operation);
return dataset;
}
};
}
// src/actions/finite/finite.ts
function finite(message) {
return {
kind: "validation",
type: "finite",
reference: finite,
async: false,
expects: null,
requirement: Number.isFinite,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "finite", dataset, config2);
}
return dataset;
}
};
}
// src/actions/hash/hash.ts
var HASH_LENGTHS = {
md4: 32,
md5: 32,
sha1: 40,
sha256: 64,
sha384: 96,
sha512: 128,
ripemd128: 32,
ripemd160: 40,
tiger128: 32,
tiger160: 40,
tiger192: 48,
crc32: 8,
crc32b: 8,
adler32: 8
};
function hash(types, message) {
return {
kind: "validation",
type: "hash",
reference: hash,
expects: null,
async: false,
requirement: RegExp(
types.map((type) => `^[a-f0-9]{${HASH_LENGTHS[type]}}$`).join("|"),
"iu"
),
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "hash", dataset, config2);
}
return dataset;
}
};
}
// src/actions/hexadecimal/hexadecimal.ts
function hexadecimal(message) {
return {
kind: "validation",
type: "hexadecimal",
reference: hexadecimal,
async: false,
expects: null,
requirement: HEXADECIMAL_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "hexadecimal", dataset, config2);
}
return dataset;
}
};
}
// src/actions/hexColor/hexColor.ts
function hexColor(message) {
return {
kind: "validation",
type: "hex_color",
reference: hexColor,
async: false,
expects: null,
requirement: HEX_COLOR_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "hex color", dataset, config2);
}
return dataset;
}
};
}
// src/actions/imei/imei.ts
function imei(message) {
return {
kind: "validation",
type: "imei",
reference: imei,
async: false,
expects: null,
requirement(input) {
return IMEI_REGEX.test(input) && _isLuhnAlgo(input);
},
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "IMEI", dataset, config2);
}
return dataset;
}
};
}
// src/actions/includes/includes.ts
function includes(requirement, message) {
const expects = _stringify(requirement);
return {
kind: "validation",
type: "includes",
reference: includes,
async: false,
expects,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !dataset.value.includes(this.requirement)) {
_addIssue(this, "content", dataset, config2, {
received: `!${expects}`
});
}
return dataset;
}
};
}
// src/actions/integer/integer.ts
function integer(message) {
return {
kind: "validation",
type: "integer",
reference: integer,
async: false,
expects: null,
requirement: Number.isInteger,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "integer", dataset, config2);
}
return dataset;
}
};
}
// src/actions/ip/ip.ts
function ip(message) {
return {
kind: "validation",
type: "ip",
reference: ip,
async: false,
expects: null,
requirement: IP_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "IP", dataset, config2);
}
return dataset;
}
};
}
// src/actions/ipv4/ipv4.ts
function ipv4(message) {
return {
kind: "validation",
type: "ipv4",
reference: ipv4,
async: false,
expects: null,
requirement: IPV4_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "IPv4", dataset, config2);
}
return dataset;
}
};
}
// src/actions/ipv6/ipv6.ts
function ipv6(message) {
return {
kind: "validation",
type: "ipv6",
reference: ipv6,
async: false,
expects: null,
requirement: IPV6_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "IPv6", dataset, config2);
}
return dataset;
}
};
}
// src/actions/isoDate/isoDate.ts
function isoDate(message) {
return {
kind: "validation",
type: "iso_date",
reference: isoDate,
async: false,
expects: null,
requirement: ISO_DATE_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "date", dataset, config2);
}
return dataset;
}
};
}
// src/actions/isoDateTime/isoDateTime.ts
function isoDateTime(message) {
return {
kind: "validation",
type: "iso_date_time",
reference: isoDateTime,
async: false,
expects: null,
requirement: ISO_DATE_TIME_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "date-time", dataset, config2);
}
return dataset;
}
};
}
// src/actions/isoTime/isoTime.ts
function isoTime(message) {
return {
kind: "validation",
type: "iso_time",
reference: isoTime,
async: false,
expects: null,
requirement: ISO_TIME_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "time", dataset, config2);
}
return dataset;
}
};
}
// src/actions/isoTimeSecond/isoTimeSecond.ts
function isoTimeSecond(message) {
return {
kind: "validation",
type: "iso_time_second",
reference: isoTimeSecond,
async: false,
expects: null,
requirement: ISO_TIME_SECOND_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "time-second", dataset, config2);
}
return dataset;
}
};
}
// src/actions/isoTimestamp/isoTimestamp.ts
function isoTimestamp(message) {
return {
kind: "validation",
type: "iso_timestamp",
reference: isoTimestamp,
async: false,
expects: null,
requirement: ISO_TIMESTAMP_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "timestamp", dataset, config2);
}
return dataset;
}
};
}
// src/actions/isoWeek/isoWeek.ts
function isoWeek(message) {
return {
kind: "validation",
type: "iso_week",
reference: isoWeek,
async: false,
expects: null,
requirement: ISO_WEEK_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "week", dataset, config2);
}
return dataset;
}
};
}
// src/actions/length/length.ts
function length(requirement, message) {
return {
kind: "validation",
type: "length",
reference: length,
async: false,
expects: `${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.length !== this.requirement) {
_addIssue(this, "length", dataset, config2, {
received: `${dataset.value.length}`
});
}
return dataset;
}
};
}
// src/actions/mac/mac.ts
function mac(message) {
return {
kind: "validation",
type: "mac",
reference: mac,
async: false,
expects: null,
requirement: MAC_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "MAC", dataset, config2);
}
return dataset;
}
};
}
// src/actions/mac48/mac48.ts
function mac48(message) {
return {
kind: "validation",
type: "mac48",
reference: mac48,
async: false,
expects: null,
requirement: MAC48_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "48-bit MAC", dataset, config2);
}
return dataset;
}
};
}
// src/actions/mac64/mac64.ts
function mac64(message) {
return {
kind: "validation",
type: "mac64",
reference: mac64,
async: false,
expects: null,
requirement: MAC64_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "64-bit MAC", dataset, config2);
}
return dataset;
}
};
}
// src/actions/mapItems/mapItems.ts
function mapItems(operation) {
return {
kind: "transformation",
type: "map_items",
reference: mapItems,
async: false,
operation,
_run(dataset) {
dataset.value = dataset.value.map(this.operation);
return dataset;
}
};
}
// src/actions/maxBytes/maxBytes.ts
function maxBytes(requirement, message) {
return {
kind: "validation",
type: "max_bytes",
reference: maxBytes,
async: false,
expects: `<=${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed) {
const length2 = new TextEncoder().encode(dataset.value).length;
if (length2 > this.requirement) {
_addIssue(this, "bytes", dataset, config2, {
received: `${length2}`
});
}
}
return dataset;
}
};
}
// src/actions/maxLength/maxLength.ts
function maxLength(requirement, message) {
return {
kind: "validation",
type: "max_length",
reference: maxLength,
async: false,
expects: `<=${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.length > this.requirement) {
_addIssue(this, "length", dataset, config2, {
received: `${dataset.value.length}`
});
}
return dataset;
}
};
}
// src/actions/maxSize/maxSize.ts
function maxSize(requirement, message) {
return {
kind: "validation",
type: "max_size",
reference: maxSize,
async: false,
expects: `<=${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.size > this.requirement) {
_addIssue(this, "size", dataset, config2, {
received: `${dataset.value.size}`
});
}
return dataset;
}
};
}
// src/actions/maxValue/maxValue.ts
function maxValue(requirement, message) {
return {
kind: "validation",
type: "max_value",
reference: maxValue,
async: false,
expects: `<=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value > this.requirement) {
_addIssue(this, "value", dataset, config2, {
received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
});
}
return dataset;
}
};
}
// src/actions/mimeType/mimeType.ts
function mimeType(requirement, message) {
return {
kind: "validation",
type: "mime_type",
reference: mimeType,
async: false,
expects: requirement.map((option) => `"${option}"`).join(" | ") || "never",
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.includes(dataset.value.type)) {
_addIssue(this, "MIME type", dataset, config2, {
received: `"${dataset.value.type}"`
});
}
return dataset;
}
};
}
// src/actions/minBytes/minBytes.ts
function minBytes(requirement, message) {
return {
kind: "validation",
type: "min_bytes",
reference: minBytes,
async: false,
expects: `>=${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed) {
const length2 = new TextEncoder().encode(dataset.value).length;
if (length2 < this.requirement) {
_addIssue(this, "bytes", dataset, config2, {
received: `${length2}`
});
}
}
return dataset;
}
};
}
// src/actions/minLength/minLength.ts
function minLength(requirement, message) {
return {
kind: "validation",
type: "min_length",
reference: minLength,
async: false,
expects: `>=${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.length < this.requirement) {
_addIssue(this, "length", dataset, config2, {
received: `${dataset.value.length}`
});
}
return dataset;
}
};
}
// src/actions/minSize/minSize.ts
function minSize(requirement, message) {
return {
kind: "validation",
type: "min_size",
reference: minSize,
async: false,
expects: `>=${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.size < this.requirement) {
_addIssue(this, "size", dataset, config2, {
received: `${dataset.value.size}`
});
}
return dataset;
}
};
}
// src/actions/minValue/minValue.ts
function minValue(requirement, message) {
return {
kind: "validation",
type: "min_value",
reference: minValue,
async: false,
expects: `>=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value < this.requirement) {
_addIssue(this, "value", dataset, config2, {
received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
});
}
return dataset;
}
};
}
// src/actions/multipleOf/multipleOf.ts
function multipleOf(requirement, message) {
return {
kind: "validation",
type: "multiple_of",
reference: multipleOf,
async: false,
expects: `%${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value % this.requirement !== 0) {
_addIssue(this, "multiple", dataset, config2);
}
return dataset;
}
};
}
// src/actions/nonEmpty/nonEmpty.ts
function nonEmpty(message) {
return {
kind: "validation",
type: "non_empty",
reference: nonEmpty,
async: false,
expects: "!0",
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.length === 0) {
_addIssue(this, "length", dataset, config2, {
received: "0"
});
}
return dataset;
}
};
}
// src/actions/normalize/normalize.ts
function normalize(form) {
return {
kind: "transformation",
type: "normalize",
reference: normalize,
async: false,
form,
_run(dataset) {
dataset.value = dataset.value.normalize(this.form);
return dataset;
}
};
}
// src/actions/notBytes/notBytes.ts
function notBytes(requirement, message) {
return {
kind: "validation",
type: "not_bytes",
reference: notBytes,
async: false,
expects: `!${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed) {
const length2 = new TextEncoder().encode(dataset.value).length;
if (length2 === this.requirement) {
_addIssue(this, "bytes", dataset, config2, {
received: `${length2}`
});
}
}
return dataset;
}
};
}
// src/actions/notLength/notLength.ts
function notLength(requirement, message) {
return {
kind: "validation",
type: "not_length",
reference: notLength,
async: false,
expects: `!${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.length === this.requirement) {
_addIssue(this, "length", dataset, config2, {
received: `${dataset.value.length}`
});
}
return dataset;
}
};
}
// src/actions/notSize/notSize.ts
function notSize(requirement, message) {
return {
kind: "validation",
type: "not_size",
reference: notSize,
async: false,
expects: `!${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.size === this.requirement) {
_addIssue(this, "size", dataset, config2, {
received: `${dataset.value.size}`
});
}
return dataset;
}
};
}
// src/actions/notValue/notValue.ts
function notValue(requirement, message) {
return {
kind: "validation",
type: "not_value",
reference: notValue,
async: false,
expects: requirement instanceof Date ? `!${requirement.toJSON()}` : `!${_stringify(requirement)}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && this.requirement <= dataset.value && this.requirement >= dataset.value) {
_addIssue(this, "value", dataset, config2, {
received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
});
}
return dataset;
}
};
}
// src/actions/octal/octal.ts
function octal(message) {
return {
kind: "validation",
type: "octal",
reference: octal,
async: false,
expects: null,
requirement: OCTAL_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "octal", dataset, config2);
}
return dataset;
}
};
}
// src/actions/partialCheck/utils/_isPartiallyTyped/_isPartiallyTyped.ts
function _isPartiallyTyped(dataset, pathList) {
if (dataset.issues) {
for (const path of pathList) {
for (const issue of dataset.issues) {
let typed = false;
const bound = Math.min(path.length, issue.path?.length ?? 0);
for (let index = 0; index < bound; index++) {
if (path[index] !== issue.path[index].key) {
typed = true;
break;
}
}
if (!typed) {
return false;
}
}
}
}
return true;
}
// src/actions/partialCheck/partialCheck.ts
function partialCheck(pathList, requirement, message) {
return {
kind: "validation",
type: "partial_check",
reference: partialCheck,
async: false,
expects: null,
requirement,
message,
_run(dataset, config2) {
if (_isPartiallyTyped(dataset, pathList) && // @ts-expect-error
!this.requirement(dataset.value)) {
_addIssue(this, "input", dataset, config2);
}
return dataset;
}
};
}
// src/actions/partialCheck/partialCheckAsync.ts
function partialCheckAsync(pathList, requirement, message) {
return {
kind: "validation",
type: "partial_check",
reference: partialCheckAsync,
async: true,
expects: null,
requirement,
message,
async _run(dataset, config2) {
if (_isPartiallyTyped(dataset, pathList) && // @ts-expect-error
!await this.requirement(dataset.value)) {
_addIssue(this, "input", dataset, config2);
}
return dataset;
}
};
}
// src/actions/rawCheck/rawCheck.ts
function rawCheck(action) {
return {
kind: "validation",
type: "raw_check",
reference: rawCheck,
async: false,
expects: null,
_run(dataset, config2) {
action({
dataset,
config: config2,
addIssue: (info) => _addIssue(this, info?.label ?? "input", dataset, config2, info)
});
return dataset;
}
};
}
// src/actions/rawCheck/rawCheckAsync.ts
function rawCheckAsync(action) {
return {
kind: "validation",
type: "raw_check",
reference: rawCheckAsync,
async: true,
expects: null,
async _run(dataset, config2) {
await action({
dataset,
config: config2,
addIssue: (info) => _addIssue(this, info?.label ?? "input", dataset, config2, info)
});
return dataset;
}
};
}
// src/actions/rawTransform/rawTransform.ts
function rawTransform(action) {
return {
kind: "transformation",
type: "raw_transform",
reference: rawTransform,
async: false,
_run(dataset, config2) {
const output = action({
dataset,
config: config2,
addIssue: (info) => _addIssue(this, info?.label ?? "input", dataset, config2, info),
NEVER: null
});
if (dataset.issues) {
dataset.typed = false;
} else {
dataset.value = output;
}
return dataset;
}
};
}
// src/actions/rawTransform/rawTransformAsync.ts
function rawTransformAsync(action) {
return {
kind: "transformation",
type: "raw_transform",
reference: rawTransformAsync,
async: true,
async _run(dataset, config2) {
const output = await action({
dataset,
config: config2,
addIssue: (info) => _addIssue(this, info?.label ?? "input", dataset, config2, info),
NEVER: null
});
if (dataset.issues) {
dataset.typed = false;
} else {
dataset.value = output;
}
return dataset;
}
};
}
// src/actions/readonly/readonly.ts
function readonly() {
return {
kind: "transformation",
type: "readonly",
reference: readonly,
async: false,
_run(dataset) {
return dataset;
}
};
}
// src/actions/reduceItems/reduceItems.ts
function reduceItems(operation, initial) {
return {
kind: "transformation",
type: "reduce_items",
reference: reduceItems,
async: false,
operation,
initial,
_run(dataset) {
dataset.value = dataset.value.reduce(this.operation, this.initial);
return dataset;
}
};
}
// src/actions/regex/regex.ts
function regex(requirement, message) {
return {
kind: "validation",
type: "regex",
reference: regex,
async: false,
expects: `${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "format", dataset, config2);
}
return dataset;
}
};
}
// src/actions/safeInteger/safeInteger.ts
function safeInteger(message) {
return {
kind: "validation",
type: "safe_integer",
reference: safeInteger,
async: false,
expects: null,
requirement: Number.isSafeInteger,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "safe integer", dataset, config2);
}
return dataset;
}
};
}
// src/actions/size/size.ts
function size(requirement, message) {
return {
kind: "validation",
type: "size",
reference: size,
async: false,
expects: `${requirement}`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && dataset.value.size !== this.requirement) {
_addIssue(this, "size", dataset, config2, {
received: `${dataset.value.size}`
});
}
return dataset;
}
};
}
// src/actions/someItem/someItem.ts
function someItem(requirement, message) {
return {
kind: "validation",
type: "some_item",
reference: someItem,
async: false,
expects: null,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !dataset.value.some(this.requirement)) {
_addIssue(this, "item", dataset, config2);
}
return dataset;
}
};
}
// src/actions/sortItems/sortItems.ts
function sortItems(operation) {
return {
kind: "transformation",
type: "sort_items",
reference: sortItems,
async: false,
operation,
_run(dataset) {
dataset.value = dataset.value.sort(this.operation);
return dataset;
}
};
}
// src/actions/startsWith/startsWith.ts
function startsWith(requirement, message) {
return {
kind: "validation",
type: "starts_with",
reference: startsWith,
async: false,
expects: `"${requirement}"`,
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !dataset.value.startsWith(this.requirement)) {
_addIssue(this, "start", dataset, config2, {
received: `"${dataset.value.slice(0, this.requirement.length)}"`
});
}
return dataset;
}
};
}
// src/actions/toLowerCase/toLowerCase.ts
function toLowerCase() {
return {
kind: "transformation",
type: "to_lower_case",
reference: toLowerCase,
async: false,
_run(dataset) {
dataset.value = dataset.value.toLowerCase();
return dataset;
}
};
}
// src/actions/toMaxValue/toMaxValue.ts
function toMaxValue(requirement) {
return {
kind: "transformation",
type: "to_max_value",
reference: toMaxValue,
async: false,
requirement,
_run(dataset) {
dataset.value = dataset.value > this.requirement ? this.requirement : dataset.value;
return dataset;
}
};
}
// src/actions/toMinValue/toMinValue.ts
function toMinValue(requirement) {
return {
kind: "transformation",
type: "to_min_value",
reference: toMinValue,
async: false,
requirement,
_run(dataset) {
dataset.value = dataset.value < this.requirement ? this.requirement : dataset.value;
return dataset;
}
};
}
// src/actions/toUpperCase/toUpperCase.ts
function toUpperCase() {
return {
kind: "transformation",
type: "to_upper_case",
reference: toUpperCase,
async: false,
_run(dataset) {
dataset.value = dataset.value.toUpperCase();
return dataset;
}
};
}
// src/actions/transform/transform.ts
function transform(operation) {
return {
kind: "transformation",
type: "transform",
reference: transform,
async: false,
operation,
_run(dataset) {
dataset.value = this.operation(dataset.value);
return dataset;
}
};
}
// src/actions/transform/transformAsync.ts
function transformAsync(operation) {
return {
kind: "transformation",
type: "transform",
reference: transformAsync,
async: true,
operation,
async _run(dataset) {
dataset.value = await this.operation(dataset.value);
return dataset;
}
};
}
// src/actions/trim/trim.ts
function trim() {
return {
kind: "transformation",
type: "trim",
reference: trim,
async: false,
_run(dataset) {
dataset.value = dataset.value.trim();
return dataset;
}
};
}
// src/actions/trimEnd/trimEnd.ts
function trimEnd() {
return {
kind: "transformation",
type: "trim_end",
reference: trimEnd,
async: false,
_run(dataset) {
dataset.value = dataset.value.trimEnd();
return dataset;
}
};
}
// src/actions/trimStart/trimStart.ts
function trimStart() {
return {
kind: "transformation",
type: "trim_start",
reference: trimStart,
async: false,
_run(dataset) {
dataset.value = dataset.value.trimStart();
return dataset;
}
};
}
// src/actions/ulid/ulid.ts
function ulid(message) {
return {
kind: "validation",
type: "ulid",
reference: ulid,
async: false,
expects: null,
requirement: ULID_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "ULID", dataset, config2);
}
return dataset;
}
};
}
// src/actions/url/url.ts
function url(message) {
return {
kind: "validation",
type: "url",
reference: url,
async: false,
expects: null,
requirement(input) {
try {
new URL(input);
return true;
} catch {
return false;
}
},
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement(dataset.value)) {
_addIssue(this, "URL", dataset, config2);
}
return dataset;
}
};
}
// src/actions/uuid/uuid.ts
function uuid(message) {
return {
kind: "validation",
type: "uuid",
reference: uuid,
async: false,
expects: null,
requirement: UUID_REGEX,
message,
_run(dataset, config2) {
if (dataset.typed && !this.requirement.test(dataset.value)) {
_addIssue(this, "UUID", dataset, config2);
}
return dataset;
}
};
}
// src/actions/value/value.ts
function value(requirement, message) {
return {
kind: "validation",
type: "value",
reference: value,
async: false,
expects: requirement instanceof Date ? requirement.toJSON() : _stringify(requirement),
requirement,
message,
_run(dataset, config2) {
if (dataset.typed && !(this.requirement <= dataset.value && this.requirement >= dataset.value)) {
_addIssue(this, "value", dataset, config2, {
received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
});
}
return dataset;
}
};
}
// src/methods/config/config.ts
function config(schema, config2) {
return {
...schema,
_run(dataset, config_) {
return schema._run(dataset, { ...config_, ...config2 });
}
};
}
// src/methods/getFallback/getFallback.ts
function getFallback(schema, dataset, config2) {
return typeof schema.fallback === "function" ? (
// @ts-expect-error
schema.fallback(dataset, config2)
) : (
// @ts-expect-error
schema.fallback
);
}
// src/methods/fallback/fallback.ts
function fallback(schema, fallback2) {
return {
...schema,
fallback: fallback2,
_run(dataset, config2) {
schema._run(dataset, config2);
return dataset.issues ? { typed: true, value: getFallback(this, dataset, config2) } : dataset;
}
};
}
// src/methods/fallback/fallbackAsync.ts
function fallbackAsync(schema, fallback2) {
return {
...schema,
fallback: fallback2,
async: true,
async _run(dataset, config2) {
schema._run(dataset, config2);
return dataset.issues ? (
// @ts-expect-error
{ typed: true, value: await getFallback(this, dataset, config2) }
) : dataset;
}
};
}
// src/methods/flatten/flatten.ts
function flatten(issues) {
const flatErrors = {};
for (const issue of issues) {
if (issue.path) {
const dotPath = getDotPath(issue);
if (dotPath) {
if (!flatErrors.nested) {
flatErrors.nested = {};
}
if (flatErrors.nested[dotPath]) {
flatErrors.nested[dotPath].push(issue.message);
} else {
flatErrors.nested[dotPath] = [issue.message];
}
} else {
if (flatErrors.other) {
flatErrors.other.push(issue.message);
} else {
flatErrors.other = [issue.message];
}
}
} else {
if (flatErrors.root) {
flatErrors.root.push(issue.message);
} else {
flatErrors.root = [issue.message];
}
}
}
return flatErrors;
}
// src/methods/forward/forward.ts
function forward(action, pathKeys) {
return {
...action,
_run(dataset, config2) {
const prevIssues = dataset.issues && [...dataset.issues];
action._run(dataset, config2);
if (dataset.issues) {
for (const issue of dataset.issues) {
if (!prevIssues?.includes(issue)) {
let pathInput = dataset.value;
for (const key of pathKeys) {
const pathValue = pathInput[key];
const pathItem = {
type: "unknown",
origin: "value",
input: pathInput,
key,
value: pathValue
};
if (issue.path) {
issue.path.push(pathItem);
} else {
issue.path = [pathItem];
}
if (!pathValue) {
break;
}
pathInput = pathValue;
}
}
}
}
return dataset;
}
};
}
// src/methods/forward/forwardAsync.ts
function forwardAsync(action, pathKeys) {
return {
...action,
async: true,
async _run(dataset, config2) {
const prevIssues = dataset.issues && [...dataset.issues];
await action._run(dataset, config2);
if (dataset.issues) {
for (const issue of dataset.issues) {
if (!prevIssues?.includes(issue)) {
let pathInput = dataset.value;
for (const key of pathKeys) {
const pathValue = pathInput[key];
const pathItem = {
type: "unknown",
origin: "value",
input: pathInput,
key,
value: pathValue
};
if (issue.path) {
issue.path.push(pathItem);
} else {
issue.path = [pathItem];
}
if (!pathValue) {
break;
}
pathInput = pathValue;
}
}
}
}
return dataset;
}
};
}
// src/methods/getDefault/getDefault.ts
function getDefault(schema, dataset, config2) {
return typeof schema.default === "function" ? (
// @ts-expect-error
schema.default(dataset, config2)
) : (
// @ts-expect-error
schema.default
);
}
// src/methods/getDefaults/getDefaults.ts
function getDefaults(schema) {
if ("entries" in schema) {
const object2 = {};
for (const key in schema.entries) {
object2[key] = getDefaults(schema.entries[key]);
}
return object2;
}
if ("items" in schema) {
return schema.items.map(getDefaults);
}
return getDefault(schema);
}
// src/methods/getDefaults/getDefaultsAsync.ts
async function getDefaultsAsync(schema) {
if ("entries" in schema) {
return Object.fromEntries(
await Promise.all(
Object.entries(schema.entries).map(async ([key, value2]) => [
key,
await getDefaultsAsync(value2)
])
)
);
}
if ("items" in schema) {
return Promise.all(schema.items.map(getDefaultsAsync));
}
return getDefault(schema);
}
// src/methods/getFallbacks/getFallbacks.ts
function getFallbacks(schema) {
if ("entries" in schema) {
const object2 = {};
for (const key in schema.entries) {
object2[key] = getFallbacks(schema.entries[key]);
}
return object2;
}
if ("items" in schema) {
return schema.items.map(getFallbacks);
}
return getFallback(schema);
}
// src/methods/getFallbacks/getFallbacksAsync.ts
async function getFallbacksAsync(schema) {
if ("entries" in schema) {
return Object.fromEntries(
await Promise.all(
Object.entries(schema.entries).map(async ([key, value2]) => [
key,
await getFallbacksAsync(value2)
])
)
);
}
if ("items" in schema) {
return Promise.all(schema.items.map(getFallbacksAsync));
}
return getFallback(schema);
}
// src/methods/is/is.ts
function is(schema, input) {
return !schema._run({ typed: false, value: input }, { abortEarly: true }).issues;
}
// src/schemas/any/any.ts
function any() {
return {
kind: "schema",
type: "any",
reference: any,
expects: "any",
async: false,
_run(dataset) {
dataset.typed = true;
return dataset;
}
};
}
// src/schemas/array/array.ts
function array(item, message) {
return {
kind: "schema",
type: "array",
reference: array,
expects: "Array",
async: false,
item,
message,
_run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
for (let key = 0; key < input.length; key++) {
const value2 = input[key];
const itemDataset = this.item._run({ typed: false, value: value2 }, config2);
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/array/arrayAsync.ts
function arrayAsync(item, message) {
return {
kind: "schema",
type: "array",
reference: arrayAsync,
expects: "Array",
async: true,
item,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
const itemDatasets = await Promise.all(
input.map((value2) => this.item._run({ typed: false, value: value2 }, config2))
);
for (let key = 0; key < itemDatasets.length; key++) {
const itemDataset = itemDatasets[key];
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: input[key]
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/bigint/bigint.ts
function bigint(message) {
return {
kind: "schema",
type: "bigint",
reference: bigint,
expects: "bigint",
async: false,
message,
_run(dataset, config2) {
if (typeof dataset.value === "bigint") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/blob/blob.ts
function blob(message) {
return {
kind: "schema",
type: "blob",
reference: blob,
expects: "Blob",
async: false,
message,
_run(dataset, config2) {
if (dataset.value instanceof Blob) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/boolean/boolean.ts
function boolean(message) {
return {
kind: "schema",
type: "boolean",
reference: boolean,
expects: "boolean",
async: false,
message,
_run(dataset, config2) {
if (typeof dataset.value === "boolean") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/custom/custom.ts
function custom(check2, message) {
return {
kind: "schema",
type: "custom",
reference: custom,
expects: "unknown",
async: false,
check: check2,
message,
_run(dataset, config2) {
if (this.check(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/custom/customAsync.ts
function customAsync(check2, message) {
return {
kind: "schema",
type: "custom",
reference: customAsync,
expects: "unknown",
async: true,
check: check2,
message,
async _run(dataset, config2) {
if (await this.check(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/date/date.ts
function date(message) {
return {
kind: "schema",
type: "date",
reference: date,
expects: "Date",
async: false,
message,
_run(dataset, config2) {
if (dataset.value instanceof Date) {
if (!isNaN(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2, {
received: '"Invalid Date"'
});
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/enum/enum.ts
function enum_(enum__, message) {
const options = Object.entries(enum__).filter(([key]) => isNaN(+key)).map(([, value2]) => value2);
return {
kind: "schema",
type: "enum",
reference: enum_,
expects: options.map(_stringify).join(" | ") || "never",
async: false,
enum: enum__,
options,
message,
_run(dataset, config2) {
if (this.options.includes(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/file/file.ts
function file(message) {
return {
kind: "schema",
type: "file",
reference: file,
expects: "File",
async: false,
message,
_run(dataset, config2) {
if (dataset.value instanceof File) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/function/function.ts
function function_(message) {
return {
kind: "schema",
type: "function",
reference: function_,
expects: "Function",
async: false,
message,
_run(dataset, config2) {
if (typeof dataset.value === "function") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/instance/instance.ts
function instance(class_, message) {
return {
kind: "schema",
type: "instance",
reference: instance,
expects: class_.name,
async: false,
class: class_,
message,
_run(dataset, config2) {
if (dataset.value instanceof this.class) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/intersect/utils/_merge/_merge.ts
function _merge(value1, value2) {
if (typeof value1 === typeof value2) {
if (value1 === value2 || value1 instanceof Date && value2 instanceof Date && +value1 === +value2) {
return { value: value1 };
}
if (value1 && value2 && value1.constructor === Object && value2.constructor === Object) {
for (const key in value2) {
if (key in value1) {
const dataset = _merge(value1[key], value2[key]);
if (dataset.issue) {
return dataset;
}
value1[key] = dataset.value;
} else {
value1[key] = value2[key];
}
}
return { value: value1 };
}
if (Array.isArray(value1) && Array.isArray(value2)) {
if (value1.length === value2.length) {
for (let index = 0; index < value1.length; index++) {
const dataset = _merge(value1[index], value2[index]);
if (dataset.issue) {
return dataset;
}
value1[index] = dataset.value;
}
return { value: value1 };
}
}
}
return { issue: true };
}
// src/schemas/intersect/intersect.ts
function intersect(options, message) {
return {
kind: "schema",
type: "intersect",
reference: intersect,
expects: [...new Set(options.map((option) => option.expects))].join(" & ") || "never",
async: false,
options,
message,
_run(dataset, config2) {
if (this.options.length) {
const input = dataset.value;
let outputs;
dataset.typed = true;
for (const schema of this.options) {
const optionDataset = schema._run(
{ typed: false, value: input },
config2
);
if (optionDataset.issues) {
if (dataset.issues) {
dataset.issues.push(...optionDataset.issues);
} else {
dataset.issues = optionDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!optionDataset.typed) {
dataset.typed = false;
}
if (dataset.typed) {
if (outputs) {
outputs.push(optionDataset.value);
} else {
outputs = [optionDataset.value];
}
}
}
if (dataset.typed) {
dataset.value = outputs[0];
for (let index = 1; index < outputs.length; index++) {
const mergeDataset = _merge(dataset.value, outputs[index]);
if (mergeDataset.issue) {
_addIssue(this, "type", dataset, config2, {
received: "unknown"
});
break;
}
dataset.value = mergeDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/intersect/intersectAsync.ts
function intersectAsync(options, message) {
return {
kind: "schema",
type: "intersect",
reference: intersectAsync,
expects: [...new Set(options.map((option) => option.expects))].join(" & ") || "never",
async: true,
options,
message,
async _run(dataset, config2) {
if (this.options.length) {
const input = dataset.value;
let outputs;
dataset.typed = true;
const optionDatasets = await Promise.all(
this.options.map(
(schema) => schema._run({ typed: false, value: input }, config2)
)
);
for (const optionDataset of optionDatasets) {
if (optionDataset.issues) {
if (dataset.issues) {
dataset.issues.push(...optionDataset.issues);
} else {
dataset.issues = optionDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!optionDataset.typed) {
dataset.typed = false;
}
if (dataset.typed) {
if (outputs) {
outputs.push(optionDataset.value);
} else {
outputs = [optionDataset.value];
}
}
}
if (dataset.typed) {
dataset.value = outputs[0];
for (let index = 1; index < outputs.length; index++) {
const mergeDataset = _merge(dataset.value, outputs[index]);
if (mergeDataset.issue) {
_addIssue(this, "type", dataset, config2, {
received: "unknown"
});
break;
}
dataset.value = mergeDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/lazy/lazy.ts
function lazy(getter) {
return {
kind: "schema",
type: "lazy",
reference: lazy,
expects: "unknown",
async: false,
getter,
_run(dataset, config2) {
return this.getter(dataset.value)._run(dataset, config2);
}
};
}
// src/schemas/lazy/lazyAsync.ts
function lazyAsync(getter) {
return {
kind: "schema",
type: "lazy",
reference: lazyAsync,
expects: "unknown",
async: true,
getter,
async _run(dataset, config2) {
return (await this.getter(dataset.value))._run(dataset, config2);
}
};
}
// src/schemas/literal/literal.ts
function literal(literal_, message) {
return {
kind: "schema",
type: "literal",
reference: literal,
expects: _stringify(literal_),
async: false,
literal: literal_,
message,
_run(dataset, config2) {
if (dataset.value === this.literal) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/looseObject/looseObject.ts
function looseObject(entries, message) {
return {
kind: "schema",
type: "loose_object",
reference: looseObject,
expects: "Object",
async: false,
entries,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
for (const key in this.entries) {
const value2 = input[key];
const valueDataset = this.entries[key]._run(
{ typed: false, value: value2 },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
if (!dataset.issues || !config2.abortEarly) {
for (const key in input) {
if (_isValidObjectKey(input, key) && !(key in this.entries)) {
dataset.value[key] = input[key];
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/looseObject/looseObjectAsync.ts
function looseObjectAsync(entries, message) {
return {
kind: "schema",
type: "loose_object",
reference: looseObjectAsync,
expects: "Object",
async: true,
entries,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
const valueDatasets = await Promise.all(
Object.entries(this.entries).map(async ([key, schema]) => {
const value2 = input[key];
return [
key,
value2,
await schema._run({ typed: false, value: value2 }, config2)
];
})
);
for (const [key, value2, valueDataset] of valueDatasets) {
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
if (!dataset.issues || !config2.abortEarly) {
for (const key in input) {
if (_isValidObjectKey(input, key) && !(key in this.entries)) {
dataset.value[key] = input[key];
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/looseTuple/looseTuple.ts
function looseTuple(items, message) {
return {
kind: "schema",
type: "loose_tuple",
reference: looseTuple,
expects: "Array",
async: false,
items,
message,
_run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
for (let key = 0; key < this.items.length; key++) {
const value2 = input[key];
const itemDataset = this.items[key]._run(
{ typed: false, value: value2 },
config2
);
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
if (!dataset.issues || !config2.abortEarly) {
for (let key = this.items.length; key < input.length; key++) {
dataset.value.push(input[key]);
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/looseTuple/looseTupleAsync.ts
function looseTupleAsync(items, message) {
return {
kind: "schema",
type: "loose_tuple",
reference: looseTupleAsync,
expects: "Array",
async: true,
items,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
const itemDatasets = await Promise.all(
this.items.map(async (item, key) => {
const value2 = input[key];
return [
key,
value2,
await item._run({ typed: false, value: value2 }, config2)
];
})
);
for (const [key, value2, itemDataset] of itemDatasets) {
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
if (!dataset.issues || !config2.abortEarly) {
for (let key = this.items.length; key < input.length; key++) {
dataset.value.push(input[key]);
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/map/map.ts
function map(key, value2, message) {
return {
kind: "schema",
type: "map",
reference: map,
expects: "Map",
async: false,
key,
value: value2,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input instanceof Map) {
dataset.typed = true;
dataset.value = /* @__PURE__ */ new Map();
for (const [inputKey, inputValue] of input) {
const keyDataset = this.key._run(
{ typed: false, value: inputKey },
config2
);
if (keyDataset.issues) {
const pathItem = {
type: "map",
origin: "key",
input,
key: inputKey,
value: inputValue
};
for (const issue of keyDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = keyDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
const valueDataset = this.value._run(
{ typed: false, value: inputValue },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "map",
origin: "value",
input,
key: inputKey,
value: inputValue
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!keyDataset.typed || !valueDataset.typed) {
dataset.typed = false;
}
dataset.value.set(keyDataset.value, valueDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/map/mapAsync.ts
function mapAsync(key, value2, message) {
return {
kind: "schema",
type: "map",
reference: mapAsync,
expects: "Map",
async: true,
key,
value: value2,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input instanceof Map) {
dataset.typed = true;
dataset.value = /* @__PURE__ */ new Map();
const datasets = await Promise.all(
[...input].map(
([inputKey, inputValue]) => Promise.all([
inputKey,
inputValue,
this.key._run({ typed: false, value: inputKey }, config2),
this.value._run({ typed: false, value: inputValue }, config2)
])
)
);
for (const [
inputKey,
inputValue,
keyDataset,
valueDataset
] of datasets) {
if (keyDataset.issues) {
const pathItem = {
type: "map",
origin: "key",
input,
key: inputKey,
value: inputValue
};
for (const issue of keyDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = keyDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (valueDataset.issues) {
const pathItem = {
type: "map",
origin: "value",
input,
key: inputKey,
value: inputValue
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!keyDataset.typed || !valueDataset.typed) {
dataset.typed = false;
}
dataset.value.set(keyDataset.value, valueDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/nan/nan.ts
function nan(message) {
return {
kind: "schema",
type: "nan",
reference: nan,
expects: "NaN",
async: false,
message,
_run(dataset, config2) {
if (Number.isNaN(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/never/never.ts
function never(message) {
return {
kind: "schema",
type: "never",
reference: never,
expects: "never",
async: false,
message,
_run(dataset, config2) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
};
}
// src/schemas/nonNullable/nonNullable.ts
function nonNullable(wrapped, message) {
return {
kind: "schema",
type: "non_nullable",
reference: nonNullable,
expects: "!null",
async: false,
wrapped,
message,
_run(dataset, config2) {
if (dataset.value === null) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
return this.wrapped._run(dataset, config2);
}
};
}
// src/schemas/nonNullable/nonNullableAsync.ts
function nonNullableAsync(wrapped, message) {
return {
kind: "schema",
type: "non_nullable",
reference: nonNullableAsync,
expects: "!null",
async: true,
wrapped,
message,
async _run(dataset, config2) {
if (dataset.value === null) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
return this.wrapped._run(dataset, config2);
}
};
}
// src/schemas/nonNullish/nonNullish.ts
function nonNullish(wrapped, message) {
return {
kind: "schema",
type: "non_nullish",
reference: nonNullish,
expects: "!null & !undefined",
async: false,
wrapped,
message,
_run(dataset, config2) {
if (dataset.value === null || dataset.value === void 0) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
return this.wrapped._run(dataset, config2);
}
};
}
// src/schemas/nonNullish/nonNullishAsync.ts
function nonNullishAsync(wrapped, message) {
return {
kind: "schema",
type: "non_nullish",
reference: nonNullishAsync,
expects: "!null & !undefined",
async: true,
wrapped,
message,
async _run(dataset, config2) {
if (dataset.value === null || dataset.value === void 0) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
return this.wrapped._run(dataset, config2);
}
};
}
// src/schemas/nonOptional/nonOptional.ts
function nonOptional(wrapped, message) {
return {
kind: "schema",
type: "non_optional",
reference: nonOptional,
expects: "!undefined",
async: false,
wrapped,
message,
_run(dataset, config2) {
if (dataset.value === void 0) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
return this.wrapped._run(dataset, config2);
}
};
}
// src/schemas/nonOptional/nonOptionalAsync.ts
function nonOptionalAsync(wrapped, message) {
return {
kind: "schema",
type: "non_optional",
reference: nonOptionalAsync,
expects: "!undefined",
async: true,
wrapped,
message,
async _run(dataset, config2) {
if (dataset.value === void 0) {
_addIssue(this, "type", dataset, config2);
return dataset;
}
return this.wrapped._run(dataset, config2);
}
};
}
// src/schemas/null/null.ts
function null_(message) {
return {
kind: "schema",
type: "null",
reference: null_,
expects: "null",
async: false,
message,
_run(dataset, config2) {
if (dataset.value === null) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/nullable/nullable.ts
function nullable(wrapped, ...args) {
const schema = {
kind: "schema",
type: "nullable",
reference: nullable,
expects: `${wrapped.expects} | null`,
async: false,
wrapped,
_run(dataset, config2) {
if (dataset.value === null) {
if ("default" in this) {
dataset.value = getDefault(
this,
dataset,
config2
);
}
if (dataset.value === null) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped._run(dataset, config2);
}
};
if (0 in args) {
schema.default = args[0];
}
return schema;
}
// src/schemas/nullable/nullableAsync.ts
function nullableAsync(wrapped, ...args) {
const schema = {
kind: "schema",
type: "nullable",
reference: nullableAsync,
expects: `${wrapped.expects} | null`,
async: true,
wrapped,
async _run(dataset, config2) {
if (dataset.value === null) {
if ("default" in this) {
dataset.value = await getDefault(
this,
dataset,
config2
);
}
if (dataset.value === null) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped._run(dataset, config2);
}
};
if (0 in args) {
schema.default = args[0];
}
return schema;
}
// src/schemas/nullish/nullish.ts
function nullish(wrapped, ...args) {
const schema = {
kind: "schema",
type: "nullish",
reference: nullish,
expects: `${wrapped.expects} | null | undefined`,
async: false,
wrapped,
_run(dataset, config2) {
if (dataset.value === null || dataset.value === void 0) {
if ("default" in this) {
dataset.value = getDefault(
this,
dataset,
config2
);
}
if (dataset.value === null || dataset.value === void 0) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped._run(dataset, config2);
}
};
if (0 in args) {
schema.default = args[0];
}
return schema;
}
// src/schemas/nullish/nullishAsync.ts
function nullishAsync(wrapped, ...args) {
const schema = {
kind: "schema",
type: "nullish",
reference: nullishAsync,
expects: `${wrapped.expects} | null | undefined`,
async: true,
wrapped,
async _run(dataset, config2) {
if (dataset.value === null || dataset.value === void 0) {
if ("default" in this) {
dataset.value = await getDefault(
this,
dataset,
config2
);
}
if (dataset.value === null || dataset.value === void 0) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped._run(dataset, config2);
}
};
if (0 in args) {
schema.default = args[0];
}
return schema;
}
// src/schemas/number/number.ts
function number(message) {
return {
kind: "schema",
type: "number",
reference: number,
expects: "number",
async: false,
message,
_run(dataset, config2) {
if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/object/object.ts
function object(entries, message) {
return {
kind: "schema",
type: "object",
reference: object,
expects: "Object",
async: false,
entries,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
for (const key in this.entries) {
const value2 = input[key];
const valueDataset = this.entries[key]._run(
{ typed: false, value: value2 },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/object/objectAsync.ts
function objectAsync(entries, message) {
return {
kind: "schema",
type: "object",
reference: objectAsync,
expects: "Object",
async: true,
entries,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
const valueDatasets = await Promise.all(
Object.entries(this.entries).map(async ([key, schema]) => {
const value2 = input[key];
return [
key,
value2,
await schema._run({ typed: false, value: value2 }, config2)
];
})
);
for (const [key, value2, valueDataset] of valueDatasets) {
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/objectWithRest/objectWithRest.ts
function objectWithRest(entries, rest, message) {
return {
kind: "schema",
type: "object_with_rest",
reference: objectWithRest,
expects: "Object",
async: false,
entries,
rest,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
for (const key in this.entries) {
const value2 = input[key];
const valueDataset = this.entries[key]._run(
{ typed: false, value: value2 },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
if (!dataset.issues || !config2.abortEarly) {
for (const key in input) {
if (_isValidObjectKey(input, key) && !(key in this.entries)) {
const value2 = input[key];
const valueDataset = this.rest._run(
{ typed: false, value: value2 },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
dataset.value[key] = valueDataset.value;
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/objectWithRest/objectWithRestAsync.ts
function objectWithRestAsync(entries, rest, message) {
return {
kind: "schema",
type: "object_with_rest",
reference: objectWithRestAsync,
expects: "Object",
async: true,
entries,
rest,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
const [normalDatasets, restDatasets] = await Promise.all([
// Parse schema of each normal entry
Promise.all(
Object.entries(this.entries).map(async ([key, schema]) => {
const value2 = input[key];
return [
key,
value2,
await schema._run({ typed: false, value: value2 }, config2)
];
})
),
// Parse other entries with rest schema
Promise.all(
Object.entries(input).filter(
([key]) => _isValidObjectKey(input, key) && !(key in this.entries)
).map(
async ([key, value2]) => [
key,
value2,
await this.rest._run({ typed: false, value: value2 }, config2)
]
)
)
]);
for (const [key, value2, valueDataset] of normalDatasets) {
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
if (!dataset.issues || !config2.abortEarly) {
for (const [key, value2, valueDataset] of restDatasets) {
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
dataset.value[key] = valueDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/optional/optional.ts
function optional(wrapped, ...args) {
const schema = {
kind: "schema",
type: "optional",
reference: optional,
expects: `${wrapped.expects} | undefined`,
async: false,
wrapped,
_run(dataset, config2) {
if (dataset.value === void 0) {
if ("default" in this) {
dataset.value = getDefault(
this,
dataset,
config2
);
}
if (dataset.value === void 0) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped._run(dataset, config2);
}
};
if (0 in args) {
schema.default = args[0];
}
return schema;
}
// src/schemas/optional/optionalAsync.ts
function optionalAsync(wrapped, ...args) {
const schema = {
kind: "schema",
type: "optional",
reference: optionalAsync,
expects: `${wrapped.expects} | undefined`,
async: true,
wrapped,
async _run(dataset, config2) {
if (dataset.value === void 0) {
if ("default" in this) {
dataset.value = await getDefault(
this,
dataset,
config2
);
}
if (dataset.value === void 0) {
dataset.typed = true;
return dataset;
}
}
return this.wrapped._run(dataset, config2);
}
};
if (0 in args) {
schema.default = args[0];
}
return schema;
}
// src/schemas/picklist/picklist.ts
function picklist(options, message) {
return {
kind: "schema",
type: "picklist",
reference: picklist,
expects: options.map(_stringify).join(" | ") || "never",
async: false,
options,
message,
_run(dataset, config2) {
if (this.options.includes(dataset.value)) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/promise/promise.ts
function promise(message) {
return {
kind: "schema",
type: "promise",
reference: promise,
expects: "Promise",
async: false,
message,
_run(dataset, config2) {
if (dataset.value instanceof Promise) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/record/record.ts
function record(key, value2, message) {
return {
kind: "schema",
type: "record",
reference: record,
expects: "Object",
async: false,
key,
value: value2,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
for (const entryKey in input) {
if (_isValidObjectKey(input, entryKey)) {
const entryValue = input[entryKey];
const keyDataset = this.key._run(
{ typed: false, value: entryKey },
config2
);
if (keyDataset.issues) {
const pathItem = {
type: "object",
origin: "key",
input,
key: entryKey,
value: entryValue
};
for (const issue of keyDataset.issues) {
issue.path = [pathItem];
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = keyDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
const valueDataset = this.value._run(
{ typed: false, value: entryValue },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key: entryKey,
value: entryValue
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!keyDataset.typed || !valueDataset.typed) {
dataset.typed = false;
}
if (keyDataset.typed) {
dataset.value[keyDataset.value] = valueDataset.value;
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/record/recordAsync.ts
function recordAsync(key, value2, message) {
return {
kind: "schema",
type: "record",
reference: recordAsync,
expects: "Object",
async: true,
key,
value: value2,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
const datasets = await Promise.all(
Object.entries(input).filter(([key2]) => _isValidObjectKey(input, key2)).map(
([entryKey, entryValue]) => Promise.all([
entryKey,
entryValue,
this.key._run({ typed: false, value: entryKey }, config2),
this.value._run({ typed: false, value: entryValue }, config2)
])
)
);
for (const [
entryKey,
entryValue,
keyDataset,
valueDataset
] of datasets) {
if (keyDataset.issues) {
const pathItem = {
type: "object",
origin: "key",
input,
key: entryKey,
value: entryValue
};
for (const issue of keyDataset.issues) {
issue.path = [pathItem];
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = keyDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key: entryKey,
value: entryValue
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!keyDataset.typed || !valueDataset.typed) {
dataset.typed = false;
}
if (keyDataset.typed) {
dataset.value[keyDataset.value] = valueDataset.value;
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/set/set.ts
function set(value2, message) {
return {
kind: "schema",
type: "set",
reference: set,
expects: "Set",
async: false,
value: value2,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input instanceof Set) {
dataset.typed = true;
dataset.value = /* @__PURE__ */ new Set();
for (const inputValue of input) {
const valueDataset = this.value._run(
{ typed: false, value: inputValue },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "set",
origin: "value",
input,
key: null,
value: inputValue
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
dataset.value.add(valueDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/set/setAsync.ts
function setAsync(value2, message) {
return {
kind: "schema",
type: "set",
reference: setAsync,
expects: "Set",
async: true,
value: value2,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input instanceof Set) {
dataset.typed = true;
dataset.value = /* @__PURE__ */ new Set();
const valueDatasets = await Promise.all(
[...input].map(
async (inputValue) => [
inputValue,
await this.value._run(
{ typed: false, value: inputValue },
config2
)
]
)
);
for (const [inputValue, valueDataset] of valueDatasets) {
if (valueDataset.issues) {
const pathItem = {
type: "set",
origin: "value",
input,
key: null,
value: inputValue
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
dataset.value.add(valueDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/strictObject/strictObject.ts
function strictObject(entries, message) {
return {
kind: "schema",
type: "strict_object",
reference: strictObject,
expects: "Object",
async: false,
entries,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
for (const key in this.entries) {
const value2 = input[key];
const valueDataset = this.entries[key]._run(
{ typed: false, value: value2 },
config2
);
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
if (!dataset.issues || !config2.abortEarly) {
for (const key in input) {
if (!(key in this.entries)) {
const value2 = input[key];
_addIssue(this, "type", dataset, config2, {
input: value2,
expected: "never",
path: [
{
type: "object",
origin: "value",
input,
key,
value: value2
}
]
});
break;
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/strictObject/strictObjectAsync.ts
function strictObjectAsync(entries, message) {
return {
kind: "schema",
type: "strict_object",
reference: strictObjectAsync,
expects: "Object",
async: true,
entries,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
dataset.typed = true;
dataset.value = {};
const valueDatasets = await Promise.all(
Object.entries(this.entries).map(async ([key, schema]) => {
const value2 = input[key];
return [
key,
value2,
await schema._run({ typed: false, value: value2 }, config2)
];
})
);
for (const [key, value2, valueDataset] of valueDatasets) {
if (valueDataset.issues) {
const pathItem = {
type: "object",
origin: "value",
input,
key,
value: value2
};
for (const issue of valueDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = valueDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!valueDataset.typed) {
dataset.typed = false;
}
if (valueDataset.value !== void 0 || key in input) {
dataset.value[key] = valueDataset.value;
}
}
if (!dataset.issues || !config2.abortEarly) {
for (const key in input) {
if (!(key in this.entries)) {
const value2 = input[key];
_addIssue(this, "type", dataset, config2, {
input: value2,
expected: "never",
path: [
{
type: "object",
origin: "value",
input,
key,
value: value2
}
]
});
break;
}
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/strictTuple/strictTuple.ts
function strictTuple(items, message) {
return {
kind: "schema",
type: "strict_tuple",
reference: strictTuple,
expects: "Array",
async: false,
items,
message,
_run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
for (let key = 0; key < this.items.length; key++) {
const value2 = input[key];
const itemDataset = this.items[key]._run(
{ typed: false, value: value2 },
config2
);
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
if (!(dataset.issues && config2.abortEarly) && this.items.length < input.length) {
const value2 = input[items.length];
_addIssue(this, "type", dataset, config2, {
input: value2,
expected: "never",
path: [
{
type: "array",
origin: "value",
input,
key: this.items.length,
value: value2
}
]
});
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/strictTuple/strictTupleAsync.ts
function strictTupleAsync(items, message) {
return {
kind: "schema",
type: "strict_tuple",
reference: strictTupleAsync,
expects: "Array",
async: true,
items,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
const itemDatasets = await Promise.all(
this.items.map(async (item, key) => {
const value2 = input[key];
return [
key,
value2,
await item._run({ typed: false, value: value2 }, config2)
];
})
);
for (const [key, value2, itemDataset] of itemDatasets) {
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
if (!(dataset.issues && config2.abortEarly) && this.items.length < input.length) {
const value2 = input[items.length];
_addIssue(this, "type", dataset, config2, {
input: value2,
expected: "never",
path: [
{
type: "array",
origin: "value",
input,
key: this.items.length,
value: value2
}
]
});
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/string/string.ts
function string(message) {
return {
kind: "schema",
type: "string",
reference: string,
expects: "string",
async: false,
message,
_run(dataset, config2) {
if (typeof dataset.value === "string") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/symbol/symbol.ts
function symbol(message) {
return {
kind: "schema",
type: "symbol",
reference: symbol,
expects: "symbol",
async: false,
message,
_run(dataset, config2) {
if (typeof dataset.value === "symbol") {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/tuple/tuple.ts
function tuple(items, message) {
return {
kind: "schema",
type: "tuple",
reference: tuple,
expects: "Array",
async: false,
items,
message,
_run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
for (let key = 0; key < this.items.length; key++) {
const value2 = input[key];
const itemDataset = this.items[key]._run(
{ typed: false, value: value2 },
config2
);
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/tuple/tupleAsync.ts
function tupleAsync(items, message) {
return {
kind: "schema",
type: "tuple",
reference: tupleAsync,
expects: "Array",
async: true,
items,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
const itemDatasets = await Promise.all(
this.items.map(async (item, key) => {
const value2 = input[key];
return [
key,
value2,
await item._run({ typed: false, value: value2 }, config2)
];
})
);
for (const [key, value2, itemDataset] of itemDatasets) {
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/tupleWithRest/tupleWithRest.ts
function tupleWithRest(items, rest, message) {
return {
kind: "schema",
type: "tuple_with_rest",
reference: tupleWithRest,
expects: "Array",
async: false,
items,
rest,
message,
_run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
for (let key = 0; key < this.items.length; key++) {
const value2 = input[key];
const itemDataset = this.items[key]._run(
{ typed: false, value: value2 },
config2
);
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
if (!dataset.issues || !config2.abortEarly) {
for (let key = this.items.length; key < input.length; key++) {
const value2 = input[key];
const itemDataset = this.rest._run({ typed: false, value: value2 }, config2);
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/tupleWithRest/tupleWithRestAsync.ts
function tupleWithRestAsync(items, rest, message) {
return {
kind: "schema",
type: "tuple_with_rest",
reference: tupleWithRestAsync,
expects: "Array",
async: true,
items,
rest,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (Array.isArray(input)) {
dataset.typed = true;
dataset.value = [];
const [normalDatasets, restDatasets] = await Promise.all([
// Parse schema of each normal item
Promise.all(
this.items.map(async (item, key) => {
const value2 = input[key];
return [
key,
value2,
await item._run({ typed: false, value: value2 }, config2)
];
})
),
// Parse other items with rest schema
Promise.all(
input.slice(this.items.length).map(async (value2, key) => {
return [
key + this.items.length,
value2,
await this.rest._run({ typed: false, value: value2 }, config2)
];
})
)
]);
for (const [key, value2, itemDataset] of normalDatasets) {
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
if (!dataset.issues || !config2.abortEarly) {
for (const [key, value2, itemDataset] of restDatasets) {
if (itemDataset.issues) {
const pathItem = {
type: "array",
origin: "value",
input,
key,
value: value2
};
for (const issue of itemDataset.issues) {
if (issue.path) {
issue.path.unshift(pathItem);
} else {
issue.path = [pathItem];
}
dataset.issues?.push(issue);
}
if (!dataset.issues) {
dataset.issues = itemDataset.issues;
}
if (config2.abortEarly) {
dataset.typed = false;
break;
}
}
if (!itemDataset.typed) {
dataset.typed = false;
}
dataset.value.push(itemDataset.value);
}
}
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/undefined/undefined.ts
function undefined_(message) {
return {
kind: "schema",
type: "undefined",
reference: undefined_,
expects: "undefined",
async: false,
message,
_run(dataset, config2) {
if (dataset.value === void 0) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/union/utils/_subIssues/_subIssues.ts
function _subIssues(datasets) {
let issues;
if (datasets) {
for (const dataset of datasets) {
if (issues) {
issues.push(...dataset.issues);
} else {
issues = dataset.issues;
}
}
}
return issues;
}
// src/schemas/union/union.ts
function union(options, message) {
return {
kind: "schema",
type: "union",
reference: union,
expects: [...new Set(options.map((option) => option.expects))].join(" | ") || "never",
async: false,
options,
message,
_run(dataset, config2) {
let validDataset;
let typedDatasets;
let untypedDatasets;
for (const schema of this.options) {
const optionDataset = schema._run(
{ typed: false, value: dataset.value },
config2
);
if (optionDataset.typed) {
if (optionDataset.issues) {
if (typedDatasets) {
typedDatasets.push(optionDataset);
} else {
typedDatasets = [optionDataset];
}
} else {
validDataset = optionDataset;
break;
}
} else {
if (untypedDatasets) {
untypedDatasets.push(optionDataset);
} else {
untypedDatasets = [optionDataset];
}
}
}
if (validDataset) {
return validDataset;
}
if (typedDatasets) {
if (typedDatasets.length === 1) {
return typedDatasets[0];
}
_addIssue(this, "type", dataset, config2, {
issues: _subIssues(typedDatasets)
});
dataset.typed = true;
} else if (untypedDatasets?.length === 1) {
return untypedDatasets[0];
} else {
_addIssue(this, "type", dataset, config2, {
issues: _subIssues(untypedDatasets)
});
}
return dataset;
}
};
}
// src/schemas/union/unionAsync.ts
function unionAsync(options, message) {
return {
kind: "schema",
type: "union",
reference: unionAsync,
expects: [...new Set(options.map((option) => option.expects))].join(" | ") || "never",
async: true,
options,
message,
async _run(dataset, config2) {
let validDataset;
let typedDatasets;
let untypedDatasets;
for (const schema of this.options) {
const optionDataset = await schema._run(
{ typed: false, value: dataset.value },
config2
);
if (optionDataset.typed) {
if (optionDataset.issues) {
if (typedDatasets) {
typedDatasets.push(optionDataset);
} else {
typedDatasets = [optionDataset];
}
} else {
validDataset = optionDataset;
break;
}
} else {
if (untypedDatasets) {
untypedDatasets.push(optionDataset);
} else {
untypedDatasets = [optionDataset];
}
}
}
if (validDataset) {
return validDataset;
}
if (typedDatasets) {
if (typedDatasets.length === 1) {
return typedDatasets[0];
}
_addIssue(this, "type", dataset, config2, {
issues: _subIssues(typedDatasets)
});
dataset.typed = true;
} else if (untypedDatasets?.length === 1) {
return untypedDatasets[0];
} else {
_addIssue(this, "type", dataset, config2, {
issues: _subIssues(untypedDatasets)
});
}
return dataset;
}
};
}
// src/schemas/unknown/unknown.ts
function unknown() {
return {
kind: "schema",
type: "unknown",
reference: unknown,
expects: "unknown",
async: false,
_run(dataset) {
dataset.typed = true;
return dataset;
}
};
}
// src/schemas/variant/utils/_discriminators/_discriminators.ts
function _discriminators(key, options, set2 = /* @__PURE__ */ new Set()) {
for (const schema of options) {
if (schema.type === "variant") {
_discriminators(key, schema.options, set2);
} else {
set2.add(schema.entries[key].expects);
}
}
return set2;
}
// src/schemas/variant/variant.ts
function variant(key, options, message) {
let expectedDiscriminators;
return {
kind: "schema",
type: "variant",
reference: variant,
expects: "Object",
async: false,
key,
options,
message,
_run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
const discriminator = input[this.key];
if (this.key in input) {
let outputDataset;
for (const schema of this.options) {
if (schema.type === "variant" || !schema.entries[this.key]._run(
{ typed: false, value: discriminator },
config2
).issues) {
const optionDataset = schema._run(
{ typed: false, value: input },
config2
);
if (!optionDataset.issues) {
return optionDataset;
}
if (!outputDataset || !outputDataset.typed && optionDataset.typed) {
outputDataset = optionDataset;
}
}
}
if (outputDataset) {
return outputDataset;
}
}
if (!expectedDiscriminators) {
expectedDiscriminators = [..._discriminators(this.key, this.options)].join(" | ") || "never";
}
_addIssue(this, "type", dataset, config2, {
input: discriminator,
expected: expectedDiscriminators,
path: [
{
type: "object",
origin: "value",
input,
key: this.key,
value: discriminator
}
]
});
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/variant/variantAsync.ts
function variantAsync(key, options, message) {
let expectedDiscriminators;
return {
kind: "schema",
type: "variant",
reference: variantAsync,
expects: "Object",
async: true,
key,
options,
message,
async _run(dataset, config2) {
const input = dataset.value;
if (input && typeof input === "object") {
const discriminator = input[this.key];
if (this.key in input) {
let outputDataset;
for (const schema of this.options) {
if (schema.type === "variant" || !(await schema.entries[this.key]._run(
{ typed: false, value: discriminator },
config2
)).issues) {
const optionDataset = await schema._run(
{ typed: false, value: input },
config2
);
if (!optionDataset.issues) {
return optionDataset;
}
if (!outputDataset || !outputDataset.typed && optionDataset.typed) {
outputDataset = optionDataset;
}
}
}
if (outputDataset) {
return outputDataset;
}
}
if (!expectedDiscriminators) {
expectedDiscriminators = [..._discriminators(this.key, this.options)].join(" | ") || "never";
}
_addIssue(this, "type", dataset, config2, {
input: discriminator,
expected: expectedDiscriminators,
path: [
{
type: "object",
origin: "value",
input,
key: this.key,
value: discriminator
}
]
});
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/schemas/void/void.ts
function void_(message) {
return {
kind: "schema",
type: "void",
reference: void_,
expects: "void",
async: false,
message,
_run(dataset, config2) {
if (dataset.value === void 0) {
dataset.typed = true;
} else {
_addIssue(this, "type", dataset, config2);
}
return dataset;
}
};
}
// src/methods/keyof/keyof.ts
function keyof(schema, message) {
return picklist(Object.keys(schema.entries), message);
}
// src/methods/omit/omit.ts
function omit(schema, keys) {
const entries = {
...schema.entries
};
for (const key of keys) {
delete entries[key];
}
return { ...schema, entries };
}
// src/methods/parse/parse.ts
function parse(schema, input, config2) {
const dataset = schema._run(
{ typed: false, value: input },
getGlobalConfig(config2)
);
if (dataset.issues) {
throw new ValiError(dataset.issues);
}
return dataset.value;
}
// src/methods/parse/parseAsync.ts
async function parseAsync(schema, input, config2) {
const dataset = await schema._run(
{ typed: false, value: input },
getGlobalConfig(config2)
);
if (dataset.issues) {
throw new ValiError(dataset.issues);
}
return dataset.value;
}
// src/methods/parser/parser.ts
function parser(schema, config2) {
const func = (input) => parse(schema, input, config2);
func.schema = schema;
func.config = config2;
return func;
}
// src/methods/parser/parserAsync.ts
function parserAsync(schema, config2) {
const func = (input) => parseAsync(schema, input, config2);
func.schema = schema;
func.config = config2;
return func;
}
// src/methods/partial/partial.ts
function partial(schema, keys) {
const entries = {};
for (const key in schema.entries) {
entries[key] = !keys || keys.includes(key) ? optional(schema.entries[key]) : schema.entries[key];
}
return { ...schema, entries };
}
// src/methods/partial/partialAsync.ts
function partialAsync(schema, keys) {
const entries = {};
for (const key in schema.entries) {
entries[key] = !keys || keys.includes(key) ? optionalAsync(schema.entries[key]) : schema.entries[key];
}
return { ...schema, entries };
}
// src/methods/pick/pick.ts
function pick(schema, keys) {
const entries = {};
for (const key of keys) {
entries[key] = schema.entries[key];
}
return { ...schema, entries };
}
// src/methods/pipe/pipe.ts
function pipe(...pipe2) {
return {
...pipe2[0],
pipe: pipe2,
_run(dataset, config2) {
for (let index = 0; index < pipe2.length; index++) {
if (dataset.issues && (pipe2[index].kind === "schema" || pipe2[index].kind === "transformation")) {
dataset.typed = false;
break;
}
if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
dataset = pipe2[index]._run(dataset, config2);
}
}
return dataset;
}
};
}
// src/methods/pipe/pipeAsync.ts
function pipeAsync(...pipe2) {
return {
...pipe2[0],
pipe: pipe2,
async: true,
async _run(dataset, config2) {
for (let index = 0; index < pipe2.length; index++) {
if (dataset.issues && (pipe2[index].kind === "schema" || pipe2[index].kind === "transformation")) {
dataset.typed = false;
break;
}
if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
dataset = await pipe2[index]._run(dataset, config2);
}
}
return dataset;
}
};
}
// src/methods/required/required.ts
function required(schema, arg2, arg3) {
const keys = Array.isArray(arg2) ? arg2 : void 0;
const message = Array.isArray(arg2) ? arg3 : arg2;
const entries = {};
for (const key in schema.entries) {
entries[key] = !keys || keys.includes(key) ? nonOptional(schema.entries[key], message) : schema.entries[key];
}
return { ...schema, entries };
}
// src/methods/required/requiredAsync.ts
function requiredAsync(schema, arg2, arg3) {
const keys = Array.isArray(arg2) ? arg2 : void 0;
const message = Array.isArray(arg2) ? arg3 : arg2;
const entries = {};
for (const key in schema.entries) {
entries[key] = !keys || keys.includes(key) ? nonOptionalAsync(schema.entries[key], message) : schema.entries[key];
}
return { ...schema, entries };
}
// src/methods/safeParse/safeParse.ts
function safeParse(schema, input, config2) {
const dataset = schema._run(
{ typed: false, value: input },
getGlobalConfig(config2)
);
return {
typed: dataset.typed,
success: !dataset.issues,
output: dataset.value,
issues: dataset.issues
};
}
// src/methods/safeParse/safeParseAsync.ts
async function safeParseAsync(schema, input, config2) {
const dataset = await schema._run(
{ typed: false, value: input },
getGlobalConfig(config2)
);
return {
typed: dataset.typed,
success: !dataset.issues,
output: dataset.value,
issues: dataset.issues
};
}
// src/methods/safeParser/safeParser.ts
function safeParser(schema, config2) {
const func = (input) => safeParse(schema, input, config2);
func.schema = schema;
func.config = config2;
return func;
}
// src/methods/safeParser/safeParserAsync.ts
function safeParserAsync(schema, config2) {
const func = (input) => safeParseAsync(schema, input, config2);
func.schema = schema;
func.config = config2;
return func;
}
// src/methods/unwrap/unwrap.ts
function unwrap(schema) {
return schema.wrapped;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
BIC_REGEX,
CUID2_REGEX,
DECIMAL_REGEX,
EMAIL_REGEX,
EMOJI_REGEX,
HEXADECIMAL_REGEX,
HEX_COLOR_REGEX,
IMEI_REGEX,
IPV4_REGEX,
IPV6_REGEX,
IP_REGEX,
ISO_DATE_REGEX,
ISO_DATE_TIME_REGEX,
ISO_TIMESTAMP_REGEX,
ISO_TIME_REGEX,
ISO_TIME_SECOND_REGEX,
ISO_WEEK_REGEX,
MAC48_REGEX,
MAC64_REGEX,
MAC_REGEX,
OCTAL_REGEX,
ULID_REGEX,
UUID_REGEX,
ValiError,
_addIssue,
_isLuhnAlgo,
_isValidObjectKey,
_stringify,
any,
array,
arrayAsync,
awaitAsync,
bic,
bigint,
blob,
boolean,
brand,
bytes,
check,
checkAsync,
checkItems,
config,
creditCard,
cuid2,
custom,
customAsync,
date,
decimal,
deleteGlobalConfig,
deleteGlobalMessage,
deleteSchemaMessage,
deleteSpecificMessage,
email,
emoji,
empty,
endsWith,
entriesFromList,
enum: null,
enum_,
everyItem,
excludes,
fallback,
fallbackAsync,
file,
filterItems,
findItem,
finite,
flatten,
forward,
forwardAsync,
function: null,
function_,
getDefault,
getDefaults,
getDefaultsAsync,
getDotPath,
getFallback,
getFallbacks,
getFallbacksAsync,
getGlobalConfig,
getGlobalMessage,
getSchemaMessage,
getSpecificMessage,
hash,
hexColor,
hexadecimal,
imei,
includes,
instance,
integer,
intersect,
intersectAsync,
ip,
ipv4,
ipv6,
is,
isOfKind,
isOfType,
isValiError,
isoDate,
isoDateTime,
isoTime,
isoTimeSecond,
isoTimestamp,
isoWeek,
keyof,
lazy,
lazyAsync,
length,
literal,
looseObject,
looseObjectAsync,
looseTuple,
looseTupleAsync,
mac,
mac48,
mac64,
map,
mapAsync,
mapItems,
maxBytes,
maxLength,
maxSize,
maxValue,
mimeType,
minBytes,
minLength,
minSize,
minValue,
multipleOf,
nan,
never,
nonEmpty,
nonNullable,
nonNullableAsync,
nonNullish,
nonNullishAsync,
nonOptional,
nonOptionalAsync,
normalize,
notBytes,
notLength,
notSize,
notValue,
null: null,
null_,
nullable,
nullableAsync,
nullish,
nullishAsync,
number,
object,
objectAsync,
objectWithRest,
objectWithRestAsync,
octal,
omit,
optional,
optionalAsync,
parse,
parseAsync,
parser,
parserAsync,
partial,
partialAsync,
partialCheck,
partialCheckAsync,
pick,
picklist,
pipe,
pipeAsync,
promise,
rawCheck,
rawCheckAsync,
rawTransform,
rawTransformAsync,
readonly,
record,
recordAsync,
reduceItems,
regex,
required,
requiredAsync,
safeInteger,
safeParse,
safeParseAsync,
safeParser,
safeParserAsync,
set,
setAsync,
setGlobalConfig,
setGlobalMessage,
setSchemaMessage,
setSpecificMessage,
size,
someItem,
sortItems,
startsWith,
strictObject,
strictObjectAsync,
strictTuple,
strictTupleAsync,
string,
symbol,
toLowerCase,
toMaxValue,
toMinValue,
toUpperCase,
transform,
transformAsync,
trim,
trimEnd,
trimStart,
tuple,
tupleAsync,
tupleWithRest,
tupleWithRestAsync,
ulid,
undefined,
undefined_,
union,
unionAsync,
unknown,
unwrap,
url,
uuid,
value,
variant,
variantAsync,
void: null,
void_
});
Выполнить команду
Для локальной разработки. Не используйте в интернете!