@v-tilt/browser 1.1.5 → 1.2.0

package/dist/entrypoints/array.d.ts

@@ -1 +1,2 @@
+import "./external-scripts-loader";
 import "./array.no-external";

package/dist/entrypoints/external-scripts-loader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * External Scripts Loader
+ *
+ * Dynamically loads external scripts (like rrweb) from CDN.
+ * Based on PostHog's implementation.
+ */
+import type { VTilt } from "../vtilt";
+import { VTiltExtensionKind } from "../utils/globals";
+/**
+ * Load a script dynamically
+ */
+declare const loadScript: (vtilt: VTilt, url: string, callback: (error?: string | Event, event?: Event) => void) => void;
+/**
+ * Get the URL for an extension script
+ *
+ * Priority:
+ * 1. script_host config (if set) - loads from {script_host}/dist/{kind}.js
+ * 2. Default to unpkg CDN for npm package
+ *
+ * Note: script_host should be the base URL (e.g., "https://cdn.example.com")
+ * The /dist/ path is automatically appended to match the npm package structure
+ */
+declare const getExtensionUrl: (vtilt: VTilt, kind: VTiltExtensionKind) => string;
+export { loadScript, getExtensionUrl };

package/dist/entrypoints/module.es.d.ts

@@ -1,3 +1,4 @@
+import "./external-scripts-loader";
 import vt from "./module.no-external.es";
 export * from "./module.no-external.es";
 export default vt;

package/dist/entrypoints/recorder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Recorder Entrypoint
+ *
+ * This file is built as a separate bundle (recorder.js) that can be
+ * lazy-loaded when session recording is enabled.
+ *
+ * It exports:
+ * - rrweb.record: The rrweb record function
+ * - rrwebPlugins: Plugins for console recording
+ * - initSessionRecording: Factory function to create LazyLoadedSessionRecording
+ */
+import { record as rrwebRecord } from "@rrweb/record";
+import { LazyLoadedSessionRecordingInterface } from "../utils/globals";
+import type { SessionRecordingConfig } from "../extensions/replay/types";
+import type { VTilt } from "../vtilt";
+/**
+ * Factory function to create a LazyLoadedSessionRecording instance
+ *
+ * Called by SessionRecordingWrapper after the recorder script is loaded
+ */
+declare function initSessionRecording(instance: VTilt, config?: SessionRecordingConfig): LazyLoadedSessionRecordingInterface;
+export { initSessionRecording };
+export default rrwebRecord;

package/dist/extensions/replay/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session Recording Extension
+ *
+ * Exports for rrweb session recording functionality.
+ *
+ * Architecture:
+ * - SessionRecordingWrapper: Lightweight wrapper in main bundle, handles lazy loading
+ * - LazyLoadedSessionRecording: Actual recording logic, loaded on demand via recorder.js
+ */
+export { SessionRecordingWrapper, LAZY_LOADING, type SessionRecordingStatus, type LazyLoadedSessionRecordingInterface, } from "./session-recording-wrapper";
+export { LazyLoadedSessionRecording } from "./session-recording";
+export type { SessionRecordingConfig, SessionStartReason, RecordOptions, RRWebRecord, SnapshotBuffer, CanvasRecordingConfig, NetworkPayloadCaptureConfig, MaskingConfig, TriggerType, } from "./types";
+export { compressEvent, estimateSize, truncateLargeConsoleLogs, splitBuffer, isSessionIdleEvent, isRecordingPausedEvent, isInteractiveEvent, RECORDING_MAX_EVENT_SIZE, RECORDING_BUFFER_TIMEOUT, RECORDING_IDLE_THRESHOLD_MS, } from "./session-recording-utils";

package/dist/extensions/replay/session-recording-utils.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Session Recording Utilities
+ *
+ * Utility functions for session recording.
+ * Based on PostHog's sessionrecording-utils.ts
+ */
+import { EventType, IncrementalSource, eventWithTime } from "@rrweb/types";
+import type { SnapshotBuffer } from "./types";
+export declare const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3;
+export declare const ONE_KB = 1024;
+export declare const ONE_MB: number;
+export declare const SEVEN_MB: number;
+export declare const PARTIAL_COMPRESSION_THRESHOLD = 1024;
+export declare const RECORDING_MAX_EVENT_SIZE: number;
+export declare const RECORDING_BUFFER_TIMEOUT = 2000;
+export declare const RECORDING_IDLE_THRESHOLD_MS: number;
+/** Active interaction sources */
+export declare const ACTIVE_SOURCES: IncrementalSource[];
+/**
+ * Gzip compress data to a base64 string
+ */
+export declare function gzipToString(data: unknown): string;
+/**
+ * Estimate the size of an object in bytes
+ */
+export declare function estimateSize(obj: unknown): number;
+export interface CompressedFullSnapshotEvent {
+    type: typeof EventType.FullSnapshot;
+    data: string;
+}
+export interface CompressedIncrementalSnapshotEvent {
+    type: typeof EventType.IncrementalSnapshot;
+    data: {
+        source: IncrementalSource;
+        texts: string;
+        attributes: string;
+        removes: string;
+        adds: string;
+    };
+}
+export interface CompressedIncrementalStyleSnapshotEvent {
+    type: typeof EventType.IncrementalSnapshot;
+    data: {
+        source: typeof IncrementalSource.StyleSheetRule;
+        id?: number;
+        styleId?: number;
+        replace?: string;
+        replaceSync?: string;
+        adds?: string;
+        removes?: string;
+    };
+}
+export type CompressedEvent = CompressedFullSnapshotEvent | CompressedIncrementalSnapshotEvent | CompressedIncrementalStyleSnapshotEvent;
+export type CompressedEventWithTime = CompressedEvent & {
+    timestamp: number;
+    delay?: number;
+    cv: "2024-10";
+};
+/**
+ * Compress an rrweb event for transmission
+ * Only compresses full snapshots and mutation events above threshold
+ */
+export declare function compressEvent(event: eventWithTime): eventWithTime | CompressedEventWithTime;
+/**
+ * Truncate large console log payloads to prevent excessive data
+ */
+export declare function truncateLargeConsoleLogs(event: eventWithTime): eventWithTime;
+/**
+ * Split a large buffer into smaller chunks for transmission
+ */
+export declare function splitBuffer(buffer: SnapshotBuffer, sizeLimit?: number): SnapshotBuffer[];
+/**
+ * Check if an event is a session idle custom event
+ */
+export declare function isSessionIdleEvent(event: eventWithTime): event is eventWithTime & {
+    data: {
+        tag: string;
+        payload: unknown;
+    };
+};
+/**
+ * Check if an event is a recording paused custom event
+ */
+export declare function isRecordingPausedEvent(event: eventWithTime): boolean;
+/**
+ * Check if an event represents user interaction
+ */
+export declare function isInteractiveEvent(event: eventWithTime): boolean;
+/**
+ * Clamp a value to a range with logging
+ */
+export declare function clampToRange(value: number, min: number, max: number, label: string, defaultValue: number): number;

package/dist/extensions/replay/session-recording-wrapper.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Session Recording Wrapper
+ *
+ * Lightweight wrapper that handles the decision of WHEN to load recording.
+ * The actual recording logic is in LazyLoadedSessionRecording which is
+ * loaded on demand.
+ *
+ * Based on PostHog's sessionrecording-wrapper.ts
+ */
+import type { VTilt } from "../../vtilt";
+import type { SessionRecordingConfig, SessionStartReason } from "./types";
+import { LazyLoadedSessionRecordingInterface } from "../../utils/globals";
+/** Status when lazy loading is in progress */
+export declare const LAZY_LOADING: "lazy_loading";
+/** Session recording status */
+export type SessionRecordingStatus = "disabled" | "buffering" | "active" | "paused" | "sampled" | "trigger_pending" | typeof LAZY_LOADING;
+export type { LazyLoadedSessionRecordingInterface };
+/**
+ * Session Recording Wrapper
+ *
+ * This is the lightweight class that lives in the main bundle.
+ * It handles:
+ * - Deciding if recording should be enabled
+ * - Lazy loading the actual recording code
+ * - Delegating to LazyLoadedSessionRecording
+ */
+export declare class SessionRecordingWrapper {
+    private readonly _instance;
+    private _lazyLoadedRecording;
+    private _config;
+    constructor(_instance: VTilt, config?: SessionRecordingConfig);
+    get started(): boolean;
+    get status(): SessionRecordingStatus;
+    get sessionId(): string;
+    /**
+     * Start recording if enabled, otherwise stop
+     */
+    startIfEnabledOrStop(startReason?: SessionStartReason): void;
+    /**
+     * Stop recording
+     */
+    stopRecording(): void;
+    /**
+     * Log a message to the recording
+     */
+    log(message: string, level?: "log" | "warn" | "error"): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<SessionRecordingConfig>): void;
+    private get _isRecordingEnabled();
+    private get _scriptName();
+    /**
+     * Lazy load the recording script and start
+     */
+    private _lazyLoadAndStart;
+    /**
+     * Called after the recording script is loaded
+     */
+    private _onScriptLoaded;
+}

package/dist/extensions/replay/session-recording.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Lazy Loaded Session Recording
+ *
+ * The actual rrweb session recording implementation.
+ * This is loaded on demand when recording is enabled.
+ *
+ * Based on PostHog's lazy-loaded-session-recorder.ts
+ */
+import { type eventWithTime } from "@rrweb/types";
+import type { VTilt } from "../../vtilt";
+import { LazyLoadedSessionRecordingInterface } from "../../utils/globals";
+import type { SessionRecordingConfig, SessionRecordingStatus } from "./types";
+export declare const SESSION_RECORDING_BATCH_KEY = "recordings";
+export declare class LazyLoadedSessionRecording implements LazyLoadedSessionRecordingInterface {
+    private _instance;
+    private _endpoint;
+    private _flushBufferTimer?;
+    private _fullSnapshotTimer?;
+    private _captureStarted;
+    private _stopRrweb?;
+    private _isIdle;
+    private _lastActivityTimestamp;
+    private _lastHref?;
+    private _sessionId;
+    private _windowId;
+    private _buffer;
+    private _queuedRRWebEvents;
+    private _config;
+    constructor(instance: VTilt, config?: SessionRecordingConfig);
+    get isStarted(): boolean;
+    /** @deprecated Use isStarted instead */
+    get started(): boolean;
+    get sessionId(): string;
+    get status(): SessionRecordingStatus;
+    /**
+     * Start session recording (interface method)
+     */
+    start(startReason?: string): void;
+    /**
+     * Stop session recording (interface method)
+     */
+    stop(): void;
+    /** @deprecated Use stop() instead */
+    stopRecording(): void;
+    /**
+     * Add a custom event to the recording
+     */
+    addCustomEvent(tag: string, payload: unknown): boolean;
+    /**
+     * Take a full snapshot
+     */
+    takeFullSnapshot(): boolean;
+    /**
+     * Log a message to the recording
+     */
+    log(message: string, level?: "log" | "warn" | "error"): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<SessionRecordingConfig>): void;
+    private _onBeforeUnload;
+    private _onOffline;
+    private _onOnline;
+    private _onVisibilityChange;
+    private _isRecordingEnabled;
+    private _startCapture;
+    private _loadRecorder;
+    private _onScriptLoaded;
+    private _gatherRRWebPlugins;
+    onRRwebEmit(rawEvent: eventWithTime): void;
+    private _processQueuedEvents;
+    private _updateWindowAndSessionIds;
+    private _clearBuffer;
+    private _flushBuffer;
+    private _captureSnapshotBuffered;
+    private _captureSnapshot;
+    private _sendSnapshot;
+    /**
+     * Fetch with exponential backoff retry (PostHog-style)
+     * Retries on network errors and 5xx server errors
+     */
+    private _fetchWithRetry;
+    /**
+     * Schedule a retry with exponential backoff and jitter
+     */
+    private _scheduleRetry;
+    private _scheduleFullSnapshot;
+    private _tryRRWebMethod;
+    private _tryAddCustomEvent;
+    private _tryTakeFullSnapshot;
+    private _getCanvasConfig;
+    private _getMaskingConfig;
+    private _generateId;
+    private _reportStarted;
+}

package/dist/extensions/replay/types.d.ts

@@ -0,0 +1,211 @@
+/**
+ * Session Recording Types
+ *
+ * Type definitions for rrweb session recording.
+ * Based on PostHog's implementation.
+ */
+import type { blockClass, eventWithTime, hooksParam, KeepIframeSrcFn, maskTextClass, PackFn, RecordPlugin, SamplingStrategy } from "@rrweb/types";
+/** Mask options for input elements */
+export type MaskInputOptions = Partial<{
+    color: boolean;
+    date: boolean;
+    "datetime-local": boolean;
+    email: boolean;
+    month: boolean;
+    number: boolean;
+    range: boolean;
+    search: boolean;
+    tel: boolean;
+    text: boolean;
+    time: boolean;
+    url: boolean;
+    week: boolean;
+    textarea: boolean;
+    select: boolean;
+    password: boolean;
+}>;
+/** Function to mask input values */
+export type MaskInputFn = (text: string, element: HTMLElement) => string;
+/** Function to mask text content */
+export type MaskTextFn = (text: string, element: HTMLElement | null) => string;
+/** Options for slim DOM mode */
+export type SlimDOMOptions = Partial<{
+    script: boolean;
+    comment: boolean;
+    headFavicon: boolean;
+    headWhitespace: boolean;
+    headMetaDescKeywords: boolean;
+    headMetaSocial: boolean;
+    headMetaRobots: boolean;
+    headMetaHttpEquiv: boolean;
+    headMetaAuthorship: boolean;
+    headMetaVerification: boolean;
+    headTitleMutations: boolean;
+}>;
+/** Options for data URL generation */
+export type DataURLOptions = Partial<{
+    type: string;
+    quality: number;
+}>;
+/** Error handler type */
+export type ErrorHandler = (error: unknown) => void | boolean;
+/** rrweb record options */
+export interface RecordOptions {
+    emit?: (e: eventWithTime, isCheckout?: boolean) => void;
+    checkoutEveryNth?: number;
+    checkoutEveryNms?: number;
+    blockClass?: blockClass;
+    blockSelector?: string;
+    ignoreClass?: string;
+    ignoreSelector?: string;
+    maskTextClass?: maskTextClass;
+    maskTextSelector?: string;
+    maskAllInputs?: boolean;
+    maskInputOptions?: MaskInputOptions;
+    maskInputFn?: MaskInputFn;
+    maskTextFn?: MaskTextFn;
+    slimDOMOptions?: SlimDOMOptions | "all" | true;
+    ignoreCSSAttributes?: Set<string>;
+    inlineStylesheet?: boolean;
+    hooks?: hooksParam;
+    packFn?: PackFn;
+    sampling?: SamplingStrategy;
+    dataURLOptions?: DataURLOptions;
+    recordDOM?: boolean;
+    recordCanvas?: boolean;
+    recordCrossOriginIframes?: boolean;
+    recordAfter?: "DOMContentLoaded" | "load";
+    userTriggeredOnInput?: boolean;
+    collectFonts?: boolean;
+    inlineImages?: boolean;
+    plugins?: RecordPlugin[];
+    mousemoveWait?: number;
+    keepIframeSrcFn?: KeepIframeSrcFn;
+    errorHandler?: ErrorHandler;
+}
+/** rrweb record function type */
+export interface RRWebRecord {
+    (options: RecordOptions): () => void;
+    addCustomEvent: (tag: string, payload: unknown) => void;
+    takeFullSnapshot: () => void;
+    mirror: {
+        getId(n: Node | undefined | null): number;
+        getNode(id: number): Node | null;
+    };
+}
+/** Canvas recording configuration */
+export interface CanvasRecordingConfig {
+    enabled: boolean;
+    fps: number;
+    quality: number;
+}
+/** Network payload capture configuration */
+export interface NetworkPayloadCaptureConfig {
+    recordHeaders?: boolean;
+    recordBody?: boolean;
+    recordPerformance?: boolean;
+}
+/** Masking configuration */
+export interface MaskingConfig {
+    maskAllInputs?: boolean;
+    maskTextSelector?: string;
+    blockSelector?: string;
+}
+/** Session recording configuration */
+export interface SessionRecordingConfig {
+    /** Enable session recording */
+    enabled?: boolean;
+    /** Sample rate (0-1, where 1 = 100%) */
+    sampleRate?: number;
+    /** Minimum session duration in ms before sending */
+    minimumDurationMs?: number;
+    /** Session idle threshold in ms */
+    sessionIdleThresholdMs?: number;
+    /** Full snapshot interval in ms */
+    fullSnapshotIntervalMs?: number;
+    /** Enable console log capture */
+    captureConsole?: boolean;
+    /** Enable network request capture */
+    captureNetwork?: boolean;
+    /** Canvas recording settings */
+    captureCanvas?: {
+        recordCanvas?: boolean;
+        canvasFps?: number;
+        canvasQuality?: number;
+    };
+    /** Masking settings */
+    masking?: MaskingConfig;
+    /** Block class for elements to hide */
+    blockClass?: string;
+    /** Block selector for elements to hide */
+    blockSelector?: string;
+    /** Ignore class for input masking */
+    ignoreClass?: string;
+    /** Mask text class */
+    maskTextClass?: string;
+    /** Mask text selector */
+    maskTextSelector?: string;
+    /** Mask all inputs */
+    maskAllInputs?: boolean;
+    /** Mask input options */
+    maskInputOptions?: MaskInputOptions;
+    /** Record headers in network requests */
+    recordHeaders?: boolean;
+    /** Record body in network requests */
+    recordBody?: boolean;
+    /** Compress events before sending */
+    compressEvents?: boolean;
+    /** Internal: Mutation throttler refill rate */
+    __mutationThrottlerRefillRate?: number;
+    /** Internal: Mutation throttler bucket size */
+    __mutationThrottlerBucketSize?: number;
+}
+/** Recording status values */
+export type SessionRecordingStatus = "disabled" | "buffering" | "active" | "paused" | "sampled" | "trigger_pending";
+/** Recording start reason */
+export type SessionStartReason = "recording_initialized" | "session_id_changed" | "linked_flag_matched" | "linked_flag_overridden" | "sampling_overridden" | "url_trigger_matched" | "event_trigger_matched" | "sampled";
+/** Trigger type for starting recording */
+export type TriggerType = "url" | "event";
+/** Buffer for snapshot events */
+export interface SnapshotBuffer {
+    size: number;
+    data: eventWithTime[];
+    sessionId: string;
+    windowId: string;
+}
+/** Remote configuration for session recording */
+export interface SessionRecordingRemoteConfig {
+    enabled?: boolean;
+    endpoint?: string;
+    sampleRate?: string;
+    minimumDurationMilliseconds?: number;
+    consoleLogRecordingEnabled?: boolean;
+    networkPayloadCapture?: {
+        recordHeaders?: boolean;
+        recordBody?: boolean;
+        capturePerformance?: boolean;
+    };
+    masking?: MaskingConfig;
+    recordCanvas?: boolean;
+    canvasFps?: number;
+    canvasQuality?: number;
+    scriptConfig?: {
+        script?: string;
+    };
+    triggerMatchType?: "any" | "all";
+    urlTriggers?: Array<{
+        url: string;
+        matching: "regex" | "exact" | "contains";
+    }>;
+    urlBlocklist?: Array<{
+        url: string;
+        matching: "regex" | "exact" | "contains";
+    }>;
+    eventTriggers?: string[];
+}
+/** Queued rrweb method call */
+export interface QueuedRRWebEvent {
+    rrwebMethod: () => void;
+    attempt: number;
+    enqueuedAt: number;
+}

package/dist/external-scripts-loader.js

@@ -0,0 +1,2 @@
+!function(n){"use strict";var i="undefined"!=typeof window?window:void 0,l="undefined"!=typeof globalThis?globalThis:i,r=null==l?void 0:l.navigator,o=null==l?void 0:l.document;null==l||l.location,null==l||l.fetch,(null==l?void 0:l.XMLHttpRequest)&&"withCredentials"in new l.XMLHttpRequest&&l.XMLHttpRequest,null==l||l.AbortController,null==r||r.userAgent;var t=null!=i?i:{},d=(n,i,l)=>{if(n.getConfig().disable_external_dependency_loading)return console.warn("[ExternalScriptsLoader] "+i+" was requested but loading of external scripts is disabled."),l("Loading of external scripts is disabled");var r=null==o?void 0:o.querySelectorAll("script");if(r)for(var t,d=function(){if(r[e].src===i){var n=r[e];return n.__vtilt_loading_callback_fired?{v:l()}:(n.addEventListener("load",i=>{n.__vtilt_loading_callback_fired=!0,l(void 0,i)}),n.onerror=n=>l(n),{v:void 0})}},e=0;e<r.length;e++)if(t=d())return t.v;var a=()=>{var n;if(!o)return l("document not found");var r=o.createElement("script");r.type="text/javascript",r.crossOrigin="anonymous",r.src=i,r.onload=n=>{r.__vtilt_loading_callback_fired=!0,l(void 0,n)},r.onerror=n=>l(n);var t=o.querySelectorAll("body > script");t.length>0?null===(n=t[0].parentNode)||void 0===n||n.insertBefore(r,t[0]):o.body.appendChild(r)};(null==o?void 0:o.body)?a():null==o||o.addEventListener("DOMContentLoaded",a)},e=(n,i)=>{var l=n.getConfig();return l.script_host?l.script_host.replace(/\/+$/gm,"")+"/dist/"+i+".js":"https://unpkg.com/@v-tilt/browser@1.1.5/dist/"+i+".js"};t.__VTiltExtensions__=t.__VTiltExtensions__||{},t.__VTiltExtensions__.loadExternalDependency=(n,i,l)=>{var r=e(n,i);d(n,r,l)},n.getExtensionUrl=e,n.loadScript=d}({});
+//# sourceMappingURL=external-scripts-loader.js.map

package/dist/external-scripts-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-scripts-loader.js","sources":["../src/utils/globals.ts","../src/entrypoints/external-scripts-loader.ts"],"sourcesContent":[null,null],"names":["win","window","undefined","global","globalThis","navigator","document","location","fetch","XMLHttpRequest","AbortController","userAgent","assignableWindow","loadScript","vtilt","url","callback","getConfig","disable_external_dependency_loading","console","warn","LOGGER_PREFIX","existingScripts","querySelectorAll","_ret","_loop","i","src","alreadyExistingScriptTag","__vtilt_loading_callback_fired","v","addEventListener","event","onerror","error","length","addScript","scriptTag","createElement","type","crossOrigin","onload","scripts","_a","parentNode","insertBefore","body","appendChild","getExtensionUrl","kind","config","script_host","replace","__VTiltExtensions__","loadExternalDependency"],"mappings":"0BAaA,IAAMA,EACc,oBAAXC,OAAyBA,YAASC,EA8DrCC,EACkB,oBAAfC,WAA6BA,WAAaJ,EAMtCK,EAAYF,aAAM,EAANA,EAAQE,UACpBC,EAAWH,aAAM,EAANA,EAAQG,SACRH,SAAAA,EAAQI,SACXJ,SAAAA,EAAQK,OAE3BL,aAAM,EAANA,EAAQM,iBAAkB,oBAAqB,IAAIN,EAAOM,gBACtDN,EAAOM,eAEkBN,SAAAA,EAAQO,gBACdL,SAAAA,EAAWM,UAC7B,IAAMC,EAAqCZ,QAAAA,EAAQ,CAAA,EC1EpDa,EAAaA,CACjBC,EACAC,EACAC,KAKA,GAHeF,EAAMG,YAGDC,oCAIlB,OAHAC,QAAQC,KACHC,2BAAiBN,iEAEfC,EAAS,2CAIlB,IAAMM,EAAkBhB,aAAQ,EAARA,EAAUiB,iBAAiB,UACnD,GAAID,EACF,IADmB,IAuBlBE,EAvBkBC,EAAA,WAEjB,GAAIH,EAAgBI,GAAGC,MAAQZ,EAAK,CAClC,IAAMa,EAA2BN,EAC/BI,GAKF,OAAIE,EAAyBC,+BAC3B,CAAAC,EACOd,MAITY,EAAyBG,iBAAiB,OAASC,IACjDJ,EAAyBC,gCAAiC,EAC1Db,OAASd,EAAW8B,KAEtBJ,EAAyBK,QAAWC,GAAUlB,EAASkB,GAAO,CAAAJ,OAAA,GAGhE,CACF,EAtBSJ,EAAI,EAAGA,EAAIJ,EAAgBa,OAAQT,IAAG,GAAAF,EAAAC,IAAA,OAAAD,EAAAM,EAyBjD,IAAMM,EAAYA,WAChB,IAAK9B,EACH,OAAOU,EAAS,sBAGlB,IAAMqB,EAAY/B,EAASgC,cAAc,UAGzCD,EAAUE,KAAO,kBACjBF,EAAUG,YAAc,YACxBH,EAAUV,IAAMZ,EAChBsB,EAAUI,OAAUT,IAClBK,EAAUR,gCAAiC,EAC3Cb,OAASd,EAAW8B,IAEtBK,EAAUJ,QAAWC,GAAUlB,EAASkB,GAExC,IAAMQ,EAAUpC,EAASiB,iBAAiB,iBACtCmB,EAAQP,OAAS,EACE,QAArBQ,EAAAD,EAAQ,GAAGE,kBAAU,IAAAD,GAAAA,EAAEE,aAAaR,EAAWK,EAAQ,IAEvDpC,EAASwC,KAAKC,YAAYV,KAI1B/B,aAAQ,EAARA,EAAUwC,MACZV,IAEA9B,SAAAA,EAAUyB,iBAAiB,mBAAoBK,IAmB7CY,EAAkBA,CAAClC,EAAcmC,KACrC,IAAMC,EAASpC,EAAMG,YAGrB,OAAIiC,EAAOC,YACSD,EAAOC,YAAYC,QAAQ,SAAU,aAC3BH,EAAI,MAKlC,gDAAgEA,EAAI,OAItErC,EAAiByC,oBACfzC,EAAiByC,qBAAuB,CAAA,EAK1CzC,EAAiByC,oBAAoBC,uBAAyB,CAC5DxC,EACAmC,EACAjC,KAEA,IAAMD,EAAMiC,EAAgBlC,EAAOmC,GACnCpC,EAAWC,EAAOC,EAAKC"}