@platforma-sdk/ui-vue 1.42.3 → 1.42.5

package/dist/lib/model/common/dist/index.js

@@ -1,288 +1,304 @@
 import f from "../../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.js";
 import p from "../../../../_virtual/canonicalize.js";
-var k = Object.defineProperty, E = (e, t, n) => t in e ? k(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, m = (e, t, n) => E(e, typeof t != "symbol" ? t + "" : t, n);
+var E = Object.defineProperty, S = (t, e, n) => e in t ? E(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, m = (t, e, n) => S(t, typeof e != "symbol" ? e + "" : e, n);
 f.object({
   /** Included left border. */
   from: f.number(),
   /** Excluded right border. */
   to: f.number()
 });
-function A(e) {
-  throw new Error("Unexpected object: " + e);
+function x(t) {
+  throw new Error("Unexpected object: " + t);
 }
-function Z(e) {
-  if (!e || typeof e != "object")
+function Y(t) {
+  if (!t || typeof t != "object")
     return !1;
-  const t = e;
-  if (!("type" in t))
+  const e = t;
+  if (!("type" in e))
     return !1;
-  switch (t.type) {
+  switch (e.type) {
     case "Json":
-      return typeof t.keyLength == "number" && t.data !== void 0 && typeof t.data == "object";
+      return typeof e.keyLength == "number" && e.data !== void 0 && typeof e.data == "object";
     case "JsonPartitioned":
-      return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
+      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
     case "BinaryPartitioned":
-      return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
+      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
     default:
       return !1;
   }
 }
-function ee(e, t) {
-  if (e !== void 0)
-    switch (e.type) {
+function Z(t, e) {
+  if (t !== void 0)
+    switch (t.type) {
       case "Json":
-        return e;
+        return t;
       case "JsonPartitioned": {
         const n = {};
-        for (const [r, o] of Object.entries(e.parts))
-          n[r] = t(o);
+        for (const [r, o] of Object.entries(t.parts))
+          n[r] = e(o);
         return {
-          ...e,
+          ...t,
           parts: n
         };
       }
       case "BinaryPartitioned": {
         const n = {};
-        for (const [r, o] of Object.entries(e.parts))
+        for (const [r, o] of Object.entries(t.parts))
           n[r] = {
-            index: t(o.index),
-            values: t(o.values)
+            index: e(o.index),
+            values: e(o.values)
           };
         return {
-          ...e,
+          ...t,
           parts: n
         };
       }
     }
 }
-function S(e) {
-  if (!e || typeof e != "object")
+function I(t) {
+  if (!t || typeof t != "object")
     return !1;
-  const t = e;
-  if (!("type" in t))
+  const e = t;
+  if (!("type" in e))
     return !1;
-  switch (t.type) {
+  switch (e.type) {
     case "Json":
-      return typeof t.keyLength == "number" && Array.isArray(t.data);
+      return typeof e.keyLength == "number" && Array.isArray(e.data);
     case "JsonPartitioned":
-      return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
+      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
     case "BinaryPartitioned":
-      return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
+      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
     default:
       return !1;
   }
 }
-function te(e) {
-  return S(e) ? e.type === "JsonPartitioned" || e.type === "BinaryPartitioned" : !1;
+function tt(t) {
+  return I(t) ? t.type === "JsonPartitioned" || t.type === "BinaryPartitioned" : !1;
 }
-function ne(e) {
-  switch (e.type) {
+function et(t) {
+  switch (t.type) {
     case "Json": {
-      const t = Object.entries(e.data).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+      const e = Object.entries(t.data).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
       return {
         type: "Json",
-        keyLength: e.keyLength,
-        data: t
+        keyLength: t.keyLength,
+        data: e
       };
     }
     case "JsonPartitioned": {
-      const t = Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+      const e = Object.entries(t.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
       return {
         type: "JsonPartitioned",
-        partitionKeyLength: e.partitionKeyLength,
-        parts: t
+        partitionKeyLength: t.partitionKeyLength,
+        parts: e
       };
     }
     case "BinaryPartitioned": {
-      const t = Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+      const e = Object.entries(t.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
       return {
         type: "BinaryPartitioned",
-        partitionKeyLength: e.partitionKeyLength,
-        parts: t
+        partitionKeyLength: t.partitionKeyLength,
+        parts: e
       };
     }
   }
 }
-function re(e) {
-  switch (e.type) {
+function nt(t) {
+  switch (t.type) {
     case "Json": {
-      const t = {};
-      for (const n of e.data)
-        t[JSON.stringify(n.key)] = n.value;
+      const e = {};
+      for (const n of t.data)
+        e[JSON.stringify(n.key)] = n.value;
       return {
         type: "Json",
-        keyLength: e.keyLength,
-        data: t
+        keyLength: t.keyLength,
+        data: e
       };
     }
     case "JsonPartitioned": {
-      const t = {};
-      for (const n of e.parts)
-        t[JSON.stringify(n.key)] = n.value;
+      const e = {};
+      for (const n of t.parts)
+        e[JSON.stringify(n.key)] = n.value;
       return {
         type: "JsonPartitioned",
-        partitionKeyLength: e.partitionKeyLength,
-        parts: t
+        partitionKeyLength: t.partitionKeyLength,
+        parts: e
       };
     }
     case "BinaryPartitioned": {
-      const t = {};
-      for (const n of e.parts)
-        t[JSON.stringify(n.key)] = n.value;
+      const e = {};
+      for (const n of t.parts)
+        e[JSON.stringify(n.key)] = n.value;
       return {
         type: "BinaryPartitioned",
-        partitionKeyLength: e.partitionKeyLength,
-        parts: t
+        partitionKeyLength: t.partitionKeyLength,
+        parts: e
       };
     }
   }
 }
-const N = -2147483648, b = -9007199254740991n, I = null, J = null;
-function O(e, t) {
-  switch (t) {
+function A(t, e) {
+  const n = Math.floor(e / 8), r = 1 << 7 - e % 8;
+  return (t[n] & r) > 0;
+}
+function J(t, e) {
+  return A(t.absent, e);
+}
+function O(t, e) {
+  if (t.isNA) return A(t.isNA, e);
+  const n = t.type, r = t.data[e];
+  switch (n) {
     case "Int":
-      return e === N;
+      return r === -2147483648;
     case "Long":
-      return e === Number(b) || e === b;
+      return r === -9007199254740991n;
     case "Float":
-      return Number.isNaN(e);
+      return Number.isNaN(r);
     case "Double":
-      return Number.isNaN(e);
+      return Number.isNaN(r);
     case "String":
-      return e === I;
+      return r === null;
     case "Bytes":
-      return e === J;
+      return r === null;
     default:
-      throw Error(`unsupported data type: ${t}`);
+      throw Error(`unsupported data type: ${n}`);
   }
 }
-function j(e, t) {
-  const n = Math.floor(t / 8), r = 1 << 7 - t % 8;
-  return (e[n] & r) > 0;
-}
-const C = { type: "absent" }, $ = null;
-function oe(e) {
-  return typeof e == "object" && e !== null && e.type === "absent";
-}
-function ae(e, t, n = {}) {
-  if (j(e.absent, t))
-    return n.absent === void 0 ? C : n.absent;
-  const r = e.data[t], o = e.type;
-  if (O(r, o)) return n.na === void 0 ? $ : n.na;
-  switch (o) {
+const N = { type: "absent" };
+function rt(t) {
+  return typeof t == "object" && t !== null && "type" in t && t.type === "absent";
+}
+const P = null;
+function j(t) {
+  return t === P;
+}
+function ot(t, e) {
+  return !j(t);
+}
+function C(t, e, n) {
+  const r = t.type;
+  if (r === "Bytes")
+    throw Error("Bytes not yet supported");
+  if (n && "dataType" in n && n.dataType !== void 0 && n.dataType !== r)
+    throw Error(`expected column of type ${n.dataType}, got ${r}`);
+  if (J(t, e))
+    return (n == null ? void 0 : n.absent) !== void 0 ? n.absent : N;
+  if (O(t, e))
+    return (n == null ? void 0 : n.na) !== void 0 ? n.na : P;
+  const o = t.data[e];
+  switch (r) {
     case "Int":
-      return r;
+      return o;
     case "Long":
-      return Number(r);
+      return Number(o);
     case "Float":
-      return r;
+      return o;
     case "Double":
-      return r;
+      return o;
     case "String":
-      return r;
-    case "Bytes":
-      throw Error("Bytes not yet supported");
-    default:
-      throw Error(`unsupported data type: ${o}`);
+      return o;
   }
 }
-function l(e) {
-  const { type: t, name: n, domain: r } = e, o = { type: t, name: n };
+function at(t, e, n) {
+  return C(t, e, n);
+}
+function l(t) {
+  const { type: e, name: n, domain: r } = t, o = { type: e, name: n };
   return r && Object.entries(r).length > 0 && Object.assign(o, { domain: r }), o;
 }
-function L(e) {
-  return e.map(l);
+function $(t) {
+  return t.map(l);
 }
-function ie(e) {
-  return p(l(e));
+function it(t) {
+  return p(l(t));
 }
-function T(e, t) {
-  if (e === void 0) return t === void 0;
-  if (t === void 0) return !0;
-  for (const n in t)
-    if (e[n] !== t[n]) return !1;
+function T(t, e) {
+  if (t === void 0) return e === void 0;
+  if (e === void 0) return !0;
+  for (const n in e)
+    if (t[n] !== e[n]) return !1;
   return !0;
 }
-function B(e, t) {
-  return e.name === t.name && T(e.domain, t.domain);
+function L(t, e) {
+  return t.name === e.name && T(t.domain, e.domain);
 }
-function se(e, t) {
-  return { ...e, src: y(e.src, t) };
+function st(t, e) {
+  return { ...t, src: y(t.src, e) };
 }
-function y(e, t) {
-  switch (e.type) {
+function y(t, e) {
+  switch (t.type) {
     case "column":
       return {
         type: "column",
-        column: t(e.column)
+        column: e(t.column)
       };
     case "slicedColumn":
       return {
         type: "slicedColumn",
-        column: t(e.column),
-        newId: e.newId,
-        axisFilters: e.axisFilters
+        column: e(t.column),
+        newId: t.newId,
+        axisFilters: t.axisFilters
       };
     case "inlineColumn":
-      return e;
+      return t;
     case "inner":
     case "full":
       return {
-        type: e.type,
-        entries: e.entries.map((n) => y(n, t))
+        type: t.type,
+        entries: t.entries.map((n) => y(n, e))
       };
     case "outer":
       return {
         type: "outer",
-        primary: y(e.primary, t),
-        secondary: e.secondary.map((n) => y(n, t))
+        primary: y(t.primary, e),
+        secondary: t.secondary.map((n) => y(n, e))
       };
     default:
-      A(e);
+      x(t);
   }
 }
-function ce(e) {
-  switch (e.type) {
+function ct(t) {
+  switch (t.type) {
     case "axis":
       return {
         type: "axis",
-        id: e.id
+        id: t.id
       };
     case "column":
       return {
         type: "column",
-        id: e.id
+        id: t.id
       };
   }
 }
-function D(e) {
-  return p(e);
+function B(t) {
+  return p(t);
 }
-function g(e) {
-  return p(l(e));
+function b(t) {
+  return p(l(t));
 }
-function w(e, t) {
-  return JSON.stringify([e, t]);
+function g(t, e) {
+  return JSON.stringify([t, e]);
 }
-class ue {
+class ut {
   /**
    * Creates a new anchor context from a set of anchor column specifications
    * @param anchors Record of anchor column specifications indexed by anchor ID
    */
-  constructor(t) {
-    m(this, "domains", /* @__PURE__ */ new Map()), m(this, "axes", /* @__PURE__ */ new Map()), m(this, "domainPacks", []), m(this, "domainPackToAnchor", /* @__PURE__ */ new Map()), this.anchors = t;
-    const n = Object.entries(t);
+  constructor(e) {
+    m(this, "domains", /* @__PURE__ */ new Map()), m(this, "axes", /* @__PURE__ */ new Map()), m(this, "domainPacks", []), m(this, "domainPackToAnchor", /* @__PURE__ */ new Map()), this.anchors = e;
+    const n = Object.entries(e);
     n.sort((r, o) => r[0].localeCompare(o[0]));
     for (const [r, o] of n) {
       for (let s = 0; s < o.axesSpec.length; s++) {
-        const i = o.axesSpec[s], a = g(i);
+        const i = o.axesSpec[s], a = b(i);
         this.axes.set(a, { anchor: r, idx: s });
       }
       if (o.domain !== void 0) {
         const s = Object.entries(o.domain);
         s.sort((i, a) => i[0].localeCompare(a[0])), this.domainPackToAnchor.set(JSON.stringify(s), r), this.domainPacks.push(s.map(([i]) => i));
         for (const [i, a] of s) {
-          const c = w(i, a);
+          const c = g(i, a);
           this.domains.set(c, r);
         }
       }
@@ -291,22 +307,22 @@ class ue {
   /**
    * Implementation of derive method
    */
-  derive(t, n) {
+  derive(e, n) {
     const r = {
-      name: t.name,
+      name: e.name,
       axes: []
     };
     let o;
-    if (t.domain !== void 0)
-      e:
+    if (e.domain !== void 0)
+      t:
         for (const i of this.domainPacks) {
           const a = [];
           for (const u of i) {
-            const d = t.domain[u];
+            const d = e.domain[u];
             if (d !== void 0)
               a.push([u, d]);
             else
-              break e;
+              break t;
           }
           const c = this.domainPackToAnchor.get(JSON.stringify(a));
           if (c !== void 0) {
@@ -314,14 +330,14 @@ class ue {
             break;
           }
         }
-    for (const [i, a] of Object.entries(t.domain ?? {})) {
+    for (const [i, a] of Object.entries(e.domain ?? {})) {
       if (o !== void 0 && o.has(i))
         continue;
-      const c = w(i, a), u = this.domains.get(c);
+      const c = g(i, a), u = this.domains.get(c);
       r.domain ?? (r.domain = {}), r.domain[i] = u ? { anchor: u } : a;
     }
-    if (r.axes = t.axesSpec.map((i) => {
-      const a = g(i), c = this.axes.get(a);
+    if (r.axes = e.axesSpec.map((i) => {
+      const a = b(i), c = this.axes.get(a);
       return c === void 0 ? l(i) : c;
     }), !n || n.length === 0)
       return r;
@@ -329,11 +345,11 @@ class ue {
     for (const i of n) {
       const [a, c] = i;
       if (typeof a == "number") {
-        if (a < 0 || a >= t.axesSpec.length)
-          throw new Error(`Axis index ${a} is out of bounds (0-${t.axesSpec.length - 1})`);
+        if (a < 0 || a >= e.axesSpec.length)
+          throw new Error(`Axis index ${a} is out of bounds (0-${e.axesSpec.length - 1})`);
         s.push([a, c]);
       } else {
-        const u = t.axesSpec.findIndex((d) => d.name === a);
+        const u = e.axesSpec.findIndex((d) => d.name === a);
         if (u === -1)
           throw new Error(`Axis with name "${a}" not found in the column specification`);
         s.push([u, c]);
@@ -350,14 +366,14 @@ class ue {
    * @param axisFilters Optional axis filters to apply to the column
    * @returns A canonicalized string representation of the anchored column identifier
    */
-  deriveS(t, n) {
-    return D(this.derive(t, n));
+  deriveS(e, n) {
+    return B(this.derive(e, n));
   }
 }
-function fe(e, t, n) {
-  const r = { ...t }, o = (n == null ? void 0 : n.ignoreMissingDomains) ?? !1;
+function ft(t, e, n) {
+  const r = { ...e }, o = (n == null ? void 0 : n.ignoreMissingDomains) ?? !1;
   if (r.domainAnchor !== void 0) {
-    const s = e[r.domainAnchor];
+    const s = t[r.domainAnchor];
     if (!s)
       throw new Error(`Anchor "${r.domainAnchor}" not found`);
     const i = s.domain || {};
@@ -369,7 +385,7 @@ function fe(e, t, n) {
       if (typeof a == "string")
         s[i] = a;
       else {
-        const c = e[a.anchor];
+        const c = t[a.anchor];
         if (!c)
           throw new Error(`Anchor "${a.anchor}" not found for domain key "${i}"`);
         if (!c.domain || c.domain[i] === void 0) {
@@ -381,27 +397,27 @@ function fe(e, t, n) {
       }
     r.domain = s;
   }
-  return r.axes && (r.axes = r.axes.map((s) => R(e, s))), r;
+  return r.axes && (r.axes = r.axes.map((s) => R(t, s))), r;
 }
-function R(e, t) {
-  if (!V(t))
-    return t;
-  const n = t.anchor, r = e[n];
+function R(t, e) {
+  if (!D(e))
+    return e;
+  const n = e.anchor, r = t[n];
   if (!r)
     throw new Error(`Anchor "${n}" not found for axis reference`);
-  if ("idx" in t) {
-    if (t.idx < 0 || t.idx >= r.axesSpec.length)
-      throw new Error(`Axis index ${t.idx} out of bounds for anchor "${n}"`);
-    return r.axesSpec[t.idx];
-  } else if ("name" in t) {
-    const o = r.axesSpec.filter((s) => s.name === t.name);
+  if ("idx" in e) {
+    if (e.idx < 0 || e.idx >= r.axesSpec.length)
+      throw new Error(`Axis index ${e.idx} out of bounds for anchor "${n}"`);
+    return r.axesSpec[e.idx];
+  } else if ("name" in e) {
+    const o = r.axesSpec.filter((s) => s.name === e.name);
     if (o.length > 1)
-      throw new Error(`Multiple axes with name "${t.name}" found in anchor "${n}"`);
+      throw new Error(`Multiple axes with name "${e.name}" found in anchor "${n}"`);
     if (o.length === 0)
-      throw new Error(`Axis with name "${t.name}" not found in anchor "${n}"`);
+      throw new Error(`Axis with name "${e.name}" not found in anchor "${n}"`);
     return o[0];
-  } else if ("id" in t) {
-    const o = r.axesSpec.filter((s) => B(t.id, l(s)));
+  } else if ("id" in e) {
+    const o = r.axesSpec.filter((s) => L(e.id, l(s)));
     if (o.length > 1)
       throw new Error(`Multiple matching axes found for matcher in anchor "${n}"`);
     if (o.length === 0)
@@ -410,33 +426,33 @@ function R(e, t) {
   }
   throw new Error("Unsupported axis reference type");
 }
-function V(e) {
-  return typeof e == "object" && "anchor" in e;
+function D(t) {
+  return typeof t == "object" && "anchor" in t;
 }
-function h(e) {
-  return e.kind === "PColumn";
+function h(t) {
+  return t.kind === "PColumn";
 }
-function K(e) {
-  return h(e.spec);
+function K(t) {
+  return h(t.spec);
 }
-function de(e) {
-  if (!K(e)) throw new Error(`not a PColumn (kind = ${e.spec.kind})`);
-  return e;
+function dt(t) {
+  if (!K(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
+  return t;
 }
-function le(e, t) {
-  return e === void 0 ? void 0 : {
-    ...e,
-    data: t(e.data)
+function lt(t, e) {
+  return t === void 0 ? void 0 : {
+    ...t,
+    data: e(t.data)
   };
 }
-function pe(e) {
-  const t = /* @__PURE__ */ new Map(), n = (r) => {
+function pt(t) {
+  const e = /* @__PURE__ */ new Map(), n = (r) => {
     switch (r.type) {
       case "column":
-        t.set(r.column.id, r.column);
+        e.set(r.column.id, r.column);
         return;
       case "slicedColumn":
-        t.set(r.column.id, r.column);
+        e.set(r.column.id, r.column);
         return;
       case "inlineColumn":
         return;
@@ -449,68 +465,68 @@ function pe(e) {
         for (const o of r.secondary) n(o);
         return;
       default:
-        A(r);
+        x(r);
     }
   };
-  return n(e), [...t.values()];
+  return n(t), [...e.values()];
 }
-function v(e, t) {
-  if (e.name !== void 0 && e.name !== t.name)
+function w(t, e) {
+  if (t.name !== void 0 && t.name !== e.name)
     return !1;
-  if (e.type !== void 0) {
-    if (Array.isArray(e.type)) {
-      if (!e.type.includes(t.type))
+  if (t.type !== void 0) {
+    if (Array.isArray(t.type)) {
+      if (!t.type.includes(e.type))
         return !1;
-    } else if (e.type !== t.type)
+    } else if (t.type !== e.type)
       return !1;
   }
-  if (e.domain !== void 0) {
-    const n = t.domain || {};
-    for (const [r, o] of Object.entries(e.domain))
+  if (t.domain !== void 0) {
+    const n = e.domain || {};
+    for (const [r, o] of Object.entries(t.domain))
       if (n[r] !== o)
         return !1;
   }
   return !0;
 }
-function x(e, t) {
-  if (t.name !== void 0 && e.name !== t.name || t.namePattern !== void 0 && !new RegExp(t.namePattern).test(e.name))
+function v(t, e) {
+  if (e.name !== void 0 && t.name !== e.name || e.namePattern !== void 0 && !new RegExp(e.namePattern).test(t.name))
     return !1;
-  if (t.type !== void 0) {
-    if (Array.isArray(t.type)) {
-      if (!t.type.includes(e.valueType))
+  if (e.type !== void 0) {
+    if (Array.isArray(e.type)) {
+      if (!e.type.includes(t.valueType))
         return !1;
-    } else if (t.type !== e.valueType)
+    } else if (e.type !== t.valueType)
       return !1;
   }
-  if (t.domain !== void 0) {
-    const n = e.domain || {};
-    for (const [r, o] of Object.entries(t.domain))
+  if (e.domain !== void 0) {
+    const n = t.domain || {};
+    for (const [r, o] of Object.entries(e.domain))
       if (n[r] !== o)
         return !1;
   }
-  if (t.axes !== void 0) {
-    const n = e.axesSpec.map(l);
-    if (t.partialAxesMatch) {
-      for (const r of t.axes)
-        if (!n.some((o) => v(r, o)))
+  if (e.axes !== void 0) {
+    const n = t.axesSpec.map(l);
+    if (e.partialAxesMatch) {
+      for (const r of e.axes)
+        if (!n.some((o) => w(r, o)))
           return !1;
     } else {
-      if (n.length !== t.axes.length)
+      if (n.length !== e.axes.length)
         return !1;
-      for (let r = 0; r < t.axes.length; r++)
-        if (!v(t.axes[r], n[r]))
+      for (let r = 0; r < e.axes.length; r++)
+        if (!w(e.axes[r], n[r]))
           return !1;
     }
   }
-  if (t.annotations !== void 0) {
-    const n = e.annotations || {};
-    for (const [r, o] of Object.entries(t.annotations))
+  if (e.annotations !== void 0) {
+    const n = t.annotations || {};
+    for (const [r, o] of Object.entries(e.annotations))
       if (n[r] !== o)
         return !1;
   }
-  if (t.annotationPatterns !== void 0) {
-    const n = e.annotations || {};
-    for (const [r, o] of Object.entries(t.annotationPatterns)) {
+  if (e.annotationPatterns !== void 0) {
+    const n = t.annotations || {};
+    for (const [r, o] of Object.entries(e.annotationPatterns)) {
       const s = n[r];
       if (s === void 0 || !new RegExp(o).test(s))
         return !1;
@@ -518,15 +534,15 @@ function x(e, t) {
   }
   return !0;
 }
-function me(e) {
-  return Array.isArray(e) ? (t) => e.some((n) => h(t) && x(t, n)) : (t) => h(t) && x(t, e);
+function mt(t) {
+  return Array.isArray(t) ? (e) => t.some((n) => h(e) && v(e, n)) : (e) => h(e) && v(e, t);
 }
-function ye(e) {
-  const t = {
-    kind: e.kind,
-    name: e.name
+function yt(t) {
+  const e = {
+    kind: t.kind,
+    name: t.name
   };
-  return e.domain !== void 0 && (t.domain = e.domain), h(e) && (t.axesSpec = L(e.axesSpec)), p(t);
+  return t.domain !== void 0 && (e.domain = t.domain), h(t) && (e.axesSpec = $(t.axesSpec)), p(e);
 }
 f.object({
   __isRef: f.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
@@ -536,50 +552,50 @@ f.object({
 }).describe(
   "Universal reference type, allowing to set block connections. It is crucial that {@link __isRef} is present and equal to true, internal logic relies on this marker to build block dependency trees."
 ).readonly();
-function he(e) {
-  return typeof e == "object" && e !== null && "__isRef" in e && e.__isRef === !0 && "blockId" in e && "name" in e;
+function ht(t) {
+  return typeof t == "object" && t !== null && "__isRef" in t && t.__isRef === !0 && "blockId" in t && "name" in t;
 }
-function be(e, t = !0) {
-  if (t)
+function bt(t, e = !0) {
+  if (e)
     return {
-      ...e,
+      ...t,
       requireEnrichments: !0
     };
   {
-    const { requireEnrichments: n, ...r } = e;
+    const { requireEnrichments: n, ...r } = t;
     return r;
   }
 }
-function ge(e, t) {
-  return e.ok ? { ok: !0, value: t(e.value) } : e;
+function gt(t, e) {
+  return t.ok ? { ok: !0, value: e(t.value) } : t;
 }
-function U(e) {
-  if (e instanceof Int8Array || e instanceof Uint8Array || e instanceof Uint8ClampedArray)
-    return new DataView(e.buffer, e.byteOffset, e.byteLength);
-  if (e instanceof ArrayBuffer) return new DataView(e);
+function F(t) {
+  if (t instanceof Int8Array || t instanceof Uint8Array || t instanceof Uint8ClampedArray)
+    return new DataView(t.buffer, t.byteOffset, t.byteLength);
+  if (t instanceof ArrayBuffer) return new DataView(t);
   throw new TypeError(
     "Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray"
   );
 }
-const F = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", M = "0123456789ABCDEFGHIJKLMNOPQRSTUV", _ = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-function q(e, t, n) {
+const U = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", M = "0123456789ABCDEFGHIJKLMNOPQRSTUV", V = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function _(t, e, n) {
   n = n || {};
   let r, o;
-  switch (t) {
+  switch (e) {
     case "RFC3548":
     case "RFC4648":
-      r = F, o = !0;
+      r = U, o = !0;
       break;
     case "RFC4648-HEX":
       r = M, o = !0;
       break;
     case "Crockford":
-      r = _, o = !1;
+      r = V, o = !1;
       break;
     default:
-      throw new Error("Unknown base32 variant: " + String(t));
+      throw new Error("Unknown base32 variant: " + String(e));
   }
-  const s = n.padding !== void 0 ? n.padding : o, i = U(e);
+  const s = n.padding !== void 0 ? n.padding : o, i = F(t);
   let a = 0, c = 0, u = "";
   for (let d = 0; d < i.byteLength; d++)
     for (c = c << 8 | i.getUint8(d), a += 8; a >= 5; )
@@ -589,91 +605,87 @@ function q(e, t, n) {
       u += "=";
   return u;
 }
-const z = 15, H = 24, Q = f.string().length(H).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-function we() {
-  const e = new Uint8Array(z);
-  return crypto.getRandomValues(e), Q.parse(q(e, "RFC4648"));
+const z = 15, q = 24, G = f.string().length(q).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function wt() {
+  const t = new Uint8Array(z);
+  return crypto.getRandomValues(t), G.parse(_(t, "RFC4648"));
 }
-function ve(e) {
-  return p(e);
+function vt(t) {
+  return p(t);
 }
-function xe(e) {
-  return JSON.parse(e);
+function xt(t) {
+  return JSON.parse(t);
 }
-function G(e) {
-  return e instanceof Error ? e.name === "AbortError" || G(e.cause) : !1;
+function H(t) {
+  return t instanceof Error ? t.name === "AbortError" || H(t.cause) : !1;
 }
-function Y(e) {
-  if (typeof e == "string")
-    return `String value was thrown: ${e}`;
-  if (e && typeof e == "object")
+function Q(t) {
+  if (typeof t == "string")
+    return `String value was thrown: ${t}`;
+  if (t && typeof t == "object")
     try {
-      return `Plain object was thrown: ${JSON.stringify(e)}`;
-    } catch (t) {
-      return `Non-serializable object was thrown (JSON.stringify failed: ${t instanceof Error ? t.message : String(t)}): ${String(e)}`;
+      return `Plain object was thrown: ${JSON.stringify(t)}`;
+    } catch (e) {
+      return `Non-serializable object was thrown (JSON.stringify failed: ${e instanceof Error ? e.message : String(e)}): ${String(t)}`;
     }
-  return `Non-Error value (${typeof e}) was thrown: ${e}`;
+  return `Non-Error value (${typeof t}) was thrown: ${t}`;
 }
-function Ae(e) {
-  return e instanceof Error ? e : new Error(Y(e));
+function At(t) {
+  return t instanceof Error ? t : new Error(Q(t));
 }
-function P(e) {
-  const t = e.cause ? P(e.cause) : void 0, n = new Error(e.message, t !== void 0 ? { cause: t } : void 0);
-  return n.name = e.name || "Error", n.stack = e.stack, n;
+function k(t) {
+  const e = t.cause ? k(t.cause) : void 0, n = new Error(t.message, e !== void 0 ? { cause: e } : void 0);
+  return n.name = t.name || "Error", n.stack = t.stack, n;
 }
-function Pe(e) {
-  if (e.error)
-    throw e.error instanceof Error ? e.error : P(e.error);
-  return e.value;
+function Pt(t) {
+  if (t.error)
+    throw t.error instanceof Error ? t.error : k(t.error);
+  return t.value;
 }
 export {
-  ue as AnchoredIdDeriver,
-  C as PTableAbsent,
-  $ as PTableNA,
-  J as PValueBytesNA,
-  N as PValueIntNA,
-  b as PValueLongNA,
-  I as PValueStringNA,
-  Q as PlId,
+  ut as AnchoredIdDeriver,
+  N as PTableAbsent,
+  P as PTableNA,
+  G as PlId,
   z as PlIdBytes,
-  H as PlIdLength,
-  ie as canonicalizeAxisId,
-  ve as canonicalizeJson,
-  ne as dataInfoToEntries,
-  ye as deriveNativeId,
-  P as deserializeError,
-  Ae as ensureError,
-  de as ensurePColumn,
-  re as entriesToDataInfo,
-  pe as extractAllColumns,
-  L as getAxesId,
+  q as PlIdLength,
+  it as canonicalizeAxisId,
+  vt as canonicalizeJson,
+  et as dataInfoToEntries,
+  yt as deriveNativeId,
+  k as deserializeError,
+  At as ensureError,
+  dt as ensurePColumn,
+  nt as entriesToDataInfo,
+  pt as extractAllColumns,
+  $ as getAxesId,
   l as getAxisId,
-  ce as getPTableColumnId,
-  G as hasAbortError,
-  Z as isDataInfo,
-  S as isDataInfoEntries,
+  ct as getPTableColumnId,
+  H as hasAbortError,
+  Y as isDataInfo,
+  I as isDataInfoEntries,
   K as isPColumn,
   h as isPColumnSpec,
-  oe as isPTableAbsent,
-  te as isPartitionedDataInfoEntries,
-  he as isPlRef,
-  j as isValueAbsent,
-  O as isValueNA,
-  ee as mapDataInfo,
+  rt as isPTableAbsent,
+  j as isPTableNA,
+  ot as isPTableValueAxis,
+  tt as isPartitionedDataInfoEntries,
+  ht as isPlRef,
+  Z as mapDataInfo,
   y as mapJoinEntry,
-  le as mapPObjectData,
-  se as mapPTableDef,
-  ge as mapValueInVOE,
-  v as matchAxis,
-  B as matchAxisId,
-  x as matchPColumn,
-  ae as pTableValue,
-  xe as parseJson,
-  fe as resolveAnchors,
-  me as selectorsToPredicate,
-  D as stringifyColumnId,
-  we as uniquePlId,
-  Pe as unwrapResult,
-  be as withEnrichments
+  lt as mapPObjectData,
+  st as mapPTableDef,
+  gt as mapValueInVOE,
+  w as matchAxis,
+  L as matchAxisId,
+  v as matchPColumn,
+  at as pTableValue,
+  xt as parseJson,
+  ft as resolveAnchors,
+  mt as selectorsToPredicate,
+  B as stringifyColumnId,
+  wt as uniquePlId,
+  Pt as unwrapResult,
+  bt as withEnrichments
 };
 //# sourceMappingURL=index.js.map