@sisense/sdk-ui 2.8.0 → 2.9.0

package/dist/analytics-composer/node.js

@@ -0,0 +1,897 @@
+var Ce = Object.defineProperty, Re = Object.defineProperties;
+var Ie = Object.getOwnPropertyDescriptors;
+var W = Object.getOwnPropertySymbols;
+var Ne = Object.prototype.hasOwnProperty, Te = Object.prototype.propertyIsEnumerable;
+var H = (e, t, r) => t in e ? Ce(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, y = (e, t) => {
+  for (var r in t || (t = {}))
+    Ne.call(t, r) && H(e, r, t[r]);
+  if (W)
+    for (var r of W(t))
+      Te.call(t, r) && H(e, r, t[r]);
+  return e;
+}, N = (e, t) => Re(e, Ie(t));
+import { f as Me, J as Oe } from "../types-BYUVZb6u.js";
+import { b as Ir, E as Nr, a as Tr, i as Mr, e as Or, d as Sr } from "../types-BYUVZb6u.js";
+import { bU as Se, bV as Pe, bW as ke, bX as _e, bY as $e, a4 as se, bZ as xe, ah as Ve, b_ as Be, bd as Le, aG as Ue, bg as Ke, be as Qe, aP as qe, bc as Ye, bf as Je, e as We, d as He, l as Xe, b$ as Ge, c0 as Ze, c1 as je, c2 as ve, c3 as et, c4 as tt, c5 as rt, c6 as st, c7 as it, c8 as nt, aE as at, c9 as ot, ca as lt, S as ct, i as ut, cb as ft, c as mt, cc as dt, cd as pt, ce as gt, O as yt, ae as X, aF as bt, cf as wt, v as ht, u as At } from "../execute-query-agpyzZz6.js";
+import { i as Dt, b as Et, D as zt, d as Ft } from "../dimensions-B2jz151s.js";
+class Ct {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map(), this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(t, r) {
+    this.keyToValue.set(t, r), this.valueToKey.set(r, t);
+  }
+  getByKey(t) {
+    return this.keyToValue.get(t);
+  }
+  getByValue(t) {
+    return this.valueToKey.get(t);
+  }
+  clear() {
+    this.keyToValue.clear(), this.valueToKey.clear();
+  }
+}
+class ie {
+  constructor(t) {
+    this.generateIdentifier = t, this.kv = new Ct();
+  }
+  register(t, r) {
+    this.kv.getByValue(t) || (r || (r = this.generateIdentifier(t)), this.kv.set(r, t));
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(t) {
+    return this.kv.getByValue(t);
+  }
+  getValue(t) {
+    return this.kv.getByKey(t);
+  }
+}
+class Rt extends ie {
+  constructor() {
+    super((t) => t.name), this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(t, r) {
+    typeof r == "object" ? (r.allowProps && this.classToAllowedProps.set(t, r.allowProps), super.register(t, r.identifier)) : super.register(t, r);
+  }
+  getAllowedProps(t) {
+    return this.classToAllowedProps.get(t);
+  }
+}
+function It(e) {
+  if ("values" in Object)
+    return Object.values(e);
+  const t = [];
+  for (const r in e)
+    e.hasOwnProperty(r) && t.push(e[r]);
+  return t;
+}
+function Nt(e, t) {
+  const r = It(e);
+  if ("find" in r)
+    return r.find(t);
+  const s = r;
+  for (let i = 0; i < s.length; i++) {
+    const n = s[i];
+    if (t(n))
+      return n;
+  }
+}
+function A(e, t) {
+  Object.entries(e).forEach(([r, s]) => t(s, r));
+}
+function T(e, t) {
+  return e.indexOf(t) !== -1;
+}
+function G(e, t) {
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r];
+    if (t(s))
+      return s;
+  }
+}
+class Tt {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(t) {
+    this.transfomers[t.name] = t;
+  }
+  findApplicable(t) {
+    return Nt(this.transfomers, (r) => r.isApplicable(t));
+  }
+  findByName(t) {
+    return this.transfomers[t];
+  }
+}
+const Mt = (e) => Object.prototype.toString.call(e).slice(8, -1), ne = (e) => typeof e == "undefined", Ot = (e) => e === null, F = (e) => typeof e != "object" || e === null || e === Object.prototype ? !1 : Object.getPrototypeOf(e) === null ? !0 : Object.getPrototypeOf(e) === Object.prototype, P = (e) => F(e) && Object.keys(e).length === 0, g = (e) => Array.isArray(e), St = (e) => typeof e == "string", Pt = (e) => typeof e == "number" && !isNaN(e), kt = (e) => typeof e == "boolean", _t = (e) => e instanceof RegExp, C = (e) => e instanceof Map, R = (e) => e instanceof Set, ae = (e) => Mt(e) === "Symbol", $t = (e) => e instanceof Date && !isNaN(e.valueOf()), xt = (e) => e instanceof Error, Z = (e) => typeof e == "number" && isNaN(e), Vt = (e) => kt(e) || Ot(e) || ne(e) || Pt(e) || St(e) || ae(e), Bt = (e) => typeof e == "bigint", Lt = (e) => e === 1 / 0 || e === -1 / 0, Ut = (e) => ArrayBuffer.isView(e) && !(e instanceof DataView), Kt = (e) => e instanceof URL, oe = (e) => e.replace(/\./g, "\\."), S = (e) => e.map(String).map(oe).join("."), z = (e) => {
+  const t = [];
+  let r = "";
+  for (let i = 0; i < e.length; i++) {
+    let n = e.charAt(i);
+    if (n === "\\" && e.charAt(i + 1) === ".") {
+      r += ".", i++;
+      continue;
+    }
+    if (n === ".") {
+      t.push(r), r = "";
+      continue;
+    }
+    r += n;
+  }
+  const s = r;
+  return t.push(s), t;
+};
+function d(e, t, r, s) {
+  return {
+    isApplicable: e,
+    annotation: t,
+    transform: r,
+    untransform: s
+  };
+}
+const le = [
+  d(ne, "undefined", () => null, () => {
+  }),
+  d(Bt, "bigint", (e) => e.toString(), (e) => typeof BigInt != "undefined" ? BigInt(e) : (console.error("Please add a BigInt polyfill."), e)),
+  d($t, "Date", (e) => e.toISOString(), (e) => new Date(e)),
+  d(xt, "Error", (e, t) => {
+    const r = {
+      name: e.name,
+      message: e.message
+    };
+    return t.allowedErrorProps.forEach((s) => {
+      r[s] = e[s];
+    }), r;
+  }, (e, t) => {
+    const r = new Error(e.message);
+    return r.name = e.name, r.stack = e.stack, t.allowedErrorProps.forEach((s) => {
+      r[s] = e[s];
+    }), r;
+  }),
+  d(_t, "regexp", (e) => "" + e, (e) => {
+    const t = e.slice(1, e.lastIndexOf("/")), r = e.slice(e.lastIndexOf("/") + 1);
+    return new RegExp(t, r);
+  }),
+  d(
+    R,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (e) => [...e.values()],
+    (e) => new Set(e)
+  ),
+  d(C, "map", (e) => [...e.entries()], (e) => new Map(e)),
+  d((e) => Z(e) || Lt(e), "number", (e) => Z(e) ? "NaN" : e > 0 ? "Infinity" : "-Infinity", Number),
+  d((e) => e === 0 && 1 / e === -1 / 0, "number", () => "-0", Number),
+  d(Kt, "URL", (e) => e.toString(), (e) => new URL(e))
+];
+function M(e, t, r, s) {
+  return {
+    isApplicable: e,
+    annotation: t,
+    transform: r,
+    untransform: s
+  };
+}
+const ce = M((e, t) => ae(e) ? !!t.symbolRegistry.getIdentifier(e) : !1, (e, t) => ["symbol", t.symbolRegistry.getIdentifier(e)], (e) => e.description, (e, t, r) => {
+  const s = r.symbolRegistry.getValue(t[1]);
+  if (!s)
+    throw new Error("Trying to deserialize unknown symbol");
+  return s;
+}), Qt = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((e, t) => (e[t.name] = t, e), {}), ue = M(Ut, (e) => ["typed-array", e.constructor.name], (e) => [...e], (e, t) => {
+  const r = Qt[t[1]];
+  if (!r)
+    throw new Error("Trying to deserialize unknown typed array");
+  return new r(e);
+});
+function fe(e, t) {
+  return e != null && e.constructor ? !!t.classRegistry.getIdentifier(e.constructor) : !1;
+}
+const me = M(fe, (e, t) => ["class", t.classRegistry.getIdentifier(e.constructor)], (e, t) => {
+  const r = t.classRegistry.getAllowedProps(e.constructor);
+  if (!r)
+    return y({}, e);
+  const s = {};
+  return r.forEach((i) => {
+    s[i] = e[i];
+  }), s;
+}, (e, t, r) => {
+  const s = r.classRegistry.getValue(t[1]);
+  if (!s)
+    throw new Error(`Trying to deserialize unknown class '${t[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  return Object.assign(Object.create(s.prototype), e);
+}), de = M((e, t) => !!t.customTransformerRegistry.findApplicable(e), (e, t) => ["custom", t.customTransformerRegistry.findApplicable(e).name], (e, t) => t.customTransformerRegistry.findApplicable(e).serialize(e), (e, t, r) => {
+  const s = r.customTransformerRegistry.findByName(t[1]);
+  if (!s)
+    throw new Error("Trying to deserialize unknown custom value");
+  return s.deserialize(e);
+}), qt = [me, ce, de, ue], j = (e, t) => {
+  const r = G(qt, (i) => i.isApplicable(e, t));
+  if (r)
+    return {
+      value: r.transform(e, t),
+      type: r.annotation(e, t)
+    };
+  const s = G(le, (i) => i.isApplicable(e, t));
+  if (s)
+    return {
+      value: s.transform(e, t),
+      type: s.annotation
+    };
+}, pe = {};
+le.forEach((e) => {
+  pe[e.annotation] = e;
+});
+const Yt = (e, t, r) => {
+  if (g(t))
+    switch (t[0]) {
+      case "symbol":
+        return ce.untransform(e, t, r);
+      case "class":
+        return me.untransform(e, t, r);
+      case "custom":
+        return de.untransform(e, t, r);
+      case "typed-array":
+        return ue.untransform(e, t, r);
+      default:
+        throw new Error("Unknown transformation: " + t);
+    }
+  else {
+    const s = pe[t];
+    if (!s)
+      throw new Error("Unknown transformation: " + t);
+    return s.untransform(e, r);
+  }
+}, h = (e, t) => {
+  if (t > e.size)
+    throw new Error("index out of bounds");
+  const r = e.keys();
+  for (; t > 0; )
+    r.next(), t--;
+  return r.next().value;
+};
+function ge(e) {
+  if (T(e, "__proto__"))
+    throw new Error("__proto__ is not allowed as a property");
+  if (T(e, "prototype"))
+    throw new Error("prototype is not allowed as a property");
+  if (T(e, "constructor"))
+    throw new Error("constructor is not allowed as a property");
+}
+const Jt = (e, t) => {
+  ge(t);
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r];
+    if (R(e))
+      e = h(e, +s);
+    else if (C(e)) {
+      const i = +s, n = +t[++r] == 0 ? "key" : "value", o = h(e, i);
+      switch (n) {
+        case "key":
+          e = o;
+          break;
+        case "value":
+          e = e.get(o);
+          break;
+      }
+    } else
+      e = e[s];
+  }
+  return e;
+}, k = (e, t, r) => {
+  if (ge(t), t.length === 0)
+    return r(e);
+  let s = e;
+  for (let n = 0; n < t.length - 1; n++) {
+    const o = t[n];
+    if (g(s)) {
+      const l = +o;
+      s = s[l];
+    } else if (F(s))
+      s = s[o];
+    else if (R(s)) {
+      const l = +o;
+      s = h(s, l);
+    } else if (C(s)) {
+      if (n === t.length - 2)
+        break;
+      const u = +o, I = +t[++n] == 0 ? "key" : "value", w = h(s, u);
+      switch (I) {
+        case "key":
+          s = w;
+          break;
+        case "value":
+          s = s.get(w);
+          break;
+      }
+    }
+  }
+  const i = t[t.length - 1];
+  if (g(s) ? s[+i] = r(s[+i]) : F(s) && (s[i] = r(s[i])), R(s)) {
+    const n = h(s, +i), o = r(n);
+    n !== o && (s.delete(n), s.add(o));
+  }
+  if (C(s)) {
+    const n = +t[t.length - 2], o = h(s, n);
+    switch (+i == 0 ? "key" : "value") {
+      case "key": {
+        const u = r(o);
+        s.set(u, s.get(o)), u !== o && s.delete(o);
+        break;
+      }
+      case "value": {
+        s.set(o, r(s.get(o)));
+        break;
+      }
+    }
+  }
+  return e;
+};
+function _(e, t, r = []) {
+  if (!e)
+    return;
+  if (!g(e)) {
+    A(e, (n, o) => _(n, t, [...r, ...z(o)]));
+    return;
+  }
+  const [s, i] = e;
+  i && A(i, (n, o) => {
+    _(n, t, [...r, ...z(o)]);
+  }), t(s, r);
+}
+function Wt(e, t, r) {
+  return _(t, (s, i) => {
+    e = k(e, i, (n) => Yt(n, s, r));
+  }), e;
+}
+function Ht(e, t) {
+  function r(s, i) {
+    const n = Jt(e, z(i));
+    s.map(z).forEach((o) => {
+      e = k(e, o, () => n);
+    });
+  }
+  if (g(t)) {
+    const [s, i] = t;
+    s.forEach((n) => {
+      e = k(e, z(n), () => e);
+    }), i && A(i, r);
+  } else
+    A(t, r);
+  return e;
+}
+const Xt = (e, t) => F(e) || g(e) || C(e) || R(e) || fe(e, t);
+function Gt(e, t, r) {
+  const s = r.get(e);
+  s ? s.push(t) : r.set(e, [t]);
+}
+function Zt(e, t) {
+  const r = {};
+  let s;
+  return e.forEach((i) => {
+    if (i.length <= 1)
+      return;
+    t || (i = i.map((l) => l.map(String)).sort((l, u) => l.length - u.length));
+    const [n, ...o] = i;
+    n.length === 0 ? s = o.map(S) : r[S(n)] = o.map(S);
+  }), s ? P(r) ? [s] : [s, r] : P(r) ? void 0 : r;
+}
+const ye = (e, t, r, s, i = [], n = [], o = /* @__PURE__ */ new Map()) => {
+  var J;
+  const l = Vt(e);
+  if (!l) {
+    Gt(e, i, t);
+    const p = o.get(e);
+    if (p)
+      return s ? {
+        transformedValue: null
+      } : p;
+  }
+  if (!Xt(e, r)) {
+    const p = j(e, r), m = p ? {
+      transformedValue: p.value,
+      annotations: [p.type]
+    } : {
+      transformedValue: e
+    };
+    return l || o.set(e, m), m;
+  }
+  if (T(n, e))
+    return {
+      transformedValue: null
+    };
+  const u = j(e, r), I = (J = u == null ? void 0 : u.value) != null ? J : e, w = g(I) ? [] : {}, D = {};
+  A(I, (p, m) => {
+    if (m === "__proto__" || m === "constructor" || m === "prototype")
+      throw new Error(`Detected property ${m}. This is a prototype pollution risk, please remove it from your object.`);
+    const E = ye(p, t, r, s, [...i, m], [...n, e], o);
+    w[m] = E.transformedValue, g(E.annotations) ? D[m] = E.annotations : F(E.annotations) && A(E.annotations, (ze, Fe) => {
+      D[oe(m) + "." + Fe] = ze;
+    });
+  });
+  const Y = P(D) ? {
+    transformedValue: w,
+    annotations: u ? [u.type] : void 0
+  } : {
+    transformedValue: w,
+    annotations: u ? [u.type, D] : D
+  };
+  return l || o.set(e, Y), Y;
+};
+function be(e) {
+  return Object.prototype.toString.call(e).slice(8, -1);
+}
+function v(e) {
+  return be(e) === "Array";
+}
+function jt(e) {
+  if (be(e) !== "Object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  return !!t && t.constructor === Object && t === Object.prototype;
+}
+function vt(e, t, r, s, i) {
+  const n = {}.propertyIsEnumerable.call(s, t) ? "enumerable" : "nonenumerable";
+  n === "enumerable" && (e[t] = r), i && n === "nonenumerable" && Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !1,
+    writable: !0,
+    configurable: !0
+  });
+}
+function $(e, t = {}) {
+  if (v(e))
+    return e.map((i) => $(i, t));
+  if (!jt(e))
+    return e;
+  const r = Object.getOwnPropertyNames(e), s = Object.getOwnPropertySymbols(e);
+  return [...r, ...s].reduce((i, n) => {
+    if (v(t.props) && !t.props.includes(n))
+      return i;
+    const o = e[n], l = $(o, t);
+    return vt(i, n, l, e, t.nonenumerable), i;
+  }, {});
+}
+class a {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe: t = !1 } = {}) {
+    this.classRegistry = new Rt(), this.symbolRegistry = new ie((r) => {
+      var s;
+      return (s = r.description) != null ? s : "";
+    }), this.customTransformerRegistry = new Tt(), this.allowedErrorProps = [], this.dedupe = t;
+  }
+  serialize(t) {
+    const r = /* @__PURE__ */ new Map(), s = ye(t, r, this, this.dedupe), i = {
+      json: s.transformedValue
+    };
+    s.annotations && (i.meta = N(y({}, i.meta), {
+      values: s.annotations
+    }));
+    const n = Zt(r, this.dedupe);
+    return n && (i.meta = N(y({}, i.meta), {
+      referentialEqualities: n
+    })), i;
+  }
+  deserialize(t) {
+    const { json: r, meta: s } = t;
+    let i = $(r);
+    return s != null && s.values && (i = Wt(i, s.values, this)), s != null && s.referentialEqualities && (i = Ht(i, s.referentialEqualities)), i;
+  }
+  stringify(t) {
+    return JSON.stringify(this.serialize(t));
+  }
+  parse(t) {
+    return this.deserialize(JSON.parse(t));
+  }
+  registerClass(t, r) {
+    this.classRegistry.register(t, r);
+  }
+  registerSymbol(t, r) {
+    this.symbolRegistry.register(t, r);
+  }
+  registerCustom(t, r) {
+    this.customTransformerRegistry.register(y({
+      name: r
+    }, t));
+  }
+  allowErrorProps(...t) {
+    this.allowedErrorProps.push(...t);
+  }
+}
+a.defaultInstance = new a();
+a.serialize = a.defaultInstance.serialize.bind(a.defaultInstance);
+a.deserialize = a.defaultInstance.deserialize.bind(a.defaultInstance);
+a.stringify = a.defaultInstance.stringify.bind(a.defaultInstance);
+a.parse = a.defaultInstance.parse.bind(a.defaultInstance);
+a.registerClass = a.defaultInstance.registerClass.bind(a.defaultInstance);
+a.registerSymbol = a.defaultInstance.registerSymbol.bind(a.defaultInstance);
+a.registerCustom = a.defaultInstance.registerCustom.bind(a.defaultInstance);
+a.allowErrorProps = a.defaultInstance.allowErrorProps.bind(a.defaultInstance);
+const b = (e) => e === void 0 ? ct.None : e, er = (e) => new Oe(e.metadataItem, e.type), x = (e) => new We(e.name, e.expression, e.type, e.description, b(e.sort), e.dataSource, e.composeCode), V = (e) => new He(e.name, e.expression, e.granularity, e.format, e.description, b(e.sort), e.dataSource, e.composeCode), f = (e) => {
+  switch (e.__serializable) {
+    case "DimensionalAttribute":
+      return x(e);
+    case "DimensionalLevelAttribute":
+      return V(e);
+    default:
+      return e;
+  }
+}, we = (e) => new zt(e.name, e.expression, e.attributes.map(f), e.dimensions.map(tr), e.type, e.description, b(e.sort), e.dataSource, e.composeCode, e.defaultAttribute ? f(e.defaultAttribute) : void 0), he = (e) => new Ft(e.name, e.expression, e.description, b(e.sort), e.dataSource, e.composeCode), tr = (e) => {
+  switch (e.__serializable) {
+    case "DimensionalDimension":
+      return we(e);
+    case "DimensionalDateDimension":
+      return he(e);
+    default:
+      return e;
+  }
+}, B = (e) => new Xe(e.name, f(e.attribute), e.aggregation, e.format, e.description, b(e.sort), e.dataSource, e.composeCode), L = (e) => {
+  const t = Object.fromEntries(Object.entries(e.context).map(([r, s]) => {
+    if (s && typeof s == "object" && "__serializable" in s)
+      switch (s.__serializable) {
+        case "DimensionalAttribute":
+          return [
+            r,
+            x(s)
+          ];
+        case "DimensionalLevelAttribute":
+          return [
+            r,
+            V(s)
+          ];
+        case "DimensionalBaseMeasure":
+          return [
+            r,
+            B(s)
+          ];
+        case "DimensionalCalculatedMeasure":
+          return [
+            r,
+            L(s)
+          ];
+        default:
+          return [
+            r,
+            s
+          ];
+      }
+    return [
+      r,
+      s
+    ];
+  }));
+  return new Ge(e.name, e.expression, t, e.format, e.description, b(e.sort), e.dataSource, e.composeCode);
+}, Ae = (e) => new Ze(e.name, f(e.attribute), e.format, e.description, b(e.sort), e.dataSource, e.composeCode), ee = (e) => {
+  switch (e.__serializable) {
+    case "DimensionalBaseMeasure":
+      return B(e);
+    case "DimensionalCalculatedMeasure":
+      return L(e);
+    case "DimensionalMeasureTemplate":
+      return Ae(e);
+    default:
+      return e;
+  }
+}, c = (e) => {
+  switch (e.__serializable) {
+    case "MembersFilter":
+      return new lt(f(e.attribute), e.members, e.config.backgroundFilter ? N(y({}, e.config), {
+        backgroundFilter: c(e.config.backgroundFilter)
+      }) : e.config, e.composeCode);
+    case "LogicalAttributeFilter":
+      return new ot(e.filters.map((r) => c(r)), e.operator, e.config, e.composeCode);
+    case "CascadingFilter":
+      return new at(e._filters.map((r) => c(r)), e.config, e.composeCode);
+    case "ExcludeFilter":
+      return new nt(c(e.filter), e.input ? c(e.input) : void 0, e.config, e.composeCode);
+    case "MeasureFilter":
+      return new it(f(e.attribute), ee(e.measure), e.operatorA, e.valueA, e.operatorB, e.valueB, e.config, e.composeCode);
+    case "RankingFilter":
+      return new st(f(e.attribute), ee(e.measure), e.operator, e.count, e.config, e.composeCode);
+    case "NumericFilter":
+      return new rt(f(e.attribute), e.operatorA, e.valueA, e.operatorB, e.valueB, e.config, e.composeCode);
+    case "TextFilter":
+      return new tt(f(e.attribute), e.operatorA, e.valueA, e.config, e.composeCode);
+    case "DateRangeFilter": {
+      const { valueA: r, valueB: s } = e;
+      return new et(f(e.attribute), r, s, e.config, e.composeCode);
+    }
+    case "RelativeDateFilter":
+      return new ve(f(e.attribute), e.offset, e.count, e.operator, e.anchor, e.config, e.composeCode);
+    case "CustomFilter":
+      return new je(f(e.attribute), e.jaqlExpression, e.config, e.composeCode);
+    default:
+      return e;
+  }
+};
+a.registerCustom({
+  isApplicable: Me,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => er(e)
+}, "JaqlElement");
+a.registerCustom({
+  isApplicable: Se,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => x(e)
+}, "DimensionalAttribute");
+a.registerCustom({
+  isApplicable: Pe,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => V(e)
+}, "DimensionalLevelAttribute");
+a.registerCustom({
+  isApplicable: Dt,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => we(e)
+}, "DimensionalDimension");
+a.registerCustom({
+  isApplicable: Et,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => he(e)
+}, "DimensionalDateDimension");
+a.registerCustom({
+  isApplicable: ke,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => B(e)
+}, "DimensionalBaseMeasure");
+a.registerCustom({
+  isApplicable: _e,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => L(e)
+}, "DimensionalCalculatedMeasure");
+a.registerCustom({
+  isApplicable: $e,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => Ae(e)
+}, "DimensionalMeasureTemplate");
+a.registerCustom({
+  isApplicable: se,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "MembersFilter");
+a.registerCustom({
+  isApplicable: xe,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "LogicalAttributeFilter");
+a.registerCustom({
+  isApplicable: Ve,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "CascadingFilter");
+a.registerCustom({
+  isApplicable: Be,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "ExcludeFilter");
+a.registerCustom({
+  isApplicable: Le,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "MeasureFilter");
+a.registerCustom({
+  isApplicable: Ue,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "RankingFilter");
+a.registerCustom({
+  isApplicable: Ke,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "NumericFilter");
+a.registerCustom({
+  isApplicable: Qe,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "TextFilter");
+a.registerCustom({
+  isApplicable: qe,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "DateRangeFilter");
+a.registerCustom({
+  isApplicable: Ye,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "RelativeDateFilter");
+a.registerCustom({
+  isApplicable: Je,
+  serialize: (e) => e.serialize(),
+  deserialize: (e) => c(e)
+}, "CustomFilter");
+const Er = a;
+function rr(e) {
+  return typeof e == "object" && e !== null && "function" in e && "args" in e;
+}
+function U(e) {
+  return e.every(rr);
+}
+function K(e) {
+  return "attribute" in e && "config" in e;
+}
+function Q(e) {
+  return "left" in e && "right" in e && "operator" in e;
+}
+function sr(e) {
+  return !K(e) && !Q(e);
+}
+function q(e, t) {
+  const r = {}, s = e !== "" ? e + "." : "";
+  for (const i in t)
+    if (typeof t[`${i}`] == "function")
+      r[`${s}${i}`] = t[`${i}`];
+    else if (typeof t[`${i}`] == "object") {
+      const n = q("", t[`${i}`]);
+      for (const o in n)
+        r[`${s}${i}.${o}`] = n[`${o}`];
+    }
+  return r;
+}
+const te = q("measureFactory", dt), re = q("filterFactory", pt);
+function ir(e, t) {
+  const s = e.split(".")[0];
+  if (s === "filterFactory" && re[`${e}`])
+    return re[`${e}`](...t);
+  if (s === "measureFactory" && te[`${e}`])
+    return te[`${e}`](...t);
+  throw new Error(`Function "${e}" not found in filterFactory or measureFactory.`);
+}
+function nr(e) {
+  const t = e.split(".");
+  if (t.length < 3 || t[0] !== "DM")
+    throw new Error(`Invalid attribute name format: "${e}". Expected format: "DM.TableName.ColumnName[.Level]".`);
+  const r = t[1], s = t[2];
+  let i;
+  return t.length === 4 && (i = t[3]), {
+    tableName: r,
+    columnName: s,
+    level: i
+  };
+}
+function ar(e, t) {
+  const { tableName: r, columnName: s, level: i } = nr(e), n = t.find((l) => l.name === r);
+  if (!n)
+    throw new Error(`Table "${r}" not found in the data model.`);
+  const o = n.columns.find((l) => l.name === s);
+  if (!o)
+    throw new Error(`Column "${s}" not found in table "${r}".`);
+  if (i) {
+    if (o.dataType !== ft.DATETIME)
+      throw new Error(`Invalid date level "${i}" in attribute "${e}". Column "${r}.${s}" is not a datetime column.`);
+    const l = mt.all;
+    if (!l.includes(i))
+      throw new Error(`Invalid date level "${i}" in attribute "${e}". Valid levels are: ${l.join(", ")}.`);
+  }
+  return {
+    field: o,
+    level: i
+  };
+}
+function De(e, t, r) {
+  const { field: s, level: i } = ar(e, r);
+  return ut({
+    expression: s.expression,
+    dataType: s.dataType,
+    granularity: i,
+    format: void 0,
+    sort: void 0,
+    dataSource: t
+  });
+}
+function or(e, t, r) {
+  return typeof e == "object" && e !== null && !Array.isArray(e) && "function" in e && "args" in e ? O(e, t, r) : typeof e == "string" && e.startsWith("DM.") ? De(e, t, r) : e;
+}
+function O(e, t, r) {
+  const { function: s, args: i } = e, n = i.map((o) => or(o, t, r));
+  return ir(s, n);
+}
+function Ee(e) {
+  const { attribute: t, config: r } = e;
+  if (se(e) && gt(t)) {
+    const { granularity: s } = t;
+    return yt(t, e.members.map((i) => s === "Years" && !isNaN(Number(i)) ? `${i}-01-01T00:00:00` : i), r);
+  }
+  return e;
+}
+function lr(e) {
+  let t = [];
+  for (const r of e)
+    Q(r) ? t = X(r, t) : t = X([
+      Ee(r)
+    ], t);
+  return t != null ? t : [];
+}
+const cr = (e, t, r) => {
+  const s = e.map((i) => {
+    const n = O(i, t, r);
+    if (!Q(n) && !K(n))
+      throw new Error("Invalid filter JSON");
+    return n;
+  });
+  return lr(s);
+}, ur = (e, t, r) => {
+  if (!e)
+    return [];
+  if (!U(e))
+    throw new Error('Invalid filters JSON. Expected an array of function calls with "function" and "args" properties.');
+  return cr(e, t, r);
+}, fr = (e, t, r) => e.map((s) => {
+  const i = O(s, t, r);
+  if (!K(i))
+    throw new Error("Invalid filter JSON");
+  return Ee(i);
+}), mr = (e, t, r) => {
+  if (!e)
+    return [];
+  if (!U(e))
+    throw new Error('Invalid highlights JSON. Expected an array of function calls with "function" and "args" properties.');
+  return fr(e, t, r);
+};
+function dr(e) {
+  return e.every((t) => typeof t == "string");
+}
+const pr = (e, t, r) => {
+  if (!e)
+    return [];
+  if (!dr(e))
+    throw new Error("Invalid dimensions JSON. Expected an array of strings.");
+  return e.map((s) => De(s, t, r));
+}, gr = (e, t, r) => e.map((s) => {
+  const i = O(s, t, r);
+  if (!sr(i))
+    throw new Error("Invalid measure JSON");
+  return i;
+}), yr = (e, t, r) => {
+  if (!e)
+    return [];
+  if (!U(e))
+    throw new Error('Invalid measures JSON. Expected an array of function calls with "function" and "args" properties.');
+  return gr(e, t, r);
+}, zr = (e, t, r) => y({
+  dataSource: bt(t),
+  dimensions: pr(e.dimensions, t, r),
+  measures: yr(e.measures, t, r),
+  filters: ur(e.filters, t, r)
+}, e.highlights && {
+  highlights: mr(e.highlights, t, r)
+});
+function br(e) {
+  const { filters: t, relations: r } = At(e.filters || []);
+  return {
+    dataSource: e.dataSource,
+    dimensions: e.dimensions,
+    measures: e.measures,
+    filters: t,
+    filterRelations: r,
+    highlights: e.highlights
+  };
+}
+function Fr(e, t, r = !1) {
+  const s = br(e), i = wt(s, t);
+  return ht(i, r);
+}
+export {
+  Er as CustomSuperJSON,
+  Ir as EMPTY_EXPANDED_QUERY_MODEL,
+  Nr as EMPTY_SIMPLE_QUERY_MODEL,
+  Tr as isByIdDashboardCodeParams,
+  Mr as isByIdWidgetCodeParams,
+  Or as isClientSideDashboardCodeParams,
+  Sr as isClientSideWidgetCodeParams,
+  zr as translateQueryJSON,
+  Fr as translateQueryToJaql
+};