@probelabs/visor 0.1.106 → 0.1.107

package/dist/sdk/chunk-6Y4YTKCF.mjs

@@ -0,0 +1,197 @@
+import {
+  __esm,
+  __export
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/session-registry.ts
+var session_registry_exports = {};
+__export(session_registry_exports, {
+  SessionRegistry: () => SessionRegistry
+});
+var SessionRegistry;
+var init_session_registry = __esm({
+  "src/session-registry.ts"() {
+    SessionRegistry = class _SessionRegistry {
+      static instance;
+      sessions = /* @__PURE__ */ new Map();
+      exitHandlerRegistered = false;
+      constructor() {
+        this.registerExitHandlers();
+      }
+      /**
+       * Get the singleton instance of SessionRegistry
+       */
+      static getInstance() {
+        if (!_SessionRegistry.instance) {
+          _SessionRegistry.instance = new _SessionRegistry();
+        }
+        return _SessionRegistry.instance;
+      }
+      /**
+       * Register a ProbeAgent session
+       */
+      registerSession(sessionId, agent) {
+        console.error(`\u{1F504} Registering AI session: ${sessionId}`);
+        this.sessions.set(sessionId, agent);
+      }
+      /**
+       * Get an existing ProbeAgent session
+       */
+      getSession(sessionId) {
+        const agent = this.sessions.get(sessionId);
+        if (agent) {
+          console.error(`\u267B\uFE0F  Reusing AI session: ${sessionId}`);
+        }
+        return agent;
+      }
+      /**
+       * Remove a session from the registry
+       */
+      unregisterSession(sessionId) {
+        if (this.sessions.has(sessionId)) {
+          console.error(`\u{1F5D1}\uFE0F  Unregistering AI session: ${sessionId}`);
+          const agent = this.sessions.get(sessionId);
+          this.sessions.delete(sessionId);
+          if (agent && typeof agent.cleanup === "function") {
+            try {
+              agent.cleanup();
+            } catch (error) {
+              console.error(`\u26A0\uFE0F  Warning: Failed to cleanup ProbeAgent: ${error}`);
+            }
+          }
+        }
+      }
+      /**
+       * Clear all sessions (useful for cleanup)
+       */
+      clearAllSessions() {
+        console.error(`\u{1F9F9} Clearing all AI sessions (${this.sessions.size} sessions)`);
+        for (const [, agent] of this.sessions.entries()) {
+          if (agent && typeof agent.cleanup === "function") {
+            try {
+              agent.cleanup();
+            } catch {
+            }
+          }
+        }
+        this.sessions.clear();
+      }
+      /**
+       * Get all active session IDs
+       */
+      getActiveSessionIds() {
+        return Array.from(this.sessions.keys());
+      }
+      /**
+       * Check if a session exists
+       */
+      hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+      }
+      /**
+       * Clone a session with a new session ID using ProbeAgent's official clone() method
+       * This uses ProbeAgent's built-in cloning which automatically handles:
+       * - Intelligent filtering of internal messages (schema reminders, tool prompts, etc.)
+       * - Preserving system message for cache efficiency
+       * - Deep copying conversation history
+       * - Copying agent configuration
+       */
+      async cloneSession(sourceSessionId, newSessionId, checkName) {
+        const sourceAgent = this.sessions.get(sourceSessionId);
+        if (!sourceAgent) {
+          console.error(`\u26A0\uFE0F  Cannot clone session: ${sourceSessionId} not found`);
+          return void 0;
+        }
+        try {
+          const clonedAgent = sourceAgent.clone({
+            sessionId: newSessionId,
+            stripInternalMessages: true,
+            // Remove schema reminders, tool prompts, etc.
+            keepSystemMessage: true,
+            // Keep for cache efficiency
+            deepCopy: true
+            // Safe deep copy of history
+          });
+          if (sourceAgent.debug && checkName) {
+            try {
+              const { initializeTracer } = await import("./tracer-init-WP4X46IF.mjs");
+              const tracerResult = await initializeTracer(newSessionId, checkName);
+              if (tracerResult) {
+                clonedAgent.tracer = tracerResult.tracer;
+                clonedAgent._telemetryConfig = tracerResult.telemetryConfig;
+                clonedAgent._traceFilePath = tracerResult.filePath;
+              }
+            } catch (traceError) {
+              console.error(
+                "\u26A0\uFE0F  Warning: Failed to initialize tracing for cloned session:",
+                traceError
+              );
+            }
+          }
+          if (sourceAgent._mcpInitialized && typeof clonedAgent.initialize === "function") {
+            try {
+              await clonedAgent.initialize();
+              console.error(`\u{1F527} Initialized MCP tools for cloned session`);
+            } catch (initError) {
+              console.error(`\u26A0\uFE0F  Warning: Failed to initialize cloned agent: ${initError}`);
+            }
+          }
+          const historyLength = clonedAgent.history?.length || 0;
+          console.error(
+            `\u{1F4CB} Cloned session ${sourceSessionId} \u2192 ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`
+          );
+          this.registerSession(newSessionId, clonedAgent);
+          return clonedAgent;
+        } catch (error) {
+          console.error(`\u26A0\uFE0F  Failed to clone session ${sourceSessionId}:`, error);
+          return void 0;
+        }
+      }
+      /**
+       * Register process exit handlers to cleanup sessions on exit
+       */
+      registerExitHandlers() {
+        if (this.exitHandlerRegistered) {
+          return;
+        }
+        const cleanupAndExit = (signal) => {
+          if (this.sessions.size > 0) {
+            console.error(`
+\u{1F9F9} [${signal}] Cleaning up ${this.sessions.size} active AI sessions...`);
+            this.clearAllSessions();
+          }
+        };
+        process.on("exit", () => {
+          if (this.sessions.size > 0) {
+            console.error(`\u{1F9F9} [exit] Cleaning up ${this.sessions.size} active AI sessions...`);
+            for (const [, agent] of this.sessions.entries()) {
+              if (agent && typeof agent.cleanup === "function") {
+                try {
+                  agent.cleanup();
+                } catch {
+                }
+              }
+            }
+            this.sessions.clear();
+          }
+        });
+        process.on("SIGINT", () => {
+          cleanupAndExit("SIGINT");
+          process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+          cleanupAndExit("SIGTERM");
+          process.exit(0);
+        });
+        this.exitHandlerRegistered = true;
+      }
+    };
+  }
+});
+
+export {
+  SessionRegistry,
+  session_registry_exports,
+  init_session_registry
+};
+//# sourceMappingURL=chunk-6Y4YTKCF.mjs.map

package/dist/sdk/chunk-6Y4YTKCF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/session-registry.ts"],"sourcesContent":["import { ProbeAgent } from '@probelabs/probe';\n\n/**\n * Extended ProbeAgent interface that includes tracing properties\n */\ninterface TracedProbeAgent extends ProbeAgent {\n  tracer?: any; // AppTracer removed from probe\n  _telemetryConfig?: any; // TelemetryConfig removed from probe\n  _traceFilePath?: string;\n}\n\n/**\n * Registry to manage active ProbeAgent sessions for session reuse\n */\nexport class SessionRegistry {\n  private static instance: SessionRegistry;\n  private sessions: Map<string, TracedProbeAgent> = new Map();\n  private exitHandlerRegistered = false;\n\n  private constructor() {\n    // Register process exit handlers to cleanup sessions\n    this.registerExitHandlers();\n  }\n\n  /**\n   * Get the singleton instance of SessionRegistry\n   */\n  public static getInstance(): SessionRegistry {\n    if (!SessionRegistry.instance) {\n      SessionRegistry.instance = new SessionRegistry();\n    }\n    return SessionRegistry.instance;\n  }\n\n  /**\n   * Register a ProbeAgent session\n   */\n  public registerSession(sessionId: string, agent: TracedProbeAgent): void {\n    console.error(`🔄 Registering AI session: ${sessionId}`);\n    this.sessions.set(sessionId, agent);\n  }\n\n  /**\n   * Get an existing ProbeAgent session\n   */\n  public getSession(sessionId: string): TracedProbeAgent | undefined {\n    const agent = this.sessions.get(sessionId);\n    if (agent) {\n      console.error(`♻️  Reusing AI session: ${sessionId}`);\n    }\n    return agent;\n  }\n\n  /**\n   * Remove a session from the registry\n   */\n  public unregisterSession(sessionId: string): void {\n    if (this.sessions.has(sessionId)) {\n      console.error(`🗑️  Unregistering AI session: ${sessionId}`);\n      const agent = this.sessions.get(sessionId);\n      this.sessions.delete(sessionId);\n\n      // Cleanup the ProbeAgent instance to prevent hanging processes\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (agent && typeof (agent as any).cleanup === 'function') {\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (agent as any).cleanup();\n        } catch (error) {\n          console.error(`⚠️  Warning: Failed to cleanup ProbeAgent: ${error}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Clear all sessions (useful for cleanup)\n   */\n  public clearAllSessions(): void {\n    console.error(`🧹 Clearing all AI sessions (${this.sessions.size} sessions)`);\n\n    // Cleanup each ProbeAgent instance before clearing\n    for (const [, agent] of this.sessions.entries()) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if (agent && typeof (agent as any).cleanup === 'function') {\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (agent as any).cleanup();\n        } catch {\n          // Silent fail during bulk cleanup\n        }\n      }\n    }\n\n    this.sessions.clear();\n  }\n\n  /**\n   * Get all active session IDs\n   */\n  public getActiveSessionIds(): string[] {\n    return Array.from(this.sessions.keys());\n  }\n\n  /**\n   * Check if a session exists\n   */\n  public hasSession(sessionId: string): boolean {\n    return this.sessions.has(sessionId);\n  }\n\n  /**\n   * Clone a session with a new session ID using ProbeAgent's official clone() method\n   * This uses ProbeAgent's built-in cloning which automatically handles:\n   * - Intelligent filtering of internal messages (schema reminders, tool prompts, etc.)\n   * - Preserving system message for cache efficiency\n   * - Deep copying conversation history\n   * - Copying agent configuration\n   */\n  public async cloneSession(\n    sourceSessionId: string,\n    newSessionId: string,\n    checkName?: string\n  ): Promise<ProbeAgent | undefined> {\n    const sourceAgent = this.sessions.get(sourceSessionId);\n    if (!sourceAgent) {\n      console.error(`⚠️  Cannot clone session: ${sourceSessionId} not found`);\n      return undefined;\n    }\n\n    try {\n      // Use ProbeAgent's official clone() method with options\n      // This handles intelligent message filtering automatically\n      const clonedAgent = (sourceAgent as any).clone({\n        sessionId: newSessionId,\n        stripInternalMessages: true, // Remove schema reminders, tool prompts, etc.\n        keepSystemMessage: true, // Keep for cache efficiency\n        deepCopy: true, // Safe deep copy of history\n      }) as TracedProbeAgent;\n\n      // Set up tracing for cloned session if debug mode is enabled\n      if ((sourceAgent as any).debug && checkName) {\n        try {\n          const { initializeTracer } = await import('./utils/tracer-init');\n          const tracerResult = await initializeTracer(newSessionId, checkName);\n          if (tracerResult) {\n            clonedAgent.tracer = tracerResult.tracer;\n            // Store telemetry config and trace file path for proper shutdown\n            clonedAgent._telemetryConfig = tracerResult.telemetryConfig;\n            clonedAgent._traceFilePath = tracerResult.filePath;\n          }\n        } catch (traceError) {\n          console.error(\n            '⚠️  Warning: Failed to initialize tracing for cloned session:',\n            traceError\n          );\n        }\n      }\n\n      // Initialize MCP tools if the source agent had them initialized\n      if (\n        (sourceAgent as any)._mcpInitialized &&\n        typeof (clonedAgent as any).initialize === 'function'\n      ) {\n        try {\n          await (clonedAgent as any).initialize();\n          console.error(`🔧 Initialized MCP tools for cloned session`);\n        } catch (initError) {\n          console.error(`⚠️  Warning: Failed to initialize cloned agent: ${initError}`);\n        }\n      }\n\n      // Get history length for logging\n      const historyLength = (clonedAgent as any).history?.length || 0;\n\n      console.error(\n        `📋 Cloned session ${sourceSessionId} → ${newSessionId} using ProbeAgent.clone() (${historyLength} messages, internal messages filtered)`\n      );\n\n      // Register the cloned session\n      this.registerSession(newSessionId, clonedAgent);\n\n      return clonedAgent;\n    } catch (error) {\n      console.error(`⚠️  Failed to clone session ${sourceSessionId}:`, error);\n      return undefined;\n    }\n  }\n\n  /**\n   * Register process exit handlers to cleanup sessions on exit\n   */\n  private registerExitHandlers(): void {\n    if (this.exitHandlerRegistered) {\n      return;\n    }\n\n    const cleanupAndExit = (signal: string) => {\n      if (this.sessions.size > 0) {\n        console.error(`\\n🧹 [${signal}] Cleaning up ${this.sessions.size} active AI sessions...`);\n        this.clearAllSessions();\n      }\n    };\n\n    // Handle normal process exit\n    process.on('exit', () => {\n      if (this.sessions.size > 0) {\n        console.error(`🧹 [exit] Cleaning up ${this.sessions.size} active AI sessions...`);\n        // Note: async operations won't complete here, but sync cleanup methods will\n        for (const [, agent] of this.sessions.entries()) {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          if (agent && typeof (agent as any).cleanup === 'function') {\n            try {\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              (agent as any).cleanup();\n            } catch {\n              // Silent fail on exit\n            }\n          }\n        }\n        this.sessions.clear();\n      }\n    });\n\n    // Handle SIGINT (Ctrl+C)\n    process.on('SIGINT', () => {\n      cleanupAndExit('SIGINT');\n      process.exit(0);\n    });\n\n    // Handle SIGTERM\n    process.on('SIGTERM', () => {\n      cleanupAndExit('SIGTERM');\n      process.exit(0);\n    });\n\n    this.exitHandlerRegistered = true;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/sdk/chunk-CNX7V5JK.mjs

@@ -0,0 +1,89 @@
+import {
+  __esm
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/utils/author-permissions.ts
+function getPermissionLevel(association) {
+  if (!association) return PERMISSION_HIERARCHY.length;
+  const index = PERMISSION_HIERARCHY.indexOf(association.toUpperCase());
+  return index === -1 ? PERMISSION_HIERARCHY.length : index;
+}
+function hasMinPermission(authorAssociation, minPermission, isLocalMode = false) {
+  if (isLocalMode) {
+    return true;
+  }
+  const authorLevel = getPermissionLevel(authorAssociation);
+  const minLevel = getPermissionLevel(minPermission);
+  return authorLevel <= minLevel;
+}
+function isOwner(authorAssociation, isLocalMode = false) {
+  if (isLocalMode) return true;
+  return authorAssociation?.toUpperCase() === "OWNER";
+}
+function isMember(authorAssociation, isLocalMode = false) {
+  if (isLocalMode) return true;
+  return hasMinPermission(authorAssociation, "MEMBER", isLocalMode);
+}
+function isCollaborator(authorAssociation, isLocalMode = false) {
+  if (isLocalMode) return true;
+  return hasMinPermission(authorAssociation, "COLLABORATOR", isLocalMode);
+}
+function isContributor(authorAssociation, isLocalMode = false) {
+  if (isLocalMode) return true;
+  return hasMinPermission(authorAssociation, "CONTRIBUTOR", isLocalMode);
+}
+function isFirstTimer(authorAssociation, isLocalMode = false) {
+  if (isLocalMode) return false;
+  const assoc = authorAssociation?.toUpperCase();
+  return assoc === "FIRST_TIME_CONTRIBUTOR" || assoc === "FIRST_TIMER";
+}
+function createPermissionHelpers(authorAssociation, isLocalMode = false) {
+  return {
+    hasMinPermission: (minPermission) => hasMinPermission(authorAssociation, minPermission, isLocalMode),
+    isOwner: () => isOwner(authorAssociation, isLocalMode),
+    isMember: () => isMember(authorAssociation, isLocalMode),
+    isCollaborator: () => isCollaborator(authorAssociation, isLocalMode),
+    isContributor: () => isContributor(authorAssociation, isLocalMode),
+    isFirstTimer: () => isFirstTimer(authorAssociation, isLocalMode)
+  };
+}
+function detectLocalMode() {
+  return !process.env.GITHUB_ACTIONS;
+}
+function resolveAssociationFromEvent(eventContext, fallback) {
+  try {
+    const ec = eventContext || {};
+    return ec?.comment?.author_association || ec?.issue?.author_association || ec?.pull_request?.author_association || fallback;
+  } catch {
+    return fallback;
+  }
+}
+var PERMISSION_HIERARCHY;
+var init_author_permissions = __esm({
+  "src/utils/author-permissions.ts"() {
+    "use strict";
+    PERMISSION_HIERARCHY = [
+      "OWNER",
+      "MEMBER",
+      "COLLABORATOR",
+      "CONTRIBUTOR",
+      "FIRST_TIME_CONTRIBUTOR",
+      "FIRST_TIMER",
+      "NONE"
+    ];
+  }
+});
+
+export {
+  hasMinPermission,
+  isOwner,
+  isMember,
+  isCollaborator,
+  isContributor,
+  isFirstTimer,
+  createPermissionHelpers,
+  detectLocalMode,
+  resolveAssociationFromEvent,
+  init_author_permissions
+};
+//# sourceMappingURL=chunk-CNX7V5JK.mjs.map

package/dist/sdk/chunk-CNX7V5JK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/author-permissions.ts"],"sourcesContent":["/**\n * Author permission utilities for checking GitHub author associations\n *\n * GitHub provides author_association field with these values (in order of privilege):\n * - OWNER: Repository owner\n * - MEMBER: Organization member\n * - COLLABORATOR: Invited collaborator\n * - CONTRIBUTOR: Has contributed before\n * - FIRST_TIME_CONTRIBUTOR: First PR to this repo\n * - FIRST_TIMER: First GitHub contribution ever\n * - NONE: No association\n */\n\nexport type AuthorAssociation =\n  | 'OWNER'\n  | 'MEMBER'\n  | 'COLLABORATOR'\n  | 'CONTRIBUTOR'\n  | 'FIRST_TIME_CONTRIBUTOR'\n  | 'FIRST_TIMER'\n  | 'NONE';\n\n/**\n * Permission hierarchy (from highest to lowest privilege)\n */\nconst PERMISSION_HIERARCHY: AuthorAssociation[] = [\n  'OWNER',\n  'MEMBER',\n  'COLLABORATOR',\n  'CONTRIBUTOR',\n  'FIRST_TIME_CONTRIBUTOR',\n  'FIRST_TIMER',\n  'NONE',\n];\n\n/**\n * Get permission level (0 = highest, higher number = lower privilege)\n */\nfunction getPermissionLevel(association: string | undefined): number {\n  if (!association) return PERMISSION_HIERARCHY.length; // Treat unknown as lowest\n  const index = PERMISSION_HIERARCHY.indexOf(association.toUpperCase() as AuthorAssociation);\n  return index === -1 ? PERMISSION_HIERARCHY.length : index;\n}\n\n/**\n * Check if author has at least the specified permission level (>= logic)\n *\n * @param authorAssociation - The author's association from GitHub API\n * @param minPermission - Minimum required permission level\n * @param isLocalMode - Whether running in local/CLI mode (defaults to true for local runs)\n * @returns true if author has at least the specified permission level\n *\n * @example\n * hasMinPermission('MEMBER', 'MEMBER') // true (exact match)\n * hasMinPermission('OWNER', 'MEMBER') // true (owner >= member)\n * hasMinPermission('COLLABORATOR', 'MEMBER') // false (collaborator < member)\n * hasMinPermission(undefined, 'OWNER', true) // true (local mode)\n */\nexport function hasMinPermission(\n  authorAssociation: string | undefined,\n  minPermission: AuthorAssociation,\n  isLocalMode: boolean = false\n): boolean {\n  // In local mode (not GitHub Actions), treat as owner\n  if (isLocalMode) {\n    return true;\n  }\n\n  const authorLevel = getPermissionLevel(authorAssociation);\n  const minLevel = getPermissionLevel(minPermission);\n\n  // Lower number = higher privilege, so author must have equal or lower number\n  return authorLevel <= minLevel;\n}\n\n/**\n * Check if author is exactly the repository owner\n */\nexport function isOwner(\n  authorAssociation: string | undefined,\n  isLocalMode: boolean = false\n): boolean {\n  if (isLocalMode) return true;\n  return authorAssociation?.toUpperCase() === 'OWNER';\n}\n\n/**\n * Check if author is an organization member or owner\n */\nexport function isMember(\n  authorAssociation: string | undefined,\n  isLocalMode: boolean = false\n): boolean {\n  if (isLocalMode) return true;\n  return hasMinPermission(authorAssociation, 'MEMBER', isLocalMode);\n}\n\n/**\n * Check if author is a collaborator (or higher)\n */\nexport function isCollaborator(\n  authorAssociation: string | undefined,\n  isLocalMode: boolean = false\n): boolean {\n  if (isLocalMode) return true;\n  return hasMinPermission(authorAssociation, 'COLLABORATOR', isLocalMode);\n}\n\n/**\n * Check if author is a contributor (has contributed before)\n */\nexport function isContributor(\n  authorAssociation: string | undefined,\n  isLocalMode: boolean = false\n): boolean {\n  if (isLocalMode) return true;\n  return hasMinPermission(authorAssociation, 'CONTRIBUTOR', isLocalMode);\n}\n\n/**\n * Check if author is a first-time contributor (to this repo or GitHub)\n */\nexport function isFirstTimer(\n  authorAssociation: string | undefined,\n  isLocalMode: boolean = false\n): boolean {\n  if (isLocalMode) return false; // In local mode, not a first-timer\n  const assoc = authorAssociation?.toUpperCase();\n  return assoc === 'FIRST_TIME_CONTRIBUTOR' || assoc === 'FIRST_TIMER';\n}\n\n/**\n * Create permission helper functions bound to a specific author association\n * This is used to inject functions into JavaScript execution contexts\n *\n * @param authorAssociation - The author's association from PR data\n * @param isLocalMode - Whether running in local/CLI mode\n */\nexport function createPermissionHelpers(\n  authorAssociation: string | undefined,\n  isLocalMode: boolean = false\n) {\n  return {\n    hasMinPermission: (minPermission: AuthorAssociation) =>\n      hasMinPermission(authorAssociation, minPermission, isLocalMode),\n    isOwner: () => isOwner(authorAssociation, isLocalMode),\n    isMember: () => isMember(authorAssociation, isLocalMode),\n    isCollaborator: () => isCollaborator(authorAssociation, isLocalMode),\n    isContributor: () => isContributor(authorAssociation, isLocalMode),\n    isFirstTimer: () => isFirstTimer(authorAssociation, isLocalMode),\n  };\n}\n\n/**\n * Determine if we're running in local mode (not GitHub Actions)\n */\nexport function detectLocalMode(): boolean {\n  return !process.env.GITHUB_ACTIONS;\n}\n\n/**\n * Resolve the most relevant GitHub author association from an event context.\n * Prefers commenter association for issue_comment events, then issue/PR author,\n * and finally falls back to the provided default association.\n */\nexport function resolveAssociationFromEvent(\n  eventContext: any | undefined,\n  fallback?: string\n): string | undefined {\n  try {\n    const ec = eventContext || {};\n    return (\n      ec?.comment?.author_association ||\n      ec?.issue?.author_association ||\n      ec?.pull_request?.author_association ||\n      fallback\n    );\n  } catch {\n    return fallback;\n  }\n}\n"],"mappings":";;;;;AAsCA,SAAS,mBAAmB,aAAyC;AACnE,MAAI,CAAC,YAAa,QAAO,qBAAqB;AAC9C,QAAM,QAAQ,qBAAqB,QAAQ,YAAY,YAAY,CAAsB;AACzF,SAAO,UAAU,KAAK,qBAAqB,SAAS;AACtD;AAgBO,SAAS,iBACd,mBACA,eACA,cAAuB,OACd;AAET,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,mBAAmB,iBAAiB;AACxD,QAAM,WAAW,mBAAmB,aAAa;AAGjD,SAAO,eAAe;AACxB;AAKO,SAAS,QACd,mBACA,cAAuB,OACd;AACT,MAAI,YAAa,QAAO;AACxB,SAAO,mBAAmB,YAAY,MAAM;AAC9C;AAKO,SAAS,SACd,mBACA,cAAuB,OACd;AACT,MAAI,YAAa,QAAO;AACxB,SAAO,iBAAiB,mBAAmB,UAAU,WAAW;AAClE;AAKO,SAAS,eACd,mBACA,cAAuB,OACd;AACT,MAAI,YAAa,QAAO;AACxB,SAAO,iBAAiB,mBAAmB,gBAAgB,WAAW;AACxE;AAKO,SAAS,cACd,mBACA,cAAuB,OACd;AACT,MAAI,YAAa,QAAO;AACxB,SAAO,iBAAiB,mBAAmB,eAAe,WAAW;AACvE;AAKO,SAAS,aACd,mBACA,cAAuB,OACd;AACT,MAAI,YAAa,QAAO;AACxB,QAAM,QAAQ,mBAAmB,YAAY;AAC7C,SAAO,UAAU,4BAA4B,UAAU;AACzD;AASO,SAAS,wBACd,mBACA,cAAuB,OACvB;AACA,SAAO;AAAA,IACL,kBAAkB,CAAC,kBACjB,iBAAiB,mBAAmB,eAAe,WAAW;AAAA,IAChE,SAAS,MAAM,QAAQ,mBAAmB,WAAW;AAAA,IACrD,UAAU,MAAM,SAAS,mBAAmB,WAAW;AAAA,IACvD,gBAAgB,MAAM,eAAe,mBAAmB,WAAW;AAAA,IACnE,eAAe,MAAM,cAAc,mBAAmB,WAAW;AAAA,IACjE,cAAc,MAAM,aAAa,mBAAmB,WAAW;AAAA,EACjE;AACF;AAKO,SAAS,kBAA2B;AACzC,SAAO,CAAC,QAAQ,IAAI;AACtB;AAOO,SAAS,4BACd,cACA,UACoB;AACpB,MAAI;AACF,UAAM,KAAK,gBAAgB,CAAC;AAC5B,WACE,IAAI,SAAS,sBACb,IAAI,OAAO,sBACX,IAAI,cAAc,sBAClB;AAAA,EAEJ,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AApLA,IAyBM;AAzBN;AAAA;AAAA;AAyBA,IAAM,uBAA4C;AAAA,MAChD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA;AAAA;","names":[]}