react-semaphor 0.1.527 → 0.1.529

package/dist/chunks/matrix-operation-contract-BotZ-6zT.js

@@ -0,0 +1,1383 @@
+import { z as t } from "zod";
+import { a5 as k, $ as ce, aa as G, bl as ee, B as A, a6 as je, bf as K, bm as Fe, aX as Le, a0 as Ue, b0 as qe, b1 as De, b4 as Me, b5 as Be, aQ as U, aV as Z, aK as Ge, a_ as ze, a$ as le, aH as Ve, aG as We, aW as Xe, aN as $e, aO as Ke, w as ue, aS as Ze, s as He, q as de, E as Ye, A as Qe, m as Je } from "./validators-BS521dum.js";
+const H = {
+  answerSummary: "string",
+  responseDetail: "responseDetail",
+  mode: "string",
+  comparisonKind: "string",
+  executionResult: "executionResult",
+  compiledQuery: "unknown",
+  data: "unknown",
+  resultSets: "record",
+  analysisWarnings: "unknownArray",
+  columns: "unknownArray",
+  records: "recordArray",
+  rowCount: "number",
+  rowLimitExceeded: "boolean",
+  output: "string",
+  querySpec: "unknown",
+  metadata: "record",
+  validation: "validationResult",
+  coverage: "coverage",
+  diagnosticFeedback: "diagnosticFeedback",
+  missingFields: "stringArray",
+  warnings: "unknownArray",
+  comparison: "unknown",
+  population: "population",
+  comparisons: "recordArray",
+  fieldsUsed: "compactExecutionFieldArray",
+  primary: "recordArray",
+  contributors: "recordArray",
+  segments: "recordArray",
+  periodChanges: "recordArray",
+  changes: "recordArray",
+  largestNegativeChanges: "recordArray",
+  largestPositiveChanges: "recordArray",
+  drivers: "recordArray",
+  absoluteDeltaDrivers: "recordArray",
+  largestNegativeDrivers: "recordArray",
+  largestPositiveDrivers: "recordArray",
+  periodRows: "recordArray",
+  sql: "unknown",
+  omitted: "stringArray"
+}, me = [
+  /** The request can't run as asked (no specific validation code applies). */
+  "invalid_request",
+  /** No authored relationship connects the requested datasets. */
+  "missing_relationship",
+  /** More than one relationship path fits and none is preferred. */
+  "ambiguous_relationship",
+  /** The join would repeat measure rows (fan-out, chasm, unknown cardinality). */
+  "unsafe_join",
+  /** The request needs something this surface doesn't support yet. */
+  "unsupported_capability",
+  /** The caller lacks a capability (for example raw SQL). */
+  "capability_required",
+  "forbidden",
+  "not_found",
+  /** The warehouse or driver failed while the query ran; the message is its own. */
+  "execution_failed",
+  "timeout",
+  "budget_exceeded",
+  "cancelled"
+], et = {
+  invalid_request: 400,
+  missing_relationship: 400,
+  ambiguous_relationship: 400,
+  unsafe_join: 400,
+  unsupported_capability: 400,
+  capability_required: 403,
+  forbidden: 403,
+  not_found: 404,
+  execution_failed: 502,
+  timeout: 504,
+  budget_exceeded: 413,
+  cancelled: 499
+}, tt = /* @__PURE__ */ new Set(["execution_failed", "timeout"]);
+function nt(e) {
+  return typeof e == "string" && me.includes(e);
+}
+function at(e, n, a = {}) {
+  return {
+    code: e,
+    message: n,
+    ...a.details ? { details: a.details } : {},
+    ...a.nextStep ? { nextStep: a.nextStep } : {},
+    retryable: tt.has(e),
+    status: a.status ?? et[e]
+  };
+}
+function rn(e) {
+  if (!e || typeof e != "object") return;
+  const n = e.refusal ?? e;
+  if (!n || typeof n != "object") return;
+  const { code: a, message: r } = n;
+  if (!(!nt(a) || typeof r != "string"))
+    return n;
+}
+const rt = {
+  invalid_request: { message: "This query configuration cannot run.", nextStep: "Check the selected fields, filters and parameters." },
+  missing_relationship: { message: "The selected data is not connected.", nextStep: "Choose related datasets or ask the owner to add a relationship." },
+  ambiguous_relationship: { message: "The selected data has more than one relationship path.", nextStep: "Choose the relationship to use." },
+  unsafe_join: { message: "This query could count values more than once.", nextStep: "Group by shared fields or query the measures separately." },
+  unsupported_capability: { message: "This query needs a capability this view does not support.", nextStep: "Change the query configuration." },
+  capability_required: { message: "You do not have access to this capability.", nextStep: "Ask the owner for access." },
+  forbidden: { message: "You do not have access to this data.", nextStep: "Ask the owner for access." },
+  not_found: { message: "The requested data is no longer available.", nextStep: "Ask the owner to check the data source." },
+  execution_failed: { message: "The query could not complete.", nextStep: "Try again. If it keeps failing, contact the owner." },
+  timeout: { message: "The query took too long to complete.", nextStep: "Try again or narrow the query." },
+  budget_exceeded: { message: "The query exceeds this view’s limits.", nextStep: "Request fewer rows, columns or measures." },
+  cancelled: { message: "The query was cancelled.", nextStep: "Reload the view when ready." }
+};
+function sn(e) {
+  const n = rt[e.code], a = at(e.code, n.message, { nextStep: n.nextStep, status: e.status }), r = e.retryable ?? a.retryable;
+  return {
+    ...a,
+    retryable: r,
+    ...!r && a.retryable ? { nextStep: "Ask the owner to check the query." } : {}
+  };
+}
+const st = [
+  ...me,
+  "stale_cursor",
+  "source_truncated"
+], on = Object.freeze({
+  coordinates: 2e4,
+  responseBytes: 5 * 1024 * 1024
+}), O = t.string().uuid(), y = t.string().min(1), ot = t.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+function f(e, n, a) {
+  e.addIssue({ code: "custom", path: n, message: a });
+}
+function v(e, n, a) {
+  new Set(e).size !== e.length && f(n, a, "Duplicate identity.");
+}
+const it = t.object({
+  id: y,
+  axis: ce,
+  parent: k,
+  position: t.union([
+    t.object({ kind: t.literal("first") }).strict(),
+    t.object({ kind: t.enum(["after", "before"]), cursor: y }).strict()
+  ]),
+  size: ot
+}).strict(), te = t.object({
+  paths: t.array(k).readonly(),
+  pageIds: t.array(y).readonly()
+}).strict(), ct = t.object({
+  id: y,
+  rows: te,
+  columns: te,
+  measureIds: t.array(O).min(1).readonly()
+}).strict(), pe = t.object({
+  pages: t.array(it).readonly(),
+  blocks: t.array(ct).readonly()
+}).strict().superRefine((e, n) => {
+  !e.pages.length && !e.blocks.length && f(n, [], "Request at least one page or block."), v(
+    [...e.pages, ...e.blocks].map((a) => a.id),
+    n,
+    []
+  );
+  for (const a of e.blocks) {
+    v(a.measureIds, n, ["blocks", a.id, "measureIds"]);
+    for (const r of ["rows", "columns"])
+      for (const s of a[r].pageIds)
+        e.pages.some(
+          (c) => c.id === s && c.axis === r
+        ) || f(
+          n,
+          ["blocks", a.id, r],
+          "Page reference must name a page on this axis in this operation."
+        );
+  }
+}), cn = t.object({ spec: G, request: pe }).strict().superRefine(({ spec: e, request: n }, a) => {
+  for (const r of n.pages)
+    ee(
+      e,
+      r.axis,
+      r.parent,
+      a,
+      ["pages", r.id],
+      !0
+    ), r.parent.length >= e[r.axis].length && f(
+      a,
+      ["pages", r.id],
+      "Cannot request children of a leaf or empty axis."
+    );
+  for (const r of n.blocks) {
+    r.measureIds.some((s) => !e.measures.some((c) => c.id === s)) && f(a, ["blocks", r.id], "Unknown block measure.");
+    for (const s of ["rows", "columns"])
+      for (const c of r[s].paths)
+        ee(e, s, c, a, ["blocks", r.id, s]);
+  }
+}), lt = t.object({
+  requestId: y,
+  axis: ce,
+  parent: k,
+  members: t.array(t.object({ path: k }).strict()).readonly(),
+  before: y.nullable(),
+  after: y.nullable(),
+  exactCount: t.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional()
+}).strict().superRefine((e, n) => {
+  e.parent.some((r) => r.member.kind === "others") && f(n, ["parent"], "Others has no children.");
+  const a = e.members.filter(
+    ({ path: r }) => {
+      var s;
+      return ((s = r[r.length - 1]) == null ? void 0 : s.member.kind) === "others";
+    }
+  );
+  a.length > 1 && f(n, ["members"], "A page may contain Others only once."), a.length && (e.members[e.members.length - 1] !== a[0] && f(n, ["members"], "Others must be the last page member."), e.after !== null && f(n, ["after"], "Others must end the branch.")), new Set(
+    e.members.map(
+      (r) => {
+        var s;
+        return (s = r.path[r.path.length - 1]) == null ? void 0 : s.levelId;
+      }
+    )
+  ).size > 1 && f(n, ["members"], "One page must contain one child level."), v(
+    e.members.map((r) => A(r.path)),
+    n,
+    ["members"]
+  );
+  for (const r of e.members)
+    (r.path.length !== e.parent.length + 1 || A(r.path.slice(0, -1)) !== A(e.parent)) && f(n, ["members"], "Page members must be immediate children.");
+}), he = t.object({
+  rowPaths: t.array(k).readonly(),
+  columnPaths: t.array(k).readonly(),
+  measureIds: t.array(O).readonly()
+}).strict();
+function fe(e, n) {
+  const a = e.rowPaths.map(A), r = e.columnPaths.map(A);
+  return v(a, n, ["coverage", "rowPaths"]), v(r, n, ["coverage", "columnPaths"]), v(e.measureIds, n, ["coverage", "measureIds"]), { rows: a, columns: r };
+}
+const ut = t.object({
+  requestId: y,
+  coverage: he,
+  cells: t.array(
+    je.extend({ value: K }).strict()
+  ).readonly()
+}).strict().superRefine((e, n) => {
+  const { rows: a, columns: r } = fe(e.coverage, n), s = new Set(a), c = new Set(r), i = new Set(e.coverage.measureIds);
+  v(
+    e.cells.map(
+      (l) => JSON.stringify([
+        A(l.rowPath),
+        A(l.columnPath),
+        l.measureId
+      ])
+    ),
+    n,
+    ["cells"]
+  );
+  for (const l of e.cells)
+    (!s.has(A(l.rowPath)) || !c.has(A(l.columnPath)) || !i.has(l.measureId)) && f(n, ["cells"], "Cell is outside certified coverage.");
+}), q = t.number().int().nonnegative(), dt = t.object({
+  requestId: y,
+  coverage: he,
+  values: t.array(
+    t.tuple([q, q, q, K]).readonly()
+  ).readonly()
+}).strict().superRefine((e, n) => {
+  fe(e.coverage, n);
+  const { rowPaths: a, columnPaths: r, measureIds: s } = e.coverage, c = /* @__PURE__ */ new Set();
+  for (const [i, l, m] of e.values) {
+    if (i >= a.length || l >= r.length || m >= s.length) {
+      f(n, ["values"], "Cell is outside certified coverage.");
+      continue;
+    }
+    const o = `${i},${l},${m}`;
+    c.has(o) && f(n, ["values"], "Duplicate identity."), c.add(o);
+  }
+}), ne = t.object({
+  id: O,
+  column: Le,
+  nativeDataType: y,
+  semanticFormat: Fe.optional()
+}).strict(), ge = t.object({
+  levels: t.array(ne).readonly(),
+  measures: t.array(ne).readonly()
+}).strict(), Y = t.object({
+  code: t.enum(st),
+  message: y,
+  /** Technical cause for dashboard owners; never shown as the primary copy. */
+  detail: y.optional(),
+  details: t.record(t.unknown()).optional(),
+  nextStep: y.optional(),
+  status: t.number().int().optional(),
+  retryable: t.boolean(),
+  scope: t.union([
+    t.object({ kind: t.literal("operation") }).strict(),
+    t.object({ kind: t.enum(["page", "block"]), requestId: y }).strict()
+  ])
+}).strict(), mt = t.object({
+  dialect: t.enum(["postgres", "clickhouse", "duckdb"]),
+  aggregates: t.array(Ue).readonly()
+}).strict();
+function ye(e) {
+  return t.object({
+    queryIdentity: y,
+    descriptors: ge,
+    capabilities: mt,
+    pages: t.array(lt).readonly(),
+    blocks: t.array(e).readonly(),
+    failures: t.array(Y).readonly()
+  }).strict().superRefine((n, a) => {
+    const r = new Set(
+      n.descriptors.levels.map((i) => i.id)
+    ), s = new Set(
+      n.descriptors.measures.map((i) => i.id)
+    ), c = n.pages.flatMap((i) => [
+      i.parent,
+      ...i.members.map((l) => l.path)
+    ]);
+    for (const i of n.blocks)
+      c.push(...i.coverage.rowPaths, ...i.coverage.columnPaths), i.coverage.measureIds.some((l) => !s.has(l)) && f(
+        a,
+        ["blocks", i.requestId],
+        "Coverage references an unknown measure descriptor."
+      );
+    c.some((i) => i.some((l) => !r.has(l.levelId))) && f(
+      a,
+      ["descriptors"],
+      "Acquired paths require level descriptors."
+    ), v(
+      [...n.descriptors.levels, ...n.descriptors.measures].map(
+        (i) => i.id
+      ),
+      a,
+      ["descriptors"]
+    ), v(
+      [...n.pages, ...n.blocks].map((i) => i.requestId),
+      a,
+      []
+    ), v(
+      n.failures.map(
+        (i) => i.scope.kind === "operation" ? "operation" : i.scope.requestId
+      ),
+      a,
+      ["failures"]
+    );
+    for (const i of n.failures)
+      if (i.scope.kind === "operation")
+        f(
+          a,
+          ["failures"],
+          "Operation failure cannot accompany acquired data."
+        );
+      else {
+        const l = i.scope.requestId;
+        [...n.pages, ...n.blocks].some(
+          (m) => m.requestId === l
+        ) && f(
+          a,
+          ["failures"],
+          "A requested unit cannot both succeed and fail."
+        );
+      }
+  });
+}
+const Se = ye(
+  ut
+), pt = ye(
+  dt
+);
+function be(e) {
+  return t.union([
+    t.object({
+      status: t.enum(["success", "partial"]),
+      window: e
+    }).strict(),
+    t.object({ status: t.literal("failed"), failure: Y }).strict()
+  ]).superRefine((n, a) => {
+    const r = n;
+    if (r.status === "failed") return;
+    const { window: s } = r;
+    !s.pages.length && !s.blocks.length && f(
+      a,
+      ["window"],
+      "A window outcome requires successful acquired work."
+    ), r.status === "success" != (s.failures.length === 0) && f(a, ["status"], "Status must match failure coverage.");
+  });
+}
+const ln = be(
+  Se
+), un = be(
+  pt
+);
+function ht(e) {
+  const { rowPaths: n, columnPaths: a, measureIds: r } = e.coverage, s = (m) => new Map(m.map((o, d) => [o, d])), c = s(n.map(A)), i = s(a.map(A)), l = s(r);
+  return {
+    requestId: e.requestId,
+    coverage: e.coverage,
+    values: e.cells.map((m) => {
+      const o = c.get(A(m.rowPath)), d = i.get(A(m.columnPath)), p = l.get(m.measureId);
+      if (o === void 0 || d === void 0 || p === void 0)
+        throw new Error("Cell is outside certified coverage.");
+      return [o, d, p, m.value];
+    })
+  };
+}
+function ft(e) {
+  const { rowPaths: n, columnPaths: a, measureIds: r } = e.coverage;
+  return {
+    requestId: e.requestId,
+    coverage: e.coverage,
+    cells: e.values.map(([s, c, i, l]) => ({
+      rowPath: n[s],
+      columnPath: a[c],
+      measureId: r[i],
+      value: l
+    }))
+  };
+}
+function gt(e) {
+  return { ...e, blocks: e.blocks.map(ht) };
+}
+function dn(e) {
+  return { ...e, blocks: e.blocks.map(ft) };
+}
+function mn(e) {
+  return e.status === "failed" ? e : { status: e.status, window: gt(e.window) };
+}
+const Ae = t.object({
+  kind: t.literal("matrix"),
+  window: Se
+}).strict(), Ie = t.enum(["member", "subtotal", "grand_total"]), yt = t.discriminatedUnion("kind", [
+  t.object({ kind: t.literal("hierarchy"), label: t.string() }).strict(),
+  t.object({ kind: t.literal("level"), levelId: O, label: t.string() }).strict(),
+  t.object({
+    kind: t.literal("measure"),
+    measureId: O,
+    columnPath: k,
+    role: Ie,
+    label: t.string()
+  }).strict()
+]), St = t.object({
+  columns: t.array(yt).readonly(),
+  descriptors: ge
+}).strict(), ae = t.union([
+  t.object({
+    kind: t.literal("value"),
+    value: K.refine(
+      (e) => e !== null
+    )
+  }).strict(),
+  t.object({ kind: t.enum(["null", "empty"]) }).strict()
+]), bt = t.discriminatedUnion("kind", [
+  t.object({
+    kind: t.literal("layout"),
+    rowPath: k,
+    role: Ie,
+    values: t.array(ae).readonly()
+  }).strict(),
+  t.object({
+    kind: t.literal("flat"),
+    rowPath: k,
+    columnPath: k,
+    values: t.array(ae).readonly()
+  }).strict()
+]), pn = t.discriminatedUnion("kind", [
+  t.object({
+    kind: t.literal("layout"),
+    layout: St,
+    next: y
+  }).strict(),
+  t.object({
+    kind: t.literal("rows"),
+    rows: t.array(bt).readonly(),
+    next: y.nullable()
+  }).strict()
+]), At = t.union([
+  qe,
+  De,
+  Me,
+  Be,
+  Ae
+]), It = t.object({
+  status: t.enum([
+    "not_required",
+    "resolved",
+    "missing",
+    "ambiguous",
+    "fanout_risk",
+    "unknown"
+  ]),
+  requiredSources: t.array(U).optional(),
+  relationshipsUsed: t.array(t.string()).optional(),
+  missingSources: t.array(t.string()).optional(),
+  warnings: t.array(t.string()).optional(),
+  message: t.string().optional(),
+  recommendedNextStep: t.string().optional(),
+  joinPlanSummary: t.object({
+    baseSource: U.optional(),
+    joinedSources: t.array(U).optional(),
+    joinCount: t.number().optional()
+  }).passthrough().optional(),
+  fanoutRisk: t.object({
+    status: t.enum(["none", "warning", "error", "unknown"]),
+    message: t.string().optional()
+  }).passthrough().optional()
+}).passthrough(), re = t.enum([
+  "ambiguous_fields",
+  "empty_result",
+  "missing_grounded_fields",
+  "missing_relationship",
+  "no_grounded_query",
+  "partial_result",
+  "presentation_incomplete",
+  "query_validation_failed",
+  "unsafe_join"
+]), _e = t.object({
+  version: t.literal(1),
+  status: t.enum(["answered", "partial", "blocked"]),
+  summary: t.string(),
+  answered: t.array(
+    t.object({
+      slotId: t.string().optional(),
+      queryId: t.string().optional(),
+      summary: t.string(),
+      evidenceIds: t.array(t.string()).optional(),
+      fieldsUsed: t.array(Z).optional()
+    }).passthrough()
+  ),
+  blocked: t.array(
+    t.object({
+      slotId: t.string().optional(),
+      queryId: t.string().optional(),
+      reasonCode: re,
+      message: t.string(),
+      missingFields: t.array(t.string()).optional(),
+      availableFields: t.array(t.string()).optional(),
+      ambiguousFields: t.array(t.string()).optional(),
+      missingRelationships: t.array(t.string()).optional(),
+      evidenceIds: t.array(t.string()).optional(),
+      neededFromUser: t.array(t.string()).optional(),
+      recommendedNextStep: t.string().optional()
+    }).passthrough()
+  ),
+  semanticModelRecommendations: t.array(
+    t.object({
+      reasonCode: re,
+      message: t.string(),
+      recommendedNextStep: t.string().optional()
+    }).passthrough()
+  ).optional()
+}).passthrough(), we = t.object({
+  scope: t.literal("filtered_query"),
+  measures: t.record(Ge)
+}).passthrough(), ke = t.object({
+  answeredObligations: t.array(t.string()),
+  missingObligations: t.array(t.string()),
+  warnings: t.array(ze).optional()
+}).passthrough(), ve = t.object({
+  intentId: t.string().optional(),
+  queryId: t.string().optional(),
+  status: t.enum(["answered", "partial", "failed"]),
+  resultShape: t.enum([
+    "metric",
+    "records",
+    "inputOptions",
+    "sql",
+    "matrix",
+    "period_change",
+    "analysis"
+  ]).optional(),
+  intent: t.unknown().optional(),
+  compiledQuery: t.unknown().optional(),
+  fieldsUsed: t.array(Z).optional(),
+  result: At.optional(),
+  validation: le,
+  coverage: ke.optional(),
+  missingFields: t.array(t.string()).optional(),
+  warnings: t.array(t.string()).optional(),
+  relationshipDiagnostics: It.optional(),
+  diagnosticFeedback: _e.optional(),
+  population: we.optional(),
+  metadata: t.record(t.string(), t.unknown()).optional()
+}).passthrough(), _t = ve;
+function wt(e) {
+  switch (e) {
+    case "boolean":
+      return t.boolean().optional();
+    case "compactExecutionFieldArray":
+      return t.array(Xe).optional();
+    case "coverage":
+      return ke.optional();
+    case "diagnosticFeedback":
+      return _e.optional();
+    case "executionFieldArray":
+      return t.array(Z).optional();
+    case "executionResult":
+      return _t.optional();
+    case "number":
+      return t.number().finite().optional();
+    case "population":
+      return we.optional();
+    case "record":
+      return We.optional();
+    case "recordArray":
+      return Ve.optional();
+    case "responseDetail":
+      return t.enum(["compact", "standard", "debug"]).optional();
+    case "string":
+      return t.string().optional();
+    case "stringArray":
+      return t.array(t.string()).optional();
+    case "unknown":
+      return t.unknown().optional();
+    case "unknownArray":
+      return t.array(t.unknown()).optional();
+    case "validationResult":
+      return le.optional();
+  }
+}
+const kt = Object.fromEntries(
+  Object.entries(H).map(
+    ([e, n]) => [e, wt(n)]
+  )
+), vt = t.object(kt).strict(), Tt = new Set(
+  Object.keys(H)
+);
+function hn() {
+  return Object.keys(
+    H
+  );
+}
+function Rt(e) {
+  return Tt.has(e);
+}
+function fn(e) {
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw new Error("Semaphor analyze result must be an object.");
+  const a = Object.keys(e).filter(
+    (r) => !Rt(r)
+  );
+  if (a.length)
+    throw new Error(
+      `Semaphor analyze result contains unsupported top-level field(s): ${a.join(", ")}.`
+    );
+  return vt.parse(e);
+}
+const Te = 100, F = "selection:";
+function Re(e) {
+  return [
+    de(e.source),
+    Ye(e.name),
+    e.sourceField ?? ""
+  ].join("::");
+}
+function gn(e) {
+  return `${F}${e}`;
+}
+function Et(e) {
+  return e.startsWith(F) && e.length > F.length;
+}
+function yn(e) {
+  return Et(e) ? e.slice(F.length) : void 0;
+}
+function Ee(e) {
+  if (!e) return "";
+  const n = e.calendar.fiscalCalendar;
+  return JSON.stringify([
+    e.granularity,
+    e.calendar.tz,
+    e.calendar.weekStart,
+    n ? [n.kind, n.yearStartMonth] : null
+  ]);
+}
+function Ct(e) {
+  return JSON.stringify([
+    Re(e.field),
+    e.operator,
+    e.operator === "isNull" ? null : e.value,
+    Ee(e.temporalBucket)
+  ]);
+}
+function se(e) {
+  return JSON.stringify(e.conditions.map(Ct).sort());
+}
+function z(e) {
+  return JSON.stringify([
+    de(e.field.source),
+    e.field.name,
+    e.operator,
+    e.operator === "isNull" ? null : e.value,
+    Ee(e.temporalBucket)
+  ]);
+}
+function oe(e) {
+  return JSON.stringify(
+    e.conditions.map(z).sort()
+  );
+}
+function Sn(e) {
+  const n = e.map((a) => a.id);
+  if (new Set(n).size !== n.length)
+    throw new Error("Data App selections require one active selection per id.");
+  return e.map((a) => ({
+    ...a,
+    tuples: a.tuples.map((r) => ({
+      ...r,
+      conditions: [...r.conditions].sort(
+        (s, c) => D(
+          z(s),
+          z(c)
+        )
+      )
+    })).sort(
+      (r, s) => D(
+        oe(r),
+        oe(s)
+      )
+    )
+  })).sort((a, r) => D(a.id, r.id));
+}
+function D(e, n) {
+  return e < n ? -1 : e > n ? 1 : 0;
+}
+function bn(e, n) {
+  return se(e) === se(n);
+}
+const Nt = "(Blank)";
+function An(e) {
+  return e.conditions.map((n) => n.label ? n.label : n.operator === "isNull" || n.value === null ? Nt : String(n.value)).join(" · ");
+}
+const Ot = t.union([
+  $e,
+  Ke
+]), xt = t.object({
+  name: t.string().min(1),
+  source: Ot,
+  dataType: t.enum(["string", "number", "boolean", "date", "datetime"]),
+  sourceField: t.string().min(1).optional()
+}).strict(), Pt = t.object({
+  field: xt,
+  operator: t.enum(["=", "isNull"]),
+  value: t.union([t.string(), t.number().finite(), t.null()]),
+  label: t.string().optional(),
+  temporalBucket: ue.optional()
+}).strict().superRefine((e, n) => {
+  e.operator === "isNull" != (e.value === null) && n.addIssue({
+    code: t.ZodIssueCode.custom,
+    message: "isNull carries a null value, and only isNull does.",
+    path: ["value"]
+  });
+}), jt = t.object({
+  conditions: t.array(Pt).min(1)
+}).strict().superRefine((e, n) => {
+  const a = e.conditions.map((r) => Re(r.field));
+  new Set(a).size !== a.length && n.addIssue({
+    code: t.ZodIssueCode.custom,
+    message: "A tuple holds one condition per field.",
+    path: ["conditions"]
+  });
+}), In = t.object({
+  kind: t.literal("selection"),
+  sourceCardId: t.string().min(1),
+  tuples: t.array(jt).min(1).max(Te)
+}).strict(), Ft = t.object({
+  field: Ze,
+  operator: t.enum(["=", "isNull"]),
+  value: t.union([t.string(), t.number().finite(), t.null()]),
+  temporalBucket: ue.optional()
+}).strict().superRefine((e, n) => {
+  e.operator === "isNull" != (e.value === null) && n.addIssue({
+    code: t.ZodIssueCode.custom,
+    message: "isNull carries a null value, and only isNull does.",
+    path: ["value"]
+  });
+}), Lt = t.object({
+  conditions: t.array(Ft).min(1)
+}).strict().superRefine((e, n) => {
+  for (let a = 0; a < e.conditions.length; a += 1) {
+    const r = e.conditions[a];
+    e.conditions.findIndex(
+      (c, i) => i < a && He(c.field, r.field)
+    ) !== -1 && n.addIssue({
+      code: t.ZodIssueCode.custom,
+      message: "A selection tuple can contain only one condition per field.",
+      path: ["conditions", a, "field"]
+    });
+  }
+}), _n = t.object({
+  id: t.string().min(1),
+  tuples: t.array(Lt).min(1).max(Te)
+}).strict(), Ut = t.object({ key: t.string().min(1), nativeText: t.string().nullable() }).strict(), qt = t.object({
+  executionInstant: t.string().refine((e) => Qe(e) !== null, {
+    message: "executionInstant must be an ISO instant"
+  }),
+  dataAnchors: t.array(Ut).default([])
+}).strict().refine(
+  (e) => new Set(e.dataAnchors.map((n) => n.key)).size === e.dataAnchors.length,
+  { message: "dataAnchors keys must be unique", path: ["dataAnchors"] }
+);
+function wn(e) {
+  if (e == null) return;
+  const n = qt.safeParse(e);
+  return n.success ? n.data : void 0;
+}
+const Ce = {
+  COUNT: "count",
+  COUNTIF: "count",
+  COUNT_IF: "count",
+  COUNTIFS: "count",
+  SUM: "sum",
+  SUM_IF: "sum",
+  SUMIF: "sum",
+  AVG: "avg",
+  AVG_IF: "avg",
+  AVERAGE: "avg",
+  MEAN: "avg",
+  MIN: "min",
+  MIN_IF: "min",
+  MAX: "max",
+  MAX_IF: "max",
+  MEDIAN: "median",
+  DISTINCT: "count_distinct",
+  COUNT_DISTINCT: "count_distinct",
+  APPROX_COUNT_DISTINCT: "count_distinct",
+  APPROX_DISTINCT: "count_distinct",
+  NDV: "count_distinct",
+  UNIQ: "count_distinct",
+  UNIQEXACT: "count_distinct",
+  UNIQCOMBINED: "count_distinct",
+  UNIQHLL12: "count_distinct",
+  HLL_COUNT: "count_distinct",
+  HLL_ESTIMATE: "count_distinct",
+  BOOL_AND: "repeat_safe_other",
+  BOOL_OR: "repeat_safe_other",
+  BIT_AND: "repeat_safe_other",
+  BIT_OR: "repeat_safe_other",
+  EVERY: "repeat_safe_other",
+  ANY_VALUE: "repeat_safe_other",
+  MODE: "other",
+  APPROX_QUANTILES: "other",
+  APPROX_QUANTILE: "other",
+  APPROX_TOP_COUNT: "other",
+  APPROX_TOP_SUM: "other",
+  STDDEV: "other",
+  STDDEV_POP: "other",
+  STDDEV_SAMP: "other",
+  VARIANCE: "other",
+  VAR_POP: "other",
+  VAR_SAMP: "other",
+  BIT_XOR: "other",
+  CORR: "other",
+  COVAR_POP: "other",
+  COVAR_SAMP: "other",
+  STRING_AGG: "other",
+  ARRAY_AGG: "other",
+  JSON_AGG: "other",
+  JSONB_AGG: "other",
+  OBJECT_AGG: "other",
+  MAP_AGG: "other",
+  LISTAGG: "other",
+  GROUP_CONCAT: "other",
+  COLLECT_LIST: "other",
+  COLLECT_SET: "other",
+  FIRST: "other",
+  LAST: "other"
+}, Dt = /(?:_AGG$|^APPROX_[A-Z0-9_]+$|^COUNT_DISTINCT$|^HLL_(?:COUNT|ESTIMATE)$|^REGR_[A-Z_]+$)/;
+function Mt(e) {
+  const n = e.toUpperCase();
+  return n in Ce || Dt.test(n);
+}
+function Ne(e, n = !1) {
+  const a = Ce[e.toUpperCase()] ?? "other";
+  return n ? a === "count" || a === "count_distinct" ? "count_distinct" : a === "min" || a === "max" ? a : "repeat_safe_other" : a;
+}
+const Bt = /* @__PURE__ */ new Set([
+  "NULLIF",
+  "COALESCE",
+  "IFNULL",
+  "ISNULL",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "CEILING",
+  "ABS",
+  "POWER",
+  "SQRT",
+  "CAST",
+  "TRY_CAST",
+  "SAFE_CAST"
+]), Gt = /* @__PURE__ */ new Set(["DECIMAL", "NUMERIC", "INTEGER", "INT", "BIGINT", "FLOAT", "DOUBLE", "REAL", "VARCHAR", "TEXT"]), ie = /[A-Za-z_]/, zt = /[A-Za-z0-9_]/;
+function V(e, n) {
+  const a = e[n];
+  let r = n + 1;
+  for (; r < e.length; ) {
+    if (e[r] === a) {
+      if (e[r + 1] === a) {
+        r += 2;
+        continue;
+      }
+      return r + 1;
+    }
+    r += 1;
+  }
+  return r;
+}
+function P(e, n) {
+  let a = 0, r = n;
+  for (; r < e.length; ) {
+    const s = e[r];
+    if (s === "'" || s === '"') {
+      r = V(e, r);
+      continue;
+    }
+    if (s === "(" && (a += 1), s === ")" && (a -= 1, a === 0))
+      return r + 1;
+    r += 1;
+  }
+  return e.length;
+}
+function j(e, n) {
+  let a = n;
+  for (; a < e.length && /\s/.test(e[a]); ) a += 1;
+  return a;
+}
+function M(e, n) {
+  let a = n + 1;
+  for (; a < e.length && zt.test(e[a]); ) a += 1;
+  return a;
+}
+const Vt = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function Wt(e) {
+  return Array.from(e.matchAll(Vt), (n) => n[1]);
+}
+function W(e, n = /* @__PURE__ */ new Set()) {
+  const a = [], r = [];
+  let s = !1, c = "", i = !0, l = 0;
+  for (; l < e.length; ) {
+    const m = e[l];
+    if (m === "'" || m === '"') {
+      const o = V(e, l);
+      c += "'s'", m !== "'" && (i = !1), l = o;
+      continue;
+    }
+    if (m === "{") {
+      const o = e.indexOf("}", l);
+      if (o > l) {
+        const d = e.slice(l + 1, o);
+        r.push(d), n.has(d) || (i = !1), c += `#${d}`, l = o + 1;
+        continue;
+      }
+    }
+    if (ie.test(m)) {
+      const o = M(e, l), d = e.slice(l, o), p = j(e, o);
+      if (e[p] === "(" && Mt(d)) {
+        let g = P(e, p);
+        const I = g - 1;
+        let E = g;
+        const T = e.slice(p + 1, g - 1);
+        let x = T.trim() ? 1 : 0;
+        for (let h = p + 1; h < E - 1; h++)
+          e[h] === "'" || e[h] === '"' ? h = V(e, h) - 1 : e[h] === "(" ? h = P(e, h) - 1 : e[h] === "," && x++;
+        const C = /^\s*DISTINCT\b/i.test(T);
+        W(C ? T.replace(/^\s*DISTINCT\b/i, "") : T).calls.length > 0 && (s = !0);
+        let b = !1, _ = !1;
+        for (; ; ) {
+          const h = j(e, g);
+          if (!ie.test(e[h] || "")) break;
+          const N = M(e, h), R = e.slice(h, N).toUpperCase(), u = j(e, N);
+          if (R === "WITHIN") {
+            const S = M(e, u), w = j(e, S);
+            if (e.slice(u, S).toUpperCase() === "GROUP" && e[w] === "(") {
+              g = P(e, w), E = g;
+              continue;
+            }
+          }
+          if ((R === "FILTER" || R === "OVER") && e[u] === "(") {
+            b = b || R === "OVER", _ = _ || R === "FILTER", g = P(e, u);
+            continue;
+          }
+          break;
+        }
+        a.push({
+          name: d.toUpperCase(),
+          kind: Ne(d, C),
+          distinct: C,
+          windowed: b,
+          tokens: Wt(e.slice(p, g)),
+          span: { start: l, end: E, argumentStart: p + 1, argumentEnd: I },
+          argumentCount: x,
+          filtered: _
+        }), c += `@${a.length - 1}`, l = g;
+        continue;
+      }
+      c += e.slice(l, o), l = o;
+      continue;
+    }
+    /[\s0-9.,()+*/%<>=!|&^-]/.test(m) || (i = !1), c += m, l += 1;
+  }
+  return {
+    calls: a,
+    nestedAggregate: s,
+    windowed: a.some((m) => m.windowed),
+    tokensOutsideAggregates: r,
+    aggregateInputsComplete: i && Xt(c, n),
+    skeleton: c
+  };
+}
+function Xt(e, n) {
+  var m;
+  const a = [];
+  let r = 0;
+  for (; r < e.length; ) {
+    const o = e.slice(r), d = (m = /^(\s+|@\d+|#field_\d+|(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|'s'|[A-Za-z_][A-Za-z0-9_]*|<>|!=|<=|>=|[()+*/%,<>=-])/.exec(o)) == null ? void 0 : m[0];
+    if (!d) return !1;
+    if (r += d.length, d.startsWith("#")) {
+      if (!n.has(d.slice(1))) return !1;
+      a.push("@input");
+    } else d.trim() && a.push(d.toUpperCase());
+  }
+  let s = 0;
+  const c = (o) => a[s] === o && ++s > 0, i = () => {
+    if (!l()) return !1;
+    for (; ["+", "-", "*", "/", "%", "<", ">", "<=", ">=", "=", "<>", "!=", "AND", "OR", "IS"].includes(a[s]); )
+      if (a[s++] === "IS" && c("NOT"), !l()) return !1;
+    return !0;
+  }, l = () => {
+    const o = a[s];
+    if (!o) return !1;
+    if (["+", "-", "NOT"].includes(o))
+      return s++, l();
+    if (c("(")) return i() && c(")");
+    if (c("CASE")) {
+      if (a[s] !== "WHEN" && !i()) return !1;
+      let d = 0;
+      for (; c("WHEN"); ) {
+        if (!i() || !c("THEN") || !i()) return !1;
+        d++;
+      }
+      return c("ELSE") && !i() ? !1 : d > 0 && c("END");
+    }
+    if (o.startsWith("@") || o === "'S'" || ["NULL", "TRUE", "FALSE"].includes(o) || /^[0-9.]/.test(o))
+      return s++, !0;
+    if (!Bt.has(o) || (s++, !c("(") || !i())) return !1;
+    if (["CAST", "TRY_CAST", "SAFE_CAST"].includes(o)) {
+      if (!c("AS") || !Gt.has(a[s++]) || (c("PRECISION"), c("(") && (!/^\d+$/.test(a[s++] || "") || c(",") && !/^\d+$/.test(a[s++] || "") || !c(")"))))
+        return !1;
+    } else
+      for (; c(","); ) if (!i()) return !1;
+    return c(")");
+  };
+  return i() && s === a.length;
+}
+function $t(e) {
+  const n = [];
+  let a = 0;
+  for (; a < e.length; ) {
+    const r = e[a];
+    if (/\s/.test(r)) {
+      a += 1;
+      continue;
+    }
+    if (r === "@") {
+      const s = /^@(\d+)/.exec(e.slice(a));
+      n.push({ type: "unit", unit: { kind: "call", index: Number(s[1]) } }), a += s[0].length;
+      continue;
+    }
+    if (r === "#") {
+      const s = /^#([A-Za-z_][A-Za-z0-9_]*)/.exec(e.slice(a));
+      if (s) {
+        n.push({ type: "unit", unit: { kind: "token", token: s[1] } }), a += s[0].length;
+        continue;
+      }
+    }
+    if (/[0-9.]/.test(r)) {
+      const s = /^[0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?/.exec(e.slice(a));
+      if (s) {
+        n.push({ type: "number" }), a += s[0].length;
+        continue;
+      }
+    }
+    if (r === "+" || r === "-" || r === "*" || r === "/") {
+      n.push({ type: "op", value: r }), a += 1;
+      continue;
+    }
+    if (r === "(") {
+      n.push({ type: "open" }), a += 1;
+      continue;
+    }
+    if (r === ")") {
+      n.push({ type: "close" }), a += 1;
+      continue;
+    }
+    n.push({ type: "other" }), a += 1;
+  }
+  return n;
+}
+function Kt(e) {
+  const n = $t(e), a = n.some((o) => o.type === "op" && o.value === "/");
+  if (n.some((o) => o.type === "other"))
+    return { kind: "other", hasDivision: a };
+  let r = 0, s = !0;
+  const c = () => {
+    let o = [], d, p = !0;
+    for (; ; ) {
+      if (!p) {
+        const I = n[r];
+        if (!(I && I.type === "op" && (I.value === "+" || I.value === "-"))) break;
+        r += 1;
+      }
+      const g = i();
+      if (!g) return null;
+      d === void 0 ? d = g.degree : d !== g.degree && (s = !1), o = o.concat(g.units), p = !1;
+    }
+    return { degree: d ?? 0, units: o };
+  }, i = () => {
+    let o = l();
+    if (!o) return null;
+    for (; ; ) {
+      const d = n[r];
+      if (!(d && d.type === "op" && (d.value === "*" || d.value === "/"))) break;
+      r += 1;
+      const p = l();
+      if (!p) return null;
+      d.value === "/" && p.degree > 0 && (s = !1), o.degree + p.degree > 1 && (s = !1), o = { degree: o.degree + p.degree, units: o.units.concat(p.units) };
+    }
+    return o;
+  }, l = () => {
+    var d;
+    const o = n[r];
+    if (!o) return null;
+    if (o.type === "op" && o.value === "-")
+      return r += 1, l();
+    if (o.type === "unit")
+      return r += 1, { degree: 1, units: [o.unit] };
+    if (o.type === "number")
+      return r += 1, { degree: 0, units: [] };
+    if (o.type === "open") {
+      r += 1;
+      const p = c();
+      return !p || ((d = n[r]) == null ? void 0 : d.type) !== "close" ? null : (r += 1, p);
+    }
+    return null;
+  }, m = c();
+  return !m || r !== n.length ? { kind: "other", hasDivision: a } : m.units.length === 1 && m.degree === 1 && s && !a && n.filter((d) => d.type !== "open" && d.type !== "close").length === 1 ? { kind: "single", unit: m.units[0] } : s && m.degree === 1 ? { kind: "linear", units: m.units } : { kind: "other", hasDivision: a };
+}
+const Oe = /* @__PURE__ */ new Set([
+  "min",
+  "max",
+  "count_distinct",
+  "repeat_safe_other"
+]);
+function X(e) {
+  if (!(!e || !e.trim()))
+    return Ne(e);
+}
+function xe(e) {
+  switch (e) {
+    case "count":
+    case "sum":
+      return { kind: "additive" };
+    case "avg":
+      return { kind: "decomposable_avg" };
+    case "min":
+    case "max":
+      return { kind: "idempotent", fn: e };
+    case "count_distinct":
+      return { kind: "none", reason: "distinct" };
+    case "median":
+      return { kind: "none", reason: "median" };
+    default:
+      return { kind: "none", reason: "other" };
+  }
+}
+function Zt(e) {
+  var n, a;
+  return ((n = e.derivedField) == null ? void 0 : n.computeStage) || ((a = e.calculatedFormula) == null ? void 0 : a.computeStage);
+}
+const Q = {
+  stage: "aggregate",
+  calls: [],
+  windowed: !1,
+  repeatSafe: !1,
+  reaggregation: { kind: "none", reason: "unresolved" },
+  outputType: "numeric",
+  identity: "unresolved",
+  unresolved: !0
+}, Pe = { ...Q, stage: "row" };
+function $(e) {
+  return {
+    stage: "row",
+    outer: e,
+    calls: [{ kind: e, distinct: e === "count_distinct" }],
+    windowed: !1,
+    repeatSafe: Oe.has(e),
+    reaggregation: xe(e),
+    outputType: e === "min" || e === "max" ? "input" : "numeric",
+    identity: e,
+    unresolved: !1
+  };
+}
+function B(e, n) {
+  var r;
+  const a = (r = n.derivedField) == null ? void 0 : r.aggregationBehavior;
+  return !a || e.unresolved ? e : a === "additive" ? e.reaggregation.kind === "additive" ? e : { ...e, reaggregation: { kind: "additive" } } : { ...e, reaggregation: { kind: "none", reason: "declared" } };
+}
+function Ht(e, n) {
+  if (!e) return Q;
+  if (typeof e.expression == "string" && e.expression.trim()) {
+    const r = J(e, n + 1);
+    return r === "row_input" ? "raw" : r.unresolved || r.stage === "aggregate" || r.outer ? r : "raw";
+  }
+  const a = X(e.aggregate);
+  return a ? $(a) : "raw";
+}
+const Yt = 12;
+function J(e, n) {
+  var R;
+  if (n > Yt) return Q;
+  const a = typeof e.expression == "string" ? e.expression.trim() : "";
+  if (!a)
+    return B(
+      $(X(e.aggregate) ?? "sum"),
+      e
+    );
+  const r = W(a), s = ((R = e.calculatedFormula) == null ? void 0 : R.inputFields) || [], c = (u) => {
+    const S = /^field_(\d+)$/.exec(u);
+    return S ? s[Number(S[1])] : void 0;
+  }, i = /* @__PURE__ */ new Map();
+  for (const u of r.tokensOutsideAggregates)
+    i.has(u) || i.set(u, Ht(c(u), n));
+  const l = r.calls.some(
+    (u) => u.tokens.some((S) => {
+      const w = c(S);
+      if (!(w != null && w.expression)) return !1;
+      const L = J(w, n + 1);
+      return L !== "row_input" && (L.unresolved || L.stage === "aggregate");
+    })
+  ), m = Array.from(i.values()).filter(
+    (u) => u !== "raw"
+  ), o = Array.from(i.values()).some((u) => u === "raw"), d = r.calls.length > 0 || m.length > 0 || Zt(e) === "aggregate" || !!e.isPreAggregated, p = new Set(
+    [...i].filter(
+      ([u, S]) => S === "raw" ? !d && !!c(u) : !S.unresolved
+    ).map(([u]) => u)
+  ), g = W(a, p).aggregateInputsComplete;
+  if (!d) {
+    if (!g) return Pe;
+    const u = X(e.aggregate);
+    return u ? B($(u), e) : "row_input";
+  }
+  const I = !g || o || r.nestedAggregate || l || m.some((u) => u.unresolved) || r.calls.length === 0 && m.length === 0, E = [
+    ...r.calls.map((u) => ({ kind: u.kind, distinct: u.distinct })),
+    ...m.flatMap((u) => u.calls)
+  ], T = r.windowed || m.some((u) => u.windowed), x = !I && !T && E.every((u) => Oe.has(u.kind)), C = (u) => {
+    if (u.kind === "call") {
+      const w = r.calls[u.index];
+      return w ? xe(w.kind) : { kind: "none", reason: "unresolved" };
+    }
+    const S = i.get(u.token);
+    return S && S !== "raw" ? S.reaggregation : { kind: "none", reason: "unresolved" };
+  }, b = Kt(r.skeleton);
+  let _, h, N = "numeric";
+  if (I)
+    _ = { kind: "none", reason: "unresolved" }, h = "unresolved";
+  else if (T)
+    _ = { kind: "none", reason: "window" }, h = "expression";
+  else if (b.kind === "single")
+    if (_ = C(b.unit), b.unit.kind === "call") {
+      const u = r.calls[b.unit.index];
+      h = u.kind, (u.kind === "min" || u.kind === "max") && (N = "input");
+    } else {
+      const u = i.get(b.unit.token);
+      h = u.identity, N = u.outputType;
+    }
+  else b.kind === "linear" ? (_ = b.units.every((S) => C(S).kind === "additive") ? { kind: "additive" } : { kind: "none", reason: "other" }, h = "linear") : (_ = { kind: "none", reason: b.hasDivision ? "ratio" : "other" }, h = b.hasDivision ? "ratio" : "expression");
+  return B(
+    {
+      stage: "aggregate",
+      calls: E,
+      windowed: T,
+      repeatSafe: x,
+      reaggregation: _,
+      outputType: N,
+      identity: h,
+      unresolved: I
+    },
+    e
+  );
+}
+function kn(e) {
+  const n = J(e, 0);
+  return n === "row_input" ? Pe : n;
+}
+const Qt = t.object({
+  intent: Je,
+  matrixWindowRequest: pe
+}).strict(), Jt = t.object({
+  runtimeFilters: G.innerType().shape.filters,
+  runtimeSorts: G.innerType().shape.sorts.optional()
+});
+function vn(e) {
+  return Jt.parse(e);
+}
+const en = {
+  // A window executes a governed statement set, not one compiled query.
+  compiledQuery: t.never().optional(),
+  intent: Qt.shape.intent,
+  resultShape: t.literal("matrix"),
+  result: Ae.optional(),
+  metadata: t.object({ rowLimitExceeded: t.boolean(), matrixFailure: Y.optional() }).passthrough()
+}, tn = ve.extend(en), Tn = tn.superRefine((e, n) => {
+  e.status === "failed" == !!e.result && n.addIssue({ code: "custom", message: "Only answered or partial Matrix execution carries a window." }), e.result && e.status === "partial" != e.result.window.failures.length > 0 && n.addIssue({ code: "custom", message: "Matrix execution status must match acquired window failures." });
+});
+export {
+  lt as $,
+  bn as A,
+  An as B,
+  xt as C,
+  Pt as D,
+  jt as E,
+  In as F,
+  Ft as G,
+  Lt as H,
+  qt as I,
+  wn as J,
+  Mt as K,
+  Ne as L,
+  W as M,
+  Kt as N,
+  kn as O,
+  me as P,
+  nt as Q,
+  at as R,
+  H as S,
+  rn as T,
+  sn as U,
+  st as V,
+  on as W,
+  it as X,
+  te as Y,
+  ct as Z,
+  cn as _,
+  _n as a,
+  ut as a0,
+  dt as a1,
+  ne as a2,
+  Y as a3,
+  mt as a4,
+  Se as a5,
+  pt as a6,
+  ln as a7,
+  un as a8,
+  ht as a9,
+  ft as aa,
+  gt as ab,
+  dn as ac,
+  mn as ad,
+  yt as ae,
+  St as af,
+  ae as ag,
+  bt as ah,
+  pn as ai,
+  Jt as aj,
+  vn as ak,
+  Tn as al,
+  Qt as am,
+  It as b,
+  Sn as c,
+  _e as d,
+  we as e,
+  ke as f,
+  hn as g,
+  ve as h,
+  Rt as i,
+  _t as j,
+  kt as k,
+  vt as l,
+  pe as m,
+  Ae as n,
+  Te as o,
+  fn as p,
+  Re as q,
+  gn as r,
+  At as s,
+  Et as t,
+  yn as u,
+  Ee as v,
+  Ct as w,
+  se as x,
+  z as y,
+  oe as z
+};