@agrotools1/at-components 0.3.5 → 0.3.6

package/dist/utils-7d755f59.js

@@ -0,0 +1,433 @@
+import { d as N } from "./ClassBreaksDefinition-a4abcf50.js";
+import { s as k } from "./index-4ead5b97.js";
+const q = () => k.getLogger("esri.rest.support.generateRendererUtils");
+function g(t, e) {
+  return Number(t.toFixed(e));
+}
+function C(t) {
+  const { normalizationTotal: e } = t;
+  return { classBreaks: w(t), normalizationTotal: e };
+}
+function w(t) {
+  const e = t.definition, { classificationMethod: l, normalizationType: n, definedInterval: u } = e, i = e.breakCount ?? 1, c = [];
+  let o = t.values;
+  if (o.length === 0)
+    return [];
+  o = o.sort((m, d) => m - d);
+  const f = o[0], p = o[o.length - 1];
+  if (l === "equal-interval")
+    if (o.length >= i) {
+      const m = (p - f) / i;
+      let d = f;
+      for (let r = 1; r < i; r++) {
+        const a = g(f + r * m, 6);
+        c.push({ minValue: d, maxValue: a, label: b(d, a, n) }), d = a;
+      }
+      c.push({ minValue: d, maxValue: p, label: b(d, p, n) });
+    } else
+      o.forEach((m) => {
+        c.push({ minValue: m, maxValue: m, label: b(m, m, n) });
+      });
+  else if (l === "natural-breaks") {
+    const m = E(o), d = t.valueFrequency || m.valueFrequency, r = B(m.uniqueValues, d, i);
+    let a = f;
+    for (let s = 1; s < i; s++)
+      if (m.uniqueValues.length > s) {
+        const h = g(m.uniqueValues[r[s]], 6);
+        c.push({ minValue: a, maxValue: h, label: b(a, h, n) }), a = h;
+      }
+    c.push({ minValue: a, maxValue: p, label: b(a, p, n) });
+  } else if (l === "quantile")
+    if (o.length >= i && f !== p) {
+      let m = f, d = Math.ceil(o.length / i), r = 0;
+      for (let a = 1; a < i; a++) {
+        let s = d + r - 1;
+        s > o.length && (s = o.length - 1), s < 0 && (s = 0), c.push({ minValue: m, maxValue: o[s], label: b(m, o[s], n) }), m = o[s], r += d, d = Math.ceil((o.length - r) / (i - a));
+      }
+      c.push({ minValue: m, maxValue: p, label: b(m, p, n) });
+    } else {
+      let m = -1;
+      for (let d = 0; d < o.length; d++) {
+        const r = o[d];
+        r !== m && (m = r, c.push({ minValue: m, maxValue: r, label: b(m, r, n) }), m = r);
+      }
+    }
+  else if (l === "standard-deviation") {
+    const m = P(o), d = L(o, m);
+    if (d === 0)
+      c.push({ minValue: o[0], maxValue: o[0], label: b(o[0], o[0], n) });
+    else {
+      const r = U(f, p, i, m, d) * d;
+      let a = 0, s = f;
+      for (let V = i; V >= 1; V--) {
+        const F = g(m - (V - 0.5) * r, 6);
+        c.push({ minValue: s, maxValue: F, label: b(s, F, n) }), s = F, a++;
+      }
+      let h = g(m + 0.5 * r, 6);
+      c.push({ minValue: s, maxValue: h, label: b(s, h, n) }), s = h, a++;
+      for (let V = 1; V <= i; V++)
+        h = a === 2 * i ? p : g(m + (V + 0.5) * r, 6), c.push({ minValue: s, maxValue: h, label: b(s, h, n) }), s = h, a++;
+    }
+  } else if (l === "defined-interval") {
+    if (!u)
+      return c;
+    const m = o[0], d = o[o.length - 1], r = Math.ceil((d - m) / u);
+    let a = m;
+    for (let s = 1; s < r; s++) {
+      const h = g(m + s * u, 6);
+      c.push({ minValue: a, maxValue: h, label: b(a, h, n) }), a = h;
+    }
+    c.push({ minValue: a, maxValue: d, label: b(a, d, n) });
+  }
+  return c;
+}
+function b(t, e, l) {
+  let n = null;
+  return n = t === e ? l && l === "percent-of-total" ? t + "%" : t.toString() : l && l === "percent-of-total" ? t + "% - " + e + "%" : t + " - " + e, n;
+}
+function E(t) {
+  const e = [], l = [];
+  let n = Number.MIN_VALUE, u = 1, i = -1;
+  for (let c = 0; c < t.length; c++) {
+    const o = t[c];
+    o === n ? (u++, l[i] = u) : o !== null && (e.push(o), n = o, u = 1, l.push(u), i++);
+  }
+  return { uniqueValues: e, valueFrequency: l };
+}
+function B(t, e, l) {
+  const n = t.length, u = [];
+  l > n && (l = n);
+  for (let c = 0; c < l; c++)
+    u.push(Math.round(c * n / l - 1));
+  u.push(n - 1);
+  let i = D(u, t, e, l);
+  return O(i.mean, i.sdcm, u, t, e, l) && (i = D(u, t, e, l)), u;
+}
+function D(t, e, l, n) {
+  let u = [], i = [], c = [], o = 0;
+  const f = [], p = [];
+  for (let a = 0; a < n; a++) {
+    const s = v(a, t, e, l);
+    f.push(s.sbMean), p.push(s.sbSdcm), o += p[a];
+  }
+  let m, d = o, r = !0;
+  for (; r || o < d; ) {
+    r = !1, u = [];
+    for (let a = 0; a < n; a++)
+      u.push(t[a]);
+    for (let a = 0; a < n; a++)
+      for (let s = t[a] + 1; s <= t[a + 1]; s++)
+        if (m = e[s], a > 0 && s !== t[a + 1] && Math.abs(m - f[a]) > Math.abs(m - f[a - 1]))
+          t[a] = s;
+        else if (a < n - 1 && t[a] !== s - 1 && Math.abs(m - f[a]) > Math.abs(m - f[a + 1])) {
+          t[a + 1] = s - 1;
+          break;
+        }
+    d = o, o = 0, i = [], c = [];
+    for (let a = 0; a < n; a++) {
+      i.push(f[a]), c.push(p[a]);
+      const s = v(a, t, e, l);
+      f[a] = s.sbMean, p[a] = s.sbSdcm, o += p[a];
+    }
+  }
+  if (o > d) {
+    for (let a = 0; a < n; a++)
+      t[a] = u[a], f[a] = i[a], p[a] = c[a];
+    o = d;
+  }
+  return { mean: f, sdcm: p };
+}
+function O(t, e, l, n, u, i) {
+  let c = 0, o = 0, f = 0, p = 0, m = !0;
+  for (let d = 0; d < 2 && m; d++) {
+    d === 0 && (m = !1);
+    for (let r = 0; r < i - 1; r++)
+      for (; l[r + 1] + 1 !== l[r + 2]; ) {
+        l[r + 1] = l[r + 1] + 1;
+        const a = v(r, l, n, u);
+        f = a.sbMean, c = a.sbSdcm;
+        const s = v(r + 1, l, n, u);
+        if (p = s.sbMean, o = s.sbSdcm, !(c + o < e[r] + e[r + 1])) {
+          l[r + 1] = l[r + 1] - 1;
+          break;
+        }
+        e[r] = c, e[r + 1] = o, t[r] = f, t[r + 1] = p, m = !0;
+      }
+    for (let r = i - 1; r > 0; r--)
+      for (; l[r] !== l[r - 1] + 1; ) {
+        l[r] = l[r] - 1;
+        const a = v(r - 1, l, n, u);
+        f = a.sbMean, c = a.sbSdcm;
+        const s = v(r, l, n, u);
+        if (p = s.sbMean, o = s.sbSdcm, !(c + o < e[r - 1] + e[r])) {
+          l[r] = l[r] + 1;
+          break;
+        }
+        e[r - 1] = c, e[r] = o, t[r - 1] = f, t[r] = p, m = !0;
+      }
+  }
+  return m;
+}
+function U(t, e, l, n, u) {
+  let i = Math.max(n - t, e - n) / u / l;
+  return i = i >= 1 ? 1 : i >= 0.5 ? 0.5 : 0.25, i;
+}
+function P(t) {
+  let e = 0;
+  for (let l = 0; l < t.length; l++)
+    e += t[l];
+  return e /= t.length, e;
+}
+function L(t, e) {
+  let l = 0;
+  for (let n = 0; n < t.length; n++) {
+    const u = t[n];
+    l += (u - e) * (u - e);
+  }
+  return l /= t.length, Math.sqrt(l);
+}
+function v(t, e, l, n) {
+  let u = 0, i = 0;
+  for (let f = e[t] + 1; f <= e[t + 1]; f++) {
+    const p = n[f];
+    u += l[f] * p, i += p;
+  }
+  i <= 0 && q().warn("Exception in Natural Breaks calculation");
+  const c = u / i;
+  let o = 0;
+  for (let f = e[t] + 1; f <= e[t + 1]; f++)
+    o += n[f] * (l[f] - c) ** 2;
+  return { sbMean: c, sbSdcm: o };
+}
+const G = "<Null>", A = "equal-interval", _ = 1, Y = 5, j = 10, Q = /\s*(\+|-)?((\d+(\.\d+)?)|(\.\d+))\s*/gi, R = /* @__PURE__ */ new Set(["esriFieldTypeDate", "esriFieldTypeInteger", "esriFieldTypeSmallInteger", "esriFieldTypeSingle", "esriFieldTypeDouble", "esriFieldTypeLong", "esriFieldTypeOID", "esriFieldTypeBigInteger"]), H = /* @__PURE__ */ new Set(["esriFieldTypeTimeOnly", "esriFieldTypeDateOnly"]), J = ["min", "max", "avg", "stddev", "count", "sum", "variance", "nullcount", "median"];
+function x(t) {
+  return t == null || typeof t == "string" && !t ? G : t;
+}
+function K(t) {
+  const e = t.normalizationField != null || t.normalizationType != null, l = t.minValue != null || t.maxValue != null, n = !!t.sqlExpression && t.supportsSQLExpression;
+  return !e && !l && !n;
+}
+function ht(t) {
+  const e = t.returnDistinct ? [...new Set(t.values)] : t.values, l = e.filter((i) => i != null).sort(), n = l.length, u = { count: n, min: l[0], max: l[n - 1] };
+  return t.supportsNullCount && (u.nullcount = e.length - n), t.percentileParams && (u.median = $(e, t.percentileParams)), u;
+}
+function W(t) {
+  const { values: e, useSampleStdDev: l, supportsNullCount: n } = t;
+  let u = Number.POSITIVE_INFINITY, i = Number.NEGATIVE_INFINITY, c = null, o = null, f = null, p = null, m = 0;
+  const d = t.minValue == null ? -1 / 0 : t.minValue, r = t.maxValue == null ? 1 / 0 : t.maxValue;
+  for (const s of e)
+    Number.isFinite(s) ? s >= d && s <= r && (c = c === null ? s : c + s, u = Math.min(u, s), i = Math.max(i, s), m++) : typeof s == "string" && m++;
+  if (m && c != null) {
+    o = c / m;
+    let s = 0;
+    for (const h of e)
+      Number.isFinite(h) && h >= d && h <= r && (s += (h - o) ** 2);
+    p = l ? m > 1 ? s / (m - 1) : 0 : m > 0 ? s / m : 0, f = Math.sqrt(p);
+  } else
+    u = null, i = null;
+  const a = { avg: o, count: m, max: i, min: u, stddev: f, sum: c, variance: p };
+  return n && (a.nullcount = e.length - m), t.percentileParams && (a.median = $(e, t.percentileParams)), a;
+}
+function $(t, e) {
+  const { fieldType: l, value: n, orderBy: u, isDiscrete: i } = e, c = X(l, u === "desc");
+  if ((t = [...t].filter((a) => a != null).sort((a, s) => c(a, s))).length === 0)
+    return null;
+  if (n <= 0)
+    return t[0];
+  if (n >= 1)
+    return t[t.length - 1];
+  const o = (t.length - 1) * n, f = Math.floor(o), p = f + 1, m = o % 1, d = t[f], r = t[p];
+  return p >= t.length || i || typeof d == "string" || typeof r == "string" ? d : d * (1 - m) + r * m;
+}
+function X(t, e) {
+  if (t) {
+    if (R.has(t))
+      return S(e);
+    if (H.has(t))
+      return M(e, !1);
+    if (t === "esriFieldTypeTimestampOffset")
+      return lt(e);
+    const i = M(e, !0);
+    if (t === "esriFieldTypeString")
+      return i;
+    if (t === "esriFieldTypeGUID" || t === "esriFieldTypeGlobalID")
+      return (c, o) => i(I(c), I(o));
+  }
+  const l = e ? 1 : -1, n = S(e), u = M(e, !0);
+  return (i, c) => typeof i == "number" && typeof c == "number" ? n(i, c) : typeof i == "string" && typeof c == "string" ? u(i, c) : l;
+}
+const T = (t, e) => t == null ? e == null ? 0 : 1 : e == null ? -1 : null, y = (t, e) => t == null ? e == null ? 0 : -1 : e == null ? 1 : null;
+function Z(t) {
+  return t ? T : y;
+}
+const tt = (t, e) => y(t, e) ?? (t === e ? 0 : new Date(t).getTime() - new Date(e).getTime()), et = (t, e) => T(t, e) ?? (t === e ? 0 : new Date(e).getTime() - new Date(t).getTime());
+function lt(t) {
+  return t ? et : tt;
+}
+const nt = (t, e) => y(t, e) ?? (t === e ? 0 : t < e ? -1 : 1), at = (t, e) => T(t, e) ?? (t === e ? 0 : t < e ? 1 : -1);
+function M(t, e) {
+  if (!e)
+    return t ? at : nt;
+  const l = Z(t);
+  return t ? (n, u) => {
+    const i = l(n, u);
+    return i ?? ((n = n.toUpperCase()) > (u = u.toUpperCase()) ? -1 : n < u ? 1 : 0);
+  } : (n, u) => {
+    const i = l(n, u);
+    return i ?? ((n = n.toUpperCase()) < (u = u.toUpperCase()) ? -1 : n > u ? 1 : 0);
+  };
+}
+const it = (t, e) => T(t, e) ?? e - t, ut = (t, e) => y(t, e) ?? t - e;
+function S(t) {
+  return t ? it : ut;
+}
+function I(t) {
+  return t.substr(24, 12) + t.substr(19, 4) + t.substr(16, 2) + t.substr(14, 2) + t.substr(11, 2) + t.substr(9, 2) + t.substr(6, 2) + t.substr(4, 2) + t.substr(2, 2) + t.substr(0, 2);
+}
+function bt(t, e) {
+  let l;
+  for (l in t)
+    J.includes(l) && (Number.isFinite(t[l]) || (t[l] = null));
+  return e && ["avg", "stddev", "variance"].forEach((n) => {
+    t[n] != null && (t[n] = Math.ceil(t[n] ?? 0));
+  }), t;
+}
+function Vt(t) {
+  const e = {};
+  for (let l of t)
+    (l == null || typeof l == "string" && l.trim() === "") && (l = null), e[l] == null ? e[l] = { count: 1, data: l } : e[l].count++;
+  return { count: e };
+}
+function z(t) {
+  return (t == null ? void 0 : t.type) !== "coded-value" ? [] : t.codedValues.map((e) => e.code);
+}
+function gt(t, e, l, n) {
+  const u = t.count, i = [];
+  if (l && e) {
+    const c = [], o = z(e[0]);
+    for (const f of o)
+      if (e[1]) {
+        const p = z(e[1]);
+        for (const m of p)
+          if (e[2]) {
+            const d = z(e[2]);
+            for (const r of d)
+              c.push(`${x(f)}${n}${x(m)}${n}${x(r)}`);
+          } else
+            c.push(`${x(f)}${n}${x(m)}`);
+      } else
+        c.push(f);
+    for (const f of c)
+      u.hasOwnProperty(f) || (u[f] = { data: f, count: 0 });
+  }
+  for (const c in u) {
+    const o = u[c];
+    i.push({ value: o.data, count: o.count, label: o.label });
+  }
+  return { uniqueValueInfos: i };
+}
+function vt(t, e, l, n) {
+  let u = null;
+  switch (e) {
+    case "log":
+      t !== 0 && (u = Math.log(t) * Math.LOG10E);
+      break;
+    case "percent-of-total":
+      Number.isFinite(n) && n !== 0 && (u = t / n * 100);
+      break;
+    case "field":
+      Number.isFinite(l) && l !== 0 && (u = t / l);
+      break;
+    case "natural-log":
+      t > 0 && (u = Math.log(t));
+      break;
+    case "square-root":
+      t > 0 && (u = t ** 0.5);
+  }
+  return u;
+}
+function ot(t, e) {
+  const l = st({ field: e.field, normalizationType: e.normalizationType, normalizationField: e.normalizationField, classificationMethod: e.classificationMethod, standardDeviationInterval: e.standardDeviationInterval, breakCount: e.numClasses || Y });
+  return t = rt(t, e.minValue, e.maxValue), C({ definition: l, values: t, normalizationTotal: e.normalizationTotal });
+}
+function rt(t, e, l) {
+  const n = e ?? -1 / 0, u = l ?? 1 / 0;
+  return t.filter((i) => Number.isFinite(i) && i >= n && i <= u);
+}
+function st(t) {
+  const { breakCount: e, field: l, normalizationField: n, normalizationType: u } = t, i = t.classificationMethod || A, c = i === "standard-deviation" ? t.standardDeviationInterval || _ : void 0;
+  return new N({ breakCount: e, classificationField: l, classificationMethod: i, normalizationField: u === "field" ? n : void 0, normalizationType: u, standardDeviationInterval: c });
+}
+function xt(t, e) {
+  var f, p;
+  let l = t.classBreaks;
+  const n = l.length, u = (f = l[0]) == null ? void 0 : f.minValue, i = (p = l[n - 1]) == null ? void 0 : p.maxValue, c = e === "standard-deviation", o = Q;
+  return l = l.map((m) => {
+    const d = m.label, r = { minValue: m.minValue, maxValue: m.maxValue, label: d };
+    if (c && d) {
+      const a = d.match(o), s = (a == null ? void 0 : a.map((h) => +h.trim())) ?? [];
+      s.length === 2 ? (r.minStdDev = s[0], r.maxStdDev = s[1], s[0] < 0 && s[1] > 0 && (r.hasAvg = !0)) : s.length === 1 && (d.includes("<") ? (r.minStdDev = null, r.maxStdDev = s[0]) : d.includes(">") && (r.minStdDev = s[0], r.maxStdDev = null));
+    }
+    return r;
+  }), { minValue: u, maxValue: i, classBreakInfos: l, normalizationTotal: t.normalizationTotal };
+}
+function Tt(t, e) {
+  const l = ct(t, e);
+  if (l.min == null && l.max == null)
+    return { bins: [], minValue: l.min, maxValue: l.max, normalizationTotal: e.normalizationTotal };
+  const n = l.intervals, u = l.min ?? 0, i = l.max ?? 0, c = n.map((o, f) => ({ minValue: n[f][0], maxValue: n[f][1], count: 0 }));
+  for (const o of t)
+    if (o != null && o >= u && o <= i) {
+      const f = mt(n, o);
+      f > -1 && c[f].count++;
+    }
+  return { bins: c, minValue: u, maxValue: i, normalizationTotal: e.normalizationTotal };
+}
+function ct(t, e) {
+  const { field: l, classificationMethod: n, standardDeviationInterval: u, normalizationType: i, normalizationField: c, normalizationTotal: o, minValue: f, maxValue: p } = e, m = e.numBins || j;
+  let d = null, r = null, a = null;
+  if ((!n || n === "equal-interval") && !i) {
+    if (f != null && p != null)
+      d = f, r = p;
+    else {
+      const s = W({ values: t, minValue: f, maxValue: p, useSampleStdDev: !i, supportsNullCount: K({ normalizationType: i, normalizationField: c, minValue: f, maxValue: p }) });
+      d = s.min ?? null, r = s.max ?? null;
+    }
+    a = ft(d ?? 0, r ?? 0, m);
+  } else {
+    const { classBreaks: s } = ot(t, { field: l, normalizationType: i, normalizationField: c, normalizationTotal: o, classificationMethod: n, standardDeviationInterval: u, minValue: f, maxValue: p, numClasses: m });
+    d = s[0].minValue, r = s[s.length - 1].maxValue, a = s.map((h) => [h.minValue, h.maxValue]);
+  }
+  return { min: d, max: r, intervals: a };
+}
+function mt(t, e) {
+  let l = -1;
+  for (let n = t.length - 1; n >= 0; n--)
+    if (e >= t[n][0]) {
+      l = n;
+      break;
+    }
+  return l;
+}
+function ft(t, e, l) {
+  const n = (e - t) / l, u = [];
+  let i, c = t;
+  for (let o = 1; o <= l; o++)
+    i = c + n, i = Number(i.toFixed(16)), u.push([c, o === l ? e : i]), c = i;
+  return u;
+}
+export {
+  gt as $,
+  vt as B,
+  bt as C,
+  ot as E,
+  xt as P,
+  X as T,
+  Tt as U,
+  x as c,
+  ht as d,
+  K as f,
+  Vt as k,
+  W as p,
+  $ as v
+};

package/dist/utils-8b01c610.js

@@ -0,0 +1,232 @@
+import { ad as a, cW as m, gD as h, gE as k, gF as g, gG as S } from "./index-4ead5b97.js";
+import "./parser-bab9c2ce.js";
+import { M, f as C, m as z, y as I, b as L } from "./utils-b1ab6c91.js";
+import { e as x } from "./LRUCache-7a6c25d0.js";
+function j(o) {
+  const t = [];
+  return b(M(o), t), t.length ? new a(C(t[0])) : null;
+}
+function b(o, t) {
+  var e;
+  if (!o)
+    return;
+  let n;
+  n = o.type === "CIMTextSymbol" ? o.symbol : o;
+  const l = o.type === "CIMPolygonSymbol";
+  if (n != null && n.symbolLayers) {
+    for (const r of n.symbolLayers)
+      if (!(r.colorLocked || l && (z(r) || I(r) && r.markerPlacement && L(r.markerPlacement))))
+        switch (r.type) {
+          case "CIMPictureMarker":
+          case "CIMPictureStroke":
+          case "CIMPictureFill":
+            r.tintColor && p(t, r.tintColor);
+            break;
+          case "CIMVectorMarker":
+            (e = r.markerGraphics) == null || e.forEach((c) => {
+              b(c.symbol, t);
+            });
+            break;
+          case "CIMSolidStroke":
+          case "CIMSolidFill":
+            p(t, r.color);
+            break;
+          case "CIMHatchFill":
+            b(r.lineSymbol, t);
+        }
+  }
+}
+function p(o, t) {
+  for (const n of o)
+    if (n.join(".") === t.join("."))
+      return;
+  o.push(t);
+}
+new x(1e3);
+new a([128, 128, 128]);
+const $ = new a("white");
+function _(o, t) {
+  if (!o)
+    return null;
+  let n = null;
+  return m(o) ? n = E(o) : h(o) && (n = o.type === "cim" ? j(o) : o.color ? new a(o.color) : null), n ? y(n, t) : null;
+}
+function E(o) {
+  const t = o.symbolLayers;
+  if (!t)
+    return null;
+  let n = null;
+  return t.forEach((l) => {
+    var e;
+    l.type === "object" && ((e = l.resource) != null && e.href) || (n = l.type === "water" ? l.color : l.material ? l.material.color : null);
+  }), n ? new a(n) : null;
+}
+function y(o, t) {
+  if (t == null || o == null)
+    return o;
+  const n = o.toRgba();
+  return n[3] = n[3] * t, new a(n);
+}
+function P(o, t, n) {
+  const l = o.symbolLayers;
+  if (!l)
+    return;
+  const e = (r) => y(t = t ?? r ?? (n != null ? $ : null), n);
+  l.forEach((r) => {
+    var c, s;
+    if (r.type !== "object" || !((c = r.resource) != null && c.href) || t)
+      if (r.type === "water")
+        r.color = e(r.color);
+      else {
+        const i = r.material != null ? r.material.color : null, u = e(i);
+        r.material == null ? r.material = new S({ color: u }) : r.material.color = u, n != null && "outline" in r && ((s = r.outline) == null ? void 0 : s.color) != null && (r.outline.color = y(r.outline.color, n));
+      }
+  });
+}
+function v(o, t, n) {
+  var l;
+  (t = t ?? o.color) && (o.color = y(t, n)), n != null && "outline" in o && ((l = o.outline) != null && l.color) && (o.outline.color = y(o.outline.color, n));
+}
+function q(o, t, n) {
+  o && (t || n != null) && (t && (t = new a(t)), m(o) ? P(o, t, n) : h(o) && v(o, t, n));
+}
+async function F(o, t) {
+  const n = o.symbolLayers;
+  n && await k(n, async (l) => R(l, t));
+}
+async function R(o, t) {
+  switch (o.type) {
+    case "extrude":
+      G(o, t);
+      break;
+    case "icon":
+    case "line":
+    case "text":
+      D(o, t);
+      break;
+    case "path":
+      H(o, t);
+      break;
+    case "object":
+      await O(o, t);
+  }
+}
+function D(o, t) {
+  const n = w(t);
+  n != null && (o.size = n);
+}
+function w(o) {
+  for (const t of o)
+    if (typeof t == "number")
+      return t;
+  return null;
+}
+function G(o, t) {
+  o.size = typeof t[2] == "number" ? t[2] : 0;
+}
+async function O(o, t) {
+  const { resourceSize: n, symbolSize: l } = await J(o), e = d(t, n, l);
+  o.width = f(t[0], l[0], n[0], e), o.depth = f(t[1], l[1], n[1], e), o.height = f(t[2], l[2], n[2], e);
+}
+function H(o, t) {
+  const n = d(t, g, [o.width, void 0, o.height]);
+  o.width = f(t[0], o.width, 1, n), o.height = f(t[2], o.height, 1, n);
+}
+function d(o, t, n) {
+  for (let l = 0; l < 3; l++) {
+    const e = o[l];
+    switch (e) {
+      case "symbol-value": {
+        const r = n[l];
+        return r != null ? r / t[l] : 1;
+      }
+      case "proportional":
+        break;
+      default:
+        if (e && t[l])
+          return e / t[l];
+    }
+  }
+  return 1;
+}
+async function J(o) {
+  const { computeObjectLayerResourceSize: t } = await import("./symbolLayerUtils-864ff340.js"), n = await t(o, 10), { width: l, height: e, depth: r } = o, c = [l, r, e];
+  let s = 1;
+  for (let i = 0; i < 3; i++) {
+    const u = c[i];
+    if (u != null) {
+      s = u / n[i];
+      break;
+    }
+  }
+  for (let i = 0; i < 3; i++)
+    c[i] == null && (c[i] = n[i] * s);
+  return { resourceSize: n, symbolSize: c };
+}
+function f(o, t, n, l) {
+  switch (o) {
+    case "proportional":
+      return n * l;
+    case "symbol-value":
+      return t ?? n;
+    default:
+      return o;
+  }
+}
+function N(o, t) {
+  const n = w(t);
+  if (n != null)
+    switch (o.type) {
+      case "simple-marker":
+        o.size = n;
+        break;
+      case "picture-marker": {
+        const l = o.width / o.height;
+        l > 1 ? (o.width = n, o.height = n * l) : (o.width = n * l, o.height = n);
+        break;
+      }
+      case "simple-line":
+        o.width = n;
+        break;
+      case "text":
+        o.font.size = n;
+    }
+}
+async function A(o, t) {
+  if (o && t)
+    return m(o) ? F(o, t) : void (h(o) && N(o, t));
+}
+function B(o, t, n) {
+  if (o && t != null)
+    if (m(o)) {
+      const l = o.symbolLayers;
+      l && l.forEach((e) => {
+        if (e && e.type === "object")
+          switch (n) {
+            case "tilt":
+              e.tilt = (e.tilt ?? 0) + t;
+              break;
+            case "roll":
+              e.roll = (e.roll ?? 0) + t;
+              break;
+            default:
+              e.heading = (e.heading ?? 0) + t;
+          }
+      });
+    } else
+      h(o) && (o.type !== "simple-marker" && o.type !== "picture-marker" && o.type !== "text" || (o.angle += t));
+}
+function K(o) {
+  return o != null && o.type === "polygon-3d" && o.symbolLayers.some((t) => t.type === "extrude");
+}
+async function Q(o, t) {
+  return await o.fetchSymbol(t) || o.fetchCIMSymbol(t);
+}
+export {
+  B as D,
+  K as J,
+  Q as N,
+  A as R,
+  q as g,
+  _ as h
+};