@slackwater/database 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,25 @@
+THE FOLLOWING LICENSE INFORMATION COVERS ONLY THE DOCUMENTATION AND ANY CODE
+NOT WITHIN THE "data" DIRECTORY. EACH DATA FILE HAS ITS OWN LICENSE INFORMATION.
+
+The MIT License (MIT)
+
+Copyright (c) 2019 Kevin Miller
+Copyright (c) 2025 Brandon Keepers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,23 @@
+@slackwater/database
+Copyright (c) Sailing Naturali
+Licensed under the MIT License (see LICENSE).
+
+This repository uses GeoNames cities500 data under CC BY 4.0 to derive station
+location fields. This product includes data created by GeoNames
+(www.geonames.org), licensed under CC BY 4.0:
+https://creativecommons.org/licenses/by/4.0/
+
+metadata/coastline.geojson is a clipped extract of OpenStreetMap land polygons,
+licensed under ODbL 1.0. Credit: OpenStreetMap contributors.
+https://opendatacommons.org/licenses/odbl/1-0/
+
+Station context names the OpenStreetMap bay or strait a station sits in,
+derived from metadata/water-bodies.geojson, an extract of OpenStreetMap
+licensed under ODbL 1.0. Credit: OpenStreetMap contributors.
+https://opendatacommons.org/licenses/odbl/1-0/
+
+Station countries for registry records are derived from
+metadata/maritime-zones.geojson, an extract of the Marine Regions Maritime
+Boundaries Geodatabase (Exclusive Economic Zones) by the Flanders Marine
+Institute (marineregions.org), licensed under CC BY 4.0:
+https://creativecommons.org/licenses/by/4.0/

package/README.md

@@ -0,0 +1,190 @@
+# @slackwater/database
+
+> A public database of tide harmonics
+
+Harmonic constituents, tidal datums, and station metadata for thousands of tide stations around the world. Feed the constituents to a tide harmonic calculator like [Slackwater](https://github.com/openwatersio/slackwater) to produce astronomical tide predictions.
+
+Station data is curated in the [slackwater-database repository](https://github.com/openwatersio/slackwater-database), which documents [where each station comes from](https://github.com/openwatersio/slackwater-database#sources) and how it is quality-checked.
+
+## Install
+
+```sh
+$ npm install @slackwater/database
+```
+
+## Usage
+
+The package exports every tide and current station that passes the database's quality gates:
+
+```typescript
+import { stations, stationsById } from "@slackwater/database";
+
+console.log("Total stations:", stations.length);
+console.log(stationsById.get("noaa/9447130"));
+```
+
+`stations` leaves out records the quality evaluation rejected, such as duplicate gauges and implausible datums. `allStations` is the unfiltered catalog, `stationsById` maps an id to its station, and every search function below takes `includeAll: true` to search the full catalog instead of the accepted subset.
+
+Each station carries its identity and location eagerly. The heavy prediction fields — `harmonic_constituents`, `datums`, and `epoch` — are decoded from the database file on first access, so importing the module does not pull every station's prediction data onto the heap. [See the format documentation](https://github.com/openwatersio/slackwater-database/blob/main/docs/database-format.md) for how that works.
+
+Each station has separate `locality`, `region`, and `country` display fields. `country_code` is an ISO 3166-1 alpha-2 code; `region_code`, when available, is an ISO 3166-2 subdivision code. Consumers can therefore omit country or region text when the surrounding page already supplies it.
+
+### Stable station routes
+
+```typescript
+import { stationRouteBySlug, stationsById } from "@slackwater/database";
+
+const route = stationRouteBySlug("tide", "victoria");
+const station = route && stationsById.get(route.stationIds[0]!);
+console.log(station?.locality, station?.region, station?.country_code);
+```
+
+`stationRouteBySlug(kind, slug)` performs a binary lookup without decoding the full route index. `stationRoutes(kind)` decodes that kind's complete route list on demand. Prediction fields such as constituents and datums remain lazy.
+
+### Searching for stations
+
+#### Geographic search
+
+`near` returns an array of `[station, distanceInKm]` tuples, closest first:
+
+```typescript
+import { near, nearest } from "@slackwater/database";
+
+// Find stations within 10 km of a lat/lon
+const nearbyStations = near({
+  lon: -122,
+  lat: 37,
+  maxDistance: 10,
+  maxResults: 50,
+});
+console.log("Nearby stations:", nearbyStations.length);
+```
+
+`nearest` returns a single `[station, distanceInKm]` tuple, or `null` when nothing matches:
+
+```typescript
+const result = nearest({ longitude: -75.5, latitude: 22 });
+if (result) {
+  const [station, distance] = result;
+  console.log("Nearest station:", station.name, "is", distance, "km away");
+}
+```
+
+Both functions take the following parameters:
+
+- `latitude` or `lat`: Latitude in decimal degrees.
+- `longitude`, `lon`, or `lng`: Longitude in decimal degrees.
+- `maxDistance`: Maximum distance in kilometers to search for stations (default: unlimited).
+- `filter`: A function that takes a station and returns `true` to include it in results, or `false` to exclude it.
+- `includeAll`: Search the full catalog rather than quality-accepted stations only (default: `false`).
+
+`near` also takes:
+
+- `maxResults`: Maximum number of results to return (default: `10`).
+
+#### Bounding box search
+
+`bbox` takes a `[minLon, minLat, maxLon, maxLat]` tuple and returns the stations inside it:
+
+```typescript
+import { bbox } from "@slackwater/database";
+
+// Find stations in the Boston area
+const bostonStations = bbox([-71.5, 42, -70.5, 42.8]);
+console.log("Stations in bounds:", bostonStations.length);
+
+// With a filter
+const referenceOnly = bbox([-72, 41, -70, 43], {
+  filter: (station) => station.type === "reference",
+});
+```
+
+The bounds are `minLon` (west edge), `minLat` (south edge), `maxLon` (east edge), and `maxLat` (north edge), in decimal degrees. The optional second argument takes:
+
+- `filter`: A function that takes a station and returns `true` to include it in results, or `false` to exclude it.
+- `includeAll`: Search the full catalog rather than quality-accepted stations only (default: `false`).
+
+#### Full-text search
+
+You can search for stations by name, region, country, or continent using the `search` function. It supports fuzzy matching and prefix search:
+
+```typescript
+import { search } from "@slackwater/database";
+
+// Search for stations by name with fuzzy matching
+const results = search("Boston");
+console.log("Found:", results.length, "stations");
+console.log(results[0].name);
+
+// Search with a filter function
+const usStations = search("harbor", {
+  filter: (station) => station.country === "United States",
+  maxResults: 10,
+});
+console.log("US harbor stations:", usStations);
+
+// Combine multiple filters
+const referenceStations = search("island", {
+  filter: (station) =>
+    station.type === "reference" && station.continent === "Americas",
+  maxResults: 20,
+});
+console.log("Reference stations:", referenceStations);
+```
+
+The `search` function takes the following parameters:
+
+- `query` (required): Search string. Supports fuzzy matching and prefix search.
+- `options` (optional):
+  - `filter`: Function that takes a station and returns `true` to include it in results, or `false` to exclude it.
+  - `includeAll`: Search the full catalog rather than quality-accepted stations only (default: `false`).
+  - `maxResults`: Maximum number of results to return (default: `20`).
+
+## Station types
+
+Stations are either _reference_ or _subordinate_, given by the station's `type` field.
+
+Reference stations have their own `harmonic_constituents`, usually derived from a long record of real water level observations. Subordinate stations predict from a nearby reference station's harmonics, adjusted by four `offsets` — two correcting water level and two correcting the time of high and low tide. Reading a subordinate's `harmonic_constituents` or `datums` returns its reference station's values, so both types predict the same way.
+
+`astronomical_bounds` is how low and high a prediction for the station can go — `{ lat, hat }` in metres above its chart datum — with the height offsets applied for a subordinate. It sits outside `datums` because the reduced pair is the floor and ceiling of a prediction rather than a hydrographic datum; [see the datum documentation](https://github.com/openwatersio/slackwater-database/blob/main/docs/datums.md).
+
+The full field-by-field description lives in [`schemas/station.schema.json`](https://github.com/openwatersio/slackwater-database/blob/main/schemas/station.schema.json).
+
+## The database file
+
+The module reads a single [FlatBuffers](https://flatbuffers.dev) file built from [`schemas/database.fbs`](https://github.com/openwatersio/slackwater-database/blob/main/schemas/database.fbs). Every release of this package also attaches that file as `slackwater-<date>.tcdb`, so native apps can bundle and memory-map it and generate a reader in their own language from the schema. [See the format documentation.](https://github.com/openwatersio/slackwater-database/blob/main/docs/database-format.md)
+
+## License
+
+- All code in this package is licensed under the [MIT License](./LICENSE).
+- The `license` field of each station specifies the license for that station's data, as a `type`, a `url`, and a `commercial_use` flag you can filter on.
+- Unless otherwise noted, all other data is licensed under the [Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) license. Some stations are CC BY-NC 4.0 and are marked `commercial_use: false`.
+
+## Attribution
+
+Most stations are CC BY, so displaying or redistributing them carries an obligation to the original source, not only to this project. Every station carries the notice that satisfies it as `attribution`, already assembled.
+
+**Display the station's `attribution`.** That is the whole of the rule. Nothing here needs its own table of sources, or its own reading of what a licence requires.
+
+```typescript
+import { stationsById } from "@slackwater/database";
+
+console.log(stationsById.get("ticon/newlyn-new-gbr-bodc")?.attribution);
+// Slackwater database (https://github.com/openwatersio/slackwater-database). Source:
+// Hart-Davis, M., Dettmering, D., Seitz, F. (2025), TICON-4: TIdal CONstants
+// based on GESLA-4 sea-level records, SEANOE, https://doi.org/10.17882/109129.
+// Licensed CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Modified:
+// see https://github.com/openwatersio/slackwater-database#modifications-to-source-data
+```
+
+What the string contains, and why that is sufficient:
+
+- **The creator credit.** For TICON-4 stations, the citation its authors ask for; for Kartverket, the publishing agency. A source that requires no credit, such as public-domain NOAA data, contributes nothing here.
+- **The licence and its URI**, taken from the station rather than its source. Licence varies within a single source — the TICON stations relayed from CMEMS are CC BY-NC while the rest are CC BY — so the notice names the one that actually applies to the station in hand.
+- **An indication that the material was modified**, pointing at [what this project changes](https://github.com/openwatersio/slackwater-database#modifications-to-source-data): derived datums, normalized names, geocoded location fields, and re-fit phases for two GESLA sources.
+
+Those are the three things [CC BY 4.0 section 3(a)(1)](https://creativecommons.org/licenses/by/4.0/) requires a redistributor to pass on. A station whose licence imposes no notice gets the project credit alone:
+
+> Slackwater database (https://github.com/openwatersio/slackwater-database)
+
+`attribution` is a display string. It is not a substitute for `license` when you need to make a decision in code — filter on `license.commercial_use` or `license.type` for that.

package/dist/browser/index.d.ts

@@ -0,0 +1,283 @@
+//#region src/attribution.d.ts
+/**
+ * The project half of every notice. A station's full notice opens with this,
+ * then adds whatever its source and licence require.
+ */
+export declare const PROJECT_CREDIT = "Slackwater database (https://github.com/openwatersio/slackwater-database)";
+/** Where a redistributor is pointed to find what this project changed. */
+export declare const MODIFICATIONS_URL = "https://github.com/openwatersio/slackwater-database#modifications-to-source-data";
+/** Whether a source name has a credit decision recorded. */
+export declare function isKnownSource(sourceName: string): boolean;
+/**
+ * Assemble a station's complete notice, so displaying it is the whole of a
+ * consumer's obligation. Under a Creative Commons licence that means the
+ * creator credit, the licence and its URI, and an indication that the material
+ * was modified — the three things CC BY 4.0 section 3(a)(1) requires be passed
+ * on. Licence is taken per station rather than per source because it varies
+ * within one source: TICON stations relayed from CMEMS are CC BY-NC while the
+ * rest are CC BY.
+ */
+export declare function attributionFor(sourceName: string | undefined, license: {
+  type: string;
+  url: string;
+} | undefined): string;
+//#endregion
+//#region src/types.d.ts
+interface HarmonicConstituent {
+  name: string;
+  description?: string;
+  amplitude: number;
+  phase: number;
+  speed?: number;
+}
+interface Constituent {
+  name: string;
+  description: string | null;
+  speed: number;
+}
+interface StationRouteInput {
+  slug: string;
+  station_ids: string[];
+  former_paths?: string[];
+}
+interface StationRoute {
+  slug: string;
+  stationIds: string[];
+  formerPaths: string[];
+}
+interface DatabaseRoutes {
+  tide: StationRouteInput[];
+  current: StationRouteInput[];
+}
+interface StationData {
+  name: string;
+  continent: string;
+  country: string;
+  country_code?: string;
+  locality?: string;
+  region?: string;
+  region_code?: string;
+  timezone: string;
+  context?: string;
+  context_derived?: boolean;
+  cities?: string[];
+  disclaimers?: string;
+  type: "reference" | "subordinate";
+  latitude: number;
+  longitude: number;
+  source: {
+    name: string;
+    id: string;
+    published_harmonics: boolean;
+    url: string;
+  };
+  license: {
+    type: string;
+    commercial_use: boolean;
+    url: string;
+    notes?: string;
+  };
+  harmonic_constituents: HarmonicConstituent[];
+  offsets?: {
+    reference: string;
+    height: {
+      high: number;
+      low: number;
+      type: "ratio" | "fixed";
+    };
+    time: {
+      high: number;
+      low: number;
+    };
+  };
+  datums: Record<string, number>;
+  datums_source?: "observed" | "harmonic";
+  chart_datum?: string;
+  epoch?: {
+    start: string;
+    end: string;
+  };
+  aliases?: string[];
+}
+interface TideDerivedCurrentData {
+  reference: string;
+  high_water_lag_minutes: number;
+  low_water_lag_minutes: number;
+}
+interface CurrentData {
+  /** Degrees true. */
+  flood_direction?: number;
+  ebb_direction?: number;
+  /** Knots; the constant term added to the harmonic sum. */
+  mean_flow?: number;
+  /** Id of the tide station whose extremes pair with this current, if any. */
+  tide_reference?: string;
+  magnitude_note?: string;
+  derived?: TideDerivedCurrentData;
+  /** Subordinate currents only. Times in minutes, ratios dimensionless. */
+  offsets?: {
+    reference: string;
+    slack_before_flood?: number;
+    slack_before_ebb?: number;
+    flood_time?: number;
+    ebb_time?: number;
+    flood_speed_ratio?: number;
+    ebb_speed_ratio?: number;
+  };
+}
+/**
+ * What buildDatabase accepts: a station id plus whatever fields the catalog
+ * has. Downstream generators can pass filtered stations from this package or
+ * records of their own (including current stations).
+ */
+type StationInput = {
+  id: string;
+  kind?: "tide" | "current";
+  current?: CurrentData;
+  quality?: StationQuality;
+} & Partial<StationData>;
+interface StationQuality {
+  /** The station's id — not stored in the database, filled from identity. */
+  id: string;
+  accepted: boolean;
+  score: number;
+  /** Scoring factors, each 0-1. */
+  factors?: {
+    epoch: number;
+    recency: number;
+    source: number;
+    quality: number;
+    amplitude: number;
+    coverage: number;
+  };
+  /** Human-readable findings, e.g. "MLW (3.827) < LAT (3.831)". */
+  issues?: string[];
+  /** Rejection category ("duplicate", "datum", "constituents", ...), if rejected. */
+  reason?: string;
+  /** Id of the station that makes this one redundant, if any. */
+  redundant?: string;
+}
+/** The floor and ceiling of a station's predictions, in metres above its chart datum. */
+interface AstronomicalBounds {
+  /** Lowest Astronomical Tide. */
+  lat: number;
+  /** Highest Astronomical Tide. */
+  hat: number;
+}
+interface Station extends StationData {
+  id: string;
+  country_code: string;
+  kind: "tide" | "current";
+  current?: CurrentData;
+  quality?: StationQuality;
+  /**
+   * Lowest and highest astronomical tide, in metres above this station's chart
+   * datum; absent when the station predicting for this one has no LAT and HAT.
+   * A subordinate's is the reference's range reduced through `offsets.height`,
+   * the floor of a prediction rather than a hydrographic datum — which is why
+   * it is here and not in `datums`. See docs/datums.md.
+   */
+  astronomical_bounds?: AstronomicalBounds;
+  /**
+   * The credit to display when showing or redistributing this station, ready
+   * to render as-is. Derived from `source`; see src/attribution.ts.
+   */
+  attribution: string;
+}
+type StationMetaKey = "name" | "latitude" | "longitude" | "locality" | "region" | "region_code" | "country" | "country_code" | "continent" | "context" | "context_derived" | "cities" | "aliases" | "timezone" | "type" | "source";
+type StationMeta = {
+  id: string;
+} & Pick<StationData, StationMetaKey>;
+//#endregion
+//#region src/stations.d.ts
+/** All datum keys present across the database (e.g. "MLLW", "MSL", "NAVD88"). */
+export declare const datums: string[];
+export declare const allStations: Station[];
+export declare const stationsById: Map<string, Station>;
+export declare const qualityMap: Map<string, StationQuality>;
+export declare function qualityFilter(station: Station): boolean;
+export declare const stations: Station[];
+//#endregion
+//#region src/routes.d.ts
+export declare function stationRouteBySlug(kind: "tide" | "current", slug: string): StationRoute | undefined;
+export declare function stationRoutes(kind: "tide" | "current"): StationRoute[];
+//#endregion
+//#region src/search/index.d.ts
+export type Position = Latitude & Longitude;
+type Latitude = {
+  latitude: number;
+} | {
+  lat: number;
+};
+type Longitude = {
+  longitude: number;
+} | {
+  lon: number;
+} | {
+  lng: number;
+};
+export type Filter = (station: Station) => boolean;
+export type NearestOptions = Position & {
+  maxDistance?: number;
+  /** Include all stations, not just quality-filtered ones. */
+  includeAll?: boolean;
+  filter?: Filter;
+};
+export type NearOptions = NearestOptions & {
+  maxResults?: number;
+};
+export type BboxOptions = {
+  /** Include all stations, not just quality-filtered ones. */
+  includeAll?: boolean;
+  filter?: Filter;
+};
+export type TextSearchOptions = {
+  /** Include all stations, not just quality-filtered ones. */
+  includeAll?: boolean;
+  filter?: Filter;
+  maxResults?: number;
+};
+/**
+ * A tuple of a station and its distance from a given point, in kilometers.
+ */
+export type StationWithDistance = [Station, number];
+/**
+ * Find stations near a given position.
+ */
+export declare function near({ maxDistance, maxResults, includeAll, filter, ...position }: NearOptions): StationWithDistance[];
+/**
+ * Find the single nearest station to a given position.
+ */
+export declare function nearest(options: NearestOptions): StationWithDistance | null;
+/**
+ * Find stations within a bounding box.
+ */
+export declare function bbox([minLon, minLat, maxLon, maxLat]: [number, number, number, number], { includeAll, filter }?: BboxOptions): Station[];
+export declare function positionToPoint(options: Position): [number, number];
+/**
+ * Search for stations by text across name, region, country, and continent.
+ * Supports fuzzy matching and prefix search.
+ */
+export declare function search(query: string, { includeAll, filter, maxResults }?: TextSearchOptions): Station[];
+//#endregion
+//#region src/database/builder.d.ts
+/**
+ * Serialize stations into the FlatBuffers database format
+ * (schemas/database.fbs). Stations are sorted by id — the vector key — so
+ * readers can binary-search the buffer.
+ *
+ * Build order matters and the schema cannot express it: FlatBuffers writes back
+ * to front, so the prediction data (constituents and datums vectors) is written
+ * first for every station, landing together at the tail of the file, and the
+ * station tables are written together after, landing at the head. A naive
+ * per-station loop would interleave ~100 bytes of identity with ~1,300 bytes of
+ * constituents, making an identity scan over a memory-mapped file fault in
+ * every page. test/database.test.ts asserts the layout.
+ */
+export declare function buildDatabase(stations: StationInput[], { version, routes }?: {
+  version?: string;
+  routes?: DatabaseRoutes;
+}): Uint8Array;
+//#endregion
+export type { AstronomicalBounds, Constituent, CurrentData, DatabaseRoutes, HarmonicConstituent, Station, StationData, StationInput, StationMeta, StationMetaKey, StationQuality, StationRoute, StationRouteInput, TideDerivedCurrentData };
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/attribution.ts","../../src/types.ts","../../src/stations.ts","../../src/routes.ts","../../src/search/index.ts","../../src/database/builder.ts"],"mappings":";;;;;qBAIa;;qBAIA;;wBAiCG,cAAc;;;;;;;;;;wBAad,eACd,gCACA;EAAW;EAAc;;;;UCxDV;EACf;EACA;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;;UAGe;EACf,MAAM;EACN,SAAS;;UAGM;EAEf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EAGA;IACE;IACA;IACA;IACA;;EAIF;IACE;IACA;IACA;IACA;;EAIF,uBAAuB;EAGvB;IACE;IACA;MAAU;MAAc;MAAa;;IACrC;MAAQ;MAAc;;;EAGxB,QAAQ;EAIR;EAGA;EAGA;IACE;IACA;;EAIF;;UAMe;EACf;EACA;EACA;;UAGe;;EAEf;EACA;;EAEA;;EAEA;EACA;EACA,UAAU;;EAEV;IACE;IACA;IACA;IACA;IACA;IACA;IACA;;;;;;;;KASQ;EACV;EACA;EACA,UAAU;EACV,UAAU;IACR,QAAQ;UAIK;;EAEf;EACA;EACA;;EAEA;IACE;IACA;IACA;IACA;IACA;IACA;;;EAGF;;EAEA;;EAEA;;;UAIe;;EAEf;;EAEA;;UAGe,gBAAgB;EAC/B;EACA;EACA;EACA,UAAU;EACV,UAAU;;;;;;;;EAQV,sBAAsB;;;;;EAKtB;;KAMU;KAkBA;EAAgB;IAAe,KAAK,aAAa;;;;qBChLhD;qBA+SA,aAAa;qBAOb,cAAY,YAAA;qBAEZ,YAAU,YAAA;wBAIP,cAAc,SAAS;qBAI1B,UAAU;;;wBClVP,mBACd,0BACA,eACC;wBAkBa,cAAc,2BAA2B;;;YChC7C,WAAW,WAAW;KAC7B;EAAa;;EAAuB;;KACpC;EAAc;;EAAwB;;EAAkB;;YAEjD,UAAU,SAAS;YAEnB,iBAAiB;EAC3B;;EAEA;EACA,SAAS;;YAGC,cAAc;EACxB;;YAGU;;EAEV;EACA,SAAS;;YAGC;;EAEV;EACA,SAAS;EACT;;;;;YAMU,uBAAuB;;;;wBAgCnB,OACd,aACA,YACA,YACA,WACG,YACF,cAAc;;;;wBAqBD,QAAQ,SAAS,iBAAiB;;;;wBAQlC,MACb,QAAQ,QAAQ,QAAQ,6CACvB,YAAoB,WAAU,cAC/B;wBAOa,gBAAgB,SAAS;;;;;wBAezB,OACd,iBACE,YAAY,QAAQ,eAAmB,oBACxC;;;;;;;;;;;;;;;;wBC9Fa,cACd,UAAU,kBAER,SACA;EACG;EAAkB,SAAS;IAC/B"}