@budiauktioner/buildi-primitives 0.1.0

package/dist/organization/index.cjs

@@ -0,0 +1,2376 @@
+'use strict';
+
+// src/organization/swedish-organization-type.ts
+var SwedishOrganizationType = /* @__PURE__ */ ((SwedishOrganizationType2) => {
+  SwedishOrganizationType2[SwedishOrganizationType2["Unknown"] = 0] = "Unknown";
+  SwedishOrganizationType2[SwedishOrganizationType2["Aktiebolag"] = 1] = "Aktiebolag";
+  SwedishOrganizationType2[SwedishOrganizationType2["Dodsbo"] = 2] = "Dodsbo";
+  SwedishOrganizationType2[SwedishOrganizationType2["HandelsbolagEllerKommanditbolag"] = 10] = "HandelsbolagEllerKommanditbolag";
+  SwedishOrganizationType2[SwedishOrganizationType2["Handelsbolag"] = 11] = "Handelsbolag";
+  SwedishOrganizationType2[SwedishOrganizationType2["Kommanditbolag"] = 12] = "Kommanditbolag";
+  SwedishOrganizationType2[SwedishOrganizationType2["EkonomiskForening"] = 20] = "EkonomiskForening";
+  SwedishOrganizationType2[SwedishOrganizationType2["Bostadsrattsforening"] = 21] = "Bostadsrattsforening";
+  SwedishOrganizationType2[SwedishOrganizationType2["Samfallighetsforening"] = 22] = "Samfallighetsforening";
+  SwedishOrganizationType2[SwedishOrganizationType2["IdeellForening"] = 30] = "IdeellForening";
+  SwedishOrganizationType2[SwedishOrganizationType2["Stiftelse"] = 31] = "Stiftelse";
+  SwedishOrganizationType2[SwedishOrganizationType2["OffentligSektor"] = 40] = "OffentligSektor";
+  SwedishOrganizationType2[SwedishOrganizationType2["Kommun"] = 41] = "Kommun";
+  SwedishOrganizationType2[SwedishOrganizationType2["Region"] = 42] = "Region";
+  SwedishOrganizationType2[SwedishOrganizationType2["Forsamling"] = 43] = "Forsamling";
+  SwedishOrganizationType2[SwedishOrganizationType2["EnkeltBolag"] = 50] = "EnkeltBolag";
+  SwedishOrganizationType2[SwedishOrganizationType2["Filial"] = 51] = "Filial";
+  SwedishOrganizationType2[SwedishOrganizationType2["Europabolag"] = 52] = "Europabolag";
+  SwedishOrganizationType2[SwedishOrganizationType2["EuropeiskEkonomiskIntressegruppering"] = 53] = "EuropeiskEkonomiskIntressegruppering";
+  SwedishOrganizationType2[SwedishOrganizationType2["SCEForening"] = 54] = "SCEForening";
+  SwedishOrganizationType2[SwedishOrganizationType2["EnskildFirmaEllerPrivatperson"] = 60] = "EnskildFirmaEllerPrivatperson";
+  SwedishOrganizationType2[SwedishOrganizationType2["EnskildFirma"] = 61] = "EnskildFirma";
+  SwedishOrganizationType2[SwedishOrganizationType2["Privatperson"] = 62] = "Privatperson";
+  SwedishOrganizationType2[SwedishOrganizationType2["Other"] = 99] = "Other";
+  return SwedishOrganizationType2;
+})(SwedishOrganizationType || {});
+
+// src/organization/swedish-organization-identifier-type.ts
+var SwedishOrganizationIdentifierType = /* @__PURE__ */ ((SwedishOrganizationIdentifierType2) => {
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["Unknown"] = 0] = "Unknown";
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["SwedishOrganizationNumber"] = 1] = "SwedishOrganizationNumber";
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["SwedishPersonalIdentityNumber"] = 2] = "SwedishPersonalIdentityNumber";
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["SwedishCoordinationNumber"] = 3] = "SwedishCoordinationNumber";
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["EuVatNumber"] = 10] = "EuVatNumber";
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["DunsNumber"] = 20] = "DunsNumber";
+  SwedishOrganizationIdentifierType2[SwedishOrganizationIdentifierType2["LeiCode"] = 30] = "LeiCode";
+  return SwedishOrganizationIdentifierType2;
+})(SwedishOrganizationIdentifierType || {});
+var DEFAULT_UI_CULTURE = "sv-SE";
+var state = {
+  uiCulture: DEFAULT_UI_CULTURE};
+var PrimitivesDefaults = {
+  /**
+   * `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, " ");
+}
+function keepDigits(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 48 && c <= 57) out += input[i];
+  }
+  return out;
+}
+function keepAsciiAlphanumericUppercase(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 48 && c <= 57) out += input[i];
+    else if (c >= 65 && c <= 90) out += input[i];
+    else if (c >= 97 && c <= 122) out += String.fromCharCode(c - 32);
+  }
+  return out;
+}
+
+// src/internal/clock.ts
+var systemClock = {
+  now: () => /* @__PURE__ */ new Date()
+};
+
+// src/text-scanning/text-candidate-category.ts
+var TextCandidateCategory = {
+  PersonalIdentifier: "PersonalIdentifier",
+  OrganizationIdentifier: "OrganizationIdentifier"};
+
+// 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 = {
+  /**
+   * Pattern match only. High false-positive risk — the matched text merely
+   * fits a syntactic pattern (e.g. a run of digits that happens to be the
+   * right length).
+   */
+  Low: 0,
+  /**
+   * 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",
+  InputTooShort: "InputTooShort",
+  InvalidLength: "InvalidLength",
+  InvalidFormat: "InvalidFormat",
+  InvalidCheckDigit: "InvalidCheckDigit",
+  InvalidEntityPattern: "InvalidEntityPattern",
+  // --- International / country ---
+  UnknownCountryCode: "UnknownCountryCode",
+  InvalidCountryPrefix: "InvalidCountryPrefix"};
+
+// 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_LENGTH = 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_LENGTH) 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_LENGTH) {
+      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;
+  return f.slice(0, f.length - 4) + "****";
+}
+
+// src/person/swedish-coordination-number.ts
+var MAX_INPUT_LENGTH2 = 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_LENGTH2) 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_LENGTH2) {
+      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;
+  return f.slice(0, f.length - 4) + "****";
+}
+
+// src/organization/duns-number.ts
+var MAX_INPUT_LENGTH3 = 20;
+var DunsNumber = class _DunsNumber {
+  static typeInfo = Object.freeze({
+    englishName: "D-U-N-S Number",
+    localizedName: "D-U-N-S-nummer",
+    emoji: "\u{1F522}",
+    sources: Object.freeze([
+      "https://www.dnb.com/duns.html",
+      "https://en.wikipedia.org/wiki/Data_Universal_Numbering_System"
+    ])
+  });
+  digits;
+  constructor(digits) {
+    this.digits = digits;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const digits = keepDigits(sanitizeInput(input));
+    if (digits.length > MAX_INPUT_LENGTH3 || digits.length !== 9) return null;
+    return new _DunsNumber(digits);
+  }
+  static parse(input) {
+    const r = _DunsNumber.tryParse(input);
+    if (r === null) throw new Error("Invalid D-U-N-S number.");
+    return r;
+  }
+  static isValid(input) {
+    return _DunsNumber.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _DunsNumber.tryParse(input);
+    if (r) return r.digits;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _DunsNumber.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _DunsNumber.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.digits;
+  }
+  toString() {
+    return this.digits;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const re = /(?<!\d)\d{9}(?!\d)/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const r = _DunsNumber.tryParse(m[0]);
+      if (!r) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "DunsNumber",
+          category: TextCandidateCategory.OrganizationIdentifier,
+          normalizedForm: r.toNormalizedString(),
+          formattedForm: r.toString(),
+          maskedForm: maskDunsNumber(r),
+          confidence: TextMatchConfidence.Low,
+          value: r
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this.digits === other.digits;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.digits < other.digits ? -1 : this.digits > other.digits ? 1 : 0;
+  }
+};
+function maskDunsNumber(d) {
+  return "*".repeat(d.digits.length);
+}
+
+// src/organization/organization-validation-utils.ts
+function isValidIso7064Mod97(input) {
+  if (!input) return false;
+  let s = "";
+  for (const c of input) {
+    if (c >= "0" && c <= "9") s += c;
+    else if (c >= "A" && c <= "Z") s += String(c.charCodeAt(0) - 55);
+    else if (c >= "a" && c <= "z") s += String(c.charCodeAt(0) - 87);
+    else return false;
+  }
+  let mod = 0;
+  for (let i = 0; i < s.length; i++) {
+    mod = (mod * 10 + (s.charCodeAt(i) - 48)) % 97;
+  }
+  return mod === 1;
+}
+function cleanSeparators(input) {
+  if (!input) return "";
+  let out = "";
+  for (const c of input) {
+    if (c !== " " && c !== "-" && c !== "\xA0") out += c;
+  }
+  return out;
+}
+function nameContains(haystack, ...needles) {
+  if (!haystack) return false;
+  for (const n of needles) if (haystack.indexOf(n) >= 0) return true;
+  return false;
+}
+function nameContainsStandalone(haystack, ...needles) {
+  if (!haystack) return false;
+  for (const n of needles) {
+    if (haystack === n) return true;
+    if (haystack.startsWith(n + " ")) return true;
+    if (haystack.endsWith(" " + n)) return true;
+    if (haystack.indexOf(" " + n + " ") >= 0) return true;
+  }
+  return false;
+}
+
+// src/organization/swedish-organization-name.ts
+var MAX_INPUT_LENGTH4 = 300;
+var COMPANY_NAME_PATTERN = /^[\p{L}\d\s\-'&.,/:()+]+$/u;
+var ORG_SUFFIX_TOKENS = ["AB", "HB", "KB", "BRF", "HSB", "EF"];
+var ORG_SUFFIX_PHRASES = [
+  " EK.F\xD6R.",
+  " EK F\xD6R",
+  " EKONOMISK F\xD6RENING",
+  " IDEELL F\xD6RENING",
+  " SAMF\xC4LLIGHETSF\xD6RENING",
+  " RIKSF\xD6RBUND"
+];
+var ORG_PREFIXES = ["STIFTELSEN ", "BRF ", "HSB "];
+var ORG_KEYWORDS = [
+  " KOMMUN",
+  " REGION",
+  " LANDSTING",
+  " MYNDIGHET",
+  " STIFTELSE",
+  " F\xD6RENING"
+];
+var KNOWN_ABBREVIATIONS = /* @__PURE__ */ new Set(["AB", "HB", "KB", "BRF", "HSB", "EF"]);
+var KNOWN_GOVERNMENT_AGENCIES = /* @__PURE__ */ new Set([
+  "SKATTEVERKET",
+  "TULLVERKET",
+  "KRONOFOGDEN",
+  "STATISTISKA CENTRALBYR\xC5N",
+  "KRIMINALV\xC5RDEN",
+  "MIGRATIONSVERKET",
+  "DOMSTOLSVERKET",
+  "BROTTSF\xD6REBYGGANDE R\xC5DET",
+  "F\xD6RS\xC4KRINGSKASSAN",
+  "SOCIALSTYRELSEN",
+  "SKOLVERKET",
+  "CENTRALA STUDIEST\xD6DSN\xC4MNDEN",
+  "UNIVERSITETS- OCH H\xD6GSKOLER\xC5DET",
+  "BOLAGSVERKET",
+  "TRAFIKVERKET",
+  "TRANSPORTSTYRELSEN",
+  "TILLV\xC4XTVERKET",
+  "PATENT- OCH REGISTRERINGSVERKET",
+  "ARBETSF\xD6RMEDLINGEN",
+  "ARBETSMILJ\xD6VERKET",
+  "NATURV\xC5RDSVERKET",
+  "F\xD6RSVARSMAKTEN",
+  "POST- OCH TELESTYRELSEN",
+  "SJ\xD6FARTSVERKET",
+  "RIKSBANKEN",
+  "RIKSREVISIONEN",
+  "RIKSG\xC4LDEN",
+  "RIKSG\xC4LDSKONTORET",
+  "EKONOMISTYRNINGSVERKET",
+  "JORDBRUKSVERKET",
+  "LIVSMEDELSVERKET",
+  "LANTM\xC4TERIET",
+  "BOVERKET",
+  "KONSUMENTVERKET",
+  "RIKSARKIVET",
+  "KUNGLIGA BIBLIOTEKET",
+  "KEMIKALIEINSPEKTIONEN",
+  "INTEGRITETSSKYDDSMYNDIGHETEN",
+  "ELS\xC4KERHETSVERKET",
+  "HAVS- OCH VATTENMYNDIGHETEN",
+  "SKOGSSTYRELSEN",
+  "VALMYNDIGHETEN",
+  "L\xC4NSSTYRELSEN",
+  "DATAINSPEKTIONEN",
+  "KONKURRENSVERKET",
+  "UPPHANDLINGSMYNDIGHETEN"
+]);
+var SwedishOrganizationName = class _SwedishOrganizationName {
+  static typeInfo = Object.freeze({
+    englishName: "Organization Name",
+    localizedName: "Organisationsnamn",
+    emoji: "\u{1F3F7}\uFE0F",
+    sources: Object.freeze(["https://bolagsverket.se"])
+  });
+  value;
+  casingNormalizedValue;
+  hasOrganizationIndicators;
+  inferredSwedishOrganizationType;
+  constructor(value, casingNormalized, hasIndicators, inferredType) {
+    this.value = value;
+    this.casingNormalizedValue = casingNormalized;
+    this.hasOrganizationIndicators = hasIndicators;
+    this.inferredSwedishOrganizationType = inferredType;
+  }
+  static tryParse(input) {
+    const normalized = collapseWhitespace(input);
+    if (normalized.length === 0 || normalized.length > MAX_INPUT_LENGTH4) return null;
+    if (!validateName(normalized)) return null;
+    const forInference = stripPublSuffix(normalized);
+    const hasIndicators = detectOrganizationIndicators(forInference);
+    const inferred = inferTypeFromName(forInference);
+    const casing = _SwedishOrganizationName.normalizeCasing(normalized);
+    return new _SwedishOrganizationName(normalized, casing, hasIndicators, inferred);
+  }
+  static parse(input) {
+    const r = _SwedishOrganizationName.tryParse(input);
+    if (r === null) throw new Error("Invalid organization name.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishOrganizationName.tryParse(input) !== null;
+  }
+  static isKnownGovernmentAgency(name) {
+    if (name == null || name.trim() === "") return false;
+    return KNOWN_GOVERNMENT_AGENCIES.has(collapseWhitespace(name).toUpperCase());
+  }
+  static inferSwedishOrganizationType(name) {
+    if (name == null || name.trim() === "") return 0 /* Unknown */;
+    return inferTypeFromName(stripPublSuffix(collapseWhitespace(name)));
+  }
+  static normalizeCasing(name) {
+    const letters = [...name].filter((c) => /\p{L}/u.test(c));
+    if (letters.length === 0) return name;
+    const allLower = letters.every((c) => c === c.toLowerCase());
+    const allUpper = letters.every((c) => c === c.toUpperCase());
+    if (!allLower && !allUpper) return name;
+    return name.split(" ").map((w) => KNOWN_ABBREVIATIONS.has(w.toUpperCase()) ? w.toUpperCase() : capitalizeWord(w)).join(" ");
+  }
+  static format(input, options) {
+    const r = _SwedishOrganizationName.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _SwedishOrganizationName.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishOrganizationName.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;
+  }
+};
+function stripPublSuffix(name) {
+  const trimmed = name.trimEnd();
+  if (trimmed.toUpperCase().endsWith("(PUBL)")) return trimmed.slice(0, -6).trimEnd();
+  return name;
+}
+function validateName(value) {
+  if (value.length < 2 || value.length > 200) return false;
+  for (const c of value) {
+    const code = c.charCodeAt(0);
+    if (code < 32 || code === 127) return false;
+  }
+  return COMPANY_NAME_PATTERN.test(value);
+}
+function detectOrganizationIndicators(collapsed) {
+  const upper = collapsed.toUpperCase();
+  if (!upper) return false;
+  const words = upper.split(" ");
+  if (words.length > 0 && ORG_SUFFIX_TOKENS.includes(words[words.length - 1])) return true;
+  for (const p of ORG_SUFFIX_PHRASES) if (upper.endsWith(p)) return true;
+  for (const p of ORG_PREFIXES) if (upper.startsWith(p)) return true;
+  for (const k of ORG_KEYWORDS) if (upper.indexOf(k) >= 0) return true;
+  if (KNOWN_GOVERNMENT_AGENCIES.has(upper)) return true;
+  return false;
+}
+function inferTypeFromName(collapsed) {
+  const upper = collapsed.toUpperCase();
+  if (!upper) return 0 /* Unknown */;
+  const words = upper.split(" ");
+  const lastWord = words.length > 0 ? words[words.length - 1] : "";
+  if (lastWord === "AB") return 1 /* Aktiebolag */;
+  if (lastWord === "KB" || nameContains(upper, "KOMMANDITBOLAG"))
+    return 12 /* Kommanditbolag */;
+  if (lastWord === "HB" || nameContains(upper, "HANDELSBOLAG"))
+    return 11 /* Handelsbolag */;
+  if (nameContainsStandalone(upper, "BRF") || nameContains(upper, "BOSTADSR\xC4TTSF\xD6RENING", "BOSTADSRATTSFORENING"))
+    return 21 /* Bostadsrattsforening */;
+  if (nameContains(
+    upper,
+    "SAMF\xC4LLIGHETSF\xD6RENING",
+    "SAMFALLIGHETSFORENING",
+    "SAMFALLIGHETSSFORENING",
+    "SAMF\xC4LLIGHET",
+    "SAMFALLIGHET"
+  ))
+    return 22 /* Samfallighetsforening */;
+  if (lastWord === "HSB" || upper.startsWith("HSB "))
+    return 20 /* EkonomiskForening */;
+  if (upper.endsWith(" EK.F\xD6R.") || upper.endsWith(" EK F\xD6R") || nameContains(upper, "EKONOMISK F\xD6RENING"))
+    return 20 /* EkonomiskForening */;
+  if (nameContains(upper, "IDEELL F\xD6RENING")) return 30 /* IdeellForening */;
+  if (upper.startsWith("STIFTELSEN ") || nameContains(upper, "STIFTELSE"))
+    return 31 /* Stiftelse */;
+  if (nameContains(upper, "KOMMUN")) return 41 /* Kommun */;
+  if (nameContains(upper, "REGION", "LANDSTING")) return 42 /* Region */;
+  if (nameContains(upper, "F\xD6RSAMLING", "FORSAMLING")) return 43 /* Forsamling */;
+  if (nameContains(upper, "MYNDIGHET")) return 40 /* OffentligSektor */;
+  if (KNOWN_GOVERNMENT_AGENCIES.has(upper)) return 40 /* OffentligSektor */;
+  if (nameContains(upper, "D\xD6DSBO", "DODSBO")) return 2 /* Dodsbo */;
+  if (lastWord === "EF" || nameContains(upper, "ENSKILD FIRMA"))
+    return 61 /* EnskildFirma */;
+  if (nameContains(upper, "PRIVATPERSON")) return 62 /* Privatperson */;
+  if (nameContainsStandalone(upper, "EUROPABOLAG", "SE-BOLAG"))
+    return 52 /* Europabolag */;
+  if (nameContainsStandalone(upper, "EUROPEISK EKONOMISK INTRESSEGRUPPERING", "EEIG"))
+    return 53 /* EuropeiskEkonomiskIntressegruppering */;
+  if (nameContainsStandalone(upper, "SCE") || nameContains(upper, "EUROPEISK KOOPERATIV F\xD6RENING"))
+    return 54 /* SCEForening */;
+  if (nameContainsStandalone(upper, "FILIAL")) return 51 /* Filial */;
+  if (nameContains(upper, "RIKSF\xD6RBUND", "F\xD6RENING")) return 30 /* IdeellForening */;
+  return 0 /* Unknown */;
+}
+function maskSwedishOrganizationName(value) {
+  return value.value.split(" ").filter((part) => part.length > 0).map((part) => part.length <= 1 ? "*" : part[0] + "*".repeat(part.length - 1)).join(" ");
+}
+function capitalizeWord(word) {
+  if (!word) return word;
+  const lowered = word.toLocaleLowerCase("sv-SE");
+  return lowered[0].toLocaleUpperCase("sv-SE") + lowered.slice(1);
+}
+
+// src/organization/swedish-organization-number.ts
+var MAX_INPUT_LENGTH5 = 30;
+var LEGAL_ENTITY_PREFIX = "16";
+var SwedishOrganizationNumber = class _SwedishOrganizationNumber {
+  static typeInfo = Object.freeze({
+    englishName: "Organization Number",
+    localizedName: "Organisationsnummer",
+    emoji: "\u{1F3E2}",
+    sources: Object.freeze([
+      "https://bolagsverket.se",
+      "https://skatteverket.se/foretag/drivaforetag/startaforetag/organisationsnummer.html",
+      "https://sv.wikipedia.org/wiki/Organisationsnummer"
+    ])
+  });
+  _tenWithDash;
+  _twelveDigits;
+  _isPerson;
+  get isPerson() {
+    return this._isPerson;
+  }
+  constructor(tenWithDash, twelveDigits, isPerson) {
+    this._tenWithDash = tenWithDash;
+    this._twelveDigits = twelveDigits;
+    this._isPerson = isPerson;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length > MAX_INPUT_LENGTH5) return null;
+    const pin = SwedishPersonalIdentityNumber.tryParse(sanitized);
+    if (pin) {
+      return new _SwedishOrganizationNumber(pin.formatted, pin.value, true);
+    }
+    const cn = SwedishCoordinationNumber.tryParse(sanitized);
+    if (cn) {
+      return new _SwedishOrganizationNumber(cn.formatted, cn.value, true);
+    }
+    const digits = keepDigits(sanitized);
+    if (digits.length === 0) return null;
+    let tenDigits;
+    if (digits.length === 10) tenDigits = digits;
+    else if (digits.length === 12 && digits.startsWith(LEGAL_ENTITY_PREFIX))
+      tenDigits = digits.slice(2);
+    else return null;
+    if (!isLegalEntityPattern(tenDigits)) return null;
+    if (!luhnIsValid(tenDigits)) return null;
+    const tenWithDash = `${tenDigits.slice(0, 6)}-${tenDigits.slice(6)}`;
+    const twelve = LEGAL_ENTITY_PREFIX + tenDigits;
+    return new _SwedishOrganizationNumber(tenWithDash, twelve, false);
+  }
+  static parse(input) {
+    const r = _SwedishOrganizationNumber.tryParse(input);
+    if (r === null) throw new Error("Invalid Swedish organization number.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishOrganizationNumber.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishOrganizationNumber.tryParse(input);
+    if (r) return r.to10DigitString();
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _SwedishOrganizationNumber.tryParse(input);
+    if (r) return r.to12DigitString();
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const t = input.trim();
+      return t.length > 0 ? t : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishOrganizationNumber.normalize(input) === input;
+  }
+  to10DigitsOnly() {
+    return this._tenWithDash.replace(/[-+]/g, "");
+  }
+  to10DigitString() {
+    return this._tenWithDash;
+  }
+  to12DigitString() {
+    return this._twelveDigits;
+  }
+  toNormalizedString() {
+    return this.to12DigitString();
+  }
+  toString() {
+    return this.to10DigitString();
+  }
+  getSwedishOrganizationTypeHint(name, isPrivatePerson) {
+    let certain;
+    let bestGuess;
+    if (this._isPerson) {
+      certain = 60 /* EnskildFirmaEllerPrivatperson */;
+      if (isPrivatePerson === true) bestGuess = 62 /* Privatperson */;
+      else if (isPrivatePerson === false) bestGuess = 61 /* EnskildFirma */;
+      else {
+        const nameType2 = SwedishOrganizationName.inferSwedishOrganizationType(name ?? null);
+        bestGuess = nameType2 === 61 /* EnskildFirma */ || nameType2 === 62 /* Privatperson */ ? nameType2 : certain;
+      }
+      return { certain, bestGuess };
+    }
+    const first = this.to10DigitsOnly()[0];
+    const nameType = SwedishOrganizationName.inferSwedishOrganizationType(name ?? null);
+    switch (first) {
+      case "1":
+        certain = 2 /* Dodsbo */;
+        bestGuess = certain;
+        break;
+      case "2":
+        certain = 40 /* OffentligSektor */;
+        bestGuess = nameType === 41 /* Kommun */ || nameType === 42 /* Region */ || nameType === 43 /* Forsamling */ ? nameType : certain;
+        break;
+      case "5":
+        certain = 1 /* Aktiebolag */;
+        bestGuess = nameType === 12 /* Kommanditbolag */ ? nameType : certain;
+        break;
+      case "6":
+        certain = 10 /* HandelsbolagEllerKommanditbolag */;
+        bestGuess = nameType === 12 /* Kommanditbolag */ || nameType === 11 /* Handelsbolag */ ? nameType : certain;
+        break;
+      case "7":
+        certain = 20 /* EkonomiskForening */;
+        bestGuess = nameType === 21 /* Bostadsrattsforening */ || nameType === 22 /* Samfallighetsforening */ ? nameType : certain;
+        break;
+      case "8":
+        certain = 30 /* IdeellForening */;
+        bestGuess = nameType === 31 /* Stiftelse */ ? nameType : certain;
+        break;
+      case "9":
+        certain = 10 /* HandelsbolagEllerKommanditbolag */;
+        bestGuess = nameType === 12 /* Kommanditbolag */ || nameType === 11 /* Handelsbolag */ ? nameType : certain;
+        break;
+      default:
+        certain = 99 /* Other */;
+        bestGuess = nameType === 53 /* EuropeiskEkonomiskIntressegruppering */ || nameType === 52 /* Europabolag */ || nameType === 54 /* SCEForening */ || nameType === 51 /* Filial */ ? nameType : certain;
+        break;
+    }
+    return { certain, bestGuess };
+  }
+  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."
+      );
+    }
+    if (SwedishPersonalIdentityNumber.tryParse(sanitized)) return validResult(input);
+    if (SwedishCoordinationNumber.tryParse(sanitized)) return validResult(input);
+    const digits = keepDigits(sanitized);
+    if (digits.length === 0) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidFormat,
+        "Input contains no digits.",
+        "V\xE4rdet inneh\xE5ller inga siffror."
+      );
+    }
+    if (!(digits.length === 10 || digits.length === 12 && digits.startsWith(LEGAL_ENTITY_PREFIX))) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidLength,
+        "Organization number must be 10 or 12 digits (12-digit form must start with 16).",
+        "Organisationsnummer m\xE5ste vara 10 eller 12 siffror (12-siffrig form m\xE5ste b\xF6rja med 16)."
+      );
+    }
+    const tenDigits = digits.length === 12 ? digits.slice(2) : digits;
+    if (!isLegalEntityPattern(tenDigits)) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidEntityPattern,
+        "Number does not match a valid organization type pattern.",
+        "Numret matchar inte ett giltigt organisationstypsm\xF6nster."
+      );
+    }
+    if (!luhnIsValid(tenDigits)) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidCheckDigit,
+        "Invalid check digit.",
+        "Ogiltig kontrollsiffra."
+      );
+    }
+    return validResult(input);
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const re = /(?<!\d)(\d{6})-?(\d{4})(?!\d)/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const r = _SwedishOrganizationNumber.tryParse(m[0]);
+      if (!r || r.isPerson) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "SwedishOrganizationNumber",
+          category: TextCandidateCategory.OrganizationIdentifier,
+          normalizedForm: r.toNormalizedString(),
+          formattedForm: r.toString(),
+          maskedForm: maskSwedishOrganizationNumber(r),
+          confidence: TextMatchConfidence.High,
+          value: r
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this._twelveDigits === other._twelveDigits;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this._twelveDigits < other._twelveDigits ? -1 : this._twelveDigits > other._twelveDigits ? 1 : 0;
+  }
+};
+function isLegalEntityPattern(tenDigits) {
+  if (tenDigits.length !== 10) return false;
+  if (tenDigits[0] === "1") return true;
+  const first = tenDigits[0];
+  if (first !== "2" && first !== "3" && first !== "5" && first !== "6" && first !== "7" && first !== "8" && first !== "9")
+    return false;
+  const m1 = tenDigits.charCodeAt(2) - 48;
+  const m2 = tenDigits.charCodeAt(3) - 48;
+  const mm = m1 * 10 + m2;
+  return mm >= 20;
+}
+function maskSwedishOrganizationNumber(o, options) {
+  const s = o.to10DigitString();
+  if (o.isPerson) {
+    const sep = s[6];
+    if (options?.maskBirthDate) return "******" + sep + "****";
+    return s.slice(0, 6) + sep + "****";
+  }
+  if (options?.maskOrganizationNumbers) return s.slice(0, 7) + "****";
+  return s;
+}
+
+// src/organization/eu-vat-number.ts
+var MAX_INPUT_LENGTH6 = 30;
+var COUNTRY_INFO = Object.freeze({
+  AT: { countryCode: "AT", countryName: "Austria" },
+  BE: { countryCode: "BE", countryName: "Belgium" },
+  BG: { countryCode: "BG", countryName: "Bulgaria" },
+  HR: { countryCode: "HR", countryName: "Croatia" },
+  CY: { countryCode: "CY", countryName: "Cyprus" },
+  CZ: { countryCode: "CZ", countryName: "Czech Republic" },
+  DK: { countryCode: "DK", countryName: "Denmark" },
+  EE: { countryCode: "EE", countryName: "Estonia" },
+  FI: { countryCode: "FI", countryName: "Finland" },
+  FR: { countryCode: "FR", countryName: "France" },
+  DE: { countryCode: "DE", countryName: "Germany" },
+  EL: { countryCode: "GR", countryName: "Greece" },
+  GR: { countryCode: "GR", countryName: "Greece" },
+  HU: { countryCode: "HU", countryName: "Hungary" },
+  IE: { countryCode: "IE", countryName: "Ireland" },
+  IT: { countryCode: "IT", countryName: "Italy" },
+  LV: { countryCode: "LV", countryName: "Latvia" },
+  LT: { countryCode: "LT", countryName: "Lithuania" },
+  LU: { countryCode: "LU", countryName: "Luxembourg" },
+  MT: { countryCode: "MT", countryName: "Malta" },
+  NL: { countryCode: "NL", countryName: "Netherlands" },
+  PL: { countryCode: "PL", countryName: "Poland" },
+  PT: { countryCode: "PT", countryName: "Portugal" },
+  RO: { countryCode: "RO", countryName: "Romania" },
+  SK: { countryCode: "SK", countryName: "Slovakia" },
+  SI: { countryCode: "SI", countryName: "Slovenia" },
+  ES: { countryCode: "ES", countryName: "Spain" },
+  SE: { countryCode: "SE", countryName: "Sweden" },
+  GB: { countryCode: "GB", countryName: "United Kingdom" },
+  NO: { countryCode: "NO", countryName: "Norway" },
+  IS: { countryCode: "IS", countryName: "Iceland" },
+  LI: { countryCode: "LI", countryName: "Liechtenstein" },
+  CH: { countryCode: "CH", countryName: "Switzerland" },
+  AL: { countryCode: "AL", countryName: "Albania" },
+  BA: { countryCode: "BA", countryName: "Bosnia and Herzegovina" },
+  BY: { countryCode: "BY", countryName: "Belarus" },
+  MK: { countryCode: "MK", countryName: "North Macedonia" },
+  RS: { countryCode: "RS", countryName: "Serbia" },
+  SM: { countryCode: "SM", countryName: "San Marino" },
+  TR: { countryCode: "TR", countryName: "Turkey" },
+  UA: { countryCode: "UA", countryName: "Ukraine" },
+  RU: { countryCode: "RU", countryName: "Russia" },
+  UZ: { countryCode: "UZ", countryName: "Uzbekistan" },
+  AU: { countryCode: "AU", countryName: "Australia" },
+  CN: { countryCode: "CN", countryName: "China" },
+  HK: { countryCode: "HK", countryName: "Hong Kong" },
+  IN: { countryCode: "IN", countryName: "India" },
+  ID: { countryCode: "ID", countryName: "Indonesia" },
+  IL: { countryCode: "IL", countryName: "Israel" },
+  JP: { countryCode: "JP", countryName: "Japan" },
+  KZ: { countryCode: "KZ", countryName: "Kazakhstan" },
+  NZ: { countryCode: "NZ", countryName: "New Zealand" },
+  PH: { countryCode: "PH", countryName: "Philippines" },
+  SA: { countryCode: "SA", countryName: "Saudi Arabia" },
+  SG: { countryCode: "SG", countryName: "Singapore" },
+  TW: { countryCode: "TW", countryName: "Taiwan" },
+  AR: { countryCode: "AR", countryName: "Argentina" },
+  BZ: { countryCode: "BZ", countryName: "Belize" },
+  BO: { countryCode: "BO", countryName: "Bolivia" },
+  BR: { countryCode: "BR", countryName: "Brazil" },
+  CA: { countryCode: "CA", countryName: "Canada" },
+  CL: { countryCode: "CL", countryName: "Chile" },
+  CO: { countryCode: "CO", countryName: "Colombia" },
+  CR: { countryCode: "CR", countryName: "Costa Rica" },
+  DO: { countryCode: "DO", countryName: "Dominican Republic" },
+  EC: { countryCode: "EC", countryName: "Ecuador" },
+  SV: { countryCode: "SV", countryName: "El Salvador" },
+  GT: { countryCode: "GT", countryName: "Guatemala" },
+  HN: { countryCode: "HN", countryName: "Honduras" },
+  MX: { countryCode: "MX", countryName: "Mexico" },
+  NI: { countryCode: "NI", countryName: "Nicaragua" },
+  PA: { countryCode: "PA", countryName: "Panama" },
+  PY: { countryCode: "PY", countryName: "Paraguay" },
+  PE: { countryCode: "PE", countryName: "Peru" },
+  UY: { countryCode: "UY", countryName: "Uruguay" },
+  US: { countryCode: "US", countryName: "United States" },
+  VE: { countryCode: "VE", countryName: "Venezuela" },
+  NG: { countryCode: "NG", countryName: "Nigeria" }
+});
+var EuVatNumber = class _EuVatNumber {
+  static typeInfo = Object.freeze({
+    englishName: "VAT Number",
+    localizedName: "Momsnummer",
+    emoji: "\u{1F4B0}",
+    sources: Object.freeze([
+      "https://ec.europa.eu/taxation_customs/vies/#/vat-validation",
+      "https://en.wikipedia.org/wiki/VAT_identification_number"
+    ])
+  });
+  vatPrefix;
+  countryCode;
+  countryName;
+  body;
+  constructor(vatPrefix, countryCode, countryName, body) {
+    this.vatPrefix = vatPrefix;
+    this.countryCode = countryCode;
+    this.countryName = countryName;
+    this.body = body;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const cleaned = cleanSeparators(sanitizeInput(input));
+    if (cleaned.length > MAX_INPUT_LENGTH6 || cleaned.length < 3) return null;
+    const cc = cleaned.slice(0, 2).toUpperCase();
+    if (!/^[A-Z]{2}$/.test(cc)) return null;
+    const info = COUNTRY_INFO[cc];
+    if (!info) return null;
+    const body = cleaned.slice(2).split("").map((c) => {
+      if (!/[A-Za-z0-9]/.test(c)) return null;
+      return c.toUpperCase();
+    });
+    if (body.some((c) => c === null)) return null;
+    const bodyString = body.join("");
+    if (bodyString.length === 0) return null;
+    if (!validateCountryFormat(info.countryCode, bodyString)) return null;
+    return new _EuVatNumber(cc, info.countryCode, info.countryName, bodyString);
+  }
+  static parse(input) {
+    const r = _EuVatNumber.tryParse(input);
+    if (r === null) throw new Error("Invalid VAT number.");
+    return r;
+  }
+  static isValid(input) {
+    return _EuVatNumber.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _EuVatNumber.tryParse(input);
+    if (r) return r.vatPrefix + r.body;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _EuVatNumber.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _EuVatNumber.normalize(input) === input;
+  }
+  static tryParseForCountry(input, countryCode) {
+    if (countryCode == null || countryCode.trim() === "") return null;
+    const vat = _EuVatNumber.tryParse(input);
+    if (!vat) return null;
+    const normalized = countryCode.toUpperCase();
+    if ((normalized === "EL" || normalized === "GR") && vat.countryCode === "GR") return vat;
+    return vat.countryCode === normalized ? vat : null;
+  }
+  static parseForCountry(input, countryCode) {
+    const r = _EuVatNumber.tryParseForCountry(input, countryCode);
+    if (!r) throw new Error(`Invalid VAT number for country ${countryCode}.`);
+    return r;
+  }
+  static validate(input) {
+    if (input == null || input.trim() === "") {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputIsEmpty,
+        "Input is empty or whitespace.",
+        "V\xE4rdet \xE4r tomt."
+      );
+    }
+    const cleaned = cleanSeparators(sanitizeInput(input));
+    if (cleaned.length > MAX_INPUT_LENGTH6) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputTooLong,
+        "Input contains too many characters.",
+        "V\xE4rdet inneh\xE5ller f\xF6r m\xE5nga tecken."
+      );
+    }
+    if (cleaned.length < 3) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InputTooShort,
+        "VAT number is too short.",
+        "Momsnumret \xE4r f\xF6r kort."
+      );
+    }
+    const cc = cleaned.slice(0, 2).toUpperCase();
+    if (!/^[A-Z]{2}$/.test(cc)) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidCountryPrefix,
+        "VAT number must start with a two-letter country code.",
+        "Momsnumret m\xE5ste b\xF6rja med en tv\xE5bokstavig landskod."
+      );
+    }
+    const info = COUNTRY_INFO[cc];
+    if (!info) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.UnknownCountryCode,
+        "Unknown VAT country code.",
+        "Ok\xE4nd momsnummer-landskod."
+      );
+    }
+    let body = "";
+    for (const c of cleaned.slice(2)) {
+      if (!/[A-Za-z0-9]/.test(c)) {
+        return invalidResult(
+          input,
+          ValidationErrorReason.InvalidFormat,
+          "VAT number body contains invalid characters.",
+          "Momsnumrets inneh\xE5ll har ogiltiga tecken."
+        );
+      }
+      body += c.toUpperCase();
+    }
+    if (body.length === 0 || !validateCountryFormat(info.countryCode, body)) {
+      return invalidResult(
+        input,
+        ValidationErrorReason.InvalidFormat,
+        "VAT number format is invalid for the specified country.",
+        "Momsnummerformatet \xE4r ogiltigt f\xF6r det angivna landet."
+      );
+    }
+    return validResult(input);
+  }
+  toNormalizedString() {
+    return this.vatPrefix + this.body;
+  }
+  toString() {
+    return this.vatPrefix + this.body;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const results = [];
+    const re = /(?<![A-Z0-9])[A-Z]{2}[A-Z0-9]{5,14}(?![A-Z0-9])/gu;
+    let match;
+    while ((match = re.exec(text)) !== null) {
+      const vat = _EuVatNumber.tryParse(match[0]);
+      if (!vat) continue;
+      results.push(
+        new TextCandidate({
+          startIndex: match.index,
+          length: match[0].length,
+          originalText: match[0],
+          typeName: "EuVatNumber",
+          category: TextCandidateCategory.OrganizationIdentifier,
+          normalizedForm: vat.toNormalizedString(),
+          formattedForm: vat.toString(),
+          maskedForm: maskEuVatNumber(vat),
+          confidence: TextMatchConfidence.High,
+          value: vat
+        })
+      );
+    }
+    return results;
+  }
+  equals(other) {
+    return other != null && this.vatPrefix === other.vatPrefix && this.body === other.body;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    const a = this.toNormalizedString();
+    const b = other.toNormalizedString();
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+};
+function validateCountryFormat(countryCode, body) {
+  switch (countryCode.toUpperCase()) {
+    case "AT":
+      return body.length === 9 && body[0] === "U" && /^\d{8}$/.test(body.slice(1));
+    case "BE":
+      return validateBelgianVat(body);
+    case "BG":
+      return /^\d{9,10}$/.test(body);
+    case "HR":
+      return /^\d{11}$/.test(body) && validateMod1110(body);
+    case "CY":
+      return /^\d{8}[A-Z]$/.test(body);
+    case "CZ":
+      return /^\d{8,10}$/.test(body);
+    case "DK":
+      return /^\d{8}$/.test(body);
+    case "EE":
+      return /^\d{9}$/.test(body);
+    case "FI":
+      return validateFinnishVat(body);
+    case "FR":
+      return /^[A-Z0-9]{2}\d{9}$/.test(body);
+    case "DE":
+    case "GR":
+      return /^\d{9}$/.test(body);
+    case "HU":
+      return /^\d{8}$/.test(body);
+    case "IE":
+      return validateIrishVat(body);
+    case "IT":
+      return /^\d{11}$/.test(body) && luhnIsValid(body);
+    case "LV":
+      return /^\d{11}$/.test(body);
+    case "LT":
+      return /^\d{9}$/.test(body) || /^\d{12}$/.test(body);
+    case "LU":
+    case "MT":
+      return /^\d{8}$/.test(body);
+    case "NL":
+      return /^\d{9}B\d{2}$/.test(body);
+    case "PL":
+      return validatePolishVat(body);
+    case "PT":
+      return /^\d{9}$/.test(body);
+    case "RO":
+      return /^\d{2,10}$/.test(body);
+    case "SK":
+      return validateSlovakVat(body);
+    case "SI":
+      return /^\d{8}$/.test(body);
+    case "ES":
+      return body.length === 9;
+    case "SE":
+      return validateSwedishVat(body);
+    case "GB":
+      return validateUkVat(body);
+    case "NO":
+      return validateNorwegianVat(body);
+    case "CH":
+      return keepDigits(body).length === 9;
+    default:
+      return /\d/.test(body);
+  }
+}
+function validateSwedishVat(body) {
+  const digits = keepDigits(body);
+  if (digits.length !== 12 || !digits.endsWith("01")) return false;
+  return SwedishOrganizationNumber.tryParse(digits.slice(0, 10)) !== null;
+}
+function validateBelgianVat(body) {
+  const digits = keepDigits(body);
+  if (digits.length !== 10) return false;
+  const baseNumber = parseInt(digits.slice(0, 8), 10);
+  const checkDigits = 97 - baseNumber % 97;
+  return checkDigits === parseInt(digits.slice(8, 10), 10);
+}
+function validateFinnishVat(body) {
+  const digits = keepDigits(body);
+  if (digits.length !== 8) return false;
+  const weights = [7, 9, 10, 5, 8, 4, 2];
+  const sum = weights.reduce((acc, weight, i) => acc + (digits.charCodeAt(i) - 48) * weight, 0);
+  const remainder = sum % 11;
+  if (remainder === 1) return false;
+  const checkDigit = remainder === 0 ? 0 : 11 - remainder;
+  return checkDigit === digits.charCodeAt(7) - 48;
+}
+function validateIrishVat(body) {
+  if (body.length < 8 || body.length > 9) return false;
+  if (body.length === 8) return /^\d{7}[A-Z]$/.test(body);
+  return /^\d{7}[A-Z]{2}$/.test(body) || /^\d[A-Z]\d{5}[A-Z]$/.test(body);
+}
+function validatePolishVat(body) {
+  const digits = keepDigits(body);
+  if (digits.length !== 10) return false;
+  const weights = [6, 5, 7, 2, 3, 4, 5, 6, 7];
+  const sum = weights.reduce((acc, weight, i) => acc + (digits.charCodeAt(i) - 48) * weight, 0);
+  const checkDigit = sum % 11;
+  if (checkDigit === 10) return false;
+  return checkDigit === digits.charCodeAt(9) - 48;
+}
+function validateSlovakVat(body) {
+  const digits = keepDigits(body);
+  if (digits.length !== 10) return false;
+  return parseInt(digits, 10) % 11 === 0;
+}
+function validateUkVat(body) {
+  const digits = keepDigits(body);
+  if (body.startsWith("GD") || body.startsWith("HA")) return body.length >= 5;
+  return digits.length === 9 || digits.length === 12;
+}
+function validateNorwegianVat(body) {
+  const digits = keepDigits(body);
+  if (digits.length !== 9) return false;
+  const weights = [3, 2, 7, 6, 5, 4, 3, 2];
+  const sum = weights.reduce((acc, weight, i) => acc + (digits.charCodeAt(i) - 48) * weight, 0);
+  const remainder = 11 - sum % 11;
+  if (remainder === 10) return false;
+  const checkDigit = remainder === 11 ? 0 : remainder;
+  return checkDigit === digits.charCodeAt(8) - 48;
+}
+function validateMod1110(digits) {
+  let checksum = 10;
+  for (let i = 0; i < digits.length - 1; i++) {
+    const digit = digits.charCodeAt(i) - 48;
+    checksum = (checksum + digit) % 10;
+    if (checksum === 0) checksum = 10;
+    checksum = checksum * 2 % 11;
+  }
+  const expectedCheck = (11 - checksum) % 10;
+  const actualCheck = digits.charCodeAt(digits.length - 1) - 48;
+  return expectedCheck === actualCheck;
+}
+function maskEuVatNumber(vat, alwaysMask = false) {
+  if (vat.countryCode === "SE") {
+    const body = vat.body;
+    if (body.length >= 10) {
+      const orgPart = body.slice(0, 10);
+      const org = SwedishOrganizationNumber.tryParse(orgPart);
+      if (org && (org.isPerson || alwaysMask)) {
+        const suffix = body.length > 10 ? body.slice(10) : "";
+        return `${vat.vatPrefix}${orgPart.slice(0, 6)}****${suffix}`;
+      }
+    }
+  } else if (alwaysMask) {
+    const visible = Math.min(4, vat.body.length);
+    return `${vat.vatPrefix}${vat.body.slice(0, visible)}${"*".repeat(vat.body.length - visible)}`;
+  }
+  return vat.toString();
+}
+
+// src/organization/lei-code.ts
+var MAX_INPUT_LENGTH7 = 30;
+var LeiCode = class _LeiCode {
+  static typeInfo = Object.freeze({
+    englishName: "LEI Code",
+    localizedName: "LEI-kod",
+    emoji: "\u{1F3DB}\uFE0F",
+    sources: Object.freeze([
+      "https://www.gleif.org/en/about-lei/iso-17442-the-lei-code-structure/",
+      "https://en.wikipedia.org/wiki/Legal_Entity_Identifier"
+    ])
+  });
+  value;
+  get louPrefix() {
+    return this.value.slice(0, 4);
+  }
+  get reserved() {
+    return this.value.slice(4, 6);
+  }
+  get entitySpecific() {
+    return this.value.slice(6, 18);
+  }
+  get checkDigits() {
+    return this.value.slice(18, 20);
+  }
+  constructor(value) {
+    this.value = value;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const source = sanitizeInput(input);
+    let cleaned = "";
+    for (const c of source) {
+      if (/[A-Za-z0-9]/.test(c)) cleaned += c.toUpperCase();
+    }
+    if (cleaned.length > MAX_INPUT_LENGTH7 || cleaned.length !== 20) return null;
+    if (!isValidIso7064Mod97(cleaned)) return null;
+    return new _LeiCode(cleaned);
+  }
+  static parse(input) {
+    const r = _LeiCode.tryParse(input);
+    if (r === null) throw new Error("Invalid LEI code (length or checksum invalid).");
+    return r;
+  }
+  static isValid(input) {
+    return _LeiCode.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _LeiCode.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _LeiCode.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _LeiCode.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const re = /(?<![A-Z0-9])[A-Z0-9]{18}\d{2}(?![A-Z0-9])/gu;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const r = _LeiCode.tryParse(m[0]);
+      if (!r) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "LeiCode",
+          category: TextCandidateCategory.OrganizationIdentifier,
+          normalizedForm: r.toNormalizedString(),
+          formattedForm: r.toString(),
+          maskedForm: maskLeiCode(r),
+          confidence: TextMatchConfidence.High,
+          value: r
+        })
+      );
+    }
+    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 maskLeiCode(l) {
+  const v = l.value;
+  return v.slice(0, 4) + "*".repeat(v.length - 4);
+}
+
+// src/organization/organization-extensions.ts
+function toSwedishOrganizationNumber(value) {
+  if (value instanceof SwedishPersonalIdentityNumber || value instanceof SwedishCoordinationNumber) {
+    return SwedishOrganizationNumber.parse(value.to12DigitString());
+  }
+  if (value.countryCode !== "SE") return null;
+  const digits = keepDigits(value.body);
+  if (digits.length !== 12 || !digits.endsWith("01")) return null;
+  return SwedishOrganizationNumber.tryParse(digits.slice(0, 10));
+}
+function toPersonalIdentityNumber(value) {
+  const org = value instanceof EuVatNumber ? toSwedishOrganizationNumber(value) : value;
+  if (!org?.isPerson) return null;
+  return SwedishPersonalIdentityNumber.tryParse(org.to12DigitString());
+}
+function toCoordinationNumber(value) {
+  const org = value instanceof EuVatNumber ? toSwedishOrganizationNumber(value) : value;
+  if (!org?.isPerson) return null;
+  return SwedishCoordinationNumber.tryParse(org.to12DigitString());
+}
+function toEuVatNumber(value) {
+  const digits = value instanceof SwedishOrganizationNumber ? value.to10DigitsOnly() : keepDigits(value.to10DigitString());
+  return EuVatNumber.parse(`SE${digits}01`);
+}
+function getBolagsverketUrl(org) {
+  return new URL(
+    `https://foretagsinfo.bolagsverket.se/sok-foretagsinformation-web/foretag/${org.to10DigitString()}`
+  );
+}
+function getAllabolagUrl(org) {
+  return `https://www.allabolag.se/${org.toNormalizedString()}`;
+}
+function getAllabolagExternalUrl(org) {
+  return new URL(`https://www.allabolag.se/${org.to10DigitsOnly()}`);
+}
+function toViesUrl(vat) {
+  return `https://ec.europa.eu/taxation_customs/vies/#/vat-validation/${vat.toNormalizedString()}`;
+}
+function getGleifUrl(lei) {
+  return new URL(`https://search.gleif.org/#/record/${lei.toNormalizedString()}`);
+}
+function toGleifUrl(lei) {
+  return `https://search.gleif.org/#/record/${lei.toNormalizedString()}`;
+}
+
+// src/organization/swedish-organization-identifier.ts
+var MAX_INPUT_LENGTH8 = 30;
+function unknownResult() {
+  return {
+    type: 0 /* Unknown */,
+    organizationTypeHintCertain: 0 /* Unknown */,
+    organizationTypeHintBestGuess: 0 /* Unknown */,
+    normalizedValue: "",
+    swedishOrganizationNumber: null,
+    euVatNumber: null,
+    dunsNumber: null,
+    leiCode: null
+  };
+}
+var SwedishOrganizationIdentifierParser = class _SwedishOrganizationIdentifierParser {
+  static tryParse(input, options) {
+    if (input == null || input.trim() === "") return null;
+    const sanitized = sanitizeInput(input).trim();
+    if (sanitized.length > MAX_INPUT_LENGTH8) return null;
+    {
+      const se = tryParseSwedishOrg(sanitized, options);
+      if (se) return se;
+      const vat = tryParseVat(sanitized, options);
+      if (vat) return vat;
+    }
+    const duns = DunsNumber.tryParse(sanitized);
+    if (duns) {
+      return {
+        ...unknownResult(),
+        type: 20 /* DunsNumber */,
+        normalizedValue: duns.digits,
+        dunsNumber: duns
+      };
+    }
+    const lei = LeiCode.tryParse(sanitized);
+    if (lei) {
+      return {
+        ...unknownResult(),
+        type: 30 /* LeiCode */,
+        normalizedValue: lei.value,
+        leiCode: lei
+      };
+    }
+    return null;
+  }
+  static parse(input, options) {
+    const r = _SwedishOrganizationIdentifierParser.tryParse(input, options);
+    if (!r) throw new Error("Could not parse input as a known organization/identity number.");
+    return r;
+  }
+  static tryParseForCountry(input, countryCode, options) {
+    if (input == null || input.trim() === "" || countryCode == null || countryCode.trim() === "") {
+      return null;
+    }
+    const normalizedCountryCode = countryCode.toUpperCase();
+    if (normalizedCountryCode === "SE") {
+      const seOrg = SwedishOrganizationNumber.tryParse(input);
+      if (seOrg) return buildSwedishOrgResult(seOrg, options);
+    }
+    const vat = EuVatNumber.tryParseForCountry(input, normalizedCountryCode);
+    if (vat) return buildVatResult(vat, options);
+    return null;
+  }
+  static parseForCountry(input, countryCode, options) {
+    const r = _SwedishOrganizationIdentifierParser.tryParseForCountry(input, countryCode, options);
+    if (!r) {
+      throw new Error(
+        `Could not parse input as a known organization/identity number for country ${countryCode}.`
+      );
+    }
+    return r;
+  }
+};
+function tryParseSwedishOrg(input, options) {
+  const seOrg = SwedishOrganizationNumber.tryParse(input);
+  if (!seOrg) return null;
+  return buildSwedishOrgResult(seOrg, options);
+}
+function buildSwedishOrgResult(seOrg, options) {
+  let type = 1 /* SwedishOrganizationNumber */;
+  if (seOrg.isPerson) {
+    const twelve = seOrg.to12DigitString();
+    if (SwedishPersonalIdentityNumber.tryParse(twelve)) {
+      type = 2 /* SwedishPersonalIdentityNumber */;
+    } else if (SwedishCoordinationNumber.tryParse(twelve)) {
+      type = 3 /* SwedishCoordinationNumber */;
+    }
+  }
+  const hint = seOrg.getSwedishOrganizationTypeHint(
+    options?.organizationName ?? null,
+    options?.isPrivatePerson ?? null
+  );
+  return {
+    ...unknownResult(),
+    type,
+    organizationTypeHintCertain: hint.certain,
+    organizationTypeHintBestGuess: hint.bestGuess,
+    normalizedValue: seOrg.to12DigitString(),
+    swedishOrganizationNumber: seOrg
+  };
+}
+function tryParseVat(input, options) {
+  const vat = EuVatNumber.tryParse(input);
+  if (!vat) return null;
+  return buildVatResult(vat, options);
+}
+function buildVatResult(vat, options) {
+  let certain = 0 /* Unknown */;
+  let bestGuess = 0 /* Unknown */;
+  const seOrg = toSwedishOrganizationNumber(vat);
+  if (seOrg) {
+    const hint = seOrg.getSwedishOrganizationTypeHint(
+      options?.organizationName ?? null,
+      options?.isPrivatePerson ?? null
+    );
+    certain = hint.certain;
+    bestGuess = hint.bestGuess;
+  }
+  return {
+    ...unknownResult(),
+    type: 10 /* EuVatNumber */,
+    organizationTypeHintCertain: certain,
+    organizationTypeHintBestGuess: bestGuess,
+    normalizedValue: vat.countryCode + vat.body,
+    euVatNumber: vat
+  };
+}
+
+// src/organization/eu-organization-name.ts
+var MAX_INPUT_LENGTH9 = 300;
+var COMPANY_NAME_PATTERN2 = /^[\p{L}\d\s\-'&.,/:()+|"]+$/u;
+var PIPE_SEPARATOR = /\s*\|+\s*/;
+var EuOrganizationName = class _EuOrganizationName {
+  static typeInfo = Object.freeze({
+    englishName: "EU Organization Name",
+    localizedName: "Europeiskt organisationsnamn",
+    emoji: "\u{1F1EA}\u{1F1FA}",
+    sources: Object.freeze([
+      "https://ec.europa.eu/taxation_customs/vies/",
+      "https://www.businessregisters.eu/"
+    ])
+  });
+  value;
+  legalName;
+  tradeName;
+  get hasTradeName() {
+    return this.tradeName !== null;
+  }
+  constructor(value, legal, trade) {
+    this.value = value;
+    this.legalName = legal;
+    this.tradeName = trade;
+  }
+  static tryParse(input) {
+    const normalized = collapseWhitespace(input);
+    if (normalized.length === 0 || normalized.length > MAX_INPUT_LENGTH9) return null;
+    if (!validate(normalized)) return null;
+    const [legal, trade] = splitLegalAndTrade(normalized);
+    return new _EuOrganizationName(normalized, legal, trade);
+  }
+  static parse(input) {
+    const r = _EuOrganizationName.tryParse(input);
+    if (r === null) throw new Error("Invalid EU organization name.");
+    return r;
+  }
+  static isValid(input) {
+    return _EuOrganizationName.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _EuOrganizationName.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _EuOrganizationName.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _EuOrganizationName.normalize(input) === input;
+  }
+  static trySplitLegalAndTrade(input) {
+    if (input == null || input.trim() === "") return null;
+    const collapsed = collapseWhitespace(input);
+    const [legal, trade] = splitLegalAndTrade(collapsed);
+    return { legalName: legal, tradeName: trade };
+  }
+  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;
+  }
+};
+function maskEuOrganizationName(value) {
+  return value.value.replace(/[\p{L}\d]+/gu, (part) => {
+    if (part.length <= 1) return part;
+    return part[0] + "*".repeat(part.length - 1);
+  });
+}
+function splitLegalAndTrade(collapsed) {
+  if (collapsed.indexOf("|") < 0) return [collapsed, null];
+  const parts = collapsed.split(PIPE_SEPARATOR).filter((p) => p.length > 0);
+  if (parts.length < 2) return [collapsed, null];
+  return [parts[0], parts.slice(1).join(" | ")];
+}
+function validate(value) {
+  if (value.length < 2 || value.length > 200) return false;
+  for (const c of value) {
+    const code = c.charCodeAt(0);
+    if (code < 32 || code === 127) return false;
+  }
+  return COMPANY_NAME_PATTERN2.test(value);
+}
+
+// src/organization/elf-code.ts
+var CODE_LENGTH = 4;
+var MAX_INPUT_LENGTH10 = 20;
+var KNOWN_CODES = /* @__PURE__ */ new Map([
+  ["XTIQ", { englishName: "Limited company", swedishName: "Aktiebolag" }],
+  ["N2GY", { englishName: "General partnership", swedishName: "Handelsbolag" }],
+  ["FR3V", { englishName: "Limited partnership", swedishName: "Kommanditbolag" }],
+  ["V2YH", { englishName: "Economic association", swedishName: "Ekonomisk f\xF6rening" }],
+  ["WJEL", { englishName: "Sole proprietorship", swedishName: "Enskild n\xE4ringsidkare" }],
+  ["CLBQ", { englishName: "Foundation", swedishName: "Stiftelse" }],
+  ["F85L", { englishName: "Non-profit association", swedishName: "Ideell f\xF6rening" }],
+  ["O9FH", { englishName: "Housing cooperative", swedishName: "Bostadsr\xE4ttsf\xF6rening" }],
+  [
+    "H0PO",
+    {
+      englishName: "Cooperative housing association",
+      swedishName: "Kooperativ hyresr\xE4ttsf\xF6rening"
+    }
+  ],
+  ["2HBR", { englishName: "Government entity", swedishName: "Statlig enhet" }],
+  ["EVKQ", { englishName: "Municipality", swedishName: "Kommun" }],
+  ["R7GX", { englishName: "Region", swedishName: "Region" }],
+  ["KQM9", { englishName: "Banking company", swedishName: "Bankaktiebolag" }],
+  ["L5CF", { englishName: "Insurance company", swedishName: "F\xF6rs\xE4kringsaktiebolag" }],
+  ["LRQE", { englishName: "Mutual insurance company", swedishName: "\xD6msesidigt f\xF6rs\xE4kringsbolag" }],
+  [
+    "J4GF",
+    { englishName: "Branch of foreign company", swedishName: "Filial till utl\xE4ndskt f\xF6retag" }
+  ],
+  ["9GQP", { englishName: "European company (SE)", swedishName: "Europabolag" }]
+]);
+var ElfCode = class _ElfCode {
+  static typeInfo = Object.freeze({
+    englishName: "Entity Legal Form Code",
+    localizedName: "Juridisk f\xF6retagsform",
+    emoji: "\u{1F4CB}",
+    sources: Object.freeze([
+      "https://www.gleif.org/en/about-lei/code-lists/iso-20275-entity-legal-forms-code-list",
+      "https://www.iso.org/standard/67462.html"
+    ])
+  });
+  code;
+  englishName;
+  localizedName;
+  get displayName() {
+    const localized = PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedName : this.englishName;
+    return localized ?? this.code;
+  }
+  get isKnown() {
+    return this.englishName !== null;
+  }
+  constructor(code, en, sv) {
+    this.code = code;
+    this.englishName = en;
+    this.localizedName = sv;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const cleaned = keepAsciiAlphanumericUppercase(input);
+    if (cleaned.length > MAX_INPUT_LENGTH10 || cleaned.length !== CODE_LENGTH) return null;
+    const known = KNOWN_CODES.get(cleaned);
+    return new _ElfCode(cleaned, known?.englishName ?? null, known?.swedishName ?? null);
+  }
+  static parse(input) {
+    const r = _ElfCode.tryParse(input);
+    if (r === null) {
+      throw new Error("Invalid ELF code (must be exactly 4 alphanumeric characters).");
+    }
+    return r;
+  }
+  static isValid(input) {
+    return _ElfCode.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _ElfCode.tryParse(input);
+    if (r) return r.displayName;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _ElfCode.tryParse(input);
+    if (r) return r.code;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null) {
+      const t = input.trim();
+      return t.length > 0 ? t : null;
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _ElfCode.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.code;
+  }
+  toString() {
+    return this.displayName;
+  }
+  equals(other) {
+    return other != null && this.code === other.code;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.code < other.code ? -1 : this.code > other.code ? 1 : 0;
+  }
+};
+
+// src/organization/swedish-cfar-number.ts
+var MAX_INPUT_LENGTH11 = 20;
+var SwedishCfarNumber = class _SwedishCfarNumber {
+  static typeInfo = Object.freeze({
+    englishName: "CFAR Number",
+    localizedName: "CFAR-nummer",
+    emoji: "\u{1F3ED}",
+    sources: Object.freeze([
+      "https://www.cfarnrsok.scb.se/",
+      "https://www.scb.se/vara-tjanster/bestall-data-och-statistik/foretagsregistret/variabelbeskrivning/"
+    ])
+  });
+  number;
+  constructor(n) {
+    this.number = n;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const digits = keepDigits(sanitizeInput(input));
+    if (digits.length > MAX_INPUT_LENGTH11) return null;
+    if (digits.length !== 8) return null;
+    if (digits === "00000000") return null;
+    return new _SwedishCfarNumber(digits);
+  }
+  static parse(input) {
+    const r = _SwedishCfarNumber.tryParse(input);
+    if (r === null) throw new Error("Invalid CFAR number.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishCfarNumber.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishCfarNumber.tryParse(input);
+    if (r) return r.number;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _SwedishCfarNumber.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishCfarNumber.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.number;
+  }
+  toString() {
+    return this.number;
+  }
+  equals(other) {
+    return other != null && this.number === other.number;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.number < other.number ? -1 : this.number > other.number ? 1 : 0;
+  }
+};
+function maskSwedishCfarNumber(c) {
+  return c.number.slice(0, 4) + "****";
+}
+
+// src/organization/swedish-sni-code.ts
+var MAX_INPUT_LENGTH12 = 20;
+var SwedishSniCode = class _SwedishSniCode {
+  static typeInfo = Object.freeze({
+    englishName: "SNI Code",
+    localizedName: "SNI-kod",
+    emoji: "\u{1F4CA}",
+    sources: Object.freeze([
+      "https://www.scb.se/en/documentation/classifications-and-standards/swedish-standard-industrial-classification-sni/",
+      "https://snisok.scb.se/en"
+    ])
+  });
+  code;
+  formatted;
+  get divisionCode() {
+    return this.code.slice(0, 2);
+  }
+  get groupCode() {
+    return this.code.slice(0, 3);
+  }
+  get subGroupCode() {
+    return this.code.slice(0, 4);
+  }
+  constructor(code, formatted) {
+    this.code = code;
+    this.formatted = formatted;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const digits = keepDigits(input);
+    if (digits.length > MAX_INPUT_LENGTH12) return null;
+    if (digits.length !== 5) return null;
+    if (digits === "00000") return null;
+    if (digits.slice(0, 2) === "00") return null;
+    return new _SwedishSniCode(digits, `${digits.slice(0, 2)}.${digits.slice(2)}`);
+  }
+  static parse(input) {
+    const r = _SwedishSniCode.tryParse(input);
+    if (r === null) throw new Error("Invalid SNI code.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishSniCode.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishSniCode.tryParse(input);
+    if (r) return r.formatted;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _SwedishSniCode.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishSniCode.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.formatted;
+  }
+  toString() {
+    return this.formatted;
+  }
+  equals(other) {
+    return other != null && this.formatted === other.formatted;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.formatted < other.formatted ? -1 : this.formatted > other.formatted ? 1 : 0;
+  }
+};
+
+exports.DunsNumber = DunsNumber;
+exports.ElfCode = ElfCode;
+exports.EuOrganizationName = EuOrganizationName;
+exports.EuVatNumber = EuVatNumber;
+exports.LeiCode = LeiCode;
+exports.SwedishCfarNumber = SwedishCfarNumber;
+exports.SwedishOrganizationIdentifierParser = SwedishOrganizationIdentifierParser;
+exports.SwedishOrganizationIdentifierType = SwedishOrganizationIdentifierType;
+exports.SwedishOrganizationName = SwedishOrganizationName;
+exports.SwedishOrganizationNumber = SwedishOrganizationNumber;
+exports.SwedishOrganizationType = SwedishOrganizationType;
+exports.SwedishSniCode = SwedishSniCode;
+exports.getAllabolagExternalUrl = getAllabolagExternalUrl;
+exports.getAllabolagUrl = getAllabolagUrl;
+exports.getBolagsverketUrl = getBolagsverketUrl;
+exports.getGleifUrl = getGleifUrl;
+exports.maskDunsNumber = maskDunsNumber;
+exports.maskEuOrganizationName = maskEuOrganizationName;
+exports.maskEuVatNumber = maskEuVatNumber;
+exports.maskLeiCode = maskLeiCode;
+exports.maskSwedishCfarNumber = maskSwedishCfarNumber;
+exports.maskSwedishOrganizationName = maskSwedishOrganizationName;
+exports.maskSwedishOrganizationNumber = maskSwedishOrganizationNumber;
+exports.toCoordinationNumber = toCoordinationNumber;
+exports.toEuVatNumber = toEuVatNumber;
+exports.toGleifUrl = toGleifUrl;
+exports.toPersonalIdentityNumber = toPersonalIdentityNumber;
+exports.toSwedishOrganizationNumber = toSwedishOrganizationNumber;
+exports.toViesUrl = toViesUrl;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map