@honua/react 0.1.0-beta.0 → 0.1.1-beta.0

package/style/renderers.js

@@ -0,0 +1,517 @@
+/**
+ * First-class renderer objects (issue #497): serializable, renderer-neutral
+ * descriptions of smart-mapping styles (class breaks, unique values, heatmap,
+ * clustering) that compile deterministically to MapLibre style fragments
+ * through the `/expr` builder.
+ *
+ * A renderer object is a pure value: construct it from options (or revive it
+ * from JSON with {@link rendererFromJSON}), read legend metadata with
+ * `legendItems()`, and compile MapLibre layer fragments with
+ * `toMapLibre(geometryType)`. Compilation is a pure function of the
+ * descriptor — no caching, no map access — so the same descriptor always
+ * produces byte-identical style JSON.
+ *
+ * The WebMap JSON converter (`src/webmap/convert-renderer.ts`) and the
+ * esri-compat renderer shims emit these objects instead of private
+ * transforms, so there is exactly one class-breaks/unique-value compiler in
+ * the SDK.
+ *
+ * @module
+ */
+import { concat, get, heatmapDensity, interpolate, linear, matchExpr, step, toNumber, } from "../expr/expression.js";
+/**
+ * Create a graduated (class-breaks) renderer: a `step` expression over a
+ * numeric field.
+ *
+ * @example
+ * ```ts
+ * const renderer = classBreaksRenderer({
+ *   field: "magnitude",
+ *   breaks: [
+ *     { min: 0, max: 3, label: "Minor" },
+ *     { min: 3, max: 5, label: "Moderate" },
+ *     { min: 5, label: "Strong" },
+ *   ],
+ *   colors: ["#fed976", "#fd8d3c", "#b10026"],
+ *   defaultColor: "#cccccc",
+ * });
+ * const [fragment] = renderer.toMapLibre("point");
+ * // fragment.paint["circle-color"] → ["step", ["get", "magnitude"], "#cccccc", 0, "#fed976", …]
+ * ```
+ *
+ * @experimental
+ */
+export function classBreaksRenderer(options) {
+    const descriptor = cloneDescriptor({ ...options, kind: "class-breaks" });
+    if (typeof descriptor.field !== "string" || descriptor.field.length === 0) {
+        throw new TypeError("classBreaksRenderer requires a non-empty field.");
+    }
+    if (!Array.isArray(descriptor.breaks) || descriptor.breaks.length === 0) {
+        throw new TypeError("classBreaksRenderer requires at least one break.");
+    }
+    descriptor.breaks.forEach((entry, index) => {
+        if (entry.style !== undefined)
+            return; // advanced entries are trusted as-is
+        if (entry.min === undefined && entry.max === undefined) {
+            throw new TypeError(`breaks[${index}] needs a min or max threshold.`);
+        }
+        if (entry.color === undefined && descriptor.colors?.[index] === undefined) {
+            throw new TypeError(`breaks[${index}] needs a color, a positional colors[] entry, or a style override.`);
+        }
+    });
+    return Object.freeze({
+        kind: "class-breaks",
+        toJSON: () => cloneDescriptor(descriptor),
+        legendItems: () => classBreaksLegend(descriptor),
+        toMapLibre: (geometry) => {
+            const type = descriptor.layerType ?? layerTypeFor(geometry);
+            const colorProperty = colorPropertyFor(type);
+            const entries = descriptor.breaks.map((entry, index) => ({
+                key: entry.min ?? entry.max,
+                style: resolveEntryStyle(entry, index, descriptor.colors, colorProperty),
+            }));
+            const defaultStyle = resolveDefaultStyle(descriptor, colorProperty);
+            const compiled = compileDataDrivenStyle("step", get(descriptor.field), entries, defaultStyle);
+            return Object.freeze([
+                Object.freeze({ role: "symbolizer", type, paint: compiled.paint, layout: compiled.layout }),
+            ]);
+        },
+    });
+}
+function classBreaksLegend(descriptor) {
+    const items = descriptor.breaks.map((entry, index) => Object.freeze({
+        kind: "class-break",
+        label: entry.label ?? formatRange(entry.min, entry.max),
+        color: legendColor(entry.color, index, descriptor.colors, entry.style),
+        ...(entry.min !== undefined ? { minValue: entry.min } : {}),
+        ...(entry.max !== undefined ? { maxValue: entry.max } : {}),
+    }));
+    const defaultItem = legendDefaultItem(descriptor);
+    if (defaultItem)
+        items.push(defaultItem);
+    return Object.freeze(items);
+}
+/**
+ * Create a categorical (unique-value) renderer: a `match` expression over a
+ * feature property (or a delimited concatenation of up to three).
+ *
+ * @example
+ * ```ts
+ * const renderer = uniqueValueRenderer({
+ *   field: "priority",
+ *   values: [
+ *     { value: "high", color: "#b91c1c", label: "High priority" },
+ *     { value: "low", color: "#0f766e", label: "Low priority" },
+ *   ],
+ *   defaultColor: "#334155",
+ * });
+ * renderer.legendItems(); // [{ kind: "unique-value", label: "High priority", … }, …]
+ * ```
+ *
+ * @experimental
+ */
+export function uniqueValueRenderer(options) {
+    const descriptor = cloneDescriptor({ ...options, kind: "unique-value" });
+    if (typeof descriptor.field !== "string") {
+        throw new TypeError("uniqueValueRenderer requires a field.");
+    }
+    if (!Array.isArray(descriptor.values) || descriptor.values.length === 0) {
+        throw new TypeError("uniqueValueRenderer requires at least one value entry.");
+    }
+    descriptor.values.forEach((entry, index) => {
+        if (entry.value === undefined)
+            throw new TypeError(`values[${index}] needs a value.`);
+        if (entry.color === undefined && entry.style === undefined) {
+            throw new TypeError(`values[${index}] needs a color or a style override.`);
+        }
+    });
+    return Object.freeze({
+        kind: "unique-value",
+        toJSON: () => cloneDescriptor(descriptor),
+        legendItems: () => uniqueValueLegend(descriptor),
+        toMapLibre: (geometry) => {
+            const type = descriptor.layerType ?? layerTypeFor(geometry);
+            const colorProperty = colorPropertyFor(type);
+            const entries = descriptor.values.map((entry) => ({
+                key: entry.value,
+                style: resolveEntryStyle(entry, undefined, undefined, colorProperty),
+            }));
+            const defaultStyle = resolveDefaultStyle(descriptor, colorProperty);
+            const compiled = compileDataDrivenStyle("match", uniqueValueFieldExpression(descriptor), entries, defaultStyle);
+            return Object.freeze([
+                Object.freeze({ role: "symbolizer", type, paint: compiled.paint, layout: compiled.layout }),
+            ]);
+        },
+    });
+}
+function uniqueValueFieldExpression(descriptor) {
+    if (!descriptor.field2 && !descriptor.field3)
+        return get(descriptor.field);
+    const delimiter = descriptor.fieldDelimiter ?? ",";
+    const parts = [];
+    if (descriptor.field)
+        parts.push(get(descriptor.field));
+    if (descriptor.field2) {
+        parts.push(delimiter);
+        parts.push(get(descriptor.field2));
+    }
+    if (descriptor.field3) {
+        parts.push(delimiter);
+        parts.push(get(descriptor.field3));
+    }
+    return concat(...parts);
+}
+function uniqueValueLegend(descriptor) {
+    const items = descriptor.values.map((entry) => Object.freeze({
+        kind: "unique-value",
+        label: entry.label ?? String(entry.value),
+        color: legendColor(entry.color, undefined, undefined, entry.style),
+        value: entry.value,
+    }));
+    const defaultItem = legendDefaultItem(descriptor);
+    if (defaultItem)
+        items.push(defaultItem);
+    return Object.freeze(items);
+}
+const DEFAULT_HEATMAP_RAMP = Object.freeze([
+    Object.freeze({ stop: 0, color: "rgba(33,102,172,0)" }),
+    Object.freeze({ stop: 0.2, color: "rgb(103,169,207)" }),
+    Object.freeze({ stop: 0.4, color: "rgb(209,229,240)" }),
+    Object.freeze({ stop: 0.6, color: "rgb(253,219,199)" }),
+    Object.freeze({ stop: 0.8, color: "rgb(239,138,98)" }),
+    Object.freeze({ stop: 1, color: "rgb(178,24,43)" }),
+]);
+/**
+ * Create a MapLibre-native heatmap renderer. Compiles to a single `heatmap`
+ * layer fragment regardless of the requested geometry (heatmaps render
+ * point data).
+ *
+ * @experimental
+ */
+export function heatmapRenderer(options = {}) {
+    const descriptor = cloneDescriptor({ ...options, kind: "heatmap" });
+    const ramp = normalizeHeatmapRamp(descriptor.colorRamp);
+    return Object.freeze({
+        kind: "heatmap",
+        toJSON: () => cloneDescriptor(descriptor),
+        legendItems: () => Object.freeze(ramp.map((entry) => Object.freeze({
+            kind: "heatmap-stop",
+            label: String(entry.stop),
+            color: entry.color,
+            value: entry.stop,
+        }))),
+        toMapLibre: () => {
+            const paint = {
+                "heatmap-radius": descriptor.radius ?? 30,
+                "heatmap-intensity": descriptor.intensity ?? 1,
+                "heatmap-color": interpolate(linear(), heatmapDensity(), ...ramp.map((entry) => [entry.stop, entry.color])).toJSON(),
+            };
+            if (descriptor.weightField !== undefined) {
+                paint["heatmap-weight"] = toNumber(get(descriptor.weightField), 0).toJSON();
+            }
+            if (descriptor.opacity !== undefined)
+                paint["heatmap-opacity"] = descriptor.opacity;
+            return Object.freeze([Object.freeze({ role: "symbolizer", type: "heatmap", paint, layout: {} })]);
+        },
+    });
+}
+function normalizeHeatmapRamp(ramp) {
+    if (ramp === undefined || ramp.length === 0)
+        return DEFAULT_HEATMAP_RAMP;
+    if (typeof ramp[0] === "string") {
+        const colors = ramp;
+        if (colors.length === 1)
+            return [{ stop: 1, color: colors[0] }];
+        return colors.map((color, index) => ({
+            stop: roundStop(index / (colors.length - 1)),
+            color,
+        }));
+    }
+    const stops = [...ramp];
+    for (let i = 1; i < stops.length; i++) {
+        if (stops[i].stop <= stops[i - 1].stop) {
+            throw new TypeError("heatmapRenderer colorRamp stops must be strictly ascending.");
+        }
+    }
+    return stops;
+}
+function roundStop(value) {
+    return Math.round(value * 1000) / 1000;
+}
+/**
+ * Create a MapLibre-native cluster renderer. Compiles to three fragments —
+ * cluster circles, cluster count labels, and unclustered points — plus
+ * GeoJSON source cluster options via {@link ClusterRenderer.toMapLibreSource}.
+ *
+ * @experimental
+ */
+export function clusterRenderer(options) {
+    const descriptor = cloneDescriptor({ ...options, kind: "cluster" });
+    if (!Array.isArray(descriptor.steps) || descriptor.steps.length === 0) {
+        throw new TypeError("clusterRenderer requires at least one step.");
+    }
+    for (let i = 1; i < descriptor.steps.length; i++) {
+        if (descriptor.steps[i].threshold <= descriptor.steps[i - 1].threshold) {
+            throw new TypeError("clusterRenderer steps must have strictly ascending thresholds.");
+        }
+    }
+    const sumProperty = descriptor.countField !== undefined ? `${descriptor.countField}_sum` : undefined;
+    const countExpression = () => get(sumProperty ?? "point_count");
+    return Object.freeze({
+        kind: "cluster",
+        toJSON: () => cloneDescriptor(descriptor),
+        toMapLibreSource: () => ({
+            cluster: true,
+            clusterRadius: descriptor.radius ?? 50,
+            clusterMaxZoom: descriptor.maxZoom ?? 14,
+            ...(descriptor.countField !== undefined && sumProperty !== undefined
+                ? { clusterProperties: { [sumProperty]: ["+", ["get", descriptor.countField]] } }
+                : {}),
+        }),
+        legendItems: () => clusterLegend(descriptor),
+        toMapLibre: () => {
+            const steps = descriptor.steps;
+            const color = steps.length === 1
+                ? steps[0].color
+                : step(countExpression(), steps[0].color, ...steps.slice(1).map((entry) => [entry.threshold, entry.color])).toJSON();
+            const radiusFor = (entry, index) => entry.radius ?? 14 + 6 * index;
+            const radius = steps.length === 1
+                ? radiusFor(steps[0], 0)
+                : step(countExpression(), radiusFor(steps[0], 0), ...steps
+                    .slice(1)
+                    .map((entry, index) => [entry.threshold, radiusFor(entry, index + 1)])).toJSON();
+            const clusters = Object.freeze({
+                role: "clusters",
+                type: "circle",
+                filter: ["has", "point_count"],
+                paint: {
+                    "circle-color": color,
+                    "circle-radius": radius,
+                    "circle-stroke-color": "#ffffff",
+                    "circle-stroke-width": 1.5,
+                },
+                layout: {},
+            });
+            const count = Object.freeze({
+                role: "cluster-count",
+                type: "symbol",
+                filter: ["has", "point_count"],
+                paint: { "text-color": "#ffffff" },
+                layout: {
+                    "text-field": sumProperty !== undefined ? ["to-string", ["get", sumProperty]] : ["get", "point_count_abbreviated"],
+                    "text-size": 12,
+                },
+            });
+            const unclustered = Object.freeze({
+                role: "unclustered",
+                type: "circle",
+                filter: ["!", ["has", "point_count"]],
+                paint: {
+                    "circle-color": descriptor.unclusteredColor ?? "#16735b",
+                    "circle-radius": descriptor.unclusteredRadius ?? 5,
+                    "circle-stroke-color": "#ffffff",
+                    "circle-stroke-width": 1,
+                },
+                layout: {},
+            });
+            return Object.freeze([clusters, count, unclustered]);
+        },
+    });
+}
+function clusterLegend(descriptor) {
+    const items = descriptor.steps.map((entry, index) => {
+        const next = descriptor.steps[index + 1];
+        return Object.freeze({
+            kind: "cluster-step",
+            label: entry.label ?? (next ? `${entry.threshold}–${next.threshold}` : `≥ ${entry.threshold}`),
+            color: entry.color,
+            minValue: entry.threshold,
+            ...(next ? { maxValue: next.threshold } : {}),
+        });
+    });
+    items.push(Object.freeze({
+        kind: "default",
+        label: "Individual features",
+        color: descriptor.unclusteredColor ?? "#16735b",
+    }));
+    return Object.freeze(items);
+}
+// ── JSON revival ─────────────────────────────────────────────────
+/**
+ * Revive a renderer object from its serializable descriptor
+ * (`renderer.toJSON()` output).
+ *
+ * @experimental
+ */
+export function rendererFromJSON(descriptor) {
+    switch (descriptor.kind) {
+        case "class-breaks":
+            return classBreaksRenderer(descriptor);
+        case "unique-value":
+            return uniqueValueRenderer(descriptor);
+        case "heatmap":
+            return heatmapRenderer(descriptor);
+        case "cluster":
+            return clusterRenderer(descriptor);
+        default:
+            throw new TypeError(`Unknown renderer kind "${String(descriptor.kind)}".`);
+    }
+}
+/** True when a value looks like a renderer object from this module. @experimental */
+export function isRenderer(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.toMapLibre === "function" &&
+        typeof candidate.legendItems === "function" &&
+        (candidate.kind === "class-breaks" ||
+            candidate.kind === "unique-value" ||
+            candidate.kind === "heatmap" ||
+            candidate.kind === "cluster"));
+}
+// ── Shared compilation core (single implementation, REQ-002) ─────
+/**
+ * MapLibre properties that live in `layout` rather than `paint`. Shared with
+ * the WebMap converter so both route properties identically.
+ *
+ * @internal
+ */
+export const RENDERER_LAYOUT_PROPERTIES = new Set([
+    "icon-image",
+    "icon-size",
+    "icon-offset",
+    "icon-anchor",
+    "icon-rotate",
+    "text-field",
+    "text-font",
+    "text-size",
+    "text-offset",
+    "text-anchor",
+    "text-max-width",
+    "text-letter-spacing",
+    "text-justify",
+    "text-rotate",
+    "symbol-placement",
+    "symbol-spacing",
+    "visibility",
+]);
+/**
+ * The single class-breaks/unique-value property compiler (issue #497
+ * REQ-002). For every paint/layout property present on any class it builds
+ * one `match` (categorical) or `step` (graduated) expression through the
+ * `/expr` builder. When `defaultStyle` is omitted the first entry's style
+ * provides per-property defaults; missing values fall back to
+ * `"transparent"`.
+ *
+ * @internal
+ */
+export function compileDataDrivenStyle(mode, input, entries, defaultStyle) {
+    const paint = {};
+    const layout = {};
+    if (entries.length === 0)
+        return { paint, layout };
+    const keys = new Set();
+    for (const entry of entries) {
+        for (const key of Object.keys(entry.style.paint))
+            keys.add(key);
+        for (const key of Object.keys(entry.style.layout))
+            keys.add(key);
+    }
+    const fallbackStyle = defaultStyle ?? entries[0].style;
+    for (const key of keys) {
+        const defaultValue = (fallbackStyle.paint[key] ?? fallbackStyle.layout[key] ?? "transparent");
+        // Classes that do not define this property fall back to the default so
+        // the emitted match/step expression never contains `undefined` branches.
+        const valueFor = (entry) => (entry.style.paint[key] ?? entry.style.layout[key] ?? defaultValue);
+        let expression;
+        if (mode === "match") {
+            expression = matchExpr(input, ...entries.map((entry) => [entry.key, valueFor(entry)]), defaultValue).toJSON();
+        }
+        else {
+            expression = step(input, defaultValue, ...entries.map((entry) => [entry.key, valueFor(entry)])).toJSON();
+        }
+        if (RENDERER_LAYOUT_PROPERTIES.has(key))
+            layout[key] = expression;
+        else
+            paint[key] = expression;
+    }
+    return { paint, layout };
+}
+// ── Internal helpers ─────────────────────────────────────────────
+function layerTypeFor(geometry) {
+    return geometry === "point" ? "circle" : geometry === "line" ? "line" : "fill";
+}
+function colorPropertyFor(layerType) {
+    switch (layerType) {
+        case "circle":
+            return "circle-color";
+        case "line":
+            return "line-color";
+        case "fill":
+            return "fill-color";
+        case "symbol":
+            return "icon-color";
+        default:
+            return `${layerType}-color`;
+    }
+}
+function resolveEntryStyle(entry, index, colors, colorProperty) {
+    if (entry.style !== undefined) {
+        return { paint: { ...(entry.style.paint ?? {}) }, layout: { ...(entry.style.layout ?? {}) } };
+    }
+    const color = entry.color ?? (index !== undefined ? colors?.[index] : undefined);
+    return { paint: color !== undefined ? { [colorProperty]: color } : {}, layout: {} };
+}
+function resolveDefaultStyle(descriptor, colorProperty) {
+    if (descriptor.defaultStyle !== undefined) {
+        return {
+            paint: { ...(descriptor.defaultStyle.paint ?? {}) },
+            layout: { ...(descriptor.defaultStyle.layout ?? {}) },
+        };
+    }
+    if (descriptor.defaultColor !== undefined) {
+        return { paint: { [colorProperty]: descriptor.defaultColor }, layout: {} };
+    }
+    return undefined;
+}
+function legendColor(color, index, colors, style) {
+    const resolved = color ?? (index !== undefined ? colors?.[index] : undefined) ?? styleColor(style);
+    return resolved ?? "transparent";
+}
+function styleColor(style) {
+    if (!style)
+        return undefined;
+    for (const bag of [style.paint, style.layout]) {
+        if (!bag)
+            continue;
+        for (const [key, value] of Object.entries(bag)) {
+            if (key.endsWith("-color") && typeof value === "string")
+                return value;
+        }
+    }
+    return undefined;
+}
+function legendDefaultItem(descriptor) {
+    if (descriptor.defaultColor === undefined &&
+        descriptor.defaultLabel === undefined &&
+        descriptor.defaultStyle === undefined) {
+        return undefined;
+    }
+    return Object.freeze({
+        kind: "default",
+        label: descriptor.defaultLabel ?? "Other",
+        color: descriptor.defaultColor ?? styleColor(descriptor.defaultStyle) ?? "transparent",
+    });
+}
+function formatRange(min, max) {
+    if (min !== undefined && max !== undefined)
+        return `${min}–${max}`;
+    if (min !== undefined)
+        return `≥ ${min}`;
+    if (max !== undefined)
+        return `≤ ${max}`;
+    return "";
+}
+function cloneDescriptor(value) {
+    return structuredClone(value);
+}

package/webmap/convert-renderer.d.ts

@@ -1,12 +1,16 @@
 /**
  * Converts Esri renderer JSON to MapLibre paint/layout properties.
  *
- * Handles simple, uniqueValue, and classBreaks renderers. Produces
- * data-driven expressions (match, step) for categorized/graduated renderers.
+ * Since issue #497 this module emits first-class renderer objects
+ * (`src/style/renderers.ts`) for uniqueValue/classBreaks renderers and
+ * compiles them through the shared `/expr`-based compiler, so WebMap
+ * conversion, esri-compat, and standalone renderer objects share a single
+ * implementation. The compiled style output is unchanged.
  *
  * @module
  */
-import type { WebMapRenderer } from "./types.js";
+import type { ClassBreaksRenderer, UniqueValueRenderer } from "../style/renderers.js";
+import type { WebMapClassBreaksRenderer, WebMapRenderer, WebMapUniqueValueRenderer } from "./types.js";
 import type { WarningCollector } from "./warnings.js";
 export interface RendererConversionResult {
     layerType: string;
@@ -14,4 +18,21 @@ export interface RendererConversionResult {
     layout: Record<string, unknown>;
 }
 export declare function convertRenderer(renderer: WebMapRenderer | undefined, warn: WarningCollector): RendererConversionResult | undefined;
+/**
+ * Build a first-class unique-value renderer object from WebMap renderer
+ * JSON. Returns `undefined` when the renderer has no value infos or the
+ * first symbol cannot be converted (matching `convertRenderer` behavior).
+ *
+ * @experimental
+ */
+export declare function uniqueValueRendererFromWebMap(renderer: WebMapUniqueValueRenderer, warn: WarningCollector): UniqueValueRenderer | undefined;
+/**
+ * Build a first-class class-breaks renderer object from WebMap renderer
+ * JSON. Returns `undefined` when the renderer has no break infos, no field,
+ * or the first symbol cannot be converted (matching `convertRenderer`
+ * behavior).
+ *
+ * @experimental
+ */
+export declare function classBreaksRendererFromWebMap(renderer: WebMapClassBreaksRenderer, warn: WarningCollector): ClassBreaksRenderer | undefined;
 //# sourceMappingURL=convert-renderer.d.ts.map

package/webmap/convert-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert-renderer.d.ts","sourceRoot":"","sources":["../../../src/webmap/convert-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAA6B,cAAc,EAA2C,MAAM,YAAY,CAAC;AACrH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,IAAI,EAAE,gBAAgB,GACrB,wBAAwB,GAAG,SAAS,CActC"}
+{"version":3,"file":"convert-renderer.d.ts","sourceRoot":"","sources":["../../../src/webmap/convert-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAmC,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGvH,OAAO,KAAK,EAAE,yBAAyB,EAAE,cAAc,EAAgB,yBAAyB,EAAE,MAAM,YAAY,CAAC;AACrH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,GAAG,SAAS,EACpC,IAAI,EAAE,gBAAgB,GACrB,wBAAwB,GAAG,SAAS,CActC;AAmCD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,yBAAyB,EACnC,IAAI,EAAE,gBAAgB,GACrB,mBAAmB,GAAG,SAAS,CA6BjC;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,yBAAyB,EACnC,IAAI,EAAE,gBAAgB,GACrB,mBAAmB,GAAG,SAAS,CAgCjC"}