@honua/app-platform 0.0.20-alpha.0

package/core/request-pipeline.js

@@ -0,0 +1,273 @@
+import { HonuaAbortError, HonuaHttpError, HonuaNetworkError, HonuaTimeoutError } from "./errors.js";
+export const DEFAULT_RETRY_STATUSES = new Set([429, 502, 503, 504]);
+export const DEFAULT_RETRY_METHODS = new Set(["GET", "PUT", "DELETE"]);
+export function normalizeTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
+        return undefined;
+    }
+    return Math.max(1, Math.trunc(timeoutMs));
+}
+export function normalizeRetryOptions(options) {
+    if (!options) {
+        return undefined;
+    }
+    const maxRetries = typeof options.maxRetries === "number" && Number.isFinite(options.maxRetries)
+        ? Math.max(0, Math.trunc(options.maxRetries))
+        : 0;
+    if (maxRetries < 1) {
+        return undefined;
+    }
+    const baseDelayMs = typeof options.baseDelayMs === "number" && Number.isFinite(options.baseDelayMs)
+        ? Math.max(1, Math.trunc(options.baseDelayMs))
+        : 100;
+    const maxDelayMs = typeof options.maxDelayMs === "number" && Number.isFinite(options.maxDelayMs)
+        ? Math.max(baseDelayMs, Math.trunc(options.maxDelayMs))
+        : 2_000;
+    const retryStatuses = new Set((options.retryStatuses ?? Array.from(DEFAULT_RETRY_STATUSES))
+        .map((status) => Math.trunc(status))
+        .filter((status) => Number.isFinite(status) && status >= 100 && status <= 599));
+    if (retryStatuses.size === 0) {
+        for (const status of DEFAULT_RETRY_STATUSES) {
+            retryStatuses.add(status);
+        }
+    }
+    return {
+        maxRetries,
+        baseDelayMs,
+        maxDelayMs,
+        retryStatuses,
+    };
+}
+/**
+ * Parse a `Retry-After` header value (delta-seconds or HTTP-date) into a delay
+ * in milliseconds. Shared by the REST {@link parseRetryAfterMs} response helper
+ * and the gRPC-web path, which reads the same header off the Connect error
+ * metadata (a `Headers`-shaped object) rather than a `Response`.
+ */
+export function parseRetryAfterHeaderMs(headers) {
+    const value = headers.get("retry-after");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number.parseInt(value, 10);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1_000;
+    }
+    const targetTime = Date.parse(value);
+    if (!Number.isFinite(targetTime)) {
+        return undefined;
+    }
+    return Math.max(0, targetTime - Date.now());
+}
+export function parseRetryAfterMs(response) {
+    return parseRetryAfterHeaderMs(response.headers);
+}
+/**
+ * Decide whether a failed attempt should be retried. Idempotent/replay-safe
+ * methods (GET/PUT/DELETE) are retried on the configured retry statuses or on
+ * transient network/timeout errors; aborts are never retried.
+ */
+export function shouldRetryRequest(retryOptions, method, attempt, statusCode, error) {
+    if (!retryOptions || attempt >= retryOptions.maxRetries) {
+        return false;
+    }
+    if (!DEFAULT_RETRY_METHODS.has(method)) {
+        return false;
+    }
+    if (error instanceof HonuaAbortError) {
+        return false;
+    }
+    if (statusCode !== undefined) {
+        return retryOptions.retryStatuses.has(statusCode);
+    }
+    return error instanceof HonuaNetworkError || error instanceof HonuaTimeoutError;
+}
+/**
+ * Resolve the backoff delay before the next attempt. A server `Retry-After`
+ * header (capped by `maxDelayMs`) wins; otherwise an exponential backoff with
+ * full jitter in the [0.5x, 1x] band is used.
+ */
+export function resolveRetryDelayMs(retryOptions, attempt, response) {
+    const retryAfterMs = response ? parseRetryAfterMs(response) : undefined;
+    if (retryAfterMs !== undefined) {
+        return Math.min(retryOptions?.maxDelayMs ?? retryAfterMs, retryAfterMs);
+    }
+    if (!retryOptions) {
+        return 0;
+    }
+    const exponentialDelay = retryOptions.baseDelayMs * 2 ** attempt;
+    const cappedDelay = Math.min(retryOptions.maxDelayMs, exponentialDelay);
+    return cappedDelay * (0.5 + Math.random() * 0.5);
+}
+/**
+ * gRPC/Connect numeric status codes that map to the transient REST retry
+ * statuses in {@link DEFAULT_RETRY_STATUSES}, so the grpc-web transport retries
+ * the same class of transient failures as REST. Mirrors the gRPC retry
+ * conventions: `resource_exhausted` (~429), `unavailable` (~502/503),
+ * `deadline_exceeded` (~504), and the transient `aborted` concurrency code.
+ */
+export const DEFAULT_RETRYABLE_GRPC_CODES = new Set([
+    4, // deadline_exceeded
+    8, // resource_exhausted
+    10, // aborted
+    14, // unavailable
+]);
+/** Connect/gRPC `canceled` code — caller/abort-driven, never retried. */
+const GRPC_CODE_CANCELED = 1;
+/**
+ * Extract the numeric gRPC/Connect status code off a thrown error (a
+ * `ConnectError` carries a numeric `code`). Returns `undefined` for non-Connect
+ * errors so callers can treat them as non-retryable.
+ */
+export function connectErrorCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "number") {
+        return error.code;
+    }
+    return undefined;
+}
+/**
+ * Decide whether a failed gRPC-web call should be retried. Mirrors
+ * {@link shouldRetryRequest} for the Connect transport: retries only the
+ * transient {@link DEFAULT_RETRYABLE_GRPC_CODES} while honoring `maxRetries`,
+ * and never retries once the call's abort signal has fired (caller abort or the
+ * `timeoutMs` deadline) or for the `canceled` code.
+ *
+ * Replay-safety (unary-only, since server-streaming responses cannot be safely
+ * replayed mid-iteration) is enforced by the caller, mirroring the REST
+ * {@link DEFAULT_RETRY_METHODS} idempotency gate.
+ */
+export function shouldRetryGrpcCall(retryOptions, attempt, error, aborted) {
+    if (!retryOptions || attempt >= retryOptions.maxRetries) {
+        return false;
+    }
+    if (aborted) {
+        return false;
+    }
+    const code = connectErrorCode(error);
+    if (code === undefined || code === GRPC_CODE_CANCELED) {
+        return false;
+    }
+    return DEFAULT_RETRYABLE_GRPC_CODES.has(code);
+}
+function connectErrorMetadata(error) {
+    if (typeof error === "object" && error !== null && "metadata" in error) {
+        const metadata = error.metadata;
+        if (metadata && typeof metadata.get === "function") {
+            return metadata;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the backoff delay before the next gRPC-web attempt. Reuses the shared
+ * {@link resolveRetryDelayMs} exponential-with-jitter math; a `retry-after`
+ * value carried on the Connect error metadata (capped by `maxDelayMs`) wins,
+ * mirroring the REST `Retry-After` handling.
+ */
+export function resolveGrpcRetryDelayMs(retryOptions, attempt, error) {
+    const metadata = connectErrorMetadata(error);
+    const retryAfterMs = metadata ? parseRetryAfterHeaderMs(metadata) : undefined;
+    if (retryAfterMs !== undefined) {
+        return Math.min(retryOptions?.maxDelayMs ?? retryAfterMs, retryAfterMs);
+    }
+    return resolveRetryDelayMs(retryOptions, attempt);
+}
+export async function sleep(ms, signal) {
+    if (ms <= 0) {
+        return;
+    }
+    if (signal?.aborted) {
+        throw new HonuaAbortError();
+    }
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, ms);
+        const abort = () => {
+            clearTimeout(timer);
+            reject(new HonuaAbortError());
+        };
+        signal?.addEventListener("abort", abort, { once: true });
+    });
+}
+export function normalizeNetworkError(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+        return new HonuaAbortError();
+    }
+    if (error instanceof Error) {
+        return new HonuaNetworkError(error.message, error);
+    }
+    return new HonuaNetworkError(String(error), error);
+}
+export function createTimeoutSignal(existingSignal, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return {
+            signal: existingSignal ?? undefined,
+            didTimeout: false,
+            dispose: () => undefined,
+        };
+    }
+    const controller = new AbortController();
+    let didTimeout = false;
+    let timer;
+    let onAbort;
+    timer = setTimeout(() => {
+        didTimeout = true;
+        controller.abort();
+    }, timeoutMs);
+    if (existingSignal) {
+        if (existingSignal.aborted) {
+            controller.abort();
+        }
+        else {
+            onAbort = () => {
+                controller.abort();
+            };
+            existingSignal.addEventListener("abort", onAbort, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        get didTimeout() {
+            return didTimeout;
+        },
+        dispose: () => {
+            if (timer) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+            if (existingSignal && onAbort) {
+                existingSignal.removeEventListener("abort", onAbort);
+                onAbort = undefined;
+            }
+        },
+    };
+}
+/**
+ * Map a non-OK HTTP response body into a {@link HonuaHttpError}, preferring the
+ * server's structured error message (`error.message`, `message`, or `detail`)
+ * and falling back to a generic message while preserving the raw body.
+ */
+export function toHttpError(statusCode, body) {
+    const fallback = "Request failed";
+    if (isObject(body)) {
+        const error = body.error;
+        if (isObject(error) && typeof error.message === "string") {
+            return new HonuaHttpError(statusCode, error.message, body);
+        }
+        if (typeof body.message === "string") {
+            return new HonuaHttpError(statusCode, body.message, body);
+        }
+        if (typeof body.detail === "string") {
+            return new HonuaHttpError(statusCode, body.detail, body);
+        }
+    }
+    return new HonuaHttpError(statusCode, fallback, body);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}

package/core/spatial-filter.d.ts

@@ -0,0 +1,93 @@
+import type { EsriGeometryType, EsriSpatialRel, HonuaSpatialReference } from "./types.js";
+/**
+ * A spatial filter fragment that can be spread into a `QueryFeaturesRequest`
+ * or applied via `QueryBuilder.geometry()` / `.geometryType()` / `.spatialRel()`.
+ */
+export interface SpatialFilter {
+    geometry: Record<string, unknown>;
+    geometryType: EsriGeometryType;
+    spatialRel?: EsriSpatialRel;
+}
+/**
+ * Create an envelope (bounding box) spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...envelope(-118.5, 33.7, -117.5, 34.2),
+ * };
+ * ```
+ */
+export declare function envelope(xmin: number, ymin: number, xmax: number, ymax: number, spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Create a point spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...point(-118.24, 34.05),
+ * };
+ * ```
+ */
+export declare function point(x: number, y: number, spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Create a polygon spatial filter from an array of rings.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...polygon([[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]]),
+ * };
+ * ```
+ */
+export declare function polygon(rings: number[][][], spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Create an envelope spatial filter centered on a point, approximating a
+ * circular buffer as a bounding box.
+ *
+ * @param x - Center x coordinate
+ * @param y - Center y coordinate
+ * @param distance - Half-width of the envelope in coordinate units
+ * @param spatialReference - Optional spatial reference
+ *
+ * @example
+ * ```ts
+ * // 0.5-degree bounding box around a point
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...buffer(-118.24, 34.05, 0.5),
+ * };
+ * ```
+ */
+export declare function buffer(x: number, y: number, distance: number, spatialReference?: HonuaSpatialReference): SpatialFilter;
+/**
+ * Wrap an existing geometry with `esriSpatialRelIntersects`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialIntersects({ xmin: -180, ymin: -90, xmax: 180, ymax: 90 });
+ * ```
+ */
+export declare function spatialIntersects(geometry: Record<string, unknown>): SpatialFilter;
+/**
+ * Wrap an existing geometry with `esriSpatialRelContains`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialContains({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export declare function spatialContains(geometry: Record<string, unknown>): SpatialFilter;
+/**
+ * Wrap an existing geometry with `esriSpatialRelWithin`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialWithin({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export declare function spatialWithin(geometry: Record<string, unknown>): SpatialFilter;
+//# sourceMappingURL=spatial-filter.d.ts.map

package/core/spatial-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-filter.d.ts","sourceRoot":"","sources":["../../../src/core/spatial-filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE1F;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,YAAY,EAAE,gBAAgB,CAAC;IAC/B,UAAU,CAAC,EAAE,cAAc,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,aAAa,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,qBAAqB,GAAG,aAAa,CAQnG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,gBAAgB,CAAC,EAAE,qBAAqB,GAAG,aAAa,CAQpG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,aAAa,CAEf;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAMlF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAMhF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAM9E"}

package/core/spatial-filter.js

@@ -0,0 +1,153 @@
+/**
+ * Create an envelope (bounding box) spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...envelope(-118.5, 33.7, -117.5, 34.2),
+ * };
+ * ```
+ */
+export function envelope(xmin, ymin, xmax, ymax, spatialReference) {
+    const geometry = { xmin, ymin, xmax, ymax };
+    if (spatialReference)
+        geometry.spatialReference = spatialReference;
+    return {
+        geometry,
+        geometryType: "esriGeometryEnvelope",
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Create a point spatial filter.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...point(-118.24, 34.05),
+ * };
+ * ```
+ */
+export function point(x, y, spatialReference) {
+    const geometry = { x, y };
+    if (spatialReference)
+        geometry.spatialReference = spatialReference;
+    return {
+        geometry,
+        geometryType: "esriGeometryPoint",
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Create a polygon spatial filter from an array of rings.
+ *
+ * @example
+ * ```ts
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...polygon([[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]]),
+ * };
+ * ```
+ */
+export function polygon(rings, spatialReference) {
+    const geometry = { rings };
+    if (spatialReference)
+        geometry.spatialReference = spatialReference;
+    return {
+        geometry,
+        geometryType: "esriGeometryPolygon",
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Create an envelope spatial filter centered on a point, approximating a
+ * circular buffer as a bounding box.
+ *
+ * @param x - Center x coordinate
+ * @param y - Center y coordinate
+ * @param distance - Half-width of the envelope in coordinate units
+ * @param spatialReference - Optional spatial reference
+ *
+ * @example
+ * ```ts
+ * // 0.5-degree bounding box around a point
+ * const req: QueryFeaturesRequest = {
+ *   serviceId: "svc", layerId: 0,
+ *   ...buffer(-118.24, 34.05, 0.5),
+ * };
+ * ```
+ */
+export function buffer(x, y, distance, spatialReference) {
+    return envelope(x - distance, y - distance, x + distance, y + distance, spatialReference);
+}
+/**
+ * Wrap an existing geometry with `esriSpatialRelIntersects`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialIntersects({ xmin: -180, ymin: -90, xmax: 180, ymax: 90 });
+ * ```
+ */
+export function spatialIntersects(geometry) {
+    return {
+        geometry,
+        geometryType: detectGeometryType(geometry),
+        spatialRel: "esriSpatialRelIntersects",
+    };
+}
+/**
+ * Wrap an existing geometry with `esriSpatialRelContains`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialContains({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export function spatialContains(geometry) {
+    return {
+        geometry,
+        geometryType: detectGeometryType(geometry),
+        spatialRel: "esriSpatialRelContains",
+    };
+}
+/**
+ * Wrap an existing geometry with `esriSpatialRelWithin`.
+ *
+ * @example
+ * ```ts
+ * const filter = spatialWithin({ rings: [[[-118, 34], [-117, 34], [-117, 35], [-118, 35], [-118, 34]]] });
+ * ```
+ */
+export function spatialWithin(geometry) {
+    return {
+        geometry,
+        geometryType: detectGeometryType(geometry),
+        spatialRel: "esriSpatialRelWithin",
+    };
+}
+/**
+ * Detect the Esri geometry type from a plain geometry object by inspecting
+ * its shape (duck-typing).
+ *
+ * @internal
+ */
+function detectGeometryType(geometry) {
+    if ("xmin" in geometry && "ymin" in geometry && "xmax" in geometry && "ymax" in geometry) {
+        return "esriGeometryEnvelope";
+    }
+    if ("rings" in geometry) {
+        return "esriGeometryPolygon";
+    }
+    if ("paths" in geometry) {
+        return "esriGeometryPolyline";
+    }
+    if ("points" in geometry) {
+        return "esriGeometryMultipoint";
+    }
+    if ("x" in geometry && "y" in geometry) {
+        return "esriGeometryPoint";
+    }
+    return "esriGeometryPoint";
+}

package/core/stac-static.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Static STAC catalog reader.
+ *
+ * A large share of public STAC catalogs are not API servers — they are
+ * static `catalog.json` / `collection.json` / item trees served from object
+ * storage, with no `/search` endpoint. This reader walks such a tree the
+ * spec-driven way: it follows `rel="child"` links to descend catalogs /
+ * collections and `rel="item"` links to reach STAC Items, resolving every
+ * href against the document it was found in (STAC best-practice relative
+ * links). Filtering (`collections` / `bbox` / `datetime` / `limit`) is
+ * applied client-side and the result is projected onto the same
+ * {@link HonuaStacItemCollectionResponse} envelope the STAC API search path
+ * returns, so the canonical `Source` surface is identical across both
+ * layouts.
+ *
+ * @module
+ */
+import type { HonuaClient } from "./client.js";
+import type { HonuaStacItemCollectionResponse } from "./types.js";
+/** Bounded search parameters for a static catalog traversal. */
+export interface StacStaticSearchParams {
+    collections?: readonly string[];
+    bbox?: readonly [number, number, number, number];
+    datetime?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Reader bound to the URL of a static STAC catalog / collection root. The
+ * URL is the client baseUrl (the transport resolves same-origin absolute
+ * child/item hrefs directly), so `rootUrl` is normally `""` (the baseUrl
+ * itself) but may be an absolute `catalog.json` URL.
+ */
+export declare class HonuaStacStaticCatalog {
+    readonly client: HonuaClient;
+    private readonly rootUrl;
+    constructor(client: HonuaClient, rootUrl?: string);
+    /**
+     * Traverse the catalog tree, collect matching items, and return them in
+     * the STAC search envelope shape.
+     */
+    search(params?: StacStaticSearchParams): Promise<HonuaStacItemCollectionResponse>;
+    private fetchDoc;
+    /**
+     * Breadth-first walk collecting item documents. Descends `rel="child"`
+     * links; a `collections` filter prunes Collection subtrees whose `id`
+     * is not requested. Bounded by {@link MAX_DOCUMENTS} and the item cap.
+     */
+    private collectItems;
+}
+//# sourceMappingURL=stac-static.d.ts.map

package/core/stac-static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stac-static.d.ts","sourceRoot":"","sources":["../../../src/core/stac-static.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,KAAK,EAAE,+BAA+B,EAAyB,MAAM,YAAY,CAAC;AAEzF,gEAAgE;AAChE,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,IAAI,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAeD;;;;;GAKG;AACH,qBAAa,sBAAsB;IACjC,SAAgB,MAAM,EAAE,WAAW,CAAC;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAEd,MAAM,EAAE,WAAW,EAAE,OAAO,SAAK;IAKpD;;;OAGG;IACU,MAAM,CAAC,MAAM,GAAE,sBAA2B,GAAG,OAAO,CAAC,+BAA+B,CAAC;YAcpF,QAAQ;IAMtB;;;;OAIG;YACW,YAAY;CA6D3B"}