@forwardslashns/fws-geo-location-api 1.0.0

package/README.md

@@ -0,0 +1,509 @@
+# @forwardslashns/fws-geo-location-api
+
+> **FWS company-dedicated TypeScript wrapper around the [GeoNames](https://www.geonames.org) geolocation service.**
+
+Provides strongly-typed access to countries, administrative regions (states/provinces), cities, and postal codes — with automatic username rotation, global restriction support, paginated results, cursor-based chunked iteration, and frontend-friendly display names.
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Prerequisites](#prerequisites)
+- [Quick Start](#quick-start)
+- [Constructor](#constructor)
+- [Methods](#methods)
+  - [getCountries](#getcountries)
+  - [getRegions](#getregions)
+  - [getCities](#getcities)
+  - [getPostalCodes](#getpostalcodes)
+  - [getPostalCodesPage](#getpostalcodespage)
+  - [getAllPostalCodes](#getallpostalcodes)
+  - [findPostalCode](#findpostalcode)
+- [Types](#types)
+- [Constants](#constants)
+- [Error Handling](#error-handling)
+- [Global Restrictions](#global-restrictions)
+- [Username Rotation](#username-rotation)
+- [Publishing (FWS internal)](#publishing-fws-internal)
+
+---
+
+## Installation
+
+```bash
+pnpm add @forwardslashns/fws-geo-location-api
+```
+
+---
+
+## Prerequisites
+
+This library authenticates against the **GeoNames free API** using account usernames, not API keys.
+
+1. Register one or more free accounts at https://www.geonames.org/login
+2. Enable the free web services for each account in your profile settings
+3. Pass the usernames in the `usernames` option when constructing the client
+
+> The free tier allows ~20,000 credits per username per day. For high-volume applications register multiple service accounts and pass them all — the client will rotate automatically on rate-limit errors.
+
+---
+
+## Quick Start
+
+```typescript
+import { GeoLocationClient } from '@forwardslashns/fws-geo-location-api';
+
+const client = new GeoLocationClient({
+  usernames: ['myGeoNamesUser1', 'myGeoNamesUser2'],
+});
+
+// All countries
+const countries = await client.getCountries();
+
+// European countries only
+const europe = await client.getCountries({ continents: ['EU'] });
+
+// States / provinces for Germany
+const regions = await client.getRegions('DE');
+console.log(regions.data); // Region[]
+
+// Cities in New York state
+const cities = await client.getCities('US', { regionCode: 'NY' });
+console.log(cities.data); // City[]
+
+// Postal codes starting with "10" in the Netherlands
+const postalCodes = await client.getPostalCodes('NL', { postalCodePrefix: '10' });
+console.log(postalCodes.data); // PostalCode[]
+
+// Look up a single postal code
+const zip = await client.findPostalCode('10001', 'US');
+console.log(zip?.displayName); // "10001 — New York City, New York, United States"
+```
+
+---
+
+## Constructor
+
+### `new GeoLocationClient(options)`
+
+| Option                    | Type                    | Required | Description                                                                       |
+| ------------------------- | ----------------------- | -------- | --------------------------------------------------------------------------------- |
+| `usernames`               | `[string, ...string[]]` | ✅       | One or more GeoNames usernames. TypeScript enforces at least one at compile time. |
+| `restrictions.continents` | `ContinentCode[]`       | —        | Global continent filter applied to every call (can be overridden per call).       |
+| `restrictions.countries`  | `string[]`              | —        | Global ISO 3166-1 alpha-2 country code allow-list applied to every call.          |
+
+```typescript
+const client = new GeoLocationClient({
+  usernames: ['user1', 'user2'],
+  restrictions: {
+    continents: ['EU'],
+  },
+});
+```
+
+---
+
+## Methods
+
+### `getCountries`
+
+```typescript
+getCountries(options?: GetCountriesOptions): Promise<Country[]>
+```
+
+Returns all countries (or a filtered subset). Not paginated — the GeoNames country list is small (~250 entries).
+
+| Option         | Type              | Description                                                   |
+| -------------- | ----------------- | ------------------------------------------------------------- |
+| `continents`   | `ContinentCode[]` | Filter to specific continents (overrides global restriction). |
+| `countryCodes` | `string[]`        | Filter to specific ISO2 codes (overrides global restriction). |
+
+```typescript
+// All countries
+const all = await client.getCountries();
+
+// Only DACH
+const dach = await client.getCountries({ countryCodes: ['DE', 'AT', 'CH'] });
+
+// Only Europe
+const eu = await client.getCountries({ continents: ['EU'] });
+```
+
+**`Country` fields:**
+
+| Field           | Type       | Description                                 |
+| --------------- | ---------- | ------------------------------------------- |
+| `countryCode`   | `string`   | ISO 3166-1 alpha-2, e.g. `"DE"`             |
+| `countryName`   | `string`   | English name, e.g. `"Germany"`              |
+| `continent`     | `string`   | Two-letter continent code, e.g. `"EU"`      |
+| `continentName` | `string`   | Continent full name, e.g. `"Europe"`        |
+| `capital`       | `string`   | Capital city name                           |
+| `currencyCode`  | `string`   | ISO 4217 currency code, e.g. `"EUR"`        |
+| `currencyName`  | `string`   | Currency display name, e.g. `"Euro"`        |
+| `population`    | `number`   | Total country population                    |
+| `languages`     | `string[]` | BCP 47 language codes spoken in the country |
+| `areaInSqKm`    | `number`   | Land area in square kilometres              |
+| `geonameId`     | `number`   | GeoNames unique identifier                  |
+
+---
+
+### `getRegions`
+
+```typescript
+getRegions(countryCode: string, options?: GetRegionsOptions): Promise<PaginatedResult<Region>>
+```
+
+Returns first-order administrative divisions (states, provinces, prefectures, etc.) for a country.
+
+| Option    | Type     | Description                                        |
+| --------- | -------- | -------------------------------------------------- |
+| `maxRows` | `number` | Max results (GeoNames cap: 1 000). Default: 1 000. |
+| `page`    | `number` | 1-based page number. Default: 1.                   |
+
+```typescript
+const result = await client.getRegions('US');
+console.log(result.data); // Region[]
+console.log(result.total); // total count
+console.log(result.hasMore); // boolean
+```
+
+**`Region` fields:**
+
+| Field         | Type     | Description                          |
+| ------------- | -------- | ------------------------------------ |
+| `geonameId`   | `number` | GeoNames unique identifier           |
+| `name`        | `string` | Region name, e.g. `"New York"`       |
+| `code`        | `string` | Short admin code, e.g. `"NY"`        |
+| `isoCode`     | `string` | Full ISO code, e.g. `"US-NY"`        |
+| `countryCode` | `string` | Parent country ISO2 code             |
+| `population`  | `number` | Population (0 if unknown)            |
+| `lat`         | `number` | Latitude of centroid                 |
+| `lng`         | `number` | Longitude of centroid                |
+| `featureCode` | `string` | GeoNames feature code, e.g. `"ADM1"` |
+| `adminCode1`  | `string` | Raw admin level-1 code from GeoNames |
+
+---
+
+### `getCities`
+
+```typescript
+getCities(countryCode: string | null, options?: GetCitiesOptions): Promise<PaginatedResult<City>>
+```
+
+Returns populated places. Pass `null` for `countryCode` to search globally.
+
+| Option       | Type                                         | Description                                        |
+| ------------ | -------------------------------------------- | -------------------------------------------------- |
+| `regionCode` | `string`                                     | Filter by admin level-1 code (state/province).     |
+| `searchTerm` | `string`                                     | Filter by place name prefix.                       |
+| `maxRows`    | `number`                                     | Max results (GeoNames cap: 1 000). Default: 1 000. |
+| `orderBy`    | `'population' \| 'elevation' \| 'relevance'` | Sort order. Default: `'population'`.               |
+| `page`       | `number`                                     | 1-based page number. Default: 1.                   |
+
+```typescript
+// 100 most populous Japanese cities
+const result = await client.getCities('JP', { maxRows: 100 });
+
+// Global search — find all cities named "Paris"
+const paris = await client.getCities(null, { searchTerm: 'Paris' });
+
+// New York state cities
+const nyc = await client.getCities('US', { regionCode: 'NY' });
+```
+
+**`City` fields:**
+
+| Field         | Type     | Description                         |
+| ------------- | -------- | ----------------------------------- |
+| `geonameId`   | `number` | GeoNames unique identifier          |
+| `name`        | `string` | City name                           |
+| `countryCode` | `string` | ISO2 country code                   |
+| `adminName1`  | `string` | Region / state name                 |
+| `adminCode1`  | `string` | Region short code                   |
+| `population`  | `number` | Population                          |
+| `lat`         | `number` | Latitude                            |
+| `lng`         | `number` | Longitude                           |
+| `featureCode` | `string` | GeoNames feature code, e.g. `"PPL"` |
+| `featureName` | `string` | Human-readable feature type         |
+
+---
+
+### `getPostalCodes`
+
+```typescript
+getPostalCodes(countryCode: string, options?: GetPostalCodesOptions): Promise<PaginatedResult<PostalCode>>
+```
+
+Returns postal codes matching the supplied filter. **A filter is required for large countries** (US, DE, etc.) due to a GeoNames dataset-size limit — callers that omit a filter for an oversized country receive a descriptive `GeoLocationError` pointing them to `getAllPostalCodes` or `getPostalCodesPage`.
+
+| Option             | Type     | Description                                             |
+| ------------------ | -------- | ------------------------------------------------------- |
+| `postalCodePrefix` | `string` | Return codes whose postal code starts with this string. |
+| `placeName`        | `string` | Return codes whose place name starts with this string.  |
+| `maxRows`          | `number` | Max results (GeoNames cap: 1 000). Default: 100.        |
+| `page`             | `number` | 1-based page number. Default: 1.                        |
+
+```typescript
+// ZIP codes in the Netherlands starting with "10"
+const nld = await client.getPostalCodes('NL', { postalCodePrefix: '10' });
+
+// US codes filtered by city name
+const nyZips = await client.getPostalCodes('US', { placeName: 'New York', maxRows: 20 });
+```
+
+Each result has a `displayName` formatted for dropdowns:
+
+```
+"10001 — New York City, New York, United States"
+```
+
+---
+
+### `getPostalCodesPage`
+
+```typescript
+getPostalCodesPage(countryCode: string, options?: GetPostalCodePageOptions): Promise<PostalCodePage>
+```
+
+Cursor-based paginated iteration over the **entire** postal code dataset of a country, including large countries like the US. Internally iterates 36 alphanumeric prefix buckets (0–9, A–Z) so every call works regardless of country size.
+
+Typical cost: **1 GeoNames API request per call** (occasionally 2 at a prefix bucket boundary).
+
+| Option    | Type     | Description                                                                            |
+| --------- | -------- | -------------------------------------------------------------------------------------- |
+| `cursor`  | `string` | Opaque cursor returned by the previous call. Omit to start from the first postal code. |
+| `maxRows` | `number` | Records per page (capped at 500). Default: 100.                                        |
+
+**Returns `PostalCodePage`:**
+
+| Field            | Type                          | Description                                                        |
+| ---------------- | ----------------------------- | ------------------------------------------------------------------ |
+| `data`           | `PostalCode[]`                | Postal codes for this page.                                        |
+| `nextCursor`     | `string \| null`              | Pass to the next call to get the following page. `null` when done. |
+| `hasMore`        | `boolean`                     | Convenience alias: `true` when `nextCursor` is not `null`.         |
+| `prefixProgress` | `{ done: number; total: 36 }` | How many of the 36 prefix buckets have been fully processed.       |
+
+```typescript
+// Iterate all US postal codes in pages of 200
+let page = await client.getPostalCodesPage('US', { maxRows: 200 });
+
+while (true) {
+  for (const zip of page.data) {
+    console.log(zip.postalCode, zip.placeName);
+  }
+
+  if (!page.hasMore) break;
+  page = await client.getPostalCodesPage('US', {
+    cursor: page.nextCursor!,
+    maxRows: 200,
+  });
+}
+```
+
+> **Tip:** Store the cursor externally to resume across sessions or HTTP requests.
+
+---
+
+### `getAllPostalCodes`
+
+```typescript
+getAllPostalCodes(countryCode: string, options?: GetAllPostalCodesOptions): Promise<PostalCode[]>
+```
+
+Fetches every postal code for a country in a single call by iterating all 36 prefix buckets internally. Results are deduplicated and returned sorted by postal code. For the US (~43 000 codes) this makes ~80 GeoNames requests.
+
+| Option       | Type                                          | Description                                                                      |
+| ------------ | --------------------------------------------- | -------------------------------------------------------------------------------- |
+| `onProgress` | `(loaded: ReadonlyArray<PostalCode>) => void` | Called after each prefix bucket is fetched. Use to stream progress into your UI. |
+
+```typescript
+const allCodes = await client.getAllPostalCodes('DE', {
+  onProgress: (loaded) => {
+    console.log(`${loaded.length} codes loaded so far…`);
+  },
+});
+
+console.log(`Total: ${allCodes.length}`);
+```
+
+> **Use this method** when you need the complete dataset in memory (e.g. to build a local search index). Use `getPostalCodesPage` when you only need a few pages at a time.
+
+---
+
+### `findPostalCode`
+
+```typescript
+findPostalCode(postalCode: string, countryCode: string): Promise<PostalCode | null>
+```
+
+Looks up a single postal code by its exact string. Returns `null` when not found. Uses exactly 1 GeoNames API credit.
+
+```typescript
+const result = await client.findPostalCode('SW1A 1AA', 'GB');
+if (result) {
+  console.log(result.displayName);
+  // "SW1A 1AA — Westminster, England, United Kingdom"
+}
+
+const missing = await client.findPostalCode('00000', 'US');
+console.log(missing); // null
+```
+
+---
+
+## Types
+
+### `PaginatedResult<T>`
+
+Returned by `getRegions`, `getCities`, and `getPostalCodes`.
+
+```typescript
+interface PaginatedResult<T> {
+  data: T[];
+  total: number; // -1 when GeoNames does not return an exact count
+  page: number; // 1-based
+  pageSize: number;
+  hasMore: boolean;
+}
+```
+
+### `PostalCode`
+
+```typescript
+interface PostalCode {
+  postalCode: string;
+  placeName: string;
+  countryCode: string;
+  countryName: string;
+  adminName1: string; // state / region
+  adminCode1: string;
+  adminName2: string; // district / county
+  adminCode2: string;
+  lat: number;
+  lng: number;
+  /** Pre-formatted label: "10001 — New York City, New York, United States" */
+  displayName: string;
+}
+```
+
+### `PostalCodePage`
+
+Returned by `getPostalCodesPage`.
+
+```typescript
+interface PostalCodePage {
+  data: PostalCode[];
+  nextCursor: string | null;
+  hasMore: boolean;
+  prefixProgress: { done: number; total: 36 };
+}
+```
+
+### `AtLeastOne<T>`
+
+Utility type enforcing a non-empty array at compile time.
+
+```typescript
+type AtLeastOne<T> = [T, ...T[]];
+```
+
+---
+
+## Constants
+
+### Continent codes
+
+```typescript
+import { CONTINENT_CODES, CONTINENT_NAMES } from '@forwardslashns/fws-geo-location-api';
+
+CONTINENT_CODES.AFRICA; // 'AF'
+CONTINENT_CODES.ANTARCTICA; // 'AN'
+CONTINENT_CODES.ASIA; // 'AS'
+CONTINENT_CODES.EUROPE; // 'EU'
+CONTINENT_CODES.NORTH_AMERICA; // 'NA'
+CONTINENT_CODES.OCEANIA; // 'OC'
+CONTINENT_CODES.SOUTH_AMERICA; // 'SA'
+
+CONTINENT_NAMES['EU']; // 'Europe'
+CONTINENT_NAMES['NA']; // 'North America'
+```
+
+---
+
+## Error Handling
+
+```typescript
+import { GeoLocationClient, GeoLocationError } from '@forwardslashns/fws-geo-location-api';
+
+try {
+  const countries = await client.getCountries();
+} catch (err) {
+  if (err instanceof GeoLocationError) {
+    console.error(err.message); // human-readable description
+    console.error(err.code); // GeoNames numeric status code, if applicable
+  }
+}
+```
+
+### Common error scenarios
+
+| Scenario                                         | Behaviour                                                                            |
+| ------------------------------------------------ | ------------------------------------------------------------------------------------ |
+| `getPostalCodes` without filter on large country | Throws `GeoLocationError` explaining the limit and recommending `getPostalCodesPage` |
+| All usernames exhausted (rate-limited)           | Throws `GeoLocationError` asking to add usernames or wait for credit reset           |
+| Invalid / empty `countryCode`                    | Throws `GeoLocationError` immediately (no network call made)                         |
+| GeoNames returns status for no results           | Returns empty `PaginatedResult` (not an error)                                       |
+
+---
+
+## Global Restrictions
+
+```typescript
+const client = new GeoLocationClient({
+  usernames: ['myUser'],
+  restrictions: {
+    continents: ['EU'], // only European data
+    countries: ['DE', 'AT', 'CH'], // only DACH countries
+  },
+});
+
+// All calls are automatically filtered by the restrictions
+const countries = await client.getCountries(); // returns only DE, AT, CH
+const cities = await client.getCities('FR'); // returns nothing — FR not in allow-list
+```
+
+---
+
+## Username Rotation
+
+When a username exceeds its daily/hourly/weekly credit limit (GeoNames status codes 17–20) the client automatically advances to the next username in the array. The current call is transparently retried with the new username.
+
+If **all** usernames are exhausted a `GeoLocationError` is thrown with a clear message.
+
+```typescript
+const client = new GeoLocationClient({
+  // Rotate across five accounts for high-volume usage
+  usernames: ['account1', 'account2', 'account3', 'account4', 'account5'],
+});
+```
+
+---
+
+## Publishing (FWS internal)
+
+```bash
+# Create .env with your npm token
+echo "NPM_TOKEN=your_token_here" > .env
+
+# Bump patch version, build, and publish
+node ./publish.js
+```
+
+Published to the public npm registry under the `@forwardslashns` scope.
+
+---
+
+## License
+
+ISC — ForwardSlash d.o.o.

package/dist/client/geo-location.client.d.ts

@@ -0,0 +1,121 @@
+import type { GeoLocationClientOptions, GetCountriesOptions, GetRegionsOptions, GetCitiesOptions, GetPostalCodesOptions, GetAllPostalCodesOptions, GetPostalCodePageOptions, PostalCodePage } from '../types/client.types.js';
+import type { PaginatedResult } from '../types/common.types.js';
+import type { Country } from '../types/country.types.js';
+import type { Region } from '../types/region.types.js';
+import type { City } from '../types/city.types.js';
+import type { PostalCode } from '../types/postal-code.types.js';
+export declare class GeoLocationClient {
+    private readonly httpService;
+    private readonly restrictions;
+    /** In-memory cache: ISO2 countryCode → Country. Populated on first full country fetch. */
+    private readonly countryCache;
+    constructor(options: GeoLocationClientOptions);
+    /**
+     * Returns a list of countries.
+     *
+     * @param options - Optional per-call overrides for continent and country code filters.
+     *   When omitted the global `restrictions` passed to the constructor are used.
+     */
+    getCountries(options?: GetCountriesOptions): Promise<Country[]>;
+    /**
+     * Returns first-order administrative divisions (states, provinces, etc.)
+     * for the given country.
+     *
+     * @param countryCode - ISO 3166-1 alpha-2 country code, e.g. `"US"`.
+     * @param options - Optional per-call options.
+     */
+    getRegions(countryCode: string, options?: GetRegionsOptions): Promise<PaginatedResult<Region>>;
+    /**
+     * Returns populated places (cities, towns) for the given country,
+     * ordered by population descending.
+     *
+     * @param countryCode - ISO 3166-1 alpha-2 country code, e.g. `"DE"`.
+     * @param options - Optional filters: `regionCode`, `maxRows`, `orderBy`.
+     */
+    getCities(countryCode?: string | null, options?: GetCitiesOptions): Promise<PaginatedResult<City>>;
+    /**
+     * Returns postal / zip codes for the given country. Supports optional
+     * prefix and place-name filters.
+     *
+     * Each result includes a `displayName` formatted as:
+     * `"{postalCode} — {placeName}, {adminName1}, {countryName}"`
+     *
+     * @param countryCode - ISO 3166-1 alpha-2 country code, e.g. `"US"`.
+     * @param options - Optional filters: `postalCodePrefix`, `placeName`, `maxRows`, `startRow`, `page`.
+     *
+     * **GeoNames limitation — a filter is required for large countries.**
+     * The underlying GeoNames `postalCodeSearchJSON` endpoint rejects bare country-only
+     * queries for countries with large postal code datasets (e.g. US, DE, FR) by returning
+     * status 15 ("no result found"). Providing either `postalCodePrefix` or `placeName`
+     * always works regardless of country size.
+     *
+     * To retrieve **all** postal codes for a country without knowing a prefix in advance,
+     * use {@link getAllPostalCodes} instead — it handles this constraint transparently by
+     * iterating through alphanumeric prefix buckets and supports a progressive `onProgress`
+     * callback for streaming results into the UI.
+     */
+    getPostalCodes(countryCode: string, options?: GetPostalCodesOptions): Promise<PaginatedResult<PostalCode>>;
+    /**
+     * Returns **all** postal codes for the given country by iterating through
+     * alphanumeric prefix buckets (`0–9`, `A–Z`) and paginating each bucket.
+     *
+     * Because GeoNames requires at least one search term, a bare country-only
+     * query always returns status 15. This method works around that constraint
+     * transparently: it fires one request per character prefix (up to 36), each
+     * with `postalcode_startsWith=<char>`, and pages through results in chunks
+     * of 1 000 until the bucket is exhausted. Prefixes that yield no results
+     * (status 15 or empty page) are skipped automatically.
+     *
+     * The results are deduplicated and returned as a single flat array sorted by
+     * postal code.
+     *
+     * **API credit cost**: roughly 1 request per 1 000 postal codes in the
+     * country, spread across up to 36 prefix buckets. For small countries
+     * (< 5 000 codes) expect 10–20 requests; for large ones (US ~43 000) expect
+     * ~80 requests.
+     *
+     * @param countryCode - ISO 3166-1 alpha-2 country code, e.g. `"US"`.
+     */
+    getAllPostalCodes(countryCode: string, options?: GetAllPostalCodesOptions): Promise<PostalCode[]>;
+    /**
+     * Returns one page of postal codes for a country, working around the GeoNames
+     * per-country query limit that prevents retrieving all codes for large
+     * countries (e.g. US) in a single request.
+     *
+     * Internally the library iterates 36 alphanumeric prefix buckets (0–9, A–Z)
+     * and stores progress as an opaque cursor so callers never need to track
+     * offsets themselves.
+     *
+     * **Typical usage**
+     * ```ts
+     * let page = await client.getPostalCodesPage('US', { maxRows: 200 });
+     * while (page.hasMore) {
+     *   // process page.data …
+     *   page = await client.getPostalCodesPage('US', { cursor: page.nextCursor! });
+     * }
+     * // process last page.data …
+     * ```
+     *
+     * **API credit cost**: 1 GeoNames request per call (2 at the boundary
+     * between two prefix buckets). Far cheaper than `getAllPostalCodes` when
+     * you only need the first few pages.
+     *
+     * @param countryCode - ISO 3166-1 alpha-2 country code, e.g. `"US"`.
+     * @param options     - Optional cursor and page-size settings.
+     */
+    getPostalCodesPage(countryCode: string, options?: GetPostalCodePageOptions): Promise<PostalCodePage>;
+    /**
+     * Finds a single postal code by its exact code string within a given country.
+     * Returns `null` when not found.
+     *
+     * @param postalCode - The exact postal / zip code to look up, e.g. `"10001"`.
+     * @param countryCode - ISO 3166-1 alpha-2 country code, e.g. `"US"`.
+     */
+    findPostalCode(postalCode: string, countryCode: string): Promise<PostalCode | null>;
+    private fetchAllCountries;
+    private fetchCountriesByContinent;
+    private cacheCountries;
+    private resolveCountryName;
+    private assertNonEmptyCountryCode;
+}
+//# sourceMappingURL=geo-location.client.d.ts.map

package/dist/client/geo-location.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo-location.client.d.ts","sourceRoot":"","sources":["../../src/client/geo-location.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EAExB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,cAAc,EACf,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAuBhE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;IACvD,0FAA0F;IAC1F,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;gBAE7C,OAAO,EAAE,wBAAwB;IASpD;;;;;OAKG;IACU,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAyB5E;;;;;;OAMG;IACU,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAsC3G;;;;;;OAMG;IACU,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IA+C/G;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,cAAc,CACzB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;IAuDvC;;;;;;;;;;;;;;;;;;;;OAoBG;IACU,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAoD9G;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,wBAAwB,GAAG,OAAO,CAAC,cAAc,CAAC;IAmEjH;;;;;;OAMG;IACU,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;YA8BlF,iBAAiB;YAUjB,yBAAyB;IAUvC,OAAO,CAAC,cAAc;YAMR,kBAAkB;IAUhC,OAAO,CAAC,yBAAyB;CAKlC"}