diff --git a/dist/index.js b/dist/index.js
index aaecca1..de1e6e9 100644
--- a/dist/index.js
+++ b/dist/index.js
@@ -30942,5635 +30942,6 @@ var __webpack_exports__ = {};
 var core = __nccwpck_require__(7627);
 // EXTERNAL MODULE: ./node_modules/.pnpm/@actions+github@6.0.0/node_modules/@actions/github/lib/github.js
 var github = __nccwpck_require__(3802);
-;// CONCATENATED MODULE: ./node_modules/.pnpm/valibot@0.42.1_typescript@5.6.2/node_modules/valibot/dist/index.js
-// 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 BASE64_REGEX = /^(?:[\da-z+/]{4})*(?:[\da-z+/]{2}==|[\da-z+/]{3}=)?$/iu;
-var BIC_REGEX = /^[A-Z]{6}(?!00)[\dA-Z]{2}(?:[\dA-Z]{3})?$/u;
-var CUID2_REGEX = /^[a-z][\da-z]*$/u;
-var DECIMAL_REGEX = /^[+-]?\d+(?:\.\d+)?$/u;
-var DIGITS_REGEX = /^\d+$/u;
-var EMAIL_REGEX = /^[\w+-]+(?:\.[\w+-]+)*@[\da-z]+(?:[.-][\da-z]+)*\.[a-z]{2,}$/iu;
-var EMOJI_REGEX = (
-  // eslint-disable-next-line redos-detector/no-unsafe-regex, regexp/no-dupe-disjunctions -- false positives
-  /^(?:[\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_Presentation})(?:\u200D(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}))*)+$/u
-);
-var HEXADECIMAL_REGEX = /^(?:0[hx])?[\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 NANO_ID_REGEX = /^[\w-]+$/u;
-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}`,
-    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 ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
-  if (message) {
-    issue.message = typeof message === "function" ? (
-      // @ts-expect-error
-      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/_joinExpects/_joinExpects.ts
-function _joinExpects(values, separator) {
-  const list = [...new Set(values)];
-  if (list.length > 1) {
-    return `(${list.join(` ${separator} `)})`;
-  }
-  return list[0] ?? "never";
-}
-
-// 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/base64/base64.ts
-function base64(message) {
-  return {
-    kind: "validation",
-    type: "base64",
-    reference: base64,
-    async: false,
-    expects: null,
-    requirement: BASE64_REGEX,
-    message,
-    _run(dataset, config2) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) {
-        _addIssue(this, "Base64", dataset, config2);
-      }
-      return dataset;
-    }
-  };
-}
-
-// 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 = (/* unused pure expression or super */ null && ([
-  // 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/description/description.ts
-function description(description_) {
-  return {
-    kind: "metadata",
-    type: "description",
-    reference: description,
-    description: description_
-  };
-}
-
-// src/actions/digits/digits.ts
-function digits(message) {
-  return {
-    kind: "validation",
-    type: "digits",
-    reference: digits,
-    async: false,
-    expects: null,
-    requirement: DIGITS_REGEX,
-    message,
-    _run(dataset, config2) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) {
-        _addIssue(this, "digits", 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 dist_length(requirement, message) {
-  return {
-    kind: "validation",
-    type: "length",
-    reference: dist_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/metadata/metadata.ts
-function metadata(metadata_) {
-  return {
-    kind: "metadata",
-    type: "metadata",
-    reference: metadata,
-    metadata: metadata_
-  };
-}
-
-// src/actions/mimeType/mimeType.ts
-function mimeType(requirement, message) {
-  return {
-    kind: "validation",
-    type: "mime_type",
-    reference: mimeType,
-    async: false,
-    expects: _joinExpects(
-      requirement.map((option) => `"${option}"`),
-      "|"
-    ),
-    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/nanoid/nanoid.ts
-function nanoid(message) {
-  return {
-    kind: "validation",
-    type: "nanoid",
-    reference: nanoid,
-    async: false,
-    expects: null,
-    requirement: NANO_ID_REGEX,
-    message,
-    _run(dataset, config2) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) {
-        _addIssue(this, "Nano ID", 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/title/title.ts
-function title(title_) {
-  return {
-    kind: "metadata",
-    type: "title",
-    reference: title,
-    title: title_
-  };
-}
-
-// 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) {
-      const outputDataset = schema._run(dataset, config2);
-      return outputDataset.issues ? { typed: true, value: getFallback(this, outputDataset, config2) } : outputDataset;
-    }
-  };
-}
-
-// src/methods/fallback/fallbackAsync.ts
-function fallbackAsync(schema, fallback2) {
-  return {
-    ...schema,
-    fallback: fallback2,
-    async: true,
-    async _run(dataset, config2) {
-      const outputDataset = await schema._run(dataset, config2);
-      return outputDataset.issues ? (
-        // @ts-expect-error
-        { typed: true, value: await getFallback(this, outputDataset, config2) }
-      ) : outputDataset;
-    }
-  };
-}
-
-// 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 dist_boolean(message) {
-  return {
-    kind: "schema",
-    type: "boolean",
-    reference: dist_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: _joinExpects(options.map(_stringify), "|"),
-    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: _joinExpects(
-      options.map((option) => option.expects),
-      "&"
-    ),
-    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: _joinExpects(
-      options.map((option) => option.expects),
-      "&"
-    ),
-    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
-          // Hint: We do not distinguish between missing and `undefined` entries.
-          // The reason for this decision is that it reduces the bundle size, and
-          // we also expect that most users will expect this behavior.
-          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
-          // Hint: We exclude specific keys for security reasons
-          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: _joinExpects(options.map(_stringify), "|"),
-    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/undefinedable/undefinedable.ts
-function undefinedable(wrapped, ...args) {
-  const schema = {
-    kind: "schema",
-    type: "undefinedable",
-    reference: undefinedable,
-    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/undefinedable/undefinedableAsync.ts
-function undefinedableAsync(wrapped, ...args) {
-  const schema = {
-    kind: "schema",
-    type: "undefinedable",
-    reference: undefinedableAsync,
-    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/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: _joinExpects(
-      options.map((option) => option.expects),
-      "|"
-    ),
-    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: _joinExpects(
-      options.map((option) => option.expects),
-      "|"
-    ),
-    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/variant.ts
-function variant(key, options, message) {
-  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") {
-        let outputDataset;
-        let maxDiscriminatorPriority = 0;
-        let invalidDiscriminatorKey = this.key;
-        let expectedDiscriminators = [];
-        const parseOptions = (variant2, allKeys) => {
-          for (const schema of variant2.options) {
-            if (schema.type === "variant") {
-              parseOptions(schema, new Set(allKeys).add(schema.key));
-            } else {
-              let keysAreValid = true;
-              let currentPriority = 0;
-              for (const currentKey of allKeys) {
-                if (schema.entries[currentKey]._run(
-                  // @ts-expect-error
-                  { typed: false, value: input[currentKey] },
-                  config2
-                ).issues) {
-                  keysAreValid = false;
-                  if (invalidDiscriminatorKey !== currentKey && (maxDiscriminatorPriority < currentPriority || maxDiscriminatorPriority === currentPriority && currentKey in input && !(invalidDiscriminatorKey in input))) {
-                    maxDiscriminatorPriority = currentPriority;
-                    invalidDiscriminatorKey = currentKey;
-                    expectedDiscriminators = [];
-                  }
-                  if (invalidDiscriminatorKey === currentKey) {
-                    expectedDiscriminators.push(
-                      schema.entries[currentKey].expects
-                    );
-                  }
-                  break;
-                }
-                currentPriority++;
-              }
-              if (keysAreValid) {
-                const optionDataset = schema._run(
-                  { typed: false, value: input },
-                  config2
-                );
-                if (!outputDataset || !outputDataset.typed && optionDataset.typed) {
-                  outputDataset = optionDataset;
-                }
-              }
-            }
-            if (outputDataset && !outputDataset.issues) {
-              break;
-            }
-          }
-        };
-        parseOptions(this, /* @__PURE__ */ new Set([this.key]));
-        if (outputDataset) {
-          return outputDataset;
-        }
-        _addIssue(this, "type", dataset, config2, {
-          // @ts-expect-error
-          input: input[invalidDiscriminatorKey],
-          expected: _joinExpects(expectedDiscriminators, "|"),
-          path: [
-            {
-              type: "object",
-              origin: "value",
-              input,
-              key: invalidDiscriminatorKey,
-              // @ts-expect-error
-              value: input[invalidDiscriminatorKey]
-            }
-          ]
-        });
-      } else {
-        _addIssue(this, "type", dataset, config2);
-      }
-      return dataset;
-    }
-  };
-}
-
-// src/schemas/variant/variantAsync.ts
-function variantAsync(key, options, message) {
-  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") {
-        let outputDataset;
-        let maxDiscriminatorPriority = 0;
-        let invalidDiscriminatorKey = this.key;
-        let expectedDiscriminators = [];
-        const parseOptions = async (variant2, allKeys) => {
-          for (const schema of variant2.options) {
-            if (schema.type === "variant") {
-              await parseOptions(schema, new Set(allKeys).add(schema.key));
-            } else {
-              let keysAreValid = true;
-              let currentPriority = 0;
-              for (const currentKey of allKeys) {
-                if ((await schema.entries[currentKey]._run(
-                  // @ts-expect-error
-                  { typed: false, value: input[currentKey] },
-                  config2
-                )).issues) {
-                  keysAreValid = false;
-                  if (invalidDiscriminatorKey !== currentKey && (maxDiscriminatorPriority < currentPriority || maxDiscriminatorPriority === currentPriority && currentKey in input && !(invalidDiscriminatorKey in input))) {
-                    maxDiscriminatorPriority = currentPriority;
-                    invalidDiscriminatorKey = currentKey;
-                    expectedDiscriminators = [];
-                  }
-                  if (invalidDiscriminatorKey === currentKey) {
-                    expectedDiscriminators.push(
-                      schema.entries[currentKey].expects
-                    );
-                  }
-                  break;
-                }
-                currentPriority++;
-              }
-              if (keysAreValid) {
-                const optionDataset = await schema._run(
-                  { typed: false, value: input },
-                  config2
-                );
-                if (!outputDataset || !outputDataset.typed && optionDataset.typed) {
-                  outputDataset = optionDataset;
-                }
-              }
-            }
-            if (outputDataset && !outputDataset.issues) {
-              break;
-            }
-          }
-        };
-        await parseOptions(this, /* @__PURE__ */ new Set([this.key]));
-        if (outputDataset) {
-          return outputDataset;
-        }
-        _addIssue(this, "type", dataset, config2, {
-          // @ts-expect-error
-          input: input[invalidDiscriminatorKey],
-          expected: _joinExpects(expectedDiscriminators, "|"),
-          path: [
-            {
-              type: "object",
-              origin: "value",
-              input,
-              key: invalidDiscriminatorKey,
-              // @ts-expect-error
-              value: input[invalidDiscriminatorKey]
-            }
-          ]
-        });
-      } 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 (const item of pipe2) {
-        if (item.kind !== "metadata") {
-          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-            dataset.typed = false;
-            break;
-          }
-          if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
-            dataset = item._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 (const item of pipe2) {
-        if (item.kind !== "metadata") {
-          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-            dataset.typed = false;
-            break;
-          }
-          if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
-            dataset = await item._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;
-}
-
-
-;// CONCATENATED MODULE: ./src/parser.ts
-
-const StringSchema = string();
-const OptionalStringSchema = optional(string());
-const NullableStringSchema = nullable(string());
-const stringParser = parser(StringSchema);
-const optionalStringParser = parser(OptionalStringSchema);
-const nullableStringParser = parser(NullableStringSchema);
-
 ;// CONCATENATED MODULE: ./src/internal/utils.ts
 const convertRef = (str, { refType }) => {
     if (str === null || str === undefined)
@@ -36589,51 +30960,52 @@ const convertRef = (str, { refType }) => {
 
 ;// CONCATENATED MODULE: ./src/ref.ts
 
-
 const getRef = ({ eventName, payload }) => {
     switch (eventName) {
         case 'check_run':
-            return convertRef(nullableStringParser(payload.check_run.check_suite.head_branch), { refType: 'branch' });
+            return convertRef(payload.check_run.check_suite.head_branch, {
+                refType: 'branch'
+            });
         case 'check_suite':
-            return convertRef(nullableStringParser(payload.check_suite.head_branch), {
+            return convertRef(payload.check_suite.head_branch, {
                 refType: 'branch'
             });
         case 'create':
         case 'delete':
-            return convertRef(nullableStringParser(payload.ref), {
+            return convertRef(payload.ref, {
                 refType: payload.ref_type
             });
         case 'deployment_status':
-            return convertRef(optionalStringParser(payload.workflow_run?.head_branch), {
+            return convertRef(payload.workflow_run?.head_branch, {
                 refType: 'branch'
             });
         case 'issue_comment':
-            return convertRef(stringParser(payload.issue?.number.toString()), {
+            return convertRef(payload.issue.number.toString(), {
                 refType: 'pull'
             });
         case 'merge_group':
-            return stringParser(payload.merge_group.head_ref);
+            return payload.merge_group.head_ref;
         case 'pull_request':
         case 'pull_request_review':
         case 'pull_request_review_comment':
         case 'pull_request_target':
-            return convertRef(payload.pull_request?.number.toString(), {
+            return convertRef(payload.pull_request.number.toString(), {
                 refType: 'pull'
             });
         case 'push':
-            return stringParser(payload.ref);
+            return payload.ref;
         case 'registry_package':
-            return convertRef(optionalStringParser(payload.registry_package?.package_version?.release?.tag_name), {
+            return convertRef(payload.registry_package.package_version?.release?.tag_name, {
                 refType: 'tag'
             });
         case 'release':
-            return convertRef(stringParser(payload.release.tag_name), {
+            return convertRef(payload.release.tag_name, {
                 refType: 'tag'
             });
         case 'workflow_dispatch':
-            return stringParser(payload.ref);
+            return payload.ref;
         case 'workflow_run':
-            return convertRef(nullableStringParser(payload.workflow_run.head_branch), {
+            return convertRef(payload.workflow_run.head_branch, {
                 refType: 'branch'
             });
         default:
@@ -36690,19 +31062,19 @@ async function run() {
         const { token, branchNames, dryRun: isDryRun } = getInputs();
         const octokit = github.getOctokit(token);
         // get repostiory information
-        const { repo, eventName, payload } = github.context;
+        const context = github.context;
         const infoNull = (name) => {
             core.info(`🤔 Could not determine deletion target: ${name}`);
             core.info('ℹ️ If you suspect this is a bug, please consider raising an issue to help us address it promptly.');
             return [];
         };
         const refs = branchNames.length === 0
-            ? [getRef({ eventName, payload })].flatMap(x => x ? x : infoNull(eventName))
+            ? [getRef(context)].flatMap(x => (x ? x : infoNull(context.eventName)))
             : branchNames
                 .map(branchName => convertRef(branchName, { refType: 'branch' }))
                 .filter(ref => ref !== null);
         for (const ref of refs) {
-            await deleteRefActionsCaches(octokit, repo, ref, isDryRun);
+            await deleteRefActionsCaches(octokit, context.repo, ref, isDryRun);
         }
         core.info(`${prefix({ isDryRun })}✅ Done`);
     }
diff --git a/dist/licenses.txt b/dist/licenses.txt
index 90c97c2..7cc89b6 100644
--- a/dist/licenses.txt
+++ b/dist/licenses.txt
@@ -558,19 +558,6 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
-valibot
-MIT
-MIT License
-
-Copyright (c) Fabian Hiller
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
 wrappy
 ISC
 The ISC License
diff --git a/package.json b/package.json
index a959284..bb5ee7f 100644
--- a/package.json
+++ b/package.json
@@ -68,12 +68,12 @@
   },
   "dependencies": {
     "@actions/core": "1.10.1",
-    "@actions/github": "6.0.0",
-    "valibot": "0.42.1"
+    "@actions/github": "6.0.0"
   },
   "devDependencies": {
     "@eslint/js": "9.11.1",
     "@octokit/openapi-types": "22.2.0",
+    "@octokit/webhooks-types": "7.5.1",
     "@types/eslint-config-prettier": "6.11.3",
     "@types/eslint__js": "8.42.3",
     "@types/jest": "29.5.13",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index eff3028..fb8b38d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -14,9 +14,6 @@ importers:
       '@actions/github':
         specifier: 6.0.0
         version: 6.0.0
-      valibot:
-        specifier: 0.42.1
-        version: 0.42.1(typescript@5.6.2)
     devDependencies:
       '@eslint/js':
         specifier: 9.11.1
@@ -24,6 +21,9 @@ importers:
       '@octokit/openapi-types':
         specifier: 22.2.0
         version: 22.2.0
+      '@octokit/webhooks-types':
+        specifier: 7.5.1
+        version: 7.5.1
       '@types/eslint-config-prettier':
         specifier: 6.11.3
         version: 6.11.3
@@ -475,6 +475,9 @@ packages:
   '@octokit/types@13.5.0':
     resolution: {integrity: sha512-HdqWTf5Z3qwDVlzCrP8UJquMwunpDiMPt5er+QjGzL4hqr/vBVY/MauQgS1xWxCDT1oMx1EULyqxncdCY/NVSQ==}
 
+  '@octokit/webhooks-types@7.5.1':
+    resolution: {integrity: sha512-1dozxWEP8lKGbtEu7HkRbK1F/nIPuJXNfT0gd96y6d3LcHZTtRtlf8xz3nicSJfesADxJyDh+mWBOsdLkqgzYw==}
+
   '@sinclair/typebox@0.27.8':
     resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==}
 
@@ -1886,14 +1889,6 @@ packages:
     resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==}
     engines: {node: '>=10.12.0'}
 
-  valibot@0.42.1:
-    resolution: {integrity: sha512-3keXV29Ar5b//Hqi4MbSdV7lfVp6zuYLZuA9V1PvQUsXqogr+u5lvLPLk3A4f74VUXDnf/JfWMN6sB+koJ/FFw==}
-    peerDependencies:
-      typescript: '>=5'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
   vue-eslint-parser@9.4.3:
     resolution: {integrity: sha512-2rYRLWlIpaiN8xbPiDyXZXRgLGOtWxERV7ND5fFAv5qo1D2N9Fu9MNajBNc6o13lZ+24DAWCkQCvj4klgmcITg==}
     engines: {node: ^14.17.0 || >=16.0.0}
@@ -2502,6 +2497,8 @@ snapshots:
     dependencies:
       '@octokit/openapi-types': 22.2.0
 
+  '@octokit/webhooks-types@7.5.1': {}
+
   '@sinclair/typebox@0.27.8': {}
 
   '@sinonjs/commons@3.0.1':
@@ -4113,10 +4110,6 @@ snapshots:
       '@types/istanbul-lib-coverage': 2.0.6
       convert-source-map: 2.0.0
 
-  valibot@0.42.1(typescript@5.6.2):
-    optionalDependencies:
-      typescript: 5.6.2
-
   vue-eslint-parser@9.4.3(eslint@8.57.1):
     dependencies:
       debug: 4.3.7
diff --git a/src/main.ts b/src/main.ts
index bab0b24..5b84d63 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -4,6 +4,7 @@ import { getRef } from './ref.js'
 import type * as types from '@octokit/openapi-types'
 import { getInputs } from './get-inputs.js'
 import { convertRef } from './internal/utils.js'
+import type { StrictContext } from './types.js'
 
 type Cache =
   types.components['schemas']['actions-cache-list']['actions_caches'][number]
@@ -56,7 +57,7 @@ export async function run(): Promise<void> {
     const octokit = github.getOctokit(token)
 
     // get repostiory information
-    const { repo, eventName, payload } = github.context
+    const context = github.context as StrictContext
 
     const infoNull = (name: string): never[] => {
       core.info(`🤔 Could not determine deletion target: ${name}`)
@@ -68,15 +69,13 @@ export async function run(): Promise<void> {
 
     const refs: string[] =
       branchNames.length === 0
-        ? [getRef({ eventName, payload })].flatMap(x =>
-            x ? x : infoNull(eventName)
-          )
+        ? [getRef(context)].flatMap(x => (x ? x : infoNull(context.eventName)))
         : branchNames
             .map(branchName => convertRef(branchName, { refType: 'branch' }))
             .filter(ref => ref !== null)
 
     for (const ref of refs) {
-      await deleteRefActionsCaches(octokit, repo, ref, isDryRun)
+      await deleteRefActionsCaches(octokit, context.repo, ref, isDryRun)
     }
 
     core.info(`${prefix({ isDryRun })}✅ Done`)
diff --git a/src/parser.ts b/src/parser.ts
deleted file mode 100644
index e3148b6..0000000
--- a/src/parser.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { nullable, optional, parser, string } from 'valibot'
-
-const StringSchema = string()
-const OptionalStringSchema = optional(string())
-const NullableStringSchema = nullable(string())
-
-export const stringParser = parser(StringSchema)
-export const optionalStringParser = parser(OptionalStringSchema)
-export const nullableStringParser = parser(NullableStringSchema)
diff --git a/src/ref.ts b/src/ref.ts
index 3282df8..d34432e 100644
--- a/src/ref.ts
+++ b/src/ref.ts
@@ -1,77 +1,60 @@
-import { WebhookPayload } from '@actions/github/lib/interfaces.js'
-import {
-  optionalStringParser,
-  nullableStringParser,
-  stringParser
-} from './parser.js'
 import { convertRef } from './internal/utils.js'
+import type { StrictContext } from './types.js'
 
 export const getRef = ({
   eventName,
   payload
-}: {
-  eventName: string
-  payload: WebhookPayload
-}): string | null => {
+}: StrictContext): string | null => {
   switch (eventName) {
     case 'check_run':
-      return convertRef(
-        nullableStringParser(payload.check_run.check_suite.head_branch),
-        { refType: 'branch' }
-      )
+      return convertRef(payload.check_run.check_suite.head_branch, {
+        refType: 'branch'
+      })
     case 'check_suite':
-      return convertRef(nullableStringParser(payload.check_suite.head_branch), {
+      return convertRef(payload.check_suite.head_branch, {
         refType: 'branch'
       })
     case 'create':
     case 'delete':
-      return convertRef(nullableStringParser(payload.ref), {
+      return convertRef(payload.ref, {
         refType: payload.ref_type
       })
     case 'deployment_status':
-      return convertRef(
-        optionalStringParser(payload.workflow_run?.head_branch),
-        {
-          refType: 'branch'
-        }
-      )
+      return convertRef(payload.workflow_run?.head_branch, {
+        refType: 'branch'
+      })
     case 'issue_comment':
-      return convertRef(stringParser(payload.issue?.number.toString()), {
+      return convertRef(payload.issue.number.toString(), {
         refType: 'pull'
       })
     case 'merge_group':
-      return stringParser(payload.merge_group.head_ref)
+      return payload.merge_group.head_ref
     case 'pull_request':
     case 'pull_request_review':
     case 'pull_request_review_comment':
     case 'pull_request_target':
-      return convertRef(payload.pull_request?.number.toString(), {
+      return convertRef(payload.pull_request.number.toString(), {
         refType: 'pull'
       })
     case 'push':
-      return stringParser(payload.ref)
+      return payload.ref
     case 'registry_package':
       return convertRef(
-        optionalStringParser(
-          payload.registry_package?.package_version?.release?.tag_name
-        ),
+        payload.registry_package.package_version?.release?.tag_name,
         {
           refType: 'tag'
         }
       )
     case 'release':
-      return convertRef(stringParser(payload.release.tag_name), {
+      return convertRef(payload.release.tag_name, {
         refType: 'tag'
       })
     case 'workflow_dispatch':
-      return stringParser(payload.ref)
+      return payload.ref
     case 'workflow_run':
-      return convertRef(
-        nullableStringParser(payload.workflow_run.head_branch),
-        {
-          refType: 'branch'
-        }
-      )
+      return convertRef(payload.workflow_run.head_branch, {
+        refType: 'branch'
+      })
     default:
       throw new Error(`${eventName} event is not supported.`)
   }
diff --git a/src/types.ts b/src/types.ts
new file mode 100644
index 0000000..d0302b5
--- /dev/null
+++ b/src/types.ts
@@ -0,0 +1,33 @@
+import type { Context } from '@actions/github/lib/context.js'
+import type { EventPayloadMap } from '@octokit/webhooks-types'
+
+type WorkflowEventPayloadMap = EventPayloadMap & {
+  // https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#pull_request_target
+  pull_request_target: EventPayloadMap['pull_request']
+}
+
+type PayloadAndEventName<TName extends keyof WorkflowEventPayloadMap> = Omit<
+  Context,
+  'payload' | 'eventName'
+> & {
+  payload: WorkflowEventPayloadMap[TName]
+  eventName: TName
+}
+
+export type StrictContext =
+  | PayloadAndEventName<'check_run'>
+  | PayloadAndEventName<'check_suite'>
+  | PayloadAndEventName<'create'>
+  | PayloadAndEventName<'delete'>
+  | PayloadAndEventName<'deployment_status'>
+  | PayloadAndEventName<'issue_comment'>
+  | PayloadAndEventName<'merge_group'>
+  | PayloadAndEventName<'pull_request'>
+  | PayloadAndEventName<'pull_request_review'>
+  | PayloadAndEventName<'pull_request_review_comment'>
+  | PayloadAndEventName<'pull_request_target'>
+  | PayloadAndEventName<'push'>
+  | PayloadAndEventName<'registry_package'>
+  | PayloadAndEventName<'release'>
+  | PayloadAndEventName<'workflow_dispatch'>
+  | PayloadAndEventName<'workflow_run'>