@mailwoman/codex 4.16.1 → 5.0.0

package/out/gb/postcode-area.js

@@ -24,8 +24,8 @@
 /** Northern Ireland is a single postcode area: BT (Belfast). */
 const NORTHERN_IRELAND_AREAS = ["BT"];
 /**
- * Scotland's postcode areas. TD (Galashiels) straddles the border with England and is assigned to
- * Scotland as its majority country.
+ * Scotland's postcode areas. TD (Galashiels) straddles the border with England and is assigned to Scotland as its
+ * majority country.
  */
 const SCOTLAND_AREAS = [
     "AB", // Aberdeen
@@ -46,8 +46,8 @@ const SCOTLAND_AREAS = [
     "ZE", // Lerwick (Shetland)
 ];
 /**
- * Wales's postcode areas. SY (Shrewsbury) straddles the border with England and is assigned to
- * Wales as its majority country.
+ * Wales's postcode areas. SY (Shrewsbury) straddles the border with England and is assigned to Wales as its majority
+ * country.
  */
 const WALES_AREAS = [
     "CF", // Cardiff
@@ -58,10 +58,9 @@ const WALES_AREAS = [
     "SY", // Shrewsbury — straddles the Wales/England border, majority Wales
 ];
 /**
- * The explicit non-England postcode areas, area → constituent country. England is intentionally
- * absent: it is the DEFAULT (the great majority of UK areas are English), so listing it would be
- * both enormous and a maintenance trap. Keeping only the non-England set makes the default
- * transparent — anything not named here is England.
+ * The explicit non-England postcode areas, area → constituent country. England is intentionally absent: it is the
+ * DEFAULT (the great majority of UK areas are English), so listing it would be both enormous and a maintenance trap.
+ * Keeping only the non-England set makes the default transparent — anything not named here is England.
  */
 export const GB_POSTCODE_AREA_COUNTRY = {
     ...Object.fromEntries(NORTHERN_IRELAND_AREAS.map((a) => [a, "NIR"])),
@@ -73,11 +72,11 @@ function isAreaShape(area) {
     return typeof area === "string" && /^[A-Z]{1,2}$/i.test(area);
 }
 /**
- * The constituent country a postcode AREA belongs to. Returns the explicit country for a known
- * non-England area (e.g. `BT` → `NIR`, `G` → `SCT`, `CF` → `WLS`), and `ENG` as the default for any
- * other validly-shaped area — England is by far the largest, so the default is transparent and the
- * non-England exceptions live in {@link GB_POSTCODE_AREA_COUNTRY}. Returns null for clearly-invalid
- * input (not one-or-two letters), so a malformed token is not silently called England.
+ * The constituent country a postcode AREA belongs to. Returns the explicit country for a known non-England area (e.g.
+ * `BT` → `NIR`, `G` → `SCT`, `CF` → `WLS`), and `ENG` as the default for any other validly-shaped area — England is by
+ * far the largest, so the default is transparent and the non-England exceptions live in
+ * {@link GB_POSTCODE_AREA_COUNTRY}. Returns null for clearly-invalid input (not one-or-two letters), so a malformed
+ * token is not silently called England.
  */
 export function countryOfPostcodeArea(area) {
     if (!isAreaShape(area))
@@ -85,9 +84,8 @@ export function countryOfPostcodeArea(area) {
     return GB_POSTCODE_AREA_COUNTRY[area.toUpperCase()] ?? "ENG";
 }
 /**
- * The constituent country a whole postcode resolves to, by extracting its area. `BT1 1AA` → `NIR`,
- * `EH1 1BB` → `SCT`, `CF10 1AA` → `WLS`, `SW1A 1AA` → `ENG`. Null if the input has no extractable
- * postcode area.
+ * The constituent country a whole postcode resolves to, by extracting its area. `BT1 1AA` → `NIR`, `EH1 1BB` → `SCT`,
+ * `CF10 1AA` → `WLS`, `SW1A 1AA` → `ENG`. Null if the input has no extractable postcode area.
  */
 export function countryOfPostcode(postcode) {
     if (typeof postcode !== "string")

package/out/gb/postcode-area.js.map

@@ -1 +1 @@
-{"version":3,"file":"postcode-area.js","sourceRoot":"","sources":["../../gb/postcode-area.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,gEAAgE;AAChE,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAU,CAAA;AAE9C;;;GAGG;AACH,MAAM,cAAc,GAAG;IACtB,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,UAAU;IAChB,GAAG,EAAE,WAAW;IAChB,IAAI,EAAE,sCAAsC;IAC5C,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,gCAAgC;IACtC,IAAI,EAAE,mBAAmB;IACzB,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,kFAAkF;IACxF,IAAI,EAAE,qBAAqB;CAClB,CAAA;AAEV;;;GAGG;AACH,MAAM,WAAW,GAAG;IACnB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,oBAAoB;IAC1B,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,kEAAkE;CAC/D,CAAA;AAEV;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAkC;IACtE,GAAG,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAc,CAAC,CAAC,CAAC;IAC7E,GAAG,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAc,CAAC,CAAC,CAAC;IACrE,GAAG,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAc,CAAC,CAAC,CAAC;CAClE,CAAA;AAED,0FAA0F;AAC1F,SAAS,WAAW,CAAC,IAAa;IACjC,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAa;IAClD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IACnC,OAAO,wBAAwB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,KAAK,CAAA;AAC7D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAiB;IAClD,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IAC7C,kFAAkF;IAClF,MAAM,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAChD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAA;IACvB,OAAO,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;AACvC,CAAC"}
+{"version":3,"file":"postcode-area.js","sourceRoot":"","sources":["../../gb/postcode-area.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,gEAAgE;AAChE,MAAM,sBAAsB,GAAG,CAAC,IAAI,CAAU,CAAA;AAE9C;;;GAGG;AACH,MAAM,cAAc,GAAG;IACtB,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,SAAS;IACf,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,UAAU;IAChB,GAAG,EAAE,WAAW;IAChB,IAAI,EAAE,sCAAsC;IAC5C,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,gCAAgC;IACtC,IAAI,EAAE,mBAAmB;IACzB,IAAI,EAAE,aAAa;IACnB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,kFAAkF;IACxF,IAAI,EAAE,qBAAqB;CAClB,CAAA;AAEV;;;GAGG;AACH,MAAM,WAAW,GAAG;IACnB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,oBAAoB;IAC1B,IAAI,EAAE,YAAY;IAClB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,kEAAkE;CAC/D,CAAA;AAEV;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAkC;IACtE,GAAG,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAc,CAAC,CAAC,CAAC;IAC7E,GAAG,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAc,CAAC,CAAC,CAAC;IACrE,GAAG,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAc,CAAC,CAAC,CAAC;CAClE,CAAA;AAED,0FAA0F;AAC1F,SAAS,WAAW,CAAC,IAAa;IACjC,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC9D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAa;IAClD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IAEnC,OAAO,wBAAwB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,KAAK,CAAA;AAC7D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAiB;IAClD,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IAC7C,kFAAkF;IAClF,MAAM,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAEhD,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAA;IAEvB,OAAO,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;AACvC,CAAC"}

package/out/gb/postcode.d.ts

@@ -28,9 +28,9 @@
  */
 import type { Tagged } from "type-fest";
 /**
- * A UK postcode: variable-length alphanumeric, outward + inward (`SW1A 1AA`, `M1 1AE`). The
- * canonical form carries exactly one space before the final three characters. Unlike a US/DE/FR
- * postcode, the shape is not a fixed-width numeric string — see {@link UK_POSTCODE_PATTERN}.
+ * A UK postcode: variable-length alphanumeric, outward + inward (`SW1A 1AA`, `M1 1AE`). The canonical form carries
+ * exactly one space before the final three characters. Unlike a US/DE/FR postcode, the shape is not a fixed-width
+ * numeric string — see {@link UK_POSTCODE_PATTERN}.
  *
  * @category Postal
  * @type string
@@ -39,35 +39,34 @@ import type { Tagged } from "type-fest";
  */
 export type Postcode = Tagged<string, "UkPostcode">;
 /**
- * UK postcode shape. A permissive form of the Royal Mail / UK-gov regex: one or two leading letters
- * (the area), a district digit, an optional district letter-or-digit, then the inward sector digit
- * and two unit letters, with the inward space optional so an un-spaced `SW1A1AA` still validates.
- * The full UK-gov pattern additionally whitelists the British Overseas Territory codes (`ASCN`,
- * `STHL`, `BBND`, …); those are rare enough to leave to the gazetteer.
+ * UK postcode shape. A permissive form of the Royal Mail / UK-gov regex: one or two leading letters (the area), a
+ * district digit, an optional district letter-or-digit, then the inward sector digit and two unit letters, with the
+ * inward space optional so an un-spaced `SW1A1AA` still validates. The full UK-gov pattern additionally whitelists the
+ * British Overseas Territory codes (`ASCN`, `STHL`, `BBND`, …); those are rare enough to leave to the gazetteer.
  */
 export declare const UK_POSTCODE_PATTERN: RegExp;
 /**
- * Normalize a UK postcode surface form: uppercase, strip surrounding whitespace, and ensure exactly
- * one space before the final three characters (the inward code). `sw1a1aa` → `SW1A 1AA`, `M11AE` →
- * `M1 1AE`, `b33 8th` → `B33 8TH`. Returns null if the result is not a valid postcode.
+ * Normalize a UK postcode surface form: uppercase, strip surrounding whitespace, and ensure exactly one space before
+ * the final three characters (the inward code). `sw1a1aa` → `SW1A 1AA`, `M11AE` → `M1 1AE`, `b33 8th` → `B33 8TH`.
+ * Returns null if the result is not a valid postcode.
  */
 export declare function normalizeUkPostcode(raw: unknown): Postcode | null;
 /** Type-predicate for a UK postcode surface form (space optional). */
 export declare function isUkPostcode(input: unknown): input is Postcode;
 /**
- * The OUTWARD code — the part before the space (area + district), e.g. `SW1A 1AA` → `SW1A`, `M1
- * 1AE` → `M1`. Normalizes first so an un-spaced input still cleaves correctly; null if invalid.
+ * The OUTWARD code — the part before the space (area + district), e.g. `SW1A 1AA` → `SW1A`, `M1 1AE` → `M1`. Normalizes
+ * first so an un-spaced input still cleaves correctly; null if invalid.
  */
 export declare function outwardCode(pc: unknown): string | null;
 /**
- * The INWARD code — the three characters after the space (sector + unit), e.g. `SW1A 1AA` → `1AA`,
- * `M1 1AE` → `1AE`. Null if invalid.
+ * The INWARD code — the three characters after the space (sector + unit), e.g. `SW1A 1AA` → `1AA`, `M1 1AE` → `1AE`.
+ * Null if invalid.
  */
 export declare function inwardCode(pc: unknown): string | null;
 /**
- * The POSTCODE AREA — the leading one or two LETTERS of the outward code, the Royal Mail routing
- * region named after a sorting town: `SW1A 1AA` → `SW`, `M1 1AE` → `M`, `B33 8TH` → `B`. This is
- * the key into `postcode-area.ts`'s area→country map. Null if the input is not a valid postcode.
+ * The POSTCODE AREA — the leading one or two LETTERS of the outward code, the Royal Mail routing region named after a
+ * sorting town: `SW1A 1AA` → `SW`, `M1 1AE` → `M`, `B33 8TH` → `B`. This is the key into `postcode-area.ts`'s
+ * area→country map. Null if the input is not a valid postcode.
  */
 export declare function postcodeArea(pc: unknown): string | null;
 //# sourceMappingURL=postcode.d.ts.map

package/out/gb/postcode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postcode.d.ts","sourceRoot":"","sources":["../../gb/postcode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;AAEnD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,QAAwC,CAAA;AAExE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAOjE;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE9D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAItD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAIrD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAKvD"}
+{"version":3,"file":"postcode.d.ts","sourceRoot":"","sources":["../../gb/postcode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,QAAwC,CAAA;AAExE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CASjE;AAED,sEAAsE;AACtE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE9D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAMtD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAMrD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAOvD"}

package/out/gb/postcode.js

@@ -27,17 +27,16 @@
  *   internal space, and cleaving outward from inward — not a prefix→admin lookup.
  */
 /**
- * UK postcode shape. A permissive form of the Royal Mail / UK-gov regex: one or two leading letters
- * (the area), a district digit, an optional district letter-or-digit, then the inward sector digit
- * and two unit letters, with the inward space optional so an un-spaced `SW1A1AA` still validates.
- * The full UK-gov pattern additionally whitelists the British Overseas Territory codes (`ASCN`,
- * `STHL`, `BBND`, …); those are rare enough to leave to the gazetteer.
+ * UK postcode shape. A permissive form of the Royal Mail / UK-gov regex: one or two leading letters (the area), a
+ * district digit, an optional district letter-or-digit, then the inward sector digit and two unit letters, with the
+ * inward space optional so an un-spaced `SW1A1AA` still validates. The full UK-gov pattern additionally whitelists the
+ * British Overseas Territory codes (`ASCN`, `STHL`, `BBND`, …); those are rare enough to leave to the gazetteer.
  */
 export const UK_POSTCODE_PATTERN = /^[A-Z]{1,2}\d[A-Z\d]? ?\d[A-Z]{2}$/i;
 /**
- * Normalize a UK postcode surface form: uppercase, strip surrounding whitespace, and ensure exactly
- * one space before the final three characters (the inward code). `sw1a1aa` → `SW1A 1AA`, `M11AE` →
- * `M1 1AE`, `b33 8th` → `B33 8TH`. Returns null if the result is not a valid postcode.
+ * Normalize a UK postcode surface form: uppercase, strip surrounding whitespace, and ensure exactly one space before
+ * the final three characters (the inward code). `sw1a1aa` → `SW1A 1AA`, `M11AE` → `M1 1AE`, `b33 8th` → `B33 8TH`.
+ * Returns null if the result is not a valid postcode.
  */
 export function normalizeUkPostcode(raw) {
     if (typeof raw !== "string")
@@ -54,8 +53,8 @@ export function isUkPostcode(input) {
     return typeof input === "string" && UK_POSTCODE_PATTERN.test(input.trim());
 }
 /**
- * The OUTWARD code — the part before the space (area + district), e.g. `SW1A 1AA` → `SW1A`, `M1
- * 1AE` → `M1`. Normalizes first so an un-spaced input still cleaves correctly; null if invalid.
+ * The OUTWARD code — the part before the space (area + district), e.g. `SW1A 1AA` → `SW1A`, `M1 1AE` → `M1`. Normalizes
+ * first so an un-spaced input still cleaves correctly; null if invalid.
  */
 export function outwardCode(pc) {
     const normalized = normalizeUkPostcode(pc);
@@ -64,8 +63,8 @@ export function outwardCode(pc) {
     return normalized.slice(0, normalized.indexOf(" "));
 }
 /**
- * The INWARD code — the three characters after the space (sector + unit), e.g. `SW1A 1AA` → `1AA`,
- * `M1 1AE` → `1AE`. Null if invalid.
+ * The INWARD code — the three characters after the space (sector + unit), e.g. `SW1A 1AA` → `1AA`, `M1 1AE` → `1AE`.
+ * Null if invalid.
  */
 export function inwardCode(pc) {
     const normalized = normalizeUkPostcode(pc);
@@ -74,9 +73,9 @@ export function inwardCode(pc) {
     return normalized.slice(normalized.indexOf(" ") + 1);
 }
 /**
- * The POSTCODE AREA — the leading one or two LETTERS of the outward code, the Royal Mail routing
- * region named after a sorting town: `SW1A 1AA` → `SW`, `M1 1AE` → `M`, `B33 8TH` → `B`. This is
- * the key into `postcode-area.ts`'s area→country map. Null if the input is not a valid postcode.
+ * The POSTCODE AREA — the leading one or two LETTERS of the outward code, the Royal Mail routing region named after a
+ * sorting town: `SW1A 1AA` → `SW`, `M1 1AE` → `M`, `B33 8TH` → `B`. This is the key into `postcode-area.ts`'s
+ * area→country map. Null if the input is not a valid postcode.
  */
 export function postcodeArea(pc) {
     const outward = outwardCode(pc);

package/out/gb/postcode.js.map

@@ -1 +1 @@
-{"version":3,"file":"postcode.js","sourceRoot":"","sources":["../../gb/postcode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAgBH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,qCAAqC,CAAA;AAExE;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC/C,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,iGAAiG;IACjG,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAA;IACrD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IACnC,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;IAC7D,OAAO,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAmB,CAAC,CAAC,CAAC,IAAI,CAAA;AACtE,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,YAAY,CAAC,KAAc;IAC1C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;AAC3E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,EAAW;IACtC,MAAM,UAAU,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAA;IAC1C,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAC5B,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;AACpD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,EAAW;IACrC,MAAM,UAAU,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAA;IAC1C,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAC5B,OAAO,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;AACrD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,EAAW;IACvC,MAAM,OAAO,GAAG,WAAW,CAAC,EAAE,CAAC,CAAA;IAC/B,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAA;IACzB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACzC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AAC/B,CAAC"}
+{"version":3,"file":"postcode.js","sourceRoot":"","sources":["../../gb/postcode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAgBH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,qCAAqC,CAAA;AAExE;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAY;IAC/C,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,iGAAiG;IACjG,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAA;IAErD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAA;IACnC,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;IAE7D,OAAO,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAmB,CAAC,CAAC,CAAC,IAAI,CAAA;AACtE,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,YAAY,CAAC,KAAc;IAC1C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;AAC3E,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,EAAW;IACtC,MAAM,UAAU,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAA;IAE1C,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAE5B,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;AACpD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,EAAW;IACrC,MAAM,UAAU,GAAG,mBAAmB,CAAC,EAAE,CAAC,CAAA;IAE1C,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAE5B,OAAO,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAA;AACrD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,EAAW;IACvC,MAAM,OAAO,GAAG,WAAW,CAAC,EAAE,CAAC,CAAA;IAE/B,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAA;IACzB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAEzC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AAC/B,CAAC"}

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

@@ -19,18 +19,17 @@
  *   distinct trailing words, not fused endings.
  */
 /**
- * The British thoroughfare vocabulary. Lowercase canonical forms, matched as whole tokens. Spans
- * the common core (`street`, `road`, `lane`, `avenue`) through the distinctively British
- * (`crescent`, `mews`, `close`, `terrace`) and the regional/landscape tail (`wynd`, `brae`, `gait`,
- * `croft`, `dene`, `spinney`, `dell`, `hollow`).
+ * The British thoroughfare vocabulary. Lowercase canonical forms, matched as whole tokens. Spans the common core
+ * (`street`, `road`, `lane`, `avenue`) through the distinctively British (`crescent`, `mews`, `close`, `terrace`) and
+ * the regional/landscape tail (`wynd`, `brae`, `gait`, `croft`, `dene`, `spinney`, `dell`, `hollow`).
  */
 export declare const GB_STREET_TYPES: readonly ["street", "road", "lane", "avenue", "close", "crescent", "court", "drive", "place", "way", "gardens", "grove", "terrace", "mews", "walk", "hill", "green", "park", "rise", "view", "row", "square", "parade", "vale", "wharf", "yard", "gate", "croft", "dene", "end", "fields", "meadow", "brook", "chase", "copse", "dale", "dell", "glen", "hollow", "paddock", "ridge", "spinney", "wynd", "brae", "gait"];
 /** A canonical British thoroughfare word (e.g. `street`, `crescent`, `mews`). */
 export type BritishStreetType = (typeof GB_STREET_TYPES)[number];
 /**
- * True when a token is a British thoroughfare type word (case-insensitive, whole-token match) —
- * `Crescent`, `Mews`, `Close`, `Road`. Matches the WHOLE token, not a suffix, so an unrelated place
- * name (`Tokyo`, `Bordeaux`) is not flagged the way an `-endsWith` test might.
+ * True when a token is a British thoroughfare type word (case-insensitive, whole-token match) — `Crescent`, `Mews`,
+ * `Close`, `Road`. Matches the WHOLE token, not a suffix, so an unrelated place name (`Tokyo`, `Bordeaux`) is not
+ * flagged the way an `-endsWith` test might.
  */
 export declare function isBritishStreetWord(token: unknown): boolean;
 //# sourceMappingURL=street-type.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"street-type.d.ts","sourceRoot":"","sources":["../../gb/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,0ZA8ClB,CAAA;AAEV,iFAAiF;AACjF,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAIhE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAI3D"}
+{"version":3,"file":"street-type.d.ts","sourceRoot":"","sources":["../../gb/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe,0ZA8ClB,CAAA;AAEV,iFAAiF;AACjF,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAIhE;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK3D"}

package/out/gb/street-type.js

@@ -19,10 +19,9 @@
  *   distinct trailing words, not fused endings.
  */
 /**
- * The British thoroughfare vocabulary. Lowercase canonical forms, matched as whole tokens. Spans
- * the common core (`street`, `road`, `lane`, `avenue`) through the distinctively British
- * (`crescent`, `mews`, `close`, `terrace`) and the regional/landscape tail (`wynd`, `brae`, `gait`,
- * `croft`, `dene`, `spinney`, `dell`, `hollow`).
+ * The British thoroughfare vocabulary. Lowercase canonical forms, matched as whole tokens. Spans the common core
+ * (`street`, `road`, `lane`, `avenue`) through the distinctively British (`crescent`, `mews`, `close`, `terrace`) and
+ * the regional/landscape tail (`wynd`, `brae`, `gait`, `croft`, `dene`, `spinney`, `dell`, `hollow`).
  */
 export const GB_STREET_TYPES = [
     "street",
@@ -73,9 +72,9 @@ export const GB_STREET_TYPES = [
 ];
 const STREET_TYPE_SET = new Set(GB_STREET_TYPES);
 /**
- * True when a token is a British thoroughfare type word (case-insensitive, whole-token match) —
- * `Crescent`, `Mews`, `Close`, `Road`. Matches the WHOLE token, not a suffix, so an unrelated place
- * name (`Tokyo`, `Bordeaux`) is not flagged the way an `-endsWith` test might.
+ * True when a token is a British thoroughfare type word (case-insensitive, whole-token match) — `Crescent`, `Mews`,
+ * `Close`, `Road`. Matches the WHOLE token, not a suffix, so an unrelated place name (`Tokyo`, `Bordeaux`) is not
+ * flagged the way an `-endsWith` test might.
  */
 export function isBritishStreetWord(token) {
     if (typeof token !== "string")

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

@@ -1 +1 @@
-{"version":3,"file":"street-type.js","sourceRoot":"","sources":["../../gb/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC9B,QAAQ;IACR,MAAM;IACN,MAAM;IACN,QAAQ;IACR,OAAO;IACP,UAAU;IACV,OAAO;IACP,OAAO;IACP,OAAO;IACP,KAAK;IACL,SAAS;IACT,OAAO;IACP,SAAS;IACT,MAAM;IACN,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,KAAK;IACL,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,KAAK;IACL,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,OAAO;IACP,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,SAAS;IACT,MAAM;IACN,MAAM;IACN,MAAM;CACG,CAAA;AAKV,MAAM,eAAe,GAAwB,IAAI,GAAG,CAAC,eAAe,CAAC,CAAA;AAErE;;;;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,SAAS,EAAE,EAAE,CAAC,CAAA;IACpD,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAC9C,CAAC"}
+{"version":3,"file":"street-type.js","sourceRoot":"","sources":["../../gb/street-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG;IAC9B,QAAQ;IACR,MAAM;IACN,MAAM;IACN,QAAQ;IACR,OAAO;IACP,UAAU;IACV,OAAO;IACP,OAAO;IACP,OAAO;IACP,KAAK;IACL,SAAS;IACT,OAAO;IACP,SAAS;IACT,MAAM;IACN,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,KAAK;IACL,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,OAAO;IACP,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,KAAK;IACL,QAAQ;IACR,QAAQ;IACR,OAAO;IACP,OAAO;IACP,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,QAAQ;IACR,SAAS;IACT,OAAO;IACP,SAAS;IACT,MAAM;IACN,MAAM;IACN,MAAM;CACG,CAAA;AAKV,MAAM,eAAe,GAAwB,IAAI,GAAG,CAAC,eAAe,CAAC,CAAA;AAErE;;;;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,SAAS,EAAE,EAAE,CAAC,CAAA;IAEpD,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAC9C,CAAC"}

package/out/jp/address-unit.d.ts

@@ -44,8 +44,8 @@ export declare const JP_ADMIN_SUFFIXES: readonly ["都", "道", "府", "県", "
 /** A single administrative-area suffix kanji (`都`, `市`, `区`, …). */
 export type JapaneseAdminSuffix = (typeof JP_ADMIN_SUFFIXES)[number];
 /**
- * The markers that close the numbered tail of an address — Japan's stand-in for a house number,
- * since there is no named street to hang one on:
+ * The markers that close the numbered tail of an address — Japan's stand-in for a house number, since there is no named
+ * street to hang one on:
  *
  * - 丁目 (chōme) — a district block within a neighbourhood.
  * - 番地 (banchi) — a lot number.
@@ -56,17 +56,16 @@ export declare const JP_BLOCK_MARKERS: readonly ["丁目", "番地", "番", "号
 /** A numbered-tail marker (`丁目`, `番地`, `番`, `号`). */
 export type JapaneseBlockMarker = (typeof JP_BLOCK_MARKERS)[number];
 /**
- * True when a single kanji is one of the {@link JP_ADMIN_SUFFIXES} admin-area markers (`都`, `市`,
- * `区`, …). Strictly single-character: a multi-character input (even one ending in a suffix) is not
- * a suffix on its own.
+ * True when a single kanji is one of the {@link JP_ADMIN_SUFFIXES} admin-area markers (`都`, `市`, `区`, …). Strictly
+ * single-character: a multi-character input (even one ending in a suffix) is not a suffix on its own.
  */
 export declare function isJapaneseAdminSuffix(ch: unknown): ch is JapaneseAdminSuffix;
 /**
- * Strip a trailing admin-area suffix kanji from a place name, exposing the bare name (`東京都` → `東京`,
- * `大阪市` → `大阪`, `千代田区` → `千代田`). Leaves a name untouched if it does not end in an admin suffix.
+ * Strip a trailing admin-area suffix kanji from a place name, exposing the bare name (`東京都` → `東京`, `大阪市` → `大阪`,
+ * `千代田区` → `千代田`). Leaves a name untouched if it does not end in an admin suffix.
  *
- * Hokkaido (`北海道`) is the deliberate exception: its name ends in 道 but is indivisible, so it is
- * returned whole rather than clipped to `北海` — mirroring the same carve-out in `prefecture.ts`.
+ * Hokkaido (`北海道`) is the deliberate exception: its name ends in 道 but is indivisible, so it is returned whole rather
+ * than clipped to `北海` — mirroring the same carve-out in `prefecture.ts`.
  */
 export declare function stripAdminSuffix(name: string): string;
 //# sourceMappingURL=address-unit.d.ts.map

package/out/jp/address-unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"address-unit.d.ts","sourceRoot":"","sources":["../../jp/address-unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,wDAAyD,CAAA;AAEvF,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpE;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,iCAAkC,CAAA;AAE/D,qDAAqD;AACrD,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAA;AAInE;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,mBAAmB,CAE5E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKrD"}
+{"version":3,"file":"address-unit.d.ts","sourceRoot":"","sources":["../../jp/address-unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,wDAAyD,CAAA;AAEvF,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpE;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,iCAAkC,CAAA;AAE/D,qDAAqD;AACrD,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAA;AAInE;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,mBAAmB,CAE5E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD"}

package/out/jp/address-unit.js

@@ -42,8 +42,8 @@
  */
 export const JP_ADMIN_SUFFIXES = ["都", "道", "府", "県", "市", "区", "郡", "町", "村"];
 /**
- * The markers that close the numbered tail of an address — Japan's stand-in for a house number,
- * since there is no named street to hang one on:
+ * The markers that close the numbered tail of an address — Japan's stand-in for a house number, since there is no named
+ * street to hang one on:
  *
  * - 丁目 (chōme) — a district block within a neighbourhood.
  * - 番地 (banchi) — a lot number.
@@ -53,19 +53,18 @@ export const JP_ADMIN_SUFFIXES = ["都", "道", "府", "県", "市", "区", "郡
 export const JP_BLOCK_MARKERS = ["丁目", "番地", "番", "号"];
 const ADMIN_SUFFIX_SET = new Set(JP_ADMIN_SUFFIXES);
 /**
- * True when a single kanji is one of the {@link JP_ADMIN_SUFFIXES} admin-area markers (`都`, `市`,
- * `区`, …). Strictly single-character: a multi-character input (even one ending in a suffix) is not
- * a suffix on its own.
+ * True when a single kanji is one of the {@link JP_ADMIN_SUFFIXES} admin-area markers (`都`, `市`, `区`, …). Strictly
+ * single-character: a multi-character input (even one ending in a suffix) is not a suffix on its own.
  */
 export function isJapaneseAdminSuffix(ch) {
     return typeof ch === "string" && ADMIN_SUFFIX_SET.has(ch);
 }
 /**
- * Strip a trailing admin-area suffix kanji from a place name, exposing the bare name (`東京都` → `東京`,
- * `大阪市` → `大阪`, `千代田区` → `千代田`). Leaves a name untouched if it does not end in an admin suffix.
+ * Strip a trailing admin-area suffix kanji from a place name, exposing the bare name (`東京都` → `東京`, `大阪市` → `大阪`,
+ * `千代田区` → `千代田`). Leaves a name untouched if it does not end in an admin suffix.
  *
- * Hokkaido (`北海道`) is the deliberate exception: its name ends in 道 but is indivisible, so it is
- * returned whole rather than clipped to `北海` — mirroring the same carve-out in `prefecture.ts`.
+ * Hokkaido (`北海道`) is the deliberate exception: its name ends in 道 but is indivisible, so it is returned whole rather
+ * than clipped to `北海` — mirroring the same carve-out in `prefecture.ts`.
  */
 export function stripAdminSuffix(name) {
     if (typeof name !== "string" || name.length === 0)

package/out/jp/address-unit.js.map

@@ -1 +1 @@
-{"version":3,"file":"address-unit.js","sourceRoot":"","sources":["../../jp/address-unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAA;AAKvF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAU,CAAA;AAK/D,MAAM,gBAAgB,GAAwB,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAA;AAExE;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,EAAW;IAChD,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC5C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAC9D,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,IAAI,CAAA;IAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAA;IACnC,OAAO,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AAC7D,CAAC"}
+{"version":3,"file":"address-unit.js","sourceRoot":"","sources":["../../jp/address-unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAU,CAAA;AAKvF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,CAAU,CAAA;AAK/D,MAAM,gBAAgB,GAAwB,IAAI,GAAG,CAAC,iBAAiB,CAAC,CAAA;AAExE;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,EAAW;IAChD,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC5C,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAA;IAE9D,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,IAAI,CAAA;IAC/B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAA;IAEnC,OAAO,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AAC7D,CAAC"}

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

@@ -23,9 +23,9 @@
  */
 import type { Tagged } from "type-fest";
 /**
- * A Japanese postal code: three digits, a hyphen, then four digits (`100-0001`), conventionally
- * written after the 〒 mark (`〒100-0001`). Branded so a normalized code is distinct from an
- * arbitrary string — the 7-digit shape alone does not prove a code is real, only well-formed.
+ * A Japanese postal code: three digits, a hyphen, then four digits (`100-0001`), conventionally written after the 〒
+ * mark (`〒100-0001`). Branded so a normalized code is distinct from an arbitrary string — the 7-digit shape alone does
+ * not prove a code is real, only well-formed.
  *
  * @category Postal
  * @type string
@@ -36,28 +36,25 @@ export type PostalCode = Tagged<string, "JpPostalCode">;
 /** The postal-code shape: `NNN-NNNN`, the hyphen optional on input (`1000001` or `100-0001`). */
 export declare const JP_POSTAL_CODE_PATTERN: RegExp;
 /**
- * Normalize a postal-code surface form to the canonical hyphenated `NNN-NNNN`: strip a leading 〒
- * mark and any whitespace, then re-insert the hyphen if the input gave the bare seven digits
- * (`〒100-0001` → `100-0001`, `1000001` → `100-0001`). Returns null if the result is not seven
- * digits.
+ * Normalize a postal-code surface form to the canonical hyphenated `NNN-NNNN`: strip a leading 〒 mark and any
+ * whitespace, then re-insert the hyphen if the input gave the bare seven digits (`〒100-0001` → `100-0001`, `1000001` →
+ * `100-0001`). Returns null if the result is not seven digits.
  */
 export declare function normalizeJpPostalCode(raw: unknown): PostalCode | null;
 /** Type-predicate for a Japanese postal code (hyphen optional, `100-0001` or `1000001`). */
 export declare function isJpPostalCode(input: unknown): input is PostalCode;
 /**
- * First digit of the postal code → a coarse region label. Japan Post's numbering grows roughly
- * outward from Tokyo (`1xx`) and is **approximate** at this granularity — a single leading digit
- * spans large, irregular areas and the boundaries are postal-routing, not administrative. Use it as
- * a weak prior, never as a hard region assignment; the full code is what actually anchors the
- * address.
+ * First digit of the postal code → a coarse region label. Japan Post's numbering grows roughly outward from Tokyo
+ * (`1xx`) and is **approximate** at this granularity — a single leading digit spans large, irregular areas and the
+ * boundaries are postal-routing, not administrative. Use it as a weak prior, never as a hard region assignment; the
+ * full code is what actually anchors the address.
  *
  * Approximate — the labels below are illustrative routing regions, not precise prefecture sets.
  */
 export declare const JP_FIRST_DIGIT_REGION: Record<string, string>;
 /**
- * The coarse region label for a postal code's first digit, or null if the input is not a Japanese
- * postal code. A weak, approximate prior (see {@link JP_FIRST_DIGIT_REGION}); the full code anchors
- * the address.
+ * The coarse region label for a postal code's first digit, or null if the input is not a Japanese postal code. A weak,
+ * approximate prior (see {@link JP_FIRST_DIGIT_REGION}); the full code anchors the address.
  */
 export declare function firstDigitRegion(postalCode: unknown): string | null;
 //# sourceMappingURL=postal-code.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"postal-code.d.ts","sourceRoot":"","sources":["../../jp/postal-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAEvD,iGAAiG;AACjG,eAAO,MAAM,sBAAsB,QAAmB,CAAA;AAEtD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAMrE;AAED,4FAA4F;AAC5F,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAElE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWxD,CAAA;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAInE"}
+{"version":3,"file":"postal-code.d.ts","sourceRoot":"","sources":["../../jp/postal-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAEvD,iGAAiG;AACjG,eAAO,MAAM,sBAAsB,QAAmB,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CAQrE;AAED,4FAA4F;AAC5F,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAElE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWxD,CAAA;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAMnE"}

package/out/jp/postal-code.js

@@ -24,10 +24,9 @@
 /** 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}$/;
 /**
- * Normalize a postal-code surface form to the canonical hyphenated `NNN-NNNN`: strip a leading 〒
- * mark and any whitespace, then re-insert the hyphen if the input gave the bare seven digits
- * (`〒100-0001` → `100-0001`, `1000001` → `100-0001`). Returns null if the result is not seven
- * digits.
+ * Normalize a postal-code surface form to the canonical hyphenated `NNN-NNNN`: strip a leading 〒 mark and any
+ * whitespace, then re-insert the hyphen if the input gave the bare seven digits (`〒100-0001` → `100-0001`, `1000001` →
+ * `100-0001`). Returns null if the result is not seven digits.
  */
 export function normalizeJpPostalCode(raw) {
     if (typeof raw !== "string")
@@ -43,11 +42,10 @@ export function isJpPostalCode(input) {
     return typeof input === "string" && JP_POSTAL_CODE_PATTERN.test(input);
 }
 /**
- * First digit of the postal code → a coarse region label. Japan Post's numbering grows roughly
- * outward from Tokyo (`1xx`) and is **approximate** at this granularity — a single leading digit
- * spans large, irregular areas and the boundaries are postal-routing, not administrative. Use it as
- * a weak prior, never as a hard region assignment; the full code is what actually anchors the
- * address.
+ * First digit of the postal code → a coarse region label. Japan Post's numbering grows roughly outward from Tokyo
+ * (`1xx`) and is **approximate** at this granularity — a single leading digit spans large, irregular areas and the
+ * boundaries are postal-routing, not administrative. Use it as a weak prior, never as a hard region assignment; the
+ * full code is what actually anchors the address.
  *
  * Approximate — the labels below are illustrative routing regions, not precise prefecture sets.
  */
@@ -64,9 +62,8 @@ export const JP_FIRST_DIGIT_REGION = {
     "9": "Tōhoku north / other",
 };
 /**
- * The coarse region label for a postal code's first digit, or null if the input is not a Japanese
- * postal code. A weak, approximate prior (see {@link JP_FIRST_DIGIT_REGION}); the full code anchors
- * the address.
+ * The coarse region label for a postal code's first digit, or null if the input is not a Japanese postal code. A weak,
+ * approximate prior (see {@link JP_FIRST_DIGIT_REGION}); the full code anchors the address.
  */
 export function firstDigitRegion(postalCode) {
     const normalized = normalizeJpPostalCode(postalCode);

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

@@ -1 +1 @@
-{"version":3,"file":"postal-code.js","sourceRoot":"","sources":["../../jp/postal-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAgBH,iGAAiG;AACjG,MAAM,CAAC,MAAM,sBAAsB,GAAG,gBAAgB,CAAA;AAEtD;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IACjD,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,iEAAiE;IACjE,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;IAC1E,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAA;IACxC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAgB,CAAA;AAChE,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,cAAc,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACvE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA2B;IAC5D,GAAG,EAAE,4BAA4B;IACjC,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,+BAA+B;IACpC,GAAG,EAAE,yBAAyB;IAC9B,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,gBAAgB;IACrB,GAAG,EAAE,sBAAsB;IAC3B,GAAG,EAAE,mBAAmB;IACxB,GAAG,EAAE,QAAQ;IACb,GAAG,EAAE,sBAAsB;CAC3B,CAAA;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAmB;IACnD,MAAM,UAAU,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAA;IACpD,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAC5B,OAAO,qBAAqB,CAAC,UAAU,CAAC,CAAC,CAAE,CAAC,IAAI,IAAI,CAAA;AACrD,CAAC"}
+{"version":3,"file":"postal-code.js","sourceRoot":"","sources":["../../jp/postal-code.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAgBH,iGAAiG;AACjG,MAAM,CAAC,MAAM,sBAAsB,GAAG,gBAAgB,CAAA;AAEtD;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAY;IACjD,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACxC,iEAAiE;IACjE,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;IAE1E,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC;QAAE,OAAO,IAAI,CAAA;IAExC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAgB,CAAA;AAChE,CAAC;AAED,4FAA4F;AAC5F,MAAM,UAAU,cAAc,CAAC,KAAc;IAC5C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACvE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA2B;IAC5D,GAAG,EAAE,4BAA4B;IACjC,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,+BAA+B;IACpC,GAAG,EAAE,yBAAyB;IAC9B,GAAG,EAAE,eAAe;IACpB,GAAG,EAAE,gBAAgB;IACrB,GAAG,EAAE,sBAAsB;IAC3B,GAAG,EAAE,mBAAmB;IACxB,GAAG,EAAE,QAAQ;IACb,GAAG,EAAE,sBAAsB;CAC3B,CAAA;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAmB;IACnD,MAAM,UAAU,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAA;IAEpD,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IAE5B,OAAO,qBAAqB,CAAC,UAAU,CAAC,CAAC,CAAE,CAAC,IAAI,IAAI,CAAA;AACrD,CAAC"}

package/out/jp/prefecture.d.ts

@@ -36,8 +36,8 @@ export interface JapanesePrefectureInfo {
     type: JapanesePrefectureType;
 }
 /**
- * ISO 3166-2:JP numeric code → info, for all 47 prefectures. Ordered by code, which is also the
- * conventional north-to-south-ish ordering (Hokkaido `01` at the top, Okinawa `47` at the bottom).
+ * ISO 3166-2:JP numeric code → info, for all 47 prefectures. Ordered by code, which is also the conventional
+ * north-to-south-ish ordering (Hokkaido `01` at the top, Okinawa `47` at the bottom).
  */
 export declare const JP_PREFECTURES: {
     readonly "01": {
@@ -328,17 +328,17 @@ export type JapanesePrefectureCode = keyof typeof JP_PREFECTURES;
 /** Type-predicate for an ISO 3166-2:JP prefecture code (`"01"`..`"47"`). */
 export declare function isJapanesePrefectureCode(input: unknown): input is JapanesePrefectureCode;
 /**
- * Folded romaji / kanji surface form → ISO 3166-2:JP code. Every prefecture contributes several
- * keys: the macron-folded romaji (and the suffixed `name-ken` form folds to the same key), the full
- * kanji (`東京都`), and the suffix-less kanji (`東京`). Hokkaido keeps its 道 in both kanji keys.
+ * Folded romaji / kanji surface form → ISO 3166-2:JP code. Every prefecture contributes several keys: the macron-folded
+ * romaji (and the suffixed `name-ken` form folds to the same key), the full kanji (`東京都`), and the suffix-less kanji
+ * (`東京`). Hokkaido keeps its 道 in both kanji keys.
  */
 export declare const JP_PREFECTURE_NAME_TO_CODE: ReadonlyMap<string, JapanesePrefectureCode>;
 /**
  * Resolve a Japanese prefecture surface form to its ISO 3166-2:JP code, accepting:
  *
  * - A code directly (`"13"` → `"13"`),
- * - A romaji name, case-insensitive, macrons optional, with OR without the romaji type-suffix
- *   (`Tōkyō` / `Tokyo` / `tokyo` / `Tokyo-to` → `"13"`),
+ * - A romaji name, case-insensitive, macrons optional, with OR without the romaji type-suffix (`Tōkyō` / `Tokyo` /
+ *   `tokyo` / `Tokyo-to` → `"13"`),
  * - A kanji name, with or without its 都/道/府/県 suffix (`東京都` / `東京` → `"13"`).
  *
  * Returns null for anything it cannot place.

package/out/jp/prefecture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefecture.d.ts","sourceRoot":"","sources":["../../jp/prefecture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iEAAiE;AACjE,MAAM,MAAM,sBAAsB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAA;AAE/D,8FAA8F;AAC9F,MAAM,WAAW,sBAAsB;IACtC,oGAAoG;IACpG,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAA;IACb,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,IAAI,EAAE,sBAAsB,CAAA;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDgC,CAAA;AAE3D,yDAAyD;AACzD,MAAM,MAAM,sBAAsB,GAAG,MAAM,OAAO,cAAc,CAAA;AAIhE,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAExF;AAiCD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAS/E,CAAA;AAEJ;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,sBAAsB,GAAG,IAAI,CAMxG"}
+{"version":3,"file":"prefecture.d.ts","sourceRoot":"","sources":["../../jp/prefecture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,iEAAiE;AACjE,MAAM,MAAM,sBAAsB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAA;AAE/D,8FAA8F;AAC9F,MAAM,WAAW,sBAAsB;IACtC,oGAAoG;IACpG,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAA;IACb,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,IAAI,EAAE,sBAAsB,CAAA;CAC5B;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDgC,CAAA;AAE3D,yDAAyD;AACzD,MAAM,MAAM,sBAAsB,GAAG,MAAM,OAAO,cAAc,CAAA;AAIhE,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,sBAAsB,CAExF;AAkCD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAW/E,CAAA;AAEJ;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,sBAAsB,GAAG,IAAI,CAQxG"}

package/out/jp/prefecture.js

@@ -23,8 +23,8 @@
  *   `postal-code.ts` for why the postcode is nonetheless the single most reliable anchor.
  */
 /**
- * ISO 3166-2:JP numeric code → info, for all 47 prefectures. Ordered by code, which is also the
- * conventional north-to-south-ish ordering (Hokkaido `01` at the top, Okinawa `47` at the bottom).
+ * ISO 3166-2:JP numeric code → info, for all 47 prefectures. Ordered by code, which is also the conventional
+ * north-to-south-ish ordering (Hokkaido `01` at the top, Okinawa `47` at the bottom).
  */
 export const JP_PREFECTURES = {
     "01": { code: "01", kanji: "北海道", romaji: "Hokkaido", type: "do" },
@@ -83,14 +83,13 @@ export function isJapanesePrefectureCode(input) {
 /**
  * Fold a romaji surface form so `Tōkyō`, `Tokyo`, and `Tokyo-to` all key alike: strip macrons (NFD
  *
- * - Drop the combining marks), lowercase, peel off an appended `-to`/`-do`/`-fu`/`-ken` type-suffix,
- *   then drop everything but `a-z`. `Tōkyō-to` and `tokyo` both → `tokyo`.
+ * - Drop the combining marks), lowercase, peel off an appended `-to`/`-do`/`-fu`/`-ken` type-suffix, then drop everything
+ *   but `a-z`. `Tōkyō-to` and `tokyo` both → `tokyo`.
  *
- * The suffix is only stripped when it is a genuine appendage — separated by a
- * hyphen/space/middle-dot (`Tokyo-to`, `Osaka fu`) or trailing the macron-bearing long-vowel form.
- * That guard is essential: four bare romaji names already END in a suffix syllable (Kyo**to**,
- * Gi**fu**, Hokkai**do**, Kumamo**to**), and a blind trailing-strip would maim them. We never strip
- * from an unseparated bare name, so `kyoto` stays `kyoto`.
+ * The suffix is only stripped when it is a genuine appendage — separated by a hyphen/space/middle-dot (`Tokyo-to`,
+ * `Osaka fu`) or trailing the macron-bearing long-vowel form. That guard is essential: four bare romaji names already
+ * END in a suffix syllable (Kyo**to**, Gi**fu**, Hokkai**do**, Kumamo**to**), and a blind trailing-strip would maim
+ * them. We never strip from an unseparated bare name, so `kyoto` stays `kyoto`.
  */
 function foldRomaji(s) {
     const lowered = s
@@ -102,8 +101,8 @@ function foldRomaji(s) {
     return desuffixed.replace(/[^a-z]/g, "");
 }
 /**
- * Strip the trailing 都/道/府/県 admin kanji from a prefecture name (`東京都` → `東京`). Hokkaido is the
- * exception: `北海道` ends in 道 but is a single indivisible name, so it is left whole.
+ * Strip the trailing 都/道/府/県 admin kanji from a prefecture name (`東京都` → `東京`). Hokkaido is the exception: `北海道` ends
+ * in 道 but is a single indivisible name, so it is left whole.
  */
 function stripKanjiSuffix(kanji) {
     if (kanji === "北海道")
@@ -111,9 +110,9 @@ function stripKanjiSuffix(kanji) {
     return kanji.replace(/[都道府県]$/, "");
 }
 /**
- * Folded romaji / kanji surface form → ISO 3166-2:JP code. Every prefecture contributes several
- * keys: the macron-folded romaji (and the suffixed `name-ken` form folds to the same key), the full
- * kanji (`東京都`), and the suffix-less kanji (`東京`). Hokkaido keeps its 道 in both kanji keys.
+ * Folded romaji / kanji surface form → ISO 3166-2:JP code. Every prefecture contributes several keys: the macron-folded
+ * romaji (and the suffixed `name-ken` form folds to the same key), the full kanji (`東京都`), and the suffix-less kanji
+ * (`東京`). Hokkaido keeps its 道 in both kanji keys.
  */
 export const JP_PREFECTURE_NAME_TO_CODE = (() => {
     const out = new Map();
@@ -129,8 +128,8 @@ export const JP_PREFECTURE_NAME_TO_CODE = (() => {
  * Resolve a Japanese prefecture surface form to its ISO 3166-2:JP code, accepting:
  *
  * - A code directly (`"13"` → `"13"`),
- * - A romaji name, case-insensitive, macrons optional, with OR without the romaji type-suffix
- *   (`Tōkyō` / `Tokyo` / `tokyo` / `Tokyo-to` → `"13"`),
+ * - A romaji name, case-insensitive, macrons optional, with OR without the romaji type-suffix (`Tōkyō` / `Tokyo` /
+ *   `tokyo` / `Tokyo-to` → `"13"`),
  * - A kanji name, with or without its 都/道/府/県 suffix (`東京都` / `東京` → `"13"`).
  *
  * Returns null for anything it cannot place.