@stll/stdnum 0.0.1 → 1.0.0

package/src/patterns.ts

@@ -66,10 +66,9 @@ const inferLengths = (v: Validator): number[] => {
  * "25 123 891" → [2, 3, 3].
  */
 const inferGroups = (v: Validator): number[] | null => {
-  if (!v.examples || v.examples.length === 0) {
-    return null;
-  }
-  const compact = v.compact(v.examples[0]!);
+  const first = v.examples?.[0];
+  if (first === undefined) return null;
+  const compact = v.compact(first);
   const formatted = v.format(compact);
   if (formatted === compact) return null;
 
@@ -98,35 +97,59 @@ const inferGroups = (v: Validator): number[] | null => {
  * (e.g., "CZ" for DIČ, "CHE" for Swiss UID).
  */
 const inferPrefix = (v: Validator): string | null => {
-  if (!v.examples || v.examples.length === 0) {
-    return null;
-  }
-  const compact = v.compact(v.examples[0]!);
+  const examples = v.examples;
+  const first = examples?.[0];
+  if (!examples || first === undefined) return null;
+  const compact = v.compact(first);
   // Prefix already present in compact form.
   // But only if ALL examples share the same prefix
   // (e.g., "CHE" for Swiss UID). If examples have
   // different prefixes (IBAN: GB/DE/FR), there's
   // no fixed prefix — it's part of the value.
   const compactMatch = compact.match(/^([A-Z]+)\d/);
-  if (compactMatch && v.examples!.length > 1) {
-    const pfx = compactMatch[1]!;
-    const allSame = v.examples!.every((ex) =>
-      v.compact(ex).startsWith(pfx),
+  const compactPrefix = compactMatch?.[1];
+  if (compactPrefix !== undefined && examples.length > 1) {
+    const allSame = examples.every((ex) =>
+      v.compact(ex).startsWith(compactPrefix),
     );
-    if (allSame) return pfx;
-  } else if (compactMatch && v.examples!.length === 1) {
-    return compactMatch[1]!;
+    if (allSame) return compactPrefix;
+  } else if (
+    compactPrefix !== undefined &&
+    examples.length === 1
+  ) {
+    return compactPrefix;
   }
   // Prefix added only by format()
   // (e.g., "DE" for de.vat, "CZ" for cz.dic)
   const formatted = v.format(compact);
   const fmtMatch = formatted.match(/^([A-Z]+)[\s\-./]?\d/);
-  if (fmtMatch && !compact.startsWith(fmtMatch[1]!)) {
-    return fmtMatch[1]!;
+  const fmtPrefix = fmtMatch?.[1];
+  if (
+    fmtPrefix !== undefined &&
+    !compact.startsWith(fmtPrefix)
+  ) {
+    return fmtPrefix;
   }
   return null;
 };
 
+/**
+ * Character class for a string fragment:
+ * `\d` if all digits, `[A-Z]` if all letters,
+ * `[A-Z0-9]` if mixed.
+ */
+const charClassFor = (s: string): string => {
+  let hasLetter = false;
+  let hasDigit = false;
+  for (const ch of s) {
+    if (/[a-zA-Z]/.test(ch)) hasLetter = true;
+    if (/\d/.test(ch)) hasDigit = true;
+  }
+  if (hasLetter && hasDigit) return "[A-Z0-9]";
+  if (hasLetter) return "[A-Z]";
+  return "\\d";
+};
+
 /**
  * Determine the character class needed for the
  * compact form: `\d` if all digits, `[A-Z0-9]`
@@ -136,18 +159,81 @@ const inferCharClass = (v: Validator): string => {
   if (!v.examples || v.examples.length === 0) {
     return "\\d";
   }
-  let hasLetter = false;
-  let hasDigit = false;
-  for (const ex of v.examples) {
-    const c = v.compact(ex);
-    for (const ch of c) {
-      if (/[a-zA-Z]/.test(ch)) hasLetter = true;
-      if (/\d/.test(ch)) hasDigit = true;
+  const combined = v.examples
+    .map((ex) => v.compact(ex))
+    .join("");
+  return charClassFor(combined);
+};
+
+type PerGroup = { size: number; charClass: string };
+
+/**
+ * Infer per-group sizes AND character classes from
+ * format(). Returns groups with per-position char
+ * classes, e.g., "12 010188 M 01 1" →
+ *   sizes: [2, 6, 1, 2, 1]
+ *   classes: ["\d", "\d", "[A-Z]", "\d", "\d"]
+ *
+ * Only returns non-null when per-group classes
+ * differ (some groups are letters, some digits).
+ * Letter-only groups before the first digit group
+ * are treated as prefixes and excluded (handled
+ * by inferPrefix separately).
+ */
+const inferPerGroup = (v: Validator): PerGroup[] | null => {
+  const first = v.examples?.[0];
+  if (first === undefined) return null;
+  const compact = v.compact(first);
+  const formatted = v.format(compact);
+  if (formatted === compact) return null;
+
+  // Only applies to mixed validators (compact has
+  // both letters and digits in separate positions,
+  // like German SVNR "12010188M011").
+  const compactMixed =
+    /[a-zA-Z]/.test(compact) && /\d/.test(compact);
+  if (!compactMixed) return null;
+
+  // Also skip if any single part mixes letters and
+  // digits (IBAN, ISIN) — inferGroups already
+  // handles those correctly with the global class.
+  const parts = formatted.split(/[^a-zA-Z0-9]+/);
+  const isAlphanumeric = parts.some(
+    (p) => /[a-zA-Z]/.test(p) && /\d/.test(p),
+  );
+  if (isAlphanumeric) return null;
+
+  // Keep digit groups and letter-only groups that
+  // appear AFTER the first digit group (embedded
+  // letters). Skip letter-only groups before the
+  // first digit group (prefix like "CHE").
+  const filtered: PerGroup[] = [];
+  let seenDigitGroup = false;
+  for (const p of parts) {
+    if (p.length === 0) continue;
+    if (/\d/.test(p)) {
+      seenDigitGroup = true;
+      filtered.push({
+        size: p.length,
+        charClass: charClassFor(p),
+      });
+    } else if (seenDigitGroup) {
+      filtered.push({
+        size: p.length,
+        charClass: charClassFor(p),
+      });
     }
   }
-  if (hasLetter && hasDigit) return "[A-Z0-9]";
-  if (hasLetter) return "[A-Z]";
-  return "\\d";
+
+  if (filtered.length <= 1) return null;
+
+  const firstClass = filtered[0]?.charClass;
+  const allSame = filtered.every(
+    (g) => g.charClass === firstClass,
+  );
+  if (allSame) return null;
+
+  return filtered;
 };
 
 /**
@@ -159,6 +245,18 @@ const groupsToPattern = (
   cc: string,
 ): string => groups.map((g) => `${cc}{${g}}`).join(SEP);
 
+/**
+ * Build a group regex with per-group char classes.
+ * Produces tighter patterns when groups have different
+ * character types (e.g., digits vs letters).
+ */
+const groupsToPatternPerClass = (
+  groups: readonly { size: number; charClass: string }[],
+): string =>
+  groups
+    .map(({ size, charClass }) => `${charClass}{${size}}`)
+    .join(SEP);
+
 /**
  * Derive a loose candidate-matching regex from
  * a validator. The regex finds potential matches;
@@ -175,7 +273,16 @@ export const toRegex = (v: Validator): RegExp => {
 
   let pattern: string;
 
-  if (groups && lengths.length <= 1) {
+  // Use per-group char classes when groups mix
+  // digits and letters (e.g., German SVNR:
+  // "12 010188 M 01 1" → [\d, \d, [A-Z], \d, \d]).
+  // This prevents overly broad [A-Z0-9] from
+  // matching all-caps prose as identifiers.
+  const perGroup = inferPerGroup(v);
+
+  if (perGroup && lengths.length <= 1) {
+    pattern = groupsToPatternPerClass(perGroup);
+  } else if (groups && lengths.length <= 1) {
     pattern = groupsToPattern(groups, cc);
   } else if (lengths.length === 1) {
     pattern = `${cc}{${lengths[0]}}`;

package/src/pe/ruc.ts

@@ -15,7 +15,7 @@
  */
 
 import { clean } from "#util/clean";
-import { randomDigits } from "#util/generate";
+import { randomDigits, randomPick } from "#util/generate";
 import { err } from "#util/result";
 import { isdigits } from "#util/strings";
 
@@ -29,7 +29,8 @@ import type { ValidateResult, Validator } from "../types";
  */
 const VALID_PREFIXES = new Set(["10", "15", "17", "20"]);
 
-const WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
+const WEIGHTS = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2] as const;
+const GENERATE_PREFIXES = ["10", "15", "17", "20"] as const;
 
 const compact = (value: string): string =>
   clean(value, " -.").trim();
@@ -42,8 +43,8 @@ const compact = (value: string): string =>
  */
 const calcCheckDigit = (body: string): number => {
   let sum = 0;
-  for (let i = 0; i < 10; i++) {
-    sum += Number(body[i]) * WEIGHTS[i]!;
+  for (const [i, weight] of WEIGHTS.entries()) {
+    sum += Number(body[i]) * weight;
   }
   const remainder = 11 - (sum % 11);
   if (remainder >= 10) return remainder - 10;
@@ -87,9 +88,7 @@ const format = (value: string): string => compact(value);
 
 /** Generate a random valid Peruvian RUC. */
 const generate = (): string => {
-  const prefixes = ["10", "15", "17", "20"] as const;
-  const prefix =
-    prefixes[Math.floor(Math.random() * prefixes.length)]!;
+  const prefix = randomPick(GENERATE_PREFIXES);
   const body = prefix + randomDigits(8);
   return body + String(calcCheckDigit(body));
 };

package/src/pk/cnic.ts

@@ -53,6 +53,8 @@ const validate = (value: string): ValidateResult => {
     );
   }
   // First digit must be a valid province code
+  // SAFETY: v.length === 13 above guarantees v[0] exists.
+  // eslint-disable-next-line no-non-null-assertion
   if (!VALID_PROVINCES.has(v[0]!)) {
     return err(
       "INVALID_COMPONENT",

package/src/pl/pesel.ts

@@ -131,7 +131,7 @@ const generate = (): string => {
 };
 
 /** Polish National Identification Number. */
-const pesel: Validator = {
+const pesel: Validator<ParsedPersonId> = {
   name: "Polish National ID",
   localName:
     "Powszechny Elektroniczny System Ewidencji Ludności",
@@ -145,6 +145,7 @@ const pesel: Validator = {
   examples: ["02070803628"] as const,
   compact,
   format,
+  parse,
   validate,
   generate,
 };

package/src/pt/cc.ts

@@ -9,7 +9,7 @@
  */
 
 import { clean } from "#util/clean";
-import { randomDigits, randomInt } from "#util/generate";
+import { randomChar, randomDigits } from "#util/generate";
 import { err } from "#util/result";
 
 import type { ValidateResult, Validator } from "../types";
@@ -24,8 +24,10 @@ const compact = (value: string): string =>
 const calcCheckDigit = (value: string): string => {
   let sum = 0;
   for (let i = value.length - 1; i >= 0; i--) {
+    const ch = value[i];
+    if (ch === undefined) continue;
     const pos = value.length - 1 - i;
-    let n = ALPHABET.indexOf(value[i]!);
+    let n = ALPHABET.indexOf(ch);
     if (pos % 2 === 0) {
       n *= 2;
       if (n > 9) n = Math.floor(n / 10) + (n % 10);
@@ -70,8 +72,8 @@ const format = (value: string): string => {
 /** Generate a random valid Portuguese CC number. */
 const generate = (): string => {
   const digits = randomDigits(9);
-  const v0 = ALPHABET[randomInt(0, 35)]!;
-  const v1 = ALPHABET[randomInt(0, 35)]!;
+  const v0 = randomChar(ALPHABET);
+  const v1 = randomChar(ALPHABET);
   const body = digits + v0 + v1;
   const check = calcCheckDigit(body);
   return body + check;

package/src/ro/cnp.ts

@@ -150,7 +150,7 @@ const generate = (): string => {
 };
 
 /** Romanian Personal Identification Number. */
-const cnp: Validator = {
+const cnp: Validator<ParsedPersonId> = {
   name: "Romanian Personal ID",
   localName: "Cod Numeric Personal",
   abbreviation: "CNP",
@@ -163,6 +163,7 @@ const cnp: Validator = {
   examples: ["1630615123457"] as const,
   compact,
   format,
+  parse,
   validate,
   generate,
 };

package/src/ru/inn.ts

@@ -28,8 +28,8 @@ const checkDigit = (
   weights: readonly number[],
 ): number => {
   let sum = 0;
-  for (let i = 0; i < weights.length; i++) {
-    sum += Number(value[i]) * weights[i]!;
+  for (const [i, weight] of weights.entries()) {
+    sum += Number(value[i]) * weight;
   }
   return (sum % 11) % 10;
 };

package/src/se/personnummer.ts

@@ -154,7 +154,7 @@ const generate = (): string => {
 };
 
 /** Swedish Personal Identity Number. */
-const personnummer: Validator = {
+const personnummer: Validator<ParsedPersonId> = {
   name: "Swedish Personal ID",
   localName: "Personnummer",
   abbreviation: "PN",
@@ -172,6 +172,7 @@ const personnummer: Validator = {
   examples: ["880320-0016"] as const,
   compact,
   format,
+  parse,
   validate,
   generate,
 };

package/src/sg/uen.ts

@@ -72,6 +72,9 @@ const compact = (value: string): string =>
  * Validate Business (ROB) UEN (9 chars):
  * 8 digits + 1 check letter.
  */
+const BUSINESS_WEIGHTS = [10, 4, 9, 3, 8, 2, 7, 1] as const;
+const BUSINESS_CHECK_ALPHA = "XMKECAWLJDB";
+
 const validateBusiness = (v: string): ValidateResult => {
   if (!isdigits(v.slice(0, 8))) {
     return err(
@@ -79,6 +82,9 @@ const validateBusiness = (v: string): ValidateResult => {
       "Business UEN must start with 8 digits",
     );
   }
+  // SAFETY: caller routes to this only when
+  // v.length === 9.
+  // eslint-disable-next-line no-non-null-assertion
   if (!/^[A-Z]$/.test(v[8]!)) {
     return err(
       "INVALID_FORMAT",
@@ -86,13 +92,11 @@ const validateBusiness = (v: string): ValidateResult => {
     );
   }
 
-  const weights = [10, 4, 9, 3, 8, 2, 7, 1];
-  const checkAlpha = "XMKECAWLJDB";
   let sum = 0;
-  for (let i = 0; i < 8; i++) {
-    sum += Number(v[i]) * weights[i]!;
+  for (const [i, weight] of BUSINESS_WEIGHTS.entries()) {
+    sum += Number(v[i]) * weight;
   }
-  const expected = checkAlpha[sum % 11];
+  const expected = BUSINESS_CHECK_ALPHA[sum % 11];
   if (v[8] !== expected) {
     return err(
       "INVALID_CHECKSUM",
@@ -106,6 +110,9 @@ const validateBusiness = (v: string): ValidateResult => {
  * Validate Local Company (ROC) UEN (10 chars):
  * 9 digits (year prefix) + 1 check letter.
  */
+const LOCAL_WEIGHTS = [10, 8, 6, 4, 9, 7, 5, 3, 1] as const;
+const LOCAL_CHECK_ALPHA = "ZKCMDNERGWH";
+
 const validateLocalCompany = (
   v: string,
 ): ValidateResult => {
@@ -115,6 +122,9 @@ const validateLocalCompany = (
       "Company UEN must have 9 digits",
     );
   }
+  // SAFETY: caller routes to this only when
+  // v.length === 10.
+  // eslint-disable-next-line no-non-null-assertion
   if (!/^[A-Z]$/.test(v[9]!)) {
     return err(
       "INVALID_FORMAT",
@@ -122,13 +132,11 @@ const validateLocalCompany = (
     );
   }
 
-  const weights = [10, 8, 6, 4, 9, 7, 5, 3, 1];
-  const checkAlpha = "ZKCMDNERGWH";
   let sum = 0;
-  for (let i = 0; i < 9; i++) {
-    sum += Number(v[i]) * weights[i]!;
+  for (const [i, weight] of LOCAL_WEIGHTS.entries()) {
+    sum += Number(v[i]) * weight;
   }
-  const expected = checkAlpha[sum % 11];
+  const expected = LOCAL_CHECK_ALPHA[sum % 11];
   if (v[9] !== expected) {
     return err(
       "INVALID_CHECKSUM",
@@ -143,7 +151,12 @@ const validateLocalCompany = (
  * R/S/T + 2 digits + 2-letter type + 4 digits
  * + 1 check letter.
  */
+const OTHER_WEIGHTS = [4, 3, 5, 3, 10, 2, 2, 5, 7] as const;
+
 const validateOther = (v: string): ValidateResult => {
+  // SAFETY: caller routes to this only when
+  // v.length === 10.
+  // eslint-disable-next-line no-non-null-assertion
   const prefix = v[0]!;
   if (prefix !== "R" && prefix !== "S" && prefix !== "T") {
     return err(
@@ -171,17 +184,18 @@ const validateOther = (v: string): ValidateResult => {
     );
   }
 
-  const weights = [4, 3, 5, 3, 10, 2, 2, 5, 7];
   let sum = 0;
-  for (let i = 0; i < 9; i++) {
-    const idx = OTHER_ALPHA.indexOf(v[i]!);
+  for (const [i, weight] of OTHER_WEIGHTS.entries()) {
+    const ch = v[i];
+    if (ch === undefined) continue;
+    const idx = OTHER_ALPHA.indexOf(ch);
     if (idx === -1) {
       return err(
         "INVALID_FORMAT",
-        `Unexpected character at position ${i + 1}: ${v[i]}`,
+        `Unexpected character at position ${i + 1}: ${ch}`,
       );
     }
-    sum += idx * weights[i]!;
+    sum += idx * weight;
   }
   const expected =
     OTHER_ALPHA[(((sum - 5) % 11) + 11) % 11];
@@ -218,6 +232,8 @@ const validate = (value: string): ValidateResult => {
 
   // 10 chars: first char digit => local company,
   // otherwise "other" entity
+  // SAFETY: v.length === 10 here.
+  // eslint-disable-next-line no-non-null-assertion
   if (isdigits(v[0]!)) {
     return validateLocalCompany(v);
   }
@@ -228,14 +244,15 @@ const format = (value: string): string => compact(value);
 
 /** Generate a random valid Singapore UEN (business format). */
 const generate = (): string => {
-  const weights = [10, 4, 9, 3, 8, 2, 7, 1];
-  const checkAlpha = "XMKECAWLJDB";
   const body = randomDigits(8);
   let sum = 0;
-  for (let i = 0; i < 8; i++) {
-    sum += Number(body[i]) * weights[i]!;
+  for (const [i, weight] of BUSINESS_WEIGHTS.entries()) {
+    sum += Number(body[i]) * weight;
   }
-  const check = checkAlpha[sum % 11]!;
+  // SAFETY: sum % 11 is in 0..10 and BUSINESS_CHECK_ALPHA
+  // has 11 characters.
+  // eslint-disable-next-line no-non-null-assertion
+  const check = BUSINESS_CHECK_ALPHA[sum % 11]!;
   return body + check;
 };
 

package/src/si/emso.ts

@@ -5,8 +5,14 @@
  * encoding DDMMYYY (7-digit birth year), region code,
  * serial number, and a check digit.
  *
- * @see https://en.wikipedia.org/wiki/Unique_Master_Citizen_Number
- * @see https://www.gov.si/
+ * Canonical source:
+ * - Slovenia government registry overview
+ *
+ * This is the source behind the stricter register
+ * code check (50-59) and the decision to reject
+ * future birth dates in the embedded date field.
+ *
+ * @see https://www.gov.si/teme/registri-in-evidence-prebivalstva/
  */
 
 import { weightedSum } from "#checksums/weighted-sum";
@@ -75,6 +81,23 @@ const validate = (value: string): ValidateResult => {
       "EMŠO contains an invalid date",
     );
   }
+  const birthDate = new Date(yyyy, mm - 1, dd);
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  if (birthDate > today) {
+    return err(
+      "INVALID_COMPONENT",
+      "EMŠO cannot contain a future birth date",
+    );
+  }
+
+  const register = Number(v.slice(7, 9));
+  if (register < 50 || register > 59) {
+    return err(
+      "INVALID_COMPONENT",
+      "EMSO register code must be between 50 and 59",
+    );
+  }
 
   if (calcCheckDigit(v) !== Number(v[12])) {
     return err(
@@ -120,7 +143,7 @@ const generate = (): string => {
     const dd = String(randomInt(1, 28)).padStart(2, "0");
     const mm = String(randomInt(1, 12)).padStart(2, "0");
     const yyy = String(randomInt(900, 999));
-    const rr = String(randomInt(50, 99));
+    const rr = String(randomInt(50, 59));
     const sss = String(randomInt(0, 999)).padStart(3, "0");
     const partial = dd + mm + yyy + rr + sss;
     const c = partial + String(calcCheckDigit(partial));
@@ -129,7 +152,7 @@ const generate = (): string => {
 };
 
 /** Slovenian Unique Master Citizen Number. */
-const emso: Validator = {
+const emso: Validator<ParsedPersonId> = {
   name: "Slovenian Personal ID",
   localName: "Enotna matična številka občana",
   abbreviation: "EMŠO",
@@ -140,10 +163,12 @@ const emso: Validator = {
   candidatePattern: "\\d{13}",
   country: "SI",
   entityType: "person",
-  sourceUrl: "https://www.gov.si/",
+  sourceUrl:
+    "https://www.gov.si/teme/registri-in-evidence-prebivalstva/",
   examples: ["0101006500006"] as const,
   compact,
   format,
+  parse,
   validate,
   generate,
 };

package/src/sk/rc.ts

@@ -8,11 +8,17 @@
  * @see https://www.minv.sk/
  */
 
-import { compact, format, parse, validate } from "../cz/rc";
-import type { Validator } from "../types";
+import {
+  compact,
+  format,
+  generate,
+  parse,
+  validate,
+} from "../cz/rc";
+import type { ParsedPersonId, Validator } from "../types";
 
 /** Slovak Birth Number. */
-const rc: Validator = {
+const rc: Validator<ParsedPersonId> = {
   name: "Slovak Birth Number",
   localName: "Rodné číslo",
   abbreviation: "RČ",
@@ -21,11 +27,14 @@ const rc: Validator = {
   country: "SK",
   entityType: "person",
   sourceUrl: "https://www.minv.sk/",
+  lengths: [9, 10] as const,
   examples: ["7103192745"] as const,
   compact,
   format,
+  generate,
+  parse,
   validate,
 };
 
 export default rc;
-export { compact, format, parse, validate };
+export { compact, format, generate, parse, validate };

package/src/tw/ubn.ts

@@ -48,8 +48,8 @@ const validate = (value: string): ValidateResult => {
   }
 
   let sum = 0;
-  for (let i = 0; i < 8; i++) {
-    sum += digitSum(Number(v[i]) * WEIGHTS[i]!);
+  for (const [i, weight] of WEIGHTS.entries()) {
+    sum += digitSum(Number(v[i]) * weight);
   }
 
   const checksum = sum % 10;

package/src/types.ts

@@ -116,16 +116,28 @@ export type ValidateResult =
   | { valid: false; error: StdnumError };
 
 /**
- * Structured data extracted from a personal ID number.
- * Returned by `parse()` on validators that encode
- * birth date and gender.
+ * Structured data extracted from an identifier that
+ * encodes a birth date.
  */
-export type ParsedPersonId = {
+export type ParsedBirthDate = {
   birthDate: Date;
+};
+
+/**
+ * Structured data extracted from a personal ID number
+ * that also encodes gender.
+ */
+export type ParsedPersonId = ParsedBirthDate & {
   gender: "male" | "female";
 };
 
-export type Validator = {
+export type ParsedIdentifier =
+  | ParsedBirthDate
+  | ParsedPersonId;
+
+export type Validator<
+  TParsed extends ParsedIdentifier | undefined = undefined,
+> = {
   /** English name. */
   name: string;
   /** Name in the local language. */
@@ -197,4 +209,23 @@ export type Validator = {
    * passed to validate() for confirmation.
    */
   candidatePattern?: string;
-};
+
+  /**
+   * Extract structured data (e.g. birth date,
+   * gender) from a known-valid identifier.
+   * Available on personal IDs that encode such
+   * data. Returns null if the input cannot be
+   * parsed.
+   *
+   * On the base `Validator` type this is optional
+   * with a widened return; narrow it by typing the
+   * validator as `Validator<ParsedPersonId>` etc.
+   */
+  parse?: (value: string) => ParsedIdentifier | null;
+} & ([TParsed] extends [undefined]
+  ? unknown
+  : { parse: (value: string) => TParsed | null });
+
+export type ParsableValidator<
+  TParsed extends ParsedIdentifier = ParsedIdentifier,
+> = Validator<TParsed>;