@eifi1/ui-kit 0.21.0 → 0.23.0

package/dist/lib/decimal-marks.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The locale's decimal mark, as far as a field can type it: "," or "." (kastlan 40).
+ * A mark outside those two (Arabic's "٫") is not one {@link sanitizeLive} lets
+ * through, so those locales keep the dot rather than get a field that eats the key it
+ * shows. `undefined` is the runtime's own locale, which is what `Intl` reads it as.
+ */
+declare function decimalMark(locale: string | undefined): "," | ".";
+/**
+ * Which typed mark is the decimal one (keksdose G1). {@link sanitizeLive} folds every
+ * "," into ".", so on its own it read the German "1.234,56" as 1.23456 — and a money
+ * field's settle then made that 1.23, final. This decides per operand, from the
+ * typist's own text, before that fold:
+ *
+ * - both marks present: the one that is not the locale's is grouping, and goes;
+ * - in a "," locale, only "." present: grouping when it cannot be a decimal as a
+ *   German reader writes it — twice ("1.234.567"), or in thousands shape ("1.234",
+ *   "12.500") — otherwise a decimal ("1.5", typed by a dot-decimal habit);
+ * - in a "." locale, only "," present: grouping when it appears twice ("1,234,567");
+ *   once it stays a decimal, because Swiss and German typists write "1,5" in a
+ *   de-CH form (kastlan 40) and a unit price "1,789" is a decimal.
+ *
+ * Only a keystroke's text comes through here. A calculator result is dot-decimal
+ * already, and "1.234" from `100/81.03…` is never a thousand.
+ */
+declare function normalizeTypedMarks(raw: string, mark: "," | "."): string;
+/** What a keystroke's raw text reports: grouping read off, then the field's live
+ *  sanitising (comma → dot, stray characters out, one decimal point per operand). */
+declare function readTyped(raw: string, mark: "," | "."): string;
+/**
+ * Whether the field may keep SHOWING `raw` — the typist's own text — while it holds
+ * `canonical` (dot-decimal, as `onChange` reported it).
+ *
+ * Showing the typed text rather than re-spelling the value is what keeps the caret
+ * where the typist put it, and what keeps a grouping "." from being turned into a ","
+ * under their fingers — after which no rule could tell the two apart (keksdose G1).
+ * But only text that says the same as the value, and says it with nothing the field
+ * would have DROPPED: a letter, or a second decimal point in one operand ("1.2.3"),
+ * must not stay on screen while the value says "1.23" (Keksdose live #201 is the bug
+ * that showing it would bring back). Grouping marks and grouping spaces may stay.
+ */
+declare function showsTyped(raw: string, mark: "," | ".", canonical: string): boolean;
+/** A dot-decimal text spelt in `mark` — display only, one character for one, so a
+ *  re-spelling never moves a caret. */
+declare function localizeMark(text: string, mark: "," | "."): string;
+
+export { decimalMark, localizeMark, normalizeTypedMarks, readTyped, showsTyped };

package/dist/lib/decimal-marks.js

@@ -0,0 +1,40 @@
+"use client";
+import { sanitizeLive } from "./calc.js";
+function decimalMark(locale) {
+  try {
+    const part = new Intl.NumberFormat(locale).formatToParts(1.5).find((p) => p.type === "decimal");
+    return part?.value === "," ? "," : ".";
+  } catch {
+    return ".";
+  }
+}
+function normalizeTypedMarks(raw, mark) {
+  const other = mark === "," ? "." : ",";
+  return raw.replace(/[0-9.,]+/g, (operand) => {
+    const hasMark = operand.includes(mark);
+    const count = operand.split(other).length - 1;
+    if (count === 0) return operand;
+    const grouping = hasMark ? true : count > 1 || mark === "," && /^\d{1,3}(\.\d{3})+$/.test(operand);
+    return grouping ? operand.split(other).join("") : operand;
+  });
+}
+function readTyped(raw, mark) {
+  return sanitizeLive(normalizeTypedMarks(raw, mark));
+}
+const GROUP_SPACING = /[\s'’\u00a0\u202f]/g;
+function showsTyped(raw, mark, canonical) {
+  const read = normalizeTypedMarks(raw, mark).replace(GROUP_SPACING, "");
+  const sanitized = sanitizeLive(read);
+  return sanitized === read.replace(/,/g, ".") && sanitized === sanitizeLive(canonical);
+}
+function localizeMark(text, mark) {
+  return mark === "," ? text.replace(/\./g, ",") : text;
+}
+export {
+  decimalMark,
+  localizeMark,
+  normalizeTypedMarks,
+  readTyped,
+  showsTyped
+};
+//# sourceMappingURL=decimal-marks.js.map

package/dist/lib/decimal-marks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/decimal-marks.ts"],"sourcesContent":["/**\n * The locale's decimal mark and the reading of typed grouping marks, shared by the\n * kit's numeric text fields: {@link AmountInput}, {@link NumberInput} and, through\n * NumberInput, {@link NumberField} and {@link MoneyField}.\n *\n * Package-private — not re-exported from the barrel. It lives here rather than in\n * `calc.ts` because that module is re-exported wholesale (`export * from\n * \"./lib/calc\"`), and these are the fields' plumbing, not API.\n *\n * WHY ONE MODULE. AmountInput learned the locale's mark (kastlan 40) and the grouping\n * parse (keksdose G1); NumberInput learned neither, so the same \"1.234,56\" a German\n * user typed into a money field read as 1234.56 and, typed into the budget-goal field\n * next to it, as 1.23456 (keksdose K5). Two private copies of the same rule are how\n * that happened, so the rule now has one home.\n */\nimport { sanitizeLive } from \"./calc\";\n\n/**\n * The locale's decimal mark, as far as a field can type it: \",\" or \".\" (kastlan 40).\n * A mark outside those two (Arabic's \"٫\") is not one {@link sanitizeLive} lets\n * through, so those locales keep the dot rather than get a field that eats the key it\n * shows. `undefined` is the runtime's own locale, which is what `Intl` reads it as.\n */\nexport function decimalMark(locale: string | undefined): \",\" | \".\" {\n  try {\n    const part = new Intl.NumberFormat(locale).formatToParts(1.5).find((p) => p.type === \"decimal\");\n    return part?.value === \",\" ? \",\" : \".\";\n  } catch {\n    // An invalid tag throws a RangeError; a typo in a locale must not take the form down.\n    return \".\";\n  }\n}\n\n/**\n * Which typed mark is the decimal one (keksdose G1). {@link sanitizeLive} folds every\n * \",\" into \".\", so on its own it read the German \"1.234,56\" as 1.23456 — and a money\n * field's settle then made that 1.23, final. This decides per operand, from the\n * typist's own text, before that fold:\n *\n * - both marks present: the one that is not the locale's is grouping, and goes;\n * - in a \",\" locale, only \".\" present: grouping when it cannot be a decimal as a\n *   German reader writes it — twice (\"1.234.567\"), or in thousands shape (\"1.234\",\n *   \"12.500\") — otherwise a decimal (\"1.5\", typed by a dot-decimal habit);\n * - in a \".\" locale, only \",\" present: grouping when it appears twice (\"1,234,567\");\n *   once it stays a decimal, because Swiss and German typists write \"1,5\" in a\n *   de-CH form (kastlan 40) and a unit price \"1,789\" is a decimal.\n *\n * Only a keystroke's text comes through here. A calculator result is dot-decimal\n * already, and \"1.234\" from `100/81.03…` is never a thousand.\n */\nexport function normalizeTypedMarks(raw: string, mark: \",\" | \".\"): string {\n  const other = mark === \",\" ? \".\" : \",\";\n  return raw.replace(/[0-9.,]+/g, (operand) => {\n    const hasMark = operand.includes(mark);\n    const count = operand.split(other).length - 1;\n    if (count === 0) return operand;\n    const grouping = hasMark\n      ? true\n      : count > 1 || (mark === \",\" && /^\\d{1,3}(\\.\\d{3})+$/.test(operand));\n    return grouping ? operand.split(other).join(\"\") : operand;\n  });\n}\n\n/** What a keystroke's raw text reports: grouping read off, then the field's live\n *  sanitising (comma → dot, stray characters out, one decimal point per operand). */\nexport function readTyped(raw: string, mark: \",\" | \".\"): string {\n  return sanitizeLive(normalizeTypedMarks(raw, mark));\n}\n\n// Spacing a typist uses to group digits — a space, the no-break and narrow no-break\n// spaces `Intl` itself writes for fr-CH (\"1 234,5\" with U+202F), and the Swiss\n// apostrophes (\"1'234.50\"). The live sanitising drops them, so they never reach the\n// value; the draft may still show them.\nconst GROUP_SPACING = /[\\s'’\\u00a0\\u202f]/g;\n\n/**\n * Whether the field may keep SHOWING `raw` — the typist's own text — while it holds\n * `canonical` (dot-decimal, as `onChange` reported it).\n *\n * Showing the typed text rather than re-spelling the value is what keeps the caret\n * where the typist put it, and what keeps a grouping \".\" from being turned into a \",\"\n * under their fingers — after which no rule could tell the two apart (keksdose G1).\n * But only text that says the same as the value, and says it with nothing the field\n * would have DROPPED: a letter, or a second decimal point in one operand (\"1.2.3\"),\n * must not stay on screen while the value says \"1.23\" (Keksdose live #201 is the bug\n * that showing it would bring back). Grouping marks and grouping spaces may stay.\n */\nexport function showsTyped(raw: string, mark: \",\" | \".\", canonical: string): boolean {\n  const read = normalizeTypedMarks(raw, mark).replace(GROUP_SPACING, \"\");\n  const sanitized = sanitizeLive(read);\n  // Nothing dropped: the read text is the sanitised one, but for which mark it uses.\n  return sanitized === read.replace(/,/g, \".\") && sanitized === sanitizeLive(canonical);\n}\n\n/** A dot-decimal text spelt in `mark` — display only, one character for one, so a\n *  re-spelling never moves a caret. */\nexport function localizeMark(text: string, mark: \",\" | \".\"): string {\n  return mark === \",\" ? text.replace(/\\./g, \",\") : text;\n}\n"],"mappings":";AAeA,SAAS,oBAAoB;AAQtB,SAAS,YAAY,QAAuC;AACjE,MAAI;AACF,UAAM,OAAO,IAAI,KAAK,aAAa,MAAM,EAAE,cAAc,GAAG,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS;AAC9F,WAAO,MAAM,UAAU,MAAM,MAAM;AAAA,EACrC,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAmBO,SAAS,oBAAoB,KAAa,MAAyB;AACxE,QAAM,QAAQ,SAAS,MAAM,MAAM;AACnC,SAAO,IAAI,QAAQ,aAAa,CAAC,YAAY;AAC3C,UAAM,UAAU,QAAQ,SAAS,IAAI;AACrC,UAAM,QAAQ,QAAQ,MAAM,KAAK,EAAE,SAAS;AAC5C,QAAI,UAAU,EAAG,QAAO;AACxB,UAAM,WAAW,UACb,OACA,QAAQ,KAAM,SAAS,OAAO,sBAAsB,KAAK,OAAO;AACpE,WAAO,WAAW,QAAQ,MAAM,KAAK,EAAE,KAAK,EAAE,IAAI;AAAA,EACpD,CAAC;AACH;AAIO,SAAS,UAAU,KAAa,MAAyB;AAC9D,SAAO,aAAa,oBAAoB,KAAK,IAAI,CAAC;AACpD;AAMA,MAAM,gBAAgB;AAcf,SAAS,WAAW,KAAa,MAAiB,WAA4B;AACnF,QAAM,OAAO,oBAAoB,KAAK,IAAI,EAAE,QAAQ,eAAe,EAAE;AACrE,QAAM,YAAY,aAAa,IAAI;AAEnC,SAAO,cAAc,KAAK,QAAQ,MAAM,GAAG,KAAK,cAAc,aAAa,SAAS;AACtF;AAIO,SAAS,aAAa,MAAc,MAAyB;AAClE,SAAO,SAAS,MAAM,KAAK,QAAQ,OAAO,GAAG,IAAI;AACnD;","names":[]}

package/dist/lib/iban.d.ts

@@ -0,0 +1,98 @@
+/**
+ * IBAN helpers — ISO 13616 — for kastlan (supplier and customer bank details, the
+ * Swiss QR-bill) and keksdose (the accounts behind a household's transfers).
+ *
+ * Both apps validated an IBAN the same partial way: a regex for the shape, sometimes a
+ * mod-97, never the per-country length — so a Swiss IBAN with a digit missing passed
+ * as long as the shorter string happened to sum right, and "CH" followed by 22
+ * characters (a German length) was accepted as Swiss. And kastlan's QR-bill needs a
+ * second distinction neither had: a **QR-IBAN** (the institution id at positions 5–9 is
+ * 30000–31999) is the only account a QR-bill with a QR reference can be paid to, and it
+ * cannot receive an ordinary transfer — so a regular IBAN typed where a QR-IBAN is
+ * needed, or the other way round, is a payment that bounces weeks later.
+ *
+ * Everything here works on the **electronic format** (no spaces, upper case), which is
+ * what to store; {@link formatIban} is the paper format, which is what to show.
+ *
+ * Validation is the registry's two rules, nothing more: the length for the country and
+ * the mod-97 check digits. It does not check each country's BBAN layout (which places
+ * hold letters), nor whether the bank exists — a checksum catches a typo, not a closed
+ * account.
+ */
+/**
+ * The IBAN length for each country in the SWIFT IBAN Registry (2025 edition) — the
+ * whole string, country code and check digits included.
+ *
+ * A country that is not in the table does not issue IBANs, so {@link isValidIban}
+ * refuses it ("XX" is a typo, not an exotic bank). Territories that use another
+ * country's code (Åland under FI, Guernsey under GB, the French overseas departments
+ * under FR) are covered by that code, as the registry lists them.
+ */
+declare const IBAN_LENGTHS: Readonly<Record<string, number>>;
+/**
+ * Which kind of IBAN a field accepts. `"any"`: every valid IBAN. `"qr"`: only a
+ * QR-IBAN (a QR-bill with a QR reference — kastlan's payment slips). `"plain"`: every
+ * valid IBAN EXCEPT a QR-IBAN (an account for ordinary transfers, which a QR-IBAN
+ * cannot receive).
+ */
+type IbanKind = "qr" | "plain" | "any";
+/**
+ * Why a value is not the IBAN a field wants, most fundamental first:
+ *
+ *  - `"format"` — it does not start with a two-letter country code and two digits;
+ *  - `"country"` — the first two letters are not a country in {@link IBAN_LENGTHS};
+ *  - `"length"` — the wrong number of characters for that country;
+ *  - `"checksum"` — the mod-97 check digits do not match (a typo, a swapped pair);
+ *  - `"qrRequired"` — a valid IBAN, but not a QR-IBAN where `kind="qr"` needs one;
+ *  - `"qrNotAllowed"` — a valid QR-IBAN where `kind="plain"` refuses one.
+ */
+type IbanProblem = "format" | "country" | "length" | "checksum" | "qrRequired" | "qrNotAllowed";
+/**
+ * The electronic format: every character that is not a letter or a digit dropped, the
+ * letters in upper case. Spaces, non-breaking spaces, hyphens and dots — what a paste
+ * from an invoice, a PDF or an e-banking screen carries — all go.
+ *
+ * A leading `"IBAN"` (the paper format's label: "IBAN CH56 …") is dropped too, but only
+ * in front of a country code and check digits, so typing the word does not make it
+ * vanish under the caret.
+ */
+declare function compactIban(value: string): string;
+/**
+ * The paper format: {@link compactIban}, then groups of four separated by a single
+ * space ("CH09 0000 0000 0000 0000 1"). The last group is whatever is left over.
+ */
+declare function formatIban(value: string): string;
+/**
+ * The two check digits for a country code and a BBAN (the account part after them):
+ * `98 − ((BBAN + country + "00") mod 97)`, letters expanded A = 10 … Z = 35.
+ *
+ * What an app needs to BUILD an IBAN — a test fixture, a demo, a migration that
+ * assembles one from a clearing number and an account number — rather than to check
+ * one. Both arguments are compacted first.
+ */
+declare function ibanCheckDigits(country: string, bban: string): string;
+/**
+ * The first thing wrong with `value` as an IBAN of `kind`, or `null` when it is one.
+ * The value is compacted first, so the paper format is accepted. An empty value is
+ * `"format"`: whether a field may be left empty is the form's rule, not the IBAN's.
+ */
+declare function ibanProblem(value: string, kind?: IbanKind): IbanProblem | null;
+/**
+ * Whether `value` is a valid IBAN: a registry country, that country's length, and
+ * matching mod-97 check digits. Spaces and lower case are fine (see
+ * {@link compactIban}); what to store is the compact form.
+ */
+declare function isValidIban(value: string): boolean;
+/**
+ * Whether `value` is a valid **QR-IBAN**: a valid Swiss or Liechtenstein IBAN whose
+ * institution id — positions 5 to 9, the QR-IID — lies in 30000–31999 (SIX, Swiss
+ * Implementation Guidelines for the QR-bill).
+ *
+ * The distinction is not cosmetic (kastlan): a QR-bill with a QR reference can only be
+ * paid to a QR-IBAN, and a QR-IBAN can receive nothing else — so an app that prints
+ * payment slips needs one, and an app that stores an account for ordinary transfers
+ * must not take one.
+ */
+declare function isQrIban(value: string): boolean;
+
+export { IBAN_LENGTHS, type IbanKind, type IbanProblem, compactIban, formatIban, ibanCheckDigits, ibanProblem, isQrIban, isValidIban };

package/dist/lib/iban.js

@@ -0,0 +1,154 @@
+"use client";
+const IBAN_LENGTHS = Object.freeze({
+  AD: 24,
+  AE: 23,
+  AL: 28,
+  AT: 20,
+  AZ: 28,
+  BA: 20,
+  BE: 16,
+  BG: 22,
+  BH: 22,
+  BI: 27,
+  BR: 29,
+  BY: 28,
+  CH: 21,
+  CR: 22,
+  CY: 28,
+  CZ: 24,
+  DE: 22,
+  DJ: 27,
+  DK: 18,
+  DO: 28,
+  EE: 20,
+  EG: 29,
+  ES: 24,
+  FI: 18,
+  FK: 18,
+  FO: 18,
+  FR: 27,
+  GB: 22,
+  GE: 22,
+  GI: 23,
+  GL: 18,
+  GR: 27,
+  GT: 28,
+  HN: 28,
+  HR: 21,
+  HU: 28,
+  IE: 22,
+  IL: 23,
+  IQ: 23,
+  IS: 26,
+  IT: 27,
+  JO: 30,
+  KW: 30,
+  KZ: 20,
+  LB: 28,
+  LC: 32,
+  LI: 21,
+  LT: 20,
+  LU: 20,
+  LV: 21,
+  LY: 25,
+  MC: 27,
+  MD: 24,
+  ME: 22,
+  MK: 19,
+  MN: 20,
+  MR: 27,
+  MT: 31,
+  MU: 30,
+  NI: 28,
+  NL: 18,
+  NO: 15,
+  OM: 23,
+  PK: 24,
+  PL: 28,
+  PS: 29,
+  PT: 25,
+  QA: 29,
+  RO: 24,
+  RS: 22,
+  RU: 33,
+  SA: 24,
+  SC: 31,
+  SD: 18,
+  SE: 24,
+  SI: 19,
+  SK: 24,
+  SM: 27,
+  SO: 23,
+  ST: 25,
+  SV: 28,
+  TL: 23,
+  TN: 24,
+  TR: 26,
+  UA: 29,
+  VA: 22,
+  VG: 24,
+  XK: 20,
+  YE: 30
+});
+function compactIban(value) {
+  const compact = value.replace(/[^0-9A-Za-z]/g, "").toUpperCase();
+  return /^IBAN[A-Z]{2}\d{2}/.test(compact) ? compact.slice(4) : compact;
+}
+function formatIban(value) {
+  return compactIban(value).replace(/(.{4})(?=.)/g, "$1 ");
+}
+function mod97(digits) {
+  let rest = 0;
+  for (let i = 0; i < digits.length; i += 7) {
+    rest = Number(`${rest}${digits.slice(i, i + 7)}`) % 97;
+  }
+  return rest;
+}
+function expandLetters(value) {
+  return value.replace(/[A-Z]/g, (c) => String(c.charCodeAt(0) - 55));
+}
+function ibanCheckDigits(country, bban) {
+  const rearranged = `${compactIban(bban)}${compactIban(country)}00`;
+  const check = 98 - mod97(expandLetters(rearranged));
+  return String(check).padStart(2, "0");
+}
+function ibanProblem(value, kind = "any") {
+  const iban = compactIban(value);
+  if (!/^[A-Z]{2}\d{2}/.test(iban)) return "format";
+  const expected = IBAN_LENGTHS[iban.slice(0, 2)];
+  if (expected === void 0) return "country";
+  if (iban.length !== expected) return "length";
+  const check = iban.slice(2, 4);
+  if (check === "00" || check === "01" || check === "99") return "checksum";
+  if (mod97(expandLetters(`${iban.slice(4)}${iban.slice(0, 4)}`)) !== 1) return "checksum";
+  if (kind === "any") return null;
+  const qr = qrIid(iban);
+  if (kind === "qr" && !qr) return "qrRequired";
+  if (kind === "plain" && qr) return "qrNotAllowed";
+  return null;
+}
+function isValidIban(value) {
+  return ibanProblem(value) === null;
+}
+function qrIid(iban) {
+  const country = iban.slice(0, 2);
+  if (country !== "CH" && country !== "LI") return false;
+  const iid = iban.slice(4, 9);
+  if (!/^\d{5}$/.test(iid)) return false;
+  const n = Number(iid);
+  return n >= 3e4 && n <= 31999;
+}
+function isQrIban(value) {
+  const iban = compactIban(value);
+  return ibanProblem(iban) === null && qrIid(iban);
+}
+export {
+  IBAN_LENGTHS,
+  compactIban,
+  formatIban,
+  ibanCheckDigits,
+  ibanProblem,
+  isQrIban,
+  isValidIban
+};
+//# sourceMappingURL=iban.js.map

package/dist/lib/iban.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/iban.ts"],"sourcesContent":["/**\n * IBAN helpers — ISO 13616 — for kastlan (supplier and customer bank details, the\n * Swiss QR-bill) and keksdose (the accounts behind a household's transfers).\n *\n * Both apps validated an IBAN the same partial way: a regex for the shape, sometimes a\n * mod-97, never the per-country length — so a Swiss IBAN with a digit missing passed\n * as long as the shorter string happened to sum right, and \"CH\" followed by 22\n * characters (a German length) was accepted as Swiss. And kastlan's QR-bill needs a\n * second distinction neither had: a **QR-IBAN** (the institution id at positions 5–9 is\n * 30000–31999) is the only account a QR-bill with a QR reference can be paid to, and it\n * cannot receive an ordinary transfer — so a regular IBAN typed where a QR-IBAN is\n * needed, or the other way round, is a payment that bounces weeks later.\n *\n * Everything here works on the **electronic format** (no spaces, upper case), which is\n * what to store; {@link formatIban} is the paper format, which is what to show.\n *\n * Validation is the registry's two rules, nothing more: the length for the country and\n * the mod-97 check digits. It does not check each country's BBAN layout (which places\n * hold letters), nor whether the bank exists — a checksum catches a typo, not a closed\n * account.\n */\n\n/**\n * The IBAN length for each country in the SWIFT IBAN Registry (2025 edition) — the\n * whole string, country code and check digits included.\n *\n * A country that is not in the table does not issue IBANs, so {@link isValidIban}\n * refuses it (\"XX\" is a typo, not an exotic bank). Territories that use another\n * country's code (Åland under FI, Guernsey under GB, the French overseas departments\n * under FR) are covered by that code, as the registry lists them.\n */\nexport const IBAN_LENGTHS: Readonly<Record<string, number>> = Object.freeze({\n  AD: 24, AE: 23, AL: 28, AT: 20, AZ: 28, BA: 20, BE: 16, BG: 22, BH: 22, BI: 27,\n  BR: 29, BY: 28, CH: 21, CR: 22, CY: 28, CZ: 24, DE: 22, DJ: 27, DK: 18, DO: 28,\n  EE: 20, EG: 29, ES: 24, FI: 18, FK: 18, FO: 18, FR: 27, GB: 22, GE: 22, GI: 23,\n  GL: 18, GR: 27, GT: 28, HN: 28, HR: 21, HU: 28, IE: 22, IL: 23, IQ: 23, IS: 26,\n  IT: 27, JO: 30, KW: 30, KZ: 20, LB: 28, LC: 32, LI: 21, LT: 20, LU: 20, LV: 21,\n  LY: 25, MC: 27, MD: 24, ME: 22, MK: 19, MN: 20, MR: 27, MT: 31, MU: 30, NI: 28,\n  NL: 18, NO: 15, OM: 23, PK: 24, PL: 28, PS: 29, PT: 25, QA: 29, RO: 24, RS: 22,\n  RU: 33, SA: 24, SC: 31, SD: 18, SE: 24, SI: 19, SK: 24, SM: 27, SO: 23, ST: 25,\n  SV: 28, TL: 23, TN: 24, TR: 26, UA: 29, VA: 22, VG: 24, XK: 20, YE: 30,\n});\n\n/**\n * Which kind of IBAN a field accepts. `\"any\"`: every valid IBAN. `\"qr\"`: only a\n * QR-IBAN (a QR-bill with a QR reference — kastlan's payment slips). `\"plain\"`: every\n * valid IBAN EXCEPT a QR-IBAN (an account for ordinary transfers, which a QR-IBAN\n * cannot receive).\n */\nexport type IbanKind = \"qr\" | \"plain\" | \"any\";\n\n/**\n * Why a value is not the IBAN a field wants, most fundamental first:\n *\n *  - `\"format\"` — it does not start with a two-letter country code and two digits;\n *  - `\"country\"` — the first two letters are not a country in {@link IBAN_LENGTHS};\n *  - `\"length\"` — the wrong number of characters for that country;\n *  - `\"checksum\"` — the mod-97 check digits do not match (a typo, a swapped pair);\n *  - `\"qrRequired\"` — a valid IBAN, but not a QR-IBAN where `kind=\"qr\"` needs one;\n *  - `\"qrNotAllowed\"` — a valid QR-IBAN where `kind=\"plain\"` refuses one.\n */\nexport type IbanProblem = \"format\" | \"country\" | \"length\" | \"checksum\" | \"qrRequired\" | \"qrNotAllowed\";\n\n/**\n * The electronic format: every character that is not a letter or a digit dropped, the\n * letters in upper case. Spaces, non-breaking spaces, hyphens and dots — what a paste\n * from an invoice, a PDF or an e-banking screen carries — all go.\n *\n * A leading `\"IBAN\"` (the paper format's label: \"IBAN CH56 …\") is dropped too, but only\n * in front of a country code and check digits, so typing the word does not make it\n * vanish under the caret.\n */\nexport function compactIban(value: string): string {\n  const compact = value.replace(/[^0-9A-Za-z]/g, \"\").toUpperCase();\n  return /^IBAN[A-Z]{2}\\d{2}/.test(compact) ? compact.slice(4) : compact;\n}\n\n/**\n * The paper format: {@link compactIban}, then groups of four separated by a single\n * space (\"CH09 0000 0000 0000 0000 1\"). The last group is whatever is left over.\n */\nexport function formatIban(value: string): string {\n  return compactIban(value).replace(/(.{4})(?=.)/g, \"$1 \");\n}\n\n/** The remainder of a long digit string modulo 97, a few digits at a time so it never\n *  leaves the safe-integer range — ISO 7064 MOD 97-10 without a BigInt. */\nfunction mod97(digits: string): number {\n  let rest = 0;\n  for (let i = 0; i < digits.length; i += 7) {\n    rest = Number(`${rest}${digits.slice(i, i + 7)}`) % 97;\n  }\n  return rest;\n}\n\n/** Letters to their two-digit numbers (A = 10 … Z = 35), digits as they are. */\nfunction expandLetters(value: string): string {\n  return value.replace(/[A-Z]/g, (c) => String(c.charCodeAt(0) - 55));\n}\n\n/**\n * The two check digits for a country code and a BBAN (the account part after them):\n * `98 − ((BBAN + country + \"00\") mod 97)`, letters expanded A = 10 … Z = 35.\n *\n * What an app needs to BUILD an IBAN — a test fixture, a demo, a migration that\n * assembles one from a clearing number and an account number — rather than to check\n * one. Both arguments are compacted first.\n */\nexport function ibanCheckDigits(country: string, bban: string): string {\n  const rearranged = `${compactIban(bban)}${compactIban(country)}00`;\n  const check = 98 - mod97(expandLetters(rearranged));\n  return String(check).padStart(2, \"0\");\n}\n\n/**\n * The first thing wrong with `value` as an IBAN of `kind`, or `null` when it is one.\n * The value is compacted first, so the paper format is accepted. An empty value is\n * `\"format\"`: whether a field may be left empty is the form's rule, not the IBAN's.\n */\nexport function ibanProblem(value: string, kind: IbanKind = \"any\"): IbanProblem | null {\n  const iban = compactIban(value);\n  if (!/^[A-Z]{2}\\d{2}/.test(iban)) return \"format\";\n  const expected = IBAN_LENGTHS[iban.slice(0, 2)];\n  if (expected === undefined) return \"country\";\n  if (iban.length !== expected) return \"length\";\n  // 00, 01 and 99 are never computed (98 − r lies in 2…98), but 01 ≡ 98 mod 97 and\n  // would otherwise pass the remainder test below — ISO 7064 rules them out.\n  const check = iban.slice(2, 4);\n  if (check === \"00\" || check === \"01\" || check === \"99\") return \"checksum\";\n  if (mod97(expandLetters(`${iban.slice(4)}${iban.slice(0, 4)}`)) !== 1) return \"checksum\";\n  if (kind === \"any\") return null;\n  const qr = qrIid(iban);\n  if (kind === \"qr\" && !qr) return \"qrRequired\";\n  if (kind === \"plain\" && qr) return \"qrNotAllowed\";\n  return null;\n}\n\n/**\n * Whether `value` is a valid IBAN: a registry country, that country's length, and\n * matching mod-97 check digits. Spaces and lower case are fine (see\n * {@link compactIban}); what to store is the compact form.\n */\nexport function isValidIban(value: string): boolean {\n  return ibanProblem(value) === null;\n}\n\n/** A CH/LI IBAN whose institution id (positions 5–9) is in the QR range. Structure\n *  only — the caller has checked or will check the rest. */\nfunction qrIid(iban: string): boolean {\n  const country = iban.slice(0, 2);\n  if (country !== \"CH\" && country !== \"LI\") return false;\n  const iid = iban.slice(4, 9);\n  if (!/^\\d{5}$/.test(iid)) return false;\n  const n = Number(iid);\n  return n >= 30000 && n <= 31999;\n}\n\n/**\n * Whether `value` is a valid **QR-IBAN**: a valid Swiss or Liechtenstein IBAN whose\n * institution id — positions 5 to 9, the QR-IID — lies in 30000–31999 (SIX, Swiss\n * Implementation Guidelines for the QR-bill).\n *\n * The distinction is not cosmetic (kastlan): a QR-bill with a QR reference can only be\n * paid to a QR-IBAN, and a QR-IBAN can receive nothing else — so an app that prints\n * payment slips needs one, and an app that stores an account for ordinary transfers\n * must not take one.\n */\nexport function isQrIban(value: string): boolean {\n  const iban = compactIban(value);\n  return ibanProblem(iban) === null && qrIid(iban);\n}\n"],"mappings":";AA+BO,MAAM,eAAiD,OAAO,OAAO;AAAA,EAC1E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAC5E,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AAAA,EAAI,IAAI;AACtE,CAAC;AA+BM,SAAS,YAAY,OAAuB;AACjD,QAAM,UAAU,MAAM,QAAQ,iBAAiB,EAAE,EAAE,YAAY;AAC/D,SAAO,qBAAqB,KAAK,OAAO,IAAI,QAAQ,MAAM,CAAC,IAAI;AACjE;AAMO,SAAS,WAAW,OAAuB;AAChD,SAAO,YAAY,KAAK,EAAE,QAAQ,gBAAgB,KAAK;AACzD;AAIA,SAAS,MAAM,QAAwB;AACrC,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,GAAG;AACzC,WAAO,OAAO,GAAG,IAAI,GAAG,OAAO,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,IAAI;AAAA,EACtD;AACA,SAAO;AACT;AAGA,SAAS,cAAc,OAAuB;AAC5C,SAAO,MAAM,QAAQ,UAAU,CAAC,MAAM,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC;AACpE;AAUO,SAAS,gBAAgB,SAAiB,MAAsB;AACrE,QAAM,aAAa,GAAG,YAAY,IAAI,CAAC,GAAG,YAAY,OAAO,CAAC;AAC9D,QAAM,QAAQ,KAAK,MAAM,cAAc,UAAU,CAAC;AAClD,SAAO,OAAO,KAAK,EAAE,SAAS,GAAG,GAAG;AACtC;AAOO,SAAS,YAAY,OAAe,OAAiB,OAA2B;AACrF,QAAM,OAAO,YAAY,KAAK;AAC9B,MAAI,CAAC,iBAAiB,KAAK,IAAI,EAAG,QAAO;AACzC,QAAM,WAAW,aAAa,KAAK,MAAM,GAAG,CAAC,CAAC;AAC9C,MAAI,aAAa,OAAW,QAAO;AACnC,MAAI,KAAK,WAAW,SAAU,QAAO;AAGrC,QAAM,QAAQ,KAAK,MAAM,GAAG,CAAC;AAC7B,MAAI,UAAU,QAAQ,UAAU,QAAQ,UAAU,KAAM,QAAO;AAC/D,MAAI,MAAM,cAAc,GAAG,KAAK,MAAM,CAAC,CAAC,GAAG,KAAK,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,MAAM,EAAG,QAAO;AAC9E,MAAI,SAAS,MAAO,QAAO;AAC3B,QAAM,KAAK,MAAM,IAAI;AACrB,MAAI,SAAS,QAAQ,CAAC,GAAI,QAAO;AACjC,MAAI,SAAS,WAAW,GAAI,QAAO;AACnC,SAAO;AACT;AAOO,SAAS,YAAY,OAAwB;AAClD,SAAO,YAAY,KAAK,MAAM;AAChC;AAIA,SAAS,MAAM,MAAuB;AACpC,QAAM,UAAU,KAAK,MAAM,GAAG,CAAC;AAC/B,MAAI,YAAY,QAAQ,YAAY,KAAM,QAAO;AACjD,QAAM,MAAM,KAAK,MAAM,GAAG,CAAC;AAC3B,MAAI,CAAC,UAAU,KAAK,GAAG,EAAG,QAAO;AACjC,QAAM,IAAI,OAAO,GAAG;AACpB,SAAO,KAAK,OAAS,KAAK;AAC5B;AAYO,SAAS,SAAS,OAAwB;AAC/C,QAAM,OAAO,YAAY,KAAK;AAC9B,SAAO,YAAY,IAAI,MAAM,QAAQ,MAAM,IAAI;AACjD;","names":[]}

package/dist/lib/isin.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ISIN helpers — ISO 6166 — for keksdose, whose securities holdings are keyed by ISIN
+ * and whose import and edit forms checked only the shape (two letters, ten
+ * characters): a mistyped ISIN saved happily and then matched no price feed.
+ *
+ * An ISIN is twelve characters: a two-letter prefix (the issuing country, or a
+ * supranational code such as `XS`), nine letters or digits (the national number) and
+ * one check digit. The check digit is the Luhn digit of the first eleven characters
+ * with every letter expanded to two digits (A = 10 … Z = 35) — which is all that is
+ * checked here. Whether the prefix is an assigned code, and whether the security
+ * exists, is a lookup, not a checksum.
+ */
+/**
+ * The ISIN as it is printed: upper case, unbroken (ISO 6166 has no grouping), with
+ * the spaces and hyphens a paste from a broker's statement carries dropped.
+ */
+declare function formatIsin(value: string): string;
+/**
+ * The check digit for the first eleven characters of an ISIN (prefix and national
+ * number). For BUILDING one — a test fixture, a demo — rather than checking it.
+ */
+declare function isinCheckDigit(body: string): string;
+/**
+ * Whether `value` is a valid ISIN: two letters, nine letters or digits, one digit,
+ * and a matching Luhn check digit over the letter-expanded form. Spaces, hyphens and
+ * lower case are fine (see {@link formatIsin}).
+ */
+declare function isValidIsin(value: string): boolean;
+
+export { formatIsin, isValidIsin, isinCheckDigit };

package/dist/lib/isin.js

@@ -0,0 +1,36 @@
+"use client";
+function expandLetters(value) {
+  return value.replace(/[A-Z]/g, (c) => String(c.charCodeAt(0) - 55));
+}
+function luhnSum(digits, doubleRightmost) {
+  let sum = 0;
+  let double = doubleRightmost;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum;
+}
+function formatIsin(value) {
+  return value.replace(/[\s-]/g, "").toUpperCase();
+}
+function isinCheckDigit(body) {
+  const sum = luhnSum(expandLetters(formatIsin(body)), true);
+  return String((10 - sum % 10) % 10);
+}
+function isValidIsin(value) {
+  const isin = formatIsin(value);
+  if (!/^[A-Z]{2}[A-Z0-9]{9}\d$/.test(isin)) return false;
+  return luhnSum(expandLetters(isin), false) % 10 === 0;
+}
+export {
+  formatIsin,
+  isValidIsin,
+  isinCheckDigit
+};
+//# sourceMappingURL=isin.js.map

package/dist/lib/isin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/isin.ts"],"sourcesContent":["/**\n * ISIN helpers — ISO 6166 — for keksdose, whose securities holdings are keyed by ISIN\n * and whose import and edit forms checked only the shape (two letters, ten\n * characters): a mistyped ISIN saved happily and then matched no price feed.\n *\n * An ISIN is twelve characters: a two-letter prefix (the issuing country, or a\n * supranational code such as `XS`), nine letters or digits (the national number) and\n * one check digit. The check digit is the Luhn digit of the first eleven characters\n * with every letter expanded to two digits (A = 10 … Z = 35) — which is all that is\n * checked here. Whether the prefix is an assigned code, and whether the security\n * exists, is a lookup, not a checksum.\n */\n\n/** Letters to their two-digit numbers (A = 10 … Z = 35), digits as they are. */\nfunction expandLetters(value: string): string {\n  return value.replace(/[A-Z]/g, (c) => String(c.charCodeAt(0) - 55));\n}\n\n/** The Luhn sum of `digits` with the RIGHTMOST digit doubled first — the shape of the\n *  sum when a check digit is about to be appended. */\nfunction luhnSum(digits: string, doubleRightmost: boolean): number {\n  let sum = 0;\n  let double = doubleRightmost;\n  for (let i = digits.length - 1; i >= 0; i--) {\n    let d = digits.charCodeAt(i) - 48;\n    if (double) {\n      d *= 2;\n      if (d > 9) d -= 9;\n    }\n    sum += d;\n    double = !double;\n  }\n  return sum;\n}\n\n/**\n * The ISIN as it is printed: upper case, unbroken (ISO 6166 has no grouping), with\n * the spaces and hyphens a paste from a broker's statement carries dropped.\n */\nexport function formatIsin(value: string): string {\n  return value.replace(/[\\s-]/g, \"\").toUpperCase();\n}\n\n/**\n * The check digit for the first eleven characters of an ISIN (prefix and national\n * number). For BUILDING one — a test fixture, a demo — rather than checking it.\n */\nexport function isinCheckDigit(body: string): string {\n  const sum = luhnSum(expandLetters(formatIsin(body)), true);\n  return String((10 - (sum % 10)) % 10);\n}\n\n/**\n * Whether `value` is a valid ISIN: two letters, nine letters or digits, one digit,\n * and a matching Luhn check digit over the letter-expanded form. Spaces, hyphens and\n * lower case are fine (see {@link formatIsin}).\n */\nexport function isValidIsin(value: string): boolean {\n  const isin = formatIsin(value);\n  if (!/^[A-Z]{2}[A-Z0-9]{9}\\d$/.test(isin)) return false;\n  return luhnSum(expandLetters(isin), false) % 10 === 0;\n}\n"],"mappings":";AAcA,SAAS,cAAc,OAAuB;AAC5C,SAAO,MAAM,QAAQ,UAAU,CAAC,MAAM,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC;AACpE;AAIA,SAAS,QAAQ,QAAgB,iBAAkC;AACjE,MAAI,MAAM;AACV,MAAI,SAAS;AACb,WAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;AAC3C,QAAI,IAAI,OAAO,WAAW,CAAC,IAAI;AAC/B,QAAI,QAAQ;AACV,WAAK;AACL,UAAI,IAAI,EAAG,MAAK;AAAA,IAClB;AACA,WAAO;AACP,aAAS,CAAC;AAAA,EACZ;AACA,SAAO;AACT;AAMO,SAAS,WAAW,OAAuB;AAChD,SAAO,MAAM,QAAQ,UAAU,EAAE,EAAE,YAAY;AACjD;AAMO,SAAS,eAAe,MAAsB;AACnD,QAAM,MAAM,QAAQ,cAAc,WAAW,IAAI,CAAC,GAAG,IAAI;AACzD,SAAO,QAAQ,KAAM,MAAM,MAAO,EAAE;AACtC;AAOO,SAAS,YAAY,OAAwB;AAClD,QAAM,OAAO,WAAW,KAAK;AAC7B,MAAI,CAAC,0BAA0B,KAAK,IAAI,EAAG,QAAO;AAClD,SAAO,QAAQ,cAAc,IAAI,GAAG,KAAK,IAAI,OAAO;AACtD;","names":[]}

package/dist/lib/phone.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Phone numbers — E.164 in, grouped out — for kastlan's contacts, without a
+ * libphonenumber dependency.
+ *
+ * kastlan stored whatever was typed ("079 …", "+41 (0)79 …", "0041 79 …") and could
+ * neither dial nor de-duplicate it. What it needs is one canonical form to store —
+ * E.164, "+41210000001" — and a readable one to show. libphonenumber gets both right
+ * for every country, at ~150 kB of metadata in every app's bundle; the kit's apps are
+ * Swiss and their neighbours, so this is **light per-country rules** for the six that
+ * matter and a generic shape check for the rest:
+ *
+ *  - **CH, LI, DE, AT, FR, IT**: the national trunk prefix is dropped (a leading 0 —
+ *    but NOT for Italy, whose fixed-line numbers keep their 0 after +39, and not for
+ *    Liechtenstein, which has none), and the remaining national number has to be a
+ *    plausible length for the country.
+ *  - **Anything else** typed with its own "+" (or "00"): the digits, 8 to 15 in all,
+ *    are taken as an E.164 number as they stand.
+ *
+ * **The limitation:** a plausible length is not a valid number. There is no check of
+ * area codes or number ranges, so a well-formed number that does not exist passes, and
+ * a German or Austrian number (whose area codes run from one to five digits) is
+ * grouped only where the split is known (mobile prefixes, the largest cities) and
+ * otherwise shown in one block. A number these rules cannot read is not an error —
+ * {@link parsePhone} returns `null` and the field keeps the text as typed.
+ */
+/** The countries with their own rules. */
+type PhoneCountryCode = "CH" | "LI" | "DE" | "AT" | "FR" | "IT";
+/** A country with rules, or `"other"`: a number typed with its own "+". */
+type PhoneCountry = PhoneCountryCode | "other";
+/** The country calling codes with rules, "+" left off: `{ CH: "41", … }`. */
+declare const PHONE_DIAL_CODES: Readonly<Record<PhoneCountryCode, string>>;
+/** The countries with rules, in the order a picker offers them by default. */
+declare const PHONE_COUNTRIES: readonly PhoneCountryCode[];
+/** What {@link parsePhone} reads out of a number. */
+interface ParsedPhone {
+    /** The number in E.164: "+", the country code, the national number. */
+    e164: string;
+    /** The country whose rules read it, or `null` for a generic "+…" number. */
+    country: PhoneCountryCode | null;
+    /** The national significant number — the digits after the country code. For a
+     *  generic number, every digit after the "+" (the country code is not split off). */
+    national: string;
+}
+/**
+ * Read a typed number. With a leading "+" or "00" the number carries its own country
+ * code — one of the six with rules, or any other (8–15 digits in all, the E.164
+ * limit). Without one it is a national number of `country` (default `"CH"`), its
+ * trunk 0 optional; with `country="other"` a number without "+" cannot be read.
+ *
+ * Spaces, hyphens, dots, slashes and parentheses are ignored ("(030) 1234567"), and
+ * so is the "(0)" of "+41 (0)21 …". Anything else — a letter, an extension ("ext. 12"), a note —
+ * and the result is `null`: the text is not a number these rules can read, and a field
+ * keeps it as it is rather than guess.
+ */
+declare function parsePhone(input: string, country?: PhoneCountry): ParsedPhone | null;
+/** The national number grouped by its country's rules ("21 000 00 01"). */
+declare function formatNationalPhone(nsn: string, country: PhoneCountryCode): string;
+/**
+ * A number for display: an E.164 number (or anything {@link parsePhone} reads with a
+ * "+") grouped by its country's rules — "+41 21 000 00 01" — and a generic one as
+ * "+" and its digits. Anything it cannot read comes back exactly as it went in, so a
+ * list of contacts can format every row without first sorting out the free text.
+ */
+declare function formatPhone(value: string): string;
+/** Whether `value` is in E.164 shape: "+" and 8–15 digits, nothing else. Shape only —
+ *  what {@link PhoneInput} emits for every number it could read. */
+declare function isE164(value: string): boolean;
+
+export { PHONE_COUNTRIES, PHONE_DIAL_CODES, type ParsedPhone, type PhoneCountry, type PhoneCountryCode, formatNationalPhone, formatPhone, isE164, parsePhone };

package/dist/lib/phone.js

@@ -0,0 +1,121 @@
+"use client";
+function cut(nsn, sizes) {
+  const out = [];
+  let at = 0;
+  for (const size of sizes) {
+    if (at >= nsn.length) break;
+    out.push(nsn.slice(at, at + size));
+    at += size;
+  }
+  if (at < nsn.length) out.push(nsn.slice(at));
+  return out;
+}
+const RULES = {
+  // 9 digits, 2-3-2-2 ("21 000 00 01"); the 08xx/09xx service numbers 3-3-3.
+  CH: {
+    dial: "41",
+    trunk: true,
+    min: 9,
+    max: 9,
+    group: (n) => /^[89]/.test(n) ? cut(n, [3, 3, 3]) : cut(n, [2, 3, 2, 2])
+  },
+  // 7 digits, 3-2-2 ("100 00 01"), and 9 for some mobile ranges (3-3-3). No trunk prefix.
+  LI: {
+    dial: "423",
+    trunk: false,
+    min: 7,
+    max: 9,
+    group: (n) => n.length === 7 ? cut(n, [3, 2, 2]) : n.length === 9 ? cut(n, [3, 3, 3]) : [n]
+  },
+  // Area codes of two to five digits: only the mobile prefixes and the four
+  // two-digit cities are split; anything else is one block rather than a wrong split.
+  DE: {
+    dial: "49",
+    trunk: true,
+    min: 6,
+    max: 13,
+    group: (n) => /^15/.test(n) ? cut(n, [4]) : /^1[67]/.test(n) ? cut(n, [3]) : /^(30|40|69|89)/.test(n) ? cut(n, [2]) : [n]
+  },
+  // Vienna is "1"; mobile numbers start 6xx; other area codes vary, so one block.
+  AT: {
+    dial: "43",
+    trunk: true,
+    min: 6,
+    max: 13,
+    group: (n) => /^6/.test(n) ? cut(n, [3]) : /^1/.test(n) ? cut(n, [1]) : [n]
+  },
+  // 9 digits, 1-2-2-2-2 ("1 99 00 00 01").
+  FR: { dial: "33", trunk: true, min: 9, max: 9, group: (n) => cut(n, [1, 2, 2, 2, 2]) },
+  // The 0 of a fixed line is part of the number ("+39 06 …"); mobiles start with 3.
+  IT: {
+    dial: "39",
+    trunk: false,
+    zeroStart: true,
+    min: 6,
+    max: 11,
+    group: (n) => /^3/.test(n) ? cut(n, [3, 3]) : /^0[26]/.test(n) ? cut(n, [2, 4]) : [n]
+  }
+};
+const PHONE_DIAL_CODES = Object.freeze({
+  CH: RULES.CH.dial,
+  LI: RULES.LI.dial,
+  DE: RULES.DE.dial,
+  AT: RULES.AT.dial,
+  FR: RULES.FR.dial,
+  IT: RULES.IT.dial
+});
+const PHONE_COUNTRIES = Object.freeze(["CH", "LI", "DE", "AT", "FR", "IT"]);
+const BY_DIAL = [...PHONE_COUNTRIES].sort((a, b) => RULES[b].dial.length - RULES[a].dial.length);
+function national(digits, rule) {
+  const nsn = rule.trunk && digits.startsWith("0") ? digits.slice(1) : digits;
+  if (nsn.startsWith("0") && !rule.zeroStart) return null;
+  if (nsn.length < rule.min || nsn.length > rule.max) return null;
+  return nsn;
+}
+function parsePhone(input, country = "CH") {
+  const text = input.trim();
+  if (text === "" || !/^\+?[\d\s().\-/]+$/.test(text)) return null;
+  let digits = text.replace(/\D/g, "");
+  let international = text.startsWith("+");
+  if (!international && digits.startsWith("00")) {
+    international = true;
+    digits = digits.slice(2);
+  }
+  if (international) {
+    digits = text.replace(/\(\s*0\s*\)/g, "").replace(/\D/g, "").replace(/^00/, "");
+    if (digits.startsWith("0")) return null;
+    const known = BY_DIAL.find((c) => digits.startsWith(RULES[c].dial));
+    if (known) {
+      const rule2 = RULES[known];
+      const nsn2 = national(digits.slice(rule2.dial.length), rule2);
+      return nsn2 === null ? null : { e164: `+${rule2.dial}${nsn2}`, country: known, national: nsn2 };
+    }
+    if (digits.length < 8 || digits.length > 15) return null;
+    return { e164: `+${digits}`, country: null, national: digits };
+  }
+  if (country === "other") return null;
+  const rule = RULES[country];
+  const nsn = national(digits, rule);
+  return nsn === null ? null : { e164: `+${rule.dial}${nsn}`, country, national: nsn };
+}
+function formatNationalPhone(nsn, country) {
+  return RULES[country].group(nsn).join(" ");
+}
+function formatPhone(value) {
+  const parsed = value.trim().startsWith("+") ? parsePhone(value, "other") : null;
+  if (!parsed) return value;
+  if (!parsed.country) return parsed.e164;
+  return `+${RULES[parsed.country].dial} ${formatNationalPhone(parsed.national, parsed.country)}`;
+}
+function isE164(value) {
+  return /^\+[1-9]\d{7,14}$/.test(value);
+}
+export {
+  PHONE_COUNTRIES,
+  PHONE_DIAL_CODES,
+  formatNationalPhone,
+  formatPhone,
+  isE164,
+  parsePhone
+};
+//# sourceMappingURL=phone.js.map