claude-flow-novice 1.6.4 → 1.6.5

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/dependency-graph.js

@@ -0,0 +1,471 @@
+/**
+ * Agent Coordination V2 - Dependency Graph Implementation
+ *
+ * DAG-based dependency graph with Tarjan's algorithm for cycle detection,
+ * topological sorting, and efficient dependency resolution.
+ *
+ * Performance targets:
+ * - Build graph: <50ms for 1000 nodes
+ * - Cycle detection: <100ms for 1000 nodes (O(V+E) complexity)
+ * - Topological sort: O(V+E) complexity
+ *
+ * @module coordination/v2/core/dependency-graph
+ */ import { DependencyNodeStatus } from './dependency-node.js';
+/**
+ * Graph validation error.
+ */ export class DependencyGraphError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'DependencyGraphError';
+    }
+}
+/**
+ * Dependency Graph Implementation.
+ *
+ * Manages task dependencies using a Directed Acyclic Graph (DAG) structure
+ * with support for:
+ * - O(1) node lookup via Map-based storage
+ * - Tarjan's algorithm for cycle detection (O(V+E))
+ * - Kahn's algorithm for topological sorting (O(V+E))
+ * - Efficient dependency and dependent queries
+ * - Graph statistics and validation
+ *
+ * @example
+ * ```typescript
+ * const graph = new DependencyGraph();
+ *
+ * const nodeA = new DependencyNodeImpl({ id: 'a', agentId: 'agent-1', taskId: 'task-a' });
+ * const nodeB = new DependencyNodeImpl({ id: 'b', agentId: 'agent-1', taskId: 'task-b' });
+ *
+ * graph.addNode(nodeA);
+ * graph.addNode(nodeB);
+ * graph.addDependency('b', 'a'); // B depends on A
+ *
+ * const order = graph.getTopologicalOrder(); // ['a', 'b']
+ * const cycles = graph.detectCycles(); // { hasCycle: false, cycles: [] }
+ * ```
+ */ export class DependencyGraph {
+    nodes;
+    adjacencyList;
+    reverseAdjacencyList;
+    config;
+    completedTasks;
+    /**
+   * Creates a new dependency graph.
+   *
+   * @param config - Graph configuration options
+   */ constructor(config){
+        this.nodes = new Map();
+        this.adjacencyList = new Map();
+        this.reverseAdjacencyList = new Map();
+        this.completedTasks = new Set();
+        this.config = {
+            allowDuplicateEdges: config?.allowDuplicateEdges ?? false,
+            autoValidate: config?.autoValidate ?? true,
+            maxSize: config?.maxSize ?? 10000
+        };
+    }
+    // ============================================
+    // Node Management
+    // ============================================
+    /**
+   * Adds a node to the graph.
+   *
+   * @param node - Dependency node to add
+   * @throws {DependencyGraphError} If node already exists or max size exceeded
+   */ addNode(node) {
+        if (this.nodes.has(node.id)) {
+            throw new DependencyGraphError(`Node with ID '${node.id}' already exists`);
+        }
+        if (this.nodes.size >= this.config.maxSize) {
+            throw new DependencyGraphError(`Graph size limit reached (max: ${this.config.maxSize})`);
+        }
+        this.nodes.set(node.id, node);
+        this.adjacencyList.set(node.id, new Set());
+        this.reverseAdjacencyList.set(node.id, new Set());
+    }
+    /**
+   * Removes a node from the graph.
+   *
+   * @param nodeId - ID of the node to remove
+   * @returns True if node was removed, false if not found
+   */ removeNode(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) {
+            return false;
+        }
+        // Remove all edges involving this node
+        const dependencies = this.adjacencyList.get(nodeId) || new Set();
+        const dependents = this.reverseAdjacencyList.get(nodeId) || new Set();
+        // Update reverse adjacency for dependencies
+        for (const depId of dependencies){
+            this.reverseAdjacencyList.get(depId)?.delete(nodeId);
+        }
+        // Update adjacency for dependents
+        for (const dependentId of dependents){
+            this.adjacencyList.get(dependentId)?.delete(nodeId);
+        }
+        // Remove node and its adjacency lists
+        this.nodes.delete(nodeId);
+        this.adjacencyList.delete(nodeId);
+        this.reverseAdjacencyList.delete(nodeId);
+        return true;
+    }
+    /**
+   * Gets a node by ID.
+   *
+   * @param nodeId - Node ID
+   * @returns Node if found, undefined otherwise
+   */ getNode(nodeId) {
+        return this.nodes.get(nodeId);
+    }
+    /**
+   * Checks if a node exists in the graph.
+   *
+   * @param nodeId - Node ID to check
+   * @returns True if node exists
+   */ hasNode(nodeId) {
+        return this.nodes.has(nodeId);
+    }
+    /**
+   * Gets all nodes in the graph.
+   *
+   * @returns Array of all nodes
+   */ getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /**
+   * Returns the number of nodes in the graph.
+   */ size() {
+        return this.nodes.size;
+    }
+    // ============================================
+    // Edge Management (Dependencies)
+    // ============================================
+    /**
+   * Adds a dependency edge: from depends on to.
+   *
+   * @param fromId - ID of the node that has the dependency
+   * @param toId - ID of the node that is depended upon
+   * @throws {DependencyGraphError} If nodes don't exist or cycle would be created
+   */ addDependency(fromId, toId) {
+        // Validate nodes exist
+        if (!this.nodes.has(fromId)) {
+            throw new DependencyGraphError(`Node '${fromId}' not found in graph`);
+        }
+        if (!this.nodes.has(toId)) {
+            throw new DependencyGraphError(`Node '${toId}' not found in graph`);
+        }
+        // Prevent self-dependencies
+        if (fromId === toId) {
+            throw new DependencyGraphError('Self-dependencies are not allowed');
+        }
+        // Check for duplicate edges
+        const existingDeps = this.adjacencyList.get(fromId);
+        if (existingDeps.has(toId) && !this.config.allowDuplicateEdges) {
+            throw new DependencyGraphError(`Dependency from '${fromId}' to '${toId}' already exists`);
+        }
+        // Add edge to adjacency lists
+        this.adjacencyList.get(fromId).add(toId);
+        this.reverseAdjacencyList.get(toId).add(fromId);
+        // Validate no cycles created (if auto-validate enabled)
+        if (this.config.autoValidate) {
+            const cycleResult = this.detectCycles();
+            if (cycleResult.hasCycle) {
+                // Rollback the edge
+                this.adjacencyList.get(fromId).delete(toId);
+                this.reverseAdjacencyList.get(toId).delete(fromId);
+                throw new DependencyGraphError(`Adding dependency would create cycle: ${JSON.stringify(cycleResult.cycles)}`);
+            }
+        }
+    }
+    /**
+   * Removes a dependency edge.
+   *
+   * @param fromId - Source node ID
+   * @param toId - Target node ID
+   * @returns True if edge was removed, false if not found
+   */ removeDependency(fromId, toId) {
+        const removed = this.adjacencyList.get(fromId)?.delete(toId) ?? false;
+        if (removed) {
+            this.reverseAdjacencyList.get(toId)?.delete(fromId);
+        }
+        return removed;
+    }
+    /**
+   * Gets all dependencies for a node (nodes it depends on).
+   *
+   * @param nodeId - Node ID
+   * @returns Set of dependency node IDs
+   */ getDependencies(nodeId) {
+        return new Set(this.adjacencyList.get(nodeId) || []);
+    }
+    /**
+   * Gets all dependents for a node (nodes that depend on it).
+   *
+   * @param nodeId - Node ID
+   * @returns Set of dependent node IDs
+   */ getDependents(nodeId) {
+        return new Set(this.reverseAdjacencyList.get(nodeId) || []);
+    }
+    /**
+   * Gets the full dependency chain for a node (all transitive dependencies).
+   *
+   * @param nodeId - Node ID
+   * @returns Array of node IDs in dependency order
+   */ getDependencyChain(nodeId) {
+        const visited = new Set();
+        const chain = [];
+        const dfs = (id)=>{
+            if (visited.has(id)) return;
+            visited.add(id);
+            const deps = this.adjacencyList.get(id) || new Set();
+            for (const depId of deps){
+                dfs(depId);
+            }
+            chain.push(id);
+        };
+        dfs(nodeId);
+        return chain;
+    }
+    // ============================================
+    // Cycle Detection (Tarjan's Algorithm)
+    // ============================================
+    /**
+   * Detects cycles using Tarjan's strongly connected components algorithm.
+   *
+   * This provides more robust cycle detection than simple DFS, identifying
+   * all strongly connected components in O(V+E) time.
+   *
+   * @returns Cycle detection result with all cycles and SCCs
+   */ detectCycles() {
+        const index = new Map();
+        const lowLink = new Map();
+        const onStack = new Set();
+        const stack = [];
+        let currentIndex = 0;
+        const sccs = [];
+        const strongConnect = (nodeId)=>{
+            // Set depth index for node
+            index.set(nodeId, currentIndex);
+            lowLink.set(nodeId, currentIndex);
+            currentIndex++;
+            stack.push(nodeId);
+            onStack.add(nodeId);
+            // Consider successors (dependencies)
+            const dependencies = this.adjacencyList.get(nodeId) || new Set();
+            for (const depId of dependencies){
+                if (!index.has(depId)) {
+                    // Successor has not been visited; recurse
+                    strongConnect(depId);
+                    lowLink.set(nodeId, Math.min(lowLink.get(nodeId), lowLink.get(depId)));
+                } else if (onStack.has(depId)) {
+                    // Successor is on stack and hence in current SCC
+                    lowLink.set(nodeId, Math.min(lowLink.get(nodeId), index.get(depId)));
+                }
+            }
+            // If nodeId is a root node, pop the stack and generate SCC
+            if (lowLink.get(nodeId) === index.get(nodeId)) {
+                const scc = [];
+                let w;
+                do {
+                    w = stack.pop();
+                    onStack.delete(w);
+                    scc.push(w);
+                }while (w !== nodeId)
+                sccs.push(scc);
+            }
+        };
+        // Run Tarjan's algorithm on all unvisited nodes
+        for (const nodeId of this.nodes.keys()){
+            if (!index.has(nodeId)) {
+                strongConnect(nodeId);
+            }
+        }
+        // SCCs with size > 1 are cycles
+        const cycles = sccs.filter((scc)=>scc.length > 1);
+        return {
+            hasCycle: cycles.length > 0,
+            cycles,
+            stronglyConnectedComponents: sccs
+        };
+    }
+    // ============================================
+    // Topological Sorting (Kahn's Algorithm)
+    // ============================================
+    /**
+   * Computes topological ordering using Kahn's algorithm.
+   *
+   * Returns nodes in dependency order (dependencies before dependents).
+   * Throws if graph contains cycles.
+   *
+   * @returns Array of node IDs in topological order
+   * @throws {DependencyGraphError} If graph contains cycles
+   */ getTopologicalOrder() {
+        const inDegree = new Map();
+        const queue = [];
+        const result = [];
+        // Initialize in-degrees
+        for (const nodeId of this.nodes.keys()){
+            const deps = this.adjacencyList.get(nodeId);
+            inDegree.set(nodeId, deps.size);
+            if (deps.size === 0) {
+                queue.push(nodeId); // No dependencies
+            }
+        }
+        // Process nodes with zero in-degree
+        while(queue.length > 0){
+            const nodeId = queue.shift();
+            result.push(nodeId);
+            // Reduce in-degree for dependents
+            const dependents = this.reverseAdjacencyList.get(nodeId) || new Set();
+            for (const dependentId of dependents){
+                const newInDegree = inDegree.get(dependentId) - 1;
+                inDegree.set(dependentId, newInDegree);
+                if (newInDegree === 0) {
+                    queue.push(dependentId);
+                }
+            }
+        }
+        // If not all nodes processed, there's a cycle
+        if (result.length !== this.nodes.size) {
+            const cycleResult = this.detectCycles();
+            throw new DependencyGraphError(`Cannot compute topological order: graph contains cycles. ` + `Detected cycles: ${JSON.stringify(cycleResult.cycles)}`);
+        }
+        return result;
+    }
+    // ============================================
+    // Graph Queries
+    // ============================================
+    /**
+   * Gets all nodes that are ready for execution (no pending dependencies).
+   *
+   * @returns Array of nodes with all dependencies satisfied
+   */ getReadyTasks() {
+        const ready = [];
+        for (const [nodeId, node] of this.nodes){
+            const deps = this.adjacencyList.get(nodeId);
+            // Check if all dependencies are completed
+            let allDepsCompleted = true;
+            for (const depId of deps){
+                const depNode = this.nodes.get(depId);
+                if (depNode?.status !== DependencyNodeStatus.COMPLETED) {
+                    allDepsCompleted = false;
+                    break;
+                }
+            }
+            if (allDepsCompleted && node.status === DependencyNodeStatus.READY) {
+                ready.push(node);
+            }
+        }
+        // Sort by priority (higher priority first)
+        return ready.sort((a, b)=>b.priority - a.priority);
+    }
+    /**
+   * Gets all nodes that are blocked on dependencies.
+   *
+   * @returns Array of nodes waiting for dependencies
+   */ getBlockedTasks() {
+        const blocked = [];
+        for (const [nodeId, node] of this.nodes){
+            const deps = this.adjacencyList.get(nodeId);
+            if (deps.size > 0 && node.status === DependencyNodeStatus.PENDING) {
+                blocked.push(node);
+            }
+        }
+        return blocked;
+    }
+    /**
+   * Gets graph statistics for monitoring and debugging.
+   *
+   * @returns Object containing graph metrics
+   */ getStatistics() {
+        let edgeCount = 0;
+        let maxInDegree = 0;
+        let maxOutDegree = 0;
+        let completedCount = 0;
+        for (const deps of this.adjacencyList.values()){
+            edgeCount += deps.size;
+            maxOutDegree = Math.max(maxOutDegree, deps.size);
+        }
+        for (const dependents of this.reverseAdjacencyList.values()){
+            maxInDegree = Math.max(maxInDegree, dependents.size);
+        }
+        for (const node of this.nodes.values()){
+            if (node.status === DependencyNodeStatus.COMPLETED) {
+                completedCount++;
+            }
+        }
+        const nodeCount = this.nodes.size;
+        return {
+            nodeCount,
+            edgeCount,
+            maxInDegree,
+            maxOutDegree,
+            avgInDegree: nodeCount > 0 ? edgeCount / nodeCount : 0,
+            avgOutDegree: nodeCount > 0 ? edgeCount / nodeCount : 0,
+            readyNodeCount: this.getReadyTasks().length,
+            blockedNodeCount: this.getBlockedTasks().length,
+            completedNodeCount: completedCount
+        };
+    }
+    /**
+   * Updates the status of a node in the graph.
+   *
+   * @param nodeId - ID of the node to update
+   * @param status - New status to set
+   * @throws {DependencyGraphError} If node not found
+   */ updateStatus(nodeId, status) {
+        const node = this.nodes.get(nodeId);
+        if (!node) {
+            throw new DependencyGraphError(`Cannot update status: node '${nodeId}' not found`);
+        }
+        // Update node status using DependencyNodeImpl's updateStatus method
+        if ('updateStatus' in node && typeof node.updateStatus === 'function') {
+            node.updateStatus(status);
+        } else {
+            // Fallback: direct property update (for interfaces without updateStatus method)
+            node.status = status;
+        }
+        // Track completed tasks
+        if (status === DependencyNodeStatus.COMPLETED) {
+            this.completedTasks.add(nodeId);
+        } else {
+            this.completedTasks.delete(nodeId);
+        }
+    }
+    /**
+   * Clears all nodes and edges from the graph.
+   */ clear() {
+        this.nodes.clear();
+        this.adjacencyList.clear();
+        this.reverseAdjacencyList.clear();
+        this.completedTasks.clear();
+    }
+    /**
+   * Validates graph integrity.
+   *
+   * @returns Array of validation errors (empty if valid)
+   */ validate() {
+        const errors = [];
+        // Check adjacency list consistency
+        for (const [nodeId, deps] of this.adjacencyList){
+            if (!this.nodes.has(nodeId)) {
+                errors.push(`Adjacency list contains non-existent node: ${nodeId}`);
+            }
+            for (const depId of deps){
+                if (!this.nodes.has(depId)) {
+                    errors.push(`Node ${nodeId} depends on non-existent node: ${depId}`);
+                }
+                // Check reverse adjacency
+                const reverseDeps = this.reverseAdjacencyList.get(depId);
+                if (!reverseDeps?.has(nodeId)) {
+                    errors.push(`Reverse adjacency missing for edge: ${nodeId} -> ${depId}`);
+                }
+            }
+        }
+        return errors;
+    }
+}
+
+//# sourceMappingURL=dependency-graph.js.map

package/.claude-flow-novice/dist/src/coordination/archives/v2-sdk-typescript/v2/core/dependency-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/coordination/archives/v2-sdk-typescript/v2/core/dependency-graph.ts"],"names":["DependencyNodeStatus","DependencyGraphError","Error","message","name","DependencyGraph","nodes","adjacencyList","reverseAdjacencyList","config","completedTasks","Map","Set","allowDuplicateEdges","autoValidate","maxSize","addNode","node","has","id","size","set","removeNode","nodeId","get","dependencies","dependents","depId","delete","dependentId","getNode","hasNode","getAllNodes","Array","from","values","addDependency","fromId","toId","existingDeps","add","cycleResult","detectCycles","hasCycle","JSON","stringify","cycles","removeDependency","removed","getDependencies","getDependents","getDependencyChain","visited","chain","dfs","deps","push","index","lowLink","onStack","stack","currentIndex","sccs","strongConnect","Math","min","scc","w","pop","keys","filter","length","stronglyConnectedComponents","getTopologicalOrder","inDegree","queue","result","shift","newInDegree","getReadyTasks","ready","allDepsCompleted","depNode","status","COMPLETED","READY","sort","a","b","priority","getBlockedTasks","blocked","PENDING","getStatistics","edgeCount","maxInDegree","maxOutDegree","completedCount","max","nodeCount","avgInDegree","avgOutDegree","readyNodeCount","blockedNodeCount","completedNodeCount","updateStatus","clear","validate","errors","reverseDeps"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAED,SAA6CA,oBAAoB,QAAQ,uBAAuB;AAgBhG;;CAEC,GACD,OAAO,MAAMC,6BAA6BC;IACxC,YAAYC,OAAe,CAAE;QAC3B,KAAK,CAACA;QACN,IAAI,CAACC,IAAI,GAAG;IACd;AACF;AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,MAAMC;IACHC,MAAmC;IACnCC,cAAwC;IACxCC,qBAA+C;IAC/CC,OAAwC;IACzCC,eAA4B;IAEnC;;;;GAIC,GACD,YAAYD,MAA8B,CAAE;QAC1C,IAAI,CAACH,KAAK,GAAG,IAAIK;QACjB,IAAI,CAACJ,aAAa,GAAG,IAAII;QACzB,IAAI,CAACH,oBAAoB,GAAG,IAAIG;QAChC,IAAI,CAACD,cAAc,GAAG,IAAIE;QAC1B,IAAI,CAACH,MAAM,GAAG;YACZI,qBAAqBJ,QAAQI,uBAAuB;YACpDC,cAAcL,QAAQK,gBAAgB;YACtCC,SAASN,QAAQM,WAAW;QAC9B;IACF;IAEA,+CAA+C;IAC/C,kBAAkB;IAClB,+CAA+C;IAE/C;;;;;GAKC,GACDC,QAAQC,IAAoB,EAAQ;QAClC,IAAI,IAAI,CAACX,KAAK,CAACY,GAAG,CAACD,KAAKE,EAAE,GAAG;YAC3B,MAAM,IAAIlB,qBAAqB,CAAC,cAAc,EAAEgB,KAAKE,EAAE,CAAC,gBAAgB,CAAC;QAC3E;QAEA,IAAI,IAAI,CAACb,KAAK,CAACc,IAAI,IAAI,IAAI,CAACX,MAAM,CAACM,OAAO,EAAE;YAC1C,MAAM,IAAId,qBACR,CAAC,+BAA+B,EAAE,IAAI,CAACQ,MAAM,CAACM,OAAO,CAAC,CAAC,CAAC;QAE5D;QAEA,IAAI,CAACT,KAAK,CAACe,GAAG,CAACJ,KAAKE,EAAE,EAAEF;QACxB,IAAI,CAACV,aAAa,CAACc,GAAG,CAACJ,KAAKE,EAAE,EAAE,IAAIP;QACpC,IAAI,CAACJ,oBAAoB,CAACa,GAAG,CAACJ,KAAKE,EAAE,EAAE,IAAIP;IAC7C;IAEA;;;;;GAKC,GACDU,WAAWC,MAAc,EAAW;QAClC,MAAMN,OAAO,IAAI,CAACX,KAAK,CAACkB,GAAG,CAACD;QAC5B,IAAI,CAACN,MAAM;YACT,OAAO;QACT;QAEA,uCAAuC;QACvC,MAAMQ,eAAe,IAAI,CAAClB,aAAa,CAACiB,GAAG,CAACD,WAAW,IAAIX;QAC3D,MAAMc,aAAa,IAAI,CAAClB,oBAAoB,CAACgB,GAAG,CAACD,WAAW,IAAIX;QAEhE,4CAA4C;QAC5C,KAAK,MAAMe,SAASF,aAAc;YAChC,IAAI,CAACjB,oBAAoB,CAACgB,GAAG,CAACG,QAAQC,OAAOL;QAC/C;QAEA,kCAAkC;QAClC,KAAK,MAAMM,eAAeH,WAAY;YACpC,IAAI,CAACnB,aAAa,CAACiB,GAAG,CAACK,cAAcD,OAAOL;QAC9C;QAEA,sCAAsC;QACtC,IAAI,CAACjB,KAAK,CAACsB,MAAM,CAACL;QAClB,IAAI,CAAChB,aAAa,CAACqB,MAAM,CAACL;QAC1B,IAAI,CAACf,oBAAoB,CAACoB,MAAM,CAACL;QAEjC,OAAO;IACT;IAEA;;;;;GAKC,GACDO,QAAQP,MAAc,EAA8B;QAClD,OAAO,IAAI,CAACjB,KAAK,CAACkB,GAAG,CAACD;IACxB;IAEA;;;;;GAKC,GACDQ,QAAQR,MAAc,EAAW;QAC/B,OAAO,IAAI,CAACjB,KAAK,CAACY,GAAG,CAACK;IACxB;IAEA;;;;GAIC,GACDS,cAAgC;QAC9B,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAAC5B,KAAK,CAAC6B,MAAM;IACrC;IAEA;;GAEC,GACDf,OAAe;QACb,OAAO,IAAI,CAACd,KAAK,CAACc,IAAI;IACxB;IAEA,+CAA+C;IAC/C,iCAAiC;IACjC,+CAA+C;IAE/C;;;;;;GAMC,GACDgB,cAAcC,MAAc,EAAEC,IAAY,EAAQ;QAChD,uBAAuB;QACvB,IAAI,CAAC,IAAI,CAAChC,KAAK,CAACY,GAAG,CAACmB,SAAS;YAC3B,MAAM,IAAIpC,qBAAqB,CAAC,MAAM,EAAEoC,OAAO,oBAAoB,CAAC;QACtE;QACA,IAAI,CAAC,IAAI,CAAC/B,KAAK,CAACY,GAAG,CAACoB,OAAO;YACzB,MAAM,IAAIrC,qBAAqB,CAAC,MAAM,EAAEqC,KAAK,oBAAoB,CAAC;QACpE;QAEA,4BAA4B;QAC5B,IAAID,WAAWC,MAAM;YACnB,MAAM,IAAIrC,qBAAqB;QACjC;QAEA,4BAA4B;QAC5B,MAAMsC,eAAe,IAAI,CAAChC,aAAa,CAACiB,GAAG,CAACa;QAC5C,IAAIE,aAAarB,GAAG,CAACoB,SAAS,CAAC,IAAI,CAAC7B,MAAM,CAACI,mBAAmB,EAAE;YAC9D,MAAM,IAAIZ,qBACR,CAAC,iBAAiB,EAAEoC,OAAO,MAAM,EAAEC,KAAK,gBAAgB,CAAC;QAE7D;QAEA,8BAA8B;QAC9B,IAAI,CAAC/B,aAAa,CAACiB,GAAG,CAACa,QAASG,GAAG,CAACF;QACpC,IAAI,CAAC9B,oBAAoB,CAACgB,GAAG,CAACc,MAAOE,GAAG,CAACH;QAEzC,wDAAwD;QACxD,IAAI,IAAI,CAAC5B,MAAM,CAACK,YAAY,EAAE;YAC5B,MAAM2B,cAAc,IAAI,CAACC,YAAY;YACrC,IAAID,YAAYE,QAAQ,EAAE;gBACxB,oBAAoB;gBACpB,IAAI,CAACpC,aAAa,CAACiB,GAAG,CAACa,QAAST,MAAM,CAACU;gBACvC,IAAI,CAAC9B,oBAAoB,CAACgB,GAAG,CAACc,MAAOV,MAAM,CAACS;gBAE5C,MAAM,IAAIpC,qBACR,CAAC,sCAAsC,EAAE2C,KAAKC,SAAS,CAACJ,YAAYK,MAAM,GAAG;YAEjF;QACF;IACF;IAEA;;;;;;GAMC,GACDC,iBAAiBV,MAAc,EAAEC,IAAY,EAAW;QACtD,MAAMU,UAAU,IAAI,CAACzC,aAAa,CAACiB,GAAG,CAACa,SAAST,OAAOU,SAAS;QAChE,IAAIU,SAAS;YACX,IAAI,CAACxC,oBAAoB,CAACgB,GAAG,CAACc,OAAOV,OAAOS;QAC9C;QACA,OAAOW;IACT;IAEA;;;;;GAKC,GACDC,gBAAgB1B,MAAc,EAAe;QAC3C,OAAO,IAAIX,IAAI,IAAI,CAACL,aAAa,CAACiB,GAAG,CAACD,WAAW,EAAE;IACrD;IAEA;;;;;GAKC,GACD2B,cAAc3B,MAAc,EAAe;QACzC,OAAO,IAAIX,IAAI,IAAI,CAACJ,oBAAoB,CAACgB,GAAG,CAACD,WAAW,EAAE;IAC5D;IAEA;;;;;GAKC,GACD4B,mBAAmB5B,MAAc,EAAY;QAC3C,MAAM6B,UAAU,IAAIxC;QACpB,MAAMyC,QAAkB,EAAE;QAE1B,MAAMC,MAAM,CAACnC;YACX,IAAIiC,QAAQlC,GAAG,CAACC,KAAK;YACrBiC,QAAQZ,GAAG,CAACrB;YAEZ,MAAMoC,OAAO,IAAI,CAAChD,aAAa,CAACiB,GAAG,CAACL,OAAO,IAAIP;YAC/C,KAAK,MAAMe,SAAS4B,KAAM;gBACxBD,IAAI3B;YACN;YAEA0B,MAAMG,IAAI,CAACrC;QACb;QAEAmC,IAAI/B;QACJ,OAAO8B;IACT;IAEA,+CAA+C;IAC/C,uCAAuC;IACvC,+CAA+C;IAE/C;;;;;;;GAOC,GACDX,eAAqC;QACnC,MAAMe,QAAQ,IAAI9C;QAClB,MAAM+C,UAAU,IAAI/C;QACpB,MAAMgD,UAAU,IAAI/C;QACpB,MAAMgD,QAAkB,EAAE;QAC1B,IAAIC,eAAe;QACnB,MAAMC,OAAmB,EAAE;QAE3B,MAAMC,gBAAgB,CAACxC;YACrB,2BAA2B;YAC3BkC,MAAMpC,GAAG,CAACE,QAAQsC;YAClBH,QAAQrC,GAAG,CAACE,QAAQsC;YACpBA;YAEAD,MAAMJ,IAAI,CAACjC;YACXoC,QAAQnB,GAAG,CAACjB;YAEZ,qCAAqC;YACrC,MAAME,eAAe,IAAI,CAAClB,aAAa,CAACiB,GAAG,CAACD,WAAW,IAAIX;YAC3D,KAAK,MAAMe,SAASF,aAAc;gBAChC,IAAI,CAACgC,MAAMvC,GAAG,CAACS,QAAQ;oBACrB,0CAA0C;oBAC1CoC,cAAcpC;oBACd+B,QAAQrC,GAAG,CAACE,QAAQyC,KAAKC,GAAG,CAACP,QAAQlC,GAAG,CAACD,SAAUmC,QAAQlC,GAAG,CAACG;gBACjE,OAAO,IAAIgC,QAAQzC,GAAG,CAACS,QAAQ;oBAC7B,iDAAiD;oBACjD+B,QAAQrC,GAAG,CAACE,QAAQyC,KAAKC,GAAG,CAACP,QAAQlC,GAAG,CAACD,SAAUkC,MAAMjC,GAAG,CAACG;gBAC/D;YACF;YAEA,2DAA2D;YAC3D,IAAI+B,QAAQlC,GAAG,CAACD,YAAYkC,MAAMjC,GAAG,CAACD,SAAS;gBAC7C,MAAM2C,MAAgB,EAAE;gBACxB,IAAIC;gBAEJ,GAAG;oBACDA,IAAIP,MAAMQ,GAAG;oBACbT,QAAQ/B,MAAM,CAACuC;oBACfD,IAAIV,IAAI,CAACW;gBACX,QAASA,MAAM5C,OAAQ;gBAEvBuC,KAAKN,IAAI,CAACU;YACZ;QACF;QAEA,gDAAgD;QAChD,KAAK,MAAM3C,UAAU,IAAI,CAACjB,KAAK,CAAC+D,IAAI,GAAI;YACtC,IAAI,CAACZ,MAAMvC,GAAG,CAACK,SAAS;gBACtBwC,cAAcxC;YAChB;QACF;QAEA,gCAAgC;QAChC,MAAMuB,SAASgB,KAAKQ,MAAM,CAACJ,CAAAA,MAAOA,IAAIK,MAAM,GAAG;QAE/C,OAAO;YACL5B,UAAUG,OAAOyB,MAAM,GAAG;YAC1BzB;YACA0B,6BAA6BV;QAC/B;IACF;IAEA,+CAA+C;IAC/C,yCAAyC;IACzC,+CAA+C;IAE/C;;;;;;;;GAQC,GACDW,sBAAgC;QAC9B,MAAMC,WAAW,IAAI/D;QACrB,MAAMgE,QAAkB,EAAE;QAC1B,MAAMC,SAAmB,EAAE;QAE3B,wBAAwB;QACxB,KAAK,MAAMrD,UAAU,IAAI,CAACjB,KAAK,CAAC+D,IAAI,GAAI;YACtC,MAAMd,OAAO,IAAI,CAAChD,aAAa,CAACiB,GAAG,CAACD;YACpCmD,SAASrD,GAAG,CAACE,QAAQgC,KAAKnC,IAAI;YAE9B,IAAImC,KAAKnC,IAAI,KAAK,GAAG;gBACnBuD,MAAMnB,IAAI,CAACjC,SAAS,kBAAkB;YACxC;QACF;QAEA,oCAAoC;QACpC,MAAOoD,MAAMJ,MAAM,GAAG,EAAG;YACvB,MAAMhD,SAASoD,MAAME,KAAK;YAC1BD,OAAOpB,IAAI,CAACjC;YAEZ,kCAAkC;YAClC,MAAMG,aAAa,IAAI,CAAClB,oBAAoB,CAACgB,GAAG,CAACD,WAAW,IAAIX;YAChE,KAAK,MAAMiB,eAAeH,WAAY;gBACpC,MAAMoD,cAAcJ,SAASlD,GAAG,CAACK,eAAgB;gBACjD6C,SAASrD,GAAG,CAACQ,aAAaiD;gBAE1B,IAAIA,gBAAgB,GAAG;oBACrBH,MAAMnB,IAAI,CAAC3B;gBACb;YACF;QACF;QAEA,8CAA8C;QAC9C,IAAI+C,OAAOL,MAAM,KAAK,IAAI,CAACjE,KAAK,CAACc,IAAI,EAAE;YACrC,MAAMqB,cAAc,IAAI,CAACC,YAAY;YACrC,MAAM,IAAIzC,qBACR,CAAC,yDAAyD,CAAC,GAC3D,CAAC,iBAAiB,EAAE2C,KAAKC,SAAS,CAACJ,YAAYK,MAAM,GAAG;QAE5D;QAEA,OAAO8B;IACT;IAEA,+CAA+C;IAC/C,gBAAgB;IAChB,+CAA+C;IAE/C;;;;GAIC,GACDG,gBAAkC;QAChC,MAAMC,QAA0B,EAAE;QAElC,KAAK,MAAM,CAACzD,QAAQN,KAAK,IAAI,IAAI,CAACX,KAAK,CAAE;YACvC,MAAMiD,OAAO,IAAI,CAAChD,aAAa,CAACiB,GAAG,CAACD;YAEpC,0CAA0C;YAC1C,IAAI0D,mBAAmB;YACvB,KAAK,MAAMtD,SAAS4B,KAAM;gBACxB,MAAM2B,UAAU,IAAI,CAAC5E,KAAK,CAACkB,GAAG,CAACG;gBAC/B,IAAIuD,SAASC,WAAWnF,qBAAqBoF,SAAS,EAAE;oBACtDH,mBAAmB;oBACnB;gBACF;YACF;YAEA,IAAIA,oBAAoBhE,KAAKkE,MAAM,KAAKnF,qBAAqBqF,KAAK,EAAE;gBAClEL,MAAMxB,IAAI,CAACvC;YACb;QACF;QAEA,2CAA2C;QAC3C,OAAO+D,MAAMM,IAAI,CAAC,CAACC,GAAGC,IAAMA,EAAEC,QAAQ,GAAGF,EAAEE,QAAQ;IACrD;IAEA;;;;GAIC,GACDC,kBAAoC;QAClC,MAAMC,UAA4B,EAAE;QAEpC,KAAK,MAAM,CAACpE,QAAQN,KAAK,IAAI,IAAI,CAACX,KAAK,CAAE;YACvC,MAAMiD,OAAO,IAAI,CAAChD,aAAa,CAACiB,GAAG,CAACD;YAEpC,IAAIgC,KAAKnC,IAAI,GAAG,KAAKH,KAAKkE,MAAM,KAAKnF,qBAAqB4F,OAAO,EAAE;gBACjED,QAAQnC,IAAI,CAACvC;YACf;QACF;QAEA,OAAO0E;IACT;IAEA;;;;GAIC,GACDE,gBAUE;QACA,IAAIC,YAAY;QAChB,IAAIC,cAAc;QAClB,IAAIC,eAAe;QACnB,IAAIC,iBAAiB;QAErB,KAAK,MAAM1C,QAAQ,IAAI,CAAChD,aAAa,CAAC4B,MAAM,GAAI;YAC9C2D,aAAavC,KAAKnC,IAAI;YACtB4E,eAAehC,KAAKkC,GAAG,CAACF,cAAczC,KAAKnC,IAAI;QACjD;QAEA,KAAK,MAAMM,cAAc,IAAI,CAAClB,oBAAoB,CAAC2B,MAAM,GAAI;YAC3D4D,cAAc/B,KAAKkC,GAAG,CAACH,aAAarE,WAAWN,IAAI;QACrD;QAEA,KAAK,MAAMH,QAAQ,IAAI,CAACX,KAAK,CAAC6B,MAAM,GAAI;YACtC,IAAIlB,KAAKkE,MAAM,KAAKnF,qBAAqBoF,SAAS,EAAE;gBAClDa;YACF;QACF;QAEA,MAAME,YAAY,IAAI,CAAC7F,KAAK,CAACc,IAAI;QAEjC,OAAO;YACL+E;YACAL;YACAC;YACAC;YACAI,aAAaD,YAAY,IAAIL,YAAYK,YAAY;YACrDE,cAAcF,YAAY,IAAIL,YAAYK,YAAY;YACtDG,gBAAgB,IAAI,CAACvB,aAAa,GAAGR,MAAM;YAC3CgC,kBAAkB,IAAI,CAACb,eAAe,GAAGnB,MAAM;YAC/CiC,oBAAoBP;QACtB;IACF;IAEA;;;;;;GAMC,GACDQ,aAAalF,MAAc,EAAE4D,MAA4B,EAAQ;QAC/D,MAAMlE,OAAO,IAAI,CAACX,KAAK,CAACkB,GAAG,CAACD;QAC5B,IAAI,CAACN,MAAM;YACT,MAAM,IAAIhB,qBAAqB,CAAC,4BAA4B,EAAEsB,OAAO,WAAW,CAAC;QACnF;QAEA,oEAAoE;QACpE,IAAI,kBAAkBN,QAAQ,OAAOA,KAAKwF,YAAY,KAAK,YAAY;YACpExF,KAAawF,YAAY,CAACtB;QAC7B,OAAO;YACL,gFAAgF;YAC/ElE,KAAakE,MAAM,GAAGA;QACzB;QAEA,wBAAwB;QACxB,IAAIA,WAAWnF,qBAAqBoF,SAAS,EAAE;YAC7C,IAAI,CAAC1E,cAAc,CAAC8B,GAAG,CAACjB;QAC1B,OAAO;YACL,IAAI,CAACb,cAAc,CAACkB,MAAM,CAACL;QAC7B;IACF;IAEA;;GAEC,GACDmF,QAAc;QACZ,IAAI,CAACpG,KAAK,CAACoG,KAAK;QAChB,IAAI,CAACnG,aAAa,CAACmG,KAAK;QACxB,IAAI,CAAClG,oBAAoB,CAACkG,KAAK;QAC/B,IAAI,CAAChG,cAAc,CAACgG,KAAK;IAC3B;IAEA;;;;GAIC,GACDC,WAAqB;QACnB,MAAMC,SAAmB,EAAE;QAE3B,mCAAmC;QACnC,KAAK,MAAM,CAACrF,QAAQgC,KAAK,IAAI,IAAI,CAAChD,aAAa,CAAE;YAC/C,IAAI,CAAC,IAAI,CAACD,KAAK,CAACY,GAAG,CAACK,SAAS;gBAC3BqF,OAAOpD,IAAI,CAAC,CAAC,2CAA2C,EAAEjC,QAAQ;YACpE;YAEA,KAAK,MAAMI,SAAS4B,KAAM;gBACxB,IAAI,CAAC,IAAI,CAACjD,KAAK,CAACY,GAAG,CAACS,QAAQ;oBAC1BiF,OAAOpD,IAAI,CAAC,CAAC,KAAK,EAAEjC,OAAO,+BAA+B,EAAEI,OAAO;gBACrE;gBAEA,0BAA0B;gBAC1B,MAAMkF,cAAc,IAAI,CAACrG,oBAAoB,CAACgB,GAAG,CAACG;gBAClD,IAAI,CAACkF,aAAa3F,IAAIK,SAAS;oBAC7BqF,OAAOpD,IAAI,CAAC,CAAC,oCAAoC,EAAEjC,OAAO,IAAI,EAAEI,OAAO;gBACzE;YACF;QACF;QAEA,OAAOiF;IACT;AACF"}