@graphysdk/viz-engine 0.0.1 → 1.8.1-beta.1786024899180

package/dist/config.types-uM8CYfC1.js

@@ -0,0 +1,1951 @@
+import { differenceInDays as Re, isBefore as Ce, isValid as f, isWithinInterval as Le, parse as N } from "date-fns";
+import { isEqual as Ie, isInteger as Ve } from "lodash-es";
+import { desc as xe, op as re, table as O } from "arquero";
+var vr = (e) => e.length > 0;
+function ae(e) {
+  return e != null;
+}
+function Mr(e) {
+  if (e === null || typeof e != "object") return !1;
+  const t = Object.getPrototypeOf(e);
+  return t === Object.prototype || t === null;
+}
+var ne = "\0graphy\0_", c = (e) => `${ne}${e}`, Be = { x: c("constantX") }, se = {
+  count: c("count"),
+  mean: c("mean")
+}, je = { group: c("group") }, Pe = {
+  x: c("x"),
+  y: c("y"),
+  xMin: c("xMin"),
+  xMax: c("xMax"),
+  yMin: c("yMin"),
+  yMax: c("yMax"),
+  yRaw: c("yRaw")
+}, Ue = { role: c("stackRole") }, $e = {
+  color: c("color"),
+  size: c("size"),
+  alpha: c("alpha"),
+  strokeWidth: c("strokeWidth"),
+  lineType: c("lineType")
+}, Ye = {
+  y: c("ruleY"),
+  x: c("ruleX")
+}, Er = {
+  ...Be,
+  ...se,
+  ...je,
+  ...Pe,
+  ...Ue,
+  ...$e,
+  ...Ye
+}, ze = new Set(Object.values(se)), _r = (e) => c(`scaled_${e}`), Tr = (e) => e.startsWith(ne), Ar = (e) => ze.has(e);
+function Fr(e) {
+  return {
+    type: "mapping",
+    mapping: e
+  };
+}
+function Dr(e) {
+  return ae(e) ? typeof e == "string" ? e : "variable" in e ? e.variable : null : null;
+}
+function Nr(e) {
+  if (!(!ae(e) || typeof e == "string") && "value" in e)
+    return e.value;
+}
+var G = (e) => e instanceof Date && f(e), wr = (e) => G(e) || e === null, Sr = (e) => typeof e == "string", We = (e) => typeof e == "number" && !Number.isNaN(e) && Number.isFinite(e), Or = (e) => We(e) || e === null, oe = (e) => (Array.isArray(e) ? e : [e]).map((t) => t instanceof Date ? t.toISOString() : String(t ?? "<null>")).join("\0"), kr = (e, t) => e === t ? !0 : G(e) && G(t) ? e.getTime() === t.getTime() : !1, D = process.env.NODE_ENV !== "production", j = !0, Rr = (e) => {
+  j = e;
+}, Cr = () => j, Lr = () => {
+  let e = null;
+  const t = {
+    hits: 0,
+    misses: 0
+  };
+  return Object.assign((a, n) => {
+    if (!j)
+      return D && (t.misses += 1), n();
+    if (e && ie(e.args, a))
+      return D && (t.hits += 1), e.out;
+    D && (t.misses += 1);
+    const s = n();
+    return e = {
+      args: a,
+      out: s
+    }, s;
+  }, {
+    stats: t,
+    reset: () => {
+      e = null;
+    }
+  });
+}, Ge = () => {
+  const e = /* @__PURE__ */ new WeakMap(), t = {
+    hits: 0,
+    misses: 0
+  };
+  return Object.assign((a, n, s) => {
+    if (!j)
+      return D && (t.misses += 1), s();
+    const o = e.get(a);
+    if (o) {
+      for (const l of o) if (ie(l.args, n))
+        return D && (t.hits += 1), l.out;
+    }
+    D && (t.misses += 1);
+    const i = s();
+    return o ? o.push({
+      args: n,
+      out: i
+    }) : e.set(a, [{
+      args: n,
+      out: i
+    }]), i;
+  }, { stats: t });
+}, Ir = (...e) => e.reduce((t, r) => ({
+  hits: t.hits + r.hits,
+  misses: t.misses + r.misses
+}), {
+  hits: 0,
+  misses: 0
+}), ie = (e, t) => {
+  if (e.length !== t.length) return !1;
+  for (let r = 0; r < e.length; r += 1) if (e[r] !== t[r]) return !1;
+  return !0;
+}, Ke = class {
+  constructor() {
+    this.memo = Ge(), this.singletonKey = {};
+  }
+  get stats() {
+    return this.memo.stats;
+  }
+  compile(e) {
+    return this.memo(this.key(e), this.dependencies(e), () => this.run(e));
+  }
+  key(e) {
+    return this.singletonKey;
+  }
+}, le = class extends Error {
+  constructor(e) {
+    super(e.message, e.cause !== void 0 ? { cause: e.cause } : void 0), this.name = new.target.name, this.code = e.code, this.context = e.context, this.suggestion = e.suggestion;
+  }
+}, B = class extends le {
+  constructor(e) {
+    super(e), this.kind = "user-input";
+  }
+}, v = class extends le {
+  constructor(e) {
+    super({
+      ...e,
+      code: e.code ?? "INTERNAL_INVARIANT"
+    }), this.kind = "internal";
+  }
+}, ue = (e) => e.type === "lookup", He = (e) => e.type === "text", P = (e) => e.type === "date" || e.type === "datetime" || e.type === "year" || e.type === "month_year" || e.type === "month" || e.type === "day_month" || e.type === "weekly_date_range" || e.type === "weekly_date_range_with_year" || e.type === "quarter" || e.type === "time", qe = (e) => e.type === "decimal" || e.type === "integer" || e.type === "percentage" || e.type === "duration" || e.type === "currency", Vr = (e) => e.type === "currency", xr = (e) => e.type === "month" || e.type === "day_month" || e.type === "weekly_date_range", ce = (e) => {
+  if (ue(e)) return ce(e.fallback);
+  if (P(e)) return "temporal";
+  if (qe(e)) return "numeric";
+  if (He(e)) return "categorical";
+  throw new v({ message: `No data type found for value format: ${e.type}` });
+}, Br = (e) => ue(e) ? e.fallback : e, Xe = {
+  k: 1e3,
+  m: 1e6,
+  b: 1e9,
+  t: 1e12
+}, q = [
+  "k",
+  "m",
+  "b",
+  "t"
+], Qe = new RegExp(`^-?(\\d{1,3}(,\\d{3})*|\\d+)\\.?\\d*(${q.join("|")})?$`, "i"), Je = /^-?\d{1,3}(?:,\d{3})*(?:\.\d+)?%?$/, T = (e) => e === null || e instanceof Date || Array.isArray(e) || typeof e == "boolean" ? !1 : typeof e == "string" ? Qe.test(e) && !Number.isNaN(Number(e.replace(new RegExp(`[,${q.join("")}]`, "gi"), ""))) : !Number.isNaN(Number(e)), de = (e) => T(e) ? !0 : typeof e == "string" ? Je.test(e) : !1, ye = {
+  $: "usd",
+  "£": "gbp",
+  "€": "eur",
+  "¥": "jpy",
+  "₹": "inr",
+  "₱": "php",
+  P: "php",
+  "₩": "krw",
+  "₪": "ils",
+  "₫": "vnd",
+  "₽": "rub",
+  "฿": "thb",
+  R$: "brl",
+  Rp: "idr",
+  RM: "myr",
+  "₦": "ngn",
+  zł: "pln",
+  "₺": "try",
+  kr: "dkk",
+  Fr: "chf",
+  R: "zar",
+  "د.إ": "aed",
+  "﷼": "sar",
+  Ch$: "clp",
+  NT$: "twd",
+  HK$: "hkd",
+  S$: "sgd",
+  A$: "aud",
+  C$: "cad",
+  NZ$: "nzd",
+  MX$: "mxn"
+}, fe = (e) => {
+  if (typeof e == "string") {
+    const t = me(e);
+    return t.length ? T(t) : !1;
+  }
+  return T(e);
+}, Ze = (e) => {
+  const t = pe(e), r = t ? ye[t] : void 0;
+  if (!r) throw new v({ message: "Could not get currency ISO" });
+  return r;
+}, me = (e) => {
+  const t = pe(e);
+  let r = e;
+  if (t) {
+    const a = e.indexOf(t);
+    a === 0 ? r = e.slice(t.length) : a === e.length - t.length ? r = e.slice(0, e.length - t.length) : e[0] === "-" && a === 1 && (r = `-${e.slice(t.length + 1)}`);
+  }
+  return T(r) ? r.split(",").join("") : "";
+}, pe = (e) => Object.keys(ye).sort((t, r) => r.length - t.length).find((t) => e.includes(t)), ge = (e) => {
+  const t = Object.entries(e);
+  return !t.length || !t.some(([, r]) => !C(r));
+}, C = (e) => typeof e == "string" && e.trim() === "" || e === void 0 || e === null || e === "-", be = "en-GB", et = class {
+  constructor() {
+    this.currentYear = (/* @__PURE__ */ new Date()).getUTCFullYear(), this.previousDate = null, this.previousYear = null;
+  }
+  incrementYearIfNeeded(e) {
+    this.previousYear === null ? this.previousYear = e.getUTCFullYear() : this.previousDate !== null && Ce(new Date(this.currentYear, e.getUTCMonth(), e.getUTCDate()), new Date(this.currentYear, this.previousDate.getUTCMonth(), this.previousDate.getUTCDate())) && this.previousYear++;
+    const t = new Date(e.getTime());
+    return t.setUTCFullYear(this.previousYear), this.previousDate = t, t;
+  }
+}, tt = /^\d{4}-\d{2}-\d{2}(T|\s)\d{1,2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|\+00:00)?$/, rt = /^\s*(19\d{2}|2[01]\d{2})\s*$/, at = [
+  [/\bJan\b/i, "January"],
+  [/\bFeb\b/i, "February"],
+  [/\bMar\b/i, "March"],
+  [/\bApr\b/i, "April"],
+  [/\bJun\b/i, "June"],
+  [/\bJul\b/i, "July"],
+  [/\bAug\b/i, "August"],
+  [/\bSept?\b/i, "September"],
+  [/\bOct\b/i, "October"],
+  [/\bNov\b/i, "November"],
+  [/\bDec\b/i, "December"]
+], nt = {
+  "en-US": "MDY",
+  "en-GB": "DMY",
+  "pt-PT": "DMY",
+  ar: "DMY"
+}, he = [
+  "/",
+  "-",
+  ".",
+  " "
+], X = [
+  [
+    "d",
+    "M",
+    "yy"
+  ],
+  [
+    "d",
+    "MM",
+    "yy"
+  ],
+  [
+    "d",
+    "MMMM",
+    "yy"
+  ],
+  [
+    "dd",
+    "M",
+    "yy"
+  ],
+  [
+    "dd",
+    "MM",
+    "yy"
+  ],
+  [
+    "dd",
+    "MMMM",
+    "yy"
+  ],
+  [
+    "do",
+    "MMMM",
+    "yy"
+  ],
+  [
+    "d",
+    "M",
+    "yyyy"
+  ],
+  [
+    "d",
+    "MM",
+    "yyyy"
+  ],
+  [
+    "d",
+    "MMMM",
+    "yyyy"
+  ],
+  [
+    "dd",
+    "M",
+    "yyyy"
+  ],
+  [
+    "dd",
+    "MM",
+    "yyyy"
+  ],
+  [
+    "dd",
+    "MMMM",
+    "yyyy"
+  ],
+  [
+    "do",
+    "MMMM",
+    "yyyy"
+  ]
+], Q = [
+  [
+    "M",
+    "d",
+    "yy"
+  ],
+  [
+    "M",
+    "dd",
+    "yy"
+  ],
+  [
+    "MM",
+    "d",
+    "yy"
+  ],
+  [
+    "MM",
+    "dd",
+    "yy"
+  ],
+  [
+    "MMMM",
+    "d",
+    "yy"
+  ],
+  [
+    "MMMM",
+    "dd",
+    "yy"
+  ],
+  [
+    "MMMM",
+    "do",
+    "yy"
+  ],
+  [
+    "M",
+    "d",
+    "yyyy"
+  ],
+  [
+    "M",
+    "dd",
+    "yyyy"
+  ],
+  [
+    "MM",
+    "d",
+    "yyyy"
+  ],
+  [
+    "MM",
+    "dd",
+    "yyyy"
+  ],
+  [
+    "MMMM",
+    "d",
+    "yyyy"
+  ],
+  [
+    "MMMM",
+    "dd",
+    "yyyy"
+  ],
+  [
+    "MMMM",
+    "do",
+    "yyyy"
+  ]
+], J = [
+  [
+    "yyyy",
+    "M",
+    "d"
+  ],
+  [
+    "yyyy",
+    "M",
+    "dd"
+  ],
+  [
+    "yyyy",
+    "MM",
+    "d"
+  ],
+  [
+    "yyyy",
+    "MM",
+    "dd"
+  ],
+  [
+    "yyyy",
+    "MMMM",
+    "d"
+  ],
+  [
+    "yyyy",
+    "MMMM",
+    "dd"
+  ],
+  [
+    "yyyy",
+    "MMMM",
+    "do"
+  ]
+], ve = [
+  ["d", "MMMM"],
+  ["dd", "MMMM"],
+  ["do", "MMMM"],
+  ["MMMM", "d"],
+  ["MMMM", "dd"],
+  ["MMMM", "do"]
+], st = [
+  {
+    dateFormat: "MMMM d, yyyy",
+    type: "date"
+  },
+  {
+    dateFormat: "MMMM dd, yyyy",
+    type: "date"
+  },
+  {
+    dateFormat: "MMMM do, yyyy",
+    type: "date"
+  },
+  {
+    dateFormat: "yyyy-MM",
+    type: "month_year"
+  }
+], Me = 1900, Ee = 2199, ot = 3, it = 6, lt = 5, ut = 1, ct = 28, dt = /\s*[–—]\s*|\s-\s/, yt = (e) => typeof e == "number" ? Number.isNaN(e) ? !1 : e >= Me && e <= Ee : typeof e == "string" ? rt.test(e) : !1, _e = (e, t) => {
+  const r = R(e);
+  return !t && T(r) ? pt(r) : typeof r == "string" ? t ? f(N(r, t, /* @__PURE__ */ new Date())) : !!Te(r) || U(r) && f(new Date(r)) : f(r);
+}, R = (e) => {
+  if (typeof e != "string") return e;
+  let t = e;
+  for (const [r, a] of at) t = t.replace(r, a);
+  return t;
+}, Te = (e, t = be) => {
+  const r = R(e);
+  return U(r) ? { type: "datetime" } : Ae(t).find((a) => !P(a) || a.type === "month" && r.length < ot ? !1 : a.dateFormat && f(N(r, a.dateFormat, /* @__PURE__ */ new Date())));
+}, U = (e) => tt.test(e.trim()), jr = (e) => {
+  if (e instanceof Date) return f(e) ? e : null;
+  if (typeof e != "string" || !U(e)) return null;
+  const t = new Date(e.trim());
+  return f(t) ? t : null;
+}, ft = (e, t = be) => {
+  const [r, a] = e.split(dt);
+  if (!r || !a) return;
+  const n = R(r).trim(), s = R(a).trim();
+  return mt(t).find((o) => {
+    if (!P(o) || !o.dateFormat) return !1;
+    const i = N(n, o.dateFormat, /* @__PURE__ */ new Date()), l = N(s, o.dateFormat, /* @__PURE__ */ new Date());
+    if (!f(i) || !f(l)) return !1;
+    const u = new et(), d = u.incrementYearIfNeeded(i), M = u.incrementYearIfNeeded(l), y = Re(M, d);
+    return Le(new Date(d.getFullYear(), ut, ct), {
+      start: d,
+      end: M
+    }) && y === lt ? !0 : y === it;
+  });
+}, Ae = (e) => {
+  const t = {
+    date: Fe(e),
+    year: [["yyyy"]],
+    day_month: ve,
+    month_year: [["MMMM", "yyyy"], ["yyyy", "MMMM"]],
+    month: [["MMMM"]],
+    quarter: [["QQQ", "yyyy"], ["yyyy", "QQQ"]]
+  };
+  return [...st, ...Object.entries(t).flatMap(([r, a]) => a.flatMap((n) => he.map((s) => ({
+    dateFormat: n.join(s),
+    type: r
+  }))))];
+}, Fe = (e) => nt[e] === "MDY" ? [
+  ...Q,
+  ...X,
+  ...J
+] : [
+  ...X,
+  ...Q,
+  ...J
+], mt = (e) => {
+  const t = {
+    weekly_date_range: ve,
+    weekly_date_range_with_year: Fe(e)
+  };
+  return Object.entries(t).flatMap(([r, a]) => a.flatMap((n) => he.map((s) => ({
+    dateFormat: n.join(s),
+    type: r
+  }))));
+}, pt = (e) => {
+  const t = Number(e);
+  if (!Ve(t)) return !1;
+  const r = new Date(t), a = /* @__PURE__ */ new Date(t * 1e3), n = (s) => f(s) && s.getFullYear() >= Me && s.getFullYear() <= Ee;
+  return n(r) || n(a);
+}, gt = /\s*[–—]\s*|\s-\s/, bt = (e, t, r) => {
+  if (C(e)) return null;
+  switch (t.type) {
+    case "decimal":
+    case "integer":
+    case "duration":
+      return Ne(e);
+    case "percentage":
+      return ht(e);
+    case "currency":
+      return vt(e);
+    case "datetime":
+    case "date":
+    case "year":
+    case "month_year":
+    case "month":
+    case "day_month":
+    case "quarter":
+    case "time":
+      return De(e, t.dateFormat, r);
+    case "weekly_date_range":
+    case "weekly_date_range_with_year":
+      return Mt(e, t.dateFormat, r);
+    case "text":
+      return Et(e);
+    case "lookup":
+      throw new v({ message: "Cannot parse: lookup value formats are produced by transforms, not raw input" });
+    default:
+      throw new v({ message: `Unhandled value format: ${t.type}` });
+  }
+}, De = (e, t, r) => {
+  if (e instanceof Date) return f(e) ? e : null;
+  const a = R(String(e).trim());
+  if (a.length === 0) return null;
+  const n = /* @__PURE__ */ new Date();
+  if (t) {
+    const o = N(a, t, n);
+    return f(o) ? Y(o) : null;
+  }
+  for (const o of Ae(r)) {
+    if (!P(o) || !o.dateFormat) continue;
+    const i = N(a, o.dateFormat, n);
+    if (f(i)) return Y(i);
+  }
+  const s = new Date(a);
+  return _e(s) ? U(a) ? s : Y(s) : null;
+}, Ne = (e) => {
+  if (typeof e == "number") return Number.isNaN(e) ? null : e;
+  if (typeof e != "string") return null;
+  let t = e.trim();
+  if (!T(t)) return null;
+  let r = 1;
+  for (const a of q) if (new RegExp(`${a}$`, "i").test(t)) {
+    r = Xe[a], t = t.slice(0, -1);
+    break;
+  }
+  return Number(t.split(",").join("")) * r;
+}, ht = (e) => {
+  if (typeof e == "number") return Number.isNaN(e) ? null : e;
+  if (typeof e != "string") return null;
+  const t = e.trim();
+  if (!de(t)) return null;
+  const r = Number(t.replace(/%/g, "").replace(/,/g, "")) / 100;
+  return Number.isNaN(r) ? null : r;
+}, vt = (e) => {
+  if (typeof e == "number") return Number.isNaN(e) ? null : e;
+  if (typeof e != "string") return null;
+  const t = e.trim();
+  return fe(t) ? Ne(me(t)) : null;
+}, Mt = (e, t, r) => {
+  const a = String(e).trim().split(gt), [n, s] = [a[0]?.trim(), a[1]?.trim()];
+  return !n || !s ? null : De(n, t, r);
+}, Et = (e) => String(e).trim(), Y = (e) => new Date(Date.UTC(e.getFullYear(), e.getMonth(), e.getDate(), e.getHours(), e.getMinutes(), e.getSeconds(), e.getMilliseconds())), _t = /* @__PURE__ */ new Set([
+  "count",
+  "sum",
+  "mean",
+  "median"
+]);
+function we(e, t) {
+  return _t.has(e) ? "numeric" : t;
+}
+var Tt = "value", Z = "\0__rowMaskIndex", k = {
+  numeric: { type: "decimal" },
+  categorical: { type: "text" },
+  temporal: { type: "datetime" }
+}, At = {
+  eq: (e, t) => e[t.__variableName] === t.__value,
+  neq: (e, t) => e[t.__variableName] !== t.__value,
+  gt: (e, t) => e[t.__variableName] > t.__value,
+  gte: (e, t) => e[t.__variableName] >= t.__value,
+  lt: (e, t) => e[t.__variableName] < t.__value,
+  lte: (e, t) => e[t.__variableName] <= t.__value
+}, Se = (e, t) => e === "count" ? { type: "integer" } : t, K = class g {
+  constructor(t = {}) {
+    const { table: r, variableMetadata: a } = this.parseVariableMap(t);
+    this.table = r, this.variableMetadata = a;
+  }
+  static fromTrusted(t, r) {
+    const a = Object.create(g.prototype);
+    return a.table = t, a.variableMetadata = r, a;
+  }
+  size() {
+    return this.table.numRows();
+  }
+  getVariableNames() {
+    return this.table.columnNames();
+  }
+  hasVariable(t) {
+    return this.table.column(t) !== void 0;
+  }
+  addVariable(t, r, a, n) {
+    const s = {
+      ...this.variableMetadata,
+      [t]: {
+        type: r,
+        valueFormat: this.resolveAddedVariableFormat(t, r, n)
+      }
+    }, o = this.normalizeRawValues(r, a), i = this.table.assign(O({ [t]: o }));
+    return g.fromTrusted(i, s);
+  }
+  addConstantVariable(t, r, a, n) {
+    const s = {
+      ...this.variableMetadata,
+      [t]: {
+        type: r,
+        valueFormat: this.resolveAddedVariableFormat(t, r, n),
+        constant: { value: a }
+      }
+    }, [o] = this.normalizeRawValues(r, [a]), i = this.table.assign(O({ [t]: Array(this.size()).fill(o) }));
+    return g.fromTrusted(i, s);
+  }
+  getConstant(t) {
+    return this.variableMetadata[t]?.constant;
+  }
+  deriveVariable(t, r, a, n) {
+    const s = Array.from({ length: this.size() }, (o, i) => a(this.table.object(i)));
+    return this.addVariable(t, r, s, n);
+  }
+  renameVariable(t, r) {
+    const a = this.variableMetadata[t];
+    if (!a) throw new v({ message: `Variable ${t} not defined` });
+    const n = this.table.rename({ [t]: r }), { [t]: s, ...o } = this.variableMetadata, i = {
+      ...o,
+      [r]: a
+    };
+    return g.fromTrusted(n, i);
+  }
+  selectVariables(...t) {
+    const r = this.table.select(...t), a = Object.fromEntries(Object.entries(this.variableMetadata).filter(([n]) => t.includes(n)));
+    return g.fromTrusted(r, a);
+  }
+  getType(t) {
+    const r = this.variableMetadata[t];
+    if (!r) throw new v({ message: `Variable ${t} not defined` });
+    return r.type;
+  }
+  getValueFormat(t) {
+    const r = this.variableMetadata[t];
+    if (!r) throw new v({ message: `Variable ${t} not defined` });
+    return r.valueFormat;
+  }
+  groupVariableNamesByType() {
+    const t = {
+      numeric: [],
+      categorical: [],
+      temporal: []
+    };
+    for (const [r, { type: a }] of Object.entries(this.variableMetadata)) t[a].push(r);
+    return t;
+  }
+  getValues(t, r) {
+    if (!this.hasVariable(t)) throw new v({ message: `Variable '${t}' not defined` });
+    const a = this.getType(t);
+    if (r?.type !== void 0 && a !== r.type) throw new v({ message: `Variable '${t}' has type '${a}', expected '${r.type}'` });
+    let n = this.table.array(t);
+    return r?.distinct && (n = this.getDistinctValues(a, n)), r?.skipNulls && (n = this.skipNulls(n)), n;
+  }
+  filter(t, r, a) {
+    const n = At[r], s = this.table.params({
+      __variableName: t,
+      __value: a
+    }).filter(n);
+    return g.fromTrusted(s, this.variableMetadata);
+  }
+  filterByMask(t) {
+    if (t.length !== this.size()) throw new v({ message: `Row mask length ${t.length} does not match dataset size ${this.size()}` });
+    const r = Array.from({ length: t.length }, (n, s) => s), a = this.table.assign(O({ [Z]: r })).params({
+      __indexColumnName: Z,
+      __mask: t
+    }).filter((n, s) => s.__mask[n[s.__indexColumnName]] === 1).select(...this.table.columnNames());
+    return g.fromTrusted(a, this.variableMetadata);
+  }
+  orderBy(t, r = "asc") {
+    const a = this.table.orderby(r === "asc" ? t : xe(t));
+    return g.fromTrusted(a, this.variableMetadata);
+  }
+  getAt(t) {
+    return t < 0 || t >= this.size() ? null : this.table.object(t);
+  }
+  getFirst() {
+    return this.getAt(0);
+  }
+  getLast() {
+    return this.getAt(this.size() - 1);
+  }
+  findLast(t) {
+    for (let r = this.size() - 1; r >= 0; r--) {
+      const a = this.table.object(r);
+      if (t(a)) return a;
+    }
+    return null;
+  }
+  groupBy(...t) {
+    const r = this.table.groupby(...t);
+    return new Ft(t, r, this.variableMetadata);
+  }
+  rollup(t) {
+    const r = this.table.rollup(Object.fromEntries(Object.entries(t).map(([n, s]) => [n, re[s.aggregation](s.variableName)]))), a = {};
+    for (const [n, { variableName: s, aggregation: o }] of Object.entries(t)) {
+      const i = this.variableMetadata[s], l = i?.type ?? "numeric", u = i?.valueFormat ?? k[l];
+      a[n] = {
+        type: we(o, l),
+        valueFormat: Se(o, u)
+      };
+    }
+    return g.fromTrusted(r, a);
+  }
+  reshapeFromWideToLong({ keep: t, reshape: r, keyName: a = "key", valueName: n = Tt } = {}) {
+    const { numeric: s, categorical: o, temporal: i } = this.groupVariableNamesByType(), l = t ?? [...o, ...i], u = r ?? s.filter((y) => !l.includes(y));
+    if (l.includes(a) || l.includes(n)) throw new B({
+      code: "INVALID_DATA_SHAPE",
+      message: `The variables to keep includes the variables '${a}' or '${n}' to create the key and value variables`
+    });
+    if (u.length === 0) {
+      const y = {};
+      for (const w of l) {
+        const $ = this.variableMetadata[w];
+        $ && (y[w] = {
+          type: $.type,
+          values: [],
+          valueFormat: $.valueFormat
+        });
+      }
+      return y[a] = {
+        type: "categorical",
+        values: [],
+        valueFormat: { type: "text" }
+      }, y[n] = {
+        type: "numeric",
+        values: [],
+        valueFormat: { type: "decimal" }
+      }, new g(y);
+    }
+    if (u.filter((y) => this.variableMetadata[y]?.type !== "numeric").length > 0) throw new B({
+      code: "INVALID_DATA_SHAPE",
+      message: "Only numeric variables can be reshaped"
+    });
+    const d = this.table.select([...l, ...u]).fold(u, { as: [a, n] }), M = {};
+    for (const y of l) {
+      const w = this.variableMetadata[y];
+      w && (M[y] = w);
+    }
+    return M[a] = {
+      type: "categorical",
+      valueFormat: { type: "text" }
+    }, M[n] = {
+      type: "numeric",
+      valueFormat: Dt(this.variableMetadata, u, a)
+    }, g.fromTrusted(d, M);
+  }
+  print() {
+    console.table(this.variableMetadata), this.table.print();
+  }
+  [Symbol.iterator]() {
+    return this.table[Symbol.iterator]();
+  }
+  resolveAddedVariableFormat(t, r, a) {
+    if (a !== void 0) return a;
+    const n = this.variableMetadata[t];
+    return n ? n.valueFormat : k[r];
+  }
+  parseVariableMap(t) {
+    const r = {}, a = {};
+    for (const [n, { type: s, values: o, valueFormat: i }] of Object.entries(t))
+      r[n] = o, a[n] = {
+        type: s,
+        valueFormat: i ?? k[s]
+      };
+    return {
+      table: O(r),
+      variableMetadata: a
+    };
+  }
+  normalizeRawValues(t, r) {
+    switch (t) {
+      case "numeric":
+        return r.map((a) => typeof a != "number" || Number.isNaN(a) ? null : a);
+      case "categorical":
+        return r.map((a) => typeof a != "string" ? null : a);
+      case "temporal":
+        return r.map((a) => !(a instanceof Date) || !f(a) ? null : a);
+      default:
+        throw new v({ message: `Cannot normalize raw value of unknown type: ${t}` });
+    }
+  }
+  skipNulls(t) {
+    return t.filter((r) => r !== null);
+  }
+  getDistinctValues(t, r) {
+    const a = t === "temporal", n = /* @__PURE__ */ new Set(), s = [];
+    for (const o of r) {
+      const i = a && o instanceof Date ? o.getTime() : o;
+      n.has(i) || (n.add(i), s.push(o));
+    }
+    return s;
+  }
+}, Ft = class {
+  constructor(e, t, r) {
+    this.groupedBy = e, this.grouped = t, this.variableMetadata = r;
+  }
+  forEach(e) {
+    const t = this.grouped.partitions(), r = this.grouped.columnNames(), a = this.groupedBy.map((s) => this.grouped.column(s)).filter((s) => s !== void 0);
+    let n = 0;
+    for (const s of t) {
+      const o = s[0];
+      if (o === void 0) continue;
+      const i = this.getStableKey(a, o), l = O(Object.fromEntries(r.map((u) => {
+        const d = this.grouped.column(u);
+        return [u, s.map((M) => d?.get(M))];
+      })));
+      e(K.fromTrusted(l, this.variableMetadata), i, n++);
+    }
+  }
+  rollup(e) {
+    const t = this.grouped.rollup(Object.fromEntries(Object.entries(e).map(([a, n]) => [a, re[n.aggregation](n.variableName)]))), r = Object.fromEntries(this.groupedBy.map((a) => {
+      const n = this.variableMetadata[a], s = n?.type ?? "categorical";
+      return [a, {
+        type: s,
+        valueFormat: n?.valueFormat ?? k[s]
+      }];
+    }));
+    for (const [a, { variableName: n, aggregation: s }] of Object.entries(e)) {
+      const o = this.variableMetadata[n], i = o?.type ?? "numeric", l = o?.valueFormat ?? k[i];
+      r[a] = {
+        type: we(s, i),
+        valueFormat: Se(s, l)
+      };
+    }
+    return K.fromTrusted(t, r);
+  }
+  getStableKey(e, t) {
+    return oe(e.map((r) => r.get(t)));
+  }
+};
+function Dt(e, t, r) {
+  const a = t.map((i) => e[i]?.valueFormat ?? { type: "decimal" }), [n, ...s] = a;
+  if (!n) return { type: "decimal" };
+  for (const i of a) if (i.type === "lookup") throw new B({
+    code: "INVALID_DATA_SHAPE",
+    message: "Cannot reshape: a source column has a lookup format and lookups cannot nest"
+  });
+  if (s.every((i) => Ie(i, n)) || n.type === "lookup") return n;
+  const o = {};
+  for (const [i, l] of t.entries()) {
+    const u = oe([l]), d = a[i];
+    d && d.type !== "lookup" && (o[u] = d);
+  }
+  return {
+    type: "lookup",
+    byVariable: r,
+    cases: o,
+    fallback: n
+  };
+}
+var Nt = class {
+  constructor(e) {
+    this.label = e, this.items = /* @__PURE__ */ new Map();
+  }
+  register(e, t) {
+    return this.items.set(e, t), this;
+  }
+  get(e) {
+    if (!this.items.has(e)) {
+      const t = [...this.items.keys()].map((r) => `'${r}'`).join(", ");
+      throw new B({
+        code: "UNKNOWN_REGISTERED_TYPE",
+        message: `Unknown ${this.label}: '${e}' (available: ${t})`,
+        context: {
+          kind: this.label,
+          requested: e,
+          available: [...this.items.keys()]
+        },
+        suggestion: `Register a custom ${this.label} named '${e}' in the \`plugins\` array, or use one of: ${t}.`
+      });
+    }
+    return this.items.get(e);
+  }
+  getAll() {
+    return [...this.items.values()];
+  }
+  has(e) {
+    return this.items.has(e);
+  }
+}, wt = (e, t) => {
+  const r = typeof e == "string" ? e.trim() : e;
+  if (T(r)) return { type: "decimal" };
+  const a = typeof r == "string" && Te(r, t);
+  if (a) return a;
+  const n = typeof r == "string" && ft(r, t);
+  return n || (_e(e) ? { type: "date" } : de(e) ? { type: "percentage" } : fe(e) && typeof e == "string" ? {
+    type: "currency",
+    iso: Ze(e)
+  } : { type: "text" });
+}, St = {
+  type: "year",
+  dateFormat: "yyyy"
+}, Ot = (e) => {
+  const t = e._metadata?.parsingLocale ?? "en-GB", r = {}, a = Ct(e), n = kt(e);
+  for (const [s, o] of e.columns.entries()) {
+    if (o._metadata?.isHidden) continue;
+    const i = a.get(o.key);
+    if (C(i)) continue;
+    const l = s === n ? St : wt(i, t), u = ce(l);
+    r[o.key] = Rt(o.key, e.rows, l, u, t);
+  }
+  return new K(r);
+}, Pr = class extends Ke {
+  dependencies(e) {
+    return [e];
+  }
+  run(e) {
+    return Ot(e);
+  }
+}, kt = (e) => {
+  const t = Lt(e.rows, 5);
+  return e.columns.findIndex((r) => {
+    const a = t.map((n) => n[r.key]).filter((n) => !C(n));
+    return a.length >= 2 && a.every(yt);
+  });
+}, Rt = (e, t, r, a, n) => ({
+  type: a,
+  values: t.reduce((s, o) => (ge(o) || s.push(bt(o[e], r, n)), s), []),
+  valueFormat: r
+}), Ct = (e) => {
+  const t = /* @__PURE__ */ new Map(), r = new Set(e.columns.map((a) => a.key));
+  for (const a of e.rows) {
+    for (const n of r) {
+      const s = a[n];
+      C(s) || (t.set(n, s), r.delete(n));
+    }
+    if (r.size === 0) break;
+  }
+  return t;
+}, Lt = (e, t) => {
+  const r = [];
+  for (const a of e)
+    if (ge(a) || r.push(a), r.length === t) return r;
+  return r;
+}, It = class {
+  constructor() {
+    this.transformType = "aggregate";
+  }
+  apply(e, t) {
+    const { options: r } = t, a = {};
+    for (const n of r.operations) a[n.as] = {
+      variableName: n.variableName,
+      aggregation: n.op
+    };
+    return e.groupBy(...r.groupby).rollup(a);
+  }
+}, Vt = class {
+  constructor() {
+    this.transformType = "constant";
+  }
+  apply(e, t) {
+    const { options: r } = t;
+    return e.addConstantVariable(r.variableName, r.type, r.value);
+  }
+  getIntroducedVariables(e) {
+    const { options: t } = e;
+    return [t.variableName];
+  }
+}, xt = class {
+  constructor() {
+    this.transformType = "filter";
+  }
+  apply(e, t) {
+    const { options: r } = t;
+    return e.filter(r.variableName, r.operator, r.value);
+  }
+}, Bt = class {
+  constructor() {
+    this.transformType = "reshape";
+  }
+  apply(e, t) {
+    const { options: r } = t;
+    return e.reshapeFromWideToLong({
+      keep: r.keep,
+      reshape: r.reshape,
+      keyName: r.keyName,
+      valueName: r.valueName
+    });
+  }
+  getIntroducedVariables(e) {
+    const { options: t } = e;
+    return [t.keyName ?? "key"];
+  }
+}, jt = class {
+  constructor() {
+    this.transformType = "sort";
+  }
+  apply(e, t) {
+    const { options: r } = t;
+    return e.orderBy(r.variableName, r.direction ?? "asc");
+  }
+}, Pt = [
+  new It(),
+  new Vt(),
+  new xt(),
+  new Bt(),
+  new jt()
+], Ur = class extends Nt {
+  constructor() {
+    super("transform");
+    for (const e of Pt) this.register(e.transformType, e);
+  }
+}, $r = [
+  "grey",
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "cyan",
+  "blue",
+  "purple",
+  "pink"
+], Yr = [
+  "cyan",
+  "pink",
+  "purple",
+  "red",
+  "orange",
+  "yellow",
+  "green",
+  "blue"
+], Oe = [
+  "#B399FE",
+  "#FC7E91",
+  "#33B6E0",
+  "#FFC849",
+  "#25CDA5",
+  "#FA9B65",
+  "#D93C95",
+  "#845FD8",
+  "#3F8EEB",
+  "#58C8D8",
+  "#F35074",
+  "#6EA0DA"
+], b = {
+  red: "#E83562",
+  orange: "#F38650",
+  yellow: "#FBBC30",
+  green: "#31FCB4",
+  cyan: "#40F8FF",
+  blue: "#279EFF",
+  purple: "#B399FD",
+  dark_purple: "#6D48D2",
+  plum: "#C82184",
+  pink: "#FC8497"
+}, zr = [b.purple, b.dark_purple], Ut = [
+  b.purple,
+  b.pink,
+  b.yellow,
+  b.blue,
+  b.red,
+  b.cyan,
+  b.orange,
+  b.plum,
+  b.green,
+  b.dark_purple
+], h = {
+  green: "#B2DDC9",
+  cyan: "#A2D5E2",
+  blue: "#AAC4FF",
+  purple: "#B2A4FF",
+  plum: "#DCA8C7",
+  pink: "#FFCCD3",
+  red: "#FFADAD",
+  orange: "#FFDEB4",
+  yellow: "#FDF7C3"
+}, $t = [
+  h.green,
+  h.purple,
+  h.red,
+  h.cyan,
+  h.pink,
+  h.blue,
+  h.orange,
+  h.plum,
+  h.yellow
+], H = {
+  grey900: "#1c1917",
+  grey800: "#292524",
+  grey700: "#44403c",
+  grey600: "#57534e",
+  grey500: "#78716c",
+  grey400: "#a8a29e",
+  grey300: "#d6d3d1",
+  grey200: "#e7e5e4",
+  grey100: "#f5f5f4",
+  grey50: "#fafaf9",
+  red900: "#7f1d1d",
+  red800: "#991b1b",
+  red700: "#b91c1c",
+  red600: "#dc2626",
+  red500: "#ef4444",
+  red400: "#f87171",
+  red300: "#fca5a5",
+  red200: "#fecaca",
+  red100: "#fee2e2",
+  red50: "#fef2f2",
+  orange900: "#7c2d12",
+  orange800: "#9a3412",
+  orange700: "#c2410c",
+  orange600: "#ea580c",
+  orange500: "#f97316",
+  orange400: "#fb923c",
+  orange300: "#fdba74",
+  orange200: "#fed7aa",
+  orange100: "#ffedd5",
+  orange50: "#fff7ed",
+  yellow900: "#553B0C",
+  yellow800: "#6F4B08",
+  yellow700: "#8D6300",
+  yellow600: "#BD8A00",
+  yellow500: "#E5B400",
+  yellow400: "#FFC800",
+  yellow300: "#FBDA2B",
+  yellow200: "#FEED72",
+  yellow100: "#FEF8B4",
+  yellow50: "#FEFCE2",
+  green900: "#064e3b",
+  green800: "#065f46",
+  green700: "#047857",
+  green600: "#059669",
+  green500: "#10b981",
+  green400: "#34d399",
+  green300: "#6ee7b7",
+  green200: "#a7f3d0",
+  green100: "#d1fae5",
+  green50: "#ecfdf5",
+  cyan900: "#164e63",
+  cyan800: "#155e75",
+  cyan700: "#0e7490",
+  cyan600: "#0891B2",
+  cyan500: "#06b6d4",
+  cyan400: "#22d3ee",
+  cyan300: "#67e8f9",
+  cyan200: "#a5f3fc",
+  cyan100: "#cffafe",
+  cyan50: "#ecfeff",
+  blue900: "#1e3a8a",
+  blue800: "#1e40af",
+  blue700: "#1d4ed8",
+  blue600: "#2563eb",
+  blue500: "#3b82f6",
+  blue400: "#60a5fa",
+  blue300: "#93c5fd",
+  blue200: "#bfdbfe",
+  blue100: "#dbeafe",
+  blue50: "#eff6ff",
+  purple900: "#4c1d95",
+  purple800: "#5b21b6",
+  purple700: "#6d28d9",
+  purple600: "#7c3aed",
+  purple500: "#8b5cf6",
+  purple400: "#a78bfa",
+  purple300: "#c4b5fd",
+  purple200: "#ddd6fe",
+  purple100: "#ede9fe",
+  purple50: "#f5f3ff",
+  pink900: "#751A5E",
+  pink800: "#8F1972",
+  pink700: "#AF1C8A",
+  pink600: "#D326A8",
+  pink500: "#E845BF",
+  pink400: "#F979D9",
+  pink300: "#FCABE8",
+  pink200: "#FED0F3",
+  pink100: "#FFE8F9",
+  pink50: "#FFF4FC"
+}, Yt = [
+  H.grey200,
+  h.green,
+  h.red,
+  H.grey200
+], ee = {
+  dark: {
+    1: [500],
+    2: [600, 400],
+    3: [
+      600,
+      400,
+      200
+    ],
+    4: [
+      600,
+      500,
+      300,
+      100
+    ],
+    5: [
+      700,
+      600,
+      400,
+      200,
+      50
+    ],
+    6: [
+      600,
+      500,
+      400,
+      300,
+      200,
+      100
+    ],
+    7: [
+      600,
+      500,
+      400,
+      300,
+      200,
+      100,
+      50
+    ],
+    default: [
+      700,
+      600,
+      500,
+      400,
+      300,
+      200,
+      100,
+      50
+    ]
+  },
+  light: {
+    1: [600],
+    2: [700, 500],
+    3: [
+      800,
+      600,
+      400
+    ],
+    4: [
+      800,
+      600,
+      400,
+      300
+    ],
+    5: [
+      800,
+      700,
+      600,
+      500,
+      400
+    ],
+    6: [
+      800,
+      700,
+      600,
+      500,
+      400,
+      300
+    ],
+    7: [
+      900,
+      800,
+      700,
+      600,
+      500,
+      400,
+      300
+    ],
+    default: [
+      900,
+      800,
+      700,
+      600,
+      500,
+      400,
+      300,
+      200
+    ]
+  }
+}, p = {
+  cyan: "#22D3EE",
+  pink: "#F377EF",
+  purple: "#6528F7",
+  red: "#FB2576",
+  orange: "#FF9300",
+  yellow: "#FBFF00",
+  green: "#06FF00",
+  blue: "#0079FF"
+}, I = [
+  p.cyan,
+  p.pink,
+  p.purple,
+  p.red,
+  p.orange,
+  p.yellow,
+  p.green,
+  p.blue
+], zt = [
+  p.cyan,
+  p.green,
+  p.red,
+  p.cyan
+], V = {
+  start: "#84D1FC",
+  positive: "#84FC89",
+  negative: "#FC8497",
+  total: "#84D1FC"
+}, Wt = [
+  V.start,
+  V.positive,
+  V.negative,
+  V.total
+], Wr = {
+  transform: "linear",
+  reverse: !1,
+  nice: !0,
+  zero: !1,
+  domainMin: null,
+  domainMax: null,
+  range: null,
+  scheme: null,
+  interpolate: "lab",
+  domainMid: null,
+  symmetric: !1
+}, Gr = {
+  size: [4, 20],
+  alpha: [0.1, 1],
+  strokeWidth: [1, 4]
+}, Kr = {
+  domainMin: null,
+  domainMax: null,
+  nice: !1,
+  reverse: !1
+}, Hr = {
+  range: null,
+  domain: null,
+  padding: 0.1,
+  reverse: !1
+}, te = { palette: { type: "default" } };
+function Gt(e, t = "light", r) {
+  return ((r !== void 0 ? ee[t][r] : void 0) ?? ee[t].default).map((a) => H[`${e}${a}`]);
+}
+function Kt(e) {
+  const t = I.indexOf(p[e]);
+  return t <= 0 ? I : [...I.slice(t), ...I.slice(0, t)];
+}
+function qr(e, t) {
+  switch (e.type) {
+    case "default":
+      return Oe;
+    case "graphy":
+      return e.variant === "waterfall" ? Wt : Ut;
+    case "pastel":
+      return e.variant === "waterfall" ? Yt : $t;
+    case "neon":
+      return e.variant === "waterfall" ? zt : Kt(e.base);
+    case "mono":
+      return Gt(e.base, e.variant ?? "light", t);
+    case "custom":
+      return e.colors;
+  }
+}
+function Xr(e, t) {
+  if (!t) return e;
+  const r = [...e];
+  for (const [a, n] of Object.entries(t)) {
+    const s = Number(a);
+    if (!Number.isInteger(s) || s < 1) continue;
+    const o = s - 1;
+    o < r.length && (r[o] = n);
+  }
+  return r;
+}
+function Qr(e, t, r, a) {
+  if (!t) return;
+  const n = r?.type === "custom" ? a[r.id] : void 0, s = {};
+  for (const [o, i] of Object.entries(t)) {
+    const l = Number(o);
+    if (!(!Number.isInteger(l) || l < 1)) {
+      if (i.hex !== void 0) {
+        s[l] = i.hex;
+        continue;
+      }
+      if (i.id !== void 0) {
+        const u = n?.find((d) => d.id === i.id)?.hex;
+        u !== void 0 ? s[l] = u : e.diagnostics.addWarning({
+          code: "PALETTE_NOT_FOUND",
+          message: `Palette override at slot ${l} with id '${i.id}' did not resolve against the active palette — falling back to palette color.`,
+          context: {
+            requested: i.id,
+            available: n?.map((d) => d.id) ?? []
+          },
+          suggestion: "Define the override id in the active custom palette, or use a hex value instead."
+        });
+      }
+    }
+  }
+  return Object.keys(s).length > 0 ? s : void 0;
+}
+function Jr(e, t, r) {
+  if (!t) return te.palette;
+  if (t.type === "custom") {
+    const a = r[t.id];
+    if (!a)
+      return e.diagnostics.addWarning({
+        code: "PALETTE_NOT_FOUND",
+        message: `Custom palette with id "${t.id}" not found — falling back to the default palette.`,
+        context: {
+          requested: t.id,
+          available: Object.keys(r)
+        },
+        suggestion: "Register the palette in customPalettes, or reference an existing palette id."
+      }), te.palette;
+    const n = a.map((s) => s.hex);
+    return {
+      type: "custom",
+      id: t.id,
+      colors: n
+    };
+  }
+  return t;
+}
+function m(e, t = {}) {
+  const r = t;
+  return {
+    type: "scale",
+    scaledAesthetic: e,
+    scaleType: "continuous",
+    transform: t.transform,
+    reverse: t.reverse,
+    nice: t.nice,
+    zero: t.zero,
+    clamp: t.clamp,
+    domainMin: t.domainMin ?? null,
+    domainMax: t.domainMax ?? null,
+    range: t.range,
+    scheme: r.scheme ?? null,
+    interpolate: r.interpolate,
+    domainMid: r.domainMid ?? null,
+    symmetric: r.symmetric
+  };
+}
+function z(e, t = {}) {
+  return {
+    type: "scale",
+    scaledAesthetic: e,
+    scaleType: "datetime",
+    domainMin: t.domainMin ?? null,
+    domainMax: t.domainMax ?? null,
+    nice: t.nice,
+    reverse: t.reverse,
+    clamp: t.clamp
+  };
+}
+function _(e, t = {}) {
+  return {
+    type: "scale",
+    scaledAesthetic: e,
+    scaleType: "discrete",
+    range: t.range,
+    domain: t.domain ?? null,
+    padding: t.padding,
+    reverse: t.reverse
+  };
+}
+function x(e, t = {}) {
+  return {
+    type: "scale",
+    scaledAesthetic: e,
+    scaleType: "identity"
+  };
+}
+function W(e, t) {
+  return {
+    type: "scale",
+    scaledAesthetic: e,
+    scaleType: "inferred",
+    options: t
+  };
+}
+function Ht(e, t = {}) {
+  return {
+    type: "scale",
+    scaledAesthetic: e,
+    scaleType: "palette",
+    palette: t.palette,
+    overrides: t.overrides
+  };
+}
+var qt = [
+  "none",
+  "xs",
+  "sm",
+  "md",
+  "lg",
+  "xl",
+  "full"
+], Zr = {
+  point: Xt,
+  line: Qt,
+  area: Jt,
+  bar: Zt,
+  rule: er
+}, ea = (e) => typeof e == "string" && qt.includes(e);
+function L(e, t) {
+  return {
+    type: "layer",
+    id: t.id,
+    geom: e,
+    mapping: t.aes,
+    stat: t.stat,
+    params: t.params,
+    position: t.position,
+    yScaleType: t.yScaleType,
+    transforms: t.transforms,
+    interactive: t.interactive,
+    dataLabels: t.dataLabels
+  };
+}
+function Xt(e = {}) {
+  return L("point", e);
+}
+function Qt(e = {}) {
+  return L("line", e);
+}
+function Jt(e = {}) {
+  return L("area", e);
+}
+function Zt(e = {}) {
+  return L("bar", e);
+}
+function er(e = {}) {
+  return L("rule", e);
+}
+var ta = ["dimmed", "hovered"], ra = (e) => typeof e == "object" && e !== null && typeof e.light == "string" && typeof e.dark == "string", aa = (e) => typeof e == "object" && e !== null && typeof e.token == "string";
+function na(e) {
+  return {
+    type: "styles",
+    ...e
+  };
+}
+function S(e) {
+  return { token: e };
+}
+var A = (e) => {
+  const t = {
+    ...e?.where === void 0 ? {} : { where: e.where },
+    ...e?.state === void 0 ? {} : { state: e.state }
+  };
+  return {
+    ...e?.id === void 0 ? {} : { id: e.id },
+    ...Object.keys(t).length === 0 ? {} : { when: t }
+  };
+}, F = (e) => e?.layer === void 0 ? {} : { layer: e.layer }, E = { geom: Object.assign((e, t) => ({
+  ...A(t),
+  select: {
+    target: "geom",
+    ...F(t)
+  },
+  declarations: e
+}), {
+  bar: (e, t) => ({
+    ...A(t),
+    select: {
+      target: "geom",
+      kind: "bar",
+      ...F(t)
+    },
+    declarations: e
+  }),
+  line: (e, t) => ({
+    ...A(t),
+    select: {
+      target: "geom",
+      kind: "line",
+      ...F(t)
+    },
+    declarations: e
+  }),
+  area: (e, t) => ({
+    ...A(t),
+    select: {
+      target: "geom",
+      kind: "area",
+      ...F(t)
+    },
+    declarations: e
+  }),
+  point: (e, t) => ({
+    ...A(t),
+    select: {
+      target: "geom",
+      kind: "point",
+      ...F(t)
+    },
+    declarations: e
+  }),
+  rule: (e, t) => ({
+    ...A(t),
+    select: {
+      target: "geom",
+      kind: "rule",
+      ...F(t)
+    },
+    declarations: e
+  })
+}) }, tr = Oe[0], rr = Object.freeze({
+  light: "#1D2129",
+  dark: "#FFFFFF"
+}), ar = "#ffffff", nr = 0.4, sr = {
+  geomColor: tr,
+  ruleColor: rr,
+  pointBorderColor: "#ffffff",
+  hoverAffordanceColor: ar
+}, ke = [
+  E.geom({
+    color: S("geomColor"),
+    alpha: 1
+  }),
+  E.geom.bar({
+    borderRadius: "sm",
+    borderWidth: 1
+  }),
+  E.geom.line({
+    strokeWidth: 2,
+    lineType: "solid"
+  }),
+  E.geom.area({
+    alpha: 0.3,
+    strokeWidth: 2,
+    lineType: "solid",
+    strokeAlpha: 1
+  }),
+  E.geom.point({
+    size: 8,
+    borderColor: S("pointBorderColor"),
+    borderWidth: 1
+  }),
+  E.geom.rule({
+    color: S("ruleColor"),
+    strokeWidth: 1,
+    lineType: "dashed"
+  }),
+  E.geom({ alpha: nr }, { state: "dimmed" }),
+  E.geom.point({ borderColor: S("hoverAffordanceColor") }, { state: "hovered" }),
+  E.geom.bar({ borderColor: S("hoverAffordanceColor") }, { state: "hovered" })
+];
+for (const e of ke) {
+  Object.freeze(e.select);
+  for (const t of Object.values(e.declarations)) typeof t == "object" && Object.freeze(t);
+  Object.freeze(e.declarations), e.when !== void 0 && Object.freeze(e.when), Object.freeze(e);
+}
+var sa = Object.freeze({
+  tokens: Object.freeze(sr),
+  defaults: Object.freeze(ke),
+  overrides: Object.freeze([])
+}), oa = {
+  cartesian: (e = {}) => ({
+    type: "coord",
+    coordType: "cartesian",
+    params: e
+  }),
+  flip: (e = {}) => ({
+    type: "coord",
+    coordType: "flip",
+    params: e
+  }),
+  polar: (e = {}) => ({
+    type: "coord",
+    coordType: "polar",
+    params: e
+  })
+}, ia = {
+  x: Object.assign((e) => W("x", e), {
+    continuous: (e) => m("x", e),
+    discrete: (e) => _("x", e),
+    datetime: (e) => z("x", e),
+    log: (e) => m("x", {
+      ...e,
+      transform: "log"
+    }),
+    sqrt: (e) => m("x", {
+      ...e,
+      transform: "sqrt"
+    })
+  }),
+  y: Object.assign((e) => W("y", e), {
+    continuous: (e) => m("y", e),
+    discrete: (e) => _("y", e),
+    datetime: (e) => z("y", e),
+    log: (e) => m("y", {
+      ...e,
+      transform: "log"
+    }),
+    sqrt: (e) => m("y", {
+      ...e,
+      transform: "sqrt"
+    })
+  }),
+  ySecondary: Object.assign((e) => W("ySecondary", e), {
+    continuous: (e) => m("ySecondary", e),
+    discrete: (e) => _("ySecondary", e),
+    datetime: (e) => z("ySecondary", e),
+    log: (e) => m("ySecondary", {
+      ...e,
+      transform: "log"
+    }),
+    sqrt: (e) => m("ySecondary", {
+      ...e,
+      transform: "sqrt"
+    })
+  }),
+  color: {
+    continuous: (e) => m("color", e),
+    discrete: (e) => _("color", e),
+    palette: (e) => Ht("color", e)
+  },
+  size: {
+    continuous: (e) => m("size", e),
+    discrete: (e) => _("size", e),
+    identity: (e) => x("size", e)
+  },
+  alpha: {
+    continuous: (e) => m("alpha", e),
+    discrete: (e) => _("alpha", e),
+    identity: (e) => x("alpha", e)
+  },
+  strokeWidth: {
+    continuous: (e) => m("strokeWidth", e),
+    discrete: (e) => _("strokeWidth", e),
+    identity: (e) => x("strokeWidth", e)
+  },
+  lineType: {
+    discrete: (e) => _("lineType", e),
+    identity: (e) => x("lineType", e)
+  }
+}, la = {
+  identity: ir,
+  count: lr,
+  smooth: or,
+  mean: ur
+};
+function or(e) {
+  return {
+    type: "smooth",
+    method: e.method,
+    order: e.order,
+    bandwidth: e.bandwidth
+  };
+}
+function ir() {
+  return { type: "identity" };
+}
+function lr() {
+  return { type: "count" };
+}
+function ur() {
+  return { type: "mean" };
+}
+var ua = {
+  reshape: cr,
+  filter: dr,
+  sort: yr,
+  aggregate: fr,
+  constant: mr
+};
+function cr(e = {}) {
+  return {
+    type: "transform",
+    transformType: "reshape",
+    options: e
+  };
+}
+function dr(e) {
+  return {
+    type: "transform",
+    transformType: "filter",
+    options: e
+  };
+}
+function yr(e) {
+  return {
+    type: "transform",
+    transformType: "sort",
+    options: e
+  };
+}
+function fr(e) {
+  return {
+    type: "transform",
+    transformType: "aggregate",
+    options: e
+  };
+}
+function mr(e) {
+  return {
+    type: "transform",
+    transformType: "constant",
+    options: e
+  };
+}
+function pr(e) {
+  const t = e.layout?.gaps;
+  if (t === void 0) return e;
+  const r = {};
+  for (const a of Object.keys(t)) {
+    const n = t[a];
+    n !== void 0 && (r[a] = typeof n == "number" ? { after: n } : n);
+  }
+  return {
+    ...e,
+    layout: {
+      ...e.layout,
+      gaps: r
+    }
+  };
+}
+var ca = [
+  "lilac",
+  "neon_pink",
+  "blackberry",
+  "sun",
+  "iceland",
+  "sunset",
+  "ultraviolet",
+  "purple",
+  "ice_cream",
+  "mint",
+  "cool",
+  "fresh"
+];
+function da(e) {
+  return {
+    type: "config",
+    config: pr(e)
+  };
+}
+export {
+  qe as $,
+  qr as A,
+  Ar as At,
+  Pr as B,
+  x as C,
+  je as Ct,
+  Xr as D,
+  se as Dt,
+  m as E,
+  Ue as Et,
+  Oe as F,
+  Mr as Ft,
+  jr as G,
+  Nt as H,
+  zr as I,
+  Xe as J,
+  et as K,
+  $r as L,
+  Kr as M,
+  _r as Mt,
+  Hr as N,
+  ae as Nt,
+  Jr as O,
+  $e as Ot,
+  Gr as P,
+  vr as Pt,
+  ue as Q,
+  Yr as R,
+  W as S,
+  Be as St,
+  z as T,
+  Ye as Tt,
+  K as U,
+  Ot as V,
+  bt as W,
+  Vr as X,
+  He as Y,
+  xr as Z,
+  qt as _,
+  G as _t,
+  ia as a,
+  Ke as at,
+  ea as b,
+  Dr as bt,
+  nr as c,
+  Cr as ct,
+  ta as d,
+  D as dt,
+  P as et,
+  ra as f,
+  kr as ft,
+  S as g,
+  We as gt,
+  na as h,
+  Sr as ht,
+  la as i,
+  le as it,
+  Wr as j,
+  c as jt,
+  Qr as k,
+  Tr as kt,
+  tr as l,
+  Rr as lt,
+  E as m,
+  Or as mt,
+  da as n,
+  v as nt,
+  oa as o,
+  Ge as ot,
+  aa as p,
+  oe as pt,
+  be as q,
+  ua as r,
+  B as rt,
+  sa as s,
+  Lr as st,
+  ca as t,
+  Br as tt,
+  ar as u,
+  Ir as ut,
+  L as v,
+  wr as vt,
+  _ as w,
+  Pe as wt,
+  Ht as x,
+  Fr as xt,
+  Zr as y,
+  Nr as yt,
+  Ur as z
+};