@honua/react 0.0.20-alpha.0 → 0.1.1-beta.0

package/core/geoparquet-sql.js

@@ -0,0 +1,368 @@
+/**
+ * Pure SQL compiler for the GeoParquet / DuckDB-WASM `Source`
+ * (`@honua/sdk-js/geoparquet`). Translates the protocol-neutral
+ * {@link Query} envelope into DuckDB SQL over `read_parquet(...)` with spatial
+ * predicate pushdown.
+ *
+ * This module has **no runtime dependencies** (not even `@duckdb/duckdb-wasm`)
+ * so it can be unit- and snapshot-tested in isolation and so the SQL text is a
+ * pure function of its inputs. The heavy DuckDB orchestration lives in
+ * `src/geoparquet/`.
+ *
+ * ## SQL-injection safety
+ *
+ * Every value this compiler interpolates is either (a) a numeric literal that
+ * is validated to be a finite JS number and rendered with {@link numberLiteral},
+ * (b) a string literal escaped by {@link stringLiteral} (single quotes doubled,
+ * embedded NULs rejected), or (c) a SQL identifier escaped by
+ * {@link quoteIdentifier} (double quotes doubled, embedded NULs / control chars
+ * rejected). The one exception is {@link Query.where}: like the GeoServices and
+ * OGC adapters, `where` is caller-authored filter SQL and is passed through
+ * verbatim (wrapped in parentheses). Callers are responsible for the trust
+ * boundary on `where`, exactly as they are for a GeoServices `where` clause.
+ *
+ * @module
+ */
+// ── Identifier / literal escaping ─────────────────────────────
+/**
+ * Quote a SQL identifier for DuckDB: wrap in double quotes and double any
+ * embedded double quote. Rejects NUL and other control characters, which
+ * cannot appear in a legitimate column name and are a classic smuggling
+ * vector. Overture column names (`id`, `names`, `geometry`, dotted struct
+ * paths accessed as whole columns) are all safe under this rule.
+ */
+export function quoteIdentifier(name) {
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error(`geoparquet: invalid SQL identifier ${JSON.stringify(name)}`);
+    }
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: rejecting control chars in identifiers is the point
+    if (/[\u0000-\u001f\u007f]/.test(name)) {
+        throw new Error(`geoparquet: SQL identifier contains control characters: ${JSON.stringify(name)}`);
+    }
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/**
+ * Render a string SQL literal (single quotes doubled). Rejects embedded NUL.
+ */
+export function stringLiteral(value) {
+    if (typeof value !== "string") {
+        throw new Error(`geoparquet: expected a string literal, received ${typeof value}`);
+    }
+    if (value.includes("\u0000")) {
+        throw new Error("geoparquet: string literal contains a NUL byte");
+    }
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+ * Render a numeric SQL literal, validating the input is a finite JS number.
+ * Non-finite values (NaN/Infinity) throw rather than emit `'NaN'` — a spatial
+ * predicate must never silently widen to an infinite envelope.
+ */
+export function numberLiteral(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`geoparquet: expected a finite number, received ${String(value)}`);
+    }
+    return String(value);
+}
+/**
+ * Render an integer SQL literal (offset / limit). Coerces via `Math.trunc` and
+ * validates non-negative finiteness.
+ */
+export function integerLiteral(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new Error(`geoparquet: expected a non-negative integer, received ${String(value)}`);
+    }
+    return String(Math.trunc(value));
+}
+// ── read_parquet(...) source expression ───────────────────────
+/**
+ * Build the `read_parquet(...)` table expression from one or more file URLs /
+ * globs. A single source renders `read_parquet('url')`; multiple sources
+ * render `read_parquet(['a', 'b'])`. Every URL is escaped as a string literal.
+ * `union_by_name := true` and `hive_partitioning := true` are set so mixed
+ * schemas across a hive-partitioned Overture theme line up by column name.
+ */
+export function parquetSourceExpr(urls) {
+    if (!Array.isArray(urls) || urls.length === 0) {
+        throw new Error("geoparquet: at least one parquet URL is required");
+    }
+    const list = urls.map(stringLiteral);
+    const arg = list.length === 1 ? list[0] : `[${list.join(", ")}]`;
+    return `read_parquet(${arg}, union_by_name = true, hive_partitioning = true)`;
+}
+const GEOARROW_NATIVE_ENCODINGS = new Set([
+    "geoarrow-point",
+    "geoarrow-linestring",
+    "geoarrow-polygon",
+    "geoarrow-multipoint",
+    "geoarrow-multilinestring",
+    "geoarrow-multipolygon",
+]);
+/** True for a GeoParquet 1.1 native single-geometry encoding (see {@link GeometryEncoding}). */
+export function isGeoArrowNativeEncoding(encoding) {
+    return GEOARROW_NATIVE_ENCODINGS.has(encoding);
+}
+/**
+ * SQL expression that yields a DuckDB `GEOMETRY` from the stored geometry
+ * column, adapting to the physical encoding.
+ *
+ * @throws for a `geoarrow-*` encoding — GeoParquet 1.1 native columns are
+ *   nested `STRUCT`/`LIST` values with no DuckDB spatial-predicate
+ *   expression. Callers must fail closed before constructing SQL rather than
+ *   let a malformed `ST_Intersects(...)` reach DuckDB; use a bbox-covering
+ *   column for spatial pushdown and the dedicated native decoder for
+ *   geometry projection instead.
+ */
+export function geometryExpr(plan) {
+    const col = quoteIdentifier(plan.column);
+    switch (plan.encoding) {
+        case "wkb":
+            return `ST_GeomFromWKB(${col})`;
+        case "geojson":
+            return `ST_GeomFromGeoJSON(${col})`;
+        case "native":
+            return col;
+        case "geoarrow-point":
+        case "geoarrow-linestring":
+        case "geoarrow-polygon":
+        case "geoarrow-multipoint":
+        case "geoarrow-multilinestring":
+        case "geoarrow-multipolygon":
+            throw new Error(`geoparquet: column ${JSON.stringify(plan.column)} uses the GeoParquet 1.1 native "${plan.encoding.slice("geoarrow-".length)}" encoding, which DuckDB stores as a nested struct/list value with no spatial-predicate expression. Supply a bbox-covering column for spatialFilter pushdown; geometry projection is decoded separately from the raw column.`);
+    }
+}
+/**
+ * Reduce any Esri-shaped {@link SpatialFilter} geometry to its axis-aligned
+ * bounding box. Envelopes are exact; points, polylines (`paths`), polygons
+ * (`rings`), and multipoints (`points`) are reduced to their coordinate
+ * bounds. Returns `undefined` when the geometry carries no usable coordinates.
+ */
+export function bboxFromSpatialFilter(filter) {
+    const g = filter.geometry;
+    if (typeof g.xmin === "number" &&
+        typeof g.ymin === "number" &&
+        typeof g.xmax === "number" &&
+        typeof g.ymax === "number") {
+        return { xmin: g.xmin, ymin: g.ymin, xmax: g.xmax, ymax: g.ymax };
+    }
+    if (typeof g.x === "number" && typeof g.y === "number") {
+        return { xmin: g.x, ymin: g.y, xmax: g.x, ymax: g.y };
+    }
+    const coordSets = [];
+    if (Array.isArray(g.rings))
+        coordSets.push(...g.rings);
+    if (Array.isArray(g.paths))
+        coordSets.push(...g.paths);
+    if (Array.isArray(g.points))
+        coordSets.push(g.points);
+    let xmin = Number.POSITIVE_INFINITY;
+    let ymin = Number.POSITIVE_INFINITY;
+    let xmax = Number.NEGATIVE_INFINITY;
+    let ymax = Number.NEGATIVE_INFINITY;
+    let seen = false;
+    for (const set of coordSets) {
+        if (!Array.isArray(set))
+            continue;
+        for (const pt of set) {
+            if (!Array.isArray(pt) || typeof pt[0] !== "number" || typeof pt[1] !== "number")
+                continue;
+            seen = true;
+            xmin = Math.min(xmin, pt[0]);
+            ymin = Math.min(ymin, pt[1]);
+            xmax = Math.max(xmax, pt[0]);
+            ymax = Math.max(ymax, pt[1]);
+        }
+    }
+    return seen ? { xmin, ymin, xmax, ymax } : undefined;
+}
+/**
+ * True when the spatial filter is a plain envelope (exact bbox intersection).
+ * Anything else is reduced to its bbox and is therefore an approximation the
+ * caller should be told about via a `degraded` reason.
+ */
+export function isEnvelopeFilter(filter) {
+    return filter.geometryType === "esriGeometryEnvelope";
+}
+/**
+ * Compile the spatial predicate for a bbox against a geometry plan. Prefers the
+ * GeoParquet 1.1 bbox-covering column (row-group-skippable) when present, then
+ * falls back to `ST_Intersects(<geom>, ST_MakeEnvelope(...))`.
+ */
+export function spatialPredicate(bbox, plan) {
+    const xmin = numberLiteral(bbox.xmin);
+    const ymin = numberLiteral(bbox.ymin);
+    const xmax = numberLiteral(bbox.xmax);
+    const ymax = numberLiteral(bbox.ymax);
+    if (plan.bboxColumn) {
+        const b = quoteIdentifier(plan.bboxColumn);
+        // Two envelopes intersect iff neither is strictly to one side of the other.
+        return `${b}.xmin <= ${xmax} AND ${b}.xmax >= ${xmin} AND ` + `${b}.ymin <= ${ymax} AND ${b}.ymax >= ${ymin}`;
+    }
+    return `ST_Intersects(${geometryExpr(plan)}, ST_MakeEnvelope(${xmin}, ${ymin}, ${xmax}, ${ymax}))`;
+}
+const DEFAULT_GEOMETRY_ALIAS = "geometry";
+// ── WHERE + ORDER BY + LIMIT fragments ────────────────────────
+function whereClause(query, spatial) {
+    const clauses = [];
+    if (typeof query.where === "string" && query.where.trim().length > 0) {
+        clauses.push(`(${query.where})`);
+    }
+    if (spatial)
+        clauses.push(`(${spatial})`);
+    return clauses.length > 0 ? ` WHERE ${clauses.join(" AND ")}` : "";
+}
+function orderByClause(orderBy) {
+    if (!orderBy || orderBy.length === 0)
+        return "";
+    const parts = orderBy.map((s) => {
+        const dir = s.direction === "desc" ? " DESC" : " ASC";
+        return `${quoteIdentifier(s.field)}${dir}`;
+    });
+    return ` ORDER BY ${parts.join(", ")}`;
+}
+function limitOffsetClause(query) {
+    let out = "";
+    const limit = query.pagination?.limit;
+    const offset = query.pagination?.offset;
+    if (typeof limit === "number")
+        out += ` LIMIT ${integerLiteral(limit)}`;
+    if (typeof offset === "number" && offset > 0)
+        out += ` OFFSET ${integerLiteral(offset)}`;
+    return out;
+}
+// ── Projection ────────────────────────────────────────────────
+function projection(query, options) {
+    const geom = options.geometry;
+    const geomAlias = quoteIdentifier(options.geometryAlias ?? DEFAULT_GEOMETRY_ALIAS);
+    const wantGeometry = query.returnGeometry !== false && geom !== undefined;
+    // `geoarrow-*` columns are raw nested struct/list values, not a DuckDB
+    // `GEOMETRY` — project them as-is and let the caller's native decoder
+    // (built on src/columnar/geoarrow.ts) turn the materialized rows into
+    // GeoJSON. Every other encoding keeps projecting `ST_AsGeoJSON(...)` text.
+    const geomSelect = wantGeometry
+        ? isGeoArrowNativeEncoding(geom.encoding)
+            ? `${quoteIdentifier(geom.column)} AS ${geomAlias}`
+            : `ST_AsGeoJSON(${geometryExpr(geom)}) AS ${geomAlias}`
+        : undefined;
+    const outFields = query.outFields;
+    if (outFields && outFields.length > 0) {
+        const cols = outFields.filter((f) => !geom || f !== geom.column).map((f) => quoteIdentifier(f));
+        if (geomSelect)
+            cols.push(geomSelect);
+        return cols.length > 0 ? cols.join(", ") : "*";
+    }
+    // No explicit projection: select every non-geometry column, plus the
+    // GeoJSON-projected geometry when requested. When we do not know the column
+    // list, fall back to `* EXCLUDE (geom)` so raw WKB never rides along.
+    const nonGeom = options.columns?.filter((c) => !geom || c !== geom.column);
+    if (nonGeom && nonGeom.length > 0) {
+        const cols = nonGeom.map((c) => quoteIdentifier(c));
+        if (geomSelect)
+            cols.push(geomSelect);
+        return cols.join(", ");
+    }
+    if (geom) {
+        const base = `* EXCLUDE (${quoteIdentifier(geom.column)})`;
+        return geomSelect ? `${base}, ${geomSelect}` : base;
+    }
+    return "*";
+}
+/**
+ * Compile a feature {@link Query} into a DuckDB `SELECT`. The geometry column,
+ * when present and `returnGeometry !== false`, is projected as GeoJSON text via
+ * `ST_AsGeoJSON` under the alias `geometry` (overridable).
+ */
+export function compileQuery(query, options) {
+    const from = parquetSourceExpr(options.sources);
+    let spatial;
+    let bboxApproximated = false;
+    if (query.spatialFilter) {
+        if (!options.geometry) {
+            throw new Error("geoparquet: spatialFilter supplied but the source has no detected geometry column");
+        }
+        const bbox = bboxFromSpatialFilter(query.spatialFilter);
+        if (bbox) {
+            spatial = spatialPredicate(bbox, options.geometry);
+            bboxApproximated = !isEnvelopeFilter(query.spatialFilter);
+        }
+    }
+    const sql = `SELECT ${projection(query, options)} FROM ${from}${whereClause(query, spatial)}${orderByClause(query.orderBy)}${limitOffsetClause(query)}`;
+    return { sql, bboxApproximated };
+}
+function aggregateFn(fn, field) {
+    const col = field === "*" ? "*" : quoteIdentifier(field);
+    switch (fn) {
+        case "count":
+            return `count(${col})`;
+        case "sum":
+            return `sum(${col})`;
+        case "avg":
+            return `avg(${col})`;
+        case "min":
+            return `min(${col})`;
+        case "max":
+            return `max(${col})`;
+        case "stddev":
+            return `stddev_samp(${col})`;
+        case "var":
+            return `var_samp(${col})`;
+    }
+}
+/**
+ * Compile an {@link AggregationSpec} into a GROUP BY `SELECT`. Group-by fields
+ * are echoed in the projection (so the returned rows carry the group key),
+ * followed by each metric expression aliased to its `alias` (or `fn_field`).
+ */
+export function compileAggregate(query, options) {
+    const from = parquetSourceExpr(options.sources);
+    const agg = query.aggregation;
+    if (!agg.metrics || agg.metrics.length === 0) {
+        throw new Error("geoparquet: aggregation requires at least one metric");
+    }
+    const groupBy = agg.groupBy ?? [];
+    const selectParts = [];
+    for (const field of groupBy)
+        selectParts.push(quoteIdentifier(field));
+    for (const m of agg.metrics) {
+        const alias = quoteIdentifier(m.alias ?? `${m.fn}_${m.field === "*" ? "all" : m.field}`);
+        selectParts.push(`${aggregateFn(m.fn, m.field)} AS ${alias}`);
+    }
+    let spatial;
+    let bboxApproximated = false;
+    if (query.spatialFilter && options.geometry) {
+        const bbox = bboxFromSpatialFilter(query.spatialFilter);
+        if (bbox) {
+            spatial = spatialPredicate(bbox, options.geometry);
+            bboxApproximated = !isEnvelopeFilter(query.spatialFilter);
+        }
+    }
+    const groupByClause = groupBy.length > 0 ? ` GROUP BY ${groupBy.map((f) => quoteIdentifier(f)).join(", ")}` : "";
+    const sql = `SELECT ${selectParts.join(", ")} FROM ${from}${whereClause(query, spatial)}${groupByClause}${orderByClause(query.orderBy)}${limitOffsetClause(query)}`;
+    return { sql, bboxApproximated };
+}
+/**
+ * SQL that reads the parquet footer schema without scanning rows.
+ */
+export function describeSql(sources) {
+    return `DESCRIBE SELECT * FROM ${parquetSourceExpr(sources)}`;
+}
+/**
+ * Cheap row-count estimate from the parquet footer (`num_rows` per row group),
+ * summed across all files. Avoids a full `count(*)` table scan on large
+ * Overture extracts.
+ */
+export function rowEstimateSql(sources) {
+    const list = sources.map(stringLiteral);
+    const arg = list.length === 1 ? list[0] : `[${list.join(", ")}]`;
+    return `SELECT CAST(COALESCE(sum(num_rows), 0) AS BIGINT) AS row_estimate FROM parquet_file_metadata(${arg})`;
+}
+/**
+ * SQL that reads the GeoParquet `geo` key-value metadata (the JSON blob that
+ * carries `primary_column`, per-column `encoding`, and `crs`). Returns zero
+ * rows for Parquet-native geometry files, which carry no `geo` metadata.
+ */
+export function geoMetadataSql(sources) {
+    const list = sources.map(stringLiteral);
+    const arg = list.length === 1 ? list[0] : `[${list.join(", ")}]`;
+    return `SELECT files.file_name, geo.value FROM parquet_file_metadata(${arg}) AS files LEFT JOIN parquet_kv_metadata(${arg}) AS geo ON geo.file_name = files.file_name AND decode(geo.key) = 'geo' ORDER BY files.file_name`;
+}

package/core/odata-key-path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Encode an OData key predicate without hiding its structural grammar.
+ *
+ * Quotes plus the `,` / `=` delimiters outside quoted literals remain
+ * visible to direct and JSON-batch OData parsers. Unsafe value characters
+ * are percent-encoded by Unicode code point so non-BMP string keys remain
+ * valid path data rather than splitting or truncating the target URL.
+ *
+ * @internal
+ */
+export declare function encodeOdataKeyPredicatePath(key: string | number): string;
+//# sourceMappingURL=odata-key-path.d.ts.map

package/core/odata-key-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odata-key-path.d.ts","sourceRoot":"","sources":["../../../src/core/odata-key-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAiBxE"}

package/core/odata-key-path.js

@@ -0,0 +1,28 @@
+/**
+ * Encode an OData key predicate without hiding its structural grammar.
+ *
+ * Quotes plus the `,` / `=` delimiters outside quoted literals remain
+ * visible to direct and JSON-batch OData parsers. Unsafe value characters
+ * are percent-encoded by Unicode code point so non-BMP string keys remain
+ * valid path data rather than splitting or truncating the target URL.
+ *
+ * @internal
+ */
+export function encodeOdataKeyPredicatePath(key) {
+    const raw = String(key);
+    let output = "";
+    let inQuote = false;
+    for (const character of raw) {
+        if (character === "'") {
+            inQuote = !inQuote;
+            output += "'";
+            continue;
+        }
+        if (!inQuote && (character === "," || character === "=")) {
+            output += character;
+            continue;
+        }
+        output += /[A-Za-z0-9\-._~]/.test(character) ? character : encodeURIComponent(character);
+    }
+    return output;
+}

package/core/odata-write-codec.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Metadata-driven OData write encoding primitives.
+ *
+ * This module deliberately has no transport dependencies. Callers supply the
+ * already-cached CSDL projection and decide how to attach the encoded body,
+ * content type, and key to an HTTP request.
+ */
+import { type HonuaOdataMetadata } from "./odata.js";
+/** Stable failure categories for local, pre-transport encoding errors. */
+export type HonuaOdataEdmEncodingErrorCode = "cyclic-value" | "invalid-metadata" | "invalid-options" | "invalid-value" | "max-depth-exceeded" | "missing-key" | "resource-limit-exceeded" | "unknown-entity-set" | "unsupported-type";
+/**
+ * A redacted local encoding failure.
+ *
+ * Messages contain a fixed explanation and a bounded, escaped property path.
+ * The rejected value and request body are intentionally never retained.
+ */
+export declare class HonuaOdataEdmEncodingError extends TypeError {
+    readonly code: HonuaOdataEdmEncodingErrorCode;
+    readonly path: string;
+    constructor(code: HonuaOdataEdmEncodingErrorCode, path: string);
+}
+/**
+ * Controls the hard recursion bound for complex, collection, and untyped
+ * values. Fixed breadth and aggregate-node budgets also protect every call.
+ */
+export interface HonuaOdataEdmEncodingOptions {
+    /** Maximum nested container depth. Defaults to and cannot exceed 32. */
+    readonly maxDepth?: number;
+}
+/** Controls metadata-typed entity-key encoding. */
+export interface HonuaOdataEntityKeyEncodingOptions extends HonuaOdataEdmEncodingOptions {
+    /**
+     * Ordered metadata key fields to place in this URL predicate. Omit this for
+     * a direct entity set. Navigation paths may provide the child-key subset
+     * because the parent key is already carried by the path.
+     */
+    readonly keyFields?: readonly string[];
+}
+/** Body projection consumed by a later HTTP/edit integration layer. */
+export interface HonuaOdataEncodedWriteBody {
+    /** JSON-compatible body with metadata-declared values encoded losslessly. */
+    readonly body: Record<string, unknown>;
+    /** Whether the body requires `IEEE754Compatible=true` on its media type. */
+    readonly requiresIeee754Compatible: boolean;
+}
+/** Key projection consumed by direct and batch URL builders. */
+export interface HonuaOdataEncodedEntityKey {
+    /** OData key predicate content, without surrounding parentheses. */
+    readonly literal: string;
+    /** The same predicate encoded as one RFC 3986-safe URL path segment. */
+    readonly pathSegment: string;
+}
+/**
+ * Encode one entity body using the entity and complex property declarations in
+ * an existing OData metadata snapshot.
+ */
+export declare function encodeOdataWriteBody(metadata: HonuaOdataMetadata, entitySet: string, body: Readonly<Record<string, unknown>>, options?: HonuaOdataEdmEncodingOptions): HonuaOdataEncodedWriteBody;
+/**
+ * Encode a single or composite primary key in metadata declaration order.
+ *
+ * A single key accepts either its scalar value or an object carrying the key
+ * property. Composite keys require an object so component names cannot be
+ * confused or reordered by the caller.
+ */
+export declare function encodeOdataEntityKey(metadata: HonuaOdataMetadata, entitySet: string, key: unknown, options?: HonuaOdataEntityKeyEncodingOptions): HonuaOdataEncodedEntityKey;
+//# sourceMappingURL=odata-write-codec.d.ts.map

package/core/odata-write-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odata-write-codec.d.ts","sourceRoot":"","sources":["../../../src/core/odata-write-codec.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAGL,KAAK,kBAAkB,EAGxB,MAAM,YAAY,CAAC;AAwCpB,0EAA0E;AAC1E,MAAM,MAAM,8BAA8B,GACtC,cAAc,GACd,kBAAkB,GAClB,iBAAiB,GACjB,eAAe,GACf,oBAAoB,GACpB,aAAa,GACb,yBAAyB,GACzB,oBAAoB,GACpB,kBAAkB,CAAC;AAEvB;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;IACvD,SAAgB,IAAI,EAAE,8BAA8B,CAAC;IACrD,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,8BAA8B,EAAE,IAAI,EAAE,MAAM;CAMtE;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,mDAAmD;AACnD,MAAM,WAAW,kCAAmC,SAAQ,4BAA4B;IACtF;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED,uEAAuE;AACvE,MAAM,WAAW,0BAA0B;IACzC,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,4EAA4E;IAC5E,QAAQ,CAAC,yBAAyB,EAAE,OAAO,CAAC;CAC7C;AAED,gEAAgE;AAChE,MAAM,WAAW,0BAA0B;IACzC,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAkBD;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,OAAO,GAAE,4BAAiC,GACzC,0BAA0B,CAS5B;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,EAC5B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,kCAAuC,GAC/C,0BAA0B,CAyC5B"}