@hydranium/glsp-server 1.0.0-next.10

package/lib/storage/hydranium-glsp-storage.d.ts

@@ -0,0 +1,348 @@
+/********************************************************************************
+ * Copyright (c) 2023-2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type Action, ActionDispatcher, type ClientSession, type ClientSessionListener, ClientSessionManager, type DefaultCommandStack, type Disposable, Logger as GlspLogger, type MaybePromise, ModelValidator, type RequestModelAction, type SaveModelAction, type SourceModelStorage } from '@eclipse-glsp/server';
+import { Debouncer, DisposableCollection } from '@hydranium/protocol';
+import { type AstNode } from '@hydranium/langium';
+import { AstDocument, type AstDocumentSavedEvent, type AstDocumentUpdatedEvent, type ServerSharedServices } from '@hydranium/core';
+import { type AbstractHydraniumGlspState } from '../state/abstract-hydranium-glsp-state.js';
+import { type HydraniumGlspSubmissionHandler } from '../submission/hydranium-glsp-submission-handler.js';
+import { SaveConflictPolicy } from './save-conflict-policy.js';
+/**
+ * GLSP source-model storage base shared by all hydranium adopters.
+ * Provides the DI signature, the {@link ClientSessionListener} +
+ * {@link Disposable} lifecycle plumbing (including the
+ * {@link DisposableCollection} drain on session disposal), the
+ * {@link RequestModelAction} / {@link SaveModelAction} URI-extraction
+ * helpers, and the live load/rebuild/resubmit flow with a settled-root
+ * invariant.
+ *
+ * **The settled-root invariant.** Every {@link AbstractHydraniumGlspState.setSourceRoot}
+ * the framework performs captures a root that has reached
+ * `IntegrityService.SettledState` (post-`Linked`, references indexed, on-build
+ * integrity rules applied). The GModel factory therefore always walks a fully
+ * linked + reprojected AST. The flow never captures off a transient mid-rebuild
+ * snapshot — notably it re-`settled()`s in the resubmit path rather than trusting
+ * the `onModelUpdated` event's document, which can arrive while a re-entered
+ * document is still being rebuilt.
+ *
+ * Adopters with richer needs override the seams ({@link isStructurallyBroken},
+ * {@link onParseErrorChanged}, {@link onSourceModelSettled}) rather than the
+ * whole flow, and select a {@link SaveConflictPolicy} via the bound option to
+ * tune how {@link saveSourceModel} reacts to a concurrent edit.
+ *
+ * **Default `saveSourceModel` flow.** Delegates to `ModelService.save`, which
+ * serialises through the language-specific `Serializer` bound at
+ * `services.serializer.Serializer` (resolved per-URI via `ServiceRegistry`),
+ * updates the multi-client text-document store, drives a rebuild, and writes the
+ * result via the `WritableFileSystemProvider`. The bound
+ * {@link SaveConflictPolicy} (default {@link DEFAULT_SAVE_CONFLICT_POLICY},
+ * `overwrite`) decides the based-on-version guard, await-vs-fire-and-forget, and
+ * failure handling.
+ *
+ * **tempId filter.** GLSP's `DefaultGlobalActionProvider` spins up a
+ * throwaway per-diagram-type container with upstream's {@link TEMPORARY_CLIENT_ID}
+ * placeholder purely to enumerate action kinds, then calls `unbindAll()`.
+ * The {@link postConstruct} hook skips registration for that placeholder so
+ * it doesn't linger in {@link ClientSessionManager}.
+ *
+ * **Lifecycle ordering.** `init` runs after DI resolution and parks the
+ * secondary-write-set watch, which outlives any single load.
+ * {@link sessionDisposed} calls {@link dispose}, which drains
+ * {@link toDispose} idempotently. Every transient subscription created in
+ * {@link doLoadSourceModel} is parked on {@link toDispose} so the drain catches
+ * them on client-detach.
+ */
+export declare class HydraniumGlspStorage<TRoot extends AstNode, TSourceModel = string> implements SourceModelStorage, ClientSessionListener, Disposable {
+    protected readonly logger: GlspLogger;
+    protected readonly sharedServices: ServerSharedServices;
+    protected readonly state: AbstractHydraniumGlspState<TRoot, TSourceModel>;
+    protected readonly sessionManager: ClientSessionManager;
+    protected readonly actionDispatcher: ActionDispatcher;
+    protected readonly submissionHandler: HydraniumGlspSubmissionHandler<TRoot, TSourceModel>;
+    protected readonly commandStack: DefaultCommandStack;
+    /**
+     * Optional {@link ModelValidator} whose markers are pushed to the client by
+     * {@link refreshDiagnosticMarkers}. Bound per diagram via
+     * `DiagramModule.bindModelValidator()`; absent (no push) when the head binds
+     * no validator. The framework default is `HydraniumGlspModelValidator`
+     * (LSP diagnostics → markers).
+     */
+    protected readonly modelValidator?: ModelValidator;
+    /**
+     * Selected {@link SaveConflictPolicy} for {@link saveSourceModel}. Bind the
+     * {@link SaveConflictPolicy} token in a `DiagramModule` to choose a policy;
+     * left unbound it resolves to {@link DEFAULT_SAVE_CONFLICT_POLICY}
+     * (`overwrite`, last-write-wins). Read via {@link saveConflictPolicy} so the
+     * fallback is applied even when inversify injects `undefined` for an unbound
+     * `@optional()` member.
+     */
+    protected readonly boundSaveConflictPolicy?: SaveConflictPolicy;
+    /** Disposables created during {@link doLoadSourceModel}; drained on session disposal. */
+    protected toDispose: DisposableCollection;
+    /**
+     * Live update subscriptions for the state's SECONDARY documents, keyed by URI.
+     * Reconciled by {@link reconcileSecondarySubscriptions} after every capture.
+     *
+     * Held apart from {@link toDispose} because this set is not fixed for the
+     * session: a document can leave the write set, and its subscription has to go
+     * with it rather than linger until the client detaches.
+     */
+    protected readonly secondarySubscriptions: Map<string, Disposable>;
+    /**
+     * Whether an external resubmit has ever been dispatched. Gates the
+     * keep-the-last-valid-GModel branch, which needs to know a canvas is already
+     * standing — not what is on it. The content comparison that decides whether a
+     * resubmit is worth dispatching lives on the submission handler, which is the
+     * only place that sees operation submits too.
+     */
+    protected hasSubmittedExternally: boolean;
+    /**
+     * Trailing-edge debounce for the external resubmit. Rescheduled on each
+     * {@link handleModelUpdated} so back-to-back rebuilds (cascade relinks,
+     * referenced-document edits) collapse into one {@link doUpdateAndSubmit}.
+     * Constructed in {@link init} (the injected {@link ServerSharedServices} —
+     * hence its `Clock` — is available by then); disposed on session teardown.
+     */
+    protected resubmitDebouncer: Debouncer;
+    /** Latest event document awaiting the debounced resubmit; read by {@link flushResubmit} (last write wins). */
+    protected pendingResubmitDocument?: AstDocument<AstNode, unknown>;
+    protected init(): void;
+    /**
+     * Default load flow — {@link doLoadSourceModel}. Adopters whose load flow
+     * needs more than the seams allow override this method.
+     */
+    loadSourceModel(action: RequestModelAction): MaybePromise<void>;
+    protected doLoadSourceModel(action: RequestModelAction): Promise<void>;
+    /**
+     * Capture the initial settled root and apply the initial edit mode. `settled()`
+     * strips diagnostics by phase contract, so the first edit mode is `EDITABLE`;
+     * the first {@link handleModelUpdated} (at `Validated`, with diagnostics) flips
+     * it READONLY if the document has structural parse errors. Edit-mode +
+     * settle-hook actions are dispatched on a macrotask so the initial
+     * `requestModel → setModel` handshake isn't perturbed.
+     */
+    protected captureSettledRoot(rootUri: string, document: AstDocument<AstNode, never>): Promise<void>;
+    /**
+     * Reconcile {@link secondarySubscriptions} against the state's current
+     * secondary write set: dispose what left it, subscribe what arrived. Driven by
+     * {@link AbstractHydraniumGlspState.onSecondaryUrisChanged}, so it runs when
+     * the set actually changes rather than at points a caller guessed it might.
+     *
+     * **Secondaries need a subscription of their own because nothing else
+     * notifies for them.** The state records a secondary's version for the
+     * write-side conflict gate and adopter GModel factories re-read secondary
+     * content on every build, but no rebuild of a secondary reaches the primary's
+     * subscription: Langium's affected-documents walk runs from the referenced
+     * document to the referencing one, so a document that references the primary
+     * is downstream of it and editing it correctly affects nothing upstream.
+     * Manufacturing that invalidation to obtain a notification would cost a real
+     * rebuild per edit and make the affected set mean two things — the missing
+     * piece is a subscription, not an invalidation.
+     */
+    protected reconcileSecondarySubscriptions(): void;
+    /**
+     * React to a rebuild of a SECONDARY document by resubmitting the diagram, so
+     * an external edit to (say) a layout file reaches the canvas.
+     *
+     * Reuses {@link handleModelUpdated}'s authorship guard, and that is the load-
+     * bearing half rather than the resubmit: a diagram interaction that writes a
+     * secondary — a drag persisting bounds to a layout file — comes back through
+     * this listener as the client's own `changed` edit, and resubmitting on it
+     * fights the optimistic client-side move the user is still holding.
+     *
+     * Schedules the PRIMARY's current document, never the secondary's.
+     * {@link doUpdateAndSubmit} reads its event document only for the edit-mode
+     * and structurally-broken decisions, both of which are statements about the
+     * document the canvas edits: passing the secondary's would let a typo in a
+     * layout file flip the canvas READONLY and take the keep-the-last-valid-GModel
+     * branch off an unrelated document's parse state. The pending-document field
+     * is shared with the primary path, so it would poison a concurrently
+     * scheduled primary resubmit too.
+     *
+     * No marker refresh, unlike the primary path: a secondary's diagnostics reach
+     * the client only if an adopter's index registers elements as rendering that
+     * document, and refreshing here unconditionally would add a dispatch to every
+     * drag this client authors — the guard above gates the resubmit, not the
+     * markers.
+     */
+    protected handleSecondaryUpdated(uri: string, event: AstDocumentUpdatedEvent<AstNode, unknown>): void;
+    /**
+     * The primary document's current state, or `undefined` when it is not
+     * registered.
+     *
+     * Synchronous by construction — the phase-agnostic lookup door plus the shared
+     * projection — so reacting to a secondary neither waits nor can force a build.
+     * `settled()` is not an alternative: it strips diagnostics by phase contract,
+     * and diagnostics are the reason {@link doUpdateAndSubmit} takes a separate
+     * event document at all.
+     */
+    protected currentPrimaryDocument(): AstDocument<AstNode, unknown> | undefined;
+    /**
+     * React to an external rebuild reaching `Validated`. Self-cleans if the
+     * session has vanished but this listener leaked (neither `sessionDisposed`
+     * nor `onClientClosed` fired on tab close). Resubmits for any change not
+     * authored by this client's own optimistic `changed` edit, then refreshes
+     * diagnostic markers for every update — including own edits, which skip
+     * the resubmit but can still change diagnostics.
+     */
+    protected handleModelUpdated(rootUri: string, event: AstDocumentUpdatedEvent<AstNode, unknown>): Promise<void>;
+    /**
+     * Whether this storage has outlived its session — disposing it as a side
+     * effect when so. Checked from every subscription entry point because GLSP's
+     * `sessionDisposed` is unreliable on Theia tab-close and `onClientClosed` can
+     * miss it as well; a listener that survives its session otherwise keeps firing
+     * for the life of the process. `context` names the document whose event
+     * surfaced the leak.
+     */
+    protected disposeIfStale(context: string): boolean;
+    /**
+     * Record the latest document and (re)arm the trailing-edge
+     * {@link resubmitDebouncer}, so a burst of rebuilds runs
+     * {@link doUpdateAndSubmit} once with the most recent document.
+     */
+    protected scheduleUpdateAndSubmit(document: AstDocument<AstNode, unknown>): void;
+    /**
+     * Debouncer callback: run the resubmit for the latest pending document
+     * against this storage's (invariant) source URI and dispatch the result.
+     * Fire-and-forget — failures are logged, not surfaced to the timer caller.
+     */
+    protected flushResubmit(): void;
+    /**
+     * Coordinate the command stack when another client persists the document:
+     * mark our stack clean so the editor doesn't prompt to re-save identical
+     * content. Our own saves already settle the stack through the save flow.
+     */
+    protected handleModelSaved(event: AstDocumentSavedEvent<AstNode, unknown>): void;
+    /**
+     * Re-settle to a guaranteed fully-linked + reprojected root, capture it, and
+     * (unless suppressed) resubmit a deduped external GModel. Diagnostics for the
+     * edit-mode decision come from the event document (`settled()` strips them by
+     * phase contract).
+     */
+    protected doUpdateAndSubmit(rootUri: string, eventDocument: AstDocument<AstNode, unknown>): Promise<Action[]>;
+    /**
+     * Recompute the desired edit mode from the document's structural-error state,
+     * flip {@link AbstractHydraniumGlspState.editMode}, and — only on a transition —
+     * return the {@link onParseErrorChanged} actions. No transition → no actions.
+     */
+    protected refreshEditMode(document: AstDocument<AstNode, unknown>): Action[];
+    /**
+     * Seam: is the AST structurally broken (lexing/parsing errors)? Drives both
+     * READONLY mode and the GModel resubmit skip — keeping the last valid canvas
+     * instead of blanking it mid-typing. Default: any error-severity diagnostic
+     * carrying a Langium `lexing-error` / `parsing-error` code. Adopters override
+     * to compose additional break reasons.
+     */
+    protected isStructurallyBroken(document: AstDocument<AstNode, unknown>): boolean;
+    /**
+     * Seam: actions to emit when the structural-broken state transitions. Default:
+     * a single {@link SetEditModeAction} toggling READONLY ↔ EDITABLE — editing is
+     * disabled while the syntax is broken but re-enabled once it parses, a sound
+     * generic for any Langium-backed diagram. Adopters override to add or replace
+     * the transition feedback. The {@link AbstractHydraniumGlspState.editMode}
+     * flip itself is owned by {@link refreshEditMode}.
+     */
+    protected onParseErrorChanged(_document: AstDocument<AstNode, unknown>, broken: boolean): Action[];
+    /**
+     * Seam: extra actions to dispatch right after the initial settled root is
+     * captured (e.g. an adopter-specific status or palette refresh). Default: none.
+     */
+    protected onSourceModelSettled(_document: AstDocument<AstNode, never>): Action[];
+    /** The effective {@link SaveConflictPolicy}: the bound option, or {@link DEFAULT_SAVE_CONFLICT_POLICY} when unbound. */
+    protected get saveConflictPolicy(): SaveConflictPolicy;
+    /**
+     * Default save flow: route through `ModelService.save`. The framework
+     * serialise-and-persist machinery handles serialisation (via the
+     * language-specific `Serializer` bound at `services.serializer.Serializer`),
+     * the multi-client text-document update, the rebuild, and the eventual
+     * `WritableFileSystemProvider.writeFile`.
+     *
+     * The configured {@link SaveConflictPolicy} (see {@link saveConflictPolicy})
+     * decides how a concurrent edit that advanced the document is handled:
+     * - `overwrite` (default): no based-on guard, await, propagate failures —
+     *   last-write-wins, correct for a single-editor head.
+     * - `reject`: guard on the captured `state.version`, await, surface a
+     *   `ConflictError` (and any other failure) to the GLSP save action.
+     * - `drop-and-log`: guard, fire-and-forget, log + swallow failures — a stale
+     *   diagram save is dropped because a concurrent form/code edit already wrote
+     *   the truth, and GLSP exposes no save-failure back-channel.
+     *
+     * Returns `MaybePromise<void>` to match upstream `SourceModelStorage`:
+     * resolves with the persist under `overwrite`/`reject`, returns synchronously
+     * under `drop-and-log`. Adopters that bypass `ModelService` (writing through
+     * `WritableFileSystemProvider` directly) still override the whole method.
+     */
+    saveSourceModel(action: SaveModelAction): MaybePromise<void>;
+    /**
+     * Normalise GLSP's `sourceUri` — which may be a filesystem PATH or a URI
+     * string — to the URI string the workspace keys documents by.
+     *
+     * **The protocol does not pin which form a client sends, and the clients in
+     * play disagree.** GLSP's VS Code integration sends `document.uri.toString()`;
+     * a headless caller passes the path it already has. Committing to either one
+     * alone is what this method exists to avoid.
+     *
+     * **Getting it wrong does not throw where the mistake is.** `URI.file` given
+     * a URI string treats the whole thing as a path, percent-encodes the scheme,
+     * and yields an `fsPath` with that scheme buried in the middle. Nothing
+     * rejects it; it travels down to the filesystem and surfaces as an ENOENT
+     * several layers from the coercion that produced it.
+     *
+     * Adopters whose client sends a third form override this.
+     */
+    protected toSourceModelUri(sourceUri: string): string;
+    /**
+     * Extract the source URI from a {@link RequestModelAction}. Throws
+     * {@link GLSPServerError} if the option is missing or non-string —
+     * GLSP's protocol contract requires the client to pass `sourceUri`
+     * when initiating a model request.
+     *
+     * Returns it VERBATIM, in whatever form the client sent;
+     * {@link toSourceModelUri} is what normalises it.
+     */
+    protected getSourceUri(action: RequestModelAction): string;
+    /**
+     * Resolve the URI to save to: prefer the {@link SaveModelAction.fileUri}
+     * (set when the user chose "Save As"), fall back to the
+     * {@link SOURCE_URI_ARG} mirrored into the inherited properties map by
+     * {@link AbstractHydraniumGlspState.setSourceRoot}.
+     *
+     * A save action carries no request id, so a throw here reaches the user as a
+     * toast built from `message`, with `cause` behind its details control. The
+     * two therefore address different readers and must not be collapsed: the
+     * message names what failed in the user's terms, and the cause names which
+     * lookups came back empty for whom. Neither can name the URI — not having
+     * one IS the failure, and both sources are written together, so the typed
+     * `sourceUri` is equally empty whenever this fires.
+     */
+    protected getFileUri(action: SaveModelAction): string;
+    /**
+     * Recompute the bound {@link ModelValidator}'s markers and push them to the
+     * client as a `SetMarkersAction` — asynchronously and independently of model
+     * rendering. Called from {@link handleModelUpdated} (which fires at `Validated`),
+     * so diagram markers refresh without gating the diagram submit on validation.
+     * No-op when no validator is bound.
+     *
+     * Always dispatched under {@link MarkersReason.BATCH}: the GLSP client's
+     * `ValidationFeedbackEmitter` keys feedback by reason and replaces the prior
+     * set, so re-pushing the full set clears stale markers (an empty set clears
+     * all once the model is valid), and sharing the tool-palette validate
+     * command's `BATCH` reason means the two paths replace rather than duplicate.
+     */
+    refreshDiagnosticMarkers(): Promise<void>;
+    sessionDisposed(_clientSession: ClientSession): void;
+    /**
+     * Cancel any pending resubmit and drain every subscription — those registered
+     * during {@link doLoadSourceModel} and the per-secondary ones, which live
+     * outside {@link toDispose} because they come and go with the write set.
+     * Idempotent.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=hydranium-glsp-storage.d.ts.map

package/lib/storage/hydranium-glsp-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydranium-glsp-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hydranium-glsp-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAGlF,OAAO,EACJ,KAAK,MAAM,EACX,gBAAgB,EAChB,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,oBAAoB,EAEpB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAGf,MAAM,IAAI,UAAU,EACpB,KAAK,YAAY,EAGjB,cAAc,EACd,KAAK,kBAAkB,EAEvB,KAAK,eAAe,EAEpB,KAAK,kBAAkB,EAEzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEtE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,WAAW,EAAE,KAAK,qBAAqB,EAAE,KAAK,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEnI,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,2CAA2C,CAAC;AAC5F,OAAO,EAAE,KAAK,8BAA8B,EAAE,MAAM,oDAAoD,CAAC;AAEzG,OAAO,EAAgC,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AA8B7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBACa,oBAAoB,CAAC,KAAK,SAAS,OAAO,EAAE,YAAY,GAAG,MAAM,CAC3E,YAAW,kBAAkB,EAAE,qBAAqB,EAAE,UAAU;IAE5C,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAG,UAAU,CAAC;IAChB,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAG,oBAAoB,CAAC;IAChF,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAG,0BAA0B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACjE,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAG,oBAAoB,CAAC;IAC7D,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAG,gBAAgB,CAAC;IACjD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAG,8BAA8B,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACrG,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAG,mBAAmB,CAAC;IAE5E;;;;;;OAMG;IACiC,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IAEvF;;;;;;;OAOG;IACqC,SAAS,CAAC,QAAQ,CAAC,uBAAuB,CAAC,EAAE,kBAAkB,CAAC;IAExG,yFAAyF;IACzF,SAAS,CAAC,SAAS,uBAA8B;IAEjD;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,CAAC,sBAAsB,0BAAiC;IAE1E;;;;;;OAMG;IACH,SAAS,CAAC,sBAAsB,UAAS;IAEzC;;;;;;OAMG;IACH,SAAS,CAAC,iBAAiB,EAAG,SAAS,CAAC;IAExC,8GAA8G;IAC9G,SAAS,CAAC,uBAAuB,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAGlE,SAAS,CAAC,IAAI,IAAI,IAAI;IAetB;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC;cAI/C,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B5E;;;;;;;OAOG;cACa,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUzG;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,+BAA+B,IAAI,IAAI;IAkBjD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CAAC,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAerG;;;;;;;;;OASG;IACH,SAAS,CAAC,sBAAsB,IAAI,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS;IAK7E;;;;;;;OAOG;cACa,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,uBAAuB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUpH;;;;;;;OAOG;IACH,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IASlD;;;;OAIG;IACH,SAAS,CAAC,uBAAuB,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAKhF;;;;OAIG;IACH,SAAS,CAAC,aAAa,IAAI,IAAI;IAY/B;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI;IAMhF;;;;;OAKG;cACa,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiCnH;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,EAAE;IAU5E;;;;;;OAMG;IACH,SAAS,CAAC,oBAAoB,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO;IAIhF;;;;;;;OAOG;IACH,SAAS,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM,EAAE;IAIlG;;;OAGG;IACH,SAAS,CAAC,oBAAoB,CAAC,SAAS,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE;IAIhF,wHAAwH;IACxH,SAAS,KAAK,kBAAkB,IAAI,kBAAkB,CAErD;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,CAAC,IAAI,CAAC;IA4B5D;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIrD;;;;;;;;OAQG;IACH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM;IAQ1D;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM;IAWrD;;;;;;;;;;;;OAYG;IACG,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ/C,eAAe,CAAC,cAAc,EAAE,aAAa,GAAG,IAAI;IAIpD;;;;;OAKG;IACH,OAAO,IAAI,IAAI;CAQjB"}