@honua/app-platform 0.0.20-alpha.0

package/scene-workspace/scene-discovery.js

@@ -0,0 +1,228 @@
+/**
+ * HTTP scene discovery for the 3D scene workspace.
+ *
+ * Honua publishes 3D scenes over the `geospatial.v1` `SceneService`
+ * (`ListScenes` / `GetScene`) and mirrors that catalog over plain HTTP scene
+ * discovery (`GET /api/scenes`, `GET /api/scenes/{id}`) alongside the static
+ * 3D-Tiles entry point (`GET /scenes/{id}/tileset.json`). This module gives the
+ * SDK a typed read model over that discovery surface and maps a discovered
+ * {@link HonuaScene} onto the renderer-neutral {@link SceneRuntimePrimitive}s the
+ * Cesium adapter renders.
+ *
+ * Discovery calls go through a caller-supplied {@link SceneDiscoveryRequestExecutor}
+ * — typically `(...args) => client.pipelineRequestJson(...args)` against a
+ * `HonuaClient` — so they reuse the SDK's shared auth / retry / timeout /
+ * interceptor pipeline rather than issuing ad-hoc `fetch` calls. Modelling the
+ * transport as a function keeps this module free of a hard `core/client` import
+ * (and equally usable from a Node backend, a worker, or a unit test with a mock).
+ *
+ * The mapping helpers ({@link sceneToRuntimePrimitives},
+ * {@link sceneCameraPrimitive}, {@link sceneViewpointBookmarks}) are pure (no
+ * Cesium, no transport) and unit-testable on their own.
+ *
+ * @experimental Part of the experimental `scene-workspace` surface; not yet
+ *   covered by the SDK's semver contract prior to `1.0.0`.
+ * @module
+ */
+import { trimTrailingSlashes } from "../core/path-utils.js";
+const SCENES_BASE_PATH = "/api/scenes";
+function normalizeCamera(raw) {
+    if (!raw || raw.longitude === undefined || raw.latitude === undefined)
+        return undefined;
+    return {
+        longitude: raw.longitude,
+        latitude: raw.latitude,
+        height: raw.height ?? 0,
+        ...(raw.heading !== undefined ? { heading: raw.heading } : {}),
+        ...(raw.pitch !== undefined ? { pitch: raw.pitch } : {}),
+        ...(raw.roll !== undefined ? { roll: raw.roll } : {}),
+    };
+}
+function normalizeExtent(raw) {
+    if (!raw)
+        return undefined;
+    const envelope = raw.extent ?? raw;
+    if (envelope.xmin === undefined ||
+        envelope.ymin === undefined ||
+        envelope.xmax === undefined ||
+        envelope.ymax === undefined) {
+        return undefined;
+    }
+    const minHeight = raw.minHeight ?? raw.min_height;
+    const maxHeight = raw.maxHeight ?? raw.max_height;
+    return {
+        xmin: envelope.xmin,
+        ymin: envelope.ymin,
+        xmax: envelope.xmax,
+        ymax: envelope.ymax,
+        ...(minHeight !== undefined ? { minHeight } : {}),
+        ...(maxHeight !== undefined ? { maxHeight } : {}),
+        ...(envelope.spatialReference !== undefined ? { spatialReference: envelope.spatialReference } : {}),
+    };
+}
+/**
+ * Normalize a raw scene payload (camelCase or proto3-JSON snake_case) into a
+ * {@link HonuaScene}. Exported so the normalization is unit-testable against
+ * either wire shape without a transport.
+ */
+export function normalizeScene(raw) {
+    const sceneId = raw.sceneId ?? raw.scene_id ?? "";
+    const tilesetUrl = raw.tilesetUrl ?? raw.tileset_url;
+    const terrainUrl = raw.terrainUrl ?? raw.terrain_url;
+    const initialCamera = normalizeCamera(raw.initialCamera ?? raw.initial_camera);
+    const viewpoints = (raw.viewpoints ?? [])
+        .map((viewpoint) => {
+        const camera = normalizeCamera(viewpoint.camera);
+        if (!camera || !viewpoint.id)
+            return undefined;
+        return { id: viewpoint.id, title: viewpoint.title ?? viewpoint.id, camera };
+    })
+        .filter((viewpoint) => viewpoint !== undefined);
+    const styleExpression = raw.styleExpression ?? raw.style?.expression;
+    return {
+        sceneId,
+        ...(raw.title !== undefined ? { title: raw.title } : {}),
+        ...(raw.description !== undefined ? { description: raw.description } : {}),
+        ...(tilesetUrl !== undefined ? { tilesetUrl } : {}),
+        ...(terrainUrl !== undefined ? { terrainUrl } : {}),
+        ...(normalizeExtent(raw.extent) ? { extent: normalizeExtent(raw.extent) } : {}),
+        ...(initialCamera ? { initialCamera } : {}),
+        viewpoints,
+        ...(styleExpression !== undefined ? { styleExpression } : {}),
+        ...(raw.edition !== undefined ? { edition: raw.edition } : {}),
+        capabilities: raw.capabilities ?? [],
+    };
+}
+/**
+ * List the catalog of available 3D scenes from `GET /api/scenes`
+ * (`SceneService.ListScenes`). Returns the normalized {@link HonuaScene}s.
+ */
+export async function listScenes(execute, signal) {
+    const raw = await execute("GET", SCENES_BASE_PATH, undefined, signal);
+    return (raw.scenes ?? []).map(normalizeScene);
+}
+/**
+ * Fetch a single scene's metadata from `GET /api/scenes/{sceneId}`
+ * (`SceneService.GetScene`). The response is tolerated as either the bare scene
+ * object or a `{ scene }` envelope.
+ */
+export async function getScene(execute, sceneId, signal) {
+    if (!sceneId)
+        throw new Error("getScene requires a non-empty sceneId.");
+    const raw = await execute("GET", `${SCENES_BASE_PATH}/${encodeURIComponent(sceneId)}`, undefined, signal);
+    return normalizeScene(raw.scene ?? raw);
+}
+/**
+ * Resolve the static 3D-Tiles entry-point URL for a scene
+ * (`/scenes/{sceneId}/tileset.json`). Prefers the scene's advertised
+ * `tilesetUrl`; falls back to the conventional discovery path under `baseUrl`
+ * when the scene omits one. Returns `undefined` when neither is available.
+ */
+export function resolveSceneTilesetUrl(scene, baseUrl) {
+    if (scene.tilesetUrl && scene.tilesetUrl.trim() !== "")
+        return scene.tilesetUrl;
+    if (!baseUrl)
+        return undefined;
+    const trimmed = trimTrailingSlashes(baseUrl);
+    return `${trimmed}/scenes/${encodeURIComponent(scene.sceneId)}/tileset.json`;
+}
+/**
+ * Build the camera primitive for a scene's suggested initial view, or
+ * `undefined` when the scene advertises no initial camera. Pure.
+ */
+export function sceneCameraPrimitive(scene) {
+    if (!scene.initialCamera)
+        return undefined;
+    return {
+        kind: "camera",
+        id: `${scene.sceneId}:camera`,
+        camera: scene.initialCamera,
+        mode: "global",
+    };
+}
+/**
+ * Build the 3D-Tiles model-layer primitive for a scene's root tileset, or
+ * `undefined` when the scene has no resolvable tileset URL. Pure.
+ */
+export function sceneTilesetPrimitive(scene, baseUrl) {
+    const uri = resolveSceneTilesetUrl(scene, baseUrl);
+    if (!uri)
+        return undefined;
+    return {
+        kind: "model-layer",
+        id: `${scene.sceneId}:tileset`,
+        uri,
+        format: "3d-tiles",
+        ...(scene.title !== undefined ? { title: scene.title } : {}),
+    };
+}
+/**
+ * Build the terrain elevation-source primitive for a scene's terrain provider,
+ * or `undefined` when the scene advertises no terrain. Pure. The provider is
+ * treated as a quantized-mesh endpoint (Cesium's `CesiumTerrainProvider`).
+ */
+export function sceneTerrainPrimitive(scene) {
+    if (!scene.terrainUrl || scene.terrainUrl.trim() === "")
+        return undefined;
+    return {
+        kind: "elevation-source",
+        id: `${scene.sceneId}:terrain`,
+        sourceId: `${scene.sceneId}:terrain`,
+        protocol: "quantized-mesh",
+        url: scene.terrainUrl,
+    };
+}
+/**
+ * Map a discovered scene onto the renderer-neutral primitives the Cesium
+ * adapter renders: an initial-camera primitive, the terrain elevation source
+ * (when present), and the 3D-Tiles tileset (when resolvable). Pure; the result
+ * feeds straight into `applyCesiumScenePrimitives` / a `SceneView`.
+ */
+export function sceneToRuntimePrimitives(scene, baseUrl) {
+    const primitives = [];
+    const camera = sceneCameraPrimitive(scene);
+    if (camera)
+        primitives.push(camera);
+    const terrain = sceneTerrainPrimitive(scene);
+    if (terrain)
+        primitives.push(terrain);
+    const tileset = sceneTilesetPrimitive(scene, baseUrl);
+    if (tileset)
+        primitives.push(tileset);
+    return primitives;
+}
+/**
+ * Build the workspace layer states for a discovered scene (one per rendered
+ * primitive), so a {@link module:scene-workspace/workspace.SceneWorkspace} can
+ * seed its layer list from the scene. Pure.
+ */
+export function sceneLayerStates(scene, baseUrl) {
+    const layers = [];
+    if (sceneTilesetPrimitive(scene, baseUrl)) {
+        layers.push({
+            id: `${scene.sceneId}:tileset`,
+            title: scene.title ?? scene.sceneId,
+            visible: true,
+            kind: "tiles",
+        });
+    }
+    if (sceneTerrainPrimitive(scene)) {
+        layers.push({
+            id: `${scene.sceneId}:terrain`,
+            title: "Terrain",
+            visible: true,
+            kind: "scene",
+        });
+    }
+    return layers;
+}
+/**
+ * Convert a scene's named viewpoints into workspace {@link SceneBookmark}s. Pure.
+ */
+export function sceneViewpointBookmarks(scene) {
+    return scene.viewpoints.map((viewpoint) => ({
+        id: viewpoint.id,
+        label: viewpoint.title,
+        camera: viewpoint.camera,
+    }));
+}

package/scene-workspace/scene-view.d.ts

@@ -0,0 +1,209 @@
+/**
+ * `SceneView` — first-class 3D scene container backed by a Cesium runtime.
+ *
+ * `SceneView` is the 3D counterpart of {@link module:map.HonuaMap}: a cohesive,
+ * typed handle that loads a Honua scene and drives a live Cesium globe through
+ * the renderer-neutral {@link module:scene-workspace/cesium-adapter} (#1196). It
+ * renders the scene's 3D Tiles + terrain + glTF models (#1197) and exposes the
+ * 3D analysis + measurement widgets — line-of-sight, viewshed, measure, and
+ * elevation profile (#1205) — wired to the SDK's request pipeline.
+ *
+ * Like the rest of the scene workspace, this module never imports CesiumJS
+ * statically — the live `Viewer`/`Scene` is supplied by the caller as a
+ * {@link CesiumSceneRuntimeTarget}, and the adapter pulls the runtime in lazily
+ * only when it drives the globe. A `SceneView` constructed without a `target`
+ * still loads + diagnoses scenes (useful headless / in tests) but renders
+ * nothing.
+ *
+ * @example
+ * ```ts
+ * import { SceneView } from "@honua/sdk-js/scene-workspace";
+ *
+ * const view = new SceneView({ client, target: { camera: viewer.camera, scene: viewer.scene } });
+ * await view.loadScene("downtown");
+ * view.on((event) => { if (event.type === "scene-loaded") console.log(event.scene.title); });
+ *
+ * const los = await view.lineOfSight({
+ *   datasetId: "dem",
+ *   observer: { longitude: -157.8, latitude: 21.3, height: 30 },
+ *   target: { longitude: -157.81, latitude: 21.31 },
+ *   entities: viewer.entities,
+ * });
+ * ```
+ *
+ * @experimental Part of the experimental `scene-workspace` surface; not yet
+ *   covered by the SDK's semver contract prior to `1.0.0`.
+ * @module
+ */
+import type { HonuaClient } from "../core/client.js";
+import type { QueryMethod } from "../core/types.js";
+import { type CesiumEntityCollectionLike, type ElevationProfileRequest, type ElevationProfileResult, type LineOfSightRequest, type LineOfSightResult, type SceneAnalysisCesiumModule, type SceneAnalysisOverlay, type SceneAnalysisPosition, type SceneMeasurement, type ViewshedRequest, type ViewshedResult } from "./analysis-widgets.js";
+import { type CesiumSceneRuntimeTarget } from "./cesium-adapter.js";
+import type { ScenePrimitiveDiagnostic } from "./primitives.js";
+import { type HonuaScene } from "./scene-discovery.js";
+import type { SceneBookmark, SceneCameraState, SceneLayerState } from "./types.js";
+/**
+ * The request transport a {@link SceneView} uses for scene discovery and
+ * analysis endpoints. Exactly `HonuaClient.pipelineRequestJson`, so it reuses
+ * the SDK's shared auth / retry / timeout / interceptor pipeline.
+ */
+export type SceneViewRequestExecutor = <T = unknown>(method: QueryMethod, path: string, init?: {
+    headers?: Record<string, string>;
+    body?: string | null;
+}, signal?: AbortSignal) => Promise<T>;
+/** Options for constructing a {@link SceneView}. */
+export interface SceneViewOptions {
+    /**
+     * The Honua client whose request pipeline backs scene discovery and the
+     * analysis endpoints. Either `client` or an explicit `execute` is required.
+     */
+    readonly client?: HonuaClient;
+    /**
+     * Explicit request executor (overrides `client.pipelineRequestJson`). Lets a
+     * caller wire a custom transport, or a test inject a mock without a client.
+     */
+    readonly execute?: SceneViewRequestExecutor;
+    /**
+     * The live Cesium target (a `camera`, plus an optional `scene` for layer
+     * rendering). Omit to load + diagnose scenes headlessly without rendering.
+     */
+    readonly target?: CesiumSceneRuntimeTarget;
+    /**
+     * Base URL used to resolve a scene's static `tileset.json` entry point when
+     * the scene omits an explicit `tilesetUrl`. Defaults to `client.serverBaseUrl`.
+     */
+    readonly baseUrl?: string;
+}
+/** Events emitted by a {@link SceneView}. */
+export type SceneViewEvent = {
+    readonly type: "scene-loaded";
+    readonly scene: HonuaScene;
+} | {
+    readonly type: "layers-changed";
+    readonly layers: readonly SceneLayerState[];
+} | {
+    readonly type: "layer-visibility";
+    readonly layerId: string;
+    readonly visible: boolean;
+} | {
+    readonly type: "camera-change";
+    readonly camera: SceneCameraState;
+} | {
+    readonly type: "diagnostics";
+    readonly diagnostics: readonly ScenePrimitiveDiagnostic[];
+};
+/** A listener registered via {@link SceneView.on}. */
+export type SceneViewEventListener = (event: SceneViewEvent) => void;
+/** The detached request shape shared by the analysis widget convenience methods. */
+type AnalysisOverlayTarget = {
+    /** Entity collection (typically `viewer.entities`) the result is drawn into. */
+    readonly entities?: CesiumEntityCollectionLike;
+    /** Optional Cesium-module override (test seam). */
+    readonly cesium?: SceneAnalysisCesiumModule;
+};
+/**
+ * First-class 3D scene container. Loads a Honua scene, renders it through the
+ * Cesium adapter, and exposes the analysis/measurement widgets.
+ */
+export declare class SceneView {
+    #private;
+    constructor(options: SceneViewOptions);
+    /** List the catalog of available 3D scenes (`GET /api/scenes`). */
+    listScenes(signal?: AbortSignal): Promise<HonuaScene[]>;
+    /** Fetch a single scene's metadata without loading it (`GET /api/scenes/{id}`). */
+    getScene(sceneId: string, signal?: AbortSignal): Promise<HonuaScene>;
+    /**
+     * Load a scene by id (or a pre-fetched {@link HonuaScene}) and render it onto
+     * the live target: the initial camera, terrain provider, and 3D-Tiles
+     * tileset. Replaces any previously loaded scene's layers. Returns the loaded
+     * scene. When no target is attached the scene is loaded + diagnosed but not
+     * rendered.
+     */
+    loadScene(scene: string | HonuaScene, signal?: AbortSignal): Promise<HonuaScene>;
+    /** The currently loaded scene, or `undefined` before the first `loadScene`. */
+    get scene(): HonuaScene | undefined;
+    /** Snapshot of the loaded scene's layers (one per rendered primitive). */
+    get layers(): readonly SceneLayerState[];
+    /** The loaded scene's named viewpoints as workspace bookmarks. */
+    get bookmarks(): readonly SceneBookmark[];
+    /** Diagnostics from the most recent render (capability gaps, fallbacks). */
+    get diagnostics(): readonly ScenePrimitiveDiagnostic[];
+    /** Whether a live Cesium target is attached (and therefore rendering). */
+    get hasTarget(): boolean;
+    /**
+     * Toggle a rendered layer's visibility on the live globe and in the layer
+     * snapshot. No-ops (still updates the snapshot) when the layer is not rendered
+     * (e.g. no target attached). Returns `true` when the layer is known.
+     */
+    setLayerVisible(layerId: string, visible: boolean): boolean;
+    /**
+     * Read the live camera back as a renderer-neutral {@link SceneCameraState},
+     * or `undefined` when no target is attached. Also emits a `camera-change`
+     * event so subscribers can persist the current view.
+     */
+    readCamera(): SceneCameraState | undefined;
+    /**
+     * Fly/jump to a named viewpoint (bookmark) on the loaded scene. Returns the
+     * applied camera state, or `undefined` when the viewpoint is unknown. The
+     * actual `Camera.setView` is performed through the adapter so no static Cesium
+     * import is needed here.
+     */
+    applyBookmark(bookmarkId: string): Promise<SceneCameraState | undefined>;
+    /**
+     * Set the live camera to an explicit {@link SceneCameraState}. Returns the
+     * applied state (or `undefined` when no target is attached). Routed through
+     * the adapter's camera primitive so the lazy Cesium import stays centralized.
+     */
+    setCamera(camera: SceneCameraState): Promise<SceneCameraState | undefined>;
+    /**
+     * Run a line-of-sight analysis between an observer and a target. When an
+     * `entities` collection is supplied the sightline + obstruction marker are
+     * drawn into the scene and the overlay handle is returned alongside the
+     * result.
+     */
+    lineOfSight(request: LineOfSightRequest & AnalysisOverlayTarget): Promise<{
+        result: LineOfSightResult;
+        overlay?: SceneAnalysisOverlay;
+    }>;
+    /**
+     * Run a viewshed analysis from an observer position. When an `entities`
+     * collection is supplied the radial visibility samples are drawn into the
+     * scene and the overlay handle is returned alongside the result.
+     */
+    viewshed(request: ViewshedRequest & AnalysisOverlayTarget): Promise<{
+        result: ViewshedResult;
+        overlay?: SceneAnalysisOverlay;
+    }>;
+    /**
+     * Request an elevation profile along a polyline. When an `entities`
+     * collection is supplied the draped profile line is drawn into the scene and
+     * the overlay handle is returned alongside the result.
+     */
+    elevationProfile(request: ElevationProfileRequest & AnalysisOverlayTarget): Promise<{
+        result: ElevationProfileResult;
+        overlay?: SceneAnalysisOverlay;
+    }>;
+    /**
+     * Compute a fully client-side 3D distance or area measurement from an ordered
+     * list of positions (typically picked off the scene). When an `entities`
+     * collection is supplied the measured polyline/polygon + label are drawn into
+     * the scene and the overlay handle is returned alongside the measurement.
+     */
+    measure(positions: readonly SceneAnalysisPosition[], options?: {
+        readonly mode?: "distance" | "area";
+    } & AnalysisOverlayTarget): Promise<{
+        measurement: SceneMeasurement;
+        overlay?: SceneAnalysisOverlay;
+    }>;
+    /** Subscribe to view events. Returns a handle with `remove()` to unsubscribe. */
+    on(listener: SceneViewEventListener): {
+        remove(): void;
+    };
+    /**
+     * Tear down all rendered layers and clear listeners. The supplied Cesium
+     * target is owned by the caller and is NOT destroyed.
+     */
+    dispose(): void;
+}
+export {};
+//# sourceMappingURL=scene-view.d.ts.map

package/scene-workspace/scene-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-view.d.ts","sourceRoot":"","sources":["../../../src/scene-workspace/scene-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAE1B,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,EASpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,wBAAwB,EAG9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAChE,OAAO,EACL,KAAK,UAAU,EAOhB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEnF;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,GAAG,OAAO,EACjD,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACjE,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhB,oDAAoD;AACpD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,wBAAwB,CAAC;IAC5C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,wBAAwB,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,GAChF;IAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAC1F;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,GACrE;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,wBAAwB,EAAE,CAAA;CAAE,CAAC;AAEhG,sDAAsD;AACtD,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;AAErE,oFAAoF;AACpF,KAAK,qBAAqB,GAAG;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,CAAC,EAAE,0BAA0B,CAAC;IAC/C,mDAAmD;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,yBAAyB,CAAC;CAC7C,CAAC;AAEF;;;GAGG;AACH,qBAAa,SAAS;;gBAYR,OAAO,EAAE,gBAAgB;IAYrC,mEAAmE;IACnE,UAAU,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAIvD,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAMpE;;;;;;OAMG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAoBtF,+EAA+E;IAC/E,IAAI,KAAK,IAAI,UAAU,GAAG,SAAS,CAElC;IAED,0EAA0E;IAC1E,IAAI,MAAM,IAAI,SAAS,eAAe,EAAE,CAEvC;IAED,kEAAkE;IAClE,IAAI,SAAS,IAAI,SAAS,aAAa,EAAE,CAExC;IAED,4EAA4E;IAC5E,IAAI,WAAW,IAAI,SAAS,wBAAwB,EAAE,CAErD;IAED,0EAA0E;IAC1E,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;OAIG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAY3D;;;;OAIG;IACH,UAAU,IAAI,gBAAgB,GAAG,SAAS;IAO1C;;;;;OAKG;IACG,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAM9E;;;;OAIG;IACG,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAWhF;;;;;OAKG;IACG,WAAW,CACf,OAAO,EAAE,kBAAkB,GAAG,qBAAqB,GAClD,OAAO,CAAC;QAAE,MAAM,EAAE,iBAAiB,CAAC;QAAC,OAAO,CAAC,EAAE,oBAAoB,CAAA;KAAE,CAAC;IAOzE;;;;OAIG;IACG,QAAQ,CACZ,OAAO,EAAE,eAAe,GAAG,qBAAqB,GAC/C,OAAO,CAAC;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,OAAO,CAAC,EAAE,oBAAoB,CAAA;KAAE,CAAC;IAOtE;;;;OAIG;IACG,gBAAgB,CACpB,OAAO,EAAE,uBAAuB,GAAG,qBAAqB,GACvD,OAAO,CAAC;QAAE,MAAM,EAAE,sBAAsB,CAAC;QAAC,OAAO,CAAC,EAAE,oBAAoB,CAAA;KAAE,CAAC;IAO9E;;;;;OAKG;IACG,OAAO,CACX,SAAS,EAAE,SAAS,qBAAqB,EAAE,EAC3C,OAAO,GAAE;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,CAAA;KAAE,GAAG,qBAA0B,GAC5E,OAAO,CAAC;QAAE,WAAW,EAAE,gBAAgB,CAAC;QAAC,OAAO,CAAC,EAAE,oBAAoB,CAAA;KAAE,CAAC;IAS7E,iFAAiF;IACjF,EAAE,CAAC,QAAQ,EAAE,sBAAsB,GAAG;QAAE,MAAM,IAAI,IAAI,CAAA;KAAE;IASxD;;;OAGG;IACH,OAAO,IAAI,IAAI;CA2BhB"}