@tangle-network/agent-eval 0.205.0 → 0.205.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.205.0",
+  "version": "0.205.1",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {

package/dist/paired-binary-DpwwK1fU.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paired-binary-DpwwK1fU.js","names":[],"sources":["../src/statistics/paired-binary.ts"],"sourcesContent":["import { regularizedIncompleteBeta } from '../math/special-functions'\nimport { binomialSignTwoSided, zQuantile } from './internal'\n\n// ── Binomial proportion + paired-binary + coding-eval estimators ─────\n//\n// The paired family above (pairedBootstrap/pairedTTest/wilcoxonSignedRank)\n// operates on continuous scores. Pass/fail A/B comparisons — \"does treatment\n// X raise the success RATE vs control\" — are binary and paired, so they need\n// their own correct estimators: McNemar for significance (only the discordant\n// pairs carry signal), the paired risk difference for effect size, Wilson for\n// a single-arm proportion CI, and pass@k for the standard k-sample coding-eval\n// metric. The normal approximation is wrong for proportions near 0/1 and for\n// the small discordant counts typical of eval runs, so these are exact /\n// Wilson-based, not Wald.\n\n/** A binomial proportion estimate with a confidence interval. */\nexport interface ProportionInterval {\n  /** Point estimate successes / n (0 when n = 0). */\n  estimate: number\n  /** Lower bound, clamped to [0, 1]. */\n  lower: number\n  /** Upper bound, clamped to [0, 1]. */\n  upper: number\n}\n\n/**\n * Wilson score interval for a binomial proportion. Correct at small n and near\n * 0/1, where the normal (Wald) approximation produces bounds outside [0, 1] and\n * understates coverage. Use this for any pass-rate / hit-rate / realness-rate\n * CI — the continuous `confidenceInterval` assumes the wrong distribution for a\n * proportion. `n = 0 ⇒ {0, 0, 0}`.\n */\nexport function wilson(successes: number, n: number, confidence = 0.95): ProportionInterval {\n  if (n <= 0) return { estimate: 0, lower: 0, upper: 0 }\n  if (successes < 0 || successes > n) {\n    throw new Error(`wilson: successes (${successes}) must be in [0, ${n}]`)\n  }\n  const z = zQuantile(1 - (1 - confidence) / 2)\n  const p = successes / n\n  const z2 = z * z\n  const denom = 1 + z2 / n\n  const center = (p + z2 / (2 * n)) / denom\n  const half = (z * Math.sqrt((p * (1 - p) + z2 / (4 * n)) / n)) / denom\n  return {\n    estimate: p,\n    lower: Math.max(0, center - half),\n    upper: Math.min(1, center + half),\n  }\n}\n\n/**\n * Are these per-item outcomes binary (every value exactly 0 or 1)?\n *\n * The discriminator a promotion gate needs before choosing a paired statistic.\n * On binary outcomes the paired delta vector lives in {-1, 0, +1} and is\n * normally dominated by zeros (both arms solve, or both arms miss, most items),\n * so its MEDIAN is pinned at exactly 0 no matter how large the real shift in\n * success rate is — and a bootstrap CI on that median collapses to [0, 0].\n * A gate keying on `ci.low > threshold` is then structurally unable to see\n * either a gain or a regression. Detect this shape and switch to the\n * paired-binary estimators ({@link mcnemar}, {@link pairedRiskDifference})\n * instead of silently answering \"no\" forever.\n *\n * Empty input is NOT binary: there is no evidence of the outcome's shape, and\n * defaulting an empty vector into the binary branch would pick a statistic on\n * no data at all.\n *\n * NOT the right discriminator for a gate. It recognises the literal {0, 1}\n * encoding and nothing else, so a pass/fail dimension emitted on 0-100 — which\n * judges in this codebase do routinely — reads as non-binary, and a single\n * partial-credit score in an otherwise pass/fail vector flips it to false while\n * leaving the median just as blind. Gates want {@link pairedBinaryScale} (any\n * two-point encoding). This predicate remains for callers that specifically\n * mean \"literally 0/1\".\n */\nexport function isBinaryOutcomeVector(values: ArrayLike<number>): boolean {\n  if (values.length === 0) return false\n  for (let i = 0; i < values.length; i++) {\n    const v = values[i]!\n    if (v !== 0 && v !== 1) return false\n  }\n  return true\n}\n\n/** Result of a McNemar paired-binary significance test. */\nexport interface McNemarResult {\n  /** Total paired observations. */\n  n: number\n  /** Discordant pairs (b + c) — the only ones that carry signal. */\n  nDiscordant: number\n  /** Pairs where treatment succeeded and control failed (\"newly correct\"). */\n  b: number\n  /** Pairs where control succeeded and treatment failed (\"newly wrong\"). */\n  c: number\n  /** Continuity-corrected chi-square statistic (reference; exact p drives the call). */\n  statistic: number\n  /** Two-sided p-value. Exact (binomial sign test on discordant pairs). */\n  pValue: number\n}\n\n/**\n * McNemar's test for paired binary outcomes — the correct significance test for\n * \"does treatment change the success rate vs control on the SAME items\". Only\n * discordant pairs (one arm right, the other wrong) carry information; concordant\n * pairs are uninformative, so a paired t-test / two-proportion z-test on the raw\n * rates is wrong here. The p-value is exact: under H0 the b \"treatment-wins\" are\n * Binomial(b + c, 0.5), so the two-sided p is the doubled binomial tail — correct\n * at the small discordant counts typical of eval runs (no continuity-corrected\n * chi-square approximation needed, though it is returned as `statistic` for\n * reference). Inputs are paired 0/1 (or boolean) arrays, control first to match\n * the module's (before, after) convention. Throws on unequal lengths.\n */\nexport function mcnemar(\n  control: ArrayLike<number | boolean>,\n  treatment: ArrayLike<number | boolean>,\n): McNemarResult {\n  if (control.length !== treatment.length) {\n    throw new Error(`mcnemar: unequal sample sizes (${control.length} vs ${treatment.length})`)\n  }\n  const n = control.length\n  let b = 0 // treatment 1, control 0\n  let c = 0 // treatment 0, control 1\n  for (let i = 0; i < n; i++) {\n    const ctrl = control[i] ? 1 : 0\n    const treat = treatment[i] ? 1 : 0\n    if (treat === 1 && ctrl === 0) b++\n    else if (treat === 0 && ctrl === 1) c++\n  }\n  const nDiscordant = b + c\n  const statistic = nDiscordant === 0 ? 0 : (Math.abs(b - c) - 1) ** 2 / nDiscordant\n  return { n, nDiscordant, b, c, statistic, pValue: binomialSignTwoSided(b, c) }\n}\n\n/** A paired binary effect size (treatment rate − control rate) with a CI. */\nexport interface RiskDifferenceResult {\n  /** Total paired observations. */\n  n: number\n  /** Discordant pairs: treatment-win count. */\n  b: number\n  /** Discordant pairs: control-win count. */\n  c: number\n  /** Paired risk difference p(treatment) − p(control) = (b − c) / n. */\n  riskDifference: number\n  /** Lower bound of the CI, clamped to [-1, 1]. */\n  lower: number\n  /** Upper bound of the CI, clamped to [-1, 1]. */\n  upper: number\n  /** Confidence level used. */\n  confidence: number\n}\n\n/**\n * Paired risk difference (the effect-size companion to {@link mcnemar}): the\n * change in success rate p(treatment) − p(control) on matched items, which for\n * paired binary data equals (b − c) / n. The CI uses the paired variance from\n * the discordant counts, not the independent-samples formula (which overstates\n * the interval by ignoring the pairing). Inputs are paired 0/1 (or boolean)\n * arrays, control first. Throws on unequal lengths.\n *\n * REPORTING ONLY — do NOT decide a promotion on this interval. The CI is a Wald\n * normal approximation, which badly UNDERCOVERS when only a handful of pairs are\n * discordant: at n = 3 with b = 2, c = 0 it returns [0.133, 1.000], excluding 0,\n * while McNemar's exact test on the same data gives p = 0.50. A gate keying on\n * `lower > 0` would promote noise. Use {@link pairedRiskDifferenceExact}, whose\n * interval is dual to the exact test by construction, for any decision.\n */\nexport function pairedRiskDifference(\n  control: ArrayLike<number | boolean>,\n  treatment: ArrayLike<number | boolean>,\n  confidence = 0.95,\n): RiskDifferenceResult {\n  if (control.length !== treatment.length) {\n    throw new Error(\n      `pairedRiskDifference: unequal sample sizes (${control.length} vs ${treatment.length})`,\n    )\n  }\n  const n = control.length\n  if (n === 0) return { n: 0, b: 0, c: 0, riskDifference: 0, lower: 0, upper: 0, confidence }\n  let b = 0\n  let c = 0\n  for (let i = 0; i < n; i++) {\n    const ctrl = control[i] ? 1 : 0\n    const treat = treatment[i] ? 1 : 0\n    if (treat === 1 && ctrl === 0) b++\n    else if (treat === 0 && ctrl === 1) c++\n  }\n  const rd = (b - c) / n\n  const variance = (b + c - (b - c) ** 2 / n) / (n * n)\n  const z = zQuantile(1 - (1 - confidence) / 2)\n  const half = z * Math.sqrt(Math.max(0, variance))\n  return {\n    n,\n    b,\n    c,\n    riskDifference: rd,\n    lower: Math.max(-1, rd - half),\n    upper: Math.min(1, rd + half),\n    confidence,\n  }\n}\n\n/** A paired binary effect size with an EXACT interval and the exact test that\n *  bounds it — one object so a caller cannot read the estimate without the\n *  significance it is entitled to. */\nexport interface ExactRiskDifferenceResult {\n  /** Total paired observations. */\n  n: number\n  /** Discordant pairs: treatment-win count. */\n  b: number\n  /** Discordant pairs: control-win count. */\n  c: number\n  /** Discordant pairs (b + c) — the only ones carrying information. */\n  nDiscordant: number\n  /** Paired risk difference p(treatment) − p(control) = (b − c) / n. */\n  riskDifference: number\n  /** Exact conditional CI lower bound. 0 when there are no discordant pairs. */\n  lower: number\n  /** Exact conditional CI upper bound. 0 when there are no discordant pairs. */\n  upper: number\n  /** Confidence level used. */\n  confidence: number\n  /** McNemar's exact two-sided p-value on the same discordant counts. */\n  pValue: number\n}\n\n/**\n * Paired risk difference with the EXACT CONDITIONAL interval — the estimator a\n * promotion gate may decide on.\n *\n * Conditional on the number of discordant pairs m = b + c, the treatment-win\n * count b is Binomial(m, π) with π = P(treatment wins | discordant), and the\n * risk difference is an exact reparameterisation: RD = (2π − 1)·m/n. So a\n * Clopper-Pearson exact interval for π maps straight onto RD. This buys the\n * property the Wald interval in {@link pairedRiskDifference} does not have:\n *\n *   **`lower > 0` ⟺ McNemar's exact test rejects at α = 1 − confidence.**\n *\n * Clopper-Pearson excludes π = 0.5 exactly when the two-sided exact binomial\n * test of π = 0.5 rejects, and that test IS {@link mcnemar}'s p-value — so the\n * interval and the test can never disagree, and a gate keyed on `lower` cannot\n * promote what the exact test refuses. The exact p is returned in the same\n * object so the two are impossible to compute apart.\n *\n * The interval is conservative (exact intervals over-cover; conditioning on m\n * discards the concordant pairs' information about m itself). That is the\n * correct direction for a promotion gate: it refuses more often, never less.\n *\n * With m = 0 there are no discordant pairs and π is not identified: the result\n * is the degenerate [0, 0] with p = 1. That is NOT evidence of equivalence —\n * callers must treat a zero-width interval as \"cannot decide\", not as \"no\n * difference\". Inputs are paired 0/1 (or boolean) arrays, control first.\n * Throws on unequal lengths.\n */\nexport function pairedRiskDifferenceExact(\n  control: ArrayLike<number | boolean>,\n  treatment: ArrayLike<number | boolean>,\n  confidence = 0.95,\n): ExactRiskDifferenceResult {\n  if (control.length !== treatment.length) {\n    throw new Error(\n      `pairedRiskDifferenceExact: unequal sample sizes (${control.length} vs ${treatment.length})`,\n    )\n  }\n  if (confidence <= 0 || confidence >= 1) {\n    throw new Error(`pairedRiskDifferenceExact: confidence must be in (0,1), got ${confidence}`)\n  }\n  const n = control.length\n  if (n === 0) {\n    return {\n      n: 0,\n      b: 0,\n      c: 0,\n      nDiscordant: 0,\n      riskDifference: 0,\n      lower: 0,\n      upper: 0,\n      confidence,\n      pValue: 1,\n    }\n  }\n  let b = 0\n  let c = 0\n  for (let i = 0; i < n; i++) {\n    const ctrl = control[i] ? 1 : 0\n    const treat = treatment[i] ? 1 : 0\n    if (treat === 1 && ctrl === 0) b++\n    else if (treat === 0 && ctrl === 1) c++\n  }\n  const m = b + c\n  const riskDifference = (b - c) / n\n  const pValue = binomialSignTwoSided(b, c)\n  if (m === 0) {\n    return { n, b, c, nDiscordant: 0, riskDifference: 0, lower: 0, upper: 0, confidence, pValue }\n  }\n  const alpha = 1 - confidence\n  const piLow = b === 0 ? 0 : betaQuantile(alpha / 2, b, m - b + 1)\n  const piHigh = b === m ? 1 : betaQuantile(1 - alpha / 2, b + 1, m - b)\n  const scale = m / n\n  return {\n    n,\n    b,\n    c,\n    nDiscordant: m,\n    riskDifference,\n    lower: Math.max(-1, (2 * piLow - 1) * scale),\n    upper: Math.min(1, (2 * piHigh - 1) * scale),\n    confidence,\n    pValue,\n  }\n}\n\n/** Inverse regularized incomplete beta by bisection on\n *  {@link regularizedIncompleteBeta}, which is monotone increasing in x. 80\n *  halvings of [0,1] resolve to ~8e-25, far past the continued fraction's own\n *  3e-15 tolerance, so the quantile is as exact as the CDF it inverts. */\nfunction betaQuantile(p: number, a: number, b: number): number {\n  if (p <= 0) return 0\n  if (p >= 1) return 1\n  let lo = 0\n  let hi = 1\n  for (let i = 0; i < 80; i++) {\n    const mid = (lo + hi) / 2\n    if (regularizedIncompleteBeta(mid, a, b) < p) lo = mid\n    else hi = mid\n  }\n  return (lo + hi) / 2\n}\n\n/** A paired binary effect size with an interval that is valid at a NONZERO\n *  margin — the estimator a noninferiority decision may be made on. */\nexport interface ScoreRiskDifferenceResult {\n  /** Total paired observations. */\n  n: number\n  /** Discordant pairs: treatment-win count. */\n  b: number\n  /** Discordant pairs: control-win count. */\n  c: number\n  /** Discordant pairs (b + c). */\n  nDiscordant: number\n  /** Paired risk difference p(treatment) − p(control) = (b − c) / n. */\n  riskDifference: number\n  /** Score-interval lower bound on the population risk difference. */\n  lower: number\n  /** Score-interval upper bound on the population risk difference. */\n  upper: number\n  /** Confidence level used. */\n  confidence: number\n}\n\n/**\n * Constrained MLE of q = P(treatment loses) under the hypothesis RD = `delta`.\n *\n * Profiling the two concordant cells out of the multinomial leaves\n * `L(q) = b·log(q+delta) + c·log(q) + e·log(1 − 2q − delta)` with `e = n − b − c`,\n * whose stationary point is the positive root of\n * `2n·q² − [(b + c) − delta·(b + 3c + 2e)]·q − c·delta·(1 − delta) = 0`.\n * At `delta = 0` this returns `(b + c) / 2n`, the familiar null.\n */\nfunction constrainedLossRate(b: number, c: number, n: number, delta: number): number {\n  const e = n - b - c\n  const quadratic = 2 * n\n  const linear = -(b + c - delta * (b + 3 * c + 2 * e))\n  const constant = -c * delta * (1 - delta)\n  const discriminant = linear * linear - 4 * quadratic * constant\n  const root = discriminant > 0 ? Math.sqrt(discriminant) : 0\n  const q = (-linear + root) / (2 * quadratic)\n  // Clamp into the region where all four cell probabilities stay non-negative.\n  return Math.min(Math.max(q, Math.max(0, -delta)), Math.max(0, (1 - delta) / 2))\n}\n\n/** Tango's score statistic for H0: RD = `delta`. `Var(b − c) = n·(2q + delta −\n *  delta²)` under that hypothesis, evaluated at the constrained MLE of q. */\nfunction tangoScore(b: number, c: number, n: number, delta: number): number {\n  const numerator = b - c - n * delta\n  const q = constrainedLossRate(b, c, n, delta)\n  const variance = n * (2 * q + delta * (1 - delta))\n  if (!(variance > 0)) {\n    if (numerator === 0) return 0\n    return numerator > 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY\n  }\n  return numerator / Math.sqrt(variance)\n}\n\n/**\n * Paired risk difference with TANGO'S (1998) SCORE INTERVAL — the estimator a\n * promotion gate may decide on **at a nonzero margin**.\n *\n * {@link pairedRiskDifferenceExact} conditions on the observed discordant count\n * `m = b + c`, builds a Clopper-Pearson interval for the win share among those\n * `m` pairs, and multiplies by the observed `m/n`. That is exact for testing\n * RD = 0 — it is dual to McNemar — but it is NOT a confidence interval for the\n * population risk difference at a nonzero margin, because the sampling\n * variability of `m/n` itself is discarded. The gap is not academic: with the\n * production caller's `pairedDeltaThreshold: -0.05`, a process whose true risk\n * difference sits exactly on that margin clears a nominal-95 % `lower > margin`\n * check 24.75 % of the time at n = 40 and 43.95 % at n = 76 (2000 replicates\n * each) when the conditional interval decides.\n *\n * Tango's interval inverts the score test of RD = delta, which estimates the\n * nuisance loss rate under each hypothesised delta instead of fixing it at the\n * observed value, so `m` contributes its own uncertainty. It is the method\n * `ratesci::scorepairci` uses for paired risk-difference noninferiority, and it\n * is not conditional, so it stays valid as the margin moves away from zero.\n *\n * The bounds are found by bisecting `tangoScore(delta) = ±z` — the score is\n * monotone decreasing in delta, so each crossing is unique. Inputs are paired\n * 0/1 (or boolean) arrays, control first. Throws on unequal lengths.\n */\nexport function pairedRiskDifferenceScore(\n  control: ArrayLike<number | boolean>,\n  treatment: ArrayLike<number | boolean>,\n  confidence = 0.95,\n): ScoreRiskDifferenceResult {\n  if (control.length !== treatment.length) {\n    throw new Error(\n      `pairedRiskDifferenceScore: unequal sample sizes (${control.length} vs ${treatment.length})`,\n    )\n  }\n  if (confidence <= 0 || confidence >= 1) {\n    throw new Error(`pairedRiskDifferenceScore: confidence must be in (0,1), got ${confidence}`)\n  }\n  const n = control.length\n  if (n === 0) {\n    return { n: 0, b: 0, c: 0, nDiscordant: 0, riskDifference: 0, lower: -1, upper: 1, confidence }\n  }\n  let b = 0\n  let c = 0\n  for (let i = 0; i < n; i++) {\n    const ctrl = control[i] ? 1 : 0\n    const treat = treatment[i] ? 1 : 0\n    if (treat === 1 && ctrl === 0) b++\n    else if (treat === 0 && ctrl === 1) c++\n  }\n  const riskDifference = (b - c) / n\n  const z = zQuantile(1 - (1 - confidence) / 2)\n\n  // Lower bound: the smallest delta still inside the interval, i.e. the root of\n  // score(delta) = +z on [-1, riskDifference]. score(riskDifference) = 0 < z, so\n  // the right endpoint is always inside and the bisection is well posed.\n  let lo = -1\n  let hi = riskDifference\n  // 64 halvings resolve the [-1, 1] search interval below 6e-20, past the\n  // precision available to the score calculation. More iterations only\n  // repeat identical floating-point values while multiplying every gate\n  // decision's cost.\n  for (let i = 0; i < 64; i++) {\n    const mid = (lo + hi) / 2\n    if (tangoScore(b, c, n, mid) > z) lo = mid\n    else hi = mid\n  }\n  const lower = (lo + hi) / 2\n\n  // Upper bound: root of score(delta) = -z on [riskDifference, 1].\n  let ulo = riskDifference\n  let uhi = 1\n  for (let i = 0; i < 64; i++) {\n    const mid = (ulo + uhi) / 2\n    if (tangoScore(b, c, n, mid) > -z) ulo = mid\n    else uhi = mid\n  }\n  const upper = (ulo + uhi) / 2\n\n  return {\n    n,\n    b,\n    c,\n    nDiscordant: b + c,\n    riskDifference,\n    lower: Math.max(-1, lower),\n    upper: Math.min(1, upper),\n    confidence,\n  }\n}\n\n/**\n * The common positive level `s` such that EVERY value across both paired arms is\n * exactly 0 or `s` — i.e. the outcome is pass/fail, whatever encoding it arrived\n * in. Returns null when the outcomes are not two-point, when the two arms use\n * different levels, or when no positive value was observed at all (all-zero\n * arms: the level is not identified, and there is nothing to decide anyway).\n *\n * This is the scale-aware successor to {@link isBinaryOutcomeVector}, which only\n * recognises literal {0, 1}. Judges in this codebase emit dimensions on 0-100 as\n * well as [0,1] (see `detectScale` in `campaign/gates/statistical-heldout.ts`),\n * so a pass/fail dimension routinely arrives as {0, 100} and a {0,1}-only test\n * silently sends it down the median path that cannot see it. Any positive level\n * is accepted, not just 1 and 100: for a two-point {0, s} outcome the mean paired\n * delta is exactly s·(b − c)/n, so the binary estimators apply after dividing by\n * s and rescaling the result back into the caller's native units.\n *\n * Non-finite values ⇒ null: an unusable outcome must not be classified as a\n * clean pass/fail shape.\n */\nexport function pairedBinaryScale(\n  before: ArrayLike<number>,\n  after: ArrayLike<number>,\n): number | null {\n  let level: number | null = null\n  for (const arm of [before, after]) {\n    for (let i = 0; i < arm.length; i++) {\n      const v = arm[i]!\n      if (!Number.isFinite(v)) return null\n      if (v === 0) continue\n      if (v < 0) return null\n      if (level === null) level = v\n      else if (v !== level) return null\n    }\n  }\n  return level\n}\n\n/**\n * Unbiased pass@k for code generation (Chen et al. 2021, \"Evaluating Large\n * Language Models Trained on Code\"). Given `n` independent samples for one\n * problem of which `c` pass, the probability that at least one of a random k of\n * them passes is 1 − C(n−c, k) / C(n, k). Estimating pass@k as \"did any of the\n * first k pass\" is biased high at small n; this is the variance-reduced estimator\n * averaged implicitly over all k-subsets. Average the per-problem values across\n * the suite for the corpus pass@k. Computed in the numerically stable product\n * form. Requires 1 ≤ k ≤ n and 0 ≤ c ≤ n.\n */\nexport function passAtK(n: number, c: number, k: number): number {\n  if (!Number.isInteger(n) || !Number.isInteger(c) || !Number.isInteger(k)) {\n    throw new Error(`passAtK: n, c, k must be integers (got n=${n}, c=${c}, k=${k})`)\n  }\n  if (k < 1 || k > n || c < 0 || c > n) {\n    throw new Error(`passAtK: require 1 ≤ k ≤ n and 0 ≤ c ≤ n (got n=${n}, c=${c}, k=${k})`)\n  }\n  if (n - c < k) return 1\n  let prob = 1\n  for (let i = n - c + 1; i <= n; i++) prob *= 1 - k / i\n  return 1 - prob\n}\n"],"mappings":";;;;;;;;;AAgCA,SAAgB,OAAO,WAAmB,GAAW,aAAa,KAA0B;CAC1F,IAAI,KAAK,GAAG,OAAO;EAAE,UAAU;EAAG,OAAO;EAAG,OAAO;CAAE;CACrD,IAAI,YAAY,KAAK,YAAY,GAC/B,MAAM,IAAI,MAAM,sBAAsB,UAAU,mBAAmB,EAAE,EAAE;CAEzE,MAAM,IAAI,UAAU,KAAK,IAAI,cAAc,CAAC;CAC5C,MAAM,IAAI,YAAY;CACtB,MAAM,KAAK,IAAI;CACf,MAAM,QAAQ,IAAI,KAAK;CACvB,MAAM,UAAU,IAAI,MAAM,IAAI,MAAM;CACpC,MAAM,OAAQ,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,MAAM,IAAI,MAAM,CAAC,IAAK;CACjE,OAAO;EACL,UAAU;EACV,OAAO,KAAK,IAAI,GAAG,SAAS,IAAI;EAChC,OAAO,KAAK,IAAI,GAAG,SAAS,IAAI;CAClC;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,sBAAsB,QAAoC;CACxE,IAAI,OAAO,WAAW,GAAG,OAAO;CAChC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;EACtC,MAAM,IAAI,OAAO;EACjB,IAAI,MAAM,KAAK,MAAM,GAAG,OAAO;CACjC;CACA,OAAO;AACT;;;;;;;;;;;;;AA8BA,SAAgB,QACd,SACA,WACe;CACf,IAAI,QAAQ,WAAW,UAAU,QAC/B,MAAM,IAAI,MAAM,kCAAkC,QAAQ,OAAO,MAAM,UAAU,OAAO,EAAE;CAE5F,MAAM,IAAI,QAAQ;CAClB,IAAI,IAAI;CACR,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,MAAM,OAAO,QAAQ,KAAK,IAAI;EAC9B,MAAM,QAAQ,UAAU,KAAK,IAAI;EACjC,IAAI,UAAU,KAAK,SAAS,GAAG;OAC1B,IAAI,UAAU,KAAK,SAAS,GAAG;CACtC;CACA,MAAM,cAAc,IAAI;CACxB,MAAM,YAAY,gBAAgB,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,IAAI,MAAM,IAAI;CACvE,OAAO;EAAE;EAAG;EAAa;EAAG;EAAG;EAAW,QAAQ,qBAAqB,GAAG,CAAC;CAAE;AAC/E;;;;;;;;;;;;;;;;AAmCA,SAAgB,qBACd,SACA,WACA,aAAa,KACS;CACtB,IAAI,QAAQ,WAAW,UAAU,QAC/B,MAAM,IAAI,MACR,+CAA+C,QAAQ,OAAO,MAAM,UAAU,OAAO,EACvF;CAEF,MAAM,IAAI,QAAQ;CAClB,IAAI,MAAM,GAAG,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,GAAG;EAAG,gBAAgB;EAAG,OAAO;EAAG,OAAO;EAAG;CAAW;CAC1F,IAAI,IAAI;CACR,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,MAAM,OAAO,QAAQ,KAAK,IAAI;EAC9B,MAAM,QAAQ,UAAU,KAAK,IAAI;EACjC,IAAI,UAAU,KAAK,SAAS,GAAG;OAC1B,IAAI,UAAU,KAAK,SAAS,GAAG;CACtC;CACA,MAAM,MAAM,IAAI,KAAK;CACrB,MAAM,YAAY,IAAI,KAAK,IAAI,MAAM,IAAI,MAAM,IAAI;CAEnD,MAAM,OADI,UAAU,KAAK,IAAI,cAAc,CAC9B,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,QAAQ,CAAC;CAChD,OAAO;EACL;EACA;EACA;EACA,gBAAgB;EAChB,OAAO,KAAK,IAAI,IAAI,KAAK,IAAI;EAC7B,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI;EAC5B;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,0BACd,SACA,WACA,aAAa,KACc;CAC3B,IAAI,QAAQ,WAAW,UAAU,QAC/B,MAAM,IAAI,MACR,oDAAoD,QAAQ,OAAO,MAAM,UAAU,OAAO,EAC5F;CAEF,IAAI,cAAc,KAAK,cAAc,GACnC,MAAM,IAAI,MAAM,+DAA+D,YAAY;CAE7F,MAAM,IAAI,QAAQ;CAClB,IAAI,MAAM,GACR,OAAO;EACL,GAAG;EACH,GAAG;EACH,GAAG;EACH,aAAa;EACb,gBAAgB;EAChB,OAAO;EACP,OAAO;EACP;EACA,QAAQ;CACV;CAEF,IAAI,IAAI;CACR,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,MAAM,OAAO,QAAQ,KAAK,IAAI;EAC9B,MAAM,QAAQ,UAAU,KAAK,IAAI;EACjC,IAAI,UAAU,KAAK,SAAS,GAAG;OAC1B,IAAI,UAAU,KAAK,SAAS,GAAG;CACtC;CACA,MAAM,IAAI,IAAI;CACd,MAAM,kBAAkB,IAAI,KAAK;CACjC,MAAM,SAAS,qBAAqB,GAAG,CAAC;CACxC,IAAI,MAAM,GACR,OAAO;EAAE;EAAG;EAAG;EAAG,aAAa;EAAG,gBAAgB;EAAG,OAAO;EAAG,OAAO;EAAG;EAAY;CAAO;CAE9F,MAAM,QAAQ,IAAI;CAClB,MAAM,QAAQ,MAAM,IAAI,IAAI,aAAa,QAAQ,GAAG,GAAG,IAAI,IAAI,CAAC;CAChE,MAAM,SAAS,MAAM,IAAI,IAAI,aAAa,IAAI,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC;CACrE,MAAM,QAAQ,IAAI;CAClB,OAAO;EACL;EACA;EACA;EACA,aAAa;EACb;EACA,OAAO,KAAK,IAAI,KAAK,IAAI,QAAQ,KAAK,KAAK;EAC3C,OAAO,KAAK,IAAI,IAAI,IAAI,SAAS,KAAK,KAAK;EAC3C;EACA;CACF;AACF;;;;;AAMA,SAAS,aAAa,GAAW,GAAW,GAAmB;CAC7D,IAAI,KAAK,GAAG,OAAO;CACnB,IAAI,KAAK,GAAG,OAAO;CACnB,IAAI,KAAK;CACT,IAAI,KAAK;CACT,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;EAC3B,MAAM,OAAO,KAAK,MAAM;EACxB,IAAI,0BAA0B,KAAK,GAAG,CAAC,IAAI,GAAG,KAAK;OAC9C,KAAK;CACZ;CACA,QAAQ,KAAK,MAAM;AACrB;;;;;;;;;;AAgCA,SAAS,oBAAoB,GAAW,GAAW,GAAW,OAAuB;CACnF,MAAM,IAAI,IAAI,IAAI;CAClB,MAAM,YAAY,IAAI;CACtB,MAAM,SAAS,EAAE,IAAI,IAAI,SAAS,IAAI,IAAI,IAAI,IAAI;CAClD,MAAM,WAAW,CAAC,IAAI,SAAS,IAAI;CACnC,MAAM,eAAe,SAAS,SAAS,IAAI,YAAY;CACvD,MAAM,OAAO,eAAe,IAAI,KAAK,KAAK,YAAY,IAAI;CAC1D,MAAM,KAAK,CAAC,SAAS,SAAS,IAAI;CAElC,OAAO,KAAK,IAAI,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,KAAK,IAAI,IAAI,IAAI,SAAS,CAAC,CAAC;AAChF;;;AAIA,SAAS,WAAW,GAAW,GAAW,GAAW,OAAuB;CAC1E,MAAM,YAAY,IAAI,IAAI,IAAI;CAE9B,MAAM,WAAW,KAAK,IADZ,oBAAoB,GAAG,GAAG,GAAG,KACb,IAAI,SAAS,IAAI;CAC3C,IAAI,EAAE,WAAW,IAAI;EACnB,IAAI,cAAc,GAAG,OAAO;EAC5B,OAAO,YAAY,IAAI,OAAO,oBAAoB,OAAO;CAC3D;CACA,OAAO,YAAY,KAAK,KAAK,QAAQ;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,0BACd,SACA,WACA,aAAa,KACc;CAC3B,IAAI,QAAQ,WAAW,UAAU,QAC/B,MAAM,IAAI,MACR,oDAAoD,QAAQ,OAAO,MAAM,UAAU,OAAO,EAC5F;CAEF,IAAI,cAAc,KAAK,cAAc,GACnC,MAAM,IAAI,MAAM,+DAA+D,YAAY;CAE7F,MAAM,IAAI,QAAQ;CAClB,IAAI,MAAM,GACR,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,GAAG;EAAG,aAAa;EAAG,gBAAgB;EAAG,OAAO;EAAI,OAAO;EAAG;CAAW;CAEhG,IAAI,IAAI;CACR,IAAI,IAAI;CACR,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,MAAM,OAAO,QAAQ,KAAK,IAAI;EAC9B,MAAM,QAAQ,UAAU,KAAK,IAAI;EACjC,IAAI,UAAU,KAAK,SAAS,GAAG;OAC1B,IAAI,UAAU,KAAK,SAAS,GAAG;CACtC;CACA,MAAM,kBAAkB,IAAI,KAAK;CACjC,MAAM,IAAI,UAAU,KAAK,IAAI,cAAc,CAAC;CAK5C,IAAI,KAAK;CACT,IAAI,KAAK;CAKT,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;EAC3B,MAAM,OAAO,KAAK,MAAM;EACxB,IAAI,WAAW,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,KAAK;OAClC,KAAK;CACZ;CACA,MAAM,SAAS,KAAK,MAAM;CAG1B,IAAI,MAAM;CACV,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;EAC3B,MAAM,OAAO,MAAM,OAAO;EAC1B,IAAI,WAAW,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC,GAAG,MAAM;OACpC,MAAM;CACb;CACA,MAAM,SAAS,MAAM,OAAO;CAE5B,OAAO;EACL;EACA;EACA;EACA,aAAa,IAAI;EACjB;EACA,OAAO,KAAK,IAAI,IAAI,KAAK;EACzB,OAAO,KAAK,IAAI,GAAG,KAAK;EACxB;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,kBACd,QACA,OACe;CACf,IAAI,QAAuB;CAC3B,KAAK,MAAM,OAAO,CAAC,QAAQ,KAAK,GAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,MAAM,IAAI,IAAI;EACd,IAAI,CAAC,OAAO,SAAS,CAAC,GAAG,OAAO;EAChC,IAAI,MAAM,GAAG;EACb,IAAI,IAAI,GAAG,OAAO;EAClB,IAAI,UAAU,MAAM,QAAQ;OACvB,IAAI,MAAM,OAAO,OAAO;CAC/B;CAEF,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,QAAQ,GAAW,GAAW,GAAmB;CAC/D,IAAI,CAAC,OAAO,UAAU,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,GACrE,MAAM,IAAI,MAAM,4CAA4C,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;CAElF,IAAI,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,GACjC,MAAM,IAAI,MAAM,mDAAmD,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;CAEzF,IAAI,IAAI,IAAI,GAAG,OAAO;CACtB,IAAI,OAAO;CACX,KAAK,IAAI,IAAI,IAAI,IAAI,GAAG,KAAK,GAAG,KAAK,QAAQ,IAAI,IAAI;CACrD,OAAO,IAAI;AACb"}

package/dist/statistical-heldout-Dq3pnmxd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistical-heldout-Dq3pnmxd.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":";;;;;;;UAgBiB;;EAEf;;EAEA;;EAEA;;;;;;;;;iBAUc,OAAO,mBAAmB,WAAW,sBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CzD,sBAAsB,QAAQ;;UAU7B;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;iBAec,QACd,SAAS,6BACT,WAAW,8BACV;;UAmBc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;iBAkBc,qBACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;;UAkCc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Bc,0BACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;UAyEc;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Dc,0BACd,SAAS,6BACT,WAAW,6BACX,sBACC;;;;;;;;;;;;;;;;;;;;iBAiFa,kBACd,QAAQ,mBACR,OAAO;;;;;;;;;;;iBA0BO,QAAQ,WAAW,WAAW;;;UCrgB7B;;;EAGf;;;;EAIA;;;;EAIA;;;;;;;;EAQA,SAAS;;UAGM;;EAEf;;EAEA;;EAEA;;;;;;;;;;UAWe,sBAAsB;EACrC;EACA;EACA;;EAEA;;EAEA;;EAEA;;;EAGA;;UAGe;;;EAGf,OAAO,YAAY;EACnB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BK,SAAS,OAAM,kBAAuB;;;cCnFhD,mBAAiB,EAAA;;;;;;GAQZ,EAAA,KAAA;;KAGC,2BAA2B,EAAE,aAAa;cAEhD,mBAAiB,EAAA;;;GAKZ,EAAA,KAAA;KAEC,2BAA2B,EAAE,aAAa;UAgCrC;EACf,aAAa;EACb,iBAAiB;EACjB;IAAY,aAAa;IAA0B,WAAW;;;KAGpD,qBAAqB;EAC3B;EAAiB,OAAO;;EACxB;EAAkB;IAAS;IAA8C;;;UAE9D;EACf,QACE,OAAO,2BACN,QAAQ;IAAuB,QAAQ;IAAqB;;EAC/D,OACE,mBACA,aAAa,2BACZ,QAAQ;IAAuB,QAAQ;IAAqB;;EAC/D,QAAQ,QAAQ,qBAAqB;;;cAI1B,2BAA2B;WAE3B;EADX,YACW,8CACT;;;cAQS,mCAAmC;EAC9C,YAAY;;;iBA+HE,wBAAwB;EAAW;IAAiB;;;;;;;;;;;;;;;;;;;;;;;cCvMvD;UAEI;;EAEf,eAAe;;EAEf;;;EAGA;;EAEA;;EAEA;;;EAGA;;UAGe;;EAEf;EACA,YAAY;EACZ,kBAAkB;;EAElB;;UAGe;EACf;;EAEA;;;;;;;;iBAiBc,OAAO,iBAAiB,YAAY,wBAAwB;;;;;;;;;;iBAoB5D,kBACd,iBACA,UAAU,iBACT;;;cC1EU;;cAGA;KAQD,gCAAgC;cAE/B;UAOI;WACN,MAAM;;WAEN;;UAGM;WACN,sBAAsB;;WAEtB;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;WACA,WAAW;;WAEX;;WAEA;;UAGM;WACN,SAAS;WACT,aAAa;;UAGP;WACN;WACA;;UAGM,mCAAmC,KAAK;;;;;;;iBAQzC,sBACd,OAAO,4BACP,YAAY,wBACX;;;;;iBA4Ba,sBAAsB,SAAS,kBAAkB;;;;;;iBAkCjD,sBAAsB,SAAS;;;;KCjJnC,0BAA0B,KACpC;EAOI,YAAY,KAAK;;;iBAGP,8BAA8B,UAAU,UAAU,GAAG;EACnE,UAAU,eAAe,GAAG;EAC5B,SAAS;EACT,SAAS;IAAAA;;;;;;;;;;;;;;;;;;KCPC;UAEK,UAAU;;EAEzB;EACA,WAAW;EACX,QAAQ,WAAW;;UAGJ,aAAa;EAC5B,UAAU;EACV,WAAW;;EAEX,cAAc;IAAQ,WAAW;IAAG,WAAW;;;;iBAIjC,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,YAAY,UAAU;;;;;;iBAmB/C,eAAe,GAAG,YAAY,KAAK,YAAY,UAAU,OAAO,aAAa;;;;;KCxBjF;EAAoB;;EAAwB;EAAmB;;UAE1D;;EAEf;EACA,QAAQ;;;EAGR,WAAW;;;;EAIX;;;;EAIA;;;;;EAKA;;;;KAKU;UAEK;EACf;EACA,QAAQ;EACR,WAAW;;;;;;;;EAQX,WAAW;;;;;EAKX;;;EAGA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;;EAGT;;EAEA;EACA;EACA,gBAAgB;EAChB;EACA;EACA,SAAS;;UAGM;;EAEf,MAAM;;;EAGN;;;EAGA;IAAQ;IAAmB;;;;;;KAMjB,mBAAmB,IAAI,mBAAmB;UAErC;;;;EAIf;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;;;iBASc,oBAAoB,WAAW,kBAAkB,UAC/D,KAAK,YAAY,WAAW,YAC5B,YAAY,sBACZ,OAAM,6BACL;;;;;;cAkIU,cAAc;UA+EV,sCAAsC;;EAErD,YAAY;;;EAGZ,SAAS;;EAET;;;;;;;iBAQc,uBAAuB,qBAAqB,kBAAkB,WAAW,UACvF,SAAS,gCACR,KAAK,WAAW;;;;;;;;;;;;;;;;;UCzVF;;EAEf;;;EAGA;;EAEA;;EAEA;;;;EAIA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;EAGA;;;EAGA;EACA;EACA;;EAEA;;EAEA;;;iBAYc,eAAe,MAAM,wBAAwB;;;;;UCzB5C;;;EAGf;;;;;EAKA;;EAEA;;EAEA;;EAEA,UAAU;;UAGK;;EAEf;;EAEA;;;UAIe;EACf;;;;EAIA;EACA,UAAU;EACV,WAAW;;UAGI;;EAEf,OAAO;;;EAGP,kBAAkB;;EAElB,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAqBL,SAAS,eAAe,gBAAgB,MAAM,kBAAkB;;UA8G/D;;EAEf;;EAEA;;EAEA,SAAS;;EAET,gBAAgB;;;UAID;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,aAAa;;EAEb;IAAY;IAAW;;;UAGR,iCAAiC;;;;EAIhD;;EAEA,YAAY;;UAGG;EACf;EACA;EACA;;;EAGA,aAAa;EACb,cAAc;;;;;;;;;;;;;;;iBAgBA,kBACd,eAAe,gBACf,MAAM,2BACL;UAmEc;EACf;EACA;EACA,UAAU;EACV,WAAW;;UAGI;EACf,OAAO;EACP,kBAAkB;EAClB,mBAAmB;;;;;;;;;iBAeL,eACd,uBAAuB,aACvB,wBAAwB,cACvB;;;;;;;;;;;;;;;;UCrWc;EACf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;;KAIU;UAEK,uBAAuB;;EAEtC;;EAEA,MAAM;;UAGS;EACf,UAAU;EACV;EACA;EACA;;;EAGA;;EAEA,kBAAkB;EAGlB;;;;;;;;;;;;;;;;;iBAkBoB,SAAS,GAAG,KAAK,IAAI;;;;;iBAQ3B,sBAAsB,UAAU;;;;;;iBAc1B,aAAa,GAAG,qBAAqB,QAAQ;;;;;iBAS7C,eAAe,GAAG,iBAAiB;;;;;iBAYnC,mBACpB,UAAU,gBACV;EAAY;EAAW;EAAgB;IACtC,QAAQ;;;KCrFC;UAEK;EACf,UAAU;;EAEV;;EAEA;;;EAGA;;UAGe;;;EAGf;;;;EAIA;;;EAGA;;EAEA;;;;EAIA;;;EAGA;;;;EAIA,8BAA8B;;;EAG9B,kBAAkB;;EAElB;;;;;;;EAOA,SAAS;;;;;;KAOC,wBAAwB;EAAkB,UAAU;;UAE/C,qBAAqB,qBAAqB,kBAAkB,WAAW,kBAC9E,KAAK,WAAW;;;;;;;;;;EAUxB,QAAQ,gBAAgB;;;EAGxB,SAAS;;;;;;;;;;;;;;;;;iBAuPK,qBAAqB,qBAAqB,kBAAkB,WAAW,UACrF,SAAS,8BACR,qBAAqB,WAAW;UA6GlB;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;GACd;IAAQ,SAAS;;IAAyB;IAAe;;;EAE1D,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BK,iBAAiB,UAAS,0BAA+B;;;UC9dxD;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;iBA4Ec,YACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,SAAS,GAAG,oCACX;UAkEc;EACf,QAAQ;;;;;;;;;;;;EAYR,WAAW;;;;EAIX,iBAAiB;;;;;;;EAOjB,UAAU;;EAEV,mBAAmB;;EAEnB,SAAS;;;;EAIT;;EAEA;;EAEA;EACA;;EAEA;;EAEA;;EAEA,gBAAgB;;EAEhB;;;;EAIA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;EACA;;EAEA,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BhB,oBACd,QAAQ,eACR,OAAM,6BACL;UA2Ec;EACf;;;EAGA,WAAW;;;;EAIX;;EAEA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;EAET;;;;EAIA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;;;;iBAMc,YAAY;;;;;;;;;iBAYZ,qBACd,WAAW,YAAY,eAAe,cACtC,UAAU,YAAY,eAAe,cACrC,aAAa,aACb,8BACA;EACE;EACA;EACA;EACA;;;EAGA;EACA,8BAA8B;EAC9B;IAED"}