@slashlab/numerik-js 1.0.0

package/dist/zod/index.cjs

@@ -0,0 +1,1247 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zod/index.ts
+var zod_exports = {};
+__export(zod_exports, {
+  ibanParseSchema: () => ibanParseSchema,
+  ibanSchema: () => ibanSchema,
+  idCardParseSchema: () => idCardParseSchema,
+  idCardSchema: () => idCardSchema,
+  krsParseSchema: () => krsParseSchema,
+  krsSchema: () => krsSchema,
+  nipParseSchema: () => nipParseSchema,
+  nipSchema: () => nipSchema,
+  nrbParseSchema: () => nrbParseSchema,
+  nrbSchema: () => nrbSchema,
+  passportParseSchema: () => passportParseSchema,
+  passportSchema: () => passportSchema,
+  peselParseSchema: () => peselParseSchema,
+  peselSchema: () => peselSchema,
+  regonParseSchema: () => regonParseSchema,
+  regonSchema: () => regonSchema,
+  vatEuParseSchema: () => vatEuParseSchema,
+  vatEuSchema: () => vatEuSchema
+});
+module.exports = __toCommonJS(zod_exports);
+var import_zod = require("zod");
+
+// src/exceptions/ValidationException.ts
+var ValidationException = class extends Error {
+  constructor(result) {
+    super(result.getFirstFailure()?.message ?? "Validation failed");
+    this.result = result;
+    this.name = "ValidationException";
+  }
+  result;
+};
+
+// src/exceptions/InvalidChecksumException.ts
+var InvalidChecksumException = class extends ValidationException {
+  constructor(result) {
+    super(result);
+    this.name = "InvalidChecksumException";
+  }
+};
+
+// src/exceptions/InvalidDateException.ts
+var InvalidDateException = class extends ValidationException {
+  constructor(result) {
+    super(result);
+    this.name = "InvalidDateException";
+  }
+};
+
+// src/exceptions/InvalidFormatException.ts
+var InvalidFormatException = class extends ValidationException {
+  constructor(result) {
+    super(result);
+    this.name = "InvalidFormatException";
+  }
+};
+
+// src/result/ValidationFailure.ts
+var ValidationFailure = class {
+  constructor(reason, message) {
+    this.reason = reason;
+    this.message = message;
+  }
+  reason;
+  message;
+};
+
+// src/result/ValidationResult.ts
+var ValidationResult = class _ValidationResult {
+  isValid;
+  failures;
+  constructor(isValid, failures = []) {
+    this.isValid = isValid;
+    this.failures = [...failures];
+  }
+  static pass() {
+    return new _ValidationResult(true);
+  }
+  static fail(failures) {
+    return new _ValidationResult(false, failures);
+  }
+  static failWithReason(reason, message) {
+    return new _ValidationResult(false, [new ValidationFailure(reason, message)]);
+  }
+  isFailed() {
+    return !this.isValid;
+  }
+  getFailures() {
+    return this.failures;
+  }
+  getFirstFailure() {
+    return this.failures[0] ?? null;
+  }
+  hasFailureReason(reason) {
+    return this.failures.some((f) => f.reason === reason);
+  }
+  toException() {
+    switch (this.getFirstFailure()?.reason) {
+      case "invalid_checksum" /* InvalidChecksum */:
+        return new InvalidChecksumException(this);
+      case "invalid_date" /* InvalidDate */:
+      case "future_date" /* FutureDate */:
+      case "invalid_month" /* InvalidMonth */:
+        return new InvalidDateException(this);
+      default:
+        return new InvalidFormatException(this);
+    }
+  }
+};
+
+// src/value-objects/Iban.ts
+var Iban = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getFormatted() {
+    return this.normalized.match(/.{1,4}/g)?.join(" ") ?? this.normalized;
+  }
+  getCountryCode() {
+    return "PL";
+  }
+  getNrb() {
+    return this.normalized.slice(2);
+  }
+  getCheckDigits() {
+    return this.normalized.slice(2, 4);
+  }
+  getSortCode() {
+    return this.normalized.slice(4, 12);
+  }
+  getBankCode() {
+    return this.normalized.slice(4, 7);
+  }
+  getAccountNumber() {
+    return this.normalized.slice(12, 28);
+  }
+};
+
+// src/value-objects/Nrb.ts
+var Nrb = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getFormatted() {
+    const rest = this.normalized.slice(2);
+    const grouped = rest.match(/.{1,4}/g)?.join(" ") ?? rest;
+    return `${this.normalized.slice(0, 2)} ${grouped}`;
+  }
+  getIban() {
+    return `PL${this.normalized}`;
+  }
+  getFormattedIban() {
+    const full = `PL${this.normalized}`;
+    return full.match(/.{1,4}/g)?.join(" ") ?? full;
+  }
+  getCheckDigits() {
+    return this.normalized.slice(0, 2);
+  }
+  getSortCode() {
+    return this.normalized.slice(2, 10);
+  }
+  getBankCode() {
+    return this.normalized.slice(2, 5);
+  }
+  getAccountNumber() {
+    return this.normalized.slice(10, 26);
+  }
+};
+
+// src/identifiers/NrbIdentifier.ts
+var DIGITS = 26;
+var MAX_LENGTH = 40;
+var NrbIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 40 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    if (normalized.length !== DIGITS) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "NRB must be exactly 26 digits."
+      );
+    }
+    if (!/^\d+$/.test(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "NRB must contain only digits."
+      );
+    }
+    if (!this.isValidChecksum(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "NRB checksum (MOD-97) does not match."
+      );
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new Nrb(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    const stripped = input.replace(/[ -]/g, "");
+    return stripped.toUpperCase().startsWith("PL") ? stripped.slice(2) : stripped;
+  }
+  isValidChecksum(normalized) {
+    const rearranged = `${normalized.slice(2)}2521${normalized.slice(0, 2)}`;
+    let remainder = 0;
+    for (const ch of rearranged) {
+      remainder = (remainder * 10 + Number(ch)) % 97;
+    }
+    return remainder === 1;
+  }
+};
+
+// src/identifiers/IbanIdentifier.ts
+var MAX_LENGTH2 = 40;
+var NRB_DIGITS = 26;
+var IbanIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+    this.nrb = new NrbIdentifier(strict);
+  }
+  strict;
+  nrb;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH2) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 40 characters."
+      );
+    }
+    const stripped = this.stripSeparators(input);
+    if (stripped.length < 2 || stripped.slice(0, 2).toUpperCase() !== "PL") {
+      return ValidationResult.failWithReason(
+        "invalid_format" /* InvalidFormat */,
+        "IBAN must start with the PL country prefix."
+      );
+    }
+    const nrbPart = stripped.slice(2);
+    if (nrbPart.length !== NRB_DIGITS) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "IBAN must contain exactly 26 digits after the PL prefix."
+      );
+    }
+    return this.nrb.validate(nrbPart);
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new Iban(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  stripSeparators(input) {
+    return input.replace(/[ -]/g, "");
+  }
+  normalize(input) {
+    const stripped = this.stripSeparators(input);
+    return `PL${stripped.slice(2)}`;
+  }
+};
+
+// src/value-objects/IdCard.ts
+var IdCard = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getSeries() {
+    return this.normalized.slice(0, 3);
+  }
+  getSequentialNumber() {
+    return this.normalized.slice(3, 8);
+  }
+  getCheckDigit() {
+    return this.normalized.slice(8, 9);
+  }
+};
+
+// src/identifiers/IdCardIdentifier.ts
+var WEIGHTS = [7, 3, 1, 7, 3, 1, 7, 3];
+var MAX_LENGTH3 = 32;
+var LENGTH = 9;
+var IdCardIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH3) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    if (normalized.length !== LENGTH) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Identity card number must be exactly 9 characters."
+      );
+    }
+    const series = normalized.slice(0, 3);
+    if (!/^[A-Za-z]{3}$/.test(series)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "Identity card series (first 3 characters) must contain only letters."
+      );
+    }
+    if (series.includes("O") || series.includes("Q")) {
+      return ValidationResult.failWithReason(
+        "invalid_format" /* InvalidFormat */,
+        "Identity card series cannot contain the letters O or Q."
+      );
+    }
+    if (!/^\d{6}$/.test(normalized.slice(3))) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "Identity card number portion (characters 4\u20139) must contain only digits."
+      );
+    }
+    if (!this.isValidChecksum(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "Identity card checksum digit does not match."
+      );
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new IdCard(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    return input.replace(/[-\s]/g, "").toUpperCase();
+  }
+  icaoCharValue(char) {
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57 ? code - 48 : code - 55;
+  }
+  isValidChecksum(normalized) {
+    let sum = 0;
+    for (let i = 0; i < 8; i++) {
+      sum += this.icaoCharValue(normalized[i] ?? "") * (WEIGHTS[i] ?? 0);
+    }
+    return sum % 10 === Number(normalized[8]);
+  }
+};
+
+// src/value-objects/Krs.ts
+var Krs = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getFormatted() {
+    return this.normalized.padStart(10, "0");
+  }
+  getNumericValue() {
+    return Number(this.normalized);
+  }
+};
+
+// src/identifiers/KrsIdentifier.ts
+var MAX_LENGTH4 = 32;
+var MAX_DIGITS = 10;
+var KrsIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH4) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    if (normalized.length === 0 || normalized.length > MAX_DIGITS) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "KRS must have between 1 and 10 digits."
+      );
+    }
+    if (!/^\d+$/.test(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "KRS must contain only digits and spaces."
+      );
+    }
+    if (Number(normalized) === 0) {
+      return ValidationResult.failWithReason(
+        "all_zeros" /* AllZeros */,
+        "KRS cannot be all zeros."
+      );
+    }
+    const padded = normalized.padStart(MAX_DIGITS, "0");
+    if (this.strict && new Set(padded).size === 1) {
+      return ValidationResult.failWithReason(
+        "all_same_digit" /* AllSameDigit */,
+        "KRS consists of a single repeated digit."
+      );
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new Krs(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    return input.replace(/ /g, "");
+  }
+};
+
+// src/value-objects/Nip.ts
+var Nip = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getFormatted() {
+    const n = this.normalized;
+    return `${n.slice(0, 3)}-${n.slice(3, 6)}-${n.slice(6, 8)}-${n.slice(8, 10)}`;
+  }
+  getFormattedAlternative() {
+    const n = this.normalized;
+    return `${n.slice(0, 3)}-${n.slice(3, 5)}-${n.slice(5, 7)}-${n.slice(7, 10)}`;
+  }
+  getTaxOfficeCode() {
+    return this.normalized.slice(0, 3);
+  }
+};
+
+// src/identifiers/NipIdentifier.ts
+var WEIGHTS2 = [6, 5, 7, 2, 3, 4, 5, 6, 7];
+var MAX_LENGTH5 = 32;
+var DIGITS2 = 10;
+var NipIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH5) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    if (normalized.length !== DIGITS2) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "NIP must be exactly 10 digits."
+      );
+    }
+    if (!/^\d+$/.test(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "NIP must contain only digits, hyphens, and spaces."
+      );
+    }
+    if (normalized.startsWith("000")) {
+      return ValidationResult.failWithReason(
+        "invalid_format" /* InvalidFormat */,
+        "NIP tax office code cannot be 000."
+      );
+    }
+    const digits = Array.from(normalized).map(Number);
+    const sum = digits.slice(0, 9).reduce((acc, d, i) => acc + d * (WEIGHTS2[i] ?? 0), 0);
+    if (sum % 11 !== (digits[9] ?? -1)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "NIP checksum digit does not match."
+      );
+    }
+    if (this.strict && new Set(digits).size === 1) {
+      return ValidationResult.failWithReason(
+        "all_same_digit" /* AllSameDigit */,
+        "NIP consists of a single repeated digit."
+      );
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new Nip(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    return input.replace(/[-\s]/g, "");
+  }
+};
+
+// src/value-objects/Passport.ts
+var Passport = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getSeries() {
+    return this.normalized.slice(0, 2);
+  }
+  getSequentialNumber() {
+    return this.normalized.slice(2, 8);
+  }
+  getCheckDigit() {
+    return this.normalized.slice(8, 9);
+  }
+};
+
+// src/identifiers/PassportIdentifier.ts
+var WEIGHTS3 = [7, 3, 1, 7, 3, 1, 7, 3];
+var MAX_LENGTH6 = 32;
+var LENGTH2 = 9;
+var PassportIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH6) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    if (normalized.length !== LENGTH2) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Passport number must be exactly 9 characters."
+      );
+    }
+    if (!/^[A-Za-z]{2}/.test(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "Passport series (first 2 characters) must contain only letters."
+      );
+    }
+    if (!/^\d{7}$/.test(normalized.slice(2))) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "Passport number portion (characters 3\u20139) must contain only digits."
+      );
+    }
+    if (!this.isValidChecksum(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "Passport checksum digit does not match."
+      );
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new Passport(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    return input.replace(/[-\s]/g, "").toUpperCase();
+  }
+  icaoCharValue(char) {
+    const code = char.charCodeAt(0);
+    return code >= 48 && code <= 57 ? code - 48 : code - 55;
+  }
+  isValidChecksum(normalized) {
+    let sum = 0;
+    for (let i = 0; i < 8; i++) {
+      sum += this.icaoCharValue(normalized[i] ?? "") * (WEIGHTS3[i] ?? 0);
+    }
+    return sum % 10 === Number(normalized[8]);
+  }
+};
+
+// src/value-objects/Pesel.ts
+var Pesel = class {
+  constructor(raw, normalized, birthDate, gender, ordinalNumber) {
+    this.raw = raw;
+    this.normalized = normalized;
+    this.gender = gender;
+    this.ordinalNumber = ordinalNumber;
+    this.birthDate = new Date(birthDate.getTime());
+  }
+  raw;
+  normalized;
+  gender;
+  ordinalNumber;
+  birthDate;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getBirthDate() {
+    return new Date(this.birthDate);
+  }
+  getGender() {
+    return this.gender;
+  }
+  getOrdinalNumber() {
+    return this.ordinalNumber;
+  }
+  isMale() {
+    return this.gender === "male" /* Male */;
+  }
+  isFemale() {
+    return this.gender === "female" /* Female */;
+  }
+  getAge() {
+    const today = /* @__PURE__ */ new Date();
+    const birth = this.birthDate;
+    let age = today.getFullYear() - birth.getFullYear();
+    const m = today.getMonth() - birth.getMonth();
+    if (m < 0 || m === 0 && today.getDate() < birth.getDate()) {
+      age--;
+    }
+    return age;
+  }
+  isAdult() {
+    return this.getAge() >= 18;
+  }
+  getCentury() {
+    const year = this.birthDate.getFullYear();
+    return year - year % 100;
+  }
+};
+
+// src/identifiers/PeselIdentifier.ts
+var WEIGHTS4 = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3];
+var MAX_LENGTH7 = 32;
+var DIGITS3 = 11;
+var PeselIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH7) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    if (normalized.length !== DIGITS3) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "PESEL must be exactly 11 digits."
+      );
+    }
+    if (!/^\d+$/.test(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "PESEL must contain only digits."
+      );
+    }
+    const digits = Array.from(normalized).map(Number);
+    const encodedMonth = (digits[2] ?? 0) * 10 + (digits[3] ?? 0);
+    const month = this.decodeMonth(encodedMonth);
+    if (month === null) {
+      return ValidationResult.failWithReason(
+        "invalid_month" /* InvalidMonth */,
+        "PESEL contains an invalid month encoding."
+      );
+    }
+    const year = this.decodeYear(
+      (digits[0] ?? 0) * 10 + (digits[1] ?? 0),
+      encodedMonth
+    );
+    const day = (digits[4] ?? 0) * 10 + (digits[5] ?? 0);
+    if (!this.isValidDate(year, month, day)) {
+      return ValidationResult.failWithReason(
+        "invalid_date" /* InvalidDate */,
+        "PESEL contains an invalid date."
+      );
+    }
+    const sum = digits.slice(0, 10).reduce((acc, d, i) => acc + d * (WEIGHTS4[i] ?? 0), 0);
+    if ((10 - sum % 10) % 10 !== (digits[10] ?? -1)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "PESEL checksum digit does not match."
+      );
+    }
+    if (this.strict) {
+      const birthDate = new Date(year, month - 1, day);
+      const today = /* @__PURE__ */ new Date();
+      today.setHours(0, 0, 0, 0);
+      if (birthDate > today) {
+        return ValidationResult.failWithReason(
+          "future_date" /* FutureDate */,
+          "PESEL birth date is in the future."
+        );
+      }
+      if (new Set(digits).size === 1) {
+        return ValidationResult.failWithReason(
+          "all_same_digit" /* AllSameDigit */,
+          "PESEL consists of a single repeated digit."
+        );
+      }
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    const normalized = this.normalize(input);
+    const digits = Array.from(normalized).map(Number);
+    const encodedMonth = (digits[2] ?? 0) * 10 + (digits[3] ?? 0);
+    const month = this.decodeMonth(encodedMonth) ?? 1;
+    const year = this.decodeYear(
+      (digits[0] ?? 0) * 10 + (digits[1] ?? 0),
+      encodedMonth
+    );
+    const day = (digits[4] ?? 0) * 10 + (digits[5] ?? 0);
+    const birthDate = new Date(year, month - 1, day);
+    const gender = (digits[9] ?? 0) % 2 === 1 ? "male" /* Male */ : "female" /* Female */;
+    const ordinalNumber = (digits[6] ?? 0) * 1e3 + (digits[7] ?? 0) * 100 + (digits[8] ?? 0) * 10 + (digits[9] ?? 0);
+    return new Pesel(input, normalized, birthDate, gender, ordinalNumber);
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    return input.replace(/ /g, "");
+  }
+  decodeMonth(encodedMonth) {
+    if (encodedMonth >= 1 && encodedMonth <= 12) return encodedMonth;
+    if (encodedMonth >= 21 && encodedMonth <= 32) return encodedMonth - 20;
+    if (encodedMonth >= 41 && encodedMonth <= 52) return encodedMonth - 40;
+    if (encodedMonth >= 61 && encodedMonth <= 72) return encodedMonth - 60;
+    if (encodedMonth >= 81 && encodedMonth <= 92) return encodedMonth - 80;
+    return null;
+  }
+  decodeYear(yy, encodedMonth) {
+    if (encodedMonth >= 81 && encodedMonth <= 92) return 1800 + yy;
+    if (encodedMonth >= 1 && encodedMonth <= 12) return 1900 + yy;
+    if (encodedMonth >= 21 && encodedMonth <= 32) return 2e3 + yy;
+    if (encodedMonth >= 41 && encodedMonth <= 52) return 2100 + yy;
+    return 2200 + yy;
+  }
+  isValidDate(year, month, day) {
+    const d = new Date(year, month - 1, day);
+    return d.getFullYear() === year && d.getMonth() === month - 1 && d.getDate() === day;
+  }
+};
+
+// src/value-objects/Regon.ts
+var Regon = class {
+  constructor(raw, normalized, type) {
+    this.raw = raw;
+    this.normalized = normalized;
+    this.type = type;
+  }
+  raw;
+  normalized;
+  type;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getType() {
+    return this.type;
+  }
+  getBaseRegon() {
+    return this.normalized.slice(0, 9);
+  }
+  getLocalUnitSuffix() {
+    if (this.type === "individual" /* Individual */) return null;
+    return this.normalized.slice(9, 14);
+  }
+  isLocalUnit() {
+    return this.type === "legal_entity" /* LegalEntity */;
+  }
+};
+
+// src/identifiers/RegonIdentifier.ts
+var WEIGHTS_9 = [8, 9, 2, 3, 4, 5, 6, 7];
+var WEIGHTS_14 = [2, 4, 8, 5, 0, 9, 7, 3, 6, 1, 2, 4, 8];
+var MAX_LENGTH8 = 32;
+var DIGITS_9 = 9;
+var DIGITS_14 = 14;
+var RegonIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+  }
+  strict;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH8) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const normalized = this.normalize(input);
+    const length = normalized.length;
+    if (length !== DIGITS_9 && length !== DIGITS_14) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "REGON must be exactly 9 or 14 digits."
+      );
+    }
+    if (!/^\d+$/.test(normalized)) {
+      return ValidationResult.failWithReason(
+        "invalid_characters" /* InvalidCharacters */,
+        "REGON must contain only digits and spaces."
+      );
+    }
+    const digits = Array.from(normalized).map(Number);
+    if (!this.isValid9DigitChecksum(digits)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "REGON checksum digit does not match."
+      );
+    }
+    if (length === DIGITS_14 && !this.isValid14DigitChecksum(digits)) {
+      return ValidationResult.failWithReason(
+        "invalid_checksum" /* InvalidChecksum */,
+        "REGON local unit checksum digit does not match."
+      );
+    }
+    return ValidationResult.pass();
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    const normalized = this.normalize(input);
+    const type = normalized.length === DIGITS_9 ? "individual" /* Individual */ : "legal_entity" /* LegalEntity */;
+    return new Regon(input, normalized, type);
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  normalize(input) {
+    return input.replace(/ /g, "");
+  }
+  isValid9DigitChecksum(digits) {
+    let sum = 0;
+    for (let i = 0; i < 8; i++) {
+      sum += (digits[i] ?? 0) * (WEIGHTS_9[i] ?? 0);
+    }
+    const checksum = sum % 11;
+    return (checksum === 10 ? 0 : checksum) === (digits[8] ?? -1);
+  }
+  isValid14DigitChecksum(digits) {
+    let sum = 0;
+    for (let i = 0; i < 13; i++) {
+      sum += (digits[i] ?? 0) * (WEIGHTS_14[i] ?? 0);
+    }
+    const checksum = sum % 11;
+    return (checksum === 10 ? 0 : checksum) === (digits[13] ?? -1);
+  }
+};
+
+// src/value-objects/VatEu.ts
+var VatEu = class {
+  constructor(raw, normalized) {
+    this.raw = raw;
+    this.normalized = normalized;
+  }
+  raw;
+  normalized;
+  getRaw() {
+    return this.raw;
+  }
+  getNormalized() {
+    return this.normalized;
+  }
+  toString() {
+    return this.normalized;
+  }
+  getCountryCode() {
+    return "PL";
+  }
+  getNip() {
+    return this.normalized.slice(2);
+  }
+  getFormatted() {
+    const n = this.getNip();
+    return `PL${n.slice(0, 3)}-${n.slice(3, 6)}-${n.slice(6, 8)}-${n.slice(8, 10)}`;
+  }
+};
+
+// src/identifiers/VatEuIdentifier.ts
+var MAX_LENGTH9 = 32;
+var NIP_DIGITS = 10;
+var PREFIX = "PL";
+var VatEuIdentifier = class {
+  constructor(strict = true) {
+    this.strict = strict;
+    this.nip = new NipIdentifier(strict);
+  }
+  strict;
+  nip;
+  isStrict() {
+    return this.strict;
+  }
+  validate(input) {
+    if (input.length > MAX_LENGTH9) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "Input exceeds maximum length of 32 characters."
+      );
+    }
+    const stripped = this.stripSeparators(input);
+    if (stripped.length < 2 || stripped.slice(0, 2).toUpperCase() !== PREFIX) {
+      return ValidationResult.failWithReason(
+        "invalid_format" /* InvalidFormat */,
+        "VAT-EU number must start with the PL country prefix."
+      );
+    }
+    const nipPart = stripped.slice(2);
+    if (nipPart.length !== NIP_DIGITS) {
+      return ValidationResult.failWithReason(
+        "invalid_length" /* InvalidLength */,
+        "VAT-EU must contain exactly 10 digits after the PL prefix."
+      );
+    }
+    return this.nip.validate(nipPart);
+  }
+  isValid(input) {
+    return this.validate(input).isValid;
+  }
+  parse(input) {
+    const result = this.validate(input);
+    if (result.isFailed()) {
+      throw result.toException();
+    }
+    return new VatEu(input, this.normalize(input));
+  }
+  tryParse(input) {
+    try {
+      return this.parse(input);
+    } catch (err) {
+      if (err instanceof ValidationException) return null;
+      throw err;
+    }
+  }
+  stripSeparators(input) {
+    return input.replace(/[-\s]/g, "");
+  }
+  normalize(input) {
+    const stripped = this.stripSeparators(input);
+    return PREFIX + stripped.slice(2);
+  }
+};
+
+// src/Numerik.ts
+var Numerik = {
+  // Personal
+  pesel: (strict = true) => new PeselIdentifier(strict),
+  idCard: (strict = true) => new IdCardIdentifier(strict),
+  passport: (strict = true) => new PassportIdentifier(strict),
+  // Tax & Business
+  nip: (strict = true) => new NipIdentifier(strict),
+  vatEu: (strict = true) => new VatEuIdentifier(strict),
+  regon: (strict = true) => new RegonIdentifier(strict),
+  krs: (strict = true) => new KrsIdentifier(strict),
+  // Banking
+  nrb: (strict = true) => new NrbIdentifier(strict),
+  iban: (strict = true) => new IbanIdentifier(strict)
+};
+
+// src/zod/index.ts
+function refine(identifier) {
+  return (val, ctx) => {
+    const result = identifier.validate(val);
+    for (const failure of result.failures) {
+      ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: failure.message });
+    }
+  };
+}
+function makeIdSchemas(factory) {
+  return {
+    schema: (strict = true) => {
+      const id = factory(strict);
+      return import_zod.z.string().superRefine(refine(id));
+    },
+    parseSchema: (strict = true) => {
+      const id = factory(strict);
+      return import_zod.z.string().superRefine(refine(id)).transform((val) => id.parse(val));
+    }
+  };
+}
+var { schema: peselSchema, parseSchema: peselParseSchema } = makeIdSchemas((strict) => Numerik.pesel(strict));
+var { schema: idCardSchema, parseSchema: idCardParseSchema } = makeIdSchemas((strict) => Numerik.idCard(strict));
+var { schema: passportSchema, parseSchema: passportParseSchema } = makeIdSchemas((strict) => Numerik.passport(strict));
+var { schema: nipSchema, parseSchema: nipParseSchema } = makeIdSchemas((strict) => Numerik.nip(strict));
+var { schema: vatEuSchema, parseSchema: vatEuParseSchema } = makeIdSchemas((strict) => Numerik.vatEu(strict));
+var { schema: regonSchema, parseSchema: regonParseSchema } = makeIdSchemas((strict) => Numerik.regon(strict));
+var { schema: krsSchema, parseSchema: krsParseSchema } = makeIdSchemas((strict) => Numerik.krs(strict));
+var { schema: nrbSchema, parseSchema: nrbParseSchema } = makeIdSchemas((strict) => Numerik.nrb(strict));
+var { schema: ibanSchema, parseSchema: ibanParseSchema } = makeIdSchemas((strict) => Numerik.iban(strict));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ibanParseSchema,
+  ibanSchema,
+  idCardParseSchema,
+  idCardSchema,
+  krsParseSchema,
+  krsSchema,
+  nipParseSchema,
+  nipSchema,
+  nrbParseSchema,
+  nrbSchema,
+  passportParseSchema,
+  passportSchema,
+  peselParseSchema,
+  peselSchema,
+  regonParseSchema,
+  regonSchema,
+  vatEuParseSchema,
+  vatEuSchema
+});
+//# sourceMappingURL=index.cjs.map