opnet
Version:
The perfect library for building Bitcoin-based applications.
1,634 lines (1,632 loc) • 183 kB
JavaScript
var dist = {};
var hasRequiredDist;
function requireDist () {
if (hasRequiredDist) return dist;
hasRequiredDist = 1;
let store$4;
function setGlobalConfig(config$1) {
store$4 = {
...store$4,
...config$1
};
}
// @__NO_SIDE_EFFECTS__
function getGlobalConfig(config$1) {
return {
lang: config$1?.lang ?? store$4?.lang,
message: config$1?.message,
abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
};
}
function deleteGlobalConfig() {
store$4 = void 0;
}
let store$3;
function setGlobalMessage(message$1, lang) {
if (!store$3) store$3 = /* @__PURE__ */ new Map();
store$3.set(lang, message$1);
}
// @__NO_SIDE_EFFECTS__
function getGlobalMessage(lang) {
return store$3?.get(lang);
}
function deleteGlobalMessage(lang) {
store$3?.delete(lang);
}
let store$2;
function setSchemaMessage(message$1, lang) {
if (!store$2) store$2 = /* @__PURE__ */ new Map();
store$2.set(lang, message$1);
}
// @__NO_SIDE_EFFECTS__
function getSchemaMessage(lang) {
return store$2?.get(lang);
}
function deleteSchemaMessage(lang) {
store$2?.delete(lang);
}
let store$1;
function setSpecificMessage(reference, message$1, lang) {
if (!store$1) store$1 = /* @__PURE__ */ new Map();
if (!store$1.get(reference)) store$1.set(reference, /* @__PURE__ */ new Map());
store$1.get(reference).set(lang, message$1);
}
// @__NO_SIDE_EFFECTS__
function getSpecificMessage(reference, lang) {
return store$1?.get(reference)?.get(lang);
}
function deleteSpecificMessage(reference, lang) {
store$1?.get(reference)?.delete(lang);
}
// @__NO_SIDE_EFFECTS__
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;
}
function _addIssue(context, label, dataset, config$1, other) {
const input = other && "input" in other ? other.input : dataset.value;
const expected = other?.expected ?? context.expects ?? null;
const received = other?.received ?? /* @__PURE__ */ _stringify(input);
const issue = {
kind: context.kind,
type: context.type,
input,
expected,
received,
message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
requirement: context.requirement,
path: other?.path,
issues: other?.issues,
lang: config$1.lang,
abortEarly: config$1.abortEarly,
abortPipeEarly: config$1.abortPipeEarly
};
const isSchema = context.kind === "schema";
const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
if (isSchema) dataset.typed = false;
if (dataset.issues) dataset.issues.push(issue);
else dataset.issues = [issue];
}
let textEncoder;
// @__NO_SIDE_EFFECTS__
function _getByteCount(input) {
if (!textEncoder) textEncoder = new TextEncoder();
return textEncoder.encode(input).length;
}
let segmenter;
// @__NO_SIDE_EFFECTS__
function _getGraphemeCount(input) {
if (!segmenter) segmenter = new Intl.Segmenter();
const segments = segmenter.segment(input);
let count = 0;
for (const _ of segments) count++;
return count;
}
// @__NO_SIDE_EFFECTS__
function _getLastMetadata(schema, type) {
if ("pipe" in schema) {
const nestedSchemas = [];
for (let index = schema.pipe.length - 1; index >= 0; index--) {
const item = schema.pipe[index];
if (item.kind === "schema" && "pipe" in item) nestedSchemas.push(item);
else if (item.kind === "metadata" && item.type === type) return item[type];
}
for (const nestedSchema of nestedSchemas) {
const result = /* @__PURE__ */ _getLastMetadata(nestedSchema, type);
if (result !== void 0) return result;
}
}
}
// @__NO_SIDE_EFFECTS__
function _getStandardProps(context) {
return {
version: 1,
vendor: "valibot",
validate(value$1) {
return context["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig());
}
};
}
let store;
// @__NO_SIDE_EFFECTS__
function _getWordCount(locales, input) {
if (!store) store = /* @__PURE__ */ new Map();
if (!store.get(locales)) store.set(locales, new Intl.Segmenter(locales, { granularity: "word" }));
const segments = store.get(locales).segment(input);
let count = 0;
for (const segment of segments) if (segment.isWordLike) count++;
return count;
}
const NON_DIGIT_REGEX = /\D/gu;
// @__NO_SIDE_EFFECTS__
function _isLuhnAlgo(input) {
const number$1 = input.replace(NON_DIGIT_REGEX, "");
let length$1 = number$1.length;
let bit = 1;
let sum = 0;
while (length$1) {
const value$1 = +number$1[--length$1];
bit ^= 1;
sum += bit ? [
0,
2,
4,
6,
8,
1,
3,
5,
7,
9
][value$1] : value$1;
}
return sum % 10 === 0;
}
// @__NO_SIDE_EFFECTS__
function _isValidObjectKey(object$1, key) {
return Object.hasOwn(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
}
// @__NO_SIDE_EFFECTS__
function _joinExpects(values$1, separator) {
const list = [...new Set(values$1)];
if (list.length > 1) return `(${list.join(` ${separator} `)})`;
return list[0] ?? "never";
}
// @__NO_SIDE_EFFECTS__
function entriesFromList(list, schema) {
const entries$1 = {};
for (const key of list) entries$1[key] = schema;
return entries$1;
}
// @__NO_SIDE_EFFECTS__
function entriesFromObjects(schemas) {
const entries$1 = {};
for (const schema of schemas) Object.assign(entries$1, schema.entries);
return entries$1;
}
// @__NO_SIDE_EFFECTS__
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;
}
// @__NO_SIDE_EFFECTS__
function isOfKind(kind, object$1) {
return object$1.kind === kind;
}
// @__NO_SIDE_EFFECTS__
function isOfType(type, object$1) {
return object$1.type === type;
}
// @__NO_SIDE_EFFECTS__
function isValiError(error) {
return error instanceof ValiError;
}
var ValiError = class extends Error {
/**
* Creates a Valibot error with useful information.
*
* @param issues The error issues.
*/
constructor(issues) {
super(issues[0].message);
this.name = "ValiError";
this.issues = issues;
}
};
// @__NO_SIDE_EFFECTS__
function args(schema) {
return {
kind: "transformation",
type: "args",
reference: args,
async: false,
schema,
"~run"(dataset, config$1) {
const func = dataset.value;
dataset.value = (...args_) => {
const argsDataset = this.schema["~run"]({ value: args_ }, config$1);
if (argsDataset.issues) throw new ValiError(argsDataset.issues);
return func(...argsDataset.value);
};
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function argsAsync(schema) {
return {
kind: "transformation",
type: "args",
reference: argsAsync,
async: false,
schema,
"~run"(dataset, config$1) {
const func = dataset.value;
dataset.value = async (...args$1) => {
const argsDataset = await schema["~run"]({ value: args$1 }, config$1);
if (argsDataset.issues) throw new ValiError(argsDataset.issues);
return func(...argsDataset.value);
};
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function awaitAsync() {
return {
kind: "transformation",
type: "await",
reference: awaitAsync,
async: true,
async "~run"(dataset) {
dataset.value = await dataset.value;
return dataset;
}
};
}
const BASE64_REGEX = /^(?:[\da-z+/]{4})*(?:[\da-z+/]{2}==|[\da-z+/]{3}=)?$/iu;
const BIC_REGEX = /^[A-Z]{6}(?!00)[\dA-Z]{2}(?:[\dA-Z]{3})?$/u;
const CUID2_REGEX = /^[a-z][\da-z]*$/u;
const DECIMAL_REGEX = /^[+-]?(?:\d*\.)?\d+$/u;
const DIGITS_REGEX = /^\d+$/u;
const EMAIL_REGEX = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
const EMOJI_REGEX = /^(?:[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|(?![\p{Emoji_Modifier_Base}\u{1F1E6}-\u{1F1FF}])\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|(?![\p{Emoji_Modifier_Base}\u{1F1E6}-\u{1F1FF}])\p{Emoji_Presentation}))*)+$/u;
const HEXADECIMAL_REGEX = /^(?:0[hx])?[\da-fA-F]+$/u;
const HEX_COLOR_REGEX = /^#(?:[\da-fA-F]{3,4}|[\da-fA-F]{6}|[\da-fA-F]{8})$/u;
const IMEI_REGEX = /^\d{15}$|^\d{2}-\d{6}-\d{6}-\d$/u;
const IPV4_REGEX = /^(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])(?:\.(?:(?:[1-9]|1\d|2[0-4])?\d|25[0-5])){3}$/u;
const 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;
const 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;
const ISO_DATE_REGEX = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])$/u;
const 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;
const ISO_TIME_REGEX = /^(?:0\d|1\d|2[0-3]):[0-5]\d$/u;
const ISO_TIME_SECOND_REGEX = /^(?:0\d|1\d|2[0-3])(?::[0-5]\d){2}$/u;
const 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;
const ISO_WEEK_REGEX = /^\d{4}-W(?:0[1-9]|[1-4]\d|5[0-3])$/u;
const MAC48_REGEX = /^(?:[\da-f]{2}:){5}[\da-f]{2}$|^(?:[\da-f]{2}-){5}[\da-f]{2}$|^(?:[\da-f]{4}\.){2}[\da-f]{4}$/iu;
const 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;
const 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;
const NANO_ID_REGEX = /^[\w-]+$/u;
const OCTAL_REGEX = /^(?:0o)?[0-7]+$/u;
const RFC_EMAIL_REGEX = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
const SLUG_REGEX = /^[\da-z]+(?:[-_][\da-z]+)*$/u;
const ULID_REGEX = /^[\da-hjkmnp-tv-zA-HJKMNP-TV-Z]{26}$/u;
const UUID_REGEX = /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu;
// @__NO_SIDE_EFFECTS__
function base64(message$1) {
return {
kind: "validation",
type: "base64",
reference: base64,
async: false,
expects: null,
requirement: BASE64_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "Base64", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function bic(message$1) {
return {
kind: "validation",
type: "bic",
reference: bic,
async: false,
expects: null,
requirement: BIC_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "BIC", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function brand(name) {
return {
kind: "transformation",
type: "brand",
reference: brand,
async: false,
name,
"~run"(dataset) {
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function bytes(requirement, message$1) {
return {
kind: "validation",
type: "bytes",
reference: bytes,
async: false,
expects: `${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const length$1 = /* @__PURE__ */ _getByteCount(dataset.value);
if (length$1 !== this.requirement) _addIssue(this, "bytes", dataset, config$1, { received: `${length$1}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function check(requirement, message$1) {
return {
kind: "validation",
type: "check",
reference: check,
async: false,
expects: null,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function checkAsync(requirement, message$1) {
return {
kind: "validation",
type: "check",
reference: checkAsync,
async: true,
expects: null,
requirement,
message: message$1,
async "~run"(dataset, config$1) {
if (dataset.typed && !await this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function checkItems(requirement, message$1) {
return {
kind: "validation",
type: "check_items",
reference: checkItems,
async: false,
expects: null,
requirement,
message: message$1,
"~run"(dataset, config$1) {
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, config$1, {
input: item,
path: [{
type: "array",
origin: "value",
input: dataset.value,
key: index,
value: item
}]
});
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function checkItemsAsync(requirement, message$1) {
return {
kind: "validation",
type: "check_items",
reference: checkItemsAsync,
async: true,
expects: null,
requirement,
message: message$1,
async "~run"(dataset, config$1) {
if (dataset.typed) {
const requirementResults = await Promise.all(dataset.value.map(this.requirement));
for (let index = 0; index < dataset.value.length; index++) if (!requirementResults[index]) {
const item = dataset.value[index];
_addIssue(this, "item", dataset, config$1, {
input: item,
path: [{
type: "array",
origin: "value",
input: dataset.value,
key: index,
value: item
}]
});
}
}
return dataset;
}
};
}
const CREDIT_CARD_REGEX = /^(?:\d{14,19}|\d{4}(?: \d{3,6}){2,4}|\d{4}(?:-\d{3,6}){2,4})$/u;
const SANITIZE_REGEX = /[- ]/gu;
const PROVIDER_REGEX_LIST = [
/^3[47]\d{13}$/u,
/^3(?:0[0-5]|[68]\d)\d{11,13}$/u,
/^6(?:011|5\d{2})\d{12,15}$/u,
/^(?:2131|1800|35\d{3})\d{11}$/u,
/^5[1-5]\d{2}|(?:222\d|22[3-9]\d|2[3-6]\d{2}|27[01]\d|2720)\d{12}$/u,
/^(?:6[27]\d{14,17}|81\d{14,17})$/u,
/^4\d{12}(?:\d{3,6})?$/u
];
// @__NO_SIDE_EFFECTS__
function creditCard(message$1) {
return {
kind: "validation",
type: "credit_card",
reference: creditCard,
async: false,
expects: null,
requirement(input) {
let sanitized;
return CREDIT_CARD_REGEX.test(input) && (sanitized = input.replace(SANITIZE_REGEX, "")) && PROVIDER_REGEX_LIST.some((regex$1) => regex$1.test(sanitized)) && /* @__PURE__ */ _isLuhnAlgo(sanitized);
},
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "credit card", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function cuid2(message$1) {
return {
kind: "validation",
type: "cuid2",
reference: cuid2,
async: false,
expects: null,
requirement: CUID2_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "Cuid2", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function decimal(message$1) {
return {
kind: "validation",
type: "decimal",
reference: decimal,
async: false,
expects: null,
requirement: DECIMAL_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "decimal", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function description(description_) {
return {
kind: "metadata",
type: "description",
reference: description,
description: description_
};
}
// @__NO_SIDE_EFFECTS__
function digits(message$1) {
return {
kind: "validation",
type: "digits",
reference: digits,
async: false,
expects: null,
requirement: DIGITS_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "digits", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function email(message$1) {
return {
kind: "validation",
type: "email",
reference: email,
expects: null,
async: false,
requirement: EMAIL_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "email", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function emoji(message$1) {
return {
kind: "validation",
type: "emoji",
reference: emoji,
async: false,
expects: null,
requirement: EMOJI_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "emoji", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function empty(message$1) {
return {
kind: "validation",
type: "empty",
reference: empty,
async: false,
expects: "0",
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.length > 0) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function endsWith(requirement, message$1) {
return {
kind: "validation",
type: "ends_with",
reference: endsWith,
async: false,
expects: `"${requirement}"`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !dataset.value.endsWith(this.requirement)) _addIssue(this, "end", dataset, config$1, { received: `"${dataset.value.slice(-this.requirement.length)}"` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function entries(requirement, message$1) {
return {
kind: "validation",
type: "entries",
reference: entries,
async: false,
expects: `${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (!dataset.typed) return dataset;
const count = Object.keys(dataset.value).length;
if (dataset.typed && count !== this.requirement) _addIssue(this, "entries", dataset, config$1, { received: `${count}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function everyItem(requirement, message$1) {
return {
kind: "validation",
type: "every_item",
reference: everyItem,
async: false,
expects: null,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !dataset.value.every(this.requirement)) _addIssue(this, "item", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function examples(examples_) {
return {
kind: "metadata",
type: "examples",
reference: examples,
examples: examples_
};
}
// @__NO_SIDE_EFFECTS__
function excludes(requirement, message$1) {
const received = /* @__PURE__ */ _stringify(requirement);
return {
kind: "validation",
type: "excludes",
reference: excludes,
async: false,
expects: `!${received}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.includes(this.requirement)) _addIssue(this, "content", dataset, config$1, { received });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
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;
}
};
}
// @__NO_SIDE_EFFECTS__
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;
}
};
}
// @__NO_SIDE_EFFECTS__
function finite(message$1) {
return {
kind: "validation",
type: "finite",
reference: finite,
async: false,
expects: null,
requirement: Number.isFinite,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "finite", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function flavor(name) {
return {
kind: "transformation",
type: "flavor",
reference: flavor,
async: false,
name,
"~run"(dataset) {
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function graphemes(requirement, message$1) {
return {
kind: "validation",
type: "graphemes",
reference: graphemes,
async: false,
expects: `${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getGraphemeCount(dataset.value);
if (count !== this.requirement) _addIssue(this, "graphemes", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function gtValue(requirement, message$1) {
return {
kind: "validation",
type: "gt_value",
reference: gtValue,
async: false,
expects: `>${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !(dataset.value > this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
return dataset;
}
};
}
const 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
};
// @__NO_SIDE_EFFECTS__
function hash(types, message$1) {
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: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "hash", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function hexadecimal(message$1) {
return {
kind: "validation",
type: "hexadecimal",
reference: hexadecimal,
async: false,
expects: null,
requirement: HEXADECIMAL_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "hexadecimal", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function hexColor(message$1) {
return {
kind: "validation",
type: "hex_color",
reference: hexColor,
async: false,
expects: null,
requirement: HEX_COLOR_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "hex color", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function imei(message$1) {
return {
kind: "validation",
type: "imei",
reference: imei,
async: false,
expects: null,
requirement(input) {
return IMEI_REGEX.test(input) && /* @__PURE__ */ _isLuhnAlgo(input);
},
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "IMEI", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function includes(requirement, message$1) {
const expects = /* @__PURE__ */ _stringify(requirement);
return {
kind: "validation",
type: "includes",
reference: includes,
async: false,
expects,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !dataset.value.includes(this.requirement)) _addIssue(this, "content", dataset, config$1, { received: `!${expects}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function integer(message$1) {
return {
kind: "validation",
type: "integer",
reference: integer,
async: false,
expects: null,
requirement: Number.isInteger,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function ip(message$1) {
return {
kind: "validation",
type: "ip",
reference: ip,
async: false,
expects: null,
requirement: IP_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "IP", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function ipv4(message$1) {
return {
kind: "validation",
type: "ipv4",
reference: ipv4,
async: false,
expects: null,
requirement: IPV4_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "IPv4", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function ipv6(message$1) {
return {
kind: "validation",
type: "ipv6",
reference: ipv6,
async: false,
expects: null,
requirement: IPV6_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "IPv6", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function isoDate(message$1) {
return {
kind: "validation",
type: "iso_date",
reference: isoDate,
async: false,
expects: null,
requirement: ISO_DATE_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "date", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function isoDateTime(message$1) {
return {
kind: "validation",
type: "iso_date_time",
reference: isoDateTime,
async: false,
expects: null,
requirement: ISO_DATE_TIME_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "date-time", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function isoTime(message$1) {
return {
kind: "validation",
type: "iso_time",
reference: isoTime,
async: false,
expects: null,
requirement: ISO_TIME_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "time", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function isoTimeSecond(message$1) {
return {
kind: "validation",
type: "iso_time_second",
reference: isoTimeSecond,
async: false,
expects: null,
requirement: ISO_TIME_SECOND_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "time-second", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function isoTimestamp(message$1) {
return {
kind: "validation",
type: "iso_timestamp",
reference: isoTimestamp,
async: false,
expects: null,
requirement: ISO_TIMESTAMP_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "timestamp", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function isoWeek(message$1) {
return {
kind: "validation",
type: "iso_week",
reference: isoWeek,
async: false,
expects: null,
requirement: ISO_WEEK_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "week", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function length(requirement, message$1) {
return {
kind: "validation",
type: "length",
reference: length,
async: false,
expects: `${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.length !== this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function ltValue(requirement, message$1) {
return {
kind: "validation",
type: "lt_value",
reference: ltValue,
async: false,
expects: `<${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !(dataset.value < this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function mac(message$1) {
return {
kind: "validation",
type: "mac",
reference: mac,
async: false,
expects: null,
requirement: MAC_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "MAC", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function mac48(message$1) {
return {
kind: "validation",
type: "mac48",
reference: mac48,
async: false,
expects: null,
requirement: MAC48_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "48-bit MAC", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function mac64(message$1) {
return {
kind: "validation",
type: "mac64",
reference: mac64,
async: false,
expects: null,
requirement: MAC64_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "64-bit MAC", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
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;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxBytes(requirement, message$1) {
return {
kind: "validation",
type: "max_bytes",
reference: maxBytes,
async: false,
expects: `<=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const length$1 = /* @__PURE__ */ _getByteCount(dataset.value);
if (length$1 > this.requirement) _addIssue(this, "bytes", dataset, config$1, { received: `${length$1}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxEntries(requirement, message$1) {
return {
kind: "validation",
type: "max_entries",
reference: maxEntries,
async: false,
expects: `<=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (!dataset.typed) return dataset;
const count = Object.keys(dataset.value).length;
if (dataset.typed && count > this.requirement) _addIssue(this, "entries", dataset, config$1, { received: `${count}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxGraphemes(requirement, message$1) {
return {
kind: "validation",
type: "max_graphemes",
reference: maxGraphemes,
async: false,
expects: `<=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getGraphemeCount(dataset.value);
if (count > this.requirement) _addIssue(this, "graphemes", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxLength(requirement, message$1) {
return {
kind: "validation",
type: "max_length",
reference: maxLength,
async: false,
expects: `<=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.length > this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxSize(requirement, message$1) {
return {
kind: "validation",
type: "max_size",
reference: maxSize,
async: false,
expects: `<=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.size > this.requirement) _addIssue(this, "size", dataset, config$1, { received: `${dataset.value.size}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxValue(requirement, message$1) {
return {
kind: "validation",
type: "max_value",
reference: maxValue,
async: false,
expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !(dataset.value <= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function maxWords(locales, requirement, message$1) {
return {
kind: "validation",
type: "max_words",
reference: maxWords,
async: false,
expects: `<=${requirement}`,
locales,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getWordCount(this.locales, dataset.value);
if (count > this.requirement) _addIssue(this, "words", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function metadata(metadata_) {
return {
kind: "metadata",
type: "metadata",
reference: metadata,
metadata: metadata_
};
}
// @__NO_SIDE_EFFECTS__
function mimeType(requirement, message$1) {
return {
kind: "validation",
type: "mime_type",
reference: mimeType,
async: false,
expects: /* @__PURE__ */ _joinExpects(requirement.map((option) => `"${option}"`), "|"),
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.includes(dataset.value.type)) _addIssue(this, "MIME type", dataset, config$1, { received: `"${dataset.value.type}"` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minBytes(requirement, message$1) {
return {
kind: "validation",
type: "min_bytes",
reference: minBytes,
async: false,
expects: `>=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const length$1 = /* @__PURE__ */ _getByteCount(dataset.value);
if (length$1 < this.requirement) _addIssue(this, "bytes", dataset, config$1, { received: `${length$1}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minEntries(requirement, message$1) {
return {
kind: "validation",
type: "min_entries",
reference: minEntries,
async: false,
expects: `>=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (!dataset.typed) return dataset;
const count = Object.keys(dataset.value).length;
if (dataset.typed && count < this.requirement) _addIssue(this, "entries", dataset, config$1, { received: `${count}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minGraphemes(requirement, message$1) {
return {
kind: "validation",
type: "min_graphemes",
reference: minGraphemes,
async: false,
expects: `>=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getGraphemeCount(dataset.value);
if (count < this.requirement) _addIssue(this, "graphemes", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minLength(requirement, message$1) {
return {
kind: "validation",
type: "min_length",
reference: minLength,
async: false,
expects: `>=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minSize(requirement, message$1) {
return {
kind: "validation",
type: "min_size",
reference: minSize,
async: false,
expects: `>=${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.size < this.requirement) _addIssue(this, "size", dataset, config$1, { received: `${dataset.value.size}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minValue(requirement, message$1) {
return {
kind: "validation",
type: "min_value",
reference: minValue,
async: false,
expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function minWords(locales, requirement, message$1) {
return {
kind: "validation",
type: "min_words",
reference: minWords,
async: false,
expects: `>=${requirement}`,
locales,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getWordCount(this.locales, dataset.value);
if (count < this.requirement) _addIssue(this, "words", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function multipleOf(requirement, message$1) {
return {
kind: "validation",
type: "multiple_of",
reference: multipleOf,
async: false,
expects: `%${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value % this.requirement != 0) _addIssue(this, "multiple", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function nanoid(message$1) {
return {
kind: "validation",
type: "nanoid",
reference: nanoid,
async: false,
expects: null,
requirement: NANO_ID_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "Nano ID", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function nonEmpty(message$1) {
return {
kind: "validation",
type: "non_empty",
reference: nonEmpty,
async: false,
expects: "!0",
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.length === 0) _addIssue(this, "length", dataset, config$1, { received: "0" });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function normalize(form) {
return {
kind: "transformation",
type: "normalize",
reference: normalize,
async: false,
form,
"~run"(dataset) {
dataset.value = dataset.value.normalize(this.form);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notBytes(requirement, message$1) {
return {
kind: "validation",
type: "not_bytes",
reference: notBytes,
async: false,
expects: `!${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const length$1 = /* @__PURE__ */ _getByteCount(dataset.value);
if (length$1 === this.requirement) _addIssue(this, "bytes", dataset, config$1, { received: `${length$1}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notEntries(requirement, message$1) {
return {
kind: "validation",
type: "not_entries",
reference: notEntries,
async: false,
expects: `!${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (!dataset.typed) return dataset;
const count = Object.keys(dataset.value).length;
if (dataset.typed && count === this.requirement) _addIssue(this, "entries", dataset, config$1, { received: `${count}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notGraphemes(requirement, message$1) {
return {
kind: "validation",
type: "not_graphemes",
reference: notGraphemes,
async: false,
expects: `!${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getGraphemeCount(dataset.value);
if (count === this.requirement) _addIssue(this, "graphemes", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notLength(requirement, message$1) {
return {
kind: "validation",
type: "not_length",
reference: notLength,
async: false,
expects: `!${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.length === this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notSize(requirement, message$1) {
return {
kind: "validation",
type: "not_size",
reference: notSize,
async: false,
expects: `!${requirement}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && dataset.value.size === this.requirement) _addIssue(this, "size", dataset, config$1, { received: `${dataset.value.size}` });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notValue(requirement, message$1) {
return {
kind: "validation",
type: "not_value",
reference: notValue,
async: false,
expects: requirement instanceof Date ? `!${requirement.toJSON()}` : `!${/* @__PURE__ */ _stringify(requirement)}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && this.requirement <= dataset.value && this.requirement >= dataset.value) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notValues(requirement, message$1) {
return {
kind: "validation",
type: "not_values",
reference: notValues,
async: false,
expects: `!${/* @__PURE__ */ _joinExpects(requirement.map((value$1) => value$1 instanceof Date ? value$1.toJSON() : /* @__PURE__ */ _stringify(value$1)), "|")}`,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && this.requirement.some((value$1) => value$1 <= dataset.value && value$1 >= dataset.value)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function notWords(locales, requirement, message$1) {
return {
kind: "validation",
type: "not_words",
reference: notWords,
async: false,
expects: `!${requirement}`,
locales,
requirement,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed) {
const count = /* @__PURE__ */ _getWordCount(this.locales, dataset.value);
if (count === this.requirement) _addIssue(this, "words", dataset, config$1, { received: `${count}` });
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function octal(message$1) {
return {
kind: "validation",
type: "octal",
reference: octal,
async: false,
expects: null,
requirement: OCTAL_REGEX,
message: message$1,
"~run"(dataset, config$1) {
if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "octal", dataset, config$1);
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function parseJson(config$1, message$1) {
return {
kind: "transformation",
type: "parse_json",
reference: parseJson,
config: config$1,
message: message$1,
async: false,
"~run"(dataset, config$2) {
try {
dataset.value = JSON.parse(dataset.value, this.config?.reviver);
} catch (error) {
if (error instanceof Error) {
_addIssue(this, "JSON", dataset, config$2, { received: `"${error.message}"` });
dataset.typed = false;
} else throw error;
}
return dataset;
}
};
}
// @__NO_SIDE_EFFECTS__
function _isPartiallyTyped(dataset, paths) {
if (dataset.issues) for (const path of paths) for (const issue of dataset.issues) {
let typed = false;
const bound = Math.min(pat