intergalactic 15.126.0-prerelease.9 → 15.126.1-prerelease.0

package/d3-chart/lib/esm/semcore/d3-chart/src/a11y/insights.mjs

@@ -0,0 +1,523 @@
+import $e from "@babel/runtime/helpers/esm/slicedToArray";
+import L from "@babel/runtime/helpers/esm/defineProperty";
+import z from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import o from "@babel/runtime/helpers/esm/toConsumableArray";
+import Me from "@babel/runtime/helpers/esm/typeof";
+import { makeBezier as _e } from "./bezier.mjs";
+var R = function(l, e) {
+  typeof e == "number" && (e = String(e)), typeof e == "string" && (e = e.split("."));
+  for (var y = 0; y < e.length; y++) {
+    if (Me(l) !== "object" || l === null) return l;
+    l = l[e[y]];
+  }
+  return l;
+}, ie = function(l, e) {
+  var y = [];
+  e = Math.floor(e) % 2 === l.length % 2 ? Math.floor(e) : Math.ceil(e);
+  for (var h = 0; h < l.length; h++) {
+    var k = Math.max(0, h - Math.floor(e / 2)), O = Math.min(l.length, h + Math.ceil(e / 2));
+    k = Math.min(k, Math.max(0, O - e)), O = Math.max(O, Math.min(l.length, k + e));
+    var c = l.slice(k, O), f = c.reduce(function(w, Tr) {
+      return w + Tr;
+    }, 0), C = f / c.length;
+    y.push(C);
+  }
+  return y;
+}, ul = function(l, e, y) {
+  var h, k, O, c = [], f = (h = y.dataType) !== null && h !== void 0 ? h : e.dataType, C = [], w = o(e.groups), Tr = (k = e.axesTitle.vertical) !== null && k !== void 0 ? k : e.axesTitle.horizontal, B = 0, x = Object.fromEntries(Object.keys((O = Array.isArray(l) ? l[0] : l) !== null && O !== void 0 ? O : {}).map(function(r) {
+    return [r, !0];
+  }));
+  if (!f)
+    if ((x.y || x.y1 || x.y2) && x.x && (x.value || x.label) || e.fields.horizontalAxes.size > 0 && e.fields.verticalAxes.size > 0 && e.fields.valueAxes.size > 0)
+      f = "points-cloud";
+    else if (Array.isArray(l) && l.length > 6)
+      f = "time-series";
+    else if (Array.isArray(l) && Object.keys(x).length >= 3) {
+      var Ma = Object.keys(x).filter(function(r) {
+        return typeof l[0][r] == "string";
+      }).filter(function(r) {
+        var a = l.map(function(v) {
+          return v[r];
+        });
+        return new Set(a).size === a.length;
+      });
+      Ma.length === 1 ? (w = Ma, f = "grouped-values") : f = "values-set";
+    } else
+      f = "values-set";
+  if (f === "grouped-values" && w.length === 0 && (f = "values-set"), Array.isArray(l)) {
+    if (f === "time-series") {
+      var Nr, gr, hr, da, kr, Or, jr, Ta, de = l[0], Te = l[l.length - 1], Ne = ["y", "value"].concat(o(e.fields.verticalAxes)), Na = Ne.filter(function(r) {
+        return x[r];
+      }), ge = ["label", "x"].concat(o(e.fields.horizontalAxes)), F = ge.filter(function(r) {
+        return x[r];
+      })[0];
+      B = Object.keys(Na).length;
+      var Pr = de[F], Vr = Te[F], ga = (Nr = (gr = (hr = (da = e.titles).getHorizontalAxesTitle) === null || hr === void 0 ? void 0 : hr.call(da, Pr)) !== null && gr !== void 0 ? gr : e.titles.horizontalAxes[Pr]) !== null && Nr !== void 0 ? Nr : Pr, ha = (kr = (Or = (jr = (Ta = e.titles).getHorizontalAxesTitle) === null || jr === void 0 ? void 0 : jr.call(Ta, Vr)) !== null && Or !== void 0 ? Or : e.titles.horizontalAxes[Vr]) !== null && kr !== void 0 ? kr : Vr;
+      if (B > 0) {
+        var qr;
+        C.push({
+          from: ga,
+          to: ha,
+          label: (qr = e.axesTitle.vertical) !== null && qr !== void 0 ? qr : F
+        });
+      }
+      var D = z(Na), ka;
+      try {
+        var he = function() {
+          var a, v, A, n = ka.value, u = l.map(function(T) {
+            return T[n];
+          }).filter(function(T) {
+            return Me(T) !== "symbol";
+          }), P = u.reduce(function(T, q) {
+            return T + q;
+          }, 0), br = P / u.length, $r = 1 / u.length * u.map(function(T) {
+            return Math.pow(T - br, 2);
+          }).reduce(function(T, q) {
+            return T + q;
+          }, 0), U = Math.sqrt($r), W = ["static", "weak", "medium", "strong"], Z = Math.sqrt(u.length), K = (a = y.movingAverage.longSize) !== null && a !== void 0 ? a : Z, Y = (v = y.movingAverage.shortSize) !== null && v !== void 0 ? v : Math.sqrt(Z), E = ie(u, K), t = u.length < 8 ? u : ie(u, Y), ir = [];
+          for (var b in u) {
+            var V, X, _r;
+            ir.push({
+              value: ((V = u[b]) !== null && V !== void 0 ? V : NaN).toFixed(2),
+              long: ((X = E[b]) !== null && X !== void 0 ? X : NaN).toFixed(2),
+              short: ((_r = t[b]) !== null && _r !== void 0 ? _r : NaN).toFixed(2)
+            });
+          }
+          var ce = {
+            growth: {
+              static: "static",
+              weak: "weak-growth",
+              medium: "growth",
+              strong: "strong-growth"
+            },
+            reduction: {
+              static: "static",
+              weak: "weak-reduction",
+              medium: "reduction",
+              strong: "strong-reduction"
+            }
+          }, ra = function(q) {
+            for (var G = q.value, Ke = q.width, dr = q.label, Ye = q.type, S = 0; S < W.length; S++) {
+              var pa, ya, xa, Aa, Xe = Math.abs(G.from - G.to) / ((pa = (ya = e.pointsDensity) === null || ya === void 0 ? void 0 : ya.verticalAxes) !== null && pa !== void 0 ? pa : 1), Se = Ke / ((xa = (Aa = e.pointsDensity) === null || Aa === void 0 ? void 0 : Aa.horizontalAxes) !== null && xa !== void 0 ? xa : 1), De = Xe / Se, ba = W[S];
+              if (De <= y.trendTangens[ba] || S === W.length - 1) {
+                var se = G.to > G.from ? ce.growth[ba] : ce.reduction[ba];
+                return {
+                  type: Ye,
+                  priority: S,
+                  change: {
+                    from: G.from,
+                    to: G.to,
+                    strength: se
+                  },
+                  from: dr.from,
+                  to: dr.to,
+                  dataKey: dr.dataKey,
+                  label: dr.displayValue
+                };
+              }
+            }
+          }, Ge = ra({
+            type: "general-trend",
+            value: {
+              from: t[0],
+              to: t[t.length - 1]
+            },
+            width: l.length,
+            label: {
+              from: ga,
+              to: ha,
+              dataKey: n,
+              displayValue: e.titles.valuesAxes[n]
+            }
+          }), aa = [];
+          {
+            for (var ea, me = (ea = y.movingAverage.notableDiff) !== null && ea !== void 0 ? ea : U / 10, d = 0, Mr = t[d], pe = t[0] > E[0], p = 1; p < l.length; p++) {
+              var la, va, na, ye, ua, oa, ta, xe, Ae = t[p] > E[p], ze = Math.abs(t[p] - E[p]);
+              if (Ae !== pe && !(ze < me) && !(p === 0 && d === l.length - 1) && !(p === l.length - 1 && d === 0)) {
+                p = Math.min(p, l.length - 1);
+                var fa = l[d][F], ca = l[p][F], Ie = (la = (va = (na = (ye = e.titles).getHorizontalAxesTitle) === null || na === void 0 ? void 0 : na.call(ye, fa)) !== null && va !== void 0 ? va : e.titles.horizontalAxes[fa]) !== null && la !== void 0 ? la : fa, He = (ua = (oa = (ta = (xe = e.titles).getHorizontalAxesTitle) === null || ta === void 0 ? void 0 : ta.call(xe, ca)) !== null && oa !== void 0 ? oa : e.titles.horizontalAxes[ca]) !== null && ua !== void 0 ? ua : ca;
+                aa.push(ra({
+                  type: "trend",
+                  value: {
+                    from: Mr,
+                    to: t[p]
+                  },
+                  width: p - d,
+                  label: {
+                    from: Ie,
+                    to: He,
+                    dataKey: n,
+                    displayValue: e.titles.valuesAxes[n]
+                  }
+                })), d = p, Mr = t[d], pe = Ae;
+              }
+            }
+            if (d !== 0) {
+              var ma = t.length - 1, be = t[ma];
+              Math.abs(Mr - be) > me && aa.push(ra({
+                type: "trend",
+                value: {
+                  from: Mr,
+                  to: be
+                },
+                width: ma - d,
+                label: {
+                  from: l[d][F],
+                  to: l[ma][F],
+                  dataKey: n,
+                  displayValue: e.titles.valuesAxes[n]
+                }
+              }));
+            }
+          }
+          c.push(Ge), (A = c).push.apply(A, aa);
+        };
+        for (D.s(); !(ka = D.n()).done; )
+          he();
+      } catch (r) {
+        D.e(r);
+      } finally {
+        D.f();
+      }
+    } else if (f === "points-cloud") {
+      var wr, Br, N, Oa, ja = [].concat(o(e.fields.horizontalAxes.values()), ["x"])[0], Pa = [].concat(o(e.fields.verticalAxes.values()), ["y"])[0], Va = [].concat(o(e.fields.valueAxes.values()), ["value"])[0], ke = x.label ? "label" : Va, s = l.map(function(r) {
+        return {
+          x: r[ja],
+          y: r[Pa],
+          label: r[ke],
+          value: r[Va]
+        };
+      }), $ = (wr = (Br = y.clustersGridSize) !== null && Br !== void 0 ? Br : e.grid.verticalAxes) !== null && wr !== void 0 ? wr : e.grid.horizontalAxes;
+      if (!$) {
+        var qa = /* @__PURE__ */ new Set(), wa = /* @__PURE__ */ new Set(), _ = z(s), Ba;
+        try {
+          for (_.s(); !(Ba = _.n()).done; ) {
+            var Fa = Ba.value, Oe = Fa.x, je = Fa.y;
+            qa.add(Oe), wa.add(je);
+          }
+        } catch (r) {
+          _.e(r);
+        } finally {
+          _.f();
+        }
+        var Ea = o(qa).sort(function(r, a) {
+          return r - a;
+        }), La = o(wa).sort(function(r, a) {
+          return r - a;
+        }), Fr = Ea.slice(0, -1).map(function(r, a) {
+          return Ea[a + 1] - r;
+        }), Er = La.slice(0, -1).map(function(r, a) {
+          return La[a + 1] - r;
+        }), Ra = Fr.reduce(function(r, a) {
+          return r + a;
+        }, 0) / Fr.length, Ca = Er.reduce(function(r, a) {
+          return r + a;
+        }, 0) / Er.length, Ja = Fr.filter(function(r) {
+          return r < Ra;
+        }), Qa = Er.filter(function(r) {
+          return r < Ca;
+        }), rr = Ja.reduce(function(r, a) {
+          return r + a;
+        }, 0) / Ja.length, ar = Qa.reduce(function(r, a) {
+          return r + a;
+        }, 0) / Qa.length, I = 0;
+        !Number.isNaN(rr) && !Number.isNaN(ar) ? I = (rr + ar) / 2 : Number.isNaN(rr) ? Number.isNaN(ar) ? I = (Ra + Ca) / 2 : I = ar : I = rr, $ = Math.sqrt(Math.sqrt(I));
+      }
+      for (var m = {}, Ua = /* @__PURE__ */ new Set(), Wa = /* @__PURE__ */ new Set(), er = 0; er < s.length; er++) {
+        var Lr, Rr, Za = s[er], Ga = Za.x, za = Za.y, J = Math.round(Ga / $), lr = Math.round(za / $);
+        Ua.add(za), Wa.add(Ga), m[J] = (Lr = m[J]) !== null && Lr !== void 0 ? Lr : {}, m[J][lr] = (Rr = m[J][lr]) !== null && Rr !== void 0 ? Rr : {
+          clusterId: "".concat(J, "_").concat(lr),
+          members: []
+        }, m[J][lr].members.push(s[er]);
+      }
+      var i = {}, vr = z(Object.keys(m).map(function(r) {
+        return parseInt(r, 10);
+      })), Ia;
+      try {
+        for (vr.s(); !(Ia = vr.n()).done; ) {
+          var M = Ia.value, nr = z(Object.keys(m[M]).map(function(r) {
+            return parseInt(r, 10);
+          })), Ha;
+          try {
+            for (nr.s(); !(Ha = nr.n()).done; ) {
+              for (var Cr, Ka, g = Ha.value, Ya = !1, Jr = 0, Xa = [M - 1, M, M + 1]; Jr < Xa.length; Jr++) {
+                for (var ur = Xa[Jr], Qr = 0, Sa = [g - 1, g, g + 1]; Qr < Sa.length; Qr++) {
+                  var Ur, or = Sa[Qr];
+                  if (!(ur === void 0 || or === void 0) && !(ur === M && or === g) && (Ur = m[ur]) !== null && Ur !== void 0 && Ur[or]) {
+                    Ya = !0, m[M][g].clusterId = m[ur][or].clusterId;
+                    break;
+                  }
+                }
+                if (Ya) break;
+              }
+              i[m[M][g].clusterId] = (Cr = i[m[M][g].clusterId]) !== null && Cr !== void 0 ? Cr : [], (Ka = i[m[M][g].clusterId]).push.apply(Ka, o(m[M][g].members));
+            }
+          } catch (r) {
+            nr.e(r);
+          } finally {
+            nr.f();
+          }
+        }
+      } catch (r) {
+        vr.e(r);
+      } finally {
+        vr.f();
+      }
+      var j = [];
+      for (var Q in i) {
+        var Wr, Zr, Pe = i[Q].reduce(function(r, a) {
+          var v = a.value;
+          return r + (v ?? 1);
+        }, 0), Ve = o(i[Q]).sort(function(r, a) {
+          return a.value - r.value;
+        }).map(function(r) {
+          var a = r.label;
+          return a;
+        }).filter(function(r) {
+          return r !== void 0;
+        }), qe = o(new Set(Ve)), we = i[Q].reduce(function(r, a) {
+          var v = a.x;
+          return r + v;
+        }, 0) / i[Q].length, Be = i[Q].reduce(function(r, a) {
+          var v = a.y;
+          return r + v;
+        }, 0) / i[Q].length;
+        j.push({
+          type: "cluster",
+          priority: 1,
+          size: Pe,
+          labels: qe,
+          relativeSize: "average",
+          center: {
+            x: we,
+            y: Be,
+            xLabel: (Wr = e.axesTitle.horizontal) !== null && Wr !== void 0 ? Wr : ja,
+            yLabel: (Zr = e.axesTitle.vertical) !== null && Zr !== void 0 ? Zr : Pa
+          }
+        });
+      }
+      B = Object.keys(i).length, j.sort(function(r, a) {
+        return a.size - r.size;
+      });
+      var Da = (N = {}, L(N, "significantly-bigger", {
+        max: 1 / 0,
+        min: 0.85
+      }), L(N, "bigger", {
+        min: 0.7,
+        max: 0.85
+      }), L(N, "slightly-bigger", {
+        min: 0.6,
+        max: 0.7
+      }), L(N, "average", {
+        min: 0.4,
+        max: 0.6
+      }), L(N, "slightly-smaller", {
+        max: 0.4,
+        min: 0.3
+      }), L(N, "smaller", {
+        min: 0.15,
+        max: 0.3
+      }), L(N, "significantly-smaller", {
+        min: -1 / 0,
+        max: 0.15
+      }), N), tr = j.reduce(function(r, a) {
+        return r + a.size;
+      }, 0) / j.length, sa = j.filter(function(r) {
+        return r.size < tr;
+      }), Fe = sa.reduce(function(r, a) {
+        return r + a.size;
+      }, 0) / sa.length, $a = j.filter(function(r) {
+        return r.size > tr;
+      }), Ee = $a.reduce(function(r, a) {
+        return r + a.size;
+      }, 0) / $a.length, fr = tr * 2, cr = tr / fr, mr = Fe / fr, pr = Ee / fr;
+      mr = Number.isNaN(mr) ? 0.25 : mr, cr = Number.isNaN(cr) ? 0.5 : cr, pr = Number.isNaN(pr) ? 0.75 : pr;
+      for (var Le = _e([{
+        x: 0,
+        y: 0
+      }, {
+        x: 0.25,
+        y: mr,
+        weight: 10
+      }, {
+        x: 0.5,
+        y: cr
+      }, {
+        x: 0.75,
+        y: pr,
+        weight: 10
+      }, {
+        x: 1,
+        y: 1
+      }], {
+        width: 1,
+        height: 1
+      }), Gr = 0, _a = j; Gr < _a.length; Gr++) {
+        var re = _a[Gr], Re = re.size, ae = Le(Re / fr);
+        for (var ee in Da) {
+          var le = Da[ee], Ce = le.min, Je = le.max;
+          if (ae > Ce && ae <= Je) {
+            re.relativeSize = ee;
+            break;
+          }
+        }
+      }
+      if ((Oa = c).push.apply(Oa, j), e.axesTitle.horizontal) {
+        var zr = o(Wa).sort(function(r, a) {
+          return r - a;
+        });
+        C.push({
+          from: zr[0],
+          to: zr[zr.length - 1],
+          label: e.axesTitle.horizontal
+        });
+      }
+      if (e.axesTitle.vertical) {
+        var Ir = o(Ua).sort(function(r, a) {
+          return r - a;
+        });
+        C.push({
+          from: Ir[0],
+          to: Ir[Ir.length - 1],
+          label: e.axesTitle.vertical
+        });
+      }
+    } else if (f === "grouped-values") {
+      for (var ve, Qe = function(a) {
+        return w.map(function(v, A) {
+          return "".concat(A, "-").concat(R(a, v));
+        }).join("-");
+      }, Ue = l.map(Qe), yr = {}, xr = 0; xr < l.length; xr++) {
+        var Hr, Kr, Yr, ne, ue = l[xr], Xr = Ue[xr], oe = R(ue, w[0]);
+        yr[Xr] = (Hr = yr[Xr]) !== null && Hr !== void 0 ? Hr : {
+          groupName: (Kr = (Yr = (ne = e.titles).getHorizontalAxesTitle) === null || Yr === void 0 ? void 0 : Yr.call(ne, oe)) !== null && Kr !== void 0 ? Kr : oe,
+          rows: []
+        }, yr[Xr].rows.push(ue);
+      }
+      var H = o(e.fields.values), We = Object.fromEntries(w.map(function(r) {
+        return [r, !0];
+      }));
+      if (H.length === 0) {
+        var te;
+        (te = H).push.apply(te, o(Object.keys(x)));
+      }
+      H = H.filter(function(r) {
+        return !We[r];
+      });
+      var Sr = Object.entries(yr).map(function(r) {
+        var a, v = $e(r, 2), A = v[0], n = v[1], u = [], P = z(n.rows), br;
+        try {
+          for (P.s(); !(br = P.n()).done; ) {
+            var $r = br.value, U = z(H), W;
+            try {
+              for (U.s(); !(W = U.n()).done; ) {
+                var Z, K, Y, E, t = W.value;
+                u.push({
+                  label: (Z = (K = e.titles.valuesAxes[t]) !== null && K !== void 0 ? K : (Y = (E = e.titles).getVerticalAxesTitle) === null || Y === void 0 ? void 0 : Y.call(E, t)) !== null && Z !== void 0 ? Z : t,
+                  value: R($r, t)
+                });
+              }
+            } catch (b) {
+              U.e(b);
+            } finally {
+              U.f();
+            }
+          }
+        } catch (b) {
+          P.e(b);
+        } finally {
+          P.f();
+        }
+        u.sort(function(b, V) {
+          return typeof b.value != "number" || typeof V.value != "number" ? 0 : V.value - b.value;
+        });
+        var ir = u.reduce(function(b, V) {
+          var X = V.value;
+          return b + X;
+        }, 0) / u.length;
+        return {
+          label: (a = n.groupName) !== null && a !== void 0 ? a : A,
+          values: u,
+          averageValue: Number.isNaN(ir) ? void 0 : ir
+        };
+      });
+      Sr.sort(function(r, a) {
+        return typeof r.averageValue != "number" || typeof a.averageValue != "number" ? 0 : a.averageValue - r.averageValue;
+      }), B = Sr.length, (ve = c).push.apply(ve, o(Sr.map(function(r) {
+        return {
+          type: "comparison",
+          label: r.label,
+          values: r.values,
+          priority: 1
+        };
+      })));
+    }
+  }
+  if (f === "values-set") {
+    var Ar = o(e.fields.values);
+    Ar.length === 0 && Ar.push.apply(Ar, o(Object.keys(x)));
+    var Dr = Ar.map(function(r) {
+      var a, v, A, n;
+      return {
+        label: (a = (v = e.titles.valuesAxes[r]) !== null && v !== void 0 ? v : (A = (n = e.titles).getValueAxesTitle) === null || A === void 0 ? void 0 : A.call(n, r)) !== null && a !== void 0 ? a : r,
+        value: R(l, r)
+      };
+    });
+    B = Dr.length, Dr.sort(function(r, a) {
+      return typeof r.value != "number" || typeof a.value != "number" ? 0 : a.value - r.value;
+    }), c.push({
+      type: "comparison",
+      values: Dr,
+      priority: 1
+    });
+  }
+  if (f === "indexed-groups") {
+    var fe, sr = o(e.groups).map(function(r) {
+      var a, v = o(e.fields.values).filter(function(n) {
+        return String(n).startsWith("".concat(r, "."));
+      }).map(function(n) {
+        return {
+          label: R(e.titles.valuesAxes, String(n).substring(String(r).length + 1)),
+          value: R(l, String(n))
+        };
+      });
+      v.sort(function(n, u) {
+        return typeof n.value != "number" || typeof u.value != "number" ? 0 : u.value - n.value;
+      });
+      var A = v.reduce(function(n, u) {
+        var P = u.value;
+        return n + P;
+      }, 0) / v.length;
+      return {
+        label: (a = R(e.titles.valuesAxes, String(r))) !== null && a !== void 0 ? a : r,
+        values: v,
+        averageValue: Number.isNaN(A) ? void 0 : A
+      };
+    });
+    sr.sort(function(r, a) {
+      return typeof r.averageValue != "number" || typeof a.averageValue != "number" ? 0 : a.averageValue - r.averageValue;
+    }), B = sr.length, (fe = c).push.apply(fe, o(sr.map(function(r) {
+      return {
+        type: "comparison",
+        label: r.label,
+        values: r.values,
+        priority: 1
+      };
+    })));
+  }
+  var Ze = c.some(function(r) {
+    return r.priority > 0;
+  });
+  return Ze ? c = c.filter(function(r) {
+    return r.priority > 0;
+  }) : c = c.slice(0, 1), {
+    insights: c,
+    dataType: f,
+    dataRange: C,
+    dataTitle: Tr,
+    entitiesCount: B
+  };
+};
+export {
+  ul as extractDataInsights
+};

package/d3-chart/lib/esm/semcore/d3-chart/src/a11y/intl.mjs

@@ -0,0 +1,14 @@
+import { normalizeLocale as m } from "./locale.mjs";
+import { createIntl as o } from "../../../../node_modules/.pnpm/@formatjs_intl@2.3.0_typescript@5.1.6/node_modules/@formatjs/intl/lib/src/create-intl.mjs";
+import { createIntlCache as i } from "../../../../node_modules/.pnpm/@formatjs_intl@2.3.0_typescript@5.1.6/node_modules/@formatjs/intl/lib/src/utils.mjs";
+var s = i(), t = {}, g = function(e, a, n) {
+  var r;
+  return e = (r = m(e, n)) !== null && r !== void 0 ? r : "en", t[e] = o({
+    locale: e,
+    defaultLocale: "en",
+    messages: a || {}
+  }, s), t[e];
+};
+export {
+  g as getIntl
+};

package/d3-chart/lib/esm/semcore/d3-chart/src/a11y/locale.mjs

@@ -0,0 +1,26 @@
+import v from "@babel/runtime/helpers/esm/slicedToArray";
+var b = function(o) {
+  var r, i, e, l = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, n = {};
+  for (var t in l)
+    n[t.toLowerCase()] = t;
+  o = (r = (i = o) !== null && i !== void 0 ? i : d(globalThis == null || (e = globalThis.navigator) === null || e === void 0 ? void 0 : e.language, l)) !== null && r !== void 0 ? r : "en";
+  var a = o.toLowerCase();
+  if (a.includes("-") && !l[a]) {
+    var u = a.split("-"), g = v(u, 1), s = g[0];
+    l[s] && (a = s);
+  }
+  if (a = n[a] ? n[a] : a, !l[a]) {
+    var f = Object.keys(l).join(", ");
+    return process.env.NODE_ENV !== "production" && console.error('[Intergalactic @semcore/d3-charts a11y module]: No locale "'.concat(o, '" available. Available locales: ').concat(f)), null;
+  }
+  return a;
+}, d = function(o, r) {
+  if (typeof o == "string") {
+    var i = o.split("-"), e = v(i, 1), l = e[0];
+    if (r[l])
+      return l;
+  }
+};
+export {
+  b as normalizeLocale
+};