@agile-team/mach-report 2.8.4 → 2.9.0

package/dist/matrix-CNPDJxED.js

@@ -0,0 +1,745 @@
+function y(e) {
+  if (!Number.isSafeInteger(e) || e < 0 || e > 1e3 * 2)
+    throw new Error("十进制精度超出预算");
+  return 10n ** BigInt(e);
+}
+function S(e) {
+  if (e.coefficient.toString().length > 1e3 * 2 || e.scale > 1e3 * 2)
+    throw new Error("十进制结果超出精度预算");
+  return e;
+}
+function g(e) {
+  if (typeof e != "string" && !(typeof e == "number" && Number.isFinite(e)))
+    throw new Error("十进制参数必须是有限数字或十进制文本");
+  const r = String(e);
+  if (r.length > 1e3) throw new Error("十进制文本超出精度预算");
+  const t = /^([+-]?)(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d{1,4}))?$/.exec(
+    r
+  );
+  if (!t) throw new Error("无效十进制文本");
+  const n = t[3] ?? "", l = Number(t[4] ?? 0), o = n.length - l, i = BigInt(
+    `${t[1] === "-" ? "-" : ""}${t[2]}${n}`
+  );
+  return S(
+    o < 0 ? { coefficient: i * y(-o), scale: 0 } : { coefficient: i, scale: o }
+  );
+}
+function T(e, r) {
+  const t = Math.max(e.scale, r.scale);
+  return [
+    e.coefficient * y(t - e.scale),
+    r.coefficient * y(t - r.scale),
+    t
+  ];
+}
+function R(e, r) {
+  const [t, n] = T(e, r);
+  return t < n ? -1 : t > n ? 1 : 0;
+}
+function A(e, r) {
+  const [t, n, l] = T(e, r);
+  return S({ coefficient: t + n, scale: l });
+}
+function x(e, r) {
+  return S({
+    coefficient: e.coefficient * r.coefficient,
+    scale: e.scale + r.scale
+  });
+}
+function J(e, r) {
+  const t = e / r, n = e % r, l = (o) => o < 0n ? -o : o;
+  return l(n) * 2n < l(r) ? t : t + (e < 0n == r < 0n ? 1n : -1n);
+}
+function N(e) {
+  if (!Number.isInteger(e) || e < 0 || e > 100)
+    throw new Error("十进制小数位应为 0–100 的整数");
+}
+function M(e, r, t = 20) {
+  if (N(t), r.coefficient === 0n) throw new Error("不能除以零");
+  const n = r.scale - e.scale + t, l = e.coefficient * y(Math.max(0, n)), o = r.coefficient * y(Math.max(0, -n));
+  return S({
+    coefficient: J(l, o),
+    scale: t
+  });
+}
+function $(e, r) {
+  let t = e.coefficient, n = e.scale;
+  r !== void 0 && (N(r), t = r >= n ? t * y(r - n) : J(t, y(n - r)), n = r);
+  const l = t < 0n, o = (l ? -t : t).toString().padStart(n + 1, "0");
+  let i = n ? o.slice(-n) : "";
+  return r === void 0 && (i = i.replace(/0+$/, "")), `${l ? "-" : ""}${n ? o.slice(0, -n) : o}${i ? `.${i}` : ""}`;
+}
+function ge(e, r, t = !1, n = !1) {
+  let l = g(e);
+  n && (l = x(l, { coefficient: 100n, scale: 0 }));
+  const [o, i] = $(l, r).split(".");
+  return `${t ? o.replace(/\B(?=(\d{3})+(?!\d))/g, ",") : o}${i === void 0 ? "" : `.${i}`}${n ? "%" : ""}`;
+}
+const X = [
+  "sum",
+  "count",
+  "avg",
+  "min",
+  "max",
+  "weightedAvg"
+];
+function j(e) {
+  if (typeof e != "number" || !Number.isFinite(e))
+    throw new Error(
+      "聚合度量必须是有限数字，不能隐式转换；小数文本请显式选择 decimal"
+    );
+  return e;
+}
+function v(e, r) {
+  return r && Object.prototype.hasOwnProperty.call(e, r) ? e[r] : void 0;
+}
+function Z(e) {
+  let r = 0, t = 0, n = 0, l = 0, o = 1 / 0, i = -1 / 0;
+  const a = (c) => {
+    const f = c - n, d = t + f;
+    n = d - t - f, t = d;
+  };
+  return {
+    add(c) {
+      const f = v(c, e.field);
+      if (e.op === "count") {
+        (!e.field || f != null) && r++;
+        return;
+      }
+      if (f == null) return;
+      const d = j(f), u = e.op === "weightedAvg" ? v(c, e.weightField) : 1;
+      if (u == null) return;
+      const s = j(u);
+      if (e.op === "weightedAvg" && s < 0)
+        throw new Error("加权平均的权重不能为负数");
+      ["sum", "avg", "weightedAvg"].includes(e.op) && a(d * s), l += s, o = Math.min(o, d), i = Math.max(i, d), r++;
+    },
+    value() {
+      if (e.op === "count") return r;
+      if (!r) return null;
+      const c = e.op === "min" ? o : e.op === "max" ? i : e.op === "avg" ? t / r : e.op === "weightedAvg" ? l === 0 ? null : t / l : t;
+      if (c !== null && !Number.isFinite(c))
+        throw new Error("聚合计算溢出");
+      return c;
+    }
+  };
+}
+function H(e) {
+  let r = 0, t = g("0"), n = g("0"), l, o;
+  return {
+    add(i) {
+      const a = v(i, e.field);
+      if (e.op === "count") {
+        (!e.field || a != null) && r++;
+        return;
+      }
+      if (a == null) return;
+      const c = e.op === "weightedAvg" ? v(i, e.weightField) : "1";
+      if (c == null) return;
+      const f = g(a), d = g(c);
+      if (e.op === "weightedAvg" && d.coefficient < 0n)
+        throw new Error("加权平均的权重不能为负数");
+      ["sum", "avg", "weightedAvg"].includes(e.op) && (t = A(t, x(f, d))), e.op === "weightedAvg" && (n = A(n, d)), (!l || R(f, l) < 0) && (l = f), (!o || R(f, o) > 0) && (o = f), r++;
+    },
+    value() {
+      if (e.op === "count") return r;
+      if (!r || e.op === "weightedAvg" && n.coefficient === 0n)
+        return null;
+      let i = e.op === "min" ? l : e.op === "max" ? o : t;
+      return e.op === "avg" && (i = M(t, g(r), e.digits)), e.op === "weightedAvg" && (i = M(t, n, e.digits)), $(i, e.digits);
+    }
+  };
+}
+function k(e) {
+  if (e.digits !== void 0 && N(e.digits), e.numeric !== void 0 && e.numeric !== "number" && e.numeric !== "decimal")
+    throw new Error("未知聚合数值模式");
+  if (!X.includes(e.op)) throw new Error("未知聚合操作");
+  if (e.op !== "count" && !e.field)
+    throw new Error("聚合需要度量字段");
+  if (e.op === "weightedAvg" && !e.weightField)
+    throw new Error("加权平均需要权重字段");
+  return e.numeric === "decimal" ? H(e) : Z(e);
+}
+function B(e, r) {
+  const t = k(r);
+  for (const n of e) t.add(n);
+  return t.value();
+}
+function b(e, r) {
+  return Object.prototype.hasOwnProperty.call(e, r) ? e[r] : void 0;
+}
+function z(e) {
+  if (e == null) return "null";
+  if (typeof e != "string" && typeof e != "boolean" && !(typeof e == "number" && Number.isFinite(e)))
+    throw new Error("交叉表维度应为字符串、布尔、有限数字或空值");
+  return JSON.stringify([typeof e, e]);
+}
+function D(e) {
+  return e == null ? "" : String(e);
+}
+function p(e, r) {
+  const t = e ?? r;
+  if (!Number.isInteger(t) || t < 1)
+    throw new Error("交叉表预算应为正整数");
+  return t;
+}
+function K(e, r, t, n) {
+  const l = t ? 1 : 0;
+  if ((e + l) * (r + 1 + l) > n)
+    throw new Error(
+      "交叉表输出单元格超出 maxCells 预算，请减少维度或服务端预聚合"
+    );
+}
+function Q(e, r) {
+  if (!Array.isArray(e)) throw new Error("交叉表数据应为对象数组");
+  const t = r.aggregate ?? "sum";
+  if (!["sum", "count", "avg", "min", "max", "weightedAvg"].includes(t))
+    throw new Error("未知交叉表聚合类型");
+  if (!r.rowField || !r.columnField || t !== "count" && !r.valueField)
+    throw new Error("交叉表需要明确的行维度、列维度和度量字段");
+  if (e.length > p(r.maxInputRows, 1e5))
+    throw new Error("交叉表输入超出预算，请在服务端预聚合");
+  const n = p(r.maxRows, 1e3), l = p(r.maxColumns, 200), o = p(r.maxCells, 2e6), i = () => k({
+    op: t,
+    field: t === "count" && r.countMode !== "nonNull" ? void 0 : r.valueField,
+    weightField: r.weightField,
+    numeric: r.numeric,
+    digits: r.digits
+  }), a = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), d = i();
+  for (const s of e) {
+    const m = z(b(s, r.rowField)), w = z(b(s, r.columnField));
+    if (a.has(w) || a.set(w, D(b(s, r.columnField))), c.has(m) || c.set(m, {
+      label: D(b(s, r.rowField)),
+      cells: /* @__PURE__ */ new Map(),
+      total: i()
+    }), a.size > l || c.size > n)
+      throw new Error("交叉表维度数量超出预算");
+    K(c.size, a.size, r.totals, o);
+    const h = c.get(m);
+    h.cells.has(w) || h.cells.set(w, i()), f.has(w) || f.set(w, i());
+    for (const O of [
+      h.cells.get(w),
+      h.total,
+      f.get(w),
+      d
+    ])
+      O.add(s);
+  }
+  const u = {
+    columns: [
+      {
+        header: r.rowHeader ?? r.rowField,
+        field: "rowLabel",
+        semanticRole: "dimension"
+      },
+      ...[...a.values()].map(
+        (s, m) => ({
+          header: s,
+          field: `c${m}`,
+          semanticRole: "measure"
+        })
+      )
+    ],
+    rows: [...c.values()].map((s) => ({
+      rowLabel: s.label,
+      ...Object.fromEntries(
+        [...a.keys()].map((m, w) => [
+          `c${w}`,
+          s.cells.get(m)?.value() ?? (t === "count" ? 0 : null)
+        ])
+      ),
+      ...r.totals ? { total: s.total.value() } : {}
+    }))
+  };
+  return r.totals && (u.columns.push({
+    header: "合计",
+    field: "total",
+    semanticRole: "measure"
+  }), e.length && u.rows.push({
+    rowLabel: "合计",
+    ...Object.fromEntries(
+      [...a.keys()].map((s, m) => [
+        `c${m}`,
+        f.get(s)?.value() ?? (t === "count" ? 0 : null)
+      ])
+    ),
+    total: d.value()
+  })), u;
+}
+const U = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function E(e) {
+  if (typeof e != "string" || !e.trim() || U.has(e))
+    throw new Error("计算字段应为安全的非空字段名");
+}
+function I(e) {
+  return e === null || ["string", "boolean"].includes(typeof e) || typeof e == "number" && Number.isFinite(e);
+}
+function V(e) {
+  if (e.some((r) => typeof r != "number" || !Number.isFinite(r)))
+    throw new Error("算术参数必须是有限数字；空值和小数文本不会隐式转换");
+  return e;
+}
+function Y(e, r) {
+  const t = V(r);
+  let n;
+  if (e === "add") n = t.reduce((l, o) => l + o, 0);
+  else if (e === "multiply") n = t.reduce((l, o) => l * o, 1);
+  else if (e === "subtract") n = t[0] - t[1];
+  else {
+    if (t[1] === 0) throw new Error("不能除以零");
+    n = t[0] / t[1];
+  }
+  if (!Number.isFinite(n)) throw new Error("计算结果不是有限数字");
+  return n;
+}
+function q(e, r, t) {
+  const n = r.map(g);
+  let l;
+  return e === "add" ? l = n.reduce(A) : e === "multiply" ? l = n.reduce(x) : e === "subtract" ? l = A(n[0], {
+    ...n[1],
+    coefficient: -n[1].coefficient
+  }) : l = M(n[0], n[1], t), $(l, t);
+}
+function ee(e, r, t) {
+  return t.nulls !== "error" && r.some((n) => n == null) || e === "divide" && t.divisionByZero === "null" && (t.numeric === "decimal" ? g(r[1]).coefficient === 0n : r[1] === 0) ? null : t.numeric === "decimal" ? q(e, r, t.digits) : Y(e, r);
+}
+function re(e, r) {
+  e.field !== void 0 && E(e.field), e.weightField !== void 0 && E(e.weightField);
+  const t = {
+    op: e.aggregate,
+    field: e.field,
+    weightField: e.weightField,
+    numeric: r.numeric,
+    digits: r.digits
+  };
+  B([], t);
+  const n = /* @__PURE__ */ new WeakMap();
+  return (l) => {
+    let o = n.get(l.rows);
+    if (!o) {
+      try {
+        o = { value: B(l.rows, t) };
+      } catch (i) {
+        o = {
+          error: i instanceof Error ? i : new Error(String(i))
+        };
+      }
+      n.set(l.rows, o);
+    }
+    if (o.error) throw o.error;
+    return o.value;
+  };
+}
+function te(e, r) {
+  for (const t of e) {
+    const n = t(r);
+    if (n != null) return n;
+  }
+  return null;
+}
+function C(e, r = {}, t = { nodes: 0 }, n = 0) {
+  if (++t.nodes > 256 || n > 16)
+    throw new Error("计算表达式超出深度或节点预算");
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw new Error("计算表达式应为声明式对象");
+  if ("aggregate" in e) return re(e, r);
+  if ("field" in e) {
+    E(e.field);
+    const l = e.field;
+    return ({ row: o }) => Object.prototype.hasOwnProperty.call(o, l) ? o[l] : void 0;
+  }
+  if ("value" in e) {
+    if (!I(e.value))
+      throw new Error("常量应为有限 JSON 标量");
+    return () => e.value;
+  }
+  return ne(e, r, t, n);
+}
+function ne(e, r, t, n) {
+  if (!["add", "subtract", "multiply", "divide", "coalesce"].includes(
+    e.op
+  ) || !Array.isArray(e.args))
+    throw new Error("未知计算操作");
+  if (e.args.length > 256 || Object.keys(e.args).length !== e.args.length)
+    throw new Error("计算参数超出预算或包含空位");
+  if (e.args.length < 2 || ["subtract", "divide"].includes(e.op) && e.args.length !== 2)
+    throw new Error("运算参数数量不正确");
+  const l = e.args.map(
+    (o) => C(o, r, t, n + 1)
+  );
+  return e.op === "coalesce" ? (o) => te(l, o) : (o) => ee(
+    e.op,
+    l.map((i) => i(o)),
+    r
+  );
+}
+function ie(e) {
+  C(e);
+  const r = /* @__PURE__ */ new Set(), t = (n) => {
+    "field" in n && n.field && r.add(n.field), "aggregate" in n && n.weightField && r.add(n.weightField), "args" in n && n.args.forEach(t);
+  };
+  return t(e), [...r];
+}
+function oe(e) {
+  if (E(e.field), e.scope !== void 0 && !["row", "group", "dataset"].includes(e.scope))
+    throw new Error("未知计算范围");
+  if (e.numeric !== void 0 && e.numeric !== "number" && e.numeric !== "decimal")
+    throw new Error("未知数值模式");
+  if (e.digits !== void 0 && N(e.digits), e.nulls !== void 0 && e.nulls !== "propagate" && e.nulls !== "error")
+    throw new Error("未知空值规则");
+  if (e.divisionByZero !== void 0 && e.divisionByZero !== "null" && e.divisionByZero !== "error")
+    throw new Error("未知除零规则");
+  if (e.scope === "group" && (!Array.isArray(e.groupBy) || !e.groupBy.length))
+    throw new Error("分组计算需要 groupBy 字段");
+  le(e);
+}
+function le(e) {
+  if (e.groupBy !== void 0) {
+    if (!Array.isArray(e.groupBy) || e.groupBy.length > 16)
+      throw new Error("计算分组最多 16 级");
+    e.groupBy.forEach(E);
+  }
+  if (e.dependsOn !== void 0) {
+    if (!Array.isArray(e.dependsOn) || e.dependsOn.length > 2048)
+      throw new Error("计算依赖超出预算");
+    e.dependsOn.forEach(E);
+  }
+}
+function P(e) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...typeof e.expression == "string" ? e.dependsOn ?? [] : ie(e.expression),
+      ...e.groupBy ?? []
+    ])
+  ];
+}
+function G(e) {
+  if (!Array.isArray(e) || e.length > 2048)
+    throw new Error("计算字段应为数组且最多2048项");
+  const r = /* @__PURE__ */ new Map();
+  for (const i of e) {
+    if (oe(i), r.has(i.field)) throw new Error(`计算字段重复：${i.field}`);
+    r.set(i.field, i);
+  }
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), l = [];
+  function o(i) {
+    if (!n.has(i.field)) {
+      if (t.has(i.field))
+        throw new Error(
+          `计算字段存在循环依赖：${[...t, i.field].join(" → ")}`
+        );
+      t.add(i.field);
+      for (const a of P(i)) {
+        const c = r.get(a);
+        c && o(c);
+      }
+      t.delete(i.field), n.add(i.field), l.push(i);
+    }
+  }
+  return e.forEach(o), l;
+}
+function he(e) {
+  try {
+    const r = G(e);
+    return {
+      valid: !0,
+      errors: [],
+      order: r.map((t) => t.field),
+      fields: e.map((t) => ({
+        field: t.field,
+        dependencies: P(t),
+        scope: t.scope ?? "row"
+      }))
+    };
+  } catch (r) {
+    return {
+      valid: !1,
+      errors: [r instanceof Error ? r.message : String(r)],
+      fields: [],
+      order: []
+    };
+  }
+}
+function ye(e = []) {
+  return {
+    fields: e.map((r) => ({ ...r })),
+    functions: [
+      {
+        name: "add",
+        minArgs: 2,
+        maxArgs: 256,
+        input: "numeric",
+        output: "numeric"
+      },
+      {
+        name: "subtract",
+        minArgs: 2,
+        maxArgs: 2,
+        input: "numeric",
+        output: "numeric"
+      },
+      {
+        name: "multiply",
+        minArgs: 2,
+        maxArgs: 256,
+        input: "numeric",
+        output: "numeric"
+      },
+      {
+        name: "divide",
+        minArgs: 2,
+        maxArgs: 2,
+        input: "numeric",
+        output: "numeric"
+      },
+      {
+        name: "coalesce",
+        minArgs: 2,
+        maxArgs: 256,
+        input: "scalar",
+        output: "scalar"
+      }
+    ],
+    operations: ["add", "subtract", "multiply", "divide", "coalesce"],
+    aggregates: ["sum", "count", "avg", "min", "max", "weightedAvg"],
+    scopes: ["row", "group", "dataset"],
+    numericModes: ["number", "decimal"],
+    rules: {
+      nulls: "propagate",
+      aggregateNulls: "skip",
+      emptyAggregate: null,
+      countEmpty: 0,
+      divisionByZero: "error",
+      decimalOutput: "string",
+      rounding: "half-away-from-zero"
+    }
+  };
+}
+function ce(e) {
+  return G(e.fields).map((r) => {
+    if (typeof r.expression != "string")
+      return {
+        definition: r,
+        read: C(r.expression, r)
+      };
+    if (!e.formula)
+      throw new Error("字符串公式需要显式配置 formula adapter");
+    const t = r.expression;
+    return {
+      definition: r,
+      read: (n) => e.formula.evaluate(t, n)
+    };
+  });
+}
+function ae(e, r) {
+  return JSON.stringify(
+    r.map((t) => {
+      const n = Object.prototype.hasOwnProperty.call(e, t) ? e[t] : null;
+      if (n != null && !I(n))
+        throw new Error("分组字段应为有限 JSON 标量");
+      return [typeof n, n ?? null];
+    })
+  );
+}
+function ue(e, r) {
+  if (r.scope === "dataset") return () => e;
+  if (r.scope !== "group") {
+    const l = /* @__PURE__ */ new WeakMap();
+    return (o) => {
+      let i = l.get(o);
+      return i || (i = [o], l.set(o, i)), i;
+    };
+  }
+  const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new WeakMap();
+  for (const l of e) {
+    const o = ae(l, r.groupBy);
+    n.set(l, o);
+    const i = t.get(o);
+    i ? i.push(l) : t.set(o, [l]);
+  }
+  return (l) => t.get(n.get(l));
+}
+function se(e, r) {
+  const t = r.maxRows ?? 1e5, n = r.maxCells ?? 2e6;
+  if (!Array.isArray(e) || !Number.isSafeInteger(t) || t < 1 || e.length > t)
+    throw new Error("计算数据行数超出预算或输入不是数组");
+  if (!Array.isArray(r.fields) || r.fields.length > 2048)
+    throw new Error("计算字段应为数组且最多2048项");
+  if (!Number.isSafeInteger(n) || n < 1 || e.length * r.fields.length > n)
+    throw new Error("计算单元格超出 maxCells 预算");
+}
+function _(e) {
+  if (e?.aborted) {
+    const r = new Error("数据计算已取消");
+    throw r.name = "AbortError", r;
+  }
+}
+function fe(e, r, t, n, l, o) {
+  try {
+    const i = e.read({ row: r, rowIndex: t, rows: n });
+    if (i !== void 0 && !I(i))
+      throw new Error("计算结果应为有限 JSON 标量，异步公式请先在数据源中求值");
+    r[e.definition.field] = i ?? null;
+  } catch (i) {
+    const a = i instanceof Error ? i.message : String(i);
+    if (l.onError !== "null")
+      throw Object.assign(
+        new Error(`第 ${t + 1} 行 ${e.definition.field}：${a}`),
+        { cause: i }
+      );
+    r[e.definition.field] = null, o.push({ rowIndex: t, field: e.definition.field, message: a });
+  }
+}
+function Ee(e, r) {
+  se(e, r), _(r.signal);
+  const t = ce(r), n = [], l = e.map((o, i) => {
+    if (!o || typeof o != "object" || Array.isArray(o))
+      throw new Error(`第 ${i + 1} 行应为对象`);
+    return { ...o };
+  });
+  for (const o of t) {
+    const i = ue(l, o.definition);
+    l.forEach((a, c) => {
+      _(r.signal), fe(o, a, c, i(a), r, n);
+    });
+  }
+  return { rows: l, issues: n };
+}
+function F(e, r) {
+  const t = r.map(
+    (n) => Object.prototype.hasOwnProperty.call(e, n) ? e[n] : null
+  );
+  if (t.some(
+    (n) => n != null && typeof n != "string" && typeof n != "boolean" && !(typeof n == "number" && Number.isFinite(n))
+  ))
+    throw new Error("矩阵维度必须是有限 JSON 标量");
+  return {
+    key: JSON.stringify(t.map((n) => [typeof n, n ?? null])),
+    label: t.map((n) => n == null ? "" : String(n)).join(" / ")
+  };
+}
+function me(e) {
+  for (const r of [
+    "maxRows",
+    "maxColumns",
+    "maxInputRows",
+    "maxCells"
+  ])
+    if (e[r] !== void 0 && (!Number.isSafeInteger(e[r]) || e[r] < 1))
+      throw new Error("矩阵预算应为正安全整数");
+  for (const r of ["columnWidthMm", "rowWidthMm"])
+    if (e[r] !== void 0 && (!Number.isFinite(e[r]) || e[r] <= 0))
+      throw new Error("矩阵列宽应为正数");
+}
+function de(e) {
+  if (!e || !Array.isArray(e.rowFields) || !Array.isArray(e.columnFields) || !Array.isArray(e.measures))
+    throw new Error("矩阵需要行维度、列维度和度量数组");
+  for (const t of [e.rowFields, e.columnFields])
+    if (t.some((n) => typeof n != "string" || !n.trim()) || new Set(t).size !== t.length)
+      throw new Error("矩阵维度字段应非空且唯一");
+  if (me(e), !e.rowFields.length || !e.columnFields.length || e.rowFields.length > 16 || e.columnFields.length > 16)
+    throw new Error("矩阵需要 1–16 个行/列维度");
+  if (!e.measures.length || e.measures.length > 32)
+    throw new Error("矩阵需要 1–32 个度量");
+  if (e.measures.map((t) => {
+    if (!t || typeof t != "object") throw new Error("矩阵度量应为对象");
+    if (k({
+      ...t,
+      field: t.valueField ?? t.field
+    }), t.label !== void 0 && typeof t.label != "string")
+      throw new Error("矩阵度量标签应为字符串");
+    return t.field;
+  }).some((t) => typeof t != "string" || !t.trim()))
+    throw new Error("矩阵度量字段应非空");
+}
+function we(e, r) {
+  if (de(r), !Array.isArray(e) || e.length > (r.maxInputRows ?? 1e5))
+    throw new Error("矩阵输入超出预算");
+  const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+  for (const i of e) {
+    if (!i || typeof i != "object" || Array.isArray(i))
+      throw new Error("矩阵数据行应为对象");
+    if (t.add(F(i, r.rowFields).key), n.add(F(i, r.columnFields).key), t.size > (r.maxRows ?? 1e3) || n.size > (r.maxColumns ?? 200))
+      throw new Error("矩阵维度数量超出预算");
+    if ((t.size + +!!r.totals) * ((n.size + +!!r.totals) * r.measures.length + 1) > (r.maxCells ?? 2e6))
+      throw new Error("矩阵输出超出 maxCells 预算");
+  }
+  const l = t.size + +(!!r.totals && e.length > 0), o = (n.size + +!!r.totals) * r.measures.length + 1;
+  return { rowCount: l, columnCount: o, cells: l * o };
+}
+function L(e, r) {
+  let t = r;
+  for (; e.some((n) => Object.prototype.hasOwnProperty.call(n, t)); )
+    t += "_";
+  return t;
+}
+function be(e, r) {
+  we(e, r);
+  const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), l = L(e, "__matrix_row"), o = L(e, "__matrix_column"), i = e.map((u) => {
+    const s = F(u, r.rowFields), m = F(u, r.columnFields);
+    return t.set(s.key, s.label), n.set(m.key, m.label), { ...u, [l]: s.key, [o]: m.key };
+  }), a = r.maxCells ?? 2e6;
+  if ((t.size + +!!r.totals) * ((n.size + +!!r.totals) * r.measures.length + 1) > a)
+    throw new Error("矩阵输出超出 maxCells 预算");
+  const c = r.measures.map(
+    (u) => Q(i, {
+      rowField: l,
+      columnField: o,
+      valueField: u.valueField ?? u.field,
+      aggregate: u.op,
+      countMode: "nonNull",
+      weightField: u.weightField,
+      numeric: u.numeric,
+      digits: u.digits,
+      totals: r.totals,
+      maxRows: r.maxRows,
+      maxColumns: r.maxColumns,
+      maxInputRows: r.maxInputRows,
+      maxCells: a
+    })
+  ), f = c[0].rows.map(
+    (u) => ({
+      rowLabel: t.get(String(u.rowLabel)) ?? String(u.rowLabel)
+    })
+  ), d = [
+    {
+      field: "rowLabel",
+      header: r.rowHeader ?? r.rowFields.join(" / "),
+      semanticRole: "dimension"
+    }
+  ];
+  for (let u = 0; u < c.length; u++) {
+    const s = c[u], m = r.measures[u];
+    for (const w of s.columns.slice(1)) {
+      const h = `${w.field}_${u}`;
+      d.push({
+        ...w,
+        field: h,
+        ...m.digits === void 0 ? {} : { format: { kind: "number", digits: m.digits } },
+        header: `${n.get(w.header) ?? w.header} · ${m.label ?? `${m.field} (${m.op})`}`
+      }), s.rows.forEach((O, W) => {
+        f[W][h] = O[w.field];
+      });
+    }
+  }
+  return { rows: f, columns: d };
+}
+export {
+  A as a,
+  B as b,
+  R as c,
+  Ee as d,
+  k as e,
+  Q as f,
+  be as g,
+  N as h,
+  M as i,
+  we as j,
+  ge as k,
+  ye as l,
+  x as m,
+  $ as n,
+  de as o,
+  g as p,
+  he as v
+};