@mailwoman/codex 4.0.0

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

@@ -0,0 +1,72 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Japan's analog of a "street-type" module — except the lesson here is the absence. Where
+ *   `us/street-suffix.ts` and `de/street-type.ts` exist to recognize the named-street part of an
+ *   address, Japan has **no street names** to recognize. A Japanese address is built from nested
+ *   administrative units and numbered blocks/lots, written largest-to-smallest:
+ *
+ *   ```
+ *   東京都 千代田区 千代田 1丁目 1番 1号
+ *   Tokyo-to · Chiyoda-ku · Chiyoda · 1-chōme · 1-ban · 1-gō
+ * ```
+ *
+ *   So instead of a street-suffix table this file ships two marker sets:
+ *
+ *   - {@link JP_ADMIN_SUFFIXES} — the kanji that close an administrative-area name (都/道/府/県 at the
+ *       prefecture level, then 市/区/郡/町/村 for city / ward / district / town / village). These are
+ *       the Japanese equivalent of a US street suffix in the parsing sense: the token-final marker
+ *       that tells you what KIND of unit the preceding name is.
+ *   - {@link JP_BLOCK_MARKERS} — the markers that close the numbered tail (丁目 / 番地 / 番 / 号), the part
+ *       that actually does the "house number" job in the absence of streets.
+ *
+ *   Note the reverse field order: the admin suffixes appear FIRST in the string (prefecture leads),
+ *   and the block markers LAST — the mirror image of a US line, where the house number leads and
+ *   the ZIP trails. See `postal-code.ts` for why, with no street name, the postcode is the primary
+ *   anchor.
+ */
+/**
+ * The kanji suffixes that close an administrative-area name, largest unit to smallest:
+ *
+ * - 都 (to) — metropolis; only Tokyo.
+ * - 道 (dō) — circuit; only Hokkaido.
+ * - 府 (fu) — urban prefecture; Osaka and Kyoto.
+ * - 県 (ken) — prefecture; the other 43.
+ * - 市 (shi) — city.
+ * - 区 (ku) — ward (a subdivision of a designated city, e.g. Tokyo's 23 special wards).
+ * - 郡 (gun) — district / county (rural grouping of towns and villages).
+ * - 町 (chō / machi) — town.
+ * - 村 (son / mura) — village.
+ */
+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:
+ *
+ * - 丁目 (chōme) — a district block within a neighbourhood.
+ * - 番地 (banchi) — a lot number.
+ * - 番 (ban) — block number (the `番` in the modern `chōme-ban-gō` triple).
+ * - 号 (gō) — building number (the final element of the triple).
+ */
+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.
+ */
+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.
+ *
+ * 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

@@ -0,0 +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"}

package/out/jp/address-unit.js

@@ -0,0 +1,78 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Japan's analog of a "street-type" module — except the lesson here is the absence. Where
+ *   `us/street-suffix.ts` and `de/street-type.ts` exist to recognize the named-street part of an
+ *   address, Japan has **no street names** to recognize. A Japanese address is built from nested
+ *   administrative units and numbered blocks/lots, written largest-to-smallest:
+ *
+ *   ```
+ *   東京都 千代田区 千代田 1丁目 1番 1号
+ *   Tokyo-to · Chiyoda-ku · Chiyoda · 1-chōme · 1-ban · 1-gō
+ * ```
+ *
+ *   So instead of a street-suffix table this file ships two marker sets:
+ *
+ *   - {@link JP_ADMIN_SUFFIXES} — the kanji that close an administrative-area name (都/道/府/県 at the
+ *       prefecture level, then 市/区/郡/町/村 for city / ward / district / town / village). These are
+ *       the Japanese equivalent of a US street suffix in the parsing sense: the token-final marker
+ *       that tells you what KIND of unit the preceding name is.
+ *   - {@link JP_BLOCK_MARKERS} — the markers that close the numbered tail (丁目 / 番地 / 番 / 号), the part
+ *       that actually does the "house number" job in the absence of streets.
+ *
+ *   Note the reverse field order: the admin suffixes appear FIRST in the string (prefecture leads),
+ *   and the block markers LAST — the mirror image of a US line, where the house number leads and
+ *   the ZIP trails. See `postal-code.ts` for why, with no street name, the postcode is the primary
+ *   anchor.
+ */
+/**
+ * The kanji suffixes that close an administrative-area name, largest unit to smallest:
+ *
+ * - 都 (to) — metropolis; only Tokyo.
+ * - 道 (dō) — circuit; only Hokkaido.
+ * - 府 (fu) — urban prefecture; Osaka and Kyoto.
+ * - 県 (ken) — prefecture; the other 43.
+ * - 市 (shi) — city.
+ * - 区 (ku) — ward (a subdivision of a designated city, e.g. Tokyo's 23 special wards).
+ * - 郡 (gun) — district / county (rural grouping of towns and villages).
+ * - 町 (chō / machi) — town.
+ * - 村 (son / mura) — village.
+ */
+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:
+ *
+ * - 丁目 (chōme) — a district block within a neighbourhood.
+ * - 番地 (banchi) — a lot number.
+ * - 番 (ban) — block number (the `番` in the modern `chōme-ban-gō` triple).
+ * - 号 (gō) — building number (the final element of the triple).
+ */
+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.
+ */
+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.
+ *
+ * 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)
+        return name;
+    if (name === "北海道")
+        return name;
+    const last = name[name.length - 1];
+    return ADMIN_SUFFIX_SET.has(last) ? name.slice(0, -1) : name;
+}
+//# sourceMappingURL=address-unit.js.map

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

@@ -0,0 +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"}

package/out/jp/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The Japanese address system (Japan Post / ISO 3166-2:JP): the 47 prefectures, the postal code
+ *   that is the country's most reliable geographic anchor, and the address-unit markers that stand
+ *   in for the street names Japan does not use.
+ */
+export * from "./address-unit.js";
+export * from "./postal-code.js";
+export * from "./prefecture.js";
+//# sourceMappingURL=index.d.ts.map

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

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

package/out/jp/index.js

@@ -0,0 +1,13 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The Japanese address system (Japan Post / ISO 3166-2:JP): the 47 prefectures, the postal code
+ *   that is the country's most reliable geographic anchor, and the address-unit markers that stand
+ *   in for the street names Japan does not use.
+ */
+export * from "./address-unit.js";
+export * from "./postal-code.js";
+export * from "./prefecture.js";
+//# sourceMappingURL=index.js.map

package/out/jp/index.js.map

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

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

@@ -0,0 +1,63 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Japanese postal codes (郵便番号, yūbin-bangō): the branded type, the shape, normalization, and the
+ *   first-digit → coarse-region prior.
+ *
+ *   This file is the far end of a spectrum whose other end is `us/zipcode.ts`. A US address leans on
+ *   the street line — a named street plus a house number — and the ZIP is a routing convenience. A
+ *   Japanese address is the inverse on two counts:
+ *
+ *   - It is written **largest-to-smallest**: prefecture → city/ward → district → block → lot (`東京都 千代田区
+ *       千代田 1-1`), the reverse of the US smallest-to-largest line order.
+ *   - There are **essentially no street names**. Outside a few Kyoto-style exceptions, you do not
+ *       navigate by named streets; you navigate by nested administrative areas and numbered
+ *       blocks/lots (丁目 / 番地 / 号 — see `address-unit.ts`).
+ *
+ *   With no street name to anchor on and a reverse field order, the **postal code is the single most
+ *   reliable geographic anchor** for a Japanese address — it pins the chōme-level area directly,
+ *   far tighter than a US ZIP pins a US address. So where the US parser treats the postcode as a
+ *   tie-breaker behind the street, the Japan parser should treat it as the primary key.
+ */
+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.
+ *
+ * @category Postal
+ * @type string
+ * @title 郵便番号
+ * @pattern ^\d{3}-?\d{4}$
+ */
+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.
+ */
+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.
+ *
+ * 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.
+ */
+export declare function firstDigitRegion(postalCode: unknown): string | null;
+//# sourceMappingURL=postal-code.d.ts.map

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

@@ -0,0 +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"}

package/out/jp/postal-code.js

@@ -0,0 +1,77 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   Japanese postal codes (郵便番号, yūbin-bangō): the branded type, the shape, normalization, and the
+ *   first-digit → coarse-region prior.
+ *
+ *   This file is the far end of a spectrum whose other end is `us/zipcode.ts`. A US address leans on
+ *   the street line — a named street plus a house number — and the ZIP is a routing convenience. A
+ *   Japanese address is the inverse on two counts:
+ *
+ *   - It is written **largest-to-smallest**: prefecture → city/ward → district → block → lot (`東京都 千代田区
+ *       千代田 1-1`), the reverse of the US smallest-to-largest line order.
+ *   - There are **essentially no street names**. Outside a few Kyoto-style exceptions, you do not
+ *       navigate by named streets; you navigate by nested administrative areas and numbered
+ *       blocks/lots (丁目 / 番地 / 号 — see `address-unit.ts`).
+ *
+ *   With no street name to anchor on and a reverse field order, the **postal code is the single most
+ *   reliable geographic anchor** for a Japanese address — it pins the chōme-level area directly,
+ *   far tighter than a US ZIP pins a US address. So where the US parser treats the postcode as a
+ *   tie-breaker behind the street, the Japan parser should treat it as the primary key.
+ */
+/** 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.
+ */
+export function normalizeJpPostalCode(raw) {
+    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, "");
+    if (!/^\d{7}$/.test(digits))
+        return null;
+    return `${digits.slice(0, 3)}-${digits.slice(3)}`;
+}
+/** Type-predicate for a Japanese postal code (hyphen optional, `100-0001` or `1000001`). */
+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.
+ *
+ * Approximate — the labels below are illustrative routing regions, not precise prefecture sets.
+ */
+export const JP_FIRST_DIGIT_REGION = {
+    "0": "Hokkaido & northern Tōhoku",
+    "1": "Tokyo & Kanto",
+    "2": "Kanagawa / Shizuoka & central",
+    "3": "northern Kanto / Tōhoku",
+    "4": "Tōkai / Chūbu",
+    "5": "Kinki / Kansai",
+    "6": "Kinki / Chūgoku west",
+    "7": "Chūgoku / Shikoku",
+    "8": "Kyūshū",
+    "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.
+ */
+export function firstDigitRegion(postalCode) {
+    const normalized = normalizeJpPostalCode(postalCode);
+    if (!normalized)
+        return null;
+    return JP_FIRST_DIGIT_REGION[normalized[0]] ?? null;
+}
+//# sourceMappingURL=postal-code.js.map

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

@@ -0,0 +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"}