@mailwoman/codex 8.1.0 → 8.2.0

package/de/postleitzahl.ts

@@ -28,7 +28,9 @@ import type { Tagged } from "type-fest"
  */
 export type Postleitzahl = Tagged<string, "Postleitzahl">
 
-/** The PLZ shape: exactly five digits. */
+/**
+ * The PLZ shape: exactly five digits.
+ */
 export const PLZ_PATTERN = /^\d{5}$/
 
 /**
@@ -42,20 +44,30 @@ export function normalizePLZ(raw: unknown): Postleitzahl | null {
 	return PLZ_PATTERN.test(s) ? (s as Postleitzahl) : null
 }
 
-/** Type-predicate for a (normalized) German postal code. */
+/**
+ * Type-predicate for a (normalized) German postal code.
+ */
 export function isPostleitzahl(input: unknown): input is Postleitzahl {
 	return typeof input === "string" && PLZ_PATTERN.test(input)
 }
 
-/** A PLZ Leitzone first digit. */
+/**
+ * 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). */
+/**
+ * Per-Leitzone descriptor: the routing region and a few anchor cities (coarse, postal not admin).
+ */
 export interface LeitzoneInfo {
 	digit: LeitzoneDigit
-	/** Coarse routing-region label. */
+	/**
+	 * Coarse routing-region label.
+	 */
 	region: string
-	/** Well-known anchor cities in the zone (illustrative, not exhaustive). */
+	/**
+	 * Well-known anchor cities in the zone (illustrative, not exhaustive).
+	 */
 	cities: readonly string[]
 }
 
@@ -81,7 +93,9 @@ export const PLZ_LEITZONEN = {
 	9: { digit: 9, region: "nördliches Bayern / Oberpfalz", cities: ["Nürnberg", "Würzburg", "Regensburg"] },
 } as const satisfies Record<LeitzoneDigit, LeitzoneInfo>
 
-/** The Leitzone of a PLZ (its first digit's routing region), or null if the input is not a PLZ. */
+/**
+ * The Leitzone of a PLZ (its first digit's routing region), or null if the input is not a PLZ.
+ */
 export function leitzoneOf(plz: unknown): LeitzoneInfo | null {
 	const normalized = normalizePLZ(plz)
 

package/de/street-type.ts

@@ -25,6 +25,15 @@
  * 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.
  */
+/**
+ * Shortest token still plausible as a German street-type suffix (`weg`).
+ */
+const MIN_STREET_TYPE_LENGTH = 3
+
+/**
+ * German street-type suffixes mapped to their surface variants, including the compounded forms that attach directly to
+ * the name (`-strasse`, `-str.`).
+ */
 export const DE_STREET_TYPE_VARIANTS = {
 	Straße: ["Str.", "Str", "Strasse"],
 	Weg: [],
@@ -41,7 +50,9 @@ export const DE_STREET_TYPE_VARIANTS = {
 	Twiete: [],
 } as const satisfies Record<string, readonly string[]>
 
-/** A canonical German street type (e.g. `Straße`, `Weg`, `Platz`). */
+/**
+ * A canonical German street type (e.g. `Straße`, `Weg`, `Platz`).
+ */
 export type GermanStreetType = keyof typeof DE_STREET_TYPE_VARIANTS
 
 /**
@@ -75,9 +86,9 @@ export const DE_STREET_SUFFIXES = [
  */
 export function isGermanStreetToken(token: unknown): boolean {
 	if (typeof token !== "string") return false
-	const t = token.toLowerCase().replace(/[^a-zà-ÿß]/g, "")
+	const t = token.toLowerCase().replaceAll(/[^a-zà-ÿß]/g, "")
 
-	if (t.length < 3) return false
+	if (t.length < MIN_STREET_TYPE_LENGTH) return false
 
 	return DE_STREET_SUFFIXES.some((s) => t.endsWith(s))
 }

package/fr/cedex.ts

@@ -14,16 +14,24 @@
  *   from here (the provenance-first discipline: one provenanced source).
  */
 
-/** Matches a CEDEX phrase: the keyword plus an optional 1–2 digit office number. */
+/**
+ * Matches a CEDEX phrase: the keyword plus an optional 1–2 digit office number.
+ */
 export const CEDEX_PATTERN = /\bCEDEX(?:\s+(\d{1,2}))?\b/i
 
-/** A matched CEDEX phrase with its char range and optional office number. */
+/**
+ * A matched CEDEX phrase with its char range and optional office number.
+ */
 export interface CedexMatch {
-	/** The full matched phrase as it appears ("CEDEX 08", "Cedex"). */
+	/**
+	 * The full matched phrase as it appears ("CEDEX 08", "Cedex").
+	 */
 	matched: string
 	start: number
 	end: number
-	/** The office number when present ("08"), undefined for bare CEDEX. */
+	/**
+	 * The office number when present ("08"), undefined for bare CEDEX.
+	 */
 	office?: string
 }
 
@@ -47,7 +55,9 @@ export function matchCedex(text: string): CedexMatch | null {
 	return match
 }
 
-/** True when the string is exactly a CEDEX phrase (the component-value validator). */
+/**
+ * True when the string is exactly a CEDEX phrase (the component-value validator).
+ */
 export function isCedex(input: unknown): boolean {
 	if (typeof input !== "string") return false
 	const m = input.trim().match(CEDEX_PATTERN)

package/fr/code-postal.ts

@@ -38,9 +38,17 @@ import { FR_REGIONS, type FrenchRegionInfo } from "./region.ts"
  * @title Code postal
  * @pattern ^\d{5}$
  */
+/**
+ * Postcode at which Corsica splits between departments 2A (Corse-du-Sud) and 2B (Haute-Corse). Both share the 20xxx
+ * range, so the numeric boundary is the only way to tell them apart.
+ */
+const CORSICA_2A_2B_BOUNDARY = 20_200
+
 export type CodePostal = Tagged<string, "CodePostal">
 
-/** The code-postal shape: exactly five digits. */
+/**
+ * The code-postal shape: exactly five digits.
+ */
 export const CODE_POSTAL_PATTERN = /^\d{5}$/
 
 /**
@@ -54,7 +62,9 @@ export function normalizeCodePostal(raw: unknown): CodePostal | null {
 	return CODE_POSTAL_PATTERN.test(s) ? (s as CodePostal) : null
 }
 
-/** Type-predicate for a (normalized) French postal code. */
+/**
+ * Type-predicate for a (normalized) French postal code.
+ */
 export function isCodePostal(input: unknown): input is CodePostal {
 	return typeof input === "string" && CODE_POSTAL_PATTERN.test(input)
 }
@@ -76,7 +86,7 @@ export function departementOfCodePostal(codePostal: unknown): DepartementCode |
 
 	if (cp.startsWith("20")) {
 		// Corsica: prefix 20 covers both départements; the numeric value splits them.
-		return Number(cp) < 20200 ? "2A" : "2B"
+		return Number(cp) < CORSICA_2A_2B_BOUNDARY ? "2A" : "2B"
 	}
 
 	if (cp.startsWith("97") || cp.startsWith("98")) {
@@ -85,12 +95,15 @@ export function departementOfCodePostal(codePostal: unknown): DepartementCode |
 
 		return departementInfo(dom) ? (dom as DepartementCode) : null
 	}
+
 	const dd = cp.slice(0, 2)
 
 	return departementInfo(dd) ? (dd as DepartementCode) : null
 }
 
-/** The full département record a postal code resolves to (name + région), or null. */
+/**
+ * The full département record a postal code resolves to (name + région), or null.
+ */
 export function departementForCodePostal(codePostal: unknown): DepartementInfo | null {
 	return departementInfo(departementOfCodePostal(codePostal))
 }

package/fr/departement.ts

@@ -13,17 +13,27 @@
 
 import type { FrenchRegionCode } from "./region.ts"
 
-/** Per-département record: code (2-digit, or `2A`/`2B`, or 3-digit DOM) + name + its région. */
+/**
+ * Per-département record: code (2-digit, or `2A`/`2B`, or 3-digit DOM) + name + its région.
+ */
 export interface DepartementInfo {
-	/** Département code: `01`–`95` (metropolitan), `2A`/`2B` (Corsica), or `971`–`976` (overseas). */
+	/**
+	 * Département code: `01`–`95` (metropolitan), `2A`/`2B` (Corsica), or `971`–`976` (overseas).
+	 */
 	code: string
-	/** French name (e.g. `Bouches-du-Rhône`). */
+	/**
+	 * French name (e.g. `Bouches-du-Rhône`).
+	 */
 	name: string
-	/** The ISO 3166-2:FR code of the région this département belongs to. */
+	/**
+	 * The ISO 3166-2:FR code of the région this département belongs to.
+	 */
 	region: FrenchRegionCode
 }
 
-/** Département code → info. 96 metropolitan (incl. 2A/2B) + 5 overseas = 101. */
+/**
+ * Département code → info. 96 metropolitan (incl. 2A/2B) + 5 overseas = 101.
+ */
 export const FR_DEPARTEMENTS = {
 	"01": { code: "01", name: "Ain", region: "ARA" },
 	"02": { code: "02", name: "Aisne", region: "HDF" },
@@ -128,7 +138,9 @@ export const FR_DEPARTEMENTS = {
 	"976": { code: "976", name: "Mayotte", region: "MAY" },
 } as const satisfies Record<string, DepartementInfo>
 
-/** A French département code (`01`–`95`, `2A`/`2B`, or `971`–`976`). */
+/**
+ * A French département code (`01`–`95`, `2A`/`2B`, or `971`–`976`).
+ */
 export type DepartementCode = keyof typeof FR_DEPARTEMENTS
 
 /**

package/fr/region.ts

@@ -13,15 +13,23 @@
  *   `code-postal.ts`).
  */
 
-/** Per-region record: ISO 3166-2:FR code (sans `FR-` prefix) + French name. */
+/**
+ * Per-region record: ISO 3166-2:FR code (sans `FR-` prefix) + French name.
+ */
 export interface FrenchRegionInfo {
-	/** ISO 3166-2:FR region code without the `FR-` prefix (e.g. `IDF` for `FR-IDF`). */
+	/**
+	 * ISO 3166-2:FR region code without the `FR-` prefix (e.g. `IDF` for `FR-IDF`).
+	 */
 	code: string
-	/** French name (e.g. `Île-de-France`). */
+	/**
+	 * French name (e.g. `Île-de-France`).
+	 */
 	name: string
 }
 
-/** ISO 3166-2:FR region code → info, for all 18 régions (13 metropolitan + 5 overseas). */
+/**
+ * ISO 3166-2:FR region code → info, for all 18 régions (13 metropolitan + 5 overseas).
+ */
 export const FR_REGIONS = {
 	ARA: { code: "ARA", name: "Auvergne-Rhône-Alpes" },
 	BFC: { code: "BFC", name: "Bourgogne-Franche-Comté" },
@@ -43,23 +51,29 @@ export const FR_REGIONS = {
 	MAY: { code: "MAY", name: "Mayotte" },
 } as const satisfies Record<string, FrenchRegionInfo>
 
-/** An ISO 3166-2:FR region code (`ARA`, `IDF`, `PAC`, …). */
+/**
+ * An ISO 3166-2:FR region code (`ARA`, `IDF`, `PAC`, …).
+ */
 export type FrenchRegionCode = keyof typeof FR_REGIONS
 
 const REGION_CODE_SET: ReadonlySet<string> = new Set(Object.keys(FR_REGIONS))
 
-/** Type-predicate for an ISO 3166-2:FR region code. Case-insensitive. */
+/**
+ * Type-predicate for an ISO 3166-2:FR region code. Case-insensitive.
+ */
 export function isFrenchRegionCode(input: unknown): input is FrenchRegionCode {
 	return typeof input === "string" && REGION_CODE_SET.has(input.toUpperCase())
 }
 
-/** Strip diacritics + lowercase so `Île-de-France`, `ile-de-france`, `Ile de France` all key alike. */
+/**
+ * Strip diacritics + lowercase so `Île-de-France`, `ile-de-france`, `Ile de France` 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/fr/voie.ts

@@ -55,7 +55,9 @@ export const FR_VOIE_TYPES = {
 	lotissement: ["lot"],
 } as const satisfies Record<string, readonly string[]>
 
-/** A canonical French voie type (e.g. `rue`, `avenue`, `boulevard`). */
+/**
+ * A canonical French voie type (e.g. `rue`, `avenue`, `boulevard`).
+ */
 export type FrenchVoieType = keyof typeof FR_VOIE_TYPES
 
 /**
@@ -67,7 +69,8 @@ const VOIE_TOKEN_SET: ReadonlySet<string> = (() => {
 		s
 			.toLowerCase()
 			.normalize("NFD")
-			.replace(/[\u0300-\u036f]/g, "")
+			.replaceAll(/[\u0300-\u036F]/g, "")
+
 	const out = new Set<string>()
 
 	for (const canonical of Object.keys(FR_VOIE_TYPES) as FrenchVoieType[]) {
@@ -88,11 +91,12 @@ const VOIE_TOKEN_SET: ReadonlySet<string> = (() => {
  */
 export function isFrenchStreetWord(token: unknown): boolean {
 	if (typeof token !== "string") return false
+
 	const t = token
 		.toLowerCase()
 		.normalize("NFD")
-		.replace(/[\u0300-\u036f]/g, "")
-		.replace(/[^a-z-]/g, "")
+		.replaceAll(/[\u0300-\u036F]/g, "")
+		.replaceAll(/[^a-z-]/g, "")
 
 	return t.length > 0 && VOIE_TOKEN_SET.has(t)
 }

package/gb/country.ts

@@ -14,15 +14,23 @@
  *   postcode is the thing that actually carries the geography.
  */
 
-/** Per-country record: ISO 3166-2:GB code (sans `GB-` prefix) + English name. */
+/**
+ * Per-country record: ISO 3166-2:GB code (sans `GB-` prefix) + English name.
+ */
 export interface UkCountryInfo {
-	/** ISO 3166-2:GB country code without the `GB-` prefix (e.g. `ENG` for `GB-ENG`). */
+	/**
+	 * ISO 3166-2:GB country code without the `GB-` prefix (e.g. `ENG` for `GB-ENG`).
+	 */
 	code: string
-	/** English name (e.g. `Scotland`). */
+	/**
+	 * English name (e.g. `Scotland`).
+	 */
 	name: string
 }
 
-/** ISO 3166-2:GB country code → info, for all four constituent countries. */
+/**
+ * ISO 3166-2:GB country code → info, for all four constituent countries.
+ */
 export const GB_COUNTRIES = {
 	ENG: { code: "ENG", name: "England" },
 	SCT: { code: "SCT", name: "Scotland" },
@@ -30,25 +38,33 @@ export const GB_COUNTRIES = {
 	NIR: { code: "NIR", name: "Northern Ireland" },
 } as const satisfies Record<string, UkCountryInfo>
 
-/** An ISO 3166-2:GB constituent-country code (`ENG`, `SCT`, `WLS`, `NIR`). */
+/**
+ * An ISO 3166-2:GB constituent-country code (`ENG`, `SCT`, `WLS`, `NIR`).
+ */
 export type UkCountryCode = keyof typeof GB_COUNTRIES
 
 const COUNTRY_CODE_SET: ReadonlySet<string> = new Set(Object.keys(GB_COUNTRIES))
 
-/** Type-predicate for an ISO 3166-2:GB country code. Case-insensitive. */
+/**
+ * Type-predicate for an ISO 3166-2:GB country code. Case-insensitive.
+ */
 export function isUkCountryCode(input: unknown): input is UkCountryCode {
 	return typeof input === "string" && COUNTRY_CODE_SET.has(input.toUpperCase())
 }
 
-/** Lowercase + collapse non-alphanumerics so `Northern Ireland`, `northern-ireland` key alike. */
+/**
+ * Lowercase + collapse non-alphanumerics so `Northern Ireland`, `northern-ireland` key alike.
+ */
 function foldName(s: string): string {
 	return s
 		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, " ")
+		.replaceAll(/[^a-z0-9]+/g, " ")
 		.trim()
 }
 
-/** Folded country name / code → ISO 3166-2:GB code, so a surface form maps regardless of casing. */
+/**
+ * Folded country name / code → ISO 3166-2:GB code, so a surface form maps regardless of casing.
+ */
 const COUNTRY_NAME_TO_CODE: ReadonlyMap<string, UkCountryCode> = (() => {
 	const out = new Map<string, UkCountryCode>()
 

package/gb/postcode-area.ts

@@ -24,7 +24,9 @@
 
 import type { UkCountryCode } from "./country.ts"
 
-/** Northern Ireland is a single postcode area: BT (Belfast). */
+/**
+ * Northern Ireland is a single postcode area: BT (Belfast).
+ */
 const NORTHERN_IRELAND_AREAS = ["BT"] as const
 
 /**
@@ -74,7 +76,9 @@ export const GB_POSTCODE_AREA_COUNTRY: Record<string, UkCountryCode> = {
 	...Object.fromEntries(WALES_AREAS.map((a) => [a, "WLS" as const])),
 }
 
-/** True when `area` looks like a valid postcode-area string: one or two ASCII letters. */
+/**
+ * True when `area` looks like a valid postcode-area string: one or two ASCII letters.
+ */
 function isAreaShape(area: unknown): area is string {
 	return typeof area === "string" && /^[A-Z]{1,2}$/i.test(area)
 }

package/gb/postcode.ts

@@ -39,6 +39,11 @@ import type { Tagged } from "type-fest"
  * @title UK postcode
  * @pattern ^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$
  */
+/**
+ * Shortest valid UK postcode once spaces are stripped, e.g. `M11AE`.
+ */
+const MIN_POSTCODE_LENGTH = 5
+
 export type Postcode = Tagged<string, "UkPostcode">
 
 /**
@@ -57,15 +62,17 @@ export const UK_POSTCODE_PATTERN = /^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$/i
 export function normalizeUkPostcode(raw: unknown): Postcode | null {
 	if (typeof raw !== "string") return null
 	// Drop all whitespace, uppercase, then re-insert the single canonical space before the inward 3.
-	const compact = raw.replace(/\s+/g, "").toUpperCase()
+	const compact = raw.replaceAll(/\s+/g, "").toUpperCase()
 
-	if (compact.length < 5) return null
+	if (compact.length < MIN_POSTCODE_LENGTH) return null
 	const spaced = `${compact.slice(0, -3)} ${compact.slice(-3)}`
 
 	return UK_POSTCODE_PATTERN.test(spaced) ? (spaced as Postcode) : null
 }
 
-/** Type-predicate for a UK postcode surface form (space optional). */
+/**
+ * Type-predicate for a UK postcode surface form (space optional).
+ */
 export function isUkPostcode(input: unknown): input is Postcode {
 	return typeof input === "string" && UK_POSTCODE_PATTERN.test(input.trim())
 }

package/gb/street-type.ts

@@ -72,7 +72,9 @@ export const GB_STREET_TYPES = [
 	"gait",
 ] as const
 
-/** A canonical British thoroughfare word (e.g. `street`, `crescent`, `mews`). */
+/**
+ * A canonical British thoroughfare word (e.g. `street`, `crescent`, `mews`).
+ */
 export type BritishStreetType = (typeof GB_STREET_TYPES)[number]
 
 const STREET_TYPE_SET: ReadonlySet<string> = new Set(GB_STREET_TYPES)
@@ -84,7 +86,7 @@ const STREET_TYPE_SET: ReadonlySet<string> = new Set(GB_STREET_TYPES)
  */
 export function isBritishStreetWord(token: unknown): boolean {
 	if (typeof token !== "string") return false
-	const t = token.toLowerCase().replace(/[^a-z]/g, "")
+	const t = token.toLowerCase().replaceAll(/[^a-z]/g, "")
 
 	return t.length > 0 && STREET_TYPE_SET.has(t)
 }

package/index.ts

@@ -26,6 +26,7 @@ export {
 	conventionsForSystem,
 	type AddressSystemConventions,
 } from "./address-system-conventions.ts"
+
 export * as au from "./au/index.ts"
 export * as ca from "./ca/index.ts"
 export * as de from "./de/index.ts"

package/jp/address-unit.ts

@@ -43,7 +43,9 @@
  */
 export const JP_ADMIN_SUFFIXES = ["都", "道", "府", "県", "市", "区", "郡", "町", "村"] as const
 
-/** A single administrative-area suffix kanji (`都`, `市`, `区`, …). */
+/**
+ * A single administrative-area suffix kanji (`都`, `市`, `区`, …).
+ */
 export type JapaneseAdminSuffix = (typeof JP_ADMIN_SUFFIXES)[number]
 
 /**
@@ -57,7 +59,9 @@ export type JapaneseAdminSuffix = (typeof JP_ADMIN_SUFFIXES)[number]
  */
 export const JP_BLOCK_MARKERS = ["丁目", "番地", "番", "号"] as const
 
-/** A numbered-tail marker (`丁目`, `番地`, `番`, `号`). */
+/**
+ * A numbered-tail marker (`丁目`, `番地`, `番`, `号`).
+ */
 export type JapaneseBlockMarker = (typeof JP_BLOCK_MARKERS)[number]
 
 const ADMIN_SUFFIX_SET: ReadonlySet<string> = new Set(JP_ADMIN_SUFFIXES)
@@ -78,10 +82,10 @@ export function isJapaneseAdminSuffix(ch: unknown): ch is JapaneseAdminSuffix {
  * than clipped to `北海` — mirroring the same carve-out in `prefecture.ts`.
  */
 export function stripAdminSuffix(name: string): string {
-	if (typeof name !== "string" || name.length === 0) return name
+	if (typeof name !== "string" || !name.length) return name
 
 	if (name === "北海道") return name
-	const last = name[name.length - 1]!
+	const last = name.at(-1)!
 
 	return ADMIN_SUFFIX_SET.has(last) ? name.slice(0, -1) : name
 }

package/jp/postal-code.ts

@@ -36,7 +36,9 @@ import type { Tagged } from "type-fest"
  */
 export type PostalCode = Tagged<string, "JpPostalCode">
 
-/** The postal-code shape: `NNN-NNNN`, the hyphen optional on input (`1000001` or `100-0001`). */
+/**
+ * The postal-code shape: `NNN-NNNN`, the hyphen optional on input (`1000001` or `100-0001`).
+ */
 export const JP_POSTAL_CODE_PATTERN = /^\d{3}-?\d{4}$/
 
 /**
@@ -47,14 +49,16 @@ export const JP_POSTAL_CODE_PATTERN = /^\d{3}-?\d{4}$/
 export function normalizeJpPostalCode(raw: unknown): PostalCode | null {
 	if (typeof raw !== "string") return null
 	// Drop the 〒 mark and all whitespace, then keep only the digits.
-	const digits = raw.replace(/〒/g, "").replace(/\s+/g, "").replace(/-/g, "")
+	const digits = raw.replaceAll("〒", "").replaceAll(/\s+/g, "").replaceAll("-", "")
 
 	if (!/^\d{7}$/.test(digits)) return null
 
 	return `${digits.slice(0, 3)}-${digits.slice(3)}` as PostalCode
 }
 
-/** Type-predicate for a Japanese postal code (hyphen optional, `100-0001` or `1000001`). */
+/**
+ * Type-predicate for a Japanese postal code (hyphen optional, `100-0001` or `1000001`).
+ */
 export function isJpPostalCode(input: unknown): input is PostalCode {
 	return typeof input === "string" && JP_POSTAL_CODE_PATTERN.test(input)
 }

package/jp/prefecture.ts

@@ -23,18 +23,30 @@
  *   `postal-code.ts` for why the postcode is nonetheless the single most reliable anchor.
  */
 
-/** A to/dō/fu/ken classification of the top-level admin unit. */
+/**
+ * A to/dō/fu/ken classification of the top-level admin unit.
+ */
 export type JapanesePrefectureType = "to" | "do" | "fu" | "ken"
 
-/** Per-prefecture record: ISO 3166-2:JP numeric code + kanji + romaji + to/dō/fu/ken type. */
+/**
+ * Per-prefecture record: ISO 3166-2:JP numeric code + kanji + romaji + to/dō/fu/ken type.
+ */
 export interface JapanesePrefectureInfo {
-	/** ISO 3166-2:JP code without the `JP-` prefix: a two-digit numeric string (`"13"` for `JP-13`). */
+	/**
+	 * ISO 3166-2:JP code without the `JP-` prefix: a two-digit numeric string (`"13"` for `JP-13`).
+	 */
 	code: string
-	/** Kanji name, including its 都/道/府/県 suffix (e.g. `東京都`). */
+	/**
+	 * Kanji name, including its 都/道/府/県 suffix (e.g. `東京都`).
+	 */
 	kanji: string
-	/** Macron-free romaji name, suffix-less (e.g. `Tokyo`). */
+	/**
+	 * Macron-free romaji name, suffix-less (e.g. `Tokyo`).
+	 */
 	romaji: string
-	/** Which of the four flavours of top-level unit this is. */
+	/**
+	 * Which of the four flavours of top-level unit this is.
+	 */
 	type: JapanesePrefectureType
 }
 
@@ -92,12 +104,16 @@ export const JP_PREFECTURES = {
 	"47": { code: "47", kanji: "沖縄県", romaji: "Okinawa", type: "ken" },
 } as const satisfies Record<string, JapanesePrefectureInfo>
 
-/** An ISO 3166-2:JP prefecture code (`"01"`..`"47"`). */
+/**
+ * An ISO 3166-2:JP prefecture code (`"01"`..`"47"`).
+ */
 export type JapanesePrefectureCode = keyof typeof JP_PREFECTURES
 
 const PREFECTURE_CODE_SET: ReadonlySet<string> = new Set(Object.keys(JP_PREFECTURES))
 
-/** Type-predicate for an ISO 3166-2:JP prefecture code (`"01"`..`"47"`). */
+/**
+ * Type-predicate for an ISO 3166-2:JP prefecture code (`"01"`..`"47"`).
+ */
 export function isJapanesePrefectureCode(input: unknown): input is JapanesePrefectureCode {
 	return typeof input === "string" && PREFECTURE_CODE_SET.has(input)
 }
@@ -117,11 +133,12 @@ function foldRomaji(s: string): string {
 	const lowered = s
 		.toLowerCase()
 		.normalize("NFD")
-		.replace(/[\u0300-\u036f]/g, "")
+		.replaceAll(/[\u0300-\u036F]/g, "")
+
 	// Strip an appended type-suffix only when a separator (hyphen / space / middle dot) precedes it.
 	const desuffixed = lowered.replace(/[-\s·][\s]*(to|do|fu|ken)$/, "")
 
-	return desuffixed.replace(/[^a-z]/g, "")
+	return desuffixed.replaceAll(/[^a-z]/g, "")
 }
 
 /**