@mailwoman/codex 4.0.0

package/out/ca/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The Canadian address system (Canada Post / ISO 3166-2:CA): bilingual street types, alphanumeric
+ *   postal codes, and the provinces and territories.
+ */
+export * from "./postal-code.js";
+export * from "./province.js";
+export * from "./street-type.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../ca/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}

package/out/ca/index.js

@@ -0,0 +1,12 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The Canadian address system (Canada Post / ISO 3166-2:CA): bilingual street types, alphanumeric
+ *   postal codes, and the provinces and territories.
+ */
+export * from "./postal-code.js";
+export * from "./province.js";
+export * from "./street-type.js";
+//# sourceMappingURL=index.js.map

package/out/ca/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ca/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}

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

@@ -0,0 +1,74 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Canadian postal codes: the branded type, the shape, normalization, and the FSA-letter →
+ *   province/territory prior — the only ALPHANUMERIC postcode of the systems the codex models.
+ *
+ *   The informative contrast across `us/zipcode.ts`, `de/postleitzahl.ts`, `fr/code-postal.ts`, and
+ *   here:
+ *
+ *   - A US ZIP is numeric; its first digit maps to a loose BAND of states.
+ *   - A German PLZ is numeric; its first digit maps to a Leitzone that CROSSES Bundesland borders.
+ *   - A French code postal is numeric; its first TWO digits ARE the département.
+ *   - A Canadian postal code is `A1A 1A1` — Letter Digit Letter, then Digit Letter Digit — and its
+ *       first LETTER pins the province or territory directly (`M` → Ontario, `H` → Quebec, `V` →
+ *       British Columbia). So like the French prefix it is a clean admin prior, but it does the job
+ *       with a single ALPHA character rather than digits.
+ *
+ *   The clean rule has two wrinkles worth knowing. `X` is SHARED by the Northwest Territories and
+ *   Nunavut (no single letter splits them), so `provinceOfPostalCode` returns an array there. And
+ *   the large provinces span SEVERAL letters: Ontario alone owns `K L M N P`, Quebec owns `G H J`.
+ *   The first three characters form the FSA (Forward Sortation Area); the last three are the LDU
+ *   (Local Delivery Unit). A FSA whose SECOND character (the first digit) is `0` is a RURAL area —
+ *   the bridge to the wider, lower-density delivery zones.
+ */
+import type { Tagged } from "type-fest";
+import type { CanadianProvinceCode } from "./province.js";
+/**
+ * A Canadian postal code: `A1A 1A1`. Six alphanumeric characters in a strict
+ * Letter-Digit-Letter-Digit-Letter-Digit pattern, conventionally written with a single space after
+ * the third. Unlike the other systems' bare five digits, the shape alone already says "Canada".
+ *
+ * @category Postal
+ * @type string
+ * @title Postal Code
+ * @pattern ^[ABCEGHJ-NPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?\d[ABCEGHJ-NPRSTV-Z]\d$
+ */
+export type PostalCode = Tagged<string, "CaPostalCode">;
+/**
+ * The Canadian postal-code shape. The valid FIRST letters exclude `D F I O Q U W Z` (never used to
+ * open a postcode); the interior letters additionally exclude `D F I O Q U` (the visually ambiguous
+ * ones). The space between FSA and LDU is optional in the raw form.
+ */
+export declare const CA_POSTAL_CODE_PATTERN: RegExp;
+/**
+ * Normalize a postal-code surface form to canonical `A1A 1A1`: uppercase and ensure exactly one
+ * space between the FSA (first three chars) and the LDU (last three) — `K1A0B1` → `K1A 0B1`, `k1a
+ * 0b1` → `K1A 0B1`. Returns null if the input is not a valid Canadian postal code.
+ */
+export declare function normalizeCaPostalCode(raw: unknown): PostalCode | null;
+/** Type-predicate for a Canadian postal code (accepts the spaced or unspaced surface form). */
+export declare function isCaPostalCode(input: unknown): input is PostalCode;
+/**
+ * FSA first letter → province/territory. Clean (one province per letter) except `X`, shared by the
+ * Northwest Territories and Nunavut, and the large provinces that span several letters: Ontario
+ * owns `K L M N P` and Quebec owns `G H J`. Letters `D F I O Q U W Z` never open a Canadian
+ * postcode and so do not appear here.
+ */
+export declare const FSA_LETTER_TO_PROVINCE: Record<string, CanadianProvinceCode | CanadianProvinceCode[]>;
+/**
+ * The province/territory a postal code belongs to, via its FSA first letter. Returns the single
+ * code for the clean letters, the `["NT", "NU"]` pair for the shared `X`, and null if the input is
+ * not a valid Canadian postal code (or its first letter has no province, which the pattern already
+ * forbids).
+ */
+export declare function provinceOfPostalCode(postalCode: unknown): CanadianProvinceCode | CanadianProvinceCode[] | null;
+/**
+ * True when a postal code is RURAL: its SECOND character (the FSA's first digit) is `0`. Canada
+ * Post uses a `0` in that position to mark the lower-density delivery zones (rural routes, small
+ * communities) — the contrast with the urban `1`–`9` FSAs. Returns false for a non-code.
+ */
+export declare function isRuralPostalCode(pc: unknown): boolean;
+//# sourceMappingURL=postal-code.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postal-code.d.ts","sourceRoot":"","sources":["../../ca/postal-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAEzD;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAEvD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAsE,CAAA;AAEzG;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAMrE;AAED,+FAA+F;AAC/F,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAElE;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG,oBAAoB,EAAE,CAmBhG,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,oBAAoB,GAAG,oBAAoB,EAAE,GAAG,IAAI,CAI9G;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAItD"}

package/out/ca/postal-code.js

@@ -0,0 +1,100 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Canadian postal codes: the branded type, the shape, normalization, and the FSA-letter →
+ *   province/territory prior — the only ALPHANUMERIC postcode of the systems the codex models.
+ *
+ *   The informative contrast across `us/zipcode.ts`, `de/postleitzahl.ts`, `fr/code-postal.ts`, and
+ *   here:
+ *
+ *   - A US ZIP is numeric; its first digit maps to a loose BAND of states.
+ *   - A German PLZ is numeric; its first digit maps to a Leitzone that CROSSES Bundesland borders.
+ *   - A French code postal is numeric; its first TWO digits ARE the département.
+ *   - A Canadian postal code is `A1A 1A1` — Letter Digit Letter, then Digit Letter Digit — and its
+ *       first LETTER pins the province or territory directly (`M` → Ontario, `H` → Quebec, `V` →
+ *       British Columbia). So like the French prefix it is a clean admin prior, but it does the job
+ *       with a single ALPHA character rather than digits.
+ *
+ *   The clean rule has two wrinkles worth knowing. `X` is SHARED by the Northwest Territories and
+ *   Nunavut (no single letter splits them), so `provinceOfPostalCode` returns an array there. And
+ *   the large provinces span SEVERAL letters: Ontario alone owns `K L M N P`, Quebec owns `G H J`.
+ *   The first three characters form the FSA (Forward Sortation Area); the last three are the LDU
+ *   (Local Delivery Unit). A FSA whose SECOND character (the first digit) is `0` is a RURAL area —
+ *   the bridge to the wider, lower-density delivery zones.
+ */
+/**
+ * The Canadian postal-code shape. The valid FIRST letters exclude `D F I O Q U W Z` (never used to
+ * open a postcode); the interior letters additionally exclude `D F I O Q U` (the visually ambiguous
+ * ones). The space between FSA and LDU is optional in the raw form.
+ */
+export const CA_POSTAL_CODE_PATTERN = /^[ABCEGHJ-NPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?\d[ABCEGHJ-NPRSTV-Z]\d$/i;
+/**
+ * Normalize a postal-code surface form to canonical `A1A 1A1`: uppercase and ensure exactly one
+ * space between the FSA (first three chars) and the LDU (last three) — `K1A0B1` → `K1A 0B1`, `k1a
+ * 0b1` → `K1A 0B1`. Returns null if the input is not a valid Canadian postal code.
+ */
+export function normalizeCaPostalCode(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const compact = raw.trim().toUpperCase().replace(/\s+/g, "");
+    if (compact.length !== 6)
+        return null;
+    const spaced = `${compact.slice(0, 3)} ${compact.slice(3)}`;
+    return CA_POSTAL_CODE_PATTERN.test(spaced) ? spaced : null;
+}
+/** Type-predicate for a Canadian postal code (accepts the spaced or unspaced surface form). */
+export function isCaPostalCode(input) {
+    return typeof input === "string" && CA_POSTAL_CODE_PATTERN.test(input);
+}
+/**
+ * FSA first letter → province/territory. Clean (one province per letter) except `X`, shared by the
+ * Northwest Territories and Nunavut, and the large provinces that span several letters: Ontario
+ * owns `K L M N P` and Quebec owns `G H J`. Letters `D F I O Q U W Z` never open a Canadian
+ * postcode and so do not appear here.
+ */
+export const FSA_LETTER_TO_PROVINCE = {
+    A: "NL",
+    B: "NS",
+    C: "PE",
+    E: "NB",
+    G: "QC",
+    H: "QC",
+    J: "QC",
+    K: "ON",
+    L: "ON",
+    M: "ON",
+    N: "ON",
+    P: "ON",
+    R: "MB",
+    S: "SK",
+    T: "AB",
+    V: "BC",
+    X: ["NT", "NU"],
+    Y: "YT",
+};
+/**
+ * The province/territory a postal code belongs to, via its FSA first letter. Returns the single
+ * code for the clean letters, the `["NT", "NU"]` pair for the shared `X`, and null if the input is
+ * not a valid Canadian postal code (or its first letter has no province, which the pattern already
+ * forbids).
+ */
+export function provinceOfPostalCode(postalCode) {
+    const normalized = normalizeCaPostalCode(postalCode);
+    if (!normalized)
+        return null;
+    return FSA_LETTER_TO_PROVINCE[normalized[0]] ?? null;
+}
+/**
+ * True when a postal code is RURAL: its SECOND character (the FSA's first digit) is `0`. Canada
+ * Post uses a `0` in that position to mark the lower-density delivery zones (rural routes, small
+ * communities) — the contrast with the urban `1`–`9` FSAs. Returns false for a non-code.
+ */
+export function isRuralPostalCode(pc) {
+    const normalized = normalizeCaPostalCode(pc);
+    if (!normalized)
+        return false;
+    return normalized[1] === "0";
+}
+//# sourceMappingURL=postal-code.js.map

package/out/ca/postal-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postal-code.js","sourceRoot":"","sources":["../../ca/postal-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAiBH;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,mEAAmE,CAAA;AAEzG;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IACjD,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IAC5D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IACrC,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAA;IAC3D,OAAO,sBAAsB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAqB,CAAC,CAAC,CAAC,IAAI,CAAA;AAC3E,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,cAAc,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACvE,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAkE;IACpG,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,IAAI;IACP,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;IACf,CAAC,EAAE,IAAI;CACP,CAAA;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,UAAmB;IACvD,MAAM,UAAU,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAA;IACpD,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAC5B,OAAO,sBAAsB,CAAC,UAAU,CAAC,CAAC,CAAE,CAAC,IAAI,IAAI,CAAA;AACtD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAAW;IAC5C,MAAM,UAAU,GAAG,qBAAqB,CAAC,EAAE,CAAC,CAAA;IAC5C,IAAI,CAAC,UAAU;QAAE,OAAO,KAAK,CAAA;IAC7B,OAAO,UAAU,CAAC,CAAC,CAAC,KAAK,GAAG,CAAA;AAC7B,CAAC"}

package/out/ca/province.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The 13 Canadian provinces and territories (10 provinces + 3 territories), keyed by their ISO
+ *   3166-2:CA code.
+ *
+ *   The informative contrast with `de/bundesland.ts` and `us/state.ts`: a Canadian subdivision is
+ *   officially BILINGUAL, so each unit carries two equally-canonical names — an English one and a
+ *   French one — and the gap between them is wide (`Nova Scotia` / `Nouvelle-Écosse`, `British
+ *   Columbia` / `Colombie-Britannique`). That mirrors the German English-exonym pattern (`Bavaria`
+ *   / `Bayern`), except here the French name is not a foreign exonym but a co-official form a real
+ *   address can be written in. And like a US two-letter state code, the ISO code (`ON`, `QC`, `BC`)
+ *   is the abbreviation people actually write on the address line — so unlike German or French
+ *   regions, the Canadian code IS a surface form, not just a resolver key.
+ */
+/** Per-province record: ISO 3166-2:CA code, English name, and the co-official French name. */
+export interface CanadianProvinceInfo {
+    /** ISO 3166-2:CA subdivision code without the `CA-` prefix (e.g. `ON` for `CA-ON`). */
+    code: string;
+    /** English name (e.g. `Quebec`). */
+    name: string;
+    /** Co-official French name (e.g. `Québec`). */
+    french: string;
+}
+/**
+ * ISO 3166-2:CA code → province/territory info, for all 13 subdivisions (10 provinces + 3
+ * territories). Codes are the official subdivision codes minus the `CA-` prefix.
+ */
+export declare const CA_PROVINCES: {
+    readonly AB: {
+        readonly code: "AB";
+        readonly name: "Alberta";
+        readonly french: "Alberta";
+    };
+    readonly BC: {
+        readonly code: "BC";
+        readonly name: "British Columbia";
+        readonly french: "Colombie-Britannique";
+    };
+    readonly MB: {
+        readonly code: "MB";
+        readonly name: "Manitoba";
+        readonly french: "Manitoba";
+    };
+    readonly NB: {
+        readonly code: "NB";
+        readonly name: "New Brunswick";
+        readonly french: "Nouveau-Brunswick";
+    };
+    readonly NL: {
+        readonly code: "NL";
+        readonly name: "Newfoundland and Labrador";
+        readonly french: "Terre-Neuve-et-Labrador";
+    };
+    readonly NS: {
+        readonly code: "NS";
+        readonly name: "Nova Scotia";
+        readonly french: "Nouvelle-Écosse";
+    };
+    readonly NT: {
+        readonly code: "NT";
+        readonly name: "Northwest Territories";
+        readonly french: "Territoires du Nord-Ouest";
+    };
+    readonly NU: {
+        readonly code: "NU";
+        readonly name: "Nunavut";
+        readonly french: "Nunavut";
+    };
+    readonly ON: {
+        readonly code: "ON";
+        readonly name: "Ontario";
+        readonly french: "Ontario";
+    };
+    readonly PE: {
+        readonly code: "PE";
+        readonly name: "Prince Edward Island";
+        readonly french: "Île-du-Prince-Édouard";
+    };
+    readonly QC: {
+        readonly code: "QC";
+        readonly name: "Quebec";
+        readonly french: "Québec";
+    };
+    readonly SK: {
+        readonly code: "SK";
+        readonly name: "Saskatchewan";
+        readonly french: "Saskatchewan";
+    };
+    readonly YT: {
+        readonly code: "YT";
+        readonly name: "Yukon";
+        readonly french: "Yukon";
+    };
+};
+/** An ISO 3166-2:CA province/territory code (`AB`, `ON`, `QC`, …). */
+export type CanadianProvinceCode = keyof typeof CA_PROVINCES;
+/** Type-predicate for an ISO 3166-2:CA province/territory code. Case-insensitive. */
+export declare function isCanadianProvinceCode(input: unknown): input is CanadianProvinceCode;
+/**
+ * Folded province name (English or French) / code → ISO 3166-2:CA code. Built diacritic-insensitive
+ * so both co-official names map regardless of accents: `Québec`, `Quebec`, and an unaccented
+ * `Nouvelle-Ecosse` all resolve. The two-name design is the Canadian wrinkle — unlike the German
+ * lookup's English exonym, the French form here is a name a real address may legitimately use.
+ */
+export declare const CA_PROVINCE_NAME_TO_CODE: ReadonlyMap<string, CanadianProvinceCode>;
+/**
+ * Resolve a Canadian province/territory surface form (ISO code, English name, or French name,
+ * accents optional) to its ISO code; null if unknown.
+ */
+export declare function lookupCanadianProvince(input: string | null | undefined): CanadianProvinceCode | null;
+//# sourceMappingURL=province.d.ts.map

package/out/ca/province.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"province.d.ts","sourceRoot":"","sources":["../../ca/province.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,8FAA8F;AAC9F,MAAM,WAAW,oBAAoB;IACpC,uFAAuF;IACvF,IAAI,EAAE,MAAM,CAAA;IACZ,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAA;CACd;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcgC,CAAA;AAEzD,sEAAsE;AACtE,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,YAAY,CAAA;AAI5D,qFAAqF;AACrF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAEpF;AAYD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAS3E,CAAA;AAEJ;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,oBAAoB,GAAG,IAAI,CAKpG"}

package/out/ca/province.js

@@ -0,0 +1,79 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The 13 Canadian provinces and territories (10 provinces + 3 territories), keyed by their ISO
+ *   3166-2:CA code.
+ *
+ *   The informative contrast with `de/bundesland.ts` and `us/state.ts`: a Canadian subdivision is
+ *   officially BILINGUAL, so each unit carries two equally-canonical names — an English one and a
+ *   French one — and the gap between them is wide (`Nova Scotia` / `Nouvelle-Écosse`, `British
+ *   Columbia` / `Colombie-Britannique`). That mirrors the German English-exonym pattern (`Bavaria`
+ *   / `Bayern`), except here the French name is not a foreign exonym but a co-official form a real
+ *   address can be written in. And like a US two-letter state code, the ISO code (`ON`, `QC`, `BC`)
+ *   is the abbreviation people actually write on the address line — so unlike German or French
+ *   regions, the Canadian code IS a surface form, not just a resolver key.
+ */
+/**
+ * ISO 3166-2:CA code → province/territory info, for all 13 subdivisions (10 provinces + 3
+ * territories). Codes are the official subdivision codes minus the `CA-` prefix.
+ */
+export const CA_PROVINCES = {
+    AB: { code: "AB", name: "Alberta", french: "Alberta" },
+    BC: { code: "BC", name: "British Columbia", french: "Colombie-Britannique" },
+    MB: { code: "MB", name: "Manitoba", french: "Manitoba" },
+    NB: { code: "NB", name: "New Brunswick", french: "Nouveau-Brunswick" },
+    NL: { code: "NL", name: "Newfoundland and Labrador", french: "Terre-Neuve-et-Labrador" },
+    NS: { code: "NS", name: "Nova Scotia", french: "Nouvelle-Écosse" },
+    NT: { code: "NT", name: "Northwest Territories", french: "Territoires du Nord-Ouest" },
+    NU: { code: "NU", name: "Nunavut", french: "Nunavut" },
+    ON: { code: "ON", name: "Ontario", french: "Ontario" },
+    PE: { code: "PE", name: "Prince Edward Island", french: "Île-du-Prince-Édouard" },
+    QC: { code: "QC", name: "Quebec", french: "Québec" },
+    SK: { code: "SK", name: "Saskatchewan", french: "Saskatchewan" },
+    YT: { code: "YT", name: "Yukon", french: "Yukon" },
+};
+const PROVINCE_CODE_SET = new Set(Object.keys(CA_PROVINCES));
+/** Type-predicate for an ISO 3166-2:CA province/territory code. Case-insensitive. */
+export function isCanadianProvinceCode(input) {
+    return typeof input === "string" && PROVINCE_CODE_SET.has(input.toUpperCase());
+}
+/** Strip diacritics + lowercase so `Québec`, `Quebec`, and `quebec` all key alike. */
+function foldName(s) {
+    return s
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+/**
+ * Folded province name (English or French) / code → ISO 3166-2:CA code. Built diacritic-insensitive
+ * so both co-official names map regardless of accents: `Québec`, `Quebec`, and an unaccented
+ * `Nouvelle-Ecosse` all resolve. The two-name design is the Canadian wrinkle — unlike the German
+ * lookup's English exonym, the French form here is a name a real address may legitimately use.
+ */
+export const CA_PROVINCE_NAME_TO_CODE = (() => {
+    const out = new Map();
+    for (const code of Object.keys(CA_PROVINCES)) {
+        const info = CA_PROVINCES[code];
+        out.set(foldName(info.name), code);
+        out.set(foldName(info.french), code);
+        out.set(code.toLowerCase(), code);
+    }
+    return out;
+})();
+/**
+ * Resolve a Canadian province/territory surface form (ISO code, English name, or French name,
+ * accents optional) to its ISO code; null if unknown.
+ */
+export function lookupCanadianProvince(input) {
+    if (!input || typeof input !== "string")
+        return null;
+    const upper = input.trim().toUpperCase();
+    if (PROVINCE_CODE_SET.has(upper))
+        return upper;
+    return CA_PROVINCE_NAME_TO_CODE.get(foldName(input)) ?? null;
+}
+//# sourceMappingURL=province.js.map

package/out/ca/province.js.map

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

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

@@ -0,0 +1,57 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Canadian street types and directionals — BILINGUAL, because Canada Post recognizes both English
+ *   and French forms on the same national network.
+ *
+ *   The informative contrast with `us/street-suffix.ts`, `de/street-type.ts`, and `fr/voie.ts`:
+ *
+ *   - US — a trailing word with a USPS-standardized abbreviation (`Main Street` → `ST`).
+ *   - German — a fused TRAILING suffix (`Hauptstraße`).
+ *   - French — a LEADING standalone word (`Rue de la Paix`).
+ *   - Canadian — BOTH at once. An English street puts the type LAST (`Maple Avenue`, `Sunset
+ *       Crescent`); a French street puts it FIRST (`Rue Sainte-Catherine`, `Boulevard
+ *       René-Lévesque`). So {@link isCanadianStreetWord} matches a whole token against EITHER
+ *       vocabulary and stays position-agnostic — it cannot assume a side the way the
+ *       single-language files do.
+ *
+ *   The directionals carry the same bilingual twist, and one trap inside it: French `Ouest`
+ *   abbreviates to `O`, not `W`. A naive English-only matcher reading `Rue Sherbrooke O` would miss
+ *   the quadrant entirely. {@link CA_DIRECTIONALS} spells out the French abbreviations so `O` =
+ *   Ouest = West is recognized.
+ */
+/**
+ * English Canadian street-type words (Canada Post's recognized set, lowercase). Appear as the
+ * TRAILING token of an English street name (`Maple Avenue`, `Sunset Crescent`).
+ */
+export declare const CA_STREET_TYPES_EN: ReadonlySet<string>;
+/**
+ * French Canadian street-type words (Canada Post's recognized set, lowercase, accent-bearing).
+ * Appear as the LEADING token of a French street name (`Rue Sainte-Catherine`, `Chemin du Roy`).
+ * Folded for matching in {@link isCanadianStreetWord}, so `Côte`/`cote` and `Allée`/`allee` key
+ * alike.
+ */
+export declare const CA_STREET_TYPES_FR: ReadonlySet<string>;
+/**
+ * True when a token is a Canadian street-type word in EITHER language (case- and
+ * accent-insensitive) — `Street`, `Crescent`, `Rue`, `Chemin`, `Côte`. Position-agnostic, because
+ * an English type trails the name and a French type leads it; the matcher cannot lean on a side.
+ */
+export declare function isCanadianStreetWord(token: unknown): boolean;
+/**
+ * Bilingual directional words → canonical compass letter. Covers the bare letters (`N S E W`), the
+ * full English words (`North`/`South`/`East`/`West`), and the full French words
+ * (`Nord`/`Sud`/`Est`/`Ouest`). The bilingual twist is `O`: French `Ouest` abbreviates to `O`, NOT
+ * `W`, so an English-only matcher silently drops the quadrant on a French address line. Keys are
+ * folded (lowercase, accent-free); values are the English compass letter.
+ */
+export declare const CA_DIRECTIONALS: Record<string, "N" | "S" | "E" | "W">;
+/**
+ * True when a token is a Canadian directional in either language (case- and accent-insensitive) —
+ * `N`, `NW`, `Nord`, `Ouest`, `O`. Compound English quadrants (`NW`, `SE`) are accepted by
+ * decomposing into their single-letter halves; the lone French `O` resolves to West.
+ */
+export declare function isCanadianDirectional(token: unknown): boolean;
+//# sourceMappingURL=street-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"street-type.d.ts","sourceRoot":"","sources":["../../ca/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CA8BjD,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAmBjD,CAAA;AAmBF;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI5D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAcjE,CAAA;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAW7D"}

package/out/ca/street-type.js

@@ -0,0 +1,156 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Canadian street types and directionals — BILINGUAL, because Canada Post recognizes both English
+ *   and French forms on the same national network.
+ *
+ *   The informative contrast with `us/street-suffix.ts`, `de/street-type.ts`, and `fr/voie.ts`:
+ *
+ *   - US — a trailing word with a USPS-standardized abbreviation (`Main Street` → `ST`).
+ *   - German — a fused TRAILING suffix (`Hauptstraße`).
+ *   - French — a LEADING standalone word (`Rue de la Paix`).
+ *   - Canadian — BOTH at once. An English street puts the type LAST (`Maple Avenue`, `Sunset
+ *       Crescent`); a French street puts it FIRST (`Rue Sainte-Catherine`, `Boulevard
+ *       René-Lévesque`). So {@link isCanadianStreetWord} matches a whole token against EITHER
+ *       vocabulary and stays position-agnostic — it cannot assume a side the way the
+ *       single-language files do.
+ *
+ *   The directionals carry the same bilingual twist, and one trap inside it: French `Ouest`
+ *   abbreviates to `O`, not `W`. A naive English-only matcher reading `Rue Sherbrooke O` would miss
+ *   the quadrant entirely. {@link CA_DIRECTIONALS} spells out the French abbreviations so `O` =
+ *   Ouest = West is recognized.
+ */
+/**
+ * English Canadian street-type words (Canada Post's recognized set, lowercase). Appear as the
+ * TRAILING token of an English street name (`Maple Avenue`, `Sunset Crescent`).
+ */
+export const CA_STREET_TYPES_EN = new Set([
+    "street",
+    "avenue",
+    "boulevard",
+    "drive",
+    "road",
+    "crescent",
+    "court",
+    "place",
+    "lane",
+    "way",
+    "trail",
+    "terrace",
+    "close",
+    "circle",
+    "square",
+    "heights",
+    "grove",
+    "gardens",
+    "hill",
+    "park",
+    "row",
+    "walk",
+    "green",
+    "bay",
+    "cove",
+    "gate",
+    "point",
+    "ridge",
+    "view",
+]);
+/**
+ * French Canadian street-type words (Canada Post's recognized set, lowercase, accent-bearing).
+ * Appear as the LEADING token of a French street name (`Rue Sainte-Catherine`, `Chemin du Roy`).
+ * Folded for matching in {@link isCanadianStreetWord}, so `Côte`/`cote` and `Allée`/`allee` key
+ * alike.
+ */
+export const CA_STREET_TYPES_FR = new Set([
+    "rue",
+    "avenue",
+    "boulevard",
+    "chemin",
+    "côte",
+    "place",
+    "impasse",
+    "allée",
+    "croissant",
+    "montée",
+    "rang",
+    "ruelle",
+    "voie",
+    "passage",
+    "carré",
+    "terrasse",
+    "promenade",
+    "sentier",
+]);
+/** Strip diacritics + lowercase so `Côte`/`cote`, `Allée`/`allee`, `Crescent`/`crescent` key alike. */
+function foldToken(s) {
+    return s
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z]/g, "");
+}
+/** The English + French street-type vocabularies, both folded, for one position-agnostic lookup. */
+const STREET_WORD_SET = (() => {
+    const out = new Set();
+    for (const w of CA_STREET_TYPES_EN)
+        out.add(foldToken(w));
+    for (const w of CA_STREET_TYPES_FR)
+        out.add(foldToken(w));
+    return out;
+})();
+/**
+ * True when a token is a Canadian street-type word in EITHER language (case- and
+ * accent-insensitive) — `Street`, `Crescent`, `Rue`, `Chemin`, `Côte`. Position-agnostic, because
+ * an English type trails the name and a French type leads it; the matcher cannot lean on a side.
+ */
+export function isCanadianStreetWord(token) {
+    if (typeof token !== "string")
+        return false;
+    const t = foldToken(token);
+    return t.length > 0 && STREET_WORD_SET.has(t);
+}
+/**
+ * Bilingual directional words → canonical compass letter. Covers the bare letters (`N S E W`), the
+ * full English words (`North`/`South`/`East`/`West`), and the full French words
+ * (`Nord`/`Sud`/`Est`/`Ouest`). The bilingual twist is `O`: French `Ouest` abbreviates to `O`, NOT
+ * `W`, so an English-only matcher silently drops the quadrant on a French address line. Keys are
+ * folded (lowercase, accent-free); values are the English compass letter.
+ */
+export const CA_DIRECTIONALS = {
+    n: "N",
+    north: "N",
+    nord: "N",
+    s: "S",
+    south: "S",
+    sud: "S",
+    e: "E",
+    east: "E",
+    est: "E",
+    w: "W",
+    west: "W",
+    ouest: "W",
+    o: "W", // French Ouest abbreviates to O, not W — the bilingual trap.
+};
+/**
+ * True when a token is a Canadian directional in either language (case- and accent-insensitive) —
+ * `N`, `NW`, `Nord`, `Ouest`, `O`. Compound English quadrants (`NW`, `SE`) are accepted by
+ * decomposing into their single-letter halves; the lone French `O` resolves to West.
+ */
+export function isCanadianDirectional(token) {
+    if (typeof token !== "string")
+        return false;
+    const t = foldToken(token);
+    if (t.length === 0)
+        return false;
+    if (t in CA_DIRECTIONALS)
+        return true;
+    // Compound English quadrants like NW / SE / NE / SW: each half must be a single-letter directional.
+    if (t.length === 2) {
+        const isLetter = (h) => h === "n" || h === "s" || h === "e" || h === "w";
+        return isLetter(t[0]) && isLetter(t[1]);
+    }
+    return false;
+}
+//# sourceMappingURL=street-type.js.map

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

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