@budiauktioner/buildi-primitives 0.1.0

package/dist/person/index.cjs

@@ -0,0 +1,1144 @@
+'use strict';
+
+// src/primitives-defaults.ts
+var DEFAULT_CULTURE = "sv-SE";
+var DEFAULT_UI_CULTURE = "sv-SE";
+var state = {
+  culture: DEFAULT_CULTURE,
+  uiCulture: DEFAULT_UI_CULTURE};
+var PrimitivesDefaults = {
+  /**
+   * BCP-47 locale tag used for casing and number formatting.
+   * Defaults to `'sv-SE'`.
+   */
+  get culture() {
+    return state.culture;
+  },
+  set culture(value) {
+    state.culture = value;
+  },
+  /**
+   * `true` when {@link uiCulture} is Swedish (`sv` or `sv-*`).
+   * Types use this to select between localized and English display names.
+   */
+  get useLocalizedDisplayNames() {
+    const lang = state.uiCulture.toLowerCase().split("-")[0];
+    return lang === "sv";
+  }};
+
+// src/internal/input-sanitization.ts
+var FORMAT_OR_NOT_ASSIGNED = /[\p{Cf}\p{Cn}]/u;
+var SPACE_SEPARATOR = /[\p{Zs}\p{Zl}\p{Zp}]/u;
+var CONTROL = /\p{Cc}/u;
+function sanitizeInput(input) {
+  let out = "";
+  for (const c of input) {
+    if (c === "\u2018" || c === "\u2019" || c === "\u201A" || c === "\u201B") {
+      out += "'";
+      continue;
+    }
+    if (c === "\u201C" || c === "\u201D" || c === "\u201E" || c === "\u201F" || c === "\xAB" || c === "\xBB") {
+      out += '"';
+      continue;
+    }
+    if (FORMAT_OR_NOT_ASSIGNED.test(c)) {
+      continue;
+    }
+    if (CONTROL.test(c)) {
+      if (c === "	" || c === "\n" || c === "\r") out += " ";
+      continue;
+    }
+    if (SPACE_SEPARATOR.test(c)) {
+      out += " ";
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+var WHITESPACE_RUN = /\s+/g;
+function collapseWhitespace(input) {
+  if (input == null) return "";
+  return sanitizeInput(input).trim().replace(WHITESPACE_RUN, " ");
+}
+
+// src/person/person-name-normalization.ts
+var SINGLE_PART_PATTERN = /^(?:[\p{L}\p{M}]+|['\p{L}\p{M}]{2,}|[\p{Lo}])(?:['\p{Zs}-][\p{L}\p{M}]+)*$/u;
+var HONORIFICS = [
+  "fr\xF6ken",
+  "froken",
+  "froeken",
+  "prof",
+  "miss",
+  "mrs",
+  "mr",
+  "ms",
+  "dr",
+  "herr",
+  "fru"
+];
+function collapseWhitespace2(input) {
+  let result = collapseWhitespace(input);
+  result = result.replace(/\s*-\s*/g, "-");
+  const parts = result.split(" ").map((p) => p.replace(/^\.+|\.+$/g, "")).filter((p) => p.length > 0);
+  result = parts.join(" ");
+  return stripLeadingHonorific(result);
+}
+function stripLeadingHonorific(input) {
+  const lower = input.toLowerCase();
+  for (const h of HONORIFICS) {
+    if (input.length <= h.length) continue;
+    if (!lower.startsWith(h)) continue;
+    if (input[h.length] !== " ") continue;
+    return input.slice(h.length + 1);
+  }
+  return input;
+}
+function normalizeCasing(input) {
+  const letters = [...input].filter((c) => /\p{L}/u.test(c));
+  if (letters.length === 0) return input;
+  const culture = PrimitivesDefaults.culture;
+  const allLower = letters.every((c) => c === c.toLocaleLowerCase(culture));
+  const allUpper = letters.every((c) => c === c.toLocaleUpperCase(culture));
+  return allLower || allUpper ? capitalizeEachWord(input) : input;
+}
+function validateNamePart(value) {
+  if (value == null || value.trim() === "") return false;
+  if (/[\p{Cc}]/u.test(value)) return false;
+  if (/[\p{Cn}]/u.test(value)) return false;
+  return SINGLE_PART_PATTERN.test(value);
+}
+function validateGivenNames(value) {
+  if (value == null || value.trim() === "") return false;
+  const parts = value.split(" ").filter((p) => p !== "");
+  return parts.length > 0 && parts.every(validateNamePart);
+}
+function capitalizeEachWord(input) {
+  return input.split(" ").filter(Boolean).map(capitalizeHyphenated).join(" ");
+}
+function capitalizeHyphenated(word) {
+  return word.split("-").map(capitalizeWord).join("-");
+}
+function capitalizeWord(word) {
+  if (!word) return word;
+  const culture = PrimitivesDefaults.culture;
+  const lowered = word.toLocaleLowerCase(culture);
+  for (let i = 0; i < lowered.length; i++) {
+    if (/\p{L}/u.test(lowered[i])) {
+      return lowered.slice(0, i) + lowered[i].toLocaleUpperCase(culture) + lowered.slice(i + 1);
+    }
+  }
+  return lowered;
+}
+
+// src/person/person-given-name.ts
+var MAX_INPUT_LENGTH = 200;
+var PersonGivenName = class _PersonGivenName {
+  static typeInfo = Object.freeze({
+    englishName: "Given Name",
+    localizedName: "F\xF6rnamn",
+    emoji: "\u270F\uFE0F",
+    sources: Object.freeze([
+      "https://skatteverket.se/privat/folkbokforing/namn.4.18e1b10334ebe8bc80004083.html",
+      "https://www.riksdagen.se/sv/dokument-och-lagar/dokument/svensk-forfattningssamling/lag-20161013-om-personnamn_sfs-2016-1013/"
+    ])
+  });
+  value;
+  names;
+  preferredName;
+  constructor(value, names, preferredName) {
+    this.value = value;
+    this.names = Object.freeze([...names]);
+    this.preferredName = preferredName;
+  }
+  static tryParse(input, options) {
+    const collapsed = collapseWhitespace2(input);
+    if (collapsed.length === 0 || collapsed.length > MAX_INPUT_LENGTH) return null;
+    const normalized = normalizeCasing(collapsed);
+    if (!validateGivenNames(normalized)) return null;
+    const names = normalized.split(" ").filter((p) => p !== "");
+    let preferred = null;
+    const preferredInput = options?.preferredName ?? null;
+    if (preferredInput != null && preferredInput.trim() !== "") {
+      const np = normalizeCasing(collapseWhitespace2(preferredInput));
+      const found = names.find((n) => n.toLowerCase() === np.toLowerCase()) ?? null;
+      if (found === null) return null;
+      preferred = found;
+    }
+    return new _PersonGivenName(normalized, names, preferred);
+  }
+  static parse(input, options) {
+    const r = _PersonGivenName.tryParse(input, options);
+    if (r === null) throw new Error("Invalid given name(s).");
+    return r;
+  }
+  static isValid(input) {
+    return _PersonGivenName.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _PersonGivenName.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _PersonGivenName.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _PersonGivenName.normalize(input) === input;
+  }
+  withPreferredName(preferredName) {
+    const found = this.names.find((n) => n.toLowerCase() === preferredName.toLowerCase()) ?? null;
+    if (found === null) {
+      throw new Error("Preferred name must be one of the given names.");
+    }
+    return new _PersonGivenName(this.value, this.names, found);
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+
+// src/person/person-family-name.ts
+var MAX_INPUT_LENGTH2 = 200;
+var PersonFamilyName = class _PersonFamilyName {
+  static typeInfo = Object.freeze({
+    englishName: "Family Name",
+    localizedName: "Efternamn",
+    emoji: "\u{1F4DB}",
+    sources: Object.freeze([
+      "https://skatteverket.se/privat/folkbokforing/namn.4.18e1b10334ebe8bc80004083.html",
+      "https://www.riksdagen.se/sv/dokument-och-lagar/dokument/svensk-forfattningssamling/lag-20161013-om-personnamn_sfs-2016-1013/"
+    ])
+  });
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  static tryParse(input) {
+    const collapsed = collapseWhitespace2(input);
+    if (collapsed.length === 0 || collapsed.length > MAX_INPUT_LENGTH2) return null;
+    const normalized = normalizeCasing(collapsed);
+    if (!validateNamePart(normalized)) return null;
+    return new _PersonFamilyName(normalized);
+  }
+  static parse(input) {
+    const r = _PersonFamilyName.tryParse(input);
+    if (r === null) throw new Error("Invalid family name.");
+    return r;
+  }
+  static isValid(input) {
+    return _PersonFamilyName.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _PersonFamilyName.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _PersonFamilyName.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _PersonFamilyName.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+
+// src/person/person-full-name.ts
+var MAX_INPUT_LENGTH3 = 500;
+var PersonFullName = class _PersonFullName {
+  static typeInfo = Object.freeze({
+    englishName: "Full Name",
+    localizedName: "Fullst\xE4ndigt namn",
+    emoji: "\u{1F4C7}",
+    sources: Object.freeze([
+      "https://skatteverket.se/privat/folkbokforing/namn.4.18e1b10334ebe8bc80004083.html",
+      "https://www.riksdagen.se/sv/dokument-och-lagar/dokument/svensk-forfattningssamling/lag-20161013-om-personnamn_sfs-2016-1013/"
+    ])
+  });
+  givenName;
+  familyName;
+  value;
+  get preferredName() {
+    return this.givenName.preferredName;
+  }
+  constructor(given, family, value) {
+    this.givenName = given;
+    this.familyName = family;
+    this.value = value;
+  }
+  static create(givenName, familyName) {
+    return new _PersonFullName(givenName, familyName, `${givenName.value} ${familyName.value}`);
+  }
+  static tryParse(input, options) {
+    const collapsed = collapseWhitespace2(input);
+    if (collapsed.length === 0 || collapsed.length > MAX_INPUT_LENGTH3) return null;
+    const tokens = collapsed.split(" ").filter((t) => t !== "");
+    if (tokens.length < 2) return null;
+    const givenPart = tokens.slice(0, tokens.length - 1).join(" ");
+    const given = PersonGivenName.tryParse(givenPart, options);
+    if (given === null) return null;
+    const family = PersonFamilyName.tryParse(tokens[tokens.length - 1]);
+    if (family === null) return null;
+    return new _PersonFullName(given, family, `${given.value} ${family.value}`);
+  }
+  static parse(input, options) {
+    const r = _PersonFullName.tryParse(input, options);
+    if (r === null) {
+      throw new Error("Invalid full name. Must contain at least given name(s) and a family name.");
+    }
+    return r;
+  }
+  static isValid(input) {
+    return _PersonFullName.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _PersonFullName.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _PersonFullName.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _PersonFullName.normalize(input) === input;
+  }
+  withPreferredName(preferredName) {
+    const given = this.givenName.withPreferredName(preferredName);
+    return new _PersonFullName(given, this.familyName, this.value);
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+
+// src/internal/clock.ts
+var systemClock = {
+  now: () => /* @__PURE__ */ new Date()
+};
+
+// src/person/person-age.ts
+var MAX_YEARS = 200;
+var DAYS_PER_YEAR = 365;
+var DAYS_PER_MONTH = 30;
+var MAX_TOTAL_DAYS = MAX_YEARS * DAYS_PER_YEAR;
+var YEARS_PATTERN = /^\s*(\d+(?:[.,]\d+)?)\s*(?:år|years?)?\s*$/iu;
+var MONTHS_PATTERN = /^\s*(\d+)\s+(?:månader?|månad|months?)\s*$/iu;
+var DAYS_PATTERN = /^\s*(\d+)\s+(?:dagar?|dag|days?)\s*$/iu;
+var PersonAge = class _PersonAge {
+  static typeInfo = Object.freeze({
+    englishName: "Age",
+    localizedName: "\xC5lder",
+    emoji: "\u{1F382}",
+    sources: Object.freeze([
+      "https://www.riksdagen.se/sv/dokument-och-lagar/dokument/svensk-forfattningssamling/foraldrabalk-1949381_sfs-1949-381/",
+      "https://www.riksdagen.se/sv/dokument-och-lagar/dokument/svensk-forfattningssamling/brottsbalk-1962700_sfs-1962-700/"
+    ])
+  });
+  years;
+  totalMonths;
+  totalDays;
+  get isOfSwedishLegalAge() {
+    return this.years >= 18;
+  }
+  get isSwedishCriminallyResponsible() {
+    return this.years >= 15;
+  }
+  get isOfSwedishRetirementAge() {
+    return this.years >= 65;
+  }
+  constructor(years, totalMonths, totalDays) {
+    this.years = years;
+    this.totalMonths = totalMonths;
+    this.totalDays = totalDays;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const sanitized = input.trim();
+    if (sanitized.length > 50) return null;
+    let m = DAYS_PATTERN.exec(sanitized);
+    if (m) {
+      const d = parseInt(m[1], 10);
+      return tryFromDays(d);
+    }
+    m = MONTHS_PATTERN.exec(sanitized);
+    if (m) {
+      const months = parseInt(m[1], 10);
+      return tryFromMonths(months);
+    }
+    m = YEARS_PATTERN.exec(sanitized);
+    if (m) {
+      const value = parseFloat(m[1].replace(",", "."));
+      if (!Number.isFinite(value) || value < 0) return null;
+      const intYears = Math.trunc(value);
+      if (value === intYears) return tryFromYears(intYears);
+      return tryFromDays(Math.trunc(value * DAYS_PER_YEAR));
+    }
+    return null;
+  }
+  static parse(input) {
+    const r = _PersonAge.tryParse(input);
+    if (r === null) throw new Error("Invalid person age.");
+    return r;
+  }
+  static isValid(input) {
+    return _PersonAge.tryParse(input) !== null;
+  }
+  static fromYears(years) {
+    if (years < 0 || years > MAX_YEARS || !Number.isInteger(years)) {
+      throw new RangeError(`Years must be between 0 and ${MAX_YEARS}.`);
+    }
+    return new _PersonAge(years, years * 12, years * DAYS_PER_YEAR);
+  }
+  static fromMonths(months) {
+    if (months < 0 || months > MAX_YEARS * 12 || !Number.isInteger(months)) {
+      throw new RangeError(`Months must be between 0 and ${MAX_YEARS * 12}.`);
+    }
+    return new _PersonAge(Math.trunc(months / 12), months, months * DAYS_PER_MONTH);
+  }
+  static fromDays(days) {
+    if (days < 0 || days > MAX_TOTAL_DAYS || !Number.isInteger(days)) {
+      throw new RangeError(`Days must be between 0 and ${MAX_TOTAL_DAYS}.`);
+    }
+    return new _PersonAge(Math.trunc(days / DAYS_PER_YEAR), Math.trunc(days / DAYS_PER_MONTH), days);
+  }
+  /**
+   * Build a {@link PersonAge} from a birth date and an optional reference date.
+   * `birthDate` and `referenceDate` are interpreted as UTC midnights of the date
+   * portion of the supplied {@link Date} values.
+   */
+  static fromBirthDate(birthDate, options) {
+    const ref = options?.referenceDate ?? options?.clock?.now() ?? systemClock.now();
+    const birth = new Date(
+      Date.UTC(birthDate.getUTCFullYear(), birthDate.getUTCMonth(), birthDate.getUTCDate())
+    );
+    const today = new Date(Date.UTC(ref.getUTCFullYear(), ref.getUTCMonth(), ref.getUTCDate()));
+    if (birth > today)
+      throw new RangeError("Birth date cannot be in the future relative to the reference date.");
+    const totalDays = Math.floor((today.getTime() - birth.getTime()) / 864e5);
+    let years = today.getUTCFullYear() - birth.getUTCFullYear();
+    if (today.getUTCMonth() < birth.getUTCMonth() || today.getUTCMonth() === birth.getUTCMonth() && today.getUTCDate() < birth.getUTCDate()) {
+      years--;
+    }
+    let monthDate = new Date(
+      Date.UTC(birth.getUTCFullYear() + years, birth.getUTCMonth(), birth.getUTCDate())
+    );
+    let months = 0;
+    while (true) {
+      const next = new Date(monthDate);
+      next.setUTCMonth(next.getUTCMonth() + 1);
+      if (next > today) break;
+      monthDate = next;
+      months++;
+    }
+    return new _PersonAge(years, years * 12 + months, totalDays);
+  }
+  static format(input, options) {
+    const r = _PersonAge.tryParse(input);
+    if (r) return r.toString();
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _PersonAge.tryParse(input);
+    if (r) return r.toNormalizedString();
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const t = input.trim();
+      return t.length > 0 ? t : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _PersonAge.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return String(this.years);
+  }
+  toString() {
+    return this.years >= 1 ? `${this.years} \xE5r` : `${this.totalMonths} m\xE5nader`;
+  }
+  equals(other) {
+    return other != null && this.totalDays === other.totalDays;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.totalDays - other.totalDays;
+  }
+};
+function tryFromYears(years) {
+  if (years < 0 || years > MAX_YEARS) return null;
+  return PersonAge.fromYears(years);
+}
+function tryFromMonths(months) {
+  if (months < 0 || months > MAX_YEARS * 12) return null;
+  if (months * DAYS_PER_MONTH > MAX_TOTAL_DAYS) return null;
+  return PersonAge.fromMonths(months);
+}
+function tryFromDays(days) {
+  if (days < 0 || days > MAX_TOTAL_DAYS) return null;
+  return PersonAge.fromDays(days);
+}
+
+// src/person/person-masking.ts
+var MaskedNamePart = "***";
+function maskGivenName(value, options) {
+  if (options?.useInitials) return value.names.map(toInitial).join(" ");
+  return value.names.map(() => MaskedNamePart).join(" ");
+}
+function maskFamilyName(value, options) {
+  if (options?.useInitials) return toInitial(value.value);
+  return MaskedNamePart;
+}
+function maskFullName(value, options) {
+  const family = maskFamilyName(value.familyName, options);
+  if (options?.showGivenName) return `${value.givenName.value} ${family}`;
+  return `${maskGivenName(value.givenName, options)} ${family}`;
+}
+function maskPersonAge(value) {
+  if (value.years >= 1) return `${"*".repeat(String(value.years).length)} \xE5r`;
+  return `${"*".repeat(String(value.totalMonths).length)} m\xE5nader`;
+}
+function toInitial(value) {
+  return `${value[0]}.`;
+}
+
+// src/text-scanning/text-candidate-category.ts
+var TextCandidateCategory = {
+  PersonalIdentifier: "PersonalIdentifier"};
+
+// src/text-scanning/text-candidate.ts
+var TextCandidate = class {
+  /** Zero-based start position in the scanned text. */
+  startIndex;
+  /** Number of characters in the original matched span. */
+  length;
+  /** The raw substring from the input text that was matched. */
+  originalText;
+  /**
+   * Short type name, e.g. `EmailAddress` or `SwedishPersonalIdentityNumber`.
+   */
+  typeName;
+  /** Broad category of the matched type. */
+  category;
+  /** Machine-comparable canonical form of the matched value. */
+  normalizedForm;
+  /** Human-readable display form of the matched value. */
+  formattedForm;
+  /**
+   * Display form with sensitive content masked (e.g. `990807-****`).
+   * Produced by the type's `toMaskedString()` helper.
+   */
+  maskedForm;
+  /** Heuristic confidence level. */
+  confidence;
+  /** The successfully parsed instance of the matched type. */
+  value;
+  constructor(opts) {
+    this.startIndex = opts.startIndex;
+    this.length = opts.length;
+    this.originalText = opts.originalText;
+    this.typeName = opts.typeName;
+    this.category = opts.category;
+    this.normalizedForm = opts.normalizedForm;
+    this.formattedForm = opts.formattedForm;
+    this.maskedForm = opts.maskedForm;
+    this.confidence = opts.confidence;
+    this.value = opts.value;
+  }
+  /** Exclusive end position (`startIndex + length`). */
+  get endIndex() {
+    return this.startIndex + this.length;
+  }
+  /** Returns `true` if this candidate's span overlaps with `other`. */
+  overlaps(other) {
+    return this.startIndex < other.endIndex && other.startIndex < this.endIndex;
+  }
+  /** Returns `true` if this candidate's span fully contains `other`. */
+  contains(other) {
+    return this.startIndex <= other.startIndex && this.endIndex >= other.endIndex;
+  }
+};
+
+// src/text-scanning/text-match-confidence.ts
+var TextMatchConfidence = {
+  /**
+   * Strong match with checksum or format-specific validation (e.g. a personal
+   * identity number with a valid Luhn check digit and plausible date, or an
+   * IBAN with valid MOD-97).
+   */
+  High: 2
+};
+
+// src/validation/validation-error-reason.ts
+var ValidationErrorReason = {
+  // --- Common ---
+  InputIsEmpty: "InputIsEmpty",
+  InputTooLong: "InputTooLong",
+  InvalidFormat: "InvalidFormat"};
+
+// src/validation/validation-issue.ts
+var ValidationIssue = class {
+  reason;
+  englishDescription;
+  localizedDescription;
+  constructor(reason, englishDescription, localizedDescription) {
+    this.reason = reason;
+    this.englishDescription = englishDescription;
+    this.localizedDescription = localizedDescription;
+  }
+  /**
+   * Returns {@link localizedDescription} when
+   * {@link PrimitivesDefaults.useLocalizedDisplayNames} is `true`, otherwise
+   * {@link englishDescription}.
+   */
+  get description() {
+    return PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedDescription : this.englishDescription;
+  }
+};
+
+// src/validation/validation-result.ts
+var ValidationResult = class {
+  rawInput;
+  isValid;
+  issues;
+  /** @internal — use `validResult` / `invalidResult` factories. */
+  constructor(rawInput, isValid, issues) {
+    this.rawInput = rawInput ?? null;
+    this.isValid = isValid;
+    this.issues = Object.freeze([...issues]);
+  }
+};
+function validResult(rawInput) {
+  return new ValidationResult(rawInput, true, []);
+}
+function invalidResult(rawInput, reasonOrIssues, englishDescription, localizedDescription) {
+  if (typeof reasonOrIssues === "string") {
+    if (englishDescription === void 0 || localizedDescription === void 0) {
+      throw new Error("invalidResult requires both english and localized descriptions");
+    }
+    return new ValidationResult(rawInput, false, [
+      new ValidationIssue(reasonOrIssues, englishDescription, localizedDescription)
+    ]);
+  }
+  return new ValidationResult(rawInput, false, reasonOrIssues);
+}
+
+// src/internal/luhn.ts
+function luhnIsValid(digits) {
+  if (!digits) return false;
+  let sum = 0;
+  const len = digits.length;
+  for (let i = 0; i < len; i++) {
+    const code = digits.charCodeAt(i);
+    if (code < 48 || code > 57) return false;
+    let d = code - 48;
+    if ((len - i) % 2 === 0) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+  }
+  return sum % 10 === 0;
+}
+
+// src/person/personnummer-parser.ts
+var defaultClock = systemClock;
+var TWELVE = /^(\d{4})(\d{2})(\d{2})(\d{3})(\d)$/;
+var TEN = /^(\d{2})(\d{2})(\d{2})(\d{3})(\d)$/;
+var TEN_WITH_SEP = /^(\d{2})(\d{2})(\d{2})([-+])(\d{3})(\d)$/;
+var TWELVE_WITH_SEP = /^(\d{4})(\d{2})(\d{2})([-+])(\d{3})(\d)$/;
+function parsePin(input, clock = defaultClock) {
+  if (!input) return null;
+  const cleaned = input.trim();
+  if (cleaned.length === 0) return null;
+  let year, month, day;
+  let individual, check;
+  let hadPlus = false;
+  let isTwelve = false;
+  let m = TWELVE.exec(cleaned);
+  if (m) {
+    year = +m[1];
+    month = +m[2];
+    day = +m[3];
+    individual = m[4];
+    check = m[5];
+    isTwelve = true;
+  } else if (m = TEN.exec(cleaned)) {
+    const yy = +m[1];
+    year = inferCenturyForTenDigit(yy, false, clock);
+    month = +m[2];
+    day = +m[3];
+    individual = m[4];
+    check = m[5];
+  } else if (m = TEN_WITH_SEP.exec(cleaned)) {
+    const yy = +m[1];
+    hadPlus = m[4] === "+";
+    year = inferCenturyForTenDigit(yy, hadPlus, clock);
+    month = +m[2];
+    day = +m[3];
+    individual = m[5];
+    check = m[6];
+  } else if (m = TWELVE_WITH_SEP.exec(cleaned)) {
+    year = +m[1];
+    month = +m[2];
+    day = +m[3];
+    individual = m[5];
+    check = m[6];
+    if (m[4] === "+") return null;
+  } else {
+    return null;
+  }
+  if (month < 1 || month > 12) return null;
+  const isCoordination = day >= 60 && day <= 91;
+  let realDay;
+  let kind;
+  if (isCoordination) {
+    kind = "coordination";
+    realDay = day === 60 ? 0 : day - 60;
+    if (realDay !== 0 && !isValidDay(year, month, realDay)) return null;
+  } else {
+    kind = "personal";
+    if (!isValidDay(year, month, day)) return null;
+    realDay = day;
+  }
+  const luhnInput = String(year % 100).padStart(2, "0") + String(month).padStart(2, "0") + String(day).padStart(2, "0") + individual + check;
+  if (!luhnIsValid(luhnInput)) return null;
+  if (isTwelve && (year < 1800 || year > 2200)) return null;
+  return {
+    kind,
+    year,
+    month,
+    realDay,
+    individual,
+    checkDigit: check,
+    hadPlusSeparator: hadPlus
+  };
+}
+function isValidDay(year, month, day) {
+  if (day < 1) return false;
+  const dim = daysInMonth(year, month);
+  return day <= dim;
+}
+function daysInMonth(year, month) {
+  if (month === 2) {
+    const leap = year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+    return leap ? 29 : 28;
+  }
+  if ([4, 6, 9, 11].includes(month)) return 30;
+  return 31;
+}
+function inferCenturyForTenDigit(yy, plusSeparator, clock) {
+  const now = clock.now();
+  const currentYear = now.getUTCFullYear();
+  const currentCentury = Math.floor(currentYear / 100);
+  const candidate = currentCentury * 100 + yy;
+  let year = candidate;
+  if (year > currentYear) year -= 100;
+  if (plusSeparator) year -= 100;
+  return year;
+}
+function pinTo12Digit(p) {
+  const day = p.kind === "coordination" ? p.realDay === 0 ? 60 : p.realDay + 60 : p.realDay;
+  return String(p.year).padStart(4, "0") + String(p.month).padStart(2, "0") + String(day).padStart(2, "0") + p.individual + p.checkDigit;
+}
+function pinTo10Digit(p, clock = defaultClock) {
+  const day = p.kind === "coordination" ? p.realDay === 0 ? 60 : p.realDay + 60 : p.realDay;
+  const yy = String(p.year % 100).padStart(2, "0");
+  const sep = ageInYears(p, clock) >= 100 ? "+" : "-";
+  return yy + String(p.month).padStart(2, "0") + String(day).padStart(2, "0") + sep + p.individual + p.checkDigit;
+}
+function ageInYears(p, clock) {
+  if (p.kind === "coordination" && p.realDay === 0) return 0;
+  const now = clock.now();
+  const day = p.kind === "coordination" ? p.realDay : p.realDay;
+  const birth = new Date(Date.UTC(p.year, p.month - 1, day || 1));
+  const ms = now.getTime() - birth.getTime();
+  return Math.floor(ms / (365.25 * 24 * 3600 * 1e3));
+}
+function pinGender(p) {
+  const d = parseInt(p.individual.charAt(p.individual.length - 1), 10);
+  return d % 2 === 0 ? "female" : "male";
+}
+function pinDateOfBirth(p) {
+  if (p.kind === "coordination" && p.realDay === 0) return null;
+  return new Date(Date.UTC(p.year, p.month - 1, p.realDay));
+}
+function pinAgeInYears(p, clock = defaultClock) {
+  if (p.kind === "coordination" && p.realDay === 0) return null;
+  return ageInYears(p, clock);
+}
+
+// src/person/swedish-personal-identity-number.ts
+var MAX_INPUT_LENGTH4 = 20;
+var SCAN_PATTERN = /(?<!\d)(\d{6,8})([-+])(\d{4})(?!\d)/g;
+var SwedishPersonalIdentityNumber = class _SwedishPersonalIdentityNumber {
+  static typeInfo = Object.freeze({
+    englishName: "Personal Identity Number",
+    localizedName: "Personnummer",
+    emoji: "\u{1FAAA}",
+    sources: Object.freeze([
+      "https://skatteverket.se/privat/folkbokforing/personnummer.4.3810a01c150939e893f18c29.html",
+      "https://sv.wikipedia.org/wiki/Personnummer_i_Sverige",
+      "https://en.wikipedia.org/wiki/Luhn_algorithm"
+    ])
+  });
+  _pin;
+  _clock;
+  constructor(pin, clock) {
+    this._pin = pin;
+    this._clock = clock;
+  }
+  get formatted() {
+    return pinTo10Digit(this._pin, this._clock);
+  }
+  get value() {
+    return pinTo12Digit(this._pin);
+  }
+  get dateOfBirthHint() {
+    const d = pinDateOfBirth(this._pin);
+    if (d === null) throw new Error("Date of birth is unknown.");
+    return d;
+  }
+  get ageHint() {
+    const a = pinAgeInYears(this._pin, this._clock);
+    if (a === null) throw new Error("Age is unknown.");
+    return a;
+  }
+  get genderHint() {
+    return pinGender(this._pin);
+  }
+  static tryParse(input, options) {
+    if (input == null || input.trim() === "") return null;
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length === 0 || sanitized.length > MAX_INPUT_LENGTH4) return null;
+    const clock = options?.clock ?? systemClock;
+    const pin = parsePin(sanitized, clock);
+    if (pin === null) return null;
+    if (pin.kind !== "personal") return null;
+    return new _SwedishPersonalIdentityNumber(pin, clock);
+  }
+  static parse(input, options) {
+    const r = _SwedishPersonalIdentityNumber.tryParse(input, options);
+    if (r === null) throw new Error("Invalid Swedish personal identity number.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishPersonalIdentityNumber.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishPersonalIdentityNumber.tryParse(input, options);
+    if (r) return r.formatted;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _SwedishPersonalIdentityNumber.tryParse(input, options);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const t = input.trim();
+      return t.length > 0 ? t : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishPersonalIdentityNumber.normalize(input) === input;
+  }
+  static validate(input) {
+    if (input == null || input.trim() === "") {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputIsEmpty,
+        "Input is empty or whitespace.",
+        "V\xE4rdet \xE4r tomt."
+      );
+    }
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length > MAX_INPUT_LENGTH4) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputTooLong,
+        "Input contains too many characters.",
+        "V\xE4rdet inneh\xE5ller f\xF6r m\xE5nga tecken."
+      );
+    }
+    const pin = parsePin(sanitized);
+    if (pin === null || pin.kind !== "personal") {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidFormat,
+        "Invalid personal identity number format.",
+        "Ogiltigt format f\xF6r personnummer."
+      );
+    }
+    return validResult(input);
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.formatted;
+  }
+  to10DigitString() {
+    return this.formatted;
+  }
+  to12DigitString() {
+    return this.value;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    SCAN_PATTERN.lastIndex = 0;
+    let m;
+    while ((m = SCAN_PATTERN.exec(text)) !== null) {
+      const pin = _SwedishPersonalIdentityNumber.tryParse(m[0]);
+      if (!pin) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "SwedishPersonalIdentityNumber",
+          category: TextCandidateCategory.PersonalIdentifier,
+          normalizedForm: pin.toNormalizedString(),
+          formattedForm: pin.toString(),
+          maskedForm: maskPersonalIdentityNumber(pin),
+          confidence: TextMatchConfidence.High,
+          value: pin
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+function maskPersonalIdentityNumber(p, options) {
+  const f = p.formatted;
+  if (options?.maskBirthDate) return "******-****";
+  return f.slice(0, f.length - 4) + "****";
+}
+
+// src/person/swedish-coordination-number.ts
+var MAX_INPUT_LENGTH5 = 20;
+var SCAN_PATTERN2 = /(?<!\d)(\d{6,8})([-+])(\d{4})(?!\d)/g;
+var SwedishCoordinationNumber = class _SwedishCoordinationNumber {
+  static typeInfo = Object.freeze({
+    englishName: "Coordination Number",
+    localizedName: "Samordningsnummer",
+    emoji: "\u{1F194}",
+    sources: Object.freeze([
+      "https://skatteverket.se/privat/folkbokforing/samordningsnummer.4.5c281c7015abecc2e201130b.html",
+      "https://sv.wikipedia.org/wiki/Samordningsnummer"
+    ])
+  });
+  _pin;
+  _clock;
+  constructor(pin, clock) {
+    this._pin = pin;
+    this._clock = clock;
+  }
+  get formatted() {
+    return pinTo10Digit(this._pin, this._clock);
+  }
+  get value() {
+    return pinTo12Digit(this._pin);
+  }
+  get realDay() {
+    return this._pin.realDay;
+  }
+  get dateOfBirthHint() {
+    return pinDateOfBirth(this._pin);
+  }
+  get ageHint() {
+    return pinAgeInYears(this._pin, this._clock);
+  }
+  get genderHint() {
+    return pinGender(this._pin);
+  }
+  static tryParse(input, options) {
+    if (input == null || input.trim() === "") return null;
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length === 0 || sanitized.length > MAX_INPUT_LENGTH5) return null;
+    const clock = options?.clock ?? systemClock;
+    const pin = parsePin(sanitized, clock);
+    if (pin === null) return null;
+    if (pin.kind !== "coordination") return null;
+    return new _SwedishCoordinationNumber(pin, clock);
+  }
+  static parse(input, options) {
+    const r = _SwedishCoordinationNumber.tryParse(input, options);
+    if (r === null) throw new Error("Invalid Swedish coordination number.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishCoordinationNumber.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishCoordinationNumber.tryParse(input, options);
+    if (r) return r.formatted;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _SwedishCoordinationNumber.tryParse(input, options);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const t = input.trim();
+      return t.length > 0 ? t : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishCoordinationNumber.normalize(input) === input;
+  }
+  static validate(input) {
+    if (input == null || input.trim() === "") {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputIsEmpty,
+        "Input is empty or whitespace.",
+        "V\xE4rdet \xE4r tomt."
+      );
+    }
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length > MAX_INPUT_LENGTH5) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputTooLong,
+        "Input contains too many characters.",
+        "V\xE4rdet inneh\xE5ller f\xF6r m\xE5nga tecken."
+      );
+    }
+    const pin = parsePin(sanitized);
+    if (pin === null || pin.kind !== "coordination") {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidFormat,
+        "Invalid coordination number format.",
+        "Ogiltigt format f\xF6r samordningsnummer."
+      );
+    }
+    return validResult(input);
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.formatted;
+  }
+  to10DigitString() {
+    return this.formatted;
+  }
+  to12DigitString() {
+    return this.value;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    SCAN_PATTERN2.lastIndex = 0;
+    let m;
+    while ((m = SCAN_PATTERN2.exec(text)) !== null) {
+      const cn = _SwedishCoordinationNumber.tryParse(m[0]);
+      if (!cn) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "SwedishCoordinationNumber",
+          category: TextCandidateCategory.PersonalIdentifier,
+          normalizedForm: cn.toNormalizedString(),
+          formattedForm: cn.toString(),
+          maskedForm: maskCoordinationNumber(cn),
+          confidence: TextMatchConfidence.High,
+          value: cn
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+function maskCoordinationNumber(c, options) {
+  const f = c.formatted;
+  if (options?.maskBirthDate) return "******-****";
+  return f.slice(0, f.length - 4) + "****";
+}
+
+exports.PersonAge = PersonAge;
+exports.PersonFamilyName = PersonFamilyName;
+exports.PersonFullName = PersonFullName;
+exports.PersonGivenName = PersonGivenName;
+exports.SwedishCoordinationNumber = SwedishCoordinationNumber;
+exports.SwedishPersonalIdentityNumber = SwedishPersonalIdentityNumber;
+exports.maskCoordinationNumber = maskCoordinationNumber;
+exports.maskFamilyName = maskFamilyName;
+exports.maskFullName = maskFullName;
+exports.maskGivenName = maskGivenName;
+exports.maskPersonAge = maskPersonAge;
+exports.maskPersonalIdentityNumber = maskPersonalIdentityNumber;
+exports.parsePin = parsePin;
+exports.pinAgeInYears = pinAgeInYears;
+exports.pinDateOfBirth = pinDateOfBirth;
+exports.pinGender = pinGender;
+exports.pinTo10Digit = pinTo10Digit;
+exports.pinTo12Digit = pinTo12Digit;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map