@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/thinking-panel/thinking-panel.js

@@ -1,235 +1,5 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { html, nothing } from 'lit';
-import { property } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './thinking-panel.class.js';
+import { LyraThinkingPanel } from './thinking-panel.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { nextId } from '../../internal/a11y.js';
-import { chevronIcon } from '../../internal/icons.js';
-import { styles } from './thinking-panel.styles.js';
-/** "Close enough to the body's own max scroll position to count as anchored
- *  there" -- comfortably larger than one line of streamed text, so a user
- *  who has barely nudged the scrollbar while reading the latest line isn't
- *  mistaken for having deliberately scrolled away to read earlier content. */
-const NEAR_BOTTOM_PX = 48;
-/** `820` -> `"820ms"`; `1500` -> `"1.5s"`; `2000` -> `"2s"`. Identical
- *  algorithm to lyra-tool-call-chip's and lyra-tool-result-dialog's own
- *  `formatDuration` -- duplicated rather than imported (three independent,
- *  separately-consumable components) but kept in lockstep so the same
- *  elapsed time reads identically everywhere it's shown in this library. */
-function formatDuration(ms) {
-    if (!Number.isFinite(ms) || ms < 1000) {
-        return `${Math.round(Math.max(0, ms))}ms`;
-    }
-    const seconds = ms / 1000;
-    const rounded = Math.round(seconds * 10) / 10;
-    return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1)}s`;
-}
-/**
- * `<lyra-thinking-panel>` — a collapsible panel for an AI agent's
- * intermediate reasoning/"thinking" transcript, kept visually and
- * semantically distinct from its final response. Same collapsible
- * header-button-plus-region shape as `<lyra-source-list>`; the default slot
- * is entirely free-form (a consumer-composed `<lyra-streaming-text>`,
- * `<lyra-markdown>`, or plain text) — this component has no dependency on
- * either and imposes no structure on what's slotted.
- *
- * `mode` (`'live'` while reasoning is actively streaming in, `'post-hoc'`
- * once it's complete and being reviewed after the fact) drives two concrete
- * behavior differences, not just a styling hook:
- * - **Header hint.** While `duration-ms` is unset, `'live'` shows a pulsing
- *   "Thinking…" placeholder in `[part="duration"]`; `'post-hoc'` shows
- *   nothing there instead (a finished review with no known duration has
- *   nothing useful to say in that slot). Once `duration-ms` is set, both
- *   modes show the same static `"Thought for …"` text — a `'post-hoc'`
- *   consumer that captured a duration is free to supply it too.
- * - **Auto-scroll.** Only `'live'` mode auto-follows new content appended to
- *   the default slot while `expanded` (see below); `'post-hoc'` never
- *   scrolls on its own, since reviewing finished reasoning is expected to
- *   start from the top like reading any other completed document. This
- *   library otherwise defaults to *not* editorializing about a host's data
- *   (see `<lyra-empty>`'s plain-`description` stance), but scroll position
- *   is presentation, not data, so this one behavior difference earns its
- *   keep rather than being left as a bare visual/semantic hint the host
- *   would have to reimplement identically itself.
- *
- * Live-mode auto-scroll ("stick to bottom") is the classic chat-transcript
- * convention: while `mode="live"` and `expanded`, new content keeps the
- * panel scrolled to its latest line — *unless* the user has manually
- * scrolled up to (re-)read earlier content, in which case their position is
- * never yanked away from them. This is tracked continuously via a `scroll`
- * listener on `[part="body"]` (not recomputed from the mutation itself,
- * which necessarily observes the DOM only *after* it has already changed):
- * every user-driven scroll records whether the body was left within
- * `NEAR_BOTTOM_PX` of its own max scroll position, and only a mutation that
- * arrives while that's still true triggers a follow-up scroll-to-bottom.
- * Opening an already-`'live'` panel (or one that later becomes `'live'`)
- * always resets this to "anchored" and jumps to the latest content, the same
- * way a chat app's own transcript does when you re-open it.
- *
- * New content is detected via a `MutationObserver` on this element's own
- * light DOM (`childList`+`subtree`+`characterData`) rather than the default
- * slot's `slotchange` event, because `slotchange` only fires when the set of
- * top-level assigned nodes changes — never for a text node mutating *inside*
- * an already-slotted element, which is the more likely shape for streamed
- * reasoning (a consumer appending chunks to an existing node's `textContent`
- * rather than re-slotting a whole new element per token). The one thing this
- * can't see is a mutation entirely inside a slotted custom element's own
- * shadow root (e.g. a `<lyra-markdown>` re-rendering its shadow tree after a
- * `content` property change) — Shadow DOM encapsulation blocks that by
- * design, and there is no way for this component to reach across that
- * boundary. A slotted element whose *own* internal updates should drive this
- * panel's auto-scroll needs to append/mutate visible light-DOM text itself
- * (as `<lyra-streaming-text>` is expected to), or the host can call this
- * panel's own `scrollToBottom()` directly.
- *
- * `aria-controls` linking the header to the body region uses `nextId()`
- * (`../../internal/a11y.js`) for a collision-safe id, the same convention
- * `<lyra-source-list>` and `<lyra-widget>` already establish for every
- * toggle-controls-region pairing in this library.
- *
- * @customElement lyra-thinking-panel
- * @slot - The reasoning/thinking content.
- * @event lyra-toggle - The header was activated, expanding or collapsing the
- * panel. `detail: { expanded }` — same event name and shape as
- * `<lyra-source-list>`'s own `lyra-toggle`.
- * @csspart base - The outer container.
- * @csspart header - The clickable header (`<button>`) toggling `expanded`.
- * @csspart label - The `label` text.
- * @csspart duration - The formatted duration / "Thinking…" placeholder, when shown.
- * @csspart toggle - The chevron indicator inside the header.
- * @csspart body - The wrapper around the default slot, `hidden` while collapsed.
- */
-export class LyraThinkingPanel extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** Header text. */
-        this.label = 'Thinking';
-        /** Whether the reasoning transcript is currently shown. Starts collapsed,
-         *  matching `<lyra-source-list>`'s default -- a consumer running `'live'`
-         *  reasoning sets this `true` itself to stream it in view as it arrives. */
-        this.expanded = false;
-        /** `'live'` while reasoning is actively streaming in right now; `'post-hoc'`
-         *  once it's complete and being reviewed after the fact. See the class doc
-         *  for the concrete behavior differences this drives. */
-        this.mode = 'live';
-        this.bodyId = nextId('thinking-panel-body');
-        // Whether the body was left within NEAR_BOTTOM_PX of its own max scroll
-        // position the last time a real (user-driven) scroll was recorded -- see
-        // onScroll(). Starts `true` so a panel that mounts already `expanded` and
-        // `mode="live"` follows its very first streamed content by default,
-        // before any scroll event has ever fired.
-        this.stickToBottom = true;
-        this.onScroll = (e) => {
-            const body = e.currentTarget;
-            this.stickToBottom = body.scrollHeight - body.scrollTop - body.clientHeight <= NEAR_BOTTOM_PX;
-        };
-        this.onContentMutated = () => {
-            if (this.mode !== 'live' || !this.expanded || !this.stickToBottom)
-                return;
-            // Coalesce to at most one scroll-to-bottom per animation frame -- a fast
-            // token stream can otherwise fire many mutation records in quick
-            // succession, each individually cheap to react to but wasteful (and
-            // visually janky) to lay out for separately.
-            if (this.scrollRafId !== undefined)
-                return;
-            this.scrollRafId = requestAnimationFrame(() => {
-                this.scrollRafId = undefined;
-                this.scrollToBottom();
-            });
-        };
-        this.toggle = () => {
-            this.expanded = !this.expanded;
-            this.emit('lyra-toggle', { expanded: this.expanded });
-        };
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    connectedCallback() {
-        super.connectedCallback();
-        // Watches this element's own light-DOM subtree, not the shadow-DOM
-        // [part="body"] wrapper -- the slotted reasoning content actually lives
-        // here, as this element's children. See the class doc for why this
-        // (rather than `slotchange`) is what detects streamed-in content.
-        this.contentObserver = new MutationObserver(this.onContentMutated);
-        this.contentObserver.observe(this, { childList: true, subtree: true, characterData: true });
-    }
-    disconnectedCallback() {
-        super.disconnectedCallback();
-        this.contentObserver?.disconnect();
-        this.contentObserver = undefined;
-        if (this.scrollRafId !== undefined) {
-            cancelAnimationFrame(this.scrollRafId);
-            this.scrollRafId = undefined;
-        }
-    }
-    updated(changed) {
-        if (changed.has('expanded') && this.expanded && this.mode === 'live') {
-            // Opening a live panel always jumps straight to the newest content and
-            // resets the sticky-bottom flag, so it starts following again
-            // regardless of wherever the body happened to be scrolled the last
-            // time it was collapsed. `'post-hoc'` deliberately skips this -- see
-            // the class doc's Auto-scroll section.
-            this.stickToBottom = true;
-            this.scrollToBottom();
-        }
-    }
-    /** Scrolls the body to its current bottom immediately (no smooth-scroll
-     *  animation, deliberately -- see onContentMutated()'s rAF-coalescing
-     *  comment for why an instant jump reads better than a stack of competing
-     *  smooth scrolls under a fast token stream). Safe to call directly, e.g.
-     *  from a host that wants to force a jump-to-latest action of its own. */
-    scrollToBottom() {
-        const body = this.renderRoot.querySelector('[part="body"]');
-        if (!body)
-            return;
-        body.scrollTop = body.scrollHeight;
-    }
-    get durationDisplay() {
-        if (this.durationMs != null && Number.isFinite(this.durationMs)) {
-            return { text: `Thought for ${formatDuration(this.durationMs)}`, pending: false };
-        }
-        return this.mode === 'live' ? { text: 'Thinking…', pending: true } : null;
-    }
-    render() {
-        const duration = this.durationDisplay;
-        return html `
-      <div part="base">
-        <button
-          part="header"
-          type="button"
-          aria-expanded=${this.expanded ? 'true' : 'false'}
-          aria-controls=${this.bodyId}
-          @click=${this.toggle}
-        >
-          <span part="toggle" aria-hidden="true">${chevronIcon()}</span>
-          <span part="label">${this.label}</span>
-          ${duration
-            ? html `<span part="duration" ?data-pending=${duration.pending}
-                >${duration.pending ? html `<span class="pending-dot" aria-hidden="true"></span>` : nothing}${duration.text}</span
-              >`
-            : nothing}
-        </button>
-        <div part="body" id=${this.bodyId} ?hidden=${!this.expanded} @scroll=${this.onScroll}>
-          <slot></slot>
-        </div>
-      </div>
-    `;
-    }
-}
-__decorate([
-    property()
-], LyraThinkingPanel.prototype, "label", void 0);
-__decorate([
-    property({ type: Boolean, reflect: true })
-], LyraThinkingPanel.prototype, "expanded", void 0);
-__decorate([
-    property({ reflect: true })
-], LyraThinkingPanel.prototype, "mode", void 0);
-__decorate([
-    property({ type: Number, attribute: 'duration-ms' })
-], LyraThinkingPanel.prototype, "durationMs", void 0);
 defineElement('thinking-panel', LyraThinkingPanel);
+//# sourceMappingURL=thinking-panel.js.map

package/dist/components/thinking-panel/thinking-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.js","sourceRoot":"","sources":["../../../src/components/thinking-panel/thinking-panel.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC"}

package/dist/components/thinking-panel/thinking-panel.styles.d.ts

@@ -1 +1,2 @@
 export declare const styles: import("lit").CSSResult;
+//# sourceMappingURL=thinking-panel.styles.d.ts.map

package/dist/components/thinking-panel/thinking-panel.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.styles.d.ts","sourceRoot":"","sources":["../../../src/components/thinking-panel/thinking-panel.styles.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,MAAM,yBAqHlB,CAAC"}

package/dist/components/thinking-panel/thinking-panel.styles.js

@@ -10,10 +10,10 @@ export const styles = css `
        before it scrolls internally, e.g. via ::part(body) or by overriding
        this custom property directly -- not exposed as a component prop
        since it's a pure layout knob, not something a template branches on. */
-    --lyra-thinking-panel-max-block-size: 16rem;
+    --lyra-thinking-panel-max-block-size: var(--lyra-size-16rem);
   }
   [part='base'] {
-    border: 1px solid var(--lyra-color-border);
+    border: var(--lyra-border-width-thin) solid var(--lyra-color-border);
     border-radius: var(--lyra-radius);
     background: var(--lyra-color-surface);
     overflow: hidden;
@@ -28,8 +28,8 @@ export const styles = css `
     background: none;
     color: var(--lyra-color-text);
     font: inherit;
-    font-weight: 600;
-    font-size: 0.875rem;
+    font-weight: var(--lyra-font-weight-semibold);
+    font-size: var(--lyra-font-size-md-sm);
     text-align: start;
     cursor: pointer;
   }
@@ -59,10 +59,10 @@ export const styles = css `
   [part='duration'] {
     display: inline-flex;
     align-items: center;
-    gap: 0.35em;
+    gap: var(--lyra-size-0-35em);
     flex: 0 0 auto;
-    font-weight: 400;
-    font-size: 0.8125rem;
+    font-weight: var(--lyra-font-weight-normal);
+    font-size: var(--lyra-font-size-sm);
     color: var(--lyra-color-text-quiet);
   }
   /* Actively streaming with no duration yet -- a full-opacity brand-colored
@@ -75,8 +75,8 @@ export const styles = css `
     color: var(--lyra-color-brand);
   }
   .pending-dot {
-    inline-size: 0.375rem;
-    block-size: 0.375rem;
+    inline-size: var(--lyra-size-0-375rem);
+    block-size: var(--lyra-size-0-375rem);
     border-radius: 50%;
     background: currentColor;
     animation: lyra-thinking-panel-pulse var(--lyra-transition-base) infinite;
@@ -95,11 +95,17 @@ export const styles = css `
   [part='body'] {
     max-block-size: var(--lyra-thinking-panel-max-block-size);
     overflow-y: auto;
+    /* Reaching this region's own top/bottom edge stops there instead of
+       chaining the scroll into the host page -- this is precisely the
+       component that tracks and respects the reader scrolling within it, so
+       it shouldn't hand that scroll off to the page underneath it. Same
+       convention as virtual-list.styles.ts's own auto-scrolling region. */
+    overscroll-behavior: contain;
     padding: var(--lyra-space-m);
-    border-block-start: 1px solid var(--lyra-color-border);
+    border-block-start: var(--lyra-border-width-thin) solid var(--lyra-color-border);
     color: var(--lyra-color-text-quiet);
-    font-size: 0.875rem;
-    line-height: 1.5;
+    font-size: var(--lyra-font-size-md-sm);
+    line-height: var(--lyra-line-height-normal);
   }
   [part='body'][hidden] {
     display: none;
@@ -115,3 +121,4 @@ export const styles = css `
     }
   }
 `;
+//# sourceMappingURL=thinking-panel.styles.js.map

package/dist/components/thinking-panel/thinking-panel.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-panel.styles.js","sourceRoot":"","sources":["../../../src/components/thinking-panel/thinking-panel.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,2EAA2E;AAC3E,8EAA8E;AAC9E,uEAAuE;AACvE,2EAA2E;AAC3E,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHxB,CAAC"}

package/dist/components/time-range/time-range.class.d.ts

@@ -0,0 +1,137 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+/** A single discrete-preset option for the `presets` property. */
+export interface TimeRangePreset {
+    label: string;
+    start: number;
+    end: number;
+}
+/**
+ * `<lyra-time-range>` — a two-handle brush/scrubber over a numeric domain.
+ * Callers map their own time axis to `[min, max]`; no date logic lives here
+ * (matches the no-date-library constraint used elsewhere in this library).
+ *
+ * Optionally paired with a row of discrete presets (`presets`) — e.g. "Last
+ * 7 days" / "Last 30 days" — rendered above the track; picking one is just a
+ * shortcut that sets both handles at once, the continuous brush underneath
+ * is unaffected and both interaction modes coexist.
+ *
+ * Form-associated (via a directly-attached `ElementInternals`, mirroring
+ * `<lyra-combobox>`'s minimal pattern rather than the single-string-value
+ * `FormAssociated` mixin, which doesn't fit a two-handle range): an ancestor
+ * `<fieldset disabled>` disables both handles and every preset button
+ * through `effectiveDisabled`, the same way it would a native `<input>`,
+ * without touching the consumer-facing `disabled` property/attribute itself.
+ *
+ * @customElement lyra-time-range
+ * @event lyra-input - Fired continuously while dragging or on each arrow-key press. `detail: { start, end }`.
+ * @event lyra-change - Fired on release / keyup-commit, or when a preset button is clicked. `detail: { start, end }`.
+ * @csspart base - The time-range wrapper.
+ * @csspart track - The complete range track.
+ * @csspart range - The selected range.
+ * @csspart handle-start - The start handle.
+ * @csspart handle-end - The end handle.
+ * @csspart presets - The preset controls wrapper.
+ * @csspart preset-button - A preset button.
+ */
+export interface LyraTimeRangeEventMap {
+    'lyra-input': CustomEvent<{
+        start: number;
+        end: number;
+    }>;
+    'lyra-change': CustomEvent<{
+        start: number;
+        end: number;
+    }>;
+}
+export declare class LyraTimeRange extends LyraElement<LyraTimeRangeEventMap> {
+    static formAssociated: boolean;
+    static styles: import("lit").CSSResultGroup[];
+    static properties: {
+        disabled: {
+            type: BooleanConstructor;
+            reflect: boolean;
+            noAccessor: boolean;
+        };
+    };
+    min: number;
+    max: number;
+    start: number;
+    end: number;
+    step: number;
+    /** Accessible name for the start handle, used as its `aria-label`.
+     *  Overridable for i18n/custom copy; defaults to the same literal text
+     *  this component always rendered before the property existed. */
+    startLabel: string;
+    /** Accessible name for the end handle, used as its `aria-label`.
+     *  Overridable for i18n/custom copy; defaults to the same literal text
+     *  this component always rendered before the property existed. */
+    endLabel: string;
+    /**
+     * Optional discrete presets rendered as a `[part="presets"]` button row
+     * above the track. Purely additive: leaving this empty (the default)
+     * renders nothing extra and leaves the continuous brush untouched.
+     */
+    presets: TimeRangePreset[];
+    private internals;
+    private _disabled;
+    private _fieldsetDisabled;
+    private drags;
+    constructor();
+    get disabled(): boolean;
+    set disabled(next: boolean);
+    /** Effective disabled state: this element's own `disabled` OR an ancestor
+     *  `<fieldset disabled>`'s inherited state -- mirrors native `<input>`,
+     *  whose own `disabled` IDL property/attribute is never mutated by a
+     *  fieldset. */
+    get effectiveDisabled(): boolean;
+    /**
+     * Called by the browser when an ancestor `<fieldset disabled>` toggles.
+     * Tracked separately from the consumer's own `disabled` (see
+     * `effectiveDisabled`) so a consumer's explicit `disabled` survives the
+     * fieldset re-enabling instead of being permanently overwritten.
+     */
+    formDisabledCallback(disabled: boolean): void;
+    disconnectedCallback(): void;
+    private domain;
+    private percentOf;
+    /** Each handle's actual reachable sub-range, bounded by its sibling
+     *  handle's current value the same way clamp() already enforces it — used
+     *  both for aria-valuemin/aria-valuemax and for Home/End's jump targets,
+     *  instead of reporting/jumping to the component's full [min, max] domain
+     *  which the sibling handle may make partially unreachable. */
+    private reachableBounds;
+    private clamp;
+    private setValue;
+    /**
+     * Apply a discrete preset: sets both handles and emits the same
+     * lyra-input/lyra-change pair a committed drag or keyboard step would.
+     *
+     * Deliberately bypasses `setValue()`/`clamp()` — a preset is an explicit
+     * discrete jump to the caller's own exact numbers, not a stepped nudge, so
+     * routing it through `clamp()`'s step-grid rounding would silently round
+     * a preset's values away from what the caller specified (and desync the
+     * active-button match in render(), which compares against these exact
+     * numbers). Only the domain bounds and the start<=end invariant apply
+     * here, not `step`. Both handles are also assigned before either event
+     * fires — routing them through two sequential `setValue()` calls instead
+     * would emit an extra lyra-input whose detail still held the stale
+     * pre-preset value for whichever handle hadn't been assigned yet.
+     */
+    private applyPreset;
+    private onKeyDown;
+    private onKeyUp;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    /** Stop the drag owned by `pointerId`, optionally committing a final lyra-change. */
+    private endDrag;
+    protected willUpdate(changed: PropertyValues): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-time-range': LyraTimeRange;
+    }
+}
+//# sourceMappingURL=time-range.class.d.ts.map

package/dist/components/time-range/time-range.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-range.class.d.ts","sourceRoot":"","sources":["../../../src/components/time-range/time-range.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAE9E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AA0C7D,kEAAkE;AAClE,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1D,aAAa,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5D;AACD,qBAAa,aAAc,SAAQ,WAAW,CAAC,qBAAqB,CAAC;IACnE,MAAM,CAAC,cAAc,UAAQ;IAC7B,MAAM,CAAC,MAAM,iCAAgC;IAE7C,MAAM,CAAC,UAAU;QAgBf,QAAQ;YAAI,IAAI;YAAW,OAAO;YAAQ,UAAU;;MACpD;IAE0B,GAAG,SAAK;IACR,GAAG,SAAO;IACV,KAAK,SAAK;IACV,GAAG,SAAO;IACV,IAAI,SAAK;IACrC;;sEAEkE;IAC1B,UAAU,SAAiB;IACnE;;sEAEkE;IAC5B,QAAQ,SAAe;IAC7D;;;;OAIG;IAC6B,OAAO,EAAE,eAAe,EAAE,CAAM;IAEhE,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,SAAS,CAAS;IAK1B,OAAO,CAAC,iBAAiB,CAAS;IAMlC,OAAO,CAAC,KAAK,CAAgC;IAE7C,cAGC;IAED,IAAI,QAAQ,IAAI,OAAO,CAEtB;IACD,IAAI,QAAQ,CAAC,IAAI,EAAE,OAAO,EAKzB;IAED;;;oBAGgB;IAChB,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED;;;;;OAKG;IACH,oBAAoB,CAAC,QAAQ,EAAE,OAAO,GAAG,IAAI,CAG5C;IAED,oBAAoB,IAAI,IAAI,CAW3B;IAOD,OAAO,CAAC,MAAM;IAYd,OAAO,CAAC,SAAS;IAWjB;;;;mEAI+D;IAC/D,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,KAAK;IA2Bb,OAAO,CAAC,QAAQ;IAQhB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,SAAS,CAmCf;IAEF,OAAO,CAAC,OAAO,CAMb;IAEF,OAAO,CAAC,aAAa,CAenB;IAEF,OAAO,CAAC,aAAa,CAwBnB;IAEF,OAAO,CAAC,WAAW,CAEjB;IAEF,qFAAqF;IACrF,OAAO,CAAC,OAAO;IAef,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAoClD;IAED,MAAM,IAAI,cAAc,CA+DvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,aAAa,CAAC;KAClC;CACF"}