@honua/app-platform 0.1.9-beta.0 → 0.1.10-beta.0

package/web-components/measurement-units.js

@@ -0,0 +1,278 @@
+/**
+ * Unit conversion, display formatting, and planar (Euclidean, flat-earth)
+ * math for `<honua-measurement>` (issue #1419).
+ *
+ * All conversion and formatting here operates on the canonical SI value
+ * already stored on `HonuaMeasureResult` (meters / square meters) — never on
+ * a previously rounded display string — so switching `unit`/`areaUnit`/
+ * `precision` at runtime always reformats the same full-precision number.
+ *
+ * `planarLength` / `planarArea` intentionally do not depend on `proj4`
+ * (`@honua/geometry`'s `project`): pulling that in would add proj4 as a
+ * static import of every `<honua-measurement>` consumer's bundle (the
+ * `/web-components` and `/controls` entrypoints), well past their gzip
+ * budgets, for a fidelity mode most apps never enable. Instead this uses the
+ * same equirectangular (meters-per-degree-of-latitude/longitude) flat-earth
+ * approximation `MeasurementCompat` already ships in `src/esri-compat/
+ * measurement.ts` — accurate for the local-extent sketches this widget draws,
+ * and proven parity math rather than a new approach.
+ *
+ * @module
+ */
+const METERS_PER_DISTANCE_UNIT = {
+    meters: 1,
+    kilometers: 1000,
+    feet: 0.3048,
+    yards: 0.9144,
+    miles: 1609.344,
+    nauticalmiles: 1852,
+};
+const SQUARE_METERS_PER_AREA_UNIT = {
+    "square-meters": 1,
+    hectares: 10_000,
+    "square-kilometers": 1_000_000,
+    "square-feet": 0.09290304,
+    acres: 4046.8564224,
+    "square-miles": 2_589_988.110336,
+};
+const DISTANCE_UNIT_SUFFIX = {
+    meters: "m",
+    kilometers: "km",
+    feet: "ft",
+    yards: "yd",
+    miles: "mi",
+    nauticalmiles: "nmi",
+};
+const AREA_UNIT_SUFFIX = {
+    "square-meters": "m²",
+    hectares: "ha",
+    "square-kilometers": "km²",
+    "square-feet": "ft²",
+    acres: "ac",
+    "square-miles": "mi²",
+};
+/** Converts a distance already in meters into `unit`. */
+export function convertDistance(meters, unit) {
+    return meters / METERS_PER_DISTANCE_UNIT[unit];
+}
+/** Converts an area already in square meters into `unit`. */
+export function convertArea(squareMeters, unit) {
+    return squareMeters / SQUARE_METERS_PER_AREA_UNIT[unit];
+}
+/** Resolves `"auto"` to a concrete unit given the magnitude, matching the pre-#1419 auto-scaling. */
+function resolveDistanceUnit(meters, unit) {
+    if (unit !== "auto")
+        return unit;
+    return meters >= 1000 ? "kilometers" : "meters";
+}
+/** Resolves `"auto"` to a concrete unit given the magnitude, matching the pre-#1419 auto-scaling. */
+function resolveAreaUnit(squareMeters, unit) {
+    if (unit !== "auto")
+        return unit;
+    if (squareMeters >= 1_000_000)
+        return "square-kilometers";
+    if (squareMeters >= 10_000)
+        return "hectares";
+    return "square-meters";
+}
+/** Default decimal digits per resolved unit, matching the pre-#1419 formatting. */
+function defaultDistancePrecision(unit) {
+    return unit === "meters" ? 1 : 2;
+}
+/** Default decimal digits per resolved unit, matching the pre-#1419 formatting. */
+function defaultAreaPrecision(unit) {
+    return unit === "square-meters" ? 1 : 2;
+}
+/**
+ * Formats a canonical meters value for display. `precision` overrides the
+ * unit's default decimal digits; `unit` overrides magnitude-based auto-scaling.
+ */
+export function formatDistanceValue(meters, unit, precision) {
+    const resolved = resolveDistanceUnit(meters, unit);
+    const value = convertDistance(meters, resolved);
+    const digits = precision ?? defaultDistancePrecision(resolved);
+    return `${value.toFixed(digits)} ${DISTANCE_UNIT_SUFFIX[resolved]}`;
+}
+/**
+ * Formats a canonical square-meters value for display. `precision` overrides
+ * the unit's default decimal digits; `unit` overrides magnitude-based
+ * auto-scaling.
+ */
+export function formatAreaValue(squareMeters, unit, precision) {
+    const resolved = resolveAreaUnit(squareMeters, unit);
+    const value = convertArea(squareMeters, resolved);
+    const digits = precision ?? defaultAreaPrecision(resolved);
+    return `${value.toFixed(digits)} ${AREA_UNIT_SUFFIX[resolved]}`;
+}
+/** Distance units `<honua-measurement>` accepts, including `"auto"`. */
+export const HONUA_MEASURE_DISTANCE_UNITS = [
+    "auto",
+    ...Object.keys(METERS_PER_DISTANCE_UNIT),
+];
+/** Area units `<honua-measurement>` accepts, including `"auto"`. */
+export const HONUA_MEASURE_AREA_UNITS = [
+    "auto",
+    ...Object.keys(SQUARE_METERS_PER_AREA_UNIT),
+];
+/** Planar frames `<honua-measurement>` accepts for `fidelity: "planar"`. */
+export const HONUA_MEASURE_PLANAR_CRS = ["local", "EPSG:3857"];
+/** Meters per degree of latitude (WGS84, constant to within centimeters at any latitude). */
+const METERS_PER_DEGREE_LATITUDE = 111_132.92;
+/** Semi-major axis EPSG:3857 (spherical Web Mercator) projects onto. */
+const WEB_MERCATOR_RADIUS = 6_378_137;
+/** Latitude beyond which EPSG:3857 is undefined (the square-world clamp). */
+const WEB_MERCATOR_MAX_LATITUDE = 85.051_128_779_806_59;
+/** Meters per degree of longitude at WGS84 latitude `latDeg`. */
+function metersPerDegreeLongitude(latDeg) {
+    return 111_412.84 * Math.cos(toRadians(latDeg));
+}
+function toRadians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+function meanLatitude(positions) {
+    return positions.reduce((sum, [, lat]) => sum + lat, 0) / positions.length;
+}
+/**
+ * Whether a position is a usable WGS84 vertex: finite, with latitude inside
+ * `[-90, 90]`. Longitude may exceed ±180 — MapLibre reports clicks on a world
+ * copy that way — and is unwrapped before any planar math.
+ */
+export function isValidMeasureVertex(position) {
+    const [lng, lat] = position;
+    return (typeof lng === "number" &&
+        typeof lat === "number" &&
+        Number.isFinite(lng) &&
+        Number.isFinite(lat) &&
+        lat >= -90 &&
+        lat <= 90);
+}
+/**
+ * Shifts each longitude by whole turns so consecutive vertices are never more
+ * than 180° apart. A sketch crossing the antimeridian (179° → -179°) is then
+ * measured the short way, matching what the geodesic ops already do, instead
+ * of across 358° of flat map.
+ */
+export function unwrapLongitudes(positions) {
+    const unwrapped = [];
+    for (const [lng, lat] of positions) {
+        const previous = unwrapped[unwrapped.length - 1];
+        if (!previous) {
+            unwrapped.push([lng, lat]);
+            continue;
+        }
+        const turns = Math.round((lng - previous[0]) / 360);
+        unwrapped.push([lng - turns * 360, lat]);
+    }
+    return unwrapped;
+}
+/** Projects unwrapped lng/lat into the planar frame's meters. */
+function projector(positions, crs) {
+    if (crs === "EPSG:3857") {
+        return ([lng, lat]) => {
+            const clamped = Math.max(-WEB_MERCATOR_MAX_LATITUDE, Math.min(WEB_MERCATOR_MAX_LATITUDE, lat));
+            return [
+                WEB_MERCATOR_RADIUS * toRadians(lng),
+                WEB_MERCATOR_RADIUS * Math.log(Math.tan(Math.PI / 4 + toRadians(clamped) / 2)),
+            ];
+        };
+    }
+    const metersPerDegLon = metersPerDegreeLongitude(meanLatitude(positions));
+    return ([lng, lat]) => [lng * metersPerDegLon, lat * METERS_PER_DEGREE_LATITUDE];
+}
+/**
+ * Euclidean length of a line, in meters of the planar frame `crs`:
+ *
+ * - `"local"` (default): a flat-earth approximation centered on the vertices'
+ *   mean latitude, matching `MeasurementCompat`'s approximation.
+ * - `"EPSG:3857"`: spherical Web Mercator, the projected CRS MapLibre renders
+ *   in. Its meters are not scale-corrected, so lengths grow by `sec(latitude)`
+ *   away from the equator — which is what an app mirroring ArcGIS planar
+ *   measurement on a Web Mercator view expects.
+ *
+ * Unlike the geodesic `length` op in `@honua/geometry`, this never follows
+ * the great circle. Longitudes are unwrapped first, so an antimeridian
+ * crossing is measured the short way.
+ */
+export function planarLength(positions, crs = "local") {
+    if (positions.length < 2)
+        return 0;
+    const unwrapped = unwrapLongitudes(positions);
+    const project = projector(unwrapped, crs);
+    let total = 0;
+    for (let index = 1; index < unwrapped.length; index += 1) {
+        const [x0, y0] = project(unwrapped[index - 1]);
+        const [x1, y1] = project(unwrapped[index]);
+        total += Math.hypot(x1 - x0, y1 - y0);
+    }
+    return total;
+}
+/**
+ * Euclidean (shoelace) area of a ring, in square meters of the planar frame
+ * `crs` (see {@link planarLength}). `positions` need not be closed; the first
+ * vertex is implicitly repeated to close the ring.
+ */
+export function planarArea(positions, crs = "local") {
+    if (positions.length < 3)
+        return 0;
+    const unwrapped = unwrapLongitudes(positions);
+    const project = projector(unwrapped, crs);
+    const closed = [...unwrapped, unwrapped[0]].map(project);
+    let sum = 0;
+    for (let index = 1; index < closed.length; index += 1) {
+        const [x0, y0] = closed[index - 1];
+        const [x1, y1] = closed[index];
+        sum += x0 * y1 - x1 * y0;
+    }
+    return Math.abs(sum) / 2;
+}
+/**
+ * Whether the closed ring through `positions` crosses itself (a "bow tie").
+ * Such a ring has no single enclosed area: the shoelace and geodesic sums
+ * cancel the lobes against each other, so reporting their result would be a
+ * confident wrong number. Touching at a shared vertex of adjacent edges is
+ * not a crossing; collinear overlap of non-adjacent edges is.
+ */
+export function ringSelfIntersects(positions) {
+    const ring = unwrapLongitudes(positions);
+    const count = ring.length;
+    if (count < 4)
+        return false;
+    for (let first = 0; first < count; first += 1) {
+        const a = ring[first];
+        const b = ring[(first + 1) % count];
+        for (let second = first + 1; second < count; second += 1) {
+            // Skip the edge itself and the two edges that share a vertex with it.
+            if (second === first || (second + 1) % count === first || (first + 1) % count === second)
+                continue;
+            const c = ring[second];
+            const d = ring[(second + 1) % count];
+            if (segmentsIntersect(a, b, c, d))
+                return true;
+        }
+    }
+    return false;
+}
+function orientation(p, q, r) {
+    const value = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);
+    if (Math.abs(value) < 1e-12)
+        return 0;
+    return value > 0 ? 1 : 2;
+}
+function onSegment(p, q, r) {
+    return (q[0] <= Math.max(p[0], r[0]) &&
+        q[0] >= Math.min(p[0], r[0]) &&
+        q[1] <= Math.max(p[1], r[1]) &&
+        q[1] >= Math.min(p[1], r[1]));
+}
+function segmentsIntersect(a, b, c, d) {
+    const o1 = orientation(a, b, c);
+    const o2 = orientation(a, b, d);
+    const o3 = orientation(c, d, a);
+    const o4 = orientation(c, d, b);
+    if (o1 !== o2 && o3 !== o4)
+        return true;
+    return ((o1 === 0 && onSegment(a, c, b)) ||
+        (o2 === 0 && onSegment(a, d, b)) ||
+        (o3 === 0 && onSegment(c, a, d)) ||
+        (o4 === 0 && onSegment(c, b, d)));
+}

package/web-components/measurement.d.ts

@@ -11,6 +11,15 @@
  *   suspended while a mode is active when the map exposes the handle);
  * - **Escape** (or the Cancel button) discards the in-progress sketch.
  *
+ * Touch input needs nothing extra: MapLibre reports a tap as `click`, and the
+ * Finish button stands in for double-tap (which MapLibre does not report as
+ * `dblclick`).
+ *
+ * While a mode is active the element claims the map pointer
+ * (`./map-pointer-claim.js`), so a vertex click that lands on a feature does
+ * not also rewrite the shared selection `<honua-map>` feeds to tables,
+ * inspectors, and editors.
+ *
  * Distance and area are computed with the geodesic ops from the public
  * `@honua/geometry` surface (`length` / `area`), so the widget's numbers match
  * `geometryEngine` parity math everywhere else in the SDK.
@@ -25,6 +34,12 @@
  * in-progress sketch renders as a line + fill overlay in a
  * `honua-measurement` GeoJSON source; on plain stubs the overlay is skipped.
  *
+ * ## Units, precision, fidelity, CRS
+ * `unit`, `areaUnit`, `precision`, `fidelity`, and `planarCrs` are
+ * properties, also settable declaratively as the `unit`, `area-unit`,
+ * `precision`, `fidelity`, and `planar-crs` attributes. Unknown values fall
+ * back to the default rather than producing a malformed display.
+ *
  * ## Accessibility
  * Mode buttons are a `role="group"` of toggle buttons with `aria-pressed`;
  * the live result is announced through a `role="status"` region; Finish /
@@ -33,14 +48,66 @@
  *
  * @module
  */
-import type { HonuaMeasureMode, HonuaMeasureResult, HonuaMeasurementMap, HonuaMeasurementMessages } from "./types.js";
+import type { HonuaMeasureAreaUnit, HonuaMeasureDistanceUnit, HonuaMeasureFidelity, HonuaMeasureMode, HonuaMeasurePlanarCrs, HonuaMeasureResult, HonuaMeasurementMap, HonuaMeasurementMessages } from "./types.js";
 declare const HTMLElementBase: typeof HTMLElement;
 type LngLat = readonly [number, number];
+/**
+ * Distance and area measurement drawn directly on a MapLibre map.
+ *
+ * @attr {string} for - `id` of the `<honua-map>` (or any element exposing `.map`) to measure on.
+ * @attr {string} label - Heading and accessible name of the panel; `messages.label` wins when set.
+ * @fires {CustomEvent<HonuaMeasureChangeDetail>} honua-measure-change - A mode, vertex, result, fidelity, or planar CRS change. Bubbles and is composed.
+ * @csspart panel - The measurement panel.
+ * @csspart mode - Each mode toggle button.
+ * @csspart value - The live result readout (`role="status"`).
+ * @csspart finish - The Finish button.
+ * @csspart cancel - The Cancel button.
+ */
 export declare class HonuaMeasurementElement extends HTMLElementBase {
     #private;
     static get observedAttributes(): string[];
+    /** Caller-supplied labels, statuses, and ARIA text; unset entries keep the English defaults. */
     get messages(): HonuaMeasurementMessages;
     set messages(messages: HonuaMeasurementMessages | undefined);
+    /**
+     * Displayed distance unit. `"auto"` (default) keeps the metric auto-scaling
+     * behavior. Changing this reformats the existing full-precision result — it
+     * never recomputes from a rounded display value.
+     */
+    get unit(): HonuaMeasureDistanceUnit;
+    set unit(unit: HonuaMeasureDistanceUnit | undefined);
+    /**
+     * Displayed area unit. `"auto"` (default) keeps the metric auto-scaling
+     * behavior. Changing this reformats the existing full-precision result — it
+     * never recomputes from a rounded display value.
+     */
+    get areaUnit(): HonuaMeasureAreaUnit;
+    set areaUnit(unit: HonuaMeasureAreaUnit | undefined);
+    /** Decimal digits for the displayed value. `undefined` (default) uses a per-unit default. */
+    get precision(): number | undefined;
+    set precision(precision: number | undefined);
+    /**
+     * Which math computes `result.distance` / `result.area`: `"geodesic"`
+     * (default, great-circle over WGS84) or `"planar"` (Euclidean, in the
+     * {@link planarCrs} frame — see `./measurement-units.js`). Changing this
+     * recomputes from the drawn vertices, since it changes which math produces
+     * the canonical value.
+     */
+    get fidelity(): HonuaMeasureFidelity;
+    set fidelity(fidelity: HonuaMeasureFidelity | undefined);
+    /**
+     * Planar frame used when {@link fidelity} is `"planar"`: `"local"` (default,
+     * flat-earth meters around the sketch) or `"EPSG:3857"` (Web Mercator
+     * meters, not scale-corrected). Recomputes like {@link fidelity} does.
+     */
+    get planarCrs(): HonuaMeasurePlanarCrs;
+    set planarCrs(crs: HonuaMeasurePlanarCrs | undefined);
+    /**
+     * CRS vertices are recorded in. Always WGS84 (`"EPSG:4326"`): vertices come
+     * from map click events, which report geographic lng/lat regardless of the
+     * map's own projection. Exposed so a consumer never has to assume it.
+     */
+    get crs(): "EPSG:4326";
     /** The MapLibre map this widget draws on. */
     get map(): HonuaMeasurementMap | undefined;
     set map(map: HonuaMeasurementMap | undefined);
@@ -54,13 +121,17 @@ export declare class HonuaMeasurementElement extends HTMLElementBase {
     get vertices(): readonly LngLat[];
     /** Activates a measure mode; `"off"` cancels any in-progress sketch. */
     setMode(mode: HonuaMeasureMode): void;
-    /** Adds a vertex programmatically (same as a map click). */
-    addVertex(lngLat: LngLat): void;
+    /**
+     * Adds a vertex programmatically (same as a map click). Returns `false`,
+     * changing nothing, when no mode is active or the position is not a usable
+     * WGS84 vertex (non-finite, or latitude outside `[-90, 90]`).
+     */
+    addVertex(lngLat: LngLat): boolean;
     /** Finishes the in-progress sketch (same as double-click). */
     finish(): void;
     /** Cancels the in-progress sketch (same as Escape); the mode stays active. */
     cancel(): void;
-    attributeChangedCallback(name: string): void;
+    attributeChangedCallback(name: string, _previous?: string | null, value?: string | null): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
     protected render(): void;

package/web-components/measurement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../../src/web-components/measurement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH,OAAO,KAAK,EAEV,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAQpB,QAAA,MAAM,eAAe,EAAE,OAAO,WAAkF,CAAC;AAMjH,KAAK,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAExC,qBAAa,uBAAwB,SAAQ,eAAe;;IAC1D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IASD,IAAW,QAAQ,IAAI,wBAAwB,CAE9C;IACD,IAAW,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,GAAG,SAAS,EAGjE;IAOD,6CAA6C;IAC7C,IAAW,GAAG,IAAI,mBAAmB,GAAG,SAAS,CAEhD;IAED,IAAW,GAAG,CAAC,GAAG,EAAE,mBAAmB,GAAG,SAAS,EAMlD;IAED,wEAAwE;IACjE,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,IAAI;IAI9C,+BAA+B;IAC/B,IAAW,IAAI,IAAI,gBAAgB,CAElC;IAED,yDAAyD;IACzD,IAAW,MAAM,IAAI,kBAAkB,GAAG,SAAS,CAElD;IAED,4DAA4D;IAC5D,IAAW,QAAQ,IAAI,SAAS,MAAM,EAAE,CAEvC;IAED,wEAAwE;IACjE,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAY5C,4DAA4D;IACrD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAatC,8DAA8D;IACvD,MAAM,IAAI,IAAI;IASrB,8EAA8E;IACvE,MAAM,IAAI,IAAI;IAUd,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ5C,iBAAiB,IAAI,IAAI;IAQzB,oBAAoB,IAAI,IAAI;IAsMnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAwGzB;AAED,gFAAgF;AAChF,wBAAgB,sBAAsB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKhF"}
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../../src/web-components/measurement.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAgBH,OAAO,KAAK,EACV,oBAAoB,EAEpB,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAQpB,QAAA,MAAM,eAAe,EAAE,OAAO,WAAkF,CAAC;AAMjH,KAAK,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAIxC;;;;;;;;;;;GAWG;AACH,qBAAa,uBAAwB,SAAQ,eAAe;;IAC1D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IAcD,gGAAgG;IAChG,IAAW,QAAQ,IAAI,wBAAwB,CAE9C;IACD,IAAW,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,GAAG,SAAS,EAGjE;IAED;;;;OAIG;IACH,IAAW,IAAI,IAAI,wBAAwB,CAE1C;IACD,IAAW,IAAI,CAAC,IAAI,EAAE,wBAAwB,GAAG,SAAS,EAGzD;IAED;;;;OAIG;IACH,IAAW,QAAQ,IAAI,oBAAoB,CAE1C;IACD,IAAW,QAAQ,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,EAGzD;IAED,6FAA6F;IAC7F,IAAW,SAAS,IAAI,MAAM,GAAG,SAAS,CAEzC;IACD,IAAW,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAQjD;IAED;;;;;;OAMG;IACH,IAAW,QAAQ,IAAI,oBAAoB,CAE1C;IACD,IAAW,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,GAAG,SAAS,EAO7D;IAED;;;;OAIG;IACH,IAAW,SAAS,IAAI,qBAAqB,CAE5C;IACD,IAAW,SAAS,CAAC,GAAG,EAAE,qBAAqB,GAAG,SAAS,EAQ1D;IAED;;;;OAIG;IACH,IAAW,GAAG,IAAI,WAAW,CAE5B;IAUD,6CAA6C;IAC7C,IAAW,GAAG,IAAI,mBAAmB,GAAG,SAAS,CAEhD;IAED,IAAW,GAAG,CAAC,GAAG,EAAE,mBAAmB,GAAG,SAAS,EAMlD;IAED,wEAAwE;IACjE,OAAO,CAAC,GAAG,EAAE,mBAAmB,GAAG,IAAI;IAI9C,+BAA+B;IAC/B,IAAW,IAAI,IAAI,gBAAgB,CAElC;IAED,yDAAyD;IACzD,IAAW,MAAM,IAAI,kBAAkB,GAAG,SAAS,CAElD;IAED,4DAA4D;IAC5D,IAAW,QAAQ,IAAI,SAAS,MAAM,EAAE,CAEvC;IAED,wEAAwE;IACjE,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAY5C;;;;OAIG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAczC,8DAA8D;IACvD,MAAM,IAAI,IAAI;IASrB,8EAA8E;IACvE,MAAM,IAAI,IAAI;IAUd,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IA2B9F,iBAAiB,IAAI,IAAI;IAczB,oBAAoB,IAAI,IAAI;IA+OnC,SAAS,CAAC,MAAM,IAAI,IAAI;CA2GzB;AAED,gFAAgF;AAChF,wBAAgB,sBAAsB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKhF"}