@mcp-b/char 0.0.6 → 0.1.0

package/dist/web-component.d.ts

@@ -1,250 +1,451 @@
 
-import { z } from "zod";
-
-//#region ../auth/dist/security/ticket.d.ts
+//#region src/types.d.ts
 /**
- * Client-side ticket auth data.
- * This is what the embedded widget uses for WebSocket authentication.
+ * Server-issued ticket auth payload.
+ * Used for SSR-friendly authentication flows.
+ *
+ * @public
  */
 interface TicketAuth {
-  /** The opaque ticket string */
+  /** Short-lived server-issued ticket used to start an authenticated session. */
   ticket: string;
-  /** User ID (from token's sub claim) - needed for DO routing */
+  /** End-user identifier associated with the issued ticket. */
   userId: string;
-  /** Organization ID - needed for DO routing */
+  /** Organization identifier used to scope the authenticated session. */
   orgId: string;
 }
-//#endregion
-//#region src/utils/dev-mode.d.ts
+/**
+ * Development-only embed controls used by local host integrations.
+ *
+ * @public
+ */
 interface DevModeConfig {
-  /**
-   * Your Anthropic API key for chat.
-   * Required for anonymous mode (no authToken).
-   */
   anthropicApiKey?: string;
-  /** Your OpenAI API key for voice mode (optional) */
   openaiApiKey?: string;
-  /** Use window.location.origin instead of production API (for internal development) */
   useLocalApi?: boolean;
 }
-//#endregion
-//#region src/web-component.d.ts
 /**
  * Connection options for the imperative connect() method.
- * Supports two authentication methods:
- * - `idToken`: Direct IDP token authentication (SPA-friendly)
+ *
+ * Supports two mutually exclusive authentication strategies:
+ * - `idToken` + `clientId`: Direct IDP token authentication (SPA-friendly)
  * - `ticketAuth`: Pre-fetched ticket authentication (SSR-friendly)
+ *
+ * Exactly one strategy must be provided. The discriminated union prevents
+ * combining `idToken` and `ticketAuth` at the type level.
+ *
+ * @public
  */
-interface ConnectOptions {
-  /**
-   * IDP token (ID token) for authentication.
-   * Token is stored as a JavaScript property (not as a DOM attribute),
-   * preventing exposure to DOM inspection and session replay tools.
-   *
-   * Either `idToken` or `ticketAuth` must be provided, but not both.
-   */
-  idToken?: string;
-  /**
-   * OIDC client ID for audience validation.
-   * Required when using `idToken` authentication.
-   *
-   * This must match the token's `aud` claim and be in the organization's
-   * `allowed_audiences` list (configured in the Char dashboard).
-   */
-  clientId?: string;
-  /**
-   * Pre-fetched ticket for SSR-friendly authentication.
-   * Use this when your server has already exchanged the IDP token for a ticket.
-   *
-   * Benefits:
-   * - IDP token never exposed to browser (in SSR mode)
-   * - No JWKS fetch on every connection (validation done once)
-   * - Ticket is short-lived (60s default) and single-use
-   *
-   * Either `idToken` or `ticketAuth` must be provided, but not both.
-   */
-  ticketAuth?: TicketAuth;
+type ConnectOptions = {
+  /** IDP token (ID token) for authentication. */idToken: string; /** OIDC client ID for audience validation. Required with `idToken`. */
+  clientId?: string; /** Optional organization context for multi-tenant same-origin dashboards. */
+  organizationId?: string; /** Must not be provided when using `idToken` authentication. */
+  ticketAuth?: never;
+} | {
+  /** Pre-fetched ticket for SSR-friendly authentication. */ticketAuth: TicketAuth; /** Must not be provided when using `ticketAuth` authentication. */
+  idToken?: never; /** Must not be provided when using `ticketAuth` authentication. */
+  clientId?: never; /** Must not be provided when using `ticketAuth` authentication. */
+  organizationId?: never;
+};
+/**
+ * Host visual theme hint.
+ *
+ * @public
+ */
+type CharTheme = 'light' | 'dark';
+/**
+ * Allowed display modes for the host shell and embedded runtime.
+ *
+ * @public
+ */
+type CharDisplayMode = 'inline' | 'fullscreen' | 'pip';
+/**
+ * Host platform hint for embedded UI adaptations.
+ *
+ * @public
+ */
+type CharPlatform = 'web' | 'desktop' | 'mobile';
+/**
+ * Host-provided style payload applied inside the iframe.
+ *
+ * @public
+ */
+interface CharHostStyles {
+  variables?: Record<string, string>;
+  fonts?: string;
+}
+/**
+ * Host container size constraints.
+ *
+ * @public
+ */
+interface CharContainerDimensions {
+  width?: number;
+  height?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+}
+/**
+ * Lightweight device capability hints from the host environment.
+ *
+ * @public
+ */
+interface CharDeviceCapabilities {
+  touch?: boolean;
+  hover?: boolean;
+  pointerFine?: boolean;
+}
+/**
+ * Safe-area inset values detected on the host.
+ *
+ * @public
+ */
+interface CharSafeAreaInsets {
+  top?: number;
+  right?: number;
+  bottom?: number;
+  left?: number;
+}
+/**
+ * Host shell capability flags advertised to the iframe runtime.
+ *
+ * @public
+ */
+interface CharHostCapabilities {
+  supportedDisplayModes?: CharDisplayMode[];
+  supportsOpenLink?: boolean;
+  supportsTeardown?: boolean;
+  maxContainerWidth?: number;
+}
+/**
+ * Host context payload sent from the embedding page to the iframe runtime.
+ *
+ * @public
+ */
+interface CharHostContext {
+  theme?: CharTheme;
+  styles?: CharHostStyles;
+  displayMode?: CharDisplayMode;
+  availableDisplayModes?: CharDisplayMode[];
+  containerDimensions?: CharContainerDimensions;
+  locale?: string;
+  timeZone?: string;
+  platform?: CharPlatform;
+  deviceCapabilities?: CharDeviceCapabilities;
+  safeAreaInsets?: CharSafeAreaInsets;
+  userAgent?: string;
+  hostCapabilities?: CharHostCapabilities;
+}
+/**
+ * Payload for the `char-size-changed` event.
+ *
+ * @public
+ */
+interface CharSizeChangedDetail {
+  width?: number;
+  height?: number;
+  displayMode?: CharDisplayMode;
 }
 /**
- * Base Web Component from r2wc
+ * Payload for the `char-request-display-mode` event.
  *
- * Converts EmbeddedAgent to a  custom element.
- * Attributes map to props in kebab-case (e.g., dev-mode -> devMode).
- * Note: Auth props (authToken, ticketAuth) are internal only - use connect() method.
+ * @public
  */
-declare const BaseCharElement: CustomElementConstructor;
+interface CharRequestDisplayModeDetail {
+  mode?: CharDisplayMode;
+}
 /**
- * Extended Web Component with secure connect() method
+ * Payload for the `char-error` event.
  *
- * The connect() method allows passing the auth token imperatively without
- * exposing it as a DOM attribute. This prevents token leakage via:
- * - Session replay tools (e.g., FullStory, LogRocket)
- * - Error monitoring (e.g., Sentry, DataDog)
- * - DOM snapshots and inspection
- * - Browser extensions
+ * @public
+ */
+interface CharErrorDetail {
+  code: string;
+  message?: string;
+}
+/**
+ * Payload for the `char-open-link` event.
  *
- * @example
- * ```ts
- * const agent = document.querySelector('char-agent')
- * agent.connect({ idToken: 'eyJhbGciOi...' })
- * ```
+ * @public
  */
-declare class CharAgentElement extends BaseCharElement {
+interface CharOpenLinkDetail {
+  requestId: string;
+  url: string;
+  ok: boolean;
+}
+//#endregion
+//#region src/web-component.d.ts
+/**
+ * `<char-agent>` custom element.
+ *
+ * Creates an iframe pointing to the SaaS app's /embed/ entrypoint and relays
+ * auth, styles, dark mode, display mode, and MCP messages via postMessage.
+ *
+ * Uses a unified `char-context` message with diffing (only changed fields
+ * are sent) instead of separate messages per concern.
+ *
+ * @public
+ */
+declare class CharAgentElement extends HTMLElement {
+  static observedAttributes: string[];
+  /**
+   * React 19-friendly property form of `dev-mode`.
+   * Read once during `connectedCallback`.
+   */
+  devMode?: DevModeConfig;
+  /**
+   * React 19-friendly property form of `api-base`.
+   * Read once during `connectedCallback`.
+   */
+  apiBase?: string;
+  /** Active iframe element owned by this custom element instance. */
+  private _iframe;
+  /** MCP relay between host window and embed iframe. */
+  private _proxy;
+  /** Indicates whether the iframe has emitted `char-ready`. */
+  private _iframeReady;
+  /** Bound window message handler for iframe-originated events. */
+  private _messageListener;
+  /** Observer that tracks host theme mutations. */
+  private _darkModeObserver;
+  /** Media query object for `prefers-color-scheme`. */
+  private _darkModeMediaQuery;
+  /** Registered media query callback. */
+  private _darkModeMediaHandler;
+  /** Observer that tracks host style/class mutations. */
+  private _styleObserver;
+  /** Observer that tracks container size changes. */
+  private _containerResizeObserver;
+  /** In-flight teardown request waiting for iframe acknowledgement. */
+  private _teardownPending;
+  /** Monotonic sequence used to construct teardown request IDs. */
+  private _teardownSequence;
+  /** Re-entrancy guard used during disconnect lifecycle. */
+  private _isDisconnecting;
+  /** Last host context snapshot used for delta emission. */
+  private _hostContext;
+  /** Pending credentials that are flushed when the iframe is ready. */
+  private _pendingAuth;
+  /**
+   * Mount lifecycle: builds iframe runtime, starts proxying, and starts host observers.
+   * The existing runtime is reused when reconnecting during fast detach/reattach cycles.
+   */
+  connectedCallback(): void;
+  /**
+   * Determines whether this instance already has an initialized runtime.
+   */
+  private _hasActiveRuntime;
+  /**
+   * Parses and validates the iframe origin from the configured API base URL.
+   *
+   * @throws Error When `apiBase` is not a valid URL.
+   */
+  private _resolveIframeOrigin;
+  /**
+   * Creates a fully configured iframe element for the embed runtime.
+   */
+  private _createIframe;
+  /**
+   * Creates the message listener that filters by source/origin and dispatches typed events.
+   */
+  private _createMessageListener;
+  /**
+   * Routes validated iframe messages to local handlers and host DOM events.
+   */
+  private _handleIframeMessage;
+  /**
+   * Emits a host-facing custom event without detail payload.
+   */
+  private _emitCharEvent;
+  /**
+   * Emits a host-facing custom event with detail payload.
+   */
+  private _emitCharEventWithDetail;
+  /**
+   * Emits a standardized `char-error` event.
+   */
+  private _emitCharError;
+  /**
+   * Unmount lifecycle: requests iframe teardown and releases all host resources.
+   */
+  disconnectedCallback(): void;
+  /**
+   * Releases iframe, observers, listeners, and pending teardown state.
+   */
+  private _finalizeDisconnect;
+  /**
+   * Reacts to observed attribute updates after iframe readiness.
+   * Attributes that affect iframe boot configuration are intentionally ignored
+   * after mount (`dev-mode`, `enable-debug-tools`, `api-base`).
+   */
+  attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
   /**
    * Connect to the Char agent with authentication.
    *
    * The token is stored as a JavaScript property (not as a DOM attribute),
    * preventing exposure to DOM inspection and session replay tools.
-   * This is the recommended way to authenticate.
-   *
-   * @param options.idToken - IDP token (ID token) for authentication
-   * @param options.clientId - OIDC client ID (required when using idToken)
-   * @param options.ticketAuth - Pre-fetched ticket (alternative to idToken)
-   * @returns true if connection was initiated, false if validation failed
    *
-   * @example
-   * ```ts
-   * // Vanilla JS
-   * const agent = document.querySelector('char-agent')
-   * const success = agent.connect({
-   *   idToken: session.idToken,
-   *   clientId: 'your-oidc-client-id'
-   * })
-   *
-   * // React with ref
-   * const agentRef = useRef(null)
-   * useEffect(() => {
-   *   agentRef.current?.connect({
-   *     idToken: session.idToken,
-   *     clientId: 'your-oidc-client-id'
-   *   })
-   * }, [session.idToken])
-   * ```
+   * @param options - Authentication payload for either ID token or ticket auth.
+   * @returns `true` when the payload is accepted; `false` when validation fails.
    */
   connect(options: ConnectOptions): boolean;
+  /**
+   * Convenience method for declarative wrappers.
+   * Applies auth when provided, otherwise clears auth.
+   *
+   * @param options - Auth payload to connect, or `null` to disconnect.
+   * @returns Result from `connect()` or `disconnect()`.
+   */
+  setAuth(options: ConnectOptions | null): boolean;
   /**
    * Disconnect from the Char agent.
    * Clears the authentication token.
-   * @returns true if disconnection succeeded, false if an error occurred
+   *
+   * @returns `true` when the disconnect message was sent; `false` when the iframe was not ready.
    */
   disconnect(): boolean;
   /**
-   * Override disconnectedCallback to defer React unmount.
+   * Resolves the current iframe origin when mounted.
+   */
+  private _getIframeOrigin;
+  /**
+   * Update the host context sent to the iframe.
+   * Only changed fields are transmitted (diffing pattern).
    *
-   * The base r2wc class calls root.unmount() synchronously, which can cause
-   * "Attempted to synchronously unmount a root while React was already rendering"
-   * if the element is removed while React is processing an error boundary.
+   * @param hostContext - Partial host context patch to merge and emit.
+   */
+  setHostContext(hostContext: CharHostContext): void;
+  /**
+   * Build and send the full initial context after iframe signals char-ready.
    *
-   * By deferring to queueMicrotask, we allow React to finish its current render
-   * before unmounting, preventing the race condition.
+   * @param iframeOrigin - Trusted origin used for postMessage target filtering.
    */
-  disconnectedCallback(): void;
+  private _sendInitialContext;
+  /**
+   * Send a context delta to the iframe.
+   *
+   * @param changes - Minimal context patch derived from diffing.
+   */
+  private _sendContextDelta;
+  /**
+   * Post authentication credentials to the iframe.
+   *
+   * @param iframeOrigin - Trusted origin used for postMessage target filtering.
+   */
+  private _postAuth;
+  /**
+   * Requests graceful iframe teardown and resolves once acknowledged or timed out.
+   *
+   * @param iframeOrigin - Trusted origin used for postMessage target filtering.
+   * @param reason - Lifecycle reason for teardown.
+   * @returns Promise resolved when teardown flow completes.
+   */
+  private _requestTeardown;
+  /**
+   * Completes an in-flight teardown promise when the iframe acknowledges it.
+   *
+   * @param requestId - Optional request identifier to match against pending teardown.
+   */
+  private _resolvePendingTeardown;
+  /**
+   * Handles open-link requests from the iframe with protocol allowlisting.
+   * This allowlist intentionally mirrors the iframe-side pre-filter.
+   *
+   * @param requestId - Link request identifier supplied by the iframe.
+   * @param url - Requested URL string.
+   * @param iframeOrigin - Trusted origin used for postMessage target filtering.
+   */
+  private _handleOpenLinkRequest;
+  /**
+   * Observe dark mode changes and forward to iframe via unified context.
+   */
+  private _observeDarkMode;
+  /**
+   * Observe style attribute changes on <char-agent> to detect CSS variable updates.
+   * Re-extracts variables and sends delta via unified context.
+   */
+  private _observeStyleChanges;
+  /**
+   * Observe host element dimensions to provide containerDimensions context.
+   */
+  private _observeContainerDimensions;
+  /**
+   * Resolve devMode from property (React 19) or attribute.
+   *
+   * @returns Parsed dev-mode configuration when valid.
+   */
+  private _resolveDevMode;
+  /**
+   * Resolve apiBase override from property (React 19) or attribute.
+   *
+   * @returns Sanitized API base URL without trailing slash.
+   */
+  private _resolveApiBaseOverride;
 }
 /**
  * Type declaration for the Char custom element.
  * Useful for TypeScript consumers using refs.
+ *
+ * @public
  */
 /**
- * Register the <char-agent> custom element
+ * Legacy alias for `CharAgentElement`.
  *
- * Called automatically when importing this module.
- * Styles are injected into the shadow root by ShadowRoot component.
+ * @public
  */
-declare function registerChar(tagName?: string): void;
+type CharElement = CharAgentElement;
 /**
- * Augment HTMLElementTagNameMap so document.querySelector('char-agent')
- * returns CharAgentElement automatically without manual type casting.
+ * Backward-compatible alias for `CharAgentElement`.
  *
- * @example
- * ```ts
- * // Without this augmentation:
- * const agent = document.querySelector('char-agent') as CharAgentElement;
+ * @public
+ */
+type WebMCPAgentElement = CharAgentElement;
+/**
+ * Register the <char-agent> custom element.
+ * Called automatically when importing this module.
  *
- * // With this augmentation:
- * const agent = document.querySelector('char-agent');
- * // ^? CharAgentElement | null (automatically typed!)
- * ```
+ * @param tagName - Optional custom tag name override.
+ *
+ * @public
  */
+declare function registerChar(tagName?: string): void;
 declare global {
   interface HTMLElementTagNameMap {
     'char-agent': CharAgentElement;
   }
+  namespace JSX {
+    interface IntrinsicElements {
+      'char-agent': {
+        /** Development mode configuration (JSON string for HTML attributes). */'dev-mode'?: string; /** Property form of dev mode config. */
+        devMode?: DevModeConfig; /** Explicit API base override, e.g. `https://staging-app.usechar.ai`. */
+        'api-base'?: string; /** Property form of API base override. */
+        apiBase?: string; /** Enable debug tools for inspecting embedded agent internal state. */
+        'enable-debug-tools'?: boolean; /** Display mode for host orchestration: `pip` is collapsed launcher mode. */
+        'display-mode'?: CharDisplayMode; /** Callback when the close button inside the agent panel is clicked. */
+        onClose?: () => void; /** Imperative ref to the custom element instance. */
+        ref?: unknown;
+        [key: string]: unknown;
+      };
+    }
+  }
 }
-declare module 'react' {
+declare module 'react/jsx-runtime' {
   namespace JSX {
     interface IntrinsicElements {
-      'char-agent': React.DetailedHTMLProps<React.HTMLAttributes<CharAgentElement> & {
-        /**
-         * Controlled open state.
-         * When provided, the host controls whether the agent UI is open or collapsed.
-         */
-        open?: boolean;
-        /**
-         * Development mode configuration (JSON string for HTML attributes).
-         *
-         * @example React 18 (JSON string attribute)
-         * ```tsx
-         * <char-agent
-         *   dev-mode={JSON.stringify({
-         *     anthropicApiKey: import.meta.env.VITE_ANTHROPIC_API_KEY
-         *   })}
-         * />
-         * ```
-         */
+      'char-agent': {
         'dev-mode'?: string;
-        /**
-         * React 19 only: Pass devMode as an object property directly.
-         * React 19 automatically sets object properties on custom elements.
-         *
-         * @example
-         * ```tsx
-         * <char-agent devMode={{ anthropicApiKey: 'sk-...' }} />
-         * ```
-         */
         devMode?: DevModeConfig;
-        /**
-         * Enable debug tools for inspecting embedded agent internal state.
-         * @default false
-         */
+        'api-base'?: string;
+        apiBase?: string;
         'enable-debug-tools'?: boolean;
-        /**
-         * Callback when the close button inside the agent panel is clicked.
-         *
-         * NOTE: r2wc does not support function callbacks as attributes.
-         * Instead, listen for the 'char-close' custom event:
-         *
-         * @example
-         * ```tsx
-         * const [isOpen, setIsOpen] = useState(true);
-         *
-         * useEffect(() => {
-         *   const handleClose = () => setIsOpen(false);
-         *   document.addEventListener('char-close', handleClose);
-         *   return () => document.removeEventListener('char-close', handleClose);
-         * }, []);
-         *
-         * return <char-agent open={isOpen} />;
-         * ```
-         */
+        'display-mode'?: CharDisplayMode;
         onClose?: () => void;
-        /**
-         * React ref for accessing the web component's imperative API.
-         * Use this to call connect() method securely.
-         *
-         * @example
-         * ```tsx
-         * const agentRef = useRef<CharAgentElement>(null);
-         * useEffect(() => {
-         *   agentRef.current?.connect({ idToken: session.idToken });
-         * }, [session.idToken]);
-         * return <char-agent ref={agentRef} />;
-         * ```
-         */
-        ref?: React.Ref<CharAgentElement>;
-      }, CharAgentElement>;
+        ref?: unknown;
+        [key: string]: unknown;
+      };
     }
   }
 } //# sourceMappingURL=web-component.d.ts.map
 //#endregion
-export { type CharAgentElement, ConnectOptions, type DevModeConfig, type TicketAuth, registerChar };
+export { type CharAgentElement, type CharContainerDimensions, type CharDeviceCapabilities, type CharDisplayMode, CharElement, type CharErrorDetail, type CharHostCapabilities, type CharHostContext, type CharHostStyles, type CharOpenLinkDetail, type CharPlatform, type CharRequestDisplayModeDetail, type CharSafeAreaInsets, type CharSizeChangedDetail, type CharTheme, type ConnectOptions, type DevModeConfig, type TicketAuth, WebMCPAgentElement, registerChar };
 //# sourceMappingURL=web-component.d.ts.map

package/dist/web-component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-component.d.ts","names":["TicketMetadata","ticket","userId","orgId","createdAt","expiresAt","origin","used","GenerateTicketOptions","ttlSeconds","byteLength","TICKET_DEFAULTS","TTL_SECONDS","MIN_TTL_SECONDS","MAX_TTL_SECONDS","BYTE_LENGTH","MIN_BYTE_LENGTH","TICKET_ERROR_CODE","NOT_FOUND","EXPIRED","ALREADY_USED","ORIGIN_MISMATCH","STORE_FAILED","TicketErrorCode","TicketAuth","TicketExchangeResponse","expiresIn","TicketExchangeError","error","message","generateOpaqueTicket","options","createTicketMetadata","params","isTicketExpired","clockSkewMs","validateTicketOrigin","ticketOrigin","requestOrigin","valid","errorMessage"],"sources":["../../auth/dist/security/ticket.d.ts","../src/utils/dev-mode.ts","../src/web-component.tsx"],"mappings":";;;;;;;;UA6EiBwB,UAAAA;EEgfb;EF9eAvB,MAAAA;EEmaoC;EFjapCC,MAAAA;EE+ZO;EF7ZPC,KAAAA;AAAAA;;;UCnFa,aAAA;;;AD6EjB;;ECxEC,eAAA;EDwE0B;ECtE1B,YAAA;ED0EGD;ECxEH,WAAA;AAAA;;;;;;ACwcA;;;UAtYgB,cAAA;EA6ZT;;;;;;;EArZP,OAAA;EAuZ+B;;;;;;;EA9Y/B,QAAA;EAsZgB;;;;;;;;;;;EAzYhB,UAAA,GAAa,UAAA;AAAA;;;;;;;;cA8KR,eAAA,EAAe,wBAAA;;;;;;;;;;;;;;;;;cAsCf,gBAAA,SAAyB,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC9B,OAAA,CAAQ,OAAA,EAAS,cAAA;;;;;;EA6DjB,UAAA,CAAA;;;;;;;;;;;EAuBA,oBAAA,CAAA;AAAA;;;;;;;;;;;iBA0Be,YAAA,CAAa,OAAA;;;;;;;;;;;;;;;QA6BrB,MAAA;EAAA,UACG,qBAAA;IACT,YAAA,EAAc,gBAAA;EAAA;AAAA;AAAA;EAAA,UAML,GAAA;IAAA,UACC,iBAAA;MACT,YAAA,EAAc,KAAA,CAAM,iBAAA,CACnB,KAAA,CAAM,cAAA,CAAe,gBAAA;;;;;QAKpB,IAAA;;;;;;;;;;;;;QAcA,UAAA;;;;;;;;;;QAWA,OAAA,GAAU,aAAA;;;;;QAMV,oBAAA;;;;;;;;;;;;;;;;;;;;QAqBA,OAAA;;;;;;;;;;;;;;QAeA,GAAA,GAAM,KAAA,CAAM,GAAA,CAAI,gBAAA;MAAA,GAEjB,gBAAA;IAAA;EAAA;AAAA"}
+{"version":3,"file":"web-component.d.ts","names":[],"sources":["../src/types.ts","../src/web-component.tsx"],"mappings":";;;AAMA;;;;;UAAiB,UAAA;EAMhB;EAJA,MAAA;EAIK;EAFL,MAAA;EAU6B;EAR7B,KAAA;AAAA;;;;;;UAQgB,aAAA;EAChB,eAAA;EACA,YAAA;EACA,WAAA;AAAA;;;;;;;;;;;AA0CD;;KA3BY,cAAA;EA2BS,+CAxBlB,OAAA,UA+BS;EA7BT,QAAA;EAEA,cAAA,WA2BwB;EAzBxB,UAAA;AAAA;4DAIA,UAAA,EAAY,UAAA,EA4BS;EA1BrB,OAAA,UAiC4B;EA/B5B,QAAA,UAgCgB;EA9BhB,cAAA;AAAA;;;;AAuCH;;KA/BY,SAAA;;;;;;KAOA,eAAA;;AAoCZ;;;;KA7BY,YAAA;;;;;AAwCZ;UAjCiB,cAAA;EAChB,SAAA,GAAY,MAAA;EACZ,KAAA;AAAA;;;;;;UAQgB,uBAAA;EAChB,KAAA;EACA,MAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;;;UAQgB,sBAAA;EAChB,KAAA;EACA,KAAA;EACA,WAAA;AAAA;;;;;;UAQgB,kBAAA;EAChB,GAAA;EACA,KAAA;EACA,MAAA;EACA,IAAA;AAAA;;;;;;UAQgB,oBAAA;EAChB,qBAAA,GAAwB,eAAA;EACxB,gBAAA;EACA,gBAAA;EACA,iBAAA;AAAA;;;;;;UAQgB,eAAA;EAChB,KAAA,GAAQ,SAAA;EACR,MAAA,GAAS,cAAA;EACT,WAAA,GAAc,eAAA;EACd,qBAAA,GAAwB,eAAA;EACxB,mBAAA,GAAsB,uBAAA;EACtB,MAAA;EACA,QAAA;EACA,QAAA,GAAW,YAAA;EACX,kBAAA,GAAqB,sBAAA;EACrB,cAAA,GAAiB,kBAAA;EACjB,SAAA;EACA,gBAAA,GAAmB,oBAAA;AAAA;;AAmBpB;;;;UAXiB,qBAAA;EAChB,KAAA;EACA,MAAA;EACA,WAAA,GAAc,eAAA;AAAA;;AA2Bf;;;;UAnBiB,4BAAA;EAChB,IAAA,GAAO,eAAA;AAAA;;;;;;UAQS,eAAA;EAChB,IAAA;EACA,OAAA;AAAA;;;;;;UAQgB,kBAAA;EAChB,SAAA;EACA,GAAA;EACA,EAAA;AAAA;;;;;;AA5HD;;;;;AAOA;;;cCkNM,gBAAA,SAAyB,WAAA;EAAA,OACvB,kBAAA;ED5MS;;;;ECuNR,OAAA,GAAU,aAAA;EDtNN;;;;EC4NJ,OAAA;EDnN+B;EAAA,QCsN/B,OAAA;EDtN+B;EAAA,QCwN/B,MAAA;EDtNR;EAAA,QCwNQ,YAAA;EDtNR;EAAA,QCwNQ,gBAAA;EDxNC;EAAA,QC0ND,iBAAA;EDlN8B;EAAA,QCoN9B,mBAAA;EDpN8B;EAAA,QCsN9B,qBAAA;EDpNR;EAAA,QCsNQ,cAAA;EDrNG;EAAA,QCuNH,wBAAA;ED/MQ;EAAA,QCiNR,gBAAA;;UAIA,iBAAA;EDpNR;EAAA,QCsNQ,gBAAA;EDpNR;EAAA,QCuNQ,YAAA;EDtNJ;EAAA,QCyNI,YAAA;EDjNQ;;;;EC4NhB,iBAAA,CAAA;ED3NwB;;;EAAA,QCsQhB,iBAAA;EDnQS;;AAQlB;;;EARkB,QC4QT,oBAAA;EDlQC;;;EAAA,QC6QD,aAAA;EDvQG;;;EAAA,QCoRH,sBAAA;EDhR+B;;;EAAA,QCiS/B,oBAAA;ED3SR;;;EAAA,QC8WQ,cAAA;ED5WR;;;EAAA,QCmXQ,wBAAA;EDjXR;;;EAAA,QCwXQ,cAAA;EDrXR;;;EC6XA,oBAAA,CAAA;ED3XA;;;EAAA,QCuZQ,mBAAA;EDtZ+B;AAQxC;;;;ECocC,wBAAA,CAAyB,IAAA,UAAc,SAAA,iBAA0B,QAAA;EDlcjE;;;;;AASD;;;;ECkdC,OAAA,CAAQ,OAAA,EAAS,cAAA;EDzcD;;;;;AAUjB;;ECseC,OAAA,CAAQ,OAAA,EAAS,cAAA;EDteiB;;;;;;ECmflC,UAAA,CAAA;;;AAriBe;UAqjBP,gBAAA;;;;;;;EAgBR,cAAA,CAAe,WAAA,EAAa,eAAA;EAnba;;;;;EAAA,QA4cjC,mBAAA;EAvbA;;;;;EAAA,QAwfA,iBAAA;EA5eA;;;;;EAAA,QA8fA,SAAA;EA/eA;;;;;;;EAAA,QAqgBA,gBAAA;EAvVA;;;;;EAAA,QAwYA,uBAAA;EAhSiB;;;;;;;;EAAA,QAgTjB,sBAAA;EAnOR;;;EAAA,QAiRQ,gBAAA;EAjPO;;;;EAAA,QAyQP,oBAAA;EAtFA;;;EAAA,QAoGA,2BAAA;EAAA;;;;;EAAA,QAqBA,eAAA;EA2Dc;;;;AAOvB;EAPuB,QAvBd,uBAAA;AAAA;;;AAwCT;;;;AAMC;;;;;AAAA,KAvBW,WAAA,GAAc,gBAAA;;;;;;KAOd,kBAAA,GAAqB,gBAAA;;;;;;;;;iBAUjB,YAAA,CAAa,OAAA;AAAA,QAUrB,MAAA;EAAA,UACG,qBAAA;IACT,YAAA,EAAc,gBAAA;EAAA;EAAA,UAIL,GAAA;IAAA,UACC,iBAAA;MACT,YAAA;QAiBa,wEAfZ,UAAA,WAeY;QAbZ,OAAA,GAAU,aAAA,EA6BsB;QA3BhC,UAAA,WAoBQ;QAlBR,OAAA,WAoBA;QAlBA,oBAAA,YAmBU;QAjBV,cAAA,GAAiB,eAAA,EAmBjB;QAjBA,OAAA,eAmBA;QAjBA,GAAA;QAAA,CACC,GAAA;MAAA;IAAA;EAAA;AAAA;AAAA;EAAA,UAQM,GAAA;IAAA,UACC,iBAAA;MACT,YAAA;QACC,UAAA;QACA,OAAA,GAAU,aAAA;QACV,UAAA;QACA,OAAA;QACA,oBAAA;QACA,cAAA,GAAiB,eAAA;QACjB,OAAA;QACA,GAAA;QAAA,CACC,GAAA;MAAA;IAAA;EAAA;AAAA"}