@mailwoman/codex 8.1.0 → 8.3.0

package/address-system-conventions.ts

@@ -36,6 +36,10 @@ export interface AddressSystemConventions {
 	readonly postcodePattern?: RegExp
 }
 
+/**
+ * Per-address-system ordering and formatting conventions — which component leads a line, whether the postcode precedes
+ * the locality, and so on. Keyed by address system rather than country, since several share one.
+ */
 export const ADDRESS_SYSTEM_CONVENTIONS: Partial<Record<SystemCode, AddressSystemConventions>> = {
 	/**
 	 * France (La Poste / AFNOR NF Z 10-011): the street TYPE is a LEADING particle of the street name ("Rue de Rivoli",
@@ -79,7 +83,9 @@ export const ADDRESS_SYSTEM_CONVENTIONS: Partial<Record<SystemCode, AddressSyste
 	},
 }
 
-/** Look up conventions for a system. Absent row = no constraints KNOWN (parse unconstrained). */
+/**
+ * Look up conventions for a system. Absent row = no constraints KNOWN (parse unconstrained).
+ */
 export function conventionsForSystem(system: SystemCode | null | undefined): AddressSystemConventions | null {
 	if (!system) return null
 

package/au/delivery-service.ts

@@ -40,11 +40,17 @@
  * @see {@link https://auspost.com.au/business/business-admin/po-boxes-and-locked-bags Australia Post — business PO Boxes, GPO Boxes and Locked Bags}
  */
 
-/** One Postal Delivery Type row from the Australia Post AMAS abbreviation table. */
+/**
+ * One Postal Delivery Type row from the Australia Post AMAS abbreviation table.
+ */
 export interface AuDeliveryServiceDesignator {
-	/** The full Postal Delivery Type name, verbatim from the table (uppercase as published). */
+	/**
+	 * The full Postal Delivery Type name, verbatim from the table (uppercase as published).
+	 */
 	name: string
-	/** The standard abbreviation — the surface form written on mail ("GPO BOX", "LOCKED BAG"). */
+	/**
+	 * The standard abbreviation — the surface form written on mail ("GPO BOX", "LOCKED BAG").
+	 */
 	abbreviation: string
 	/**
 	 * Whether the designator "must have an associated number for a match to occur" (AMAS rule; exceptions are Care of
@@ -81,7 +87,9 @@ export const AU_DELIVERY_SERVICE_DESIGNATORS = [
 	{ name: "ROADSIDE MAIL SERVICE", abbreviation: "RMS", requiresNumber: true, legacy: true },
 ] as const satisfies readonly AuDeliveryServiceDesignator[]
 
-/** A canonical Australia Post Postal Delivery Type abbreviation. */
+/**
+ * A canonical Australia Post Postal Delivery Type abbreviation.
+ */
 export type AuDeliveryServiceAbbreviation = (typeof AU_DELIVERY_SERVICE_DESIGNATORS)[number]["abbreviation"]
 
 /**
@@ -112,8 +120,10 @@ const DESIGNATOR_INFO = new Map<AuDeliveryServiceAbbreviation, { requiresNumber:
 	AU_DELIVERY_SERVICE_DESIGNATORS.map((d) => [d.abbreviation, { requiresNumber: d.requiresNumber, legacy: d.legacy }])
 )
 
-// One anchored regex per designator: phrase + (required|optional) identifier. The id shape matches
-// the US slice ([\dA-Za-z][\dA-Za-z-]*); MS additionally requires a digit-leading id (see above).
+/**
+ * One anchored regex per designator: phrase + (required|optional) identifier. The id shape matches the US slice
+ * ([\dA-Za-z][\dA-Za-z-]*); MS additionally requires a digit-leading id (see above).
+ */
 const MATCHERS: ReadonlyArray<{ abbreviation: AuDeliveryServiceAbbreviation; re: RegExp }> = DESIGNATOR_PATTERNS.map(
 	([abbreviation, src]) => {
 		const { requiresNumber } = DESIGNATOR_INFO.get(abbreviation)!
@@ -124,15 +134,25 @@ const MATCHERS: ReadonlyArray<{ abbreviation: AuDeliveryServiceAbbreviation; re:
 	}
 )
 
-/** Result of an AU delivery-service parse. */
+/**
+ * Result of an AU delivery-service parse.
+ */
 export interface AuDeliveryServiceMatch {
-	/** The designator phrase as it appeared ("G.P.O. Box", "Locked Bag"). */
+	/**
+	 * The designator phrase as it appeared ("G.P.O. Box", "Locked Bag").
+	 */
 	matched: string
-	/** The canonical Postal Delivery Type abbreviation ("GPO BOX", "LOCKED BAG"). */
+	/**
+	 * The canonical Postal Delivery Type abbreviation ("GPO BOX", "LOCKED BAG").
+	 */
 	designator: AuDeliveryServiceAbbreviation
-	/** The delivery-service number when present ("9999", "4600"). */
+	/**
+	 * The delivery-service number when present ("9999", "4600").
+	 */
 	id?: string
-	/** True when the designator is an AMAS-only legacy form (see the table). */
+	/**
+	 * True when the designator is an AMAS-only legacy form (see the table).
+	 */
 	legacy: boolean
 }
 
@@ -161,7 +181,9 @@ export function matchAuDeliveryService(input: unknown): AuDeliveryServiceMatch |
 	return null
 }
 
-/** Type-predicate: does the input look like a standalone AU delivery-service address line? */
+/**
+ * Type-predicate: does the input look like a standalone AU delivery-service address line?
+ */
 export function isAuDeliveryService(input: unknown): boolean {
 	return matchAuDeliveryService(input) !== null
 }

package/au/level-designator.ts

@@ -45,11 +45,17 @@
  * identifier from standalone ones.
  */
 export interface AuLevelDesignator {
-	/** AS 4590.1 LEVEL_TYPE_CODE (the GNAF / AMAS internal code). */
+	/**
+	 * AS 4590.1 LEVEL_TYPE_CODE (the GNAF / AMAS internal code).
+	 */
 	code: string
-	/** Full descriptive name (AMAS table label). */
+	/**
+	 * Full descriptive name (AMAS table label).
+	 */
 	name: string
-	/** The approved AMAS surface abbreviation written on mail ("L", "B", "M"). */
+	/**
+	 * The approved AMAS surface abbreviation written on mail ("L", "B", "M").
+	 */
 	abbreviation: string
 	/**
 	 * True when the designator takes a numeric or alphanumeric floor identifier after it (`LEVEL 3`, `BASEMENT 2`). False
@@ -74,7 +80,9 @@ export const AU_LEVEL_DESIGNATORS = [
 	{ code: "RT", name: "ROOFTOP", abbreviation: "RT", requiresNumber: false },
 ] as const satisfies readonly AuLevelDesignator[]
 
-/** A canonical AS 4590.1 LEVEL_TYPE_CODE. */
+/**
+ * A canonical AS 4590.1 LEVEL_TYPE_CODE.
+ */
 export type AuLevelCode = (typeof AU_LEVEL_DESIGNATORS)[number]["code"]
 
 /**
@@ -107,7 +115,7 @@ export const AU_LEVEL_DESIGNATOR_LOOKUP: ReadonlyMap<string, AuLevelCode> = (()
 	for (const { code } of AU_LEVEL_DESIGNATORS) {
 		const variants = AU_LEVEL_DESIGNATOR_VARIANTS[code]
 
-		if (!variants || variants.length === 0) {
+		if (!variants || !variants.length) {
 			throw new Error(`[codex/au/level-designator] code "${code}" has no variants in AU_LEVEL_DESIGNATOR_VARIANTS`)
 		}
 
@@ -119,6 +127,7 @@ export const AU_LEVEL_DESIGNATOR_LOOKUP: ReadonlyMap<string, AuLevelCode> = (()
 			}
 		}
 	}
+
 	const out = new Map<string, AuLevelCode>()
 
 	for (const { code } of AU_LEVEL_DESIGNATORS) {
@@ -134,30 +143,43 @@ export const AU_LEVEL_DESIGNATOR_LOOKUP: ReadonlyMap<string, AuLevelCode> = (()
 	return out
 })()
 
-/** Result of an AU level designator parse. */
+/**
+ * Result of an AU level designator parse.
+ */
 export interface AuLevelDesignatorMatch {
-	/** The code as it appeared in the input ("Level", "L", "lvl"). */
+	/**
+	 * The code as it appeared in the input ("Level", "L", "lvl").
+	 */
 	matched: string
-	/** The canonical AS 4590.1 LEVEL_TYPE_CODE ("L", "B", "M"). */
+	/**
+	 * The canonical AS 4590.1 LEVEL_TYPE_CODE ("L", "B", "M").
+	 */
 	code: AuLevelCode
-	/** The floor identifier when present ("3", "G", "B2"). */
+	/**
+	 * The floor identifier when present ("3", "G", "B2").
+	 */
 	identifier?: string
 }
 
-// One regex per level code. Multi-word variants ("LOWER GROUND", "GROUND FLOOR") are matched
-// before their shorter constituents by ordering the variant list longest-first within each code.
+/**
+ * One regex per level code. Multi-word variants ("LOWER GROUND", "GROUND FLOOR") are matched before their shorter
+ * constituents by ordering the variant list longest-first within each code.
+ */
 const LEVEL_MATCHERS: ReadonlyArray<{ code: AuLevelCode; requiresNumber: boolean; re: RegExp }> = (() => {
 	const rows: Array<{ code: AuLevelCode; requiresNumber: boolean; re: RegExp }> = []
 
 	for (const { code, requiresNumber } of AU_LEVEL_DESIGNATORS) {
 		const variants = [...AU_LEVEL_DESIGNATOR_VARIANTS[code]]
-			.sort((a, b) => b.length - a.length)
-			.map((v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\s+/g, String.raw`\s+`))
+			.toSorted((a, b) => b.length - a.length)
+			.map((v) => v.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&").replaceAll(/\s+/g, String.raw`\s+`))
+
 		const alts = variants.join("|")
+
 		// Identifier: optional alphanumeric (B2, 12, G). requiresNumber=true → identifier required.
 		const tail = requiresNumber
 			? String.raw`\s+([A-Za-z]?\d[\dA-Za-z-]*|\d[\dA-Za-z-]*)`
 			: String.raw`(?:\s+([A-Za-z]?\d[\dA-Za-z-]*|\d[\dA-Za-z-]*))?`
+
 		rows.push({ code, requiresNumber, re: new RegExp(String.raw`^\s*(${alts})${tail}\s*$`, "i") })
 	}
 
@@ -188,7 +210,9 @@ export function matchAuLevelDesignator(input: unknown): AuLevelDesignatorMatch |
 	return null
 }
 
-/** Type-predicate: does the input look like a standalone AU level designator phrase? */
+/**
+ * Type-predicate: does the input look like a standalone AU level designator phrase?
+ */
 export function isAuLevelDesignator(input: unknown): boolean {
 	return matchAuLevelDesignator(input) !== null
 }

package/au/postcode.ts

@@ -34,10 +34,14 @@ import type { Tagged } from "type-fest"
  */
 export type AuPostcode = Tagged<string, "AuPostcode">
 
-/** The AU postcode shape: exactly four digits. */
+/**
+ * The AU postcode shape: exactly four digits.
+ */
 export const AU_POSTCODE_PATTERN = /^\d{4}$/
 
-/** Normalize a postcode surface form (trim only — AU has no country-prefix courtesy form). */
+/**
+ * Normalize a postcode surface form (trim only — AU has no country-prefix courtesy form).
+ */
 export function normalizeAuPostcode(raw: unknown): AuPostcode | null {
 	if (typeof raw !== "string") return null
 	const s = raw.trim()
@@ -45,7 +49,9 @@ export function normalizeAuPostcode(raw: unknown): AuPostcode | null {
 	return AU_POSTCODE_PATTERN.test(s) ? (s as AuPostcode) : null
 }
 
-/** Type-predicate for a (normalized) Australian postcode. */
+/**
+ * Type-predicate for a (normalized) Australian postcode.
+ */
 export function isAuPostcode(input: unknown): input is AuPostcode {
 	return typeof input === "string" && AU_POSTCODE_PATTERN.test(input)
 }

package/au/state.ts

@@ -14,7 +14,9 @@
  * @see {@link https://www.iso.org/obp/ui/#iso:code:3166:AU ISO 3166-2:AU}
  */
 
-/** State/territory abbreviation → full name (ISO 3166-2:AU subdivision set). */
+/**
+ * State/territory abbreviation → full name (ISO 3166-2:AU subdivision set).
+ */
 export const AU_STATE_ABBREVIATIONS = {
 	ACT: "Australian Capital Territory",
 	NSW: "New South Wales",
@@ -26,10 +28,14 @@ export const AU_STATE_ABBREVIATIONS = {
 	WA: "Western Australia",
 } as const satisfies Record<string, string>
 
-/** An Australian state/territory abbreviation as written on the last address line. */
+/**
+ * An Australian state/territory abbreviation as written on the last address line.
+ */
 export type AuStateAbbreviation = keyof typeof AU_STATE_ABBREVIATIONS
 
-/** Type-predicate for an AU state/territory abbreviation (case-insensitive). */
+/**
+ * Type-predicate for an AU state/territory abbreviation (case-insensitive).
+ */
 export function isAuStateAbbreviation(input: unknown): input is AuStateAbbreviation {
 	return typeof input === "string" && Object.hasOwn(AU_STATE_ABBREVIATIONS, input.toUpperCase())
 }

package/ca/postal-code.ts

@@ -29,6 +29,11 @@ import type { Tagged } from "type-fest"
 
 import type { CanadianProvinceCode } from "./province.ts"
 
+/**
+ * Characters in a Canadian postal code once spaces are stripped: `A1A1A1`.
+ */
+const POSTAL_CODE_LENGTH = 6
+
 /**
  * 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
@@ -55,15 +60,17 @@ export const CA_POSTAL_CODE_PATTERN = /^[ABCEGHJ-NPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?
  */
 export function normalizeCaPostalCode(raw: unknown): PostalCode | null {
 	if (typeof raw !== "string") return null
-	const compact = raw.trim().toUpperCase().replace(/\s+/g, "")
+	const compact = raw.trim().toUpperCase().replaceAll(/\s+/g, "")
 
-	if (compact.length !== 6) return null
+	if (compact.length !== POSTAL_CODE_LENGTH) return null
 	const spaced = `${compact.slice(0, 3)} ${compact.slice(3)}`
 
 	return CA_POSTAL_CODE_PATTERN.test(spaced) ? (spaced as PostalCode) : null
 }
 
-/** Type-predicate for a Canadian postal code (accepts the spaced or unspaced surface form). */
+/**
+ * Type-predicate for a Canadian postal code (accepts the spaced or unspaced surface form).
+ */
 export function isCaPostalCode(input: unknown): input is PostalCode {
 	return typeof input === "string" && CA_POSTAL_CODE_PATTERN.test(input)
 }

package/ca/province.ts

@@ -16,13 +16,21 @@
  *   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. */
+/**
+ * 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`). */
+	/**
+	 * ISO 3166-2:CA subdivision code without the `CA-` prefix (e.g. `ON` for `CA-ON`).
+	 */
 	code: string
-	/** English name (e.g. `Quebec`). */
+	/**
+	 * English name (e.g. `Quebec`).
+	 */
 	name: string
-	/** Co-official French name (e.g. `Québec`). */
+	/**
+	 * Co-official French name (e.g. `Québec`).
+	 */
 	french: string
 }
 
@@ -46,23 +54,29 @@ export const CA_PROVINCES = {
 	YT: { code: "YT", name: "Yukon", french: "Yukon" },
 } as const satisfies Record<string, CanadianProvinceInfo>
 
-/** An ISO 3166-2:CA province/territory code (`AB`, `ON`, `QC`, …). */
+/**
+ * An ISO 3166-2:CA province/territory code (`AB`, `ON`, `QC`, …).
+ */
 export type CanadianProvinceCode = keyof typeof CA_PROVINCES
 
 const PROVINCE_CODE_SET: ReadonlySet<string> = new Set(Object.keys(CA_PROVINCES))
 
-/** Type-predicate for an ISO 3166-2:CA province/territory code. Case-insensitive. */
+/**
+ * Type-predicate for an ISO 3166-2:CA province/territory code. Case-insensitive.
+ */
 export function isCanadianProvinceCode(input: unknown): input is CanadianProvinceCode {
 	return typeof input === "string" && PROVINCE_CODE_SET.has(input.toUpperCase())
 }
 
-/** Strip diacritics + lowercase so `Québec`, `Quebec`, and `quebec` all key alike. */
+/**
+ * Strip diacritics + lowercase so `Québec`, `Quebec`, and `quebec` all key alike.
+ */
 function foldName(s: string): string {
 	return s
 		.toLowerCase()
 		.normalize("NFD")
-		.replace(/[\u0300-\u036f]/g, "")
-		.replace(/[^a-z0-9]+/g, " ")
+		.replaceAll(/[\u0300-\u036F]/g, "")
+		.replaceAll(/[^a-z0-9]+/g, " ")
 		.trim()
 }
 

package/ca/street-type.ts

@@ -85,16 +85,20 @@ export const CA_STREET_TYPES_FR: ReadonlySet<string> = new Set([
 	"sentier",
 ])
 
-/** Strip diacritics + lowercase so `Côte`/`cote`, `Allée`/`allee`, `Crescent`/`crescent` key alike. */
+/**
+ * Strip diacritics + lowercase so `Côte`/`cote`, `Allée`/`allee`, `Crescent`/`crescent` key alike.
+ */
 function foldToken(s: string): string {
 	return s
 		.toLowerCase()
 		.normalize("NFD")
-		.replace(/[\u0300-\u036f]/g, "")
-		.replace(/[^a-z]/g, "")
+		.replaceAll(/[\u0300-\u036F]/g, "")
+		.replaceAll(/[^a-z]/g, "")
 }
 
-/** The English + French street-type vocabularies, both folded, for one position-agnostic lookup. */
+/**
+ * The English + French street-type vocabularies, both folded, for one position-agnostic lookup.
+ */
 const STREET_WORD_SET: ReadonlySet<string> = (() => {
 	const out = new Set<string>()
 
@@ -152,7 +156,7 @@ export function isCanadianDirectional(token: unknown): boolean {
 	if (typeof token !== "string") return false
 	const t = foldToken(token)
 
-	if (t.length === 0) return false
+	if (!t.length) return false
 
 	if (t in CA_DIRECTIONALS) return true
 

package/country/country.ts

@@ -11,8 +11,10 @@
  *   the other codex matchers (street-suffix, directional, po-box).
  */
 
-import { Alpha3ToCountryRecord, CountryISO2, type CountryISO3 } from "./codes.ts"
-import { type CountryName } from "./names.ts"
+import { Alpha3ToCountryRecord, CountryISO2 } from "./codes.ts"
+import type { CountryName } from "./names.ts"
+
+export { Alpha3ToCountryRecord, CountryISO2, type CountryISO3 } from "./codes.ts"
 
 /**
  * Common real-address surface forms per ISO 3166-1 alpha-2, **canonical English name first** then endonym +
@@ -41,7 +43,9 @@ export const COUNTRY_SURFACE_FORMS = {
 
 export type CountrySurfaceISO2 = keyof typeof COUNTRY_SURFACE_FORMS
 
-/** Alpha-2 → canonical English name (inverted from the salvaged CountryISO2 enum). */
+/**
+ * Alpha-2 → canonical English name (inverted from the salvaged CountryISO2 enum).
+ */
 export const ISO2_TO_NAME: ReadonlyMap<string, CountryName> = new Map(
 	Object.entries(CountryISO2).map(([name, code]) => [code as string, name as CountryName])
 )
@@ -53,6 +57,7 @@ export const ISO2_TO_NAME: ReadonlyMap<string, CountryName> = new Map(
  */
 export const COUNTRY_LOOKUP: ReadonlyMap<string, string> = (() => {
 	const out = new Map<string, string>()
+
 	const put = (k: string, iso2: string) => {
 		const key = k.trim().toLowerCase()
 
@@ -89,7 +94,9 @@ export const COUNTRY_LOOKUP: ReadonlyMap<string, string> = (() => {
 	return out
 })()
 
-/** Result of a country match: the alpha-2 code, the canonical English name, and the matched surface. */
+/**
+ * Result of a country match: the alpha-2 code, the canonical English name, and the matched surface.
+ */
 export interface CountryMatch {
 	iso2: string
 	canonical: CountryName | undefined
@@ -110,7 +117,9 @@ export function matchCountry(token: string | null | undefined): CountryMatch | n
 	return { iso2, canonical: ISO2_TO_NAME.get(iso2), matched: token.trim() }
 }
 
-/** Case-insensitive check: is the token any recognized country form? */
+/**
+ * Case-insensitive check: is the token any recognized country form?
+ */
 export function isCountryToken(token: unknown): boolean {
 	return typeof token === "string" && COUNTRY_LOOKUP.has(token.trim().toLowerCase())
 }
@@ -121,6 +130,3 @@ export function isCountryToken(token: unknown): boolean {
 export function countrySurfaceForms(iso2: string): readonly string[] {
 	return (COUNTRY_SURFACE_FORMS as Record<string, readonly string[]>)[iso2.toUpperCase()] ?? []
 }
-
-export { Alpha3ToCountryRecord, CountryISO2 }
-export type { CountryISO3, CountryName }

package/country/official-languages.ts

@@ -12,15 +12,23 @@
  *   Regenerate with: mailwoman dev generate official-languages
  */
 
-/** Official-language spellings for one territory. */
+/**
+ * Official-language spellings for one territory.
+ */
 export interface OfficialLanguageEntry {
-	/** CLDR `official` + `de_facto_official`, in every ISO-639 spelling. */
+	/**
+	 * CLDR `official` + `de_facto_official`, in every ISO-639 spelling.
+	 */
 	official: readonly string[]
-	/** CLDR `official_regional` (e.g. Catalan in ES) — opt-in for consumers. */
+	/**
+	 * CLDR `official_regional` (e.g. Catalan in ES) — opt-in for consumers.
+	 */
 	regional?: readonly string[]
 }
 
-/** ISO 3166-1 alpha-2 → official languages. */
+/**
+ * ISO 3166-1 alpha-2 → official languages.
+ */
 export const OFFICIAL_LANGUAGES: Record<string, OfficialLanguageEntry> = {
 	AD: { official: ["ca", "cat"] },
 	AE: { official: ["ar", "ara", "arb"] },

package/country/reference-data.ts

@@ -8,13 +8,17 @@
  *   Regenerate with: mailwoman dev generate country-reference
  */
 
-/** Static per-country reference: calling code + currency. */
+/**
+ * Static per-country reference: calling code + currency.
+ */
 export interface CountryReference {
 	callingCode?: number
 	currency?: { isoCode: string; name?: string; symbol?: string }
 }
 
-/** ISO 3166-1 alpha-2 → reference. */
+/**
+ * ISO 3166-1 alpha-2 → reference.
+ */
 export const COUNTRY_REFERENCE: Record<string, CountryReference> = {
 	AD: { callingCode: 376, currency: { isoCode: "EUR", name: "Euro", symbol: "€" } },
 	AE: { callingCode: 971, currency: { isoCode: "AED", name: "United Arab Emirates dirham", symbol: "د.إ" } },
@@ -29,7 +33,7 @@ export const COUNTRY_REFERENCE: Record<string, CountryReference> = {
 	AT: { callingCode: 43, currency: { isoCode: "EUR", name: "Euro", symbol: "€" } },
 	AU: { callingCode: 61, currency: { isoCode: "AUD", name: "Australian dollar", symbol: "$" } },
 	AW: { callingCode: 297, currency: { isoCode: "AWG", name: "Aruban florin", symbol: "ƒ" } },
-	AX: { callingCode: 35818, currency: { isoCode: "EUR", name: "Euro", symbol: "€" } },
+	AX: { callingCode: 35_818, currency: { isoCode: "EUR", name: "Euro", symbol: "€" } },
 	AZ: { callingCode: 994, currency: { isoCode: "AZN", name: "Azerbaijani manat", symbol: "₼" } },
 	BA: { callingCode: 387, currency: { isoCode: "BAM", name: "Bosnia and Herzegovina convertible mark", symbol: "KM" } },
 	BB: { callingCode: 1, currency: { isoCode: "BBD", name: "Barbadian dollar", symbol: "$" } },

package/country/reference.ts

@@ -13,7 +13,7 @@ import type { AnnotationSet, Annotator } from "@mailwoman/annotations"
 
 import { COUNTRY_REFERENCE } from "./reference-data.ts"
 
-const REGIONAL_INDICATOR_BASE = 0x1f1e6
+const REGIONAL_INDICATOR_BASE = 0x1_f1_e6
 const A_UPPER = "A".charCodeAt(0)
 
 /**

package/country/subdivision.ts

@@ -29,23 +29,33 @@
 import { CA_PROVINCES } from "../ca/province.ts"
 import { US_STATE_BY_ABBREVIATION } from "../us/state.ts"
 
-/** A resolved subdivision: its ISO 3166-2 code (sans country prefix), canonical English name, and ISO 3166-1 country. */
+/**
+ * A resolved subdivision: its ISO 3166-2 code (sans country prefix), canonical English name, and ISO 3166-1 country.
+ */
 export interface SubdivisionMatch {
-	/** ISO 3166-2 subdivision code without the country prefix (e.g. `QC` for `CA-QC`, `IL` for `US-IL`). */
+	/**
+	 * ISO 3166-2 subdivision code without the country prefix (e.g. `QC` for `CA-QC`, `IL` for `US-IL`).
+	 */
 	code: string
-	/** Canonical English name (e.g. `Quebec`, `Illinois`). */
+	/**
+	 * Canonical English name (e.g. `Quebec`, `Illinois`).
+	 */
 	name: string
-	/** ISO 3166-1 alpha-2 country the subdivision belongs to (`CA`, `US`). */
+	/**
+	 * ISO 3166-1 alpha-2 country the subdivision belongs to (`CA`, `US`).
+	 */
 	country: string
 }
 
-/** Strip diacritics + lowercase so `Québec`, `Quebec`, and `quebec` all key alike (mirrors `ca/province.ts`). */
+/**
+ * Strip diacritics + lowercase so `Québec`, `Quebec`, and `quebec` all key alike (mirrors `ca/province.ts`).
+ */
 function foldName(s: string): string {
 	return s
 		.toLowerCase()
 		.normalize("NFD")
-		.replace(/[\u0300-\u036f]/g, "")
-		.replace(/[^a-z0-9]+/g, " ")
+		.replaceAll(/[\u0300-\u036F]/g, "")
+		.replaceAll(/[^a-z0-9]+/g, " ")
 		.trim()
 }
 
@@ -56,10 +66,11 @@ function foldName(s: string): string {
  */
 const SUBDIVISION_LOOKUP: ReadonlyMap<string, SubdivisionMatch> = (() => {
 	const out = new Map<string, SubdivisionMatch>()
+
 	const put = (key: string, match: SubdivisionMatch): void => {
 		const folded = foldName(key)
 
-		if (folded.length > 0 && !out.has(folded)) {
+		if (folded.length && !out.has(folded)) {
 			out.set(folded, match)
 		}
 	}

package/de/bundesland.ts

@@ -11,13 +11,21 @@
  *   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. */
+/**
+ * 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`). */
+	/**
+	 * ISO 3166-2:DE subdivision code without the `DE-` prefix (e.g. `BY` for `DE-BY`).
+	 */
 	code: string
-	/** Native German name (e.g. `Bayern`). */
+	/**
+	 * Native German name (e.g. `Bayern`).
+	 */
 	name: string
-	/** Common English name (e.g. `Bavaria`). */
+	/**
+	 * Common English name (e.g. `Bavaria`).
+	 */
 	english: string
 }
 
@@ -44,12 +52,16 @@ export const DE_BUNDESLAENDER = {
 	TH: { code: "TH", name: "Thüringen", english: "Thuringia" },
 } as const satisfies Record<string, GermanStateInfo>
 
-/** An ISO 3166-2:DE state code (`BW`, `BY`, `BE`, …). */
+/**
+ * An ISO 3166-2:DE state code (`BW`, `BY`, `BE`, …).
+ */
 export type GermanStateCode = keyof typeof DE_BUNDESLAENDER
 
 const STATE_CODE_SET: ReadonlySet<string> = new Set(Object.keys(DE_BUNDESLAENDER))
 
-/** Type-predicate for an ISO 3166-2:DE state code. Case-insensitive. */
+/**
+ * Type-predicate for an ISO 3166-2:DE state code. Case-insensitive.
+ */
 export function isGermanStateCode(input: unknown): input is GermanStateCode {
 	return typeof input === "string" && STATE_CODE_SET.has(input.toUpperCase())
 }
@@ -69,6 +81,7 @@ export const DE_STATE_NAME_TO_CODE: ReadonlyMap<string, GermanStateCode> = (() =
 		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: Record<string, GermanStateCode> = {
 		nrw: "NW",