{"version":3,"file":"flag-variants.mjs","sources":["../../../../src/lib/flags/advanced/flag-variants.ts"],"sourcesContent":["/**\n * @fileoverview Multi-variate flag management and variant selection.\n *\n * Provides comprehensive variant management including:\n * - Variant definition and validation\n * - Variant value type coercion\n * - Variant weighting for experiments\n * - Variant payload management\n *\n * @module flags/advanced/flag-variants\n *\n * @example\n * ```typescript\n * const manager = new VariantManager();\n *\n * const variants = [\n *   manager.createVariant('control', { value: false, isControl: true }),\n *   manager.createVariant('variant-a', { value: { buttonColor: 'blue' } }),\n *   manager.createVariant('variant-b', { value: { buttonColor: 'green' } }),\n * ];\n *\n * const selected = manager.selectVariant(variants, bucket, allocations);\n * ```\n */\n\nimport type { Variant, VariantId, VariantValueType, JsonValue, VariantAllocation } from './types';\n// import type { Mutable } from '../../utils/types';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Options for creating a variant.\n */\nexport interface CreateVariantOptions<T = JsonValue> {\n  /** Variant value */\n  readonly value: T;\n  /** Human-readable name */\n  readonly name?: string;\n  /** Description */\n  readonly description?: string;\n  /** Whether this is the control variant */\n  readonly isControl?: boolean;\n  /** Additional payload data */\n  readonly payload?: Record<string, JsonValue>;\n  /** File/config attachments */\n  readonly attachments?: string[];\n}\n\n/**\n * Variant with weight for traffic allocation.\n */\nexport interface WeightedVariant<T = JsonValue> extends Variant<T> {\n  /** Weight for traffic allocation (0-100) */\n  readonly weight: number;\n}\n\n/**\n * Variant statistics for experiments.\n */\nexport interface VariantStats {\n  /** Variant ID */\n  readonly variantId: VariantId;\n  /** Number of users assigned */\n  readonly userCount: number;\n  /** Number of conversions */\n  readonly conversions: number;\n  /** Conversion rate */\n  readonly conversionRate: number;\n  /** Average value (for numeric metrics) */\n  readonly averageValue?: number;\n  /** Standard deviation */\n  readonly standardDeviation?: number;\n  /** Confidence interval */\n  readonly confidenceInterval?: [number, number];\n}\n\n/**\n * Variant comparison result.\n */\nexport interface VariantComparison {\n  /** Control variant stats */\n  readonly control: VariantStats;\n  /** Treatment variant stats */\n  readonly treatment: VariantStats;\n  /** Relative lift (treatment vs control) */\n  readonly relativeLift: number;\n  /** Statistical significance (p-value) */\n  readonly pValue: number;\n  /** Whether result is statistically significant */\n  readonly isSignificant: boolean;\n  /** Confidence level used */\n  readonly confidenceLevel: number;\n}\n\n// ============================================================================\n// Variant Manager\n// ============================================================================\n\n/**\n * Manager for creating and working with flag variants.\n */\nexport class VariantManager {\n  /**\n   * Create a new variant.\n   */\n  createVariant<T extends JsonValue>(id: VariantId, options: CreateVariantOptions<T>): Variant<T> {\n    const valueType = this.inferValueType(options.value);\n\n    return {\n      id,\n      name: options.name ?? id,\n      description: options.description,\n      value: options.value,\n      valueType,\n      isControl: options.isControl ?? false,\n      payload: options.payload,\n      attachments: options.attachments,\n    };\n  }\n\n  /**\n   * Create a boolean variant.\n   */\n  createBooleanVariant(\n    id: VariantId,\n    value: boolean,\n    options?: Omit<CreateVariantOptions<boolean>, 'value'>\n  ): Variant<boolean> {\n    return {\n      id,\n      name: options?.name ?? id,\n      description: options?.description,\n      value,\n      valueType: 'boolean',\n      isControl: options?.isControl ?? false,\n      payload: options?.payload,\n      attachments: options?.attachments,\n    };\n  }\n\n  /**\n   * Create a string variant.\n   */\n  createStringVariant(\n    id: VariantId,\n    value: string,\n    options?: Omit<CreateVariantOptions<string>, 'value'>\n  ): Variant<string> {\n    return {\n      id,\n      name: options?.name ?? id,\n      description: options?.description,\n      value,\n      valueType: 'string',\n      isControl: options?.isControl ?? false,\n      payload: options?.payload,\n      attachments: options?.attachments,\n    };\n  }\n\n  /**\n   * Create a number variant.\n   */\n  createNumberVariant(\n    id: VariantId,\n    value: number,\n    options?: Omit<CreateVariantOptions<number>, 'value'>\n  ): Variant<number> {\n    return {\n      id,\n      name: options?.name ?? id,\n      description: options?.description,\n      value,\n      valueType: 'number',\n      isControl: options?.isControl ?? false,\n      payload: options?.payload,\n      attachments: options?.attachments,\n    };\n  }\n\n  /**\n   * Create a JSON variant.\n   */\n  createJsonVariant<T extends JsonValue>(\n    id: VariantId,\n    value: T,\n    options?: Omit<CreateVariantOptions<T>, 'value'>\n  ): Variant<T> {\n    return {\n      id,\n      name: options?.name ?? id,\n      description: options?.description,\n      value,\n      valueType: 'json',\n      isControl: options?.isControl ?? false,\n      payload: options?.payload,\n      attachments: options?.attachments,\n    };\n  }\n\n  /**\n   * Infer the value type from a value.\n   */\n  inferValueType(value: JsonValue): VariantValueType {\n    if (typeof value === 'boolean') return 'boolean';\n    if (typeof value === 'string') return 'string';\n    if (typeof value === 'number') return 'number';\n    return 'json';\n  }\n\n  /**\n   * Validate a variant value against its declared type.\n   */\n  validateVariant(variant: Variant): boolean {\n    switch (variant.valueType) {\n      case 'boolean':\n        return typeof variant.value === 'boolean';\n      case 'string':\n        return typeof variant.value === 'string';\n      case 'number':\n        return typeof variant.value === 'number';\n      case 'json':\n        return variant.value !== undefined;\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Coerce a value to the expected type.\n   */\n  coerceValue<T extends JsonValue>(value: unknown, targetType: VariantValueType): T | null {\n    try {\n      switch (targetType) {\n        case 'boolean':\n          if (typeof value === 'boolean') return value as T;\n          if (typeof value === 'string') {\n            if (value === 'true') return true as T;\n            if (value === 'false') return false as T;\n          }\n          if (typeof value === 'number') return (value !== 0) as T;\n          return null;\n\n        case 'string':\n          if (typeof value === 'string') return value as T;\n          if (value === null || value === undefined) return null;\n          if (typeof value === 'object') return JSON.stringify(value) as T;\n          if (typeof value === 'boolean' || typeof value === 'number') return String(value) as T;\n          return null;\n\n        case 'number':\n          if (typeof value === 'number') return value as T;\n          if (typeof value === 'string') {\n            const parsed = parseFloat(value);\n            return isNaN(parsed) ? null : (parsed as T);\n          }\n          return null;\n\n        case 'json':\n          if (typeof value === 'string') {\n            try {\n              return JSON.parse(value) as T;\n            } catch {\n              return null;\n            }\n          }\n          return value as T;\n\n        default:\n          return null;\n      }\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Select a variant based on a bucket value and allocations.\n   */\n  selectVariant<T extends JsonValue>(\n    variants: readonly Variant<T>[],\n    bucket: number,\n    allocations?: readonly VariantAllocation[]\n  ): Variant<T> | null {\n    if (variants.length === 0) {\n      return null;\n    }\n\n    // If allocations are provided, use weighted selection\n    if (allocations && allocations.length > 0) {\n      let cumulative = 0;\n      for (const allocation of allocations) {\n        cumulative += allocation.percentage;\n        if (bucket < cumulative) {\n          const variant = variants.find((v) => v.id === allocation.variantId);\n          if (variant) return variant;\n        }\n      }\n    }\n\n    // Equal weight selection\n    const index = Math.floor((bucket / 100) * variants.length);\n    return variants[Math.min(index, variants.length - 1)] ?? null;\n  }\n\n  /**\n   * Get the control variant from a list.\n   */\n  getControlVariant<T extends JsonValue>(variants: readonly Variant<T>[]): Variant<T> | null {\n    return variants.find((v) => v.isControl === true) ?? null;\n  }\n\n  /**\n   * Get all treatment (non-control) variants.\n   */\n  getTreatmentVariants<T extends JsonValue>(variants: readonly Variant<T>[]): Variant<T>[] {\n    return variants.filter((v) => v.isControl !== true);\n  }\n\n  /**\n   * Create equal allocations for variants.\n   */\n  createEqualAllocations(variants: readonly Variant[]): VariantAllocation[] {\n    const percentage = 100 / variants.length;\n    return variants.map((v) => ({\n      variantId: v.id,\n      percentage,\n    }));\n  }\n\n  /**\n   * Create weighted allocations with control getting most traffic.\n   */\n  createControlHeavyAllocations(\n    variants: readonly Variant[],\n    controlPercentage: number = 50\n  ): VariantAllocation[] {\n    const control = variants.find((v) => v.isControl === true);\n    const treatments = variants.filter((v) => v.isControl !== true);\n\n    if (!control || treatments.length === 0) {\n      return this.createEqualAllocations(variants);\n    }\n\n    const treatmentPercentage = (100 - controlPercentage) / treatments.length;\n\n    return [\n      { variantId: control.id, percentage: controlPercentage },\n      ...treatments.map((v) => ({\n        variantId: v.id,\n        percentage: treatmentPercentage,\n      })),\n    ];\n  }\n}\n\n// ============================================================================\n// Variant Builder\n// ============================================================================\n\n/**\n * Mutable variant type for builder.\n */\ntype MutableVariant<T extends JsonValue = JsonValue> = {\n  -readonly [K in keyof Variant<T>]: Variant<T>[K];\n};\n\n/**\n * Fluent builder for creating variants.\n */\nexport class VariantBuilder<T extends JsonValue = JsonValue> {\n  private variant: Partial<MutableVariant<T>> = {};\n\n  /**\n   * Set the variant ID.\n   */\n  id(id: VariantId): this {\n    this.variant.id = id;\n    return this;\n  }\n\n  /**\n   * Set the variant name.\n   */\n  name(name: string): this {\n    this.variant.name = name;\n    return this;\n  }\n\n  /**\n   * Set the variant description.\n   */\n  description(description: string): this {\n    this.variant.description = description;\n    return this;\n  }\n\n  /**\n   * Set the variant value.\n   */\n  value(value: T): this {\n    this.variant.value = value;\n    this.variant.valueType = new VariantManager().inferValueType(value);\n    return this;\n  }\n\n  /**\n   * Mark as control variant.\n   */\n  asControl(): this {\n    this.variant.isControl = true;\n    return this;\n  }\n\n  /**\n   * Add payload data.\n   */\n  payload(data: Record<string, JsonValue>): this {\n    this.variant.payload = data;\n    return this;\n  }\n\n  /**\n   * Add attachments.\n   */\n  attachments(...files: string[]): this {\n    this.variant.attachments = files;\n    return this;\n  }\n\n  /**\n   * Build the variant.\n   */\n  build(): Variant<T> {\n    if (this.variant.id == null || this.variant.id === '') {\n      throw new Error('Variant ID is required');\n    }\n    if (this.variant.value === undefined) {\n      throw new Error('Variant value is required');\n    }\n\n    return {\n      id: this.variant.id,\n      name: this.variant.name ?? this.variant.id,\n      description: this.variant.description,\n      value: this.variant.value,\n      valueType: this.variant.valueType ?? 'json',\n      isControl: this.variant.isControl ?? false,\n      payload: this.variant.payload,\n      attachments: this.variant.attachments,\n    };\n  }\n}\n\n/**\n * Create a new variant builder.\n */\nexport function createVariant<T extends JsonValue = JsonValue>(): VariantBuilder<T> {\n  return new VariantBuilder<T>();\n}\n\n// ============================================================================\n// Predefined Variant Sets\n// ============================================================================\n\n/**\n * Common variant patterns.\n */\nexport const VariantSets = {\n  /**\n   * Simple on/off boolean variants.\n   */\n  boolean(): [Variant<boolean>, Variant<boolean>] {\n    const manager = new VariantManager();\n    return [\n      manager.createBooleanVariant('off', false, { isControl: true, name: 'Off' }),\n      manager.createBooleanVariant('on', true, { name: 'On' }),\n    ];\n  },\n\n  /**\n   * A/B test variants (control + treatment).\n   */\n  abTest<T extends JsonValue>(controlValue: T, treatmentValue: T): [Variant<T>, Variant<T>] {\n    const manager = new VariantManager();\n    return [\n      manager.createVariant('control', {\n        value: controlValue,\n        name: 'Control',\n        isControl: true,\n      }),\n      manager.createVariant('treatment', {\n        value: treatmentValue,\n        name: 'Treatment',\n      }),\n    ];\n  },\n\n  /**\n   * A/B/C test variants.\n   */\n  abcTest<T extends JsonValue>(\n    controlValue: T,\n    treatmentAValue: T,\n    treatmentBValue: T\n  ): [Variant<T>, Variant<T>, Variant<T>] {\n    const manager = new VariantManager();\n    return [\n      manager.createVariant('control', {\n        value: controlValue,\n        name: 'Control',\n        isControl: true,\n      }),\n      manager.createVariant('treatment-a', {\n        value: treatmentAValue,\n        name: 'Treatment A',\n      }),\n      manager.createVariant('treatment-b', {\n        value: treatmentBValue,\n        name: 'Treatment B',\n      }),\n    ];\n  },\n\n  /**\n   * Multi-value variants from a map.\n   */\n  fromMap<T extends JsonValue>(values: Record<string, T>, controlId?: string): Variant<T>[] {\n    const manager = new VariantManager();\n    return Object.entries(values).map(([id, value]) =>\n      manager.createVariant(id, {\n        value,\n        isControl: id === controlId,\n      })\n    );\n  },\n\n  /**\n   * Color variants for UI experiments.\n   */\n  colors(colors: Record<string, string>, controlColor?: string): Variant<string>[] {\n    const manager = new VariantManager();\n    return Object.entries(colors).map(([name, value]) =>\n      manager.createStringVariant(name, value, {\n        name: `Color: ${name}`,\n        isControl: value === controlColor,\n      })\n    );\n  },\n\n  /**\n   * Size variants (e.g., for button sizes).\n   */\n  sizes(): Variant<string>[] {\n    return VariantSets.fromMap(\n      {\n        small: 'small',\n        medium: 'medium',\n        large: 'large',\n      },\n      'medium'\n    );\n  },\n};\n\n// ============================================================================\n// Statistical Utilities\n// ============================================================================\n\n/**\n * Calculate basic statistics for a variant.\n */\nexport function calculateVariantStats(\n  variantId: VariantId,\n  values: number[],\n  conversions: number\n): VariantStats {\n  const n = values.length;\n  if (n === 0) {\n    return {\n      variantId,\n      userCount: 0,\n      conversions: 0,\n      conversionRate: 0,\n    };\n  }\n\n  const mean = values.reduce((a, b) => a + b, 0) / n;\n  const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / n;\n  const stdDev = Math.sqrt(variance);\n\n  // 95% confidence interval\n  const z = 1.96;\n  const margin = z * (stdDev / Math.sqrt(n));\n\n  return {\n    variantId,\n    userCount: n,\n    conversions,\n    conversionRate: conversions / n,\n    averageValue: mean,\n    standardDeviation: stdDev,\n    confidenceInterval: [mean - margin, mean + margin],\n  };\n}\n\n/**\n * Compare two variants using a z-test.\n */\nexport function compareVariants(\n  control: VariantStats,\n  treatment: VariantStats,\n  confidenceLevel: number = 0.95\n): VariantComparison {\n  const relativeLift =\n    control.conversionRate > 0\n      ? (treatment.conversionRate - control.conversionRate) / control.conversionRate\n      : 0;\n\n  // Two-proportion z-test\n  const p1 = control.conversionRate;\n  const p2 = treatment.conversionRate;\n  const n1 = control.userCount;\n  const n2 = treatment.userCount;\n\n  if (n1 === 0 || n2 === 0) {\n    return {\n      control,\n      treatment,\n      relativeLift,\n      pValue: 1,\n      isSignificant: false,\n      confidenceLevel,\n    };\n  }\n\n  const pooledP = (control.conversions + treatment.conversions) / (n1 + n2);\n  const se = Math.sqrt(pooledP * (1 - pooledP) * (1 / n1 + 1 / n2));\n\n  const z = se > 0 ? (p2 - p1) / se : 0;\n  const pValue = 2 * (1 - normalCDF(Math.abs(z)));\n\n  return {\n    control,\n    treatment,\n    relativeLift,\n    pValue,\n    isSignificant: pValue < 1 - confidenceLevel,\n    confidenceLevel,\n  };\n}\n\n/**\n * Standard normal cumulative distribution function.\n */\nfunction normalCDF(x: number): number {\n  const a1 = 0.254829592;\n  const a2 = -0.284496736;\n  const a3 = 1.421413741;\n  const a4 = -1.453152027;\n  const a5 = 1.061405429;\n  const p = 0.3275911;\n\n  const sign = x < 0 ? -1 : 1;\n  x = Math.abs(x) / Math.sqrt(2);\n\n  const t = 1.0 / (1.0 + p * x);\n  const y = 1.0 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);\n\n  return 0.5 * (1.0 + sign * y);\n}\n\n// ============================================================================\n// Singleton Instance\n// ============================================================================\n\nlet instance: VariantManager | null = null;\n\n/**\n * Get the singleton variant manager instance.\n */\nexport function getVariantManager(): VariantManager {\n  instance ??= new VariantManager();\n  return instance;\n}\n"],"names":["VariantManager","id","options","valueType","value","variant","targetType","parsed","variants","bucket","allocations","cumulative","allocation","v","index","percentage","controlPercentage","control","treatments","treatmentPercentage","VariantBuilder","name","description","data","files","createVariant","VariantSets","manager","controlValue","treatmentValue","treatmentAValue","treatmentBValue","values","controlId","colors","controlColor","calculateVariantStats","variantId","conversions","n","mean","a","b","variance","sum","val","stdDev","margin","compareVariants","treatment","confidenceLevel","relativeLift","p1","p2","n1","n2","pooledP","se","z","pValue","normalCDF","x","a1","a2","a3","a4","a5","p","sign","t","y","instance","getVariantManager"],"mappings":"AAuGO,MAAMA,EAAe;AAAA;AAAA;AAAA;AAAA,EAI1B,cAAmCC,GAAeC,GAA8C;AAC9F,UAAMC,IAAY,KAAK,eAAeD,EAAQ,KAAK;AAEnD,WAAO;AAAA,MACL,IAAAD;AAAA,MACA,MAAMC,EAAQ,QAAQD;AAAA,MACtB,aAAaC,EAAQ;AAAA,MACrB,OAAOA,EAAQ;AAAA,MACf,WAAAC;AAAA,MACA,WAAWD,EAAQ,aAAa;AAAA,MAChC,SAASA,EAAQ;AAAA,MACjB,aAAaA,EAAQ;AAAA,IAAA;AAAA,EAEzB;AAAA;AAAA;AAAA;AAAA,EAKA,qBACED,GACAG,GACAF,GACkB;AAClB,WAAO;AAAA,MACL,IAAAD;AAAA,MACA,MAAMC,GAAS,QAAQD;AAAA,MACvB,aAAaC,GAAS;AAAA,MACtB,OAAAE;AAAA,MACA,WAAW;AAAA,MACX,WAAWF,GAAS,aAAa;AAAA,MACjC,SAASA,GAAS;AAAA,MAClB,aAAaA,GAAS;AAAA,IAAA;AAAA,EAE1B;AAAA;AAAA;AAAA;AAAA,EAKA,oBACED,GACAG,GACAF,GACiB;AACjB,WAAO;AAAA,MACL,IAAAD;AAAA,MACA,MAAMC,GAAS,QAAQD;AAAA,MACvB,aAAaC,GAAS;AAAA,MACtB,OAAAE;AAAA,MACA,WAAW;AAAA,MACX,WAAWF,GAAS,aAAa;AAAA,MACjC,SAASA,GAAS;AAAA,MAClB,aAAaA,GAAS;AAAA,IAAA;AAAA,EAE1B;AAAA;AAAA;AAAA;AAAA,EAKA,oBACED,GACAG,GACAF,GACiB;AACjB,WAAO;AAAA,MACL,IAAAD;AAAA,MACA,MAAMC,GAAS,QAAQD;AAAA,MACvB,aAAaC,GAAS;AAAA,MACtB,OAAAE;AAAA,MACA,WAAW;AAAA,MACX,WAAWF,GAAS,aAAa;AAAA,MACjC,SAASA,GAAS;AAAA,MAClB,aAAaA,GAAS;AAAA,IAAA;AAAA,EAE1B;AAAA;AAAA;AAAA;AAAA,EAKA,kBACED,GACAG,GACAF,GACY;AACZ,WAAO;AAAA,MACL,IAAAD;AAAA,MACA,MAAMC,GAAS,QAAQD;AAAA,MACvB,aAAaC,GAAS;AAAA,MACtB,OAAAE;AAAA,MACA,WAAW;AAAA,MACX,WAAWF,GAAS,aAAa;AAAA,MACjC,SAASA,GAAS;AAAA,MAClB,aAAaA,GAAS;AAAA,IAAA;AAAA,EAE1B;AAAA;AAAA;AAAA;AAAA,EAKA,eAAeE,GAAoC;AACjD,WAAI,OAAOA,KAAU,YAAkB,YACnC,OAAOA,KAAU,WAAiB,WAClC,OAAOA,KAAU,WAAiB,WAC/B;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,gBAAgBC,GAA2B;AACzC,YAAQA,EAAQ,WAAA;AAAA,MACd,KAAK;AACH,eAAO,OAAOA,EAAQ,SAAU;AAAA,MAClC,KAAK;AACH,eAAO,OAAOA,EAAQ,SAAU;AAAA,MAClC,KAAK;AACH,eAAO,OAAOA,EAAQ,SAAU;AAAA,MAClC,KAAK;AACH,eAAOA,EAAQ,UAAU;AAAA,MAC3B;AACE,eAAO;AAAA,IAAA;AAAA,EAEb;AAAA;AAAA;AAAA;AAAA,EAKA,YAAiCD,GAAgBE,GAAwC;AACvF,QAAI;AACF,cAAQA,GAAA;AAAA,QACN,KAAK;AACH,cAAI,OAAOF,KAAU,UAAW,QAAOA;AACvC,cAAI,OAAOA,KAAU,UAAU;AAC7B,gBAAIA,MAAU,OAAQ,QAAO;AAC7B,gBAAIA,MAAU,QAAS,QAAO;AAAA,UAChC;AACA,iBAAI,OAAOA,KAAU,WAAkBA,MAAU,IAC1C;AAAA,QAET,KAAK;AACH,iBAAI,OAAOA,KAAU,WAAiBA,IAClCA,KAAU,OAAoC,OAC9C,OAAOA,KAAU,WAAiB,KAAK,UAAUA,CAAK,IACtD,OAAOA,KAAU,aAAa,OAAOA,KAAU,WAAiB,OAAOA,CAAK,IACzE;AAAA,QAET,KAAK;AACH,cAAI,OAAOA,KAAU,SAAU,QAAOA;AACtC,cAAI,OAAOA,KAAU,UAAU;AAC7B,kBAAMG,IAAS,WAAWH,CAAK;AAC/B,mBAAO,MAAMG,CAAM,IAAI,OAAQA;AAAA,UACjC;AACA,iBAAO;AAAA,QAET,KAAK;AACH,cAAI,OAAOH,KAAU;AACnB,gBAAI;AACF,qBAAO,KAAK,MAAMA,CAAK;AAAA,YACzB,QAAQ;AACN,qBAAO;AAAA,YACT;AAEF,iBAAOA;AAAA,QAET;AACE,iBAAO;AAAA,MAAA;AAAA,IAEb,QAAQ;AACN,aAAO;AAAA,IACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,cACEI,GACAC,GACAC,GACmB;AACnB,QAAIF,EAAS,WAAW;AACtB,aAAO;AAIT,QAAIE,KAAeA,EAAY,SAAS,GAAG;AACzC,UAAIC,IAAa;AACjB,iBAAWC,KAAcF;AAEvB,YADAC,KAAcC,EAAW,YACrBH,IAASE,GAAY;AACvB,gBAAMN,IAAUG,EAAS,KAAK,CAACK,MAAMA,EAAE,OAAOD,EAAW,SAAS;AAClE,cAAIP,EAAS,QAAOA;AAAA,QACtB;AAAA,IAEJ;AAGA,UAAMS,IAAQ,KAAK,MAAOL,IAAS,MAAOD,EAAS,MAAM;AACzD,WAAOA,EAAS,KAAK,IAAIM,GAAON,EAAS,SAAS,CAAC,CAAC,KAAK;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA,EAKA,kBAAuCA,GAAoD;AACzF,WAAOA,EAAS,KAAK,CAACK,MAAMA,EAAE,cAAc,EAAI,KAAK;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA,EAKA,qBAA0CL,GAA+C;AACvF,WAAOA,EAAS,OAAO,CAACK,MAAMA,EAAE,cAAc,EAAI;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA,EAKA,uBAAuBL,GAAmD;AACxE,UAAMO,IAAa,MAAMP,EAAS;AAClC,WAAOA,EAAS,IAAI,CAACK,OAAO;AAAA,MAC1B,WAAWA,EAAE;AAAA,MACb,YAAAE;AAAA,IAAA,EACA;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAKA,8BACEP,GACAQ,IAA4B,IACP;AACrB,UAAMC,IAAUT,EAAS,KAAK,CAACK,MAAMA,EAAE,cAAc,EAAI,GACnDK,IAAaV,EAAS,OAAO,CAACK,MAAMA,EAAE,cAAc,EAAI;AAE9D,QAAI,CAACI,KAAWC,EAAW,WAAW;AACpC,aAAO,KAAK,uBAAuBV,CAAQ;AAG7C,UAAMW,KAAuB,MAAMH,KAAqBE,EAAW;AAEnE,WAAO;AAAA,MACL,EAAE,WAAWD,EAAQ,IAAI,YAAYD,EAAA;AAAA,MACrC,GAAGE,EAAW,IAAI,CAACL,OAAO;AAAA,QACxB,WAAWA,EAAE;AAAA,QACb,YAAYM;AAAA,MAAA,EACZ;AAAA,IAAA;AAAA,EAEN;AACF;AAgBO,MAAMC,EAAgD;AAAA,EACnD,UAAsC,CAAA;AAAA;AAAA;AAAA;AAAA,EAK9C,GAAGnB,GAAqB;AACtB,gBAAK,QAAQ,KAAKA,GACX;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,KAAKoB,GAAoB;AACvB,gBAAK,QAAQ,OAAOA,GACb;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,YAAYC,GAA2B;AACrC,gBAAK,QAAQ,cAAcA,GACpB;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,MAAMlB,GAAgB;AACpB,gBAAK,QAAQ,QAAQA,GACrB,KAAK,QAAQ,YAAY,IAAIJ,EAAA,EAAiB,eAAeI,CAAK,GAC3D;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,YAAkB;AAChB,gBAAK,QAAQ,YAAY,IAClB;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQmB,GAAuC;AAC7C,gBAAK,QAAQ,UAAUA,GAChB;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,eAAeC,GAAuB;AACpC,gBAAK,QAAQ,cAAcA,GACpB;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,QAAoB;AAClB,QAAI,KAAK,QAAQ,MAAM,QAAQ,KAAK,QAAQ,OAAO;AACjD,YAAM,IAAI,MAAM,wBAAwB;AAE1C,QAAI,KAAK,QAAQ,UAAU;AACzB,YAAM,IAAI,MAAM,2BAA2B;AAG7C,WAAO;AAAA,MACL,IAAI,KAAK,QAAQ;AAAA,MACjB,MAAM,KAAK,QAAQ,QAAQ,KAAK,QAAQ;AAAA,MACxC,aAAa,KAAK,QAAQ;AAAA,MAC1B,OAAO,KAAK,QAAQ;AAAA,MACpB,WAAW,KAAK,QAAQ,aAAa;AAAA,MACrC,WAAW,KAAK,QAAQ,aAAa;AAAA,MACrC,SAAS,KAAK,QAAQ;AAAA,MACtB,aAAa,KAAK,QAAQ;AAAA,IAAA;AAAA,EAE9B;AACF;AAKO,SAASC,IAAoE;AAClF,SAAO,IAAIL,EAAA;AACb;AASO,MAAMM,IAAc;AAAA;AAAA;AAAA;AAAA,EAIzB,UAAgD;AAC9C,UAAMC,IAAU,IAAI3B,EAAA;AACpB,WAAO;AAAA,MACL2B,EAAQ,qBAAqB,OAAO,IAAO,EAAE,WAAW,IAAM,MAAM,OAAO;AAAA,MAC3EA,EAAQ,qBAAqB,MAAM,IAAM,EAAE,MAAM,MAAM;AAAA,IAAA;AAAA,EAE3D;AAAA;AAAA;AAAA;AAAA,EAKA,OAA4BC,GAAiBC,GAA6C;AACxF,UAAMF,IAAU,IAAI3B,EAAA;AACpB,WAAO;AAAA,MACL2B,EAAQ,cAAc,WAAW;AAAA,QAC/B,OAAOC;AAAA,QACP,MAAM;AAAA,QACN,WAAW;AAAA,MAAA,CACZ;AAAA,MACDD,EAAQ,cAAc,aAAa;AAAA,QACjC,OAAOE;AAAA,QACP,MAAM;AAAA,MAAA,CACP;AAAA,IAAA;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA,EAKA,QACED,GACAE,GACAC,GACsC;AACtC,UAAMJ,IAAU,IAAI3B,EAAA;AACpB,WAAO;AAAA,MACL2B,EAAQ,cAAc,WAAW;AAAA,QAC/B,OAAOC;AAAA,QACP,MAAM;AAAA,QACN,WAAW;AAAA,MAAA,CACZ;AAAA,MACDD,EAAQ,cAAc,eAAe;AAAA,QACnC,OAAOG;AAAA,QACP,MAAM;AAAA,MAAA,CACP;AAAA,MACDH,EAAQ,cAAc,eAAe;AAAA,QACnC,OAAOI;AAAA,QACP,MAAM;AAAA,MAAA,CACP;AAAA,IAAA;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA,EAKA,QAA6BC,GAA2BC,GAAkC;AACxF,UAAMN,IAAU,IAAI3B,EAAA;AACpB,WAAO,OAAO,QAAQgC,CAAM,EAAE;AAAA,MAAI,CAAC,CAAC/B,GAAIG,CAAK,MAC3CuB,EAAQ,cAAc1B,GAAI;AAAA,QACxB,OAAAG;AAAA,QACA,WAAWH,MAAOgC;AAAA,MAAA,CACnB;AAAA,IAAA;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA,EAKA,OAAOC,GAAgCC,GAA0C;AAC/E,UAAMR,IAAU,IAAI3B,EAAA;AACpB,WAAO,OAAO,QAAQkC,CAAM,EAAE;AAAA,MAAI,CAAC,CAACb,GAAMjB,CAAK,MAC7CuB,EAAQ,oBAAoBN,GAAMjB,GAAO;AAAA,QACvC,MAAM,UAAUiB,CAAI;AAAA,QACpB,WAAWjB,MAAU+B;AAAA,MAAA,CACtB;AAAA,IAAA;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA,EAKA,QAA2B;AACzB,WAAOT,EAAY;AAAA,MACjB;AAAA,QACE,OAAO;AAAA,QACP,QAAQ;AAAA,QACR,OAAO;AAAA,MAAA;AAAA,MAET;AAAA,IAAA;AAAA,EAEJ;AACF;AASO,SAASU,EACdC,GACAL,GACAM,GACc;AACd,QAAMC,IAAIP,EAAO;AACjB,MAAIO,MAAM;AACR,WAAO;AAAA,MACL,WAAAF;AAAA,MACA,WAAW;AAAA,MACX,aAAa;AAAA,MACb,gBAAgB;AAAA,IAAA;AAIpB,QAAMG,IAAOR,EAAO,OAAO,CAACS,GAAGC,MAAMD,IAAIC,GAAG,CAAC,IAAIH,GAC3CI,IAAWX,EAAO,OAAO,CAACY,GAAKC,MAAQD,IAAM,KAAK,IAAIC,IAAML,GAAM,CAAC,GAAG,CAAC,IAAID,GAC3EO,IAAS,KAAK,KAAKH,CAAQ,GAI3BI,IADI,QACUD,IAAS,KAAK,KAAKP,CAAC;AAExC,SAAO;AAAA,IACL,WAAAF;AAAA,IACA,WAAWE;AAAA,IACX,aAAAD;AAAA,IACA,gBAAgBA,IAAcC;AAAA,IAC9B,cAAcC;AAAA,IACd,mBAAmBM;AAAA,IACnB,oBAAoB,CAACN,IAAOO,GAAQP,IAAOO,CAAM;AAAA,EAAA;AAErD;AAKO,SAASC,EACd/B,GACAgC,GACAC,IAA0B,MACP;AACnB,QAAMC,IACJlC,EAAQ,iBAAiB,KACpBgC,EAAU,iBAAiBhC,EAAQ,kBAAkBA,EAAQ,iBAC9D,GAGAmC,IAAKnC,EAAQ,gBACboC,IAAKJ,EAAU,gBACfK,IAAKrC,EAAQ,WACbsC,IAAKN,EAAU;AAErB,MAAIK,MAAO,KAAKC,MAAO;AACrB,WAAO;AAAA,MACL,SAAAtC;AAAA,MACA,WAAAgC;AAAA,MACA,cAAAE;AAAA,MACA,QAAQ;AAAA,MACR,eAAe;AAAA,MACf,iBAAAD;AAAA,IAAA;AAIJ,QAAMM,KAAWvC,EAAQ,cAAcgC,EAAU,gBAAgBK,IAAKC,IAChEE,IAAK,KAAK,KAAKD,KAAW,IAAIA,MAAY,IAAIF,IAAK,IAAIC,EAAG,GAE1DG,IAAID,IAAK,KAAKJ,IAAKD,KAAMK,IAAK,GAC9BE,IAAS,KAAK,IAAIC,EAAU,KAAK,IAAIF,CAAC,CAAC;AAE7C,SAAO;AAAA,IACL,SAAAzC;AAAA,IACA,WAAAgC;AAAA,IACA,cAAAE;AAAA,IACA,QAAAQ;AAAA,IACA,eAAeA,IAAS,IAAIT;AAAA,IAC5B,iBAAAA;AAAA,EAAA;AAEJ;AAKA,SAASU,EAAUC,GAAmB;AACpC,QAAMC,IAAK,aACLC,IAAK,cACLC,IAAK,aACLC,IAAK,cACLC,IAAK,aACLC,IAAI,WAEJC,IAAOP,IAAI,IAAI,KAAK;AAC1B,EAAAA,IAAI,KAAK,IAAIA,CAAC,IAAI,KAAK,KAAK,CAAC;AAE7B,QAAMQ,IAAI,KAAO,IAAMF,IAAIN,IACrBS,IAAI,QAAUJ,IAAKG,IAAIJ,KAAMI,IAAIL,KAAMK,IAAIN,KAAMM,IAAIP,KAAMO,IAAI,KAAK,IAAI,CAACR,IAAIA,CAAC;AAEpF,SAAO,OAAO,IAAMO,IAAOE;AAC7B;AAMA,IAAIC,IAAkC;AAK/B,SAASC,IAAoC;AAClD,SAAAD,MAAa,IAAIvE,EAAA,GACVuE;AACT;"}