{"version":3,"file":"flag-dependencies.mjs","sources":["../../../../src/lib/flags/advanced/flag-dependencies.ts"],"sourcesContent":["/**\n * @fileoverview Flag dependency resolution and management.\n *\n * Provides comprehensive dependency handling:\n * - Prerequisite flags (requires)\n * - Conflicting flags (conflicts)\n * - Implied flags (implies)\n * - Flag supersession (supersedes)\n * - Circular dependency detection\n * - Dependency graph visualization\n *\n * @module flags/advanced/flag-dependencies\n *\n * @example\n * ```typescript\n * const resolver = new DependencyResolver();\n *\n * const dependencies: FlagDependency[] = [\n *   { sourceFlag: 'advanced-search', targetFlag: 'search', type: 'requires' },\n *   { sourceFlag: 'new-ui', targetFlag: 'old-ui', type: 'conflicts' },\n *   { sourceFlag: 'premium', targetFlag: 'analytics', type: 'implies' },\n * ];\n *\n * resolver.buildGraph(dependencies);\n *\n * const result = resolver.resolveDependencies('advanced-search', flagEvaluator);\n * if (result.satisfied) {\n *   // Enable the flag\n * }\n * ```\n */\n\nimport type {\n  FlagDependency,\n  FlagId,\n  VariantId,\n  DependencyType,\n  JsonValue,\n} from './types';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Result of dependency resolution.\n */\nexport interface DependencyResolutionResult {\n  /** Whether all dependencies are satisfied */\n  readonly satisfied: boolean;\n  /** Unsatisfied dependencies */\n  readonly unsatisfied: readonly UnsatisfiedDependency[];\n  /** Order in which flags should be evaluated */\n  readonly evaluationOrder: readonly FlagId[];\n  /** Detected circular dependencies */\n  readonly circularDependencies: readonly FlagId[][];\n  /** Implied flags to enable */\n  readonly implied: readonly FlagId[];\n  /** Conflicting flags that are currently enabled */\n  readonly conflicts: readonly FlagId[];\n}\n\n/**\n * Details of an unsatisfied dependency.\n */\nexport interface UnsatisfiedDependency {\n  /** The flag with the unsatisfied dependency */\n  readonly sourceFlag: FlagId;\n  /** The target flag that failed */\n  readonly targetFlag: FlagId;\n  /** Type of dependency */\n  readonly type: DependencyType;\n  /** Reason for failure */\n  readonly reason: string;\n  /** Required variant (if applicable) */\n  readonly requiredVariant?: VariantId;\n  /** Actual variant (if applicable) */\n  readonly actualVariant?: VariantId;\n}\n\n/**\n * Node in the dependency graph.\n */\ninterface DependencyNode {\n  readonly flagId: FlagId;\n  readonly dependencies: Map<FlagId, FlagDependency>;\n  readonly dependents: Set<FlagId>;\n}\n\n/**\n * Function type for evaluating a flag's state.\n */\nexport type FlagEvaluator = (\n  flagId: FlagId\n) => { enabled: boolean; variantId?: VariantId; value?: JsonValue };\n\n// ============================================================================\n// Dependency Resolver\n// ============================================================================\n\n/**\n * Resolves and validates flag dependencies.\n */\nexport class DependencyResolver {\n  private graph = new Map<FlagId, DependencyNode>();\n  private dependencies: FlagDependency[] = [];\n\n  /**\n   * Build the dependency graph from a list of dependencies.\n   */\n  buildGraph(dependencies: readonly FlagDependency[]): void {\n    this.dependencies = [...dependencies];\n    this.graph.clear();\n\n    // Create nodes for all flags\n    for (const dep of dependencies) {\n      this.ensureNode(dep.sourceFlag);\n      this.ensureNode(dep.targetFlag);\n    }\n\n    // Add dependencies to nodes\n    for (const dep of dependencies) {\n      const sourceNode = this.graph.get(dep.sourceFlag);\n      if (sourceNode != null) {\n        sourceNode.dependencies.set(dep.targetFlag, dep);\n      }\n\n      const targetNode = this.graph.get(dep.targetFlag);\n      if (targetNode != null) {\n        targetNode.dependents.add(dep.sourceFlag);\n      }\n    }\n  }\n\n  /**\n   * Add a dependency to the graph.\n   */\n  addDependency(dependency: FlagDependency): void {\n    this.dependencies.push(dependency);\n\n    const sourceNode = this.ensureNode(dependency.sourceFlag);\n    sourceNode.dependencies.set(dependency.targetFlag, dependency);\n\n    const targetNode = this.ensureNode(dependency.targetFlag);\n    targetNode.dependents.add(dependency.sourceFlag);\n  }\n\n  /**\n   * Remove a dependency from the graph.\n   */\n  removeDependency(sourceFlag: FlagId, targetFlag: FlagId): void {\n    const sourceNode = this.graph.get(sourceFlag);\n    if (sourceNode) {\n      sourceNode.dependencies.delete(targetFlag);\n    }\n\n    const targetNode = this.graph.get(targetFlag);\n    if (targetNode) {\n      targetNode.dependents.delete(sourceFlag);\n    }\n\n    this.dependencies = this.dependencies.filter(\n      (d) => !(d.sourceFlag === sourceFlag && d.targetFlag === targetFlag)\n    );\n  }\n\n  /**\n   * Resolve all dependencies for a flag.\n   */\n  resolveDependencies(\n    flagId: FlagId,\n    evaluator: FlagEvaluator\n  ): DependencyResolutionResult {\n    const unsatisfied: UnsatisfiedDependency[] = [];\n    const implied: FlagId[] = [];\n    const conflicts: FlagId[] = [];\n\n    // Check for circular dependencies\n    const circularDependencies = this.detectCircularDependencies();\n    if (circularDependencies.some((cycle) => cycle.includes(flagId))) {\n      return {\n        satisfied: false,\n        unsatisfied: [\n          {\n            sourceFlag: flagId,\n            targetFlag: flagId,\n            type: 'requires',\n            reason: 'Circular dependency detected',\n          },\n        ],\n        evaluationOrder: [],\n        circularDependencies,\n        implied: [],\n        conflicts: [],\n      };\n    }\n\n    // Get evaluation order\n    const evaluationOrder = this.getEvaluationOrder(flagId);\n\n    // Check dependencies\n    const node = this.graph.get(flagId);\n    if (node) {\n      for (const [targetId, dep] of node.dependencies) {\n        const result = this.checkDependency(dep, evaluator);\n        if (!result.satisfied && result.unsatisfied != null) {\n          unsatisfied.push(result.unsatisfied);\n        }\n        if (result.implied === true) {\n          implied.push(targetId);\n        }\n        if (result.conflict === true) {\n          conflicts.push(targetId);\n        }\n      }\n    }\n\n    return {\n      satisfied: unsatisfied.length === 0 && conflicts.length === 0,\n      unsatisfied,\n      evaluationOrder,\n      circularDependencies,\n      implied,\n      conflicts,\n    };\n  }\n\n  /**\n   * Detect circular dependencies in the graph.\n   */\n  detectCircularDependencies(): FlagId[][] {\n    const cycles: FlagId[][] = [];\n    const visited = new Set<FlagId>();\n    const recursionStack = new Set<FlagId>();\n    const currentPath: FlagId[] = [];\n\n    const dfs = (nodeId: FlagId): void => {\n      visited.add(nodeId);\n      recursionStack.add(nodeId);\n      currentPath.push(nodeId);\n\n      const node = this.graph.get(nodeId);\n      if (node) {\n        for (const targetId of node.dependencies.keys()) {\n          if (!visited.has(targetId)) {\n            dfs(targetId);\n          } else if (recursionStack.has(targetId)) {\n            // Found a cycle\n            const cycleStart = currentPath.indexOf(targetId);\n            if (cycleStart !== -1) {\n              cycles.push([...currentPath.slice(cycleStart), targetId]);\n            }\n          }\n        }\n      }\n\n      currentPath.pop();\n      recursionStack.delete(nodeId);\n    };\n\n    for (const nodeId of this.graph.keys()) {\n      if (!visited.has(nodeId)) {\n        dfs(nodeId);\n      }\n    }\n\n    return cycles;\n  }\n\n  /**\n   * Get the evaluation order for a flag (topological sort).\n   */\n  getEvaluationOrder(flagId: FlagId): FlagId[] {\n    const order: FlagId[] = [];\n    const visited = new Set<FlagId>();\n\n    const visit = (nodeId: FlagId): void => {\n      if (visited.has(nodeId)) return;\n      visited.add(nodeId);\n\n      const node = this.graph.get(nodeId);\n      if (node) {\n        for (const depId of node.dependencies.keys()) {\n          visit(depId);\n        }\n      }\n\n      order.push(nodeId);\n    };\n\n    visit(flagId);\n    return order;\n  }\n\n  /**\n   * Get all flags that depend on a given flag.\n   */\n  getDependents(flagId: FlagId): FlagId[] {\n    const node = this.graph.get(flagId);\n    return node ? Array.from(node.dependents) : [];\n  }\n\n  /**\n   * Get all dependencies of a flag.\n   */\n  getDependencies(flagId: FlagId): FlagDependency[] {\n    const node = this.graph.get(flagId);\n    return node ? Array.from(node.dependencies.values()) : [];\n  }\n\n  /**\n   * Get all flags in the graph.\n   */\n  getAllFlags(): FlagId[] {\n    return Array.from(this.graph.keys());\n  }\n\n  /**\n   * Check if a flag has any dependencies.\n   */\n  hasDependencies(flagId: FlagId): boolean {\n    const node = this.graph.get(flagId);\n    return node ? node.dependencies.size > 0 : false;\n  }\n\n  /**\n   * Check if a flag has any dependents.\n   */\n  hasDependents(flagId: FlagId): boolean {\n    const node = this.graph.get(flagId);\n    return node ? node.dependents.size > 0 : false;\n  }\n\n  /**\n   * Export the graph for visualization.\n   */\n  exportGraph(): {\n    nodes: Array<{ id: FlagId; dependencyCount: number; dependentCount: number }>;\n    edges: Array<{ source: FlagId; target: FlagId; type: DependencyType }>;\n  } {\n    const nodes = Array.from(this.graph.values()).map((node) => ({\n      id: node.flagId,\n      dependencyCount: node.dependencies.size,\n      dependentCount: node.dependents.size,\n    }));\n\n    const edges = this.dependencies.map((dep) => ({\n      source: dep.sourceFlag,\n      target: dep.targetFlag,\n      type: dep.type,\n    }));\n\n    return { nodes, edges };\n  }\n\n  /**\n   * Clear the dependency graph.\n   */\n  clear(): void {\n    this.graph.clear();\n    this.dependencies = [];\n  }\n\n  private ensureNode(flagId: FlagId): DependencyNode {\n    if (!this.graph.has(flagId)) {\n      this.graph.set(flagId, {\n        flagId,\n        dependencies: new Map(),\n        dependents: new Set(),\n      });\n    }\n    const node = this.graph.get(flagId);\n    if (node == null) {\n      throw new Error(`Failed to ensure node for flag ${flagId}`);\n    }\n    return node;\n  }\n\n  private checkDependency(\n    dep: FlagDependency,\n    evaluator: FlagEvaluator\n  ): {\n    satisfied: boolean;\n    unsatisfied?: UnsatisfiedDependency;\n    implied?: boolean;\n    conflict?: boolean;\n  } {\n    const targetState = evaluator(dep.targetFlag);\n\n    switch (dep.type) {\n      case 'requires':\n        // Target flag must be enabled\n        if (!targetState.enabled) {\n          return {\n            satisfied: false,\n            unsatisfied: {\n              sourceFlag: dep.sourceFlag,\n              targetFlag: dep.targetFlag,\n              type: dep.type,\n              reason: `Required flag '${dep.targetFlag}' is not enabled`,\n              requiredVariant: dep.requiredVariant,\n            },\n          };\n        }\n        // Check variant if specified\n        if (\n          dep.requiredVariant != null &&\n          targetState.variantId !== dep.requiredVariant\n        ) {\n          return {\n            satisfied: false,\n            unsatisfied: {\n              sourceFlag: dep.sourceFlag,\n              targetFlag: dep.targetFlag,\n              type: dep.type,\n              reason: `Required variant '${dep.requiredVariant}' not matched`,\n              requiredVariant: dep.requiredVariant,\n              actualVariant: targetState.variantId,\n            },\n          };\n        }\n        return { satisfied: true };\n\n      case 'conflicts':\n        // Target flag must NOT be enabled\n        if (targetState.enabled) {\n          return {\n            satisfied: false,\n            conflict: true,\n            unsatisfied: {\n              sourceFlag: dep.sourceFlag,\n              targetFlag: dep.targetFlag,\n              type: dep.type,\n              reason: `Conflicting flag '${dep.targetFlag}' is enabled`,\n            },\n          };\n        }\n        return { satisfied: true };\n\n      case 'implies':\n        // Target flag should be enabled (but not a hard requirement)\n        if (!targetState.enabled) {\n          return { satisfied: true, implied: true };\n        }\n        return { satisfied: true };\n\n      case 'supersedes':\n        // This flag takes precedence over the target\n        // No validation needed, just informational\n        return { satisfied: true };\n\n      default:\n        return { satisfied: true };\n    }\n  }\n}\n\n// ============================================================================\n// Dependency Builder\n// ============================================================================\n\n/**\n * Fluent builder for creating flag dependencies.\n */\nexport class DependencyBuilder {\n  private readonly sourceFlag: FlagId;\n  private dependencies: FlagDependency[] = [];\n\n  constructor(sourceFlag: FlagId) {\n    this.sourceFlag = sourceFlag;\n  }\n\n  /**\n   * Add a \"requires\" dependency.\n   */\n  requires(\n    targetFlag: FlagId,\n    options?: { variant?: VariantId; description?: string }\n  ): this {\n    this.dependencies.push({\n      sourceFlag: this.sourceFlag,\n      targetFlag,\n      type: 'requires',\n      requiredVariant: options?.variant,\n      description: options?.description,\n    });\n    return this;\n  }\n\n  /**\n   * Add a \"conflicts\" dependency.\n   */\n  conflicts(targetFlag: FlagId, description?: string): this {\n    this.dependencies.push({\n      sourceFlag: this.sourceFlag,\n      targetFlag,\n      type: 'conflicts',\n      description,\n    });\n    return this;\n  }\n\n  /**\n   * Add an \"implies\" dependency.\n   */\n  implies(targetFlag: FlagId, description?: string): this {\n    this.dependencies.push({\n      sourceFlag: this.sourceFlag,\n      targetFlag,\n      type: 'implies',\n      description,\n    });\n    return this;\n  }\n\n  /**\n   * Add a \"supersedes\" dependency.\n   */\n  supersedes(targetFlag: FlagId, description?: string): this {\n    this.dependencies.push({\n      sourceFlag: this.sourceFlag,\n      targetFlag,\n      type: 'supersedes',\n      description,\n    });\n    return this;\n  }\n\n  /**\n   * Build the dependencies.\n   */\n  build(): FlagDependency[] {\n    return [...this.dependencies];\n  }\n}\n\n/**\n * Create a dependency builder for a flag.\n */\nexport function createDependencies(sourceFlag: FlagId): DependencyBuilder {\n  return new DependencyBuilder(sourceFlag);\n}\n\n// ============================================================================\n// Dependency Validation Utilities\n// ============================================================================\n\n/**\n * Validate a set of dependencies.\n */\nexport function validateDependencies(\n  dependencies: readonly FlagDependency[]\n): {\n  valid: boolean;\n  errors: string[];\n  warnings: string[];\n} {\n  const errors: string[] = [];\n  const warnings: string[] = [];\n\n  // Build a temporary resolver for validation\n  const resolver = new DependencyResolver();\n  resolver.buildGraph(dependencies);\n\n  // Check for circular dependencies\n  const cycles = resolver.detectCircularDependencies();\n  for (const cycle of cycles) {\n    errors.push(`Circular dependency detected: ${cycle.join(' -> ')}`);\n  }\n\n  // Check for conflicting dependency types\n  const dependencyMap = new Map<string, FlagDependency[]>();\n  for (const dep of dependencies) {\n    const key = `${dep.sourceFlag}:${dep.targetFlag}`;\n    const existing = dependencyMap.get(key) ?? [];\n    existing.push(dep);\n    dependencyMap.set(key, existing);\n  }\n\n  for (const [key, deps] of dependencyMap) {\n    if (deps.length > 1) {\n      const types = deps.map((d) => d.type);\n      if (types.includes('requires') && types.includes('conflicts')) {\n        errors.push(\n          `Flag ${key.split(':')[0]} both requires and conflicts with ${key.split(':')[1]}`\n        );\n      }\n    }\n  }\n\n  // Check for superseded flags that are also required\n  const supersededFlags = new Set(\n    dependencies.filter((d) => d.type === 'supersedes').map((d) => d.targetFlag)\n  );\n  for (const dep of dependencies) {\n    if (dep.type === 'requires' && supersededFlags.has(dep.targetFlag)) {\n      warnings.push(\n        `Flag '${dep.sourceFlag}' requires superseded flag '${dep.targetFlag}'`\n      );\n    }\n  }\n\n  return {\n    valid: errors.length === 0,\n    errors,\n    warnings,\n  };\n}\n\n/**\n * Generate a DOT representation of the dependency graph for visualization.\n */\nexport function generateDependencyDOT(\n  dependencies: readonly FlagDependency[]\n): string {\n  const lines = ['digraph FlagDependencies {'];\n  lines.push('  rankdir=TB;');\n  lines.push('  node [shape=box];');\n  lines.push('');\n\n  // Collect all nodes\n  const nodes = new Set<string>();\n  for (const dep of dependencies) {\n    nodes.add(dep.sourceFlag);\n    nodes.add(dep.targetFlag);\n  }\n\n  // Add nodes\n  for (const node of nodes) {\n    lines.push(`  \"${node}\";`);\n  }\n  lines.push('');\n\n  // Add edges with styles based on type\n  const edgeStyles: Record<DependencyType, string> = {\n    requires: 'style=solid color=blue',\n    conflicts: 'style=dashed color=red',\n    implies: 'style=dotted color=green',\n    supersedes: 'style=bold color=orange',\n  };\n\n  for (const dep of dependencies) {\n    const style = edgeStyles[dep.type] ?? '';\n    lines.push(`  \"${dep.sourceFlag}\" -> \"${dep.targetFlag}\" [${style} label=\"${dep.type}\"];`);\n  }\n\n  lines.push('}');\n  return lines.join('\\n');\n}\n\n// ============================================================================\n// Singleton Instance\n// ============================================================================\n\nlet instance: DependencyResolver | null = null;\n\n/**\n * Get the singleton dependency resolver instance.\n */\nexport function getDependencyResolver(): DependencyResolver {\n  instance ??= new DependencyResolver();\n  return instance;\n}\n\n/**\n * Reset the singleton instance.\n */\nexport function resetDependencyResolver(): void {\n  if (instance) {\n    instance.clear();\n  }\n  instance = null;\n}\n"],"names":["DependencyResolver","dependencies","dep","sourceNode","targetNode","dependency","sourceFlag","targetFlag","d","flagId","evaluator","unsatisfied","implied","conflicts","circularDependencies","cycle","evaluationOrder","node","targetId","result","cycles","visited","recursionStack","currentPath","dfs","nodeId","cycleStart","order","visit","depId","nodes","edges","targetState","DependencyBuilder","options","description","createDependencies","validateDependencies","errors","warnings","resolver","dependencyMap","key","existing","deps","types","supersededFlags","generateDependencyDOT","lines","edgeStyles","style","instance","getDependencyResolver","resetDependencyResolver"],"mappings":"AAuGO,MAAMA,EAAmB;AAAA,EACtB,4BAAY,IAAA;AAAA,EACZ,eAAiC,CAAA;AAAA;AAAA;AAAA;AAAA,EAKzC,WAAWC,GAA+C;AACxD,SAAK,eAAe,CAAC,GAAGA,CAAY,GACpC,KAAK,MAAM,MAAA;AAGX,eAAWC,KAAOD;AAChB,WAAK,WAAWC,EAAI,UAAU,GAC9B,KAAK,WAAWA,EAAI,UAAU;AAIhC,eAAWA,KAAOD,GAAc;AAC9B,YAAME,IAAa,KAAK,MAAM,IAAID,EAAI,UAAU;AAChD,MACEC,GAAW,aAAa,IAAID,EAAI,YAAYA,CAAG;AAGjD,YAAME,IAAa,KAAK,MAAM,IAAIF,EAAI,UAAU;AAChD,MACEE,GAAW,WAAW,IAAIF,EAAI,UAAU;AAAA,IAE5C;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,cAAcG,GAAkC;AAC9C,SAAK,aAAa,KAAKA,CAAU,GAEd,KAAK,WAAWA,EAAW,UAAU,EAC7C,aAAa,IAAIA,EAAW,YAAYA,CAAU,GAE1C,KAAK,WAAWA,EAAW,UAAU,EAC7C,WAAW,IAAIA,EAAW,UAAU;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA,EAKA,iBAAiBC,GAAoBC,GAA0B;AAC7D,UAAMJ,IAAa,KAAK,MAAM,IAAIG,CAAU;AAC5C,IAAIH,KACFA,EAAW,aAAa,OAAOI,CAAU;AAG3C,UAAMH,IAAa,KAAK,MAAM,IAAIG,CAAU;AAC5C,IAAIH,KACFA,EAAW,WAAW,OAAOE,CAAU,GAGzC,KAAK,eAAe,KAAK,aAAa;AAAA,MACpC,CAACE,MAAM,EAAEA,EAAE,eAAeF,KAAcE,EAAE,eAAeD;AAAA,IAAA;AAAA,EAE7D;AAAA;AAAA;AAAA;AAAA,EAKA,oBACEE,GACAC,GAC4B;AAC5B,UAAMC,IAAuC,CAAA,GACvCC,IAAoB,CAAA,GACpBC,IAAsB,CAAA,GAGtBC,IAAuB,KAAK,2BAAA;AAClC,QAAIA,EAAqB,KAAK,CAACC,MAAUA,EAAM,SAASN,CAAM,CAAC;AAC7D,aAAO;AAAA,QACL,WAAW;AAAA,QACX,aAAa;AAAA,UACX;AAAA,YACE,YAAYA;AAAA,YACZ,YAAYA;AAAA,YACZ,MAAM;AAAA,YACN,QAAQ;AAAA,UAAA;AAAA,QACV;AAAA,QAEF,iBAAiB,CAAA;AAAA,QACjB,sBAAAK;AAAA,QACA,SAAS,CAAA;AAAA,QACT,WAAW,CAAA;AAAA,MAAC;AAKhB,UAAME,IAAkB,KAAK,mBAAmBP,CAAM,GAGhDQ,IAAO,KAAK,MAAM,IAAIR,CAAM;AAClC,QAAIQ;AACF,iBAAW,CAACC,GAAUhB,CAAG,KAAKe,EAAK,cAAc;AAC/C,cAAME,IAAS,KAAK,gBAAgBjB,GAAKQ,CAAS;AAClD,QAAI,CAACS,EAAO,aAAaA,EAAO,eAAe,QAC7CR,EAAY,KAAKQ,EAAO,WAAW,GAEjCA,EAAO,YAAY,MACrBP,EAAQ,KAAKM,CAAQ,GAEnBC,EAAO,aAAa,MACtBN,EAAU,KAAKK,CAAQ;AAAA,MAE3B;AAGF,WAAO;AAAA,MACL,WAAWP,EAAY,WAAW,KAAKE,EAAU,WAAW;AAAA,MAC5D,aAAAF;AAAA,MACA,iBAAAK;AAAA,MACA,sBAAAF;AAAA,MACA,SAAAF;AAAA,MACA,WAAAC;AAAA,IAAA;AAAA,EAEJ;AAAA;AAAA;AAAA;AAAA,EAKA,6BAAyC;AACvC,UAAMO,IAAqB,CAAA,GACrBC,wBAAc,IAAA,GACdC,wBAAqB,IAAA,GACrBC,IAAwB,CAAA,GAExBC,IAAM,CAACC,MAAyB;AACpC,MAAAJ,EAAQ,IAAII,CAAM,GAClBH,EAAe,IAAIG,CAAM,GACzBF,EAAY,KAAKE,CAAM;AAEvB,YAAMR,IAAO,KAAK,MAAM,IAAIQ,CAAM;AAClC,UAAIR;AACF,mBAAWC,KAAYD,EAAK,aAAa,KAAA;AACvC,cAAI,CAACI,EAAQ,IAAIH,CAAQ;AACvB,YAAAM,EAAIN,CAAQ;AAAA,mBACHI,EAAe,IAAIJ,CAAQ,GAAG;AAEvC,kBAAMQ,IAAaH,EAAY,QAAQL,CAAQ;AAC/C,YAAIQ,MAAe,MACjBN,EAAO,KAAK,CAAC,GAAGG,EAAY,MAAMG,CAAU,GAAGR,CAAQ,CAAC;AAAA,UAE5D;AAAA;AAIJ,MAAAK,EAAY,IAAA,GACZD,EAAe,OAAOG,CAAM;AAAA,IAC9B;AAEA,eAAWA,KAAU,KAAK,MAAM,KAAA;AAC9B,MAAKJ,EAAQ,IAAII,CAAM,KACrBD,EAAIC,CAAM;AAId,WAAOL;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,mBAAmBX,GAA0B;AAC3C,UAAMkB,IAAkB,CAAA,GAClBN,wBAAc,IAAA,GAEdO,IAAQ,CAACH,MAAyB;AACtC,UAAIJ,EAAQ,IAAII,CAAM,EAAG;AACzB,MAAAJ,EAAQ,IAAII,CAAM;AAElB,YAAMR,IAAO,KAAK,MAAM,IAAIQ,CAAM;AAClC,UAAIR;AACF,mBAAWY,KAASZ,EAAK,aAAa,KAAA;AACpC,UAAAW,EAAMC,CAAK;AAIf,MAAAF,EAAM,KAAKF,CAAM;AAAA,IACnB;AAEA,WAAAG,EAAMnB,CAAM,GACLkB;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,cAAclB,GAA0B;AACtC,UAAMQ,IAAO,KAAK,MAAM,IAAIR,CAAM;AAClC,WAAOQ,IAAO,MAAM,KAAKA,EAAK,UAAU,IAAI,CAAA;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgBR,GAAkC;AAChD,UAAMQ,IAAO,KAAK,MAAM,IAAIR,CAAM;AAClC,WAAOQ,IAAO,MAAM,KAAKA,EAAK,aAAa,OAAA,CAAQ,IAAI,CAAA;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA,EAKA,cAAwB;AACtB,WAAO,MAAM,KAAK,KAAK,MAAM,MAAM;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgBR,GAAyB;AACvC,UAAMQ,IAAO,KAAK,MAAM,IAAIR,CAAM;AAClC,WAAOQ,IAAOA,EAAK,aAAa,OAAO,IAAI;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA,EAKA,cAAcR,GAAyB;AACrC,UAAMQ,IAAO,KAAK,MAAM,IAAIR,CAAM;AAClC,WAAOQ,IAAOA,EAAK,WAAW,OAAO,IAAI;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA,EAKA,cAGE;AACA,UAAMa,IAAQ,MAAM,KAAK,KAAK,MAAM,QAAQ,EAAE,IAAI,CAACb,OAAU;AAAA,MAC3D,IAAIA,EAAK;AAAA,MACT,iBAAiBA,EAAK,aAAa;AAAA,MACnC,gBAAgBA,EAAK,WAAW;AAAA,IAAA,EAChC,GAEIc,IAAQ,KAAK,aAAa,IAAI,CAAC7B,OAAS;AAAA,MAC5C,QAAQA,EAAI;AAAA,MACZ,QAAQA,EAAI;AAAA,MACZ,MAAMA,EAAI;AAAA,IAAA,EACV;AAEF,WAAO,EAAE,OAAA4B,GAAO,OAAAC,EAAA;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,MAAM,MAAA,GACX,KAAK,eAAe,CAAA;AAAA,EACtB;AAAA,EAEQ,WAAWtB,GAAgC;AACjD,IAAK,KAAK,MAAM,IAAIA,CAAM,KACxB,KAAK,MAAM,IAAIA,GAAQ;AAAA,MACrB,QAAAA;AAAA,MACA,kCAAkB,IAAA;AAAA,MAClB,gCAAgB,IAAA;AAAA,IAAI,CACrB;AAEH,UAAMQ,IAAO,KAAK,MAAM,IAAIR,CAAM;AAClC,QAAIQ,KAAQ;AACV,YAAM,IAAI,MAAM,kCAAkCR,CAAM,EAAE;AAE5D,WAAOQ;AAAA,EACT;AAAA,EAEQ,gBACNf,GACAQ,GAMA;AACA,UAAMsB,IAActB,EAAUR,EAAI,UAAU;AAE5C,YAAQA,EAAI,MAAA;AAAA,MACV,KAAK;AAEH,eAAK8B,EAAY,UAcf9B,EAAI,mBAAmB,QACvB8B,EAAY,cAAc9B,EAAI,kBAEvB;AAAA,UACL,WAAW;AAAA,UACX,aAAa;AAAA,YACX,YAAYA,EAAI;AAAA,YAChB,YAAYA,EAAI;AAAA,YAChB,MAAMA,EAAI;AAAA,YACV,QAAQ,qBAAqBA,EAAI,eAAe;AAAA,YAChD,iBAAiBA,EAAI;AAAA,YACrB,eAAe8B,EAAY;AAAA,UAAA;AAAA,QAC7B,IAGG,EAAE,WAAW,GAAA,IA5BX;AAAA,UACL,WAAW;AAAA,UACX,aAAa;AAAA,YACX,YAAY9B,EAAI;AAAA,YAChB,YAAYA,EAAI;AAAA,YAChB,MAAMA,EAAI;AAAA,YACV,QAAQ,kBAAkBA,EAAI,UAAU;AAAA,YACxC,iBAAiBA,EAAI;AAAA,UAAA;AAAA,QACvB;AAAA,MAsBN,KAAK;AAEH,eAAI8B,EAAY,UACP;AAAA,UACL,WAAW;AAAA,UACX,UAAU;AAAA,UACV,aAAa;AAAA,YACX,YAAY9B,EAAI;AAAA,YAChB,YAAYA,EAAI;AAAA,YAChB,MAAMA,EAAI;AAAA,YACV,QAAQ,qBAAqBA,EAAI,UAAU;AAAA,UAAA;AAAA,QAC7C,IAGG,EAAE,WAAW,GAAA;AAAA,MAEtB,KAAK;AAEH,eAAK8B,EAAY,UAGV,EAAE,WAAW,GAAA,IAFX,EAAE,WAAW,IAAM,SAAS,GAAA;AAAA,MAIvC,KAAK;AAGH,eAAO,EAAE,WAAW,GAAA;AAAA,MAEtB;AACE,eAAO,EAAE,WAAW,GAAA;AAAA,IAAK;AAAA,EAE/B;AACF;AASO,MAAMC,EAAkB;AAAA,EACZ;AAAA,EACT,eAAiC,CAAA;AAAA,EAEzC,YAAY3B,GAAoB;AAC9B,SAAK,aAAaA;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA,EAKA,SACEC,GACA2B,GACM;AACN,gBAAK,aAAa,KAAK;AAAA,MACrB,YAAY,KAAK;AAAA,MACjB,YAAA3B;AAAA,MACA,MAAM;AAAA,MACN,iBAAiB2B,GAAS;AAAA,MAC1B,aAAaA,GAAS;AAAA,IAAA,CACvB,GACM;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,UAAU3B,GAAoB4B,GAA4B;AACxD,gBAAK,aAAa,KAAK;AAAA,MACrB,YAAY,KAAK;AAAA,MACjB,YAAA5B;AAAA,MACA,MAAM;AAAA,MACN,aAAA4B;AAAA,IAAA,CACD,GACM;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQ5B,GAAoB4B,GAA4B;AACtD,gBAAK,aAAa,KAAK;AAAA,MACrB,YAAY,KAAK;AAAA,MACjB,YAAA5B;AAAA,MACA,MAAM;AAAA,MACN,aAAA4B;AAAA,IAAA,CACD,GACM;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW5B,GAAoB4B,GAA4B;AACzD,gBAAK,aAAa,KAAK;AAAA,MACrB,YAAY,KAAK;AAAA,MACjB,YAAA5B;AAAA,MACA,MAAM;AAAA,MACN,aAAA4B;AAAA,IAAA,CACD,GACM;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAA0B;AACxB,WAAO,CAAC,GAAG,KAAK,YAAY;AAAA,EAC9B;AACF;AAKO,SAASC,EAAmB9B,GAAuC;AACxE,SAAO,IAAI2B,EAAkB3B,CAAU;AACzC;AASO,SAAS+B,EACdpC,GAKA;AACA,QAAMqC,IAAmB,CAAA,GACnBC,IAAqB,CAAA,GAGrBC,IAAW,IAAIxC,EAAA;AACrB,EAAAwC,EAAS,WAAWvC,CAAY;AAGhC,QAAMmB,IAASoB,EAAS,2BAAA;AACxB,aAAWzB,KAASK;AAClB,IAAAkB,EAAO,KAAK,iCAAiCvB,EAAM,KAAK,MAAM,CAAC,EAAE;AAInE,QAAM0B,wBAAoB,IAAA;AAC1B,aAAWvC,KAAOD,GAAc;AAC9B,UAAMyC,IAAM,GAAGxC,EAAI,UAAU,IAAIA,EAAI,UAAU,IACzCyC,IAAWF,EAAc,IAAIC,CAAG,KAAK,CAAA;AAC3C,IAAAC,EAAS,KAAKzC,CAAG,GACjBuC,EAAc,IAAIC,GAAKC,CAAQ;AAAA,EACjC;AAEA,aAAW,CAACD,GAAKE,CAAI,KAAKH;AACxB,QAAIG,EAAK,SAAS,GAAG;AACnB,YAAMC,IAAQD,EAAK,IAAI,CAACpC,MAAMA,EAAE,IAAI;AACpC,MAAIqC,EAAM,SAAS,UAAU,KAAKA,EAAM,SAAS,WAAW,KAC1DP,EAAO;AAAA,QACL,QAAQI,EAAI,MAAM,GAAG,EAAE,CAAC,CAAC,qCAAqCA,EAAI,MAAM,GAAG,EAAE,CAAC,CAAC;AAAA,MAAA;AAAA,IAGrF;AAIF,QAAMI,IAAkB,IAAI;AAAA,IAC1B7C,EAAa,OAAO,CAACO,MAAMA,EAAE,SAAS,YAAY,EAAE,IAAI,CAACA,MAAMA,EAAE,UAAU;AAAA,EAAA;AAE7E,aAAWN,KAAOD;AAChB,IAAIC,EAAI,SAAS,cAAc4C,EAAgB,IAAI5C,EAAI,UAAU,KAC/DqC,EAAS;AAAA,MACP,SAASrC,EAAI,UAAU,+BAA+BA,EAAI,UAAU;AAAA,IAAA;AAK1E,SAAO;AAAA,IACL,OAAOoC,EAAO,WAAW;AAAA,IACzB,QAAAA;AAAA,IACA,UAAAC;AAAA,EAAA;AAEJ;AAKO,SAASQ,EACd9C,GACQ;AACR,QAAM+C,IAAQ,CAAC,4BAA4B;AAC3C,EAAAA,EAAM,KAAK,eAAe,GAC1BA,EAAM,KAAK,qBAAqB,GAChCA,EAAM,KAAK,EAAE;AAGb,QAAMlB,wBAAY,IAAA;AAClB,aAAW5B,KAAOD;AAChB,IAAA6B,EAAM,IAAI5B,EAAI,UAAU,GACxB4B,EAAM,IAAI5B,EAAI,UAAU;AAI1B,aAAWe,KAAQa;AACjB,IAAAkB,EAAM,KAAK,MAAM/B,CAAI,IAAI;AAE3B,EAAA+B,EAAM,KAAK,EAAE;AAGb,QAAMC,IAA6C;AAAA,IACjD,UAAU;AAAA,IACV,WAAW;AAAA,IACX,SAAS;AAAA,IACT,YAAY;AAAA,EAAA;AAGd,aAAW/C,KAAOD,GAAc;AAC9B,UAAMiD,IAAQD,EAAW/C,EAAI,IAAI,KAAK;AACtC,IAAA8C,EAAM,KAAK,MAAM9C,EAAI,UAAU,SAASA,EAAI,UAAU,MAAMgD,CAAK,WAAWhD,EAAI,IAAI,KAAK;AAAA,EAC3F;AAEA,SAAA8C,EAAM,KAAK,GAAG,GACPA,EAAM,KAAK;AAAA,CAAI;AACxB;AAMA,IAAIG,IAAsC;AAKnC,SAASC,IAA4C;AAC1D,SAAAD,MAAa,IAAInD,EAAA,GACVmD;AACT;AAKO,SAASE,IAAgC;AAC9C,EAAIF,KACFA,EAAS,MAAA,GAEXA,IAAW;AACb;"}