import {
  a,
  l
} from "./chunk-ULSPZIPE.js";

// node_modules/@arcgis/core/statistics/utils.js
var t = "<Null>";
var i = "equal-interval";
var l2 = 1;
var a2 = 5;
var o = 10;
var r = /\s*(\+|-)?((\d+(\.\d+)?)|(\.\d+))\s*/gi;
var u = /* @__PURE__ */ new Set(["esriFieldTypeInteger", "esriFieldTypeSmallInteger", "esriFieldTypeSingle", "esriFieldTypeDouble"]);
var s = ["min", "max", "avg", "stddev", "count", "sum", "variance", "nullcount", "median"];
function c(n) {
  return null == n || "string" == typeof n && !n ? t : n;
}
function m(n) {
  const e = null != n.normalizationField || null != n.normalizationType, t2 = null != n.minValue || null != n.maxValue, i2 = !!n.sqlExpression && n.supportsSQLExpression;
  return !e && !t2 && !i2;
}
function f(n) {
  const e = n.returnDistinct ? [...new Set(n.values)] : n.values, t2 = e.filter((n2) => null != n2).length, i2 = { count: t2 };
  return n.supportsNullCount && (i2.nullcount = e.length - t2), n.percentileParams && (i2.median = p(e, n.percentileParams)), i2;
}
function d(n) {
  const { values: e, useSampleStdDev: t2, supportsNullCount: i2 } = n;
  let l3 = Number.POSITIVE_INFINITY, a3 = Number.NEGATIVE_INFINITY, o2 = null, r2 = null, u2 = null, s2 = null, c2 = 0;
  const m2 = null == n.minValue ? -1 / 0 : n.minValue, f2 = null == n.maxValue ? 1 / 0 : n.maxValue;
  for (const p2 of e)
    Number.isFinite(p2) ? p2 >= m2 && p2 <= f2 && (o2 += p2, l3 = Math.min(l3, p2), a3 = Math.max(a3, p2), c2++) : "string" == typeof p2 && c2++;
  if (c2 && null != o2) {
    r2 = o2 / c2;
    let n2 = 0;
    for (const t3 of e)
      Number.isFinite(t3) && t3 >= m2 && t3 <= f2 && (n2 += (t3 - r2) ** 2);
    s2 = t2 ? c2 > 1 ? n2 / (c2 - 1) : 0 : c2 > 0 ? n2 / c2 : 0, u2 = Math.sqrt(s2);
  } else
    l3 = null, a3 = null;
  const d2 = { avg: r2, count: c2, max: a3, min: l3, stddev: u2, sum: o2, variance: s2 };
  return i2 && (d2.nullcount = e.length - c2), n.percentileParams && (d2.median = p(e, n.percentileParams)), d2;
}
function p(n, e) {
  const { fieldType: t2, value: i2, orderBy: l3, isDiscrete: a3 } = e, o2 = v(t2, "desc" === l3);
  if (0 === (n = [...n].filter((n2) => null != n2).sort((n2, e2) => o2(n2, e2))).length)
    return null;
  if (i2 <= 0)
    return n[0];
  if (i2 >= 1)
    return n[n.length - 1];
  const r2 = (n.length - 1) * i2, u2 = Math.floor(r2), s2 = u2 + 1, c2 = r2 % 1, m2 = n[u2], f2 = n[s2];
  return s2 >= n.length || a3 || "string" == typeof m2 || "string" == typeof f2 ? m2 : m2 * (1 - c2) + f2 * c2;
}
function v(n, e) {
  const t2 = e ? 1 : -1, i2 = h(e), l3 = b(e);
  if (!(!!n && ["esriFieldTypeDate", "esriFieldTypeString", "esriFieldTypeGUID", "esriFieldTypeGlobalID", ...u].includes(n)))
    return (n2, e2) => "number" == typeof n2 && "number" == typeof e2 ? i2(n2, e2) : "string" == typeof n2 && "string" == typeof e2 ? l3(n2, e2) : t2;
  if ("esriFieldTypeDate" === n)
    return (n2, e2) => {
      const l4 = new Date(n2).getTime(), a3 = new Date(e2).getTime();
      return isNaN(l4) || isNaN(a3) ? t2 : i2(l4, a3);
    };
  if (u.has(n))
    return (n2, e2) => i2(n2, e2);
  if ("esriFieldTypeString" === n)
    return (n2, e2) => l3(n2, e2);
  if ("esriFieldTypeGUID" === n || "esriFieldTypeGlobalID" === n) {
    const n2 = b(e);
    return (e2, t3) => n2(g(e2), g(t3));
  }
  return e ? (n2, e2) => 1 : (n2, e2) => -1;
}
function b(n) {
  return n ? (n2, e) => (n2 = n2 == null ? void 0 : n2.toUpperCase(), e = e == null ? void 0 : e.toUpperCase(), n2 > e ? -1 : n2 < e ? 1 : 0) : (n2, e) => (n2 = n2 == null ? void 0 : n2.toUpperCase(), e = e == null ? void 0 : e.toUpperCase(), n2 < e ? -1 : n2 > e ? 1 : 0);
}
function h(n) {
  return n ? (n2, e) => e - n2 : (n2, e) => n2 - e;
}
function g(n) {
  return n.substr(24, 12) + n.substr(19, 4) + n.substr(16, 2) + n.substr(14, 2) + n.substr(11, 2) + n.substr(9, 2) + n.substr(6, 2) + n.substr(4, 2) + n.substr(2, 2) + n.substr(0, 2);
}
function V(n, e) {
  let t2;
  for (t2 in n)
    s.includes(t2) && (Number.isFinite(n[t2]) || (n[t2] = null));
  return e ? (["avg", "stddev", "variance"].forEach((e2) => {
    null != n[e2] && (n[e2] = Math.ceil(n[e2]));
  }), n) : n;
}
function T(n) {
  const e = {};
  for (let t2 of n)
    (null == t2 || "string" == typeof t2 && "" === t2.trim()) && (t2 = null), null == e[t2] ? e[t2] = { count: 1, data: t2 } : e[t2].count++;
  return { count: e };
}
function y(n) {
  return "coded-value" !== (n == null ? void 0 : n.type) ? [] : n.codedValues.map((n2) => n2.code);
}
function F(n, e, t2, i2) {
  const l3 = n.count, a3 = [];
  if (t2 && e) {
    const n2 = [], t3 = y(e[0]);
    for (const l4 of t3)
      if (e[1]) {
        const t4 = y(e[1]);
        for (const a4 of t4)
          if (e[2]) {
            const t5 = y(e[2]);
            for (const e2 of t5)
              n2.push(`${c(l4)}${i2}${c(a4)}${i2}${c(e2)}`);
          } else
            n2.push(`${c(l4)}${i2}${c(a4)}`);
      } else
        n2.push(l4);
    for (const e2 of n2)
      l3.hasOwnProperty(e2) || (l3[e2] = { data: e2, count: 0 });
  }
  for (const o2 in l3) {
    const n2 = l3[o2];
    a3.push({ value: n2.data, count: n2.count, label: n2.label });
  }
  return { uniqueValueInfos: a3 };
}
function x(n, e, t2, i2) {
  let l3 = null;
  switch (e) {
    case "log":
      0 !== n && (l3 = Math.log(n) * Math.LOG10E);
      break;
    case "percent-of-total":
      Number.isFinite(i2) && 0 !== i2 && (l3 = n / i2 * 100);
      break;
    case "field":
      Number.isFinite(t2) && 0 !== t2 && (l3 = n / t2);
      break;
    case "natural-log":
      n > 0 && (l3 = Math.log(n));
      break;
    case "square-root":
      n > 0 && (l3 = n ** 0.5);
  }
  return l3;
}
function D(n, t2) {
  const i2 = I({ field: t2.field, normalizationType: t2.normalizationType, normalizationField: t2.normalizationField, classificationMethod: t2.classificationMethod, standardDeviationInterval: t2.standardDeviationInterval, breakCount: t2.numClasses || a2 });
  return n = z(n, t2.minValue, t2.maxValue), a({ definition: i2, values: n, normalizationTotal: t2.normalizationTotal });
}
function z(n, e, t2) {
  return e = e != null ? e : -1 / 0, t2 = t2 != null ? t2 : 1 / 0, n.filter((n2) => Number.isFinite(n2) && n2 >= e && n2 <= t2);
}
function I(e) {
  const t2 = e.field, a3 = e.classificationMethod || i, o2 = e.normalizationType, r2 = e.normalizationField, u2 = new l();
  return u2.classificationField = t2, u2.breakCount = e.breakCount, u2.classificationMethod = a3, u2.standardDeviationInterval = "standard-deviation" === a3 ? e.standardDeviationInterval || l2 : void 0, u2.normalizationType = o2, u2.normalizationField = "field" === o2 ? r2 : void 0, u2;
}
function N(n, e) {
  let t2 = n.classBreaks;
  const i2 = t2.length, l3 = t2[0].minValue, a3 = t2[i2 - 1].maxValue, o2 = "standard-deviation" === e, u2 = r;
  return t2 = t2.map((n2) => {
    const e2 = n2.label, t3 = { minValue: n2.minValue, maxValue: n2.maxValue, label: e2 };
    if (o2 && e2) {
      const n3 = e2.match(u2).map((n4) => +n4.trim());
      2 === n3.length ? (t3.minStdDev = n3[0], t3.maxStdDev = n3[1], n3[0] < 0 && n3[1] > 0 && (t3.hasAvg = true)) : 1 === n3.length && (e2.includes("<") ? (t3.minStdDev = null, t3.maxStdDev = n3[0]) : e2.includes(">") && (t3.minStdDev = n3[0], t3.maxStdDev = null));
    }
    return t3;
  }), { minValue: l3, maxValue: a3, classBreakInfos: t2, normalizationTotal: n.normalizationTotal };
}
function S(n, e) {
  const { min: t2, max: i2, intervals: l3 } = M(n, e), a3 = l3.map((n2, e2) => ({ minValue: l3[e2][0], maxValue: l3[e2][1], count: 0 }));
  for (const o2 of n)
    if (null != o2 && o2 >= t2 && o2 <= i2) {
      const n2 = C(l3, o2);
      n2 > -1 && a3[n2].count++;
    }
  return { bins: a3, minValue: t2, maxValue: i2, normalizationTotal: e.normalizationTotal };
}
function M(n, e) {
  const { field: t2, classificationMethod: i2, standardDeviationInterval: l3, normalizationType: a3, normalizationField: r2, normalizationTotal: u2, minValue: s2, maxValue: c2 } = e, f2 = e.numBins || o;
  let p2 = null, v2 = null, b2 = null;
  if ((!i2 || "equal-interval" === i2) && !a3) {
    if (null != s2 && null != c2)
      p2 = s2, v2 = c2;
    else {
      const e2 = d({ values: n, minValue: s2, maxValue: c2, useSampleStdDev: !a3, supportsNullCount: m({ normalizationType: a3, normalizationField: r2, minValue: s2, maxValue: c2 }) });
      p2 = e2.min, v2 = e2.max;
    }
    b2 = k(p2, v2, f2);
  } else {
    const { classBreaks: e2 } = D(n, { field: t2, normalizationType: a3, normalizationField: r2, normalizationTotal: u2, classificationMethod: i2, standardDeviationInterval: l3, minValue: s2, maxValue: c2, numClasses: f2 });
    p2 = e2[0].minValue, v2 = e2[e2.length - 1].maxValue, b2 = e2.map((n2) => [n2.minValue, n2.maxValue]);
  }
  return { min: p2, max: v2, intervals: b2 };
}
function C(n, e) {
  let t2 = -1;
  for (let i2 = n.length - 1; i2 >= 0; i2--) {
    if (e >= n[i2][0]) {
      t2 = i2;
      break;
    }
  }
  return t2;
}
function k(n, e, t2) {
  const i2 = (e - n) / t2, l3 = [];
  let a3, o2 = n;
  for (let r2 = 1; r2 <= t2; r2++)
    a3 = o2 + i2, a3 = Number(a3.toFixed(16)), l3.push([o2, r2 === t2 ? e : a3]), o2 = a3;
  return l3;
}

export {
  c,
  m,
  f,
  d,
  p,
  v,
  V,
  T,
  F,
  x,
  D,
  N,
  S
};
//# sourceMappingURL=chunk-PZ7XDUL6.js.map