@platforma-sdk/ui-vue 1.42.14 → 1.42.18

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

@@ -1,305 +1,456 @@
-import f from "../../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.js";
-import p from "../../../../_virtual/canonicalize.js";
-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({
+import o from "../../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.js";
+import g from "../../../../_virtual/canonicalize.js";
+var J = Object.defineProperty, I = (n, t, e) => t in n ? J(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, y = (n, t, e) => I(n, typeof t != "symbol" ? t + "" : t, e);
+o.object({
   /** Included left border. */
-  from: f.number(),
+  from: o.number(),
   /** Excluded right border. */
-  to: f.number()
+  to: o.number()
 });
-function x(t) {
-  throw new Error("Unexpected object: " + t);
+function w(n) {
+  throw new Error("Unexpected object: " + n);
 }
-function Y(t) {
-  if (!t || typeof t != "object")
+function cn(n) {
+  if (!n || typeof n != "object")
     return !1;
-  const e = t;
-  if (!("type" in e))
+  const t = n;
+  if (!("type" in t))
     return !1;
-  switch (e.type) {
+  switch (t.type) {
     case "Json":
-      return typeof e.keyLength == "number" && e.data !== void 0 && typeof e.data == "object";
+      return typeof t.keyLength == "number" && t.data !== void 0 && typeof t.data == "object";
     case "JsonPartitioned":
-      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
     case "BinaryPartitioned":
-      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
+    case "ParquetPartitioned":
+      return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
     default:
       return !1;
   }
 }
-function Z(t, e) {
-  if (t !== void 0)
-    switch (t.type) {
+function un(n, t) {
+  if (n !== void 0)
+    switch (n.type) {
       case "Json":
-        return t;
+        return n;
       case "JsonPartitioned": {
-        const n = {};
-        for (const [r, o] of Object.entries(t.parts))
-          n[r] = e(o);
+        const e = {};
+        for (const [r, a] of Object.entries(n.parts))
+          e[r] = t(a);
         return {
-          ...t,
-          parts: n
+          ...n,
+          parts: e
         };
       }
       case "BinaryPartitioned": {
-        const n = {};
-        for (const [r, o] of Object.entries(t.parts))
-          n[r] = {
-            index: e(o.index),
-            values: e(o.values)
+        const e = {};
+        for (const [r, a] of Object.entries(n.parts))
+          e[r] = {
+            index: t(a.index),
+            values: t(a.values)
           };
         return {
-          ...t,
-          parts: n
+          ...n,
+          parts: e
+        };
+      }
+      case "ParquetPartitioned": {
+        const e = {};
+        for (const [r, a] of Object.entries(n.parts))
+          e[r] = t(a);
+        return {
+          ...n,
+          parts: e
         };
       }
     }
 }
-function I(t) {
-  if (!t || typeof t != "object")
+function j(n) {
+  if (!n || typeof n != "object")
     return !1;
-  const e = t;
-  if (!("type" in e))
+  const t = n;
+  if (!("type" in t))
     return !1;
-  switch (e.type) {
+  switch (t.type) {
     case "Json":
-      return typeof e.keyLength == "number" && Array.isArray(e.data);
+      return typeof t.keyLength == "number" && Array.isArray(t.data);
     case "JsonPartitioned":
-      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
     case "BinaryPartitioned":
-      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
+    case "ParquetPartitioned":
+      return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
     default:
       return !1;
   }
 }
-function tt(t) {
-  return I(t) ? t.type === "JsonPartitioned" || t.type === "BinaryPartitioned" : !1;
+function fn(n) {
+  if (!j(n)) return !1;
+  switch (n.type) {
+    case "JsonPartitioned":
+    case "BinaryPartitioned":
+    case "ParquetPartitioned":
+      return !0;
+    default:
+      return !1;
+  }
 }
-function et(t) {
-  switch (t.type) {
-    case "Json": {
-      const e = Object.entries(t.data).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+function ln(n) {
+  switch (n.type) {
+    case "Json":
       return {
         type: "Json",
-        keyLength: t.keyLength,
-        data: e
+        keyLength: n.keyLength,
+        data: Object.entries(n.data).map(([t, e]) => ({ key: JSON.parse(t), value: e }))
       };
-    }
-    case "JsonPartitioned": {
-      const e = Object.entries(t.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+    case "JsonPartitioned":
       return {
         type: "JsonPartitioned",
-        partitionKeyLength: t.partitionKeyLength,
-        parts: e
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.entries(n.parts).map(([t, e]) => ({ key: JSON.parse(t), value: e }))
       };
-    }
-    case "BinaryPartitioned": {
-      const e = Object.entries(t.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+    case "BinaryPartitioned":
       return {
         type: "BinaryPartitioned",
-        partitionKeyLength: t.partitionKeyLength,
-        parts: e
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.entries(n.parts).map(([t, e]) => ({ key: JSON.parse(t), value: e }))
       };
-    }
+    case "ParquetPartitioned":
+      return {
+        type: "ParquetPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.entries(n.parts).map(([t, e]) => ({ key: JSON.parse(t), value: e }))
+      };
+    default:
+      w(n);
   }
 }
-function nt(t) {
-  switch (t.type) {
-    case "Json": {
-      const e = {};
-      for (const n of t.data)
-        e[JSON.stringify(n.key)] = n.value;
+function pn(n) {
+  switch (n.type) {
+    case "Json":
       return {
         type: "Json",
-        keyLength: t.keyLength,
-        data: e
+        keyLength: n.keyLength,
+        data: Object.fromEntries(
+          n.data.map(({ key: t, value: e }) => [JSON.stringify(t), e])
+        )
       };
-    }
-    case "JsonPartitioned": {
-      const e = {};
-      for (const n of t.parts)
-        e[JSON.stringify(n.key)] = n.value;
+    case "JsonPartitioned":
       return {
         type: "JsonPartitioned",
-        partitionKeyLength: t.partitionKeyLength,
-        parts: e
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.fromEntries(
+          n.parts.map(({ key: t, value: e }) => [JSON.stringify(t), e])
+        )
       };
-    }
-    case "BinaryPartitioned": {
-      const e = {};
-      for (const n of t.parts)
-        e[JSON.stringify(n.key)] = n.value;
+    case "BinaryPartitioned":
       return {
         type: "BinaryPartitioned",
-        partitionKeyLength: t.partitionKeyLength,
-        parts: e
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.fromEntries(
+          n.parts.map(({ key: t, value: e }) => [JSON.stringify(t), e])
+        )
       };
+    case "ParquetPartitioned":
+      return {
+        type: "ParquetPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.fromEntries(
+          n.parts.map(({ key: t, value: e }) => [JSON.stringify(t), e])
+        )
+      };
+    default:
+      w(n);
+  }
+}
+function N(n) {
+  return n instanceof Error ? n.name === "AbortError" || N(n.cause) : !1;
+}
+function L(n) {
+  if (typeof n == "string")
+    return `String value was thrown: ${n}`;
+  if (n && typeof n == "object")
+    try {
+      return `Plain object was thrown: ${JSON.stringify(n)}`;
+    } catch (t) {
+      return `Non-serializable object was thrown (JSON.stringify failed: ${t instanceof Error ? t.message : String(t)}): ${String(n)}`;
     }
+  return `Non-Error value (${typeof n}) was thrown: ${n}`;
+}
+function T(n) {
+  return n instanceof Error ? n : new Error(L(n));
+}
+function E(n) {
+  const t = n.cause ? E(n.cause) : void 0, e = new Error(n.message, t !== void 0 ? { cause: t } : void 0);
+  return e.name = n.name || "Error", e.stack = n.stack, e;
+}
+function dn(n) {
+  if (n.error)
+    throw n.error instanceof Error ? n.error : E(n.error);
+  return n.value;
+}
+function mn(n) {
+  return JSON.stringify(n);
+}
+function C(n) {
+  return g(n);
+}
+function yn(n) {
+  return JSON.parse(n);
+}
+const l = {
+  Int: "Int",
+  Long: "Long",
+  Float: "Float",
+  Double: "Double",
+  String: "String",
+  Bytes: "Bytes"
+};
+function v(n, t) {
+  return n == null ? void 0 : n[t];
+}
+function $(n, t, e, r = "readMetadataJsonOrThrow") {
+  const a = v(n, e);
+  if (a === void 0) return;
+  const c = t[e];
+  try {
+    const i = JSON.parse(a);
+    return c.parse(i);
+  } catch (i) {
+    throw new Error(
+      `${r} failed, key: ${String(e)}, value: ${a}, error: ${T(i)}`
+    );
+  }
+}
+function D(n, t, e) {
+  try {
+    return $(n, t, e);
+  } catch {
+    return;
   }
 }
-function A(t, e) {
-  const n = Math.floor(e / 8), r = 1 << 7 - e % 8;
-  return (t[n] & r) > 0;
+const hn = {
+  Alphabet: "pl7.app/alphabet"
+};
+function bn(n, t) {
+  return v(n == null ? void 0 : n.domain, t);
+}
+const p = {
+  Alphabet: "pl7.app/alphabet",
+  DiscreteValues: "pl7.app/discreteValues",
+  Format: "pl7.app/format",
+  Graph: {
+    IsVirtual: "pl7.app/graph/isVirtual"
+  },
+  HideDataFromUi: "pl7.app/hideDataFromUi",
+  IsLinkerColumn: "pl7.app/isLinkerColumn",
+  Label: "pl7.app/label",
+  Max: "pl7.app/max",
+  Min: "pl7.app/min",
+  Parents: "pl7.app/parents",
+  Sequence: {
+    Annotation: {
+      Mapping: "pl7.app/sequence/annotation/mapping"
+    },
+    IsAnnotation: "pl7.app/sequence/isAnnotation"
+  },
+  Table: {
+    FontFamily: "pl7.app/table/fontFamily",
+    OrderPriority: "pl7.app/table/orderPriority",
+    Visibility: "pl7.app/table/visibility"
+  },
+  Trace: "pl7.app/trace"
+}, F = o.object({
+  type: o.nativeEnum(l),
+  name: o.string(),
+  domain: o.record(o.string(), o.string()).optional(),
+  annotations: o.record(o.string(), o.string()).optional(),
+  parentAxes: o.array(o.number()).optional()
+}).passthrough(), M = {
+  [p.DiscreteValues]: o.array(o.string()).or(o.array(o.number())),
+  [p.Graph.IsVirtual]: o.boolean(),
+  [p.HideDataFromUi]: o.boolean(),
+  [p.IsLinkerColumn]: o.boolean(),
+  [p.Max]: o.number(),
+  [p.Min]: o.number(),
+  [p.Parents]: o.array(F),
+  [p.Sequence.Annotation.Mapping]: o.record(o.string(), o.string()),
+  [p.Sequence.IsAnnotation]: o.boolean(),
+  [p.Table.OrderPriority]: o.number(),
+  [p.Trace]: o.record(o.string(), o.unknown())
+};
+function gn(n, t) {
+  return v(n == null ? void 0 : n.annotations, t);
+}
+function wn(n, t) {
+  return D(n == null ? void 0 : n.annotations, M, t);
 }
-function J(t, e) {
-  return A(t.absent, e);
+const vn = {
+  Label: "pl7.app/label",
+  Table: {
+    RowSelection: "pl7.app/table/row-selection"
+  }
+};
+function m(n) {
+  const { type: t, name: e, domain: r } = n, a = { type: t, name: e };
+  return r && Object.entries(r).length > 0 && Object.assign(a, { domain: r }), a;
 }
-function O(t, e) {
-  if (t.isNA) return A(t.isNA, e);
-  const n = t.type, r = t.data[e];
-  switch (n) {
-    case "Int":
+function B(n) {
+  return n.map(m);
+}
+function Pn(n) {
+  return C(m(n));
+}
+function R(n, t) {
+  if (n === void 0) return t === void 0;
+  if (t === void 0) return !0;
+  for (const e in t)
+    if (n[e] !== t[e]) return !1;
+  return !0;
+}
+function V(n, t) {
+  return n.name === t.name && R(n.domain, t.domain);
+}
+function S(n, t) {
+  const e = Math.floor(t / 8), r = 1 << 7 - t % 8;
+  return (n[e] & r) > 0;
+}
+function q(n, t) {
+  return S(n.absent, t);
+}
+function U(n, t) {
+  if (n.isNA) return S(n.isNA, t);
+  const e = n.type, r = n.data[t];
+  switch (e) {
+    case l.Int:
       return r === -2147483648;
-    case "Long":
+    case l.Long:
       return r === -9007199254740991n;
-    case "Float":
+    case l.Float:
       return Number.isNaN(r);
-    case "Double":
+    case l.Double:
       return Number.isNaN(r);
-    case "String":
+    case l.String:
       return r === null;
-    case "Bytes":
+    case l.Bytes:
       return r === null;
     default:
-      throw Error(`unsupported data type: ${n}`);
+      throw Error(`unsupported data type: ${e}`);
   }
 }
-const N = { type: "absent" };
-function rt(t) {
-  return typeof t == "object" && t !== null && "type" in t && t.type === "absent";
+const K = { type: "absent" };
+function xn(n) {
+  return typeof n == "object" && n !== null && "type" in n && n.type === "absent";
 }
-const P = null;
-function j(t) {
-  return t === P;
+const O = null;
+function G(n) {
+  return n === O;
 }
-function ot(t, e) {
-  return !j(t);
+function An(n, t) {
+  return !G(n);
 }
-function C(t, e, n) {
-  const r = t.type;
-  if (r === "Bytes")
+function H(n, t, e) {
+  const r = n.type;
+  if (r === l.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];
+  if (e && "dataType" in e && e.dataType !== void 0 && e.dataType !== r)
+    throw Error(`expected column of type ${e.dataType}, got ${r}`);
+  if (q(n, t))
+    return (e == null ? void 0 : e.absent) !== void 0 ? e.absent : K;
+  if (U(n, t))
+    return (e == null ? void 0 : e.na) !== void 0 ? e.na : O;
+  const a = n.data[t];
   switch (r) {
-    case "Int":
-      return o;
-    case "Long":
-      return Number(o);
-    case "Float":
-      return o;
-    case "Double":
-      return o;
-    case "String":
-      return o;
+    case l.Int:
+      return a;
+    case l.Long:
+      return Number(a);
+    case l.Float:
+      return a;
+    case l.Double:
+      return a;
+    case l.String:
+      return a;
   }
 }
-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 kn(n, t, e) {
+  return H(n, t, e);
 }
-function $(t) {
-  return t.map(l);
+function En(n, t) {
+  return { ...n, src: h(n.src, t) };
 }
-function it(t) {
-  return p(l(t));
-}
-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 L(t, e) {
-  return t.name === e.name && T(t.domain, e.domain);
-}
-function st(t, e) {
-  return { ...t, src: y(t.src, e) };
-}
-function y(t, e) {
-  switch (t.type) {
+function h(n, t) {
+  switch (n.type) {
     case "column":
       return {
         type: "column",
-        column: e(t.column)
+        column: t(n.column)
       };
     case "slicedColumn":
       return {
         type: "slicedColumn",
-        column: e(t.column),
-        newId: t.newId,
-        axisFilters: t.axisFilters
+        column: t(n.column),
+        newId: n.newId,
+        axisFilters: n.axisFilters
       };
     case "inlineColumn":
-      return t;
+      return n;
     case "inner":
     case "full":
       return {
-        type: t.type,
-        entries: t.entries.map((n) => y(n, e))
+        type: n.type,
+        entries: n.entries.map((e) => h(e, t))
       };
     case "outer":
       return {
         type: "outer",
-        primary: y(t.primary, e),
-        secondary: t.secondary.map((n) => y(n, e))
+        primary: h(n.primary, t),
+        secondary: n.secondary.map((e) => h(e, t))
       };
     default:
-      x(t);
+      w(n);
   }
 }
-function ct(t) {
-  switch (t.type) {
+function Sn(n) {
+  switch (n.type) {
     case "axis":
       return {
         type: "axis",
-        id: t.id
+        id: n.id
       };
     case "column":
       return {
         type: "column",
-        id: t.id
+        id: n.id
       };
   }
 }
-function B(t) {
-  return p(t);
+function _(n) {
+  return g(n);
 }
-function b(t) {
-  return p(l(t));
+function P(n) {
+  return g(m(n));
 }
-function g(t, e) {
-  return JSON.stringify([t, e]);
+function x(n, t) {
+  return JSON.stringify([n, t]);
 }
-class ut {
+class On {
   /**
    * Creates a new anchor context from a set of anchor column specifications
    * @param anchors Record of anchor column specifications indexed by anchor ID
    */
-  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 = b(i);
-        this.axes.set(a, { anchor: r, idx: s });
+  constructor(t) {
+    y(this, "domains", /* @__PURE__ */ new Map()), y(this, "axes", /* @__PURE__ */ new Map()), y(this, "domainPacks", []), y(this, "domainPackToAnchor", /* @__PURE__ */ new Map()), this.anchors = t;
+    const e = Object.entries(t);
+    e.sort((r, a) => r[0].localeCompare(a[0]));
+    for (const [r, a] of e) {
+      for (let c = 0; c < a.axesSpec.length; c++) {
+        const i = a.axesSpec[c], s = P(i);
+        this.axes.set(s, { anchor: r, idx: c });
       }
-      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 = g(i, a);
-          this.domains.set(c, r);
+      if (a.domain !== void 0) {
+        const c = Object.entries(a.domain);
+        c.sort((i, s) => i[0].localeCompare(s[0])), this.domainPackToAnchor.set(JSON.stringify(c), r), this.domainPacks.push(c.map(([i]) => i));
+        for (const [i, s] of c) {
+          const u = x(i, s);
+          this.domains.set(u, r);
         }
       }
     }
@@ -307,57 +458,57 @@ class ut {
   /**
    * Implementation of derive method
    */
-  derive(e, n) {
+  derive(t, e) {
     const r = {
-      name: e.name,
+      name: t.name,
       axes: []
     };
-    let o;
-    if (e.domain !== void 0)
-      t:
+    let a;
+    if (t.domain !== void 0)
+      n:
         for (const i of this.domainPacks) {
-          const a = [];
-          for (const u of i) {
-            const d = e.domain[u];
+          const s = [];
+          for (const f of i) {
+            const d = t.domain[f];
             if (d !== void 0)
-              a.push([u, d]);
+              s.push([f, d]);
             else
-              break t;
+              break n;
           }
-          const c = this.domainPackToAnchor.get(JSON.stringify(a));
-          if (c !== void 0) {
-            r.domainAnchor = c, o = new Set(i);
+          const u = this.domainPackToAnchor.get(JSON.stringify(s));
+          if (u !== void 0) {
+            r.domainAnchor = u, a = new Set(i);
             break;
           }
         }
-    for (const [i, a] of Object.entries(e.domain ?? {})) {
-      if (o !== void 0 && o.has(i))
+    for (const [i, s] of Object.entries(t.domain ?? {})) {
+      if (a !== void 0 && a.has(i))
         continue;
-      const c = g(i, a), u = this.domains.get(c);
-      r.domain ?? (r.domain = {}), r.domain[i] = u ? { anchor: u } : a;
+      const u = x(i, s), f = this.domains.get(u);
+      r.domain ?? (r.domain = {}), r.domain[i] = f ? { anchor: f } : s;
     }
-    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)
+    if (r.axes = t.axesSpec.map((i) => {
+      const s = P(i), u = this.axes.get(s);
+      return u === void 0 ? m(i) : u;
+    }), !e || e.length === 0)
       return r;
-    const s = [];
-    for (const i of n) {
-      const [a, c] = i;
-      if (typeof a == "number") {
-        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]);
+    const c = [];
+    for (const i of e) {
+      const [s, u] = i;
+      if (typeof s == "number") {
+        if (s < 0 || s >= t.axesSpec.length)
+          throw new Error(`Axis index ${s} is out of bounds (0-${t.axesSpec.length - 1})`);
+        c.push([s, u]);
       } else {
-        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]);
+        const f = t.axesSpec.findIndex((d) => d.name === s);
+        if (f === -1)
+          throw new Error(`Axis with name "${s}" not found in the column specification`);
+        c.push([f, u]);
       }
     }
-    return s.sort((i, a) => i[0] - a[0]), {
+    return c.sort((i, s) => i[0] - s[0]), {
       source: r,
-      axisFilters: s
+      axisFilters: c
     };
   }
   /**
@@ -366,326 +517,307 @@ class ut {
    * @param axisFilters Optional axis filters to apply to the column
    * @returns A canonicalized string representation of the anchored column identifier
    */
-  deriveS(e, n) {
-    return B(this.derive(e, n));
+  deriveS(t, e) {
+    return _(this.derive(t, e));
   }
 }
-function ft(t, e, n) {
-  const r = { ...e }, o = (n == null ? void 0 : n.ignoreMissingDomains) ?? !1;
+function Jn(n, t, e) {
+  const r = { ...t }, a = (e == null ? void 0 : e.ignoreMissingDomains) ?? !1;
   if (r.domainAnchor !== void 0) {
-    const s = t[r.domainAnchor];
-    if (!s)
+    const c = n[r.domainAnchor];
+    if (!c)
       throw new Error(`Anchor "${r.domainAnchor}" not found`);
-    const i = s.domain || {};
+    const i = c.domain || {};
     r.domain = { ...i, ...r.domain }, delete r.domainAnchor;
   }
   if (r.domain) {
-    const s = {};
-    for (const [i, a] of Object.entries(r.domain))
-      if (typeof a == "string")
-        s[i] = a;
+    const c = {};
+    for (const [i, s] of Object.entries(r.domain))
+      if (typeof s == "string")
+        c[i] = s;
       else {
-        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) {
-          if (!o)
-            throw new Error(`Domain key "${i}" not found in anchor "${a.anchor}"`);
+        const u = n[s.anchor];
+        if (!u)
+          throw new Error(`Anchor "${s.anchor}" not found for domain key "${i}"`);
+        if (!u.domain || u.domain[i] === void 0) {
+          if (!a)
+            throw new Error(`Domain key "${i}" not found in anchor "${s.anchor}"`);
           continue;
         }
-        s[i] = c.domain[i];
+        c[i] = u.domain[i];
       }
-    r.domain = s;
+    r.domain = c;
   }
-  return r.axes && (r.axes = r.axes.map((s) => R(t, s))), r;
+  return r.axes && (r.axes = r.axes.map((c) => z(n, c))), r;
 }
-function R(t, e) {
-  if (!D(e))
-    return e;
-  const n = e.anchor, r = t[n];
+function z(n, t) {
+  if (!X(t))
+    return t;
+  const e = t.anchor, r = n[e];
   if (!r)
-    throw new Error(`Anchor "${n}" not found for axis reference`);
-  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 "${e.name}" found in anchor "${n}"`);
-    if (o.length === 0)
-      throw new Error(`Axis with name "${e.name}" not found in anchor "${n}"`);
-    return o[0];
-  } 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)
-      throw new Error(`No matching axis found for matcher in anchor "${n}"`);
-    return o[0];
+    throw new Error(`Anchor "${e}" 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 "${e}"`);
+    return r.axesSpec[t.idx];
+  } else if ("name" in t) {
+    const a = r.axesSpec.filter((c) => c.name === t.name);
+    if (a.length > 1)
+      throw new Error(`Multiple axes with name "${t.name}" found in anchor "${e}"`);
+    if (a.length === 0)
+      throw new Error(`Axis with name "${t.name}" not found in anchor "${e}"`);
+    return a[0];
+  } else if ("id" in t) {
+    const a = r.axesSpec.filter((c) => V(t.id, m(c)));
+    if (a.length > 1)
+      throw new Error(`Multiple matching axes found for matcher in anchor "${e}"`);
+    if (a.length === 0)
+      throw new Error(`No matching axis found for matcher in anchor "${e}"`);
+    return a[0];
   }
   throw new Error("Unsupported axis reference type");
 }
-function D(t) {
-  return typeof t == "object" && "anchor" in t;
+function X(n) {
+  return typeof n == "object" && "anchor" in n;
 }
-function h(t) {
-  return t.kind === "PColumn";
+function b(n) {
+  return n.kind === "PColumn";
 }
-function K(t) {
-  return h(t.spec);
+function Q(n) {
+  return b(n.spec);
 }
-function dt(t) {
-  if (!K(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
-  return t;
+function In(n) {
+  if (!Q(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
+  return n;
 }
-function lt(t, e) {
-  return t === void 0 ? void 0 : {
-    ...t,
-    data: e(t.data)
+function jn(n, t) {
+  return n === void 0 ? void 0 : {
+    ...n,
+    data: t(n.data)
   };
 }
-function pt(t) {
-  const e = /* @__PURE__ */ new Map(), n = (r) => {
+function Nn(n) {
+  const t = /* @__PURE__ */ new Map(), e = (r) => {
     switch (r.type) {
       case "column":
-        e.set(r.column.id, r.column);
+        t.set(r.column.id, r.column);
         return;
       case "slicedColumn":
-        e.set(r.column.id, r.column);
+        t.set(r.column.id, r.column);
         return;
       case "inlineColumn":
         return;
       case "full":
       case "inner":
-        for (const o of r.entries) n(o);
+        for (const a of r.entries) e(a);
         return;
       case "outer":
-        n(r.primary);
-        for (const o of r.secondary) n(o);
+        e(r.primary);
+        for (const a of r.secondary) e(a);
         return;
       default:
-        x(r);
+        w(r);
     }
   };
-  return n(t), [...e.values()];
+  return e(n), [...t.values()];
 }
-function w(t, e) {
-  if (t.name !== void 0 && t.name !== e.name)
+function A(n, t) {
+  if (n.name !== void 0 && n.name !== t.name)
     return !1;
-  if (t.type !== void 0) {
-    if (Array.isArray(t.type)) {
-      if (!t.type.includes(e.type))
+  if (n.type !== void 0) {
+    if (Array.isArray(n.type)) {
+      if (!n.type.includes(t.type))
         return !1;
-    } else if (t.type !== e.type)
+    } else if (n.type !== t.type)
       return !1;
   }
-  if (t.domain !== void 0) {
-    const n = e.domain || {};
-    for (const [r, o] of Object.entries(t.domain))
-      if (n[r] !== o)
+  if (n.domain !== void 0) {
+    const e = t.domain || {};
+    for (const [r, a] of Object.entries(n.domain))
+      if (e[r] !== a)
         return !1;
   }
   return !0;
 }
-function v(t, e) {
-  if (e.name !== void 0 && t.name !== e.name || e.namePattern !== void 0 && !new RegExp(e.namePattern).test(t.name))
+function k(n, t) {
+  if (t.name !== void 0 && n.name !== t.name || t.namePattern !== void 0 && !new RegExp(t.namePattern).test(n.name))
     return !1;
-  if (e.type !== void 0) {
-    if (Array.isArray(e.type)) {
-      if (!e.type.includes(t.valueType))
+  if (t.type !== void 0) {
+    if (Array.isArray(t.type)) {
+      if (!t.type.includes(n.valueType))
         return !1;
-    } else if (e.type !== t.valueType)
+    } else if (t.type !== n.valueType)
       return !1;
   }
-  if (e.domain !== void 0) {
-    const n = t.domain || {};
-    for (const [r, o] of Object.entries(e.domain))
-      if (n[r] !== o)
+  if (t.domain !== void 0) {
+    const e = n.domain || {};
+    for (const [r, a] of Object.entries(t.domain))
+      if (e[r] !== a)
         return !1;
   }
-  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)))
+  if (t.axes !== void 0) {
+    const e = n.axesSpec.map(m);
+    if (t.partialAxesMatch) {
+      for (const r of t.axes)
+        if (!e.some((a) => A(r, a)))
           return !1;
     } else {
-      if (n.length !== e.axes.length)
+      if (e.length !== t.axes.length)
         return !1;
-      for (let r = 0; r < e.axes.length; r++)
-        if (!w(e.axes[r], n[r]))
+      for (let r = 0; r < t.axes.length; r++)
+        if (!A(t.axes[r], e[r]))
           return !1;
     }
   }
-  if (e.annotations !== void 0) {
-    const n = t.annotations || {};
-    for (const [r, o] of Object.entries(e.annotations))
-      if (n[r] !== o)
+  if (t.annotations !== void 0) {
+    const e = n.annotations || {};
+    for (const [r, a] of Object.entries(t.annotations))
+      if (e[r] !== a)
         return !1;
   }
-  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))
+  if (t.annotationPatterns !== void 0) {
+    const e = n.annotations || {};
+    for (const [r, a] of Object.entries(t.annotationPatterns)) {
+      const c = e[r];
+      if (c === void 0 || !new RegExp(a).test(c))
         return !1;
     }
   }
   return !0;
 }
-function mt(t) {
-  return Array.isArray(t) ? (e) => t.some((n) => h(e) && v(e, n)) : (e) => h(e) && v(e, t);
+function Ln(n) {
+  return Array.isArray(n) ? (t) => n.some((e) => b(t) && k(t, e)) : (t) => b(t) && k(t, n);
 }
-function yt(t) {
-  const e = {
-    kind: t.kind,
-    name: t.name
+function Tn(n) {
+  const t = {
+    kind: n.kind,
+    name: n.name
   };
-  return t.domain !== void 0 && (e.domain = t.domain), h(t) && (e.axesSpec = $(t.axesSpec)), p(e);
+  return n.domain !== void 0 && (t.domain = n.domain), b(n) && (t.axesSpec = B(n.axesSpec)), g(t);
 }
-f.object({
-  __isRef: f.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: f.string().describe("Upstream block id"),
-  name: f.string().describe("Name of the output provided to the upstream block's output context"),
-  requireEnrichments: f.literal(!0).optional().describe("True if current block that stores this reference in its args, may need enrichments for the references value originating from the blocks in between current and referenced block")
+o.object({
+  __isRef: o.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: o.string().describe("Upstream block id"),
+  name: o.string().describe("Name of the output provided to the upstream block's output context"),
+  requireEnrichments: o.literal(!0).optional().describe("True if current block that stores this reference in its args, may need enrichments for the references value originating from the blocks in between current and referenced block")
 }).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 ht(t) {
-  return typeof t == "object" && t !== null && "__isRef" in t && t.__isRef === !0 && "blockId" in t && "name" in t;
+function Cn(n) {
+  return typeof n == "object" && n !== null && "__isRef" in n && n.__isRef === !0 && "blockId" in n && "name" in n;
 }
-function bt(t, e = !0) {
-  if (e)
+function $n(n, t = !0) {
+  if (t)
     return {
-      ...t,
+      ...n,
       requireEnrichments: !0
     };
   {
-    const { requireEnrichments: n, ...r } = t;
+    const { requireEnrichments: e, ...r } = n;
     return r;
   }
 }
-function gt(t, e) {
-  return t.ok ? { ok: !0, value: e(t.value) } : t;
+function Dn(n, t) {
+  return n.ok ? { ok: !0, value: t(n.value) } : n;
 }
-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);
+function Y(n) {
+  if (n instanceof Int8Array || n instanceof Uint8Array || n instanceof Uint8ClampedArray)
+    return new DataView(n.buffer, n.byteOffset, n.byteLength);
+  if (n instanceof ArrayBuffer) return new DataView(n);
   throw new TypeError(
     "Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray"
   );
 }
-const U = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", M = "0123456789ABCDEFGHIJKLMNOPQRSTUV", V = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-function _(t, e, n) {
-  n = n || {};
-  let r, o;
-  switch (e) {
+const Z = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", W = "0123456789ABCDEFGHIJKLMNOPQRSTUV", nn = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function tn(n, t, e) {
+  e = e || {};
+  let r, a;
+  switch (t) {
     case "RFC3548":
     case "RFC4648":
-      r = U, o = !0;
+      r = Z, a = !0;
       break;
     case "RFC4648-HEX":
-      r = M, o = !0;
+      r = W, a = !0;
       break;
     case "Crockford":
-      r = V, o = !1;
+      r = nn, a = !1;
       break;
     default:
-      throw new Error("Unknown base32 variant: " + String(e));
+      throw new Error("Unknown base32 variant: " + String(t));
   }
-  const s = n.padding !== void 0 ? n.padding : o, i = F(t);
-  let a = 0, c = 0, u = "";
+  const c = e.padding !== void 0 ? e.padding : a, i = Y(n);
+  let s = 0, u = 0, f = "";
   for (let d = 0; d < i.byteLength; d++)
-    for (c = c << 8 | i.getUint8(d), a += 8; a >= 5; )
-      u += r[c >>> a - 5 & 31], a -= 5;
-  if (a > 0 && (u += r[c << 5 - a & 31]), s)
-    for (; u.length % 8 !== 0; )
-      u += "=";
-  return u;
-}
-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 vt(t) {
-  return p(t);
-}
-function xt(t) {
-  return JSON.parse(t);
-}
-function H(t) {
-  return t instanceof Error ? t.name === "AbortError" || H(t.cause) : !1;
-}
-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(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 t}) was thrown: ${t}`;
-}
-function At(t) {
-  return t instanceof Error ? t : new Error(Q(t));
-}
-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 Pt(t) {
-  if (t.error)
-    throw t.error instanceof Error ? t.error : k(t.error);
-  return t.value;
+    for (u = u << 8 | i.getUint8(d), s += 8; s >= 5; )
+      f += r[u >>> s - 5 & 31], s -= 5;
+  if (s > 0 && (f += r[u << 5 - s & 31]), c)
+    for (; f.length % 8 !== 0; )
+      f += "=";
+  return f;
+}
+const en = 15, rn = 24, an = o.string().length(rn).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function Fn() {
+  const n = new Uint8Array(en);
+  return crypto.getRandomValues(n), an.parse(tn(n, "RFC4648"));
 }
 export {
-  ut as AnchoredIdDeriver,
-  N as PTableAbsent,
-  P as PTableNA,
-  G as PlId,
-  z as PlIdBytes,
-  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,
-  ct as getPTableColumnId,
-  H as hasAbortError,
-  Y as isDataInfo,
-  I as isDataInfoEntries,
-  K as isPColumn,
-  h as isPColumnSpec,
-  rt as isPTableAbsent,
-  j as isPTableNA,
-  ot as isPTableValueAxis,
-  tt as isPartitionedDataInfoEntries,
-  ht as isPlRef,
-  Z as mapDataInfo,
-  y as mapJoinEntry,
-  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
+  On as AnchoredIdDeriver,
+  p as Annotation,
+  M as AnnotationJson,
+  F as AxisSpec,
+  hn as Domain,
+  vn as PColumnName,
+  K as PTableAbsent,
+  O as PTableNA,
+  an as PlId,
+  en as PlIdBytes,
+  rn as PlIdLength,
+  l as ValueType,
+  Pn as canonicalizeAxisId,
+  C as canonicalizeJson,
+  ln as dataInfoToEntries,
+  Tn as deriveNativeId,
+  E as deserializeError,
+  T as ensureError,
+  In as ensurePColumn,
+  pn as entriesToDataInfo,
+  Nn as extractAllColumns,
+  B as getAxesId,
+  m as getAxisId,
+  Sn as getPTableColumnId,
+  N as hasAbortError,
+  cn as isDataInfo,
+  j as isDataInfoEntries,
+  Q as isPColumn,
+  b as isPColumnSpec,
+  xn as isPTableAbsent,
+  G as isPTableNA,
+  An as isPTableValueAxis,
+  fn as isPartitionedDataInfoEntries,
+  Cn as isPlRef,
+  un as mapDataInfo,
+  h as mapJoinEntry,
+  jn as mapPObjectData,
+  En as mapPTableDef,
+  Dn as mapValueInVOE,
+  A as matchAxis,
+  V as matchAxisId,
+  k as matchPColumn,
+  kn as pTableValue,
+  yn as parseJson,
+  gn as readAnnotation,
+  wn as readAnnotationJson,
+  bn as readDomain,
+  v as readMetadata,
+  D as readMetadataJson,
+  $ as readMetadataJsonOrThrow,
+  Jn as resolveAnchors,
+  Ln as selectorsToPredicate,
+  _ as stringifyColumnId,
+  mn as stringifyJson,
+  Fn as uniquePlId,
+  dn as unwrapResult,
+  $n as withEnrichments
 };
 //# sourceMappingURL=index.js.map