@mailwoman/codex 4.0.0

package/out/de/bundesland.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The 16 German federal states (Bundesländer), keyed by their ISO 3166-2:DE subdivision code.
+ *
+ *   The US analog is `us/state.ts`. The informative difference: a US state's two-letter code (`CA`)
+ *   is the USPS abbreviation people actually write in an address, whereas a German address almost
+ *   never carries the Bundesland at all — it is `PLZ City`, and the state is inferred. So these
+ *   codes matter for resolver region-matching and display, not for parsing the surface string.
+ */
+/** Per-state record: ISO 3166-2:DE code, native German name, and the common English exonym. */
+export interface GermanStateInfo {
+    /** ISO 3166-2:DE subdivision code without the `DE-` prefix (e.g. `BY` for `DE-BY`). */
+    code: string;
+    /** Native German name (e.g. `Bayern`). */
+    name: string;
+    /** Common English name (e.g. `Bavaria`). */
+    english: string;
+}
+/**
+ * ISO 3166-2:DE code → state info, for all 16 Bundesländer. Codes are the official subdivision
+ * codes minus the `DE-` prefix.
+ */
+export declare const DE_BUNDESLAENDER: {
+    readonly BW: {
+        readonly code: "BW";
+        readonly name: "Baden-Württemberg";
+        readonly english: "Baden-Württemberg";
+    };
+    readonly BY: {
+        readonly code: "BY";
+        readonly name: "Bayern";
+        readonly english: "Bavaria";
+    };
+    readonly BE: {
+        readonly code: "BE";
+        readonly name: "Berlin";
+        readonly english: "Berlin";
+    };
+    readonly BB: {
+        readonly code: "BB";
+        readonly name: "Brandenburg";
+        readonly english: "Brandenburg";
+    };
+    readonly HB: {
+        readonly code: "HB";
+        readonly name: "Bremen";
+        readonly english: "Bremen";
+    };
+    readonly HH: {
+        readonly code: "HH";
+        readonly name: "Hamburg";
+        readonly english: "Hamburg";
+    };
+    readonly HE: {
+        readonly code: "HE";
+        readonly name: "Hessen";
+        readonly english: "Hesse";
+    };
+    readonly MV: {
+        readonly code: "MV";
+        readonly name: "Mecklenburg-Vorpommern";
+        readonly english: "Mecklenburg-Western Pomerania";
+    };
+    readonly NI: {
+        readonly code: "NI";
+        readonly name: "Niedersachsen";
+        readonly english: "Lower Saxony";
+    };
+    readonly NW: {
+        readonly code: "NW";
+        readonly name: "Nordrhein-Westfalen";
+        readonly english: "North Rhine-Westphalia";
+    };
+    readonly RP: {
+        readonly code: "RP";
+        readonly name: "Rheinland-Pfalz";
+        readonly english: "Rhineland-Palatinate";
+    };
+    readonly SL: {
+        readonly code: "SL";
+        readonly name: "Saarland";
+        readonly english: "Saarland";
+    };
+    readonly SN: {
+        readonly code: "SN";
+        readonly name: "Sachsen";
+        readonly english: "Saxony";
+    };
+    readonly ST: {
+        readonly code: "ST";
+        readonly name: "Sachsen-Anhalt";
+        readonly english: "Saxony-Anhalt";
+    };
+    readonly SH: {
+        readonly code: "SH";
+        readonly name: "Schleswig-Holstein";
+        readonly english: "Schleswig-Holstein";
+    };
+    readonly TH: {
+        readonly code: "TH";
+        readonly name: "Thüringen";
+        readonly english: "Thuringia";
+    };
+};
+/** An ISO 3166-2:DE state code (`BW`, `BY`, `BE`, …). */
+export type GermanStateCode = keyof typeof DE_BUNDESLAENDER;
+/** Type-predicate for an ISO 3166-2:DE state code. Case-insensitive. */
+export declare function isGermanStateCode(input: unknown): input is GermanStateCode;
+/**
+ * Name (native German, English exonym, or common alias) → ISO 3166-2:DE code, lowercase-keyed.
+ * Includes the everyday aliases a parser actually meets: `NRW` for Nordrhein-Westfalen, `Bavaria`
+ * for Bayern, `Saxony` for Sachsen. The point is resolver region-matching: a German parse emits a
+ * region surface form, and the eval needs to map it to a code without a US-USPS-shaped matcher.
+ */
+export declare const DE_STATE_NAME_TO_CODE: ReadonlyMap<string, GermanStateCode>;
+/**
+ * Resolve a German state surface form (code, German name, English name, or common alias) to its ISO
+ * 3166-2:DE code. Returns null when unrecognized.
+ */
+export declare function lookupGermanState(input: string | null | undefined): GermanStateCode | null;
+//# sourceMappingURL=bundesland.d.ts.map

package/out/de/bundesland.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundesland.d.ts","sourceRoot":"","sources":["../../de/bundesland.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,+FAA+F;AAC/F,MAAM,WAAW,eAAe;IAC/B,uFAAuF;IACvF,IAAI,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,4CAA4C;IAC5C,OAAO,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBuB,CAAA;AAEpD,yDAAyD;AACzD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,gBAAgB,CAAA;AAI3D,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE1E;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAqBnE,CAAA;AAEJ;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,GAAG,IAAI,CAK1F"}

package/out/de/bundesland.js

@@ -0,0 +1,81 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The 16 German federal states (Bundesländer), keyed by their ISO 3166-2:DE subdivision code.
+ *
+ *   The US analog is `us/state.ts`. The informative difference: a US state's two-letter code (`CA`)
+ *   is the USPS abbreviation people actually write in an address, whereas a German address almost
+ *   never carries the Bundesland at all — it is `PLZ City`, and the state is inferred. So these
+ *   codes matter for resolver region-matching and display, not for parsing the surface string.
+ */
+/**
+ * ISO 3166-2:DE code → state info, for all 16 Bundesländer. Codes are the official subdivision
+ * codes minus the `DE-` prefix.
+ */
+export const DE_BUNDESLAENDER = {
+    BW: { code: "BW", name: "Baden-Württemberg", english: "Baden-Württemberg" },
+    BY: { code: "BY", name: "Bayern", english: "Bavaria" },
+    BE: { code: "BE", name: "Berlin", english: "Berlin" },
+    BB: { code: "BB", name: "Brandenburg", english: "Brandenburg" },
+    HB: { code: "HB", name: "Bremen", english: "Bremen" },
+    HH: { code: "HH", name: "Hamburg", english: "Hamburg" },
+    HE: { code: "HE", name: "Hessen", english: "Hesse" },
+    MV: { code: "MV", name: "Mecklenburg-Vorpommern", english: "Mecklenburg-Western Pomerania" },
+    NI: { code: "NI", name: "Niedersachsen", english: "Lower Saxony" },
+    NW: { code: "NW", name: "Nordrhein-Westfalen", english: "North Rhine-Westphalia" },
+    RP: { code: "RP", name: "Rheinland-Pfalz", english: "Rhineland-Palatinate" },
+    SL: { code: "SL", name: "Saarland", english: "Saarland" },
+    SN: { code: "SN", name: "Sachsen", english: "Saxony" },
+    ST: { code: "ST", name: "Sachsen-Anhalt", english: "Saxony-Anhalt" },
+    SH: { code: "SH", name: "Schleswig-Holstein", english: "Schleswig-Holstein" },
+    TH: { code: "TH", name: "Thüringen", english: "Thuringia" },
+};
+const STATE_CODE_SET = new Set(Object.keys(DE_BUNDESLAENDER));
+/** Type-predicate for an ISO 3166-2:DE state code. Case-insensitive. */
+export function isGermanStateCode(input) {
+    return typeof input === "string" && STATE_CODE_SET.has(input.toUpperCase());
+}
+/**
+ * Name (native German, English exonym, or common alias) → ISO 3166-2:DE code, lowercase-keyed.
+ * Includes the everyday aliases a parser actually meets: `NRW` for Nordrhein-Westfalen, `Bavaria`
+ * for Bayern, `Saxony` for Sachsen. The point is resolver region-matching: a German parse emits a
+ * region surface form, and the eval needs to map it to a code without a US-USPS-shaped matcher.
+ */
+export const DE_STATE_NAME_TO_CODE = (() => {
+    const out = new Map();
+    for (const code of Object.keys(DE_BUNDESLAENDER)) {
+        const info = DE_BUNDESLAENDER[code];
+        out.set(info.name.toLowerCase(), code);
+        out.set(info.english.toLowerCase(), code);
+        out.set(code.toLowerCase(), code);
+    }
+    // Everyday aliases that are neither the ISO code nor the canonical name.
+    const aliases = {
+        nrw: "NW",
+        "nordrhein westfalen": "NW",
+        "baden wurttemberg": "BW",
+        "baden-wuerttemberg": "BW",
+        "baden wuerttemberg": "BW",
+        thueringen: "TH",
+        "freie hansestadt bremen": "HB",
+        "freie und hansestadt hamburg": "HH",
+    };
+    for (const [alias, code] of Object.entries(aliases))
+        out.set(alias, code);
+    return out;
+})();
+/**
+ * Resolve a German state surface form (code, German name, English name, or common alias) to its ISO
+ * 3166-2:DE code. Returns null when unrecognized.
+ */
+export function lookupGermanState(input) {
+    if (!input || typeof input !== "string")
+        return null;
+    const key = input.trim().toLowerCase();
+    if (STATE_CODE_SET.has(key.toUpperCase()))
+        return key.toUpperCase();
+    return DE_STATE_NAME_TO_CODE.get(key) ?? null;
+}
+//# sourceMappingURL=bundesland.js.map

package/out/de/bundesland.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundesland.js","sourceRoot":"","sources":["../../de/bundesland.ts"],"names":[],"mappings":"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"}

package/out/de/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The German address system (Deutsche Post / ISO 3166-2:DE): street types, postal codes
+ *   (Postleitzahl), and the federal states (Bundesländer).
+ */
+export * from "./bundesland.js";
+export * from "./postleitzahl.js";
+export * from "./street-type.js";
+//# sourceMappingURL=index.d.ts.map

package/out/de/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../de/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA"}

package/out/de/index.js

@@ -0,0 +1,12 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The German address system (Deutsche Post / ISO 3166-2:DE): street types, postal codes
+ *   (Postleitzahl), and the federal states (Bundesländer).
+ */
+export * from "./bundesland.js";
+export * from "./postleitzahl.js";
+export * from "./street-type.js";
+//# sourceMappingURL=index.js.map

package/out/de/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../de/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA"}

package/out/de/postleitzahl.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   German postal codes (Postleitzahl, PLZ): the branded type, the shape, normalization, and the
+ *   first-digit → Leitzone geographic prior.
+ *
+ *   The US analog is `us/zipcode.ts`, and the contrast is the informative part. A US ZIP's first
+ *   digit maps cleanly to a band of states (`StateAbbreviationZipCodePrefixRecord`). A German PLZ's
+ *   first digit maps to a **Leitzone** — a postal routing region that deliberately **crosses
+ *   Bundesland borders** (Leitzone 6 covers Frankfurt in Hessen, Saarbrücken in Saarland, and Mainz
+ *   in Rheinland-Pfalz). So the PLZ prior narrows geography, but it does NOT narrow the state the
+ *   way a US ZIP does — a lesson for any code that tries to derive a German region from a postcode
+ *   alone.
+ */
+import type { Tagged } from "type-fest";
+/**
+ * A German postal code: five digits since the 1993 reform (`12623`). A bare 5-digit string, same
+ * shape as a US ZIP or a French code postal — disambiguation is the parser's job, not the shape's.
+ *
+ * @category Postal
+ * @type string
+ * @title Postleitzahl
+ * @pattern ^\d{5}$
+ */
+export type Postleitzahl = Tagged<string, "Postleitzahl">;
+/** The PLZ shape: exactly five digits. */
+export declare const PLZ_PATTERN: RegExp;
+/**
+ * Normalize a PLZ surface form to the bare five digits: strip the `D-` / `DE-` country courtesy
+ * prefix and surrounding whitespace (`D-68161` → `68161`). Returns null if the result is not a
+ * PLZ.
+ */
+export declare function normalizePLZ(raw: unknown): Postleitzahl | null;
+/** Type-predicate for a (normalized) German postal code. */
+export declare function isPostleitzahl(input: unknown): input is Postleitzahl;
+/** A PLZ Leitzone first digit. */
+export type LeitzoneDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/** Per-Leitzone descriptor: the routing region and a few anchor cities (coarse, postal not admin). */
+export interface LeitzoneInfo {
+    digit: LeitzoneDigit;
+    /** Coarse routing-region label. */
+    region: string;
+    /** Well-known anchor cities in the zone (illustrative, not exhaustive). */
+    cities: readonly string[];
+}
+/**
+ * PLZ first digit → Leitzone. A coarse, postal-routing prior: these zones cross Bundesland borders,
+ * so the label is "which corner of Germany", not "which state". Anchor cities are the safe,
+ * well-known way to pin a zone without over-claiming a boundary the routing geography does not
+ * actually follow.
+ */
+export declare const PLZ_LEITZONEN: {
+    readonly 0: {
+        readonly digit: 0;
+        readonly region: "Sachsen / Ostthüringen";
+        readonly cities: readonly ["Leipzig", "Dresden", "Chemnitz"];
+    };
+    readonly 1: {
+        readonly digit: 1;
+        readonly region: "Berlin / Brandenburg / Mecklenburg-Vorpommern";
+        readonly cities: readonly ["Berlin", "Potsdam", "Rostock"];
+    };
+    readonly 2: {
+        readonly digit: 2;
+        readonly region: "Hamburg / Schleswig-Holstein / Bremen";
+        readonly cities: readonly ["Hamburg", "Kiel", "Bremen"];
+    };
+    readonly 3: {
+        readonly digit: 3;
+        readonly region: "Niedersachsen / Nordhessen";
+        readonly cities: readonly ["Hannover", "Braunschweig", "Kassel"];
+    };
+    readonly 4: {
+        readonly digit: 4;
+        readonly region: "nördliches Nordrhein-Westfalen";
+        readonly cities: readonly ["Düsseldorf", "Dortmund", "Münster"];
+    };
+    readonly 5: {
+        readonly digit: 5;
+        readonly region: "südliches NRW / nördliches Rheinland-Pfalz";
+        readonly cities: readonly ["Köln", "Bonn", "Aachen"];
+    };
+    readonly 6: {
+        readonly digit: 6;
+        readonly region: "Südhessen / Rheinland-Pfalz / Saarland";
+        readonly cities: readonly ["Frankfurt am Main", "Mainz", "Saarbrücken"];
+    };
+    readonly 7: {
+        readonly digit: 7;
+        readonly region: "Baden-Württemberg";
+        readonly cities: readonly ["Stuttgart", "Karlsruhe", "Freiburg"];
+    };
+    readonly 8: {
+        readonly digit: 8;
+        readonly region: "südliches Bayern";
+        readonly cities: readonly ["München", "Augsburg", "Ingolstadt"];
+    };
+    readonly 9: {
+        readonly digit: 9;
+        readonly region: "nördliches Bayern / Oberpfalz";
+        readonly cities: readonly ["Nürnberg", "Würzburg", "Regensburg"];
+    };
+};
+/** The Leitzone of a PLZ (its first digit's routing region), or null if the input is not a PLZ. */
+export declare function leitzoneOf(plz: unknown): LeitzoneInfo | null;
+//# sourceMappingURL=postleitzahl.d.ts.map

package/out/de/postleitzahl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postleitzahl.d.ts","sourceRoot":"","sources":["../../de/postleitzahl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAEzD,0CAA0C;AAC1C,eAAO,MAAM,WAAW,QAAY,CAAA;AAEpC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAI9D;AAED,4DAA4D;AAC5D,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED,kCAAkC;AAClC,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAEjE,sGAAsG;AACtG,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,aAAa,CAAA;IACpB,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAA;IACd,2EAA2E;IAC3E,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAe8B,CAAA;AAExD,mGAAmG;AACnG,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,GAAG,IAAI,CAI5D"}

package/out/de/postleitzahl.js

@@ -0,0 +1,63 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   German postal codes (Postleitzahl, PLZ): the branded type, the shape, normalization, and the
+ *   first-digit → Leitzone geographic prior.
+ *
+ *   The US analog is `us/zipcode.ts`, and the contrast is the informative part. A US ZIP's first
+ *   digit maps cleanly to a band of states (`StateAbbreviationZipCodePrefixRecord`). A German PLZ's
+ *   first digit maps to a **Leitzone** — a postal routing region that deliberately **crosses
+ *   Bundesland borders** (Leitzone 6 covers Frankfurt in Hessen, Saarbrücken in Saarland, and Mainz
+ *   in Rheinland-Pfalz). So the PLZ prior narrows geography, but it does NOT narrow the state the
+ *   way a US ZIP does — a lesson for any code that tries to derive a German region from a postcode
+ *   alone.
+ */
+/** The PLZ shape: exactly five digits. */
+export const PLZ_PATTERN = /^\d{5}$/;
+/**
+ * Normalize a PLZ surface form to the bare five digits: strip the `D-` / `DE-` country courtesy
+ * prefix and surrounding whitespace (`D-68161` → `68161`). Returns null if the result is not a
+ * PLZ.
+ */
+export function normalizePLZ(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const s = raw.trim().toUpperCase().replace(/^DE?-/, "");
+    return PLZ_PATTERN.test(s) ? s : null;
+}
+/** Type-predicate for a (normalized) German postal code. */
+export function isPostleitzahl(input) {
+    return typeof input === "string" && PLZ_PATTERN.test(input);
+}
+/**
+ * PLZ first digit → Leitzone. A coarse, postal-routing prior: these zones cross Bundesland borders,
+ * so the label is "which corner of Germany", not "which state". Anchor cities are the safe,
+ * well-known way to pin a zone without over-claiming a boundary the routing geography does not
+ * actually follow.
+ */
+export const PLZ_LEITZONEN = {
+    0: { digit: 0, region: "Sachsen / Ostthüringen", cities: ["Leipzig", "Dresden", "Chemnitz"] },
+    1: { digit: 1, region: "Berlin / Brandenburg / Mecklenburg-Vorpommern", cities: ["Berlin", "Potsdam", "Rostock"] },
+    2: { digit: 2, region: "Hamburg / Schleswig-Holstein / Bremen", cities: ["Hamburg", "Kiel", "Bremen"] },
+    3: { digit: 3, region: "Niedersachsen / Nordhessen", cities: ["Hannover", "Braunschweig", "Kassel"] },
+    4: { digit: 4, region: "nördliches Nordrhein-Westfalen", cities: ["Düsseldorf", "Dortmund", "Münster"] },
+    5: { digit: 5, region: "südliches NRW / nördliches Rheinland-Pfalz", cities: ["Köln", "Bonn", "Aachen"] },
+    6: {
+        digit: 6,
+        region: "Südhessen / Rheinland-Pfalz / Saarland",
+        cities: ["Frankfurt am Main", "Mainz", "Saarbrücken"],
+    },
+    7: { digit: 7, region: "Baden-Württemberg", cities: ["Stuttgart", "Karlsruhe", "Freiburg"] },
+    8: { digit: 8, region: "südliches Bayern", cities: ["München", "Augsburg", "Ingolstadt"] },
+    9: { digit: 9, region: "nördliches Bayern / Oberpfalz", cities: ["Nürnberg", "Würzburg", "Regensburg"] },
+};
+/** The Leitzone of a PLZ (its first digit's routing region), or null if the input is not a PLZ. */
+export function leitzoneOf(plz) {
+    const normalized = normalizePLZ(plz);
+    if (!normalized)
+        return null;
+    return PLZ_LEITZONEN[Number(normalized[0])];
+}
+//# sourceMappingURL=postleitzahl.js.map

package/out/de/postleitzahl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postleitzahl.js","sourceRoot":"","sources":["../../de/postleitzahl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAeH,0CAA0C;AAC1C,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAA;AAEpC;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,GAAY;IACxC,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;IACvD,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAE,CAAkB,CAAC,CAAC,CAAC,IAAI,CAAA;AACxD,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,cAAc,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AAC5D,CAAC;AAcD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC5B,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,wBAAwB,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE;IAC7F,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,+CAA+C,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE;IAClH,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,uCAAuC,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE;IACvG,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,4BAA4B,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE;IACrG,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,gCAAgC,EAAE,MAAM,EAAE,CAAC,YAAY,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE;IACxG,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,4CAA4C,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE;IACzG,CAAC,EAAE;QACF,KAAK,EAAE,CAAC;QACR,MAAM,EAAE,wCAAwC;QAChD,MAAM,EAAE,CAAC,mBAAmB,EAAE,OAAO,EAAE,aAAa,CAAC;KACrD;IACD,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,CAAC,EAAE;IAC5F,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,YAAY,CAAC,EAAE;IAC1F,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,+BAA+B,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,CAAC,EAAE;CACjD,CAAA;AAExD,mGAAmG;AACnG,MAAM,UAAU,UAAU,CAAC,GAAY;IACtC,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,CAAA;IACpC,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAC5B,OAAO,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAkB,CAAC,CAAA;AAC7D,CAAC"}

package/out/de/street-type.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   German street types (Straßentypen).
+ *
+ *   The US analog is `us/street-suffix.ts`, and the structural contrast is the whole lesson of this
+ *   file. A US street type is a separate trailing word with a USPS-standardized abbreviation (`Main
+ *   Street` → `ST`). A German street type is overwhelmingly an **agglutinative suffix** fused onto
+ *   the name (`Straußstraße`, `Karl-Liebknecht-Straße`), with only one abbreviation in real use
+ *   (`Str.`). So detection is by suffix, not by a trailing token, and there is no Pub-28-style
+ *   abbreviation table to salvage.
+ *
+ *   The second lesson is the collision, the German cousin of the US `KY` = Key / Kentucky problem.
+ *   Many German PLACE names end in what look like street suffixes — `-berg` (Nürnberg), `-burg`
+ *   (Hamburg), `-dorf` (Düsseldorf), `-feld`, `-hof`, `-stadt`. If those counted as street markers,
+ *   the city token in a `PLZ City` segment would masquerade as a street and wrongly flag the
+ *   postcode as a house number. {@link DE_STREET_SUFFIXES} is therefore a curated, place-name-SAFE
+ *   set — the suffixes that are distinctively streets and (almost) never the tail of a city name.
+ */
+/**
+ * Canonical German street type → recognized written variants (including the `Str.` abbreviation and
+ * the `ß`/`ss` spelling split). The full reference table, used for synthesis/expansion. For the "is
+ * this token part of a street" test, use {@link DE_STREET_SUFFIXES} / {@link isGermanStreetToken},
+ * which exclude the place-name-colliding suffixes.
+ */
+export declare const DE_STREET_TYPE_VARIANTS: {
+    readonly Straße: readonly ["Str.", "Str", "Strasse"];
+    readonly Weg: readonly [];
+    readonly Platz: readonly ["Pl.", "Pl"];
+    readonly Gasse: readonly [];
+    readonly Allee: readonly [];
+    readonly Ring: readonly [];
+    readonly Damm: readonly [];
+    readonly Ufer: readonly [];
+    readonly Steig: readonly [];
+    readonly Stieg: readonly [];
+    readonly Pfad: readonly [];
+    readonly Chaussee: readonly ["Chaussée"];
+    readonly Twiete: readonly [];
+};
+/** A canonical German street type (e.g. `Straße`, `Weg`, `Platz`). */
+export type GermanStreetType = keyof typeof DE_STREET_TYPE_VARIANTS;
+/**
+ * Place-name-SAFE street suffixes for "is this token part of a street" detection, lowercase, with
+ * the `ß`/`ss` split spelled out and `str` for the `Str.` abbreviation. Deliberately EXCLUDES the
+ * suffixes that also end German city names — `-berg`, `-burg`, `-dorf`, `-feld`, `-hof`, `-stadt`,
+ * `-heim`, `-bach`, `-tal` — so a city token in a `PLZ City` segment is not mistaken for a street.
+ */
+export declare const DE_STREET_SUFFIXES: readonly ["straße", "strasse", "str", "weg", "platz", "gasse", "allee", "ring", "damm", "ufer", "steig", "stieg", "pfad", "chaussee", "twiete"];
+/**
+ * True when a token reads as (part of) a German street: it ends with one of the place-name-safe
+ * {@link DE_STREET_SUFFIXES}. Handles both the fused compound (`Straußstraße` → ends `straße`) and
+ * the standalone type word or `Str.` abbreviation (`Platz`, `Str` → end `platz` / `str`).
+ */
+export declare function isGermanStreetToken(token: unknown): boolean;
+//# sourceMappingURL=street-type.d.ts.map

package/out/de/street-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"street-type.d.ts","sourceRoot":"","sources":["../../de/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;CAckB,CAAA;AAEtD,sEAAsE;AACtE,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,uBAAuB,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,iJAgBrB,CAAA;AAEV;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK3D"}

package/out/de/street-type.js

@@ -0,0 +1,79 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   German street types (Straßentypen).
+ *
+ *   The US analog is `us/street-suffix.ts`, and the structural contrast is the whole lesson of this
+ *   file. A US street type is a separate trailing word with a USPS-standardized abbreviation (`Main
+ *   Street` → `ST`). A German street type is overwhelmingly an **agglutinative suffix** fused onto
+ *   the name (`Straußstraße`, `Karl-Liebknecht-Straße`), with only one abbreviation in real use
+ *   (`Str.`). So detection is by suffix, not by a trailing token, and there is no Pub-28-style
+ *   abbreviation table to salvage.
+ *
+ *   The second lesson is the collision, the German cousin of the US `KY` = Key / Kentucky problem.
+ *   Many German PLACE names end in what look like street suffixes — `-berg` (Nürnberg), `-burg`
+ *   (Hamburg), `-dorf` (Düsseldorf), `-feld`, `-hof`, `-stadt`. If those counted as street markers,
+ *   the city token in a `PLZ City` segment would masquerade as a street and wrongly flag the
+ *   postcode as a house number. {@link DE_STREET_SUFFIXES} is therefore a curated, place-name-SAFE
+ *   set — the suffixes that are distinctively streets and (almost) never the tail of a city name.
+ */
+/**
+ * Canonical German street type → recognized written variants (including the `Str.` abbreviation and
+ * the `ß`/`ss` spelling split). The full reference table, used for synthesis/expansion. For the "is
+ * this token part of a street" test, use {@link DE_STREET_SUFFIXES} / {@link isGermanStreetToken},
+ * which exclude the place-name-colliding suffixes.
+ */
+export const DE_STREET_TYPE_VARIANTS = {
+    Straße: ["Str.", "Str", "Strasse"],
+    Weg: [],
+    Platz: ["Pl.", "Pl"],
+    Gasse: [],
+    Allee: [],
+    Ring: [],
+    Damm: [],
+    Ufer: [],
+    Steig: [],
+    Stieg: [],
+    Pfad: [],
+    Chaussee: ["Chaussée"],
+    Twiete: [],
+};
+/**
+ * Place-name-SAFE street suffixes for "is this token part of a street" detection, lowercase, with
+ * the `ß`/`ss` split spelled out and `str` for the `Str.` abbreviation. Deliberately EXCLUDES the
+ * suffixes that also end German city names — `-berg`, `-burg`, `-dorf`, `-feld`, `-hof`, `-stadt`,
+ * `-heim`, `-bach`, `-tal` — so a city token in a `PLZ City` segment is not mistaken for a street.
+ */
+export const DE_STREET_SUFFIXES = [
+    "straße",
+    "strasse",
+    "str",
+    "weg",
+    "platz",
+    "gasse",
+    "allee",
+    "ring",
+    "damm",
+    "ufer",
+    "steig",
+    "stieg",
+    "pfad",
+    "chaussee",
+    "twiete",
+];
+/**
+ * True when a token reads as (part of) a German street: it ends with one of the place-name-safe
+ * {@link DE_STREET_SUFFIXES}. Handles both the fused compound (`Straußstraße` → ends `straße`) and
+ * the standalone type word or `Str.` abbreviation (`Platz`, `Str` → end `platz` / `str`).
+ */
+export function isGermanStreetToken(token) {
+    if (typeof token !== "string")
+        return false;
+    const t = token.toLowerCase().replace(/[^a-zà-ÿß]/g, "");
+    if (t.length < 3)
+        return false;
+    return DE_STREET_SUFFIXES.some((s) => t.endsWith(s));
+}
+//# sourceMappingURL=street-type.js.map

package/out/de/street-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"street-type.js","sourceRoot":"","sources":["../../de/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACtC,MAAM,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC;IAClC,GAAG,EAAE,EAAE;IACP,KAAK,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,EAAE;IACR,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;IACR,QAAQ,EAAE,CAAC,UAAU,CAAC;IACtB,MAAM,EAAE,EAAE;CAC2C,CAAA;AAKtD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IACjC,QAAQ;IACR,SAAS;IACT,KAAK;IACL,KAAK;IACL,OAAO;IACP,OAAO;IACP,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,OAAO;IACP,OAAO;IACP,MAAM;IACN,UAAU;IACV,QAAQ;CACC,CAAA;AAEV;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAc;IACjD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAC3C,MAAM,CAAC,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAA;IACxD,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IAC9B,OAAO,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AACrD,CAAC"}

package/out/fr/code-postal.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   French postal codes (code postal): the branded type, the shape, normalization, and the
+ *   first-two-digits → département mapping — the cleanest postcode→admin prior of the three
+ *   systems.
+ *
+ *   The informative contrast across `us/zipcode.ts`, `de/postleitzahl.ts`, and here:
+ *
+ *   - A US ZIP's first digit maps to a loose BAND of states.
+ *   - A German PLZ's first digit maps to a Leitzone that CROSSES Bundesland borders.
+ *   - A French code postal's first TWO digits ARE the département number directly (`75008` → 75, Paris;
+ *       `13001` → 13, Bouches-du-Rhône). So the French prefix pins the actual admin unit, and the
+ *       région follows from the département. It is the tightest of the three.
+ *
+ *   The exceptions are the interesting part: Corsica shares prefix `20` across two départements (`2A`
+ *   Corse-du-Sud / `2B` Haute-Corse, resolved by the rest of the code), and the overseas DOM use a
+ *   THREE-digit prefix (`971`–`976`). `departementOfCodePostal` handles both. Two further
+ *   real-world caveats it does NOT try to model: a handful of communes sit under a neighbouring
+ *   département's code (e.g. some `05`/`04` border villages), and a CEDEX code can carry a
+ *   large-volume-mail prefix that differs from the geographic one — both rare enough to leave to
+ *   the gazetteer.
+ */
+import type { Tagged } from "type-fest";
+import { type DepartementCode, type DepartementInfo } from "./departement.js";
+import { type FrenchRegionInfo } from "./region.js";
+/**
+ * A French postal code: five digits (`75008`). Same shape as a US ZIP or a German PLZ — the shape
+ * alone does not disambiguate the country.
+ *
+ * @category Postal
+ * @type string
+ * @title Code postal
+ * @pattern ^\d{5}$
+ */
+export type CodePostal = Tagged<string, "CodePostal">;
+/** The code-postal shape: exactly five digits. */
+export declare const CODE_POSTAL_PATTERN: RegExp;
+/**
+ * Normalize a code-postal surface form to the bare five digits: strip an `F-` country courtesy
+ * prefix and surrounding whitespace (`F-75008` → `75008`). Returns null if the result is not five
+ * digits.
+ */
+export declare function normalizeCodePostal(raw: unknown): CodePostal | null;
+/** Type-predicate for a (normalized) French postal code. */
+export declare function isCodePostal(input: unknown): input is CodePostal;
+/**
+ * The département code a postal code belongs to. The clean rule plus its two exceptions:
+ *
+ * - `20xxx` → Corsica. The split is by the rest of the code: roughly `20000`–`20199` → `2A` (Ajaccio
+ *   side), `20200`+ → `2B` (Bastia side). Approximate at the boundary, exact for the bulk.
+ * - `970`–`976`xx → an overseas DOM, keyed by the three-digit prefix (`971`–`974`, `976`).
+ * - Otherwise the first two digits are the département number.
+ *
+ * Returns null for a prefix with no département (e.g. `975`/`977`/`98x` collectivities, or a
+ * malformed code).
+ */
+export declare function departementOfCodePostal(codePostal: unknown): DepartementCode | null;
+/** The full département record a postal code resolves to (name + région), or null. */
+export declare function departementForCodePostal(codePostal: unknown): DepartementInfo | null;
+/**
+ * The région a postal code resolves to, via its département; null if the code maps to no
+ * département.
+ */
+export declare function regionForCodePostal(codePostal: unknown): FrenchRegionInfo | null;
+//# sourceMappingURL=code-postal.d.ts.map

package/out/fr/code-postal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-postal.d.ts","sourceRoot":"","sources":["../../fr/code-postal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,EAAmB,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAC9F,OAAO,EAAc,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;AAErD,kDAAkD;AAClD,eAAO,MAAM,mBAAmB,QAAY,CAAA;AAE5C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAInE;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAenF;AAED,sFAAsF;AACtF,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAEpF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAGhF"}