@milaboratories/pl-model-common 1.10.6 → 1.11.0

package/dist/index.mjs

@@ -1,144 +1,148 @@
-import { z as a } from "zod";
-function Z(t) {
-  return t !== void 0 && t.startsWith("log+live://log/");
-}
-function b(t) {
-  throw new Error("Unexpected object: " + t);
-}
-const w = "upload://upload/", h = "index://index/";
-function E(t) {
-  return t.startsWith(w);
-}
-function I(t) {
-  return t.startsWith(h);
-}
-function C(t) {
-  if (I(t)) {
-    const n = t.slice(h.length);
-    return JSON.parse(decodeURIComponent(n)).path;
-  } else if (E(t)) {
-    const n = t.slice(w.length);
-    return JSON.parse(decodeURIComponent(n)).localPath;
+var $ = Object.defineProperty;
+var F = (n, t, e) => t in n ? $(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var d = (n, t, e) => F(n, typeof t != "symbol" ? t + "" : t, e);
+import k from "canonicalize";
+import { z as m } from "zod";
+function un(n) {
+  return n !== void 0 && n.startsWith("log+live://log/");
+}
+function g(n) {
+  throw new Error("Unexpected object: " + n);
+}
+const I = "upload://upload/", N = "index://index/";
+function D(n) {
+  return n.startsWith(I);
+}
+function U(n) {
+  return n.startsWith(N);
+}
+function O(n) {
+  if (U(n)) {
+    const t = n.slice(N.length);
+    return JSON.parse(decodeURIComponent(t)).path;
+  } else if (D(n)) {
+    const t = n.slice(I.length);
+    return JSON.parse(decodeURIComponent(t)).localPath;
   }
-  b(t);
+  g(n);
 }
-function V(t) {
-  return t.replace(/^.*[\\/]/, "");
+function B(n) {
+  return n.replace(/^.*[\\/]/, "");
 }
-function z(t) {
-  return V(C(t));
+function dn(n) {
+  return B(O(n));
 }
-const F = -2147483648, g = -9007199254740991n, x = NaN, R = NaN, U = null, k = null;
-function d(t, n) {
-  switch (n) {
+const R = -2147483648, w = -9007199254740991n, j = NaN, L = NaN, M = null, _ = null;
+function p(n, t) {
+  switch (t) {
     case "Int":
-      return t === F;
+      return n === R;
     case "Long":
-      return t === Number(g) || t === g;
+      return n === Number(w) || n === w;
     case "Float":
-      return t === x;
+      return n === j;
     case "Double":
-      return t === R;
+      return n === L;
     case "String":
-      return t === U;
+      return n === M;
     case "Bytes":
-      return t === k;
+      return n === _;
     default:
-      throw Error(`unsupported data type: ${n}`);
+      throw Error(`unsupported data type: ${t}`);
   }
 }
-function q(t) {
-  if (!B(t)) throw new Error(`Expected not-NA PValue, got ${t}`);
-  return t;
+function mn(n) {
+  if (!H(n)) throw new Error(`Expected not-NA PValue, got ${n}`);
+  return n;
 }
-function B(t, n) {
-  if (!n)
-    return typeof t == "string" || typeof t == "number" && isFinite(t) || typeof t == "bigint";
-  if (d(t, n)) return !1;
-  switch (n) {
+function H(n, t) {
+  if (!t)
+    return typeof n == "string" || typeof n == "number" && isFinite(n) || typeof n == "bigint";
+  if (p(n, t)) return !1;
+  switch (t) {
     case "Int":
-      return typeof t == "number";
+      return typeof n == "number";
     case "Long":
-      return typeof t == "number" || typeof t == "bigint";
+      return typeof n == "number" || typeof n == "bigint";
     case "Float":
-      return typeof t == "number";
+      return typeof n == "number";
     case "Double":
-      return typeof t == "number";
+      return typeof n == "number";
     case "String":
-      return typeof t == "string";
+      return typeof n == "string";
     case "Bytes":
       throw Error("Bytes not yet supported");
     default:
-      throw Error(`unsupported data type: ${n}`);
+      throw Error(`unsupported data type: ${t}`);
   }
 }
-function S(t, n) {
-  if (!n)
-    return t === null || typeof t == "string" || typeof t == "number" || typeof t == "bigint";
-  if (d(t, n)) return !0;
-  switch (n) {
+function J(n, t) {
+  if (!t)
+    return n === null || typeof n == "string" || typeof n == "number" || typeof n == "bigint";
+  if (p(n, t)) return !0;
+  switch (t) {
     case "Int":
-      return typeof t == "number";
+      return typeof n == "number";
     case "Long":
-      return typeof t == "number" || typeof t == "bigint";
+      return typeof n == "number" || typeof n == "bigint";
     case "Float":
-      return typeof t == "number";
+      return typeof n == "number";
     case "Double":
-      return typeof t == "number";
+      return typeof n == "number";
     case "String":
-      return typeof t == "string";
+      return typeof n == "string";
     case "Bytes":
       throw Error("Bytes not yet supported");
     default:
-      throw Error(`unsupported data type: ${n}`);
+      throw Error(`unsupported data type: ${t}`);
   }
 }
-function v(t) {
-  if (t === null || typeof t == "string" || typeof t == "number") return t;
-  if (typeof t == "bigint") return { bigint: t.toString() };
-  throw new Error(`Type ${typeof t} (value ${t}) not yet supported.`);
+function ln(n) {
+  if (n === null || typeof n == "string" || typeof n == "number") return n;
+  if (typeof n == "bigint") return { bigint: n.toString() };
+  throw new Error(`Type ${typeof n} (value ${n}) not yet supported.`);
 }
-function D(t, n) {
-  if (t === null || typeof t == "string" || typeof t == "number" || typeof t == "bigint") {
-    if (n && !d(t, n) && !S(t, n))
-      throw new Error(`Unexpected value type, got ${typeof t}, expected ${n}`);
-    return t;
+function K(n, t) {
+  if (n === null || typeof n == "string" || typeof n == "number" || typeof n == "bigint") {
+    if (t && !p(n, t) && !J(n, t))
+      throw new Error(`Unexpected value type, got ${typeof n}, expected ${t}`);
+    return n;
   }
-  if (typeof t == "object" && t !== null && "bigint" in t && typeof t.bigint == "string") {
-    if (n && n !== "Long")
-      throw new Error(`Unexpected value type, got serialized bigint, expected ${n}`);
-    return BigInt(t.bigint);
+  if (typeof n == "object" && n !== null && "bigint" in n && typeof n.bigint == "string") {
+    if (t && t !== "Long")
+      throw new Error(`Unexpected value type, got serialized bigint, expected ${t}`);
+    return BigInt(n.bigint);
   }
-  throw new Error(`Unsupported type ${typeof t} (value ${t}).`);
-}
-function tt(t) {
-  if (t = $(t), t === null) throw new Error("Value is null");
-  return t;
-}
-function $(t) {
-  if (t = D(t), t === null) return null;
-  if (typeof t == "string") return t;
-  if (typeof t == "number") {
-    if (!isFinite(t)) throw new Error(`Value is not finite (${t})`);
-    return t;
+  throw new Error(`Unsupported type ${typeof n} (value ${n}).`);
+}
+function pn(n) {
+  if (n = T(n), n === null) throw new Error("Value is null");
+  return n;
+}
+function T(n) {
+  if (n = K(n), n === null) return null;
+  if (typeof n == "string") return n;
+  if (typeof n == "number") {
+    if (!isFinite(n)) throw new Error(`Value is not finite (${n})`);
+    return n;
   }
-  if (typeof t == "bigint")
-    return Number(t);
-  throw new Error(`Unexpected value type: ${typeof t}`);
-}
-function L(t, n) {
-  const e = Math.floor(n / 8), r = 1 << 7 - n % 8;
-  return (t[e] & r) > 0;
-}
-const O = { type: "absent" }, H = null;
-function nt(t) {
-  return typeof t == "object" && t !== null && t.type === "absent";
-}
-function et(t, n, e = {}) {
-  if (L(t.absent, n))
-    return e.absent === void 0 ? O : e.absent;
-  const r = t.data[n], o = t.type;
-  if (d(r, o)) return e.na === void 0 ? H : e.na;
+  if (typeof n == "bigint")
+    return Number(n);
+  throw new Error(`Unexpected value type: ${typeof n}`);
+}
+function W(n, t) {
+  const e = Math.floor(t / 8), r = 1 << 7 - t % 8;
+  return (n[e] & r) > 0;
+}
+const X = { type: "absent" }, G = null;
+function hn(n) {
+  return typeof n == "object" && n !== null && n.type === "absent";
+}
+function yn(n, t, e = {}) {
+  if (W(n.absent, t))
+    return e.absent === void 0 ? X : e.absent;
+  const r = n.data[t], o = n.type;
+  if (p(r, o)) return e.na === void 0 ? G : e.na;
   switch (o) {
     case "Int":
       return r;
@@ -156,86 +160,223 @@ function et(t, n, e = {}) {
       throw Error(`unsupported data type: ${o}`);
   }
 }
-function J(t) {
-  const { type: n, name: e, domain: r } = t;
-  return { type: n, name: e, ...r && { domain: r } };
+function h(n) {
+  const { type: t, name: e, domain: r } = n;
+  return { type: t, name: e, ...r && { domain: r } };
 }
-function rt(t) {
-  return t.map(J);
+function bn(n) {
+  return n.map(h);
 }
-function _(t, n) {
-  if (t === void 0) return n === void 0;
-  if (n === void 0) return !0;
-  for (const e in n)
-    if (t[e] !== n[e]) return !1;
+function Q(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 ot(t, n) {
-  return t.name === n.name && _(t.domain, n.domain);
+function z(n, t) {
+  return n.name === t.name && Q(n.domain, t.domain);
 }
-function it(t, n) {
-  return { ...t, src: f(t.src, n) };
+function gn(n, t) {
+  return { ...n, src: l(n.src, t) };
 }
-function f(t, n) {
-  switch (t.type) {
+function l(n, t) {
+  switch (n.type) {
     case "column":
       return {
         type: "column",
-        column: n(t.column)
+        column: t(n.column)
       };
     case "inner":
     case "full":
       return {
-        type: t.type,
-        entries: t.entries.map((e) => f(e, n))
+        type: n.type,
+        entries: n.entries.map((e) => l(e, t))
       };
     case "outer":
       return {
         type: "outer",
-        primary: f(t.primary, n),
-        secondary: t.secondary.map((e) => f(e, n))
+        primary: l(n.primary, t),
+        secondary: n.secondary.map((e) => l(e, t))
       };
     default:
-      b(t);
+      g(n);
   }
 }
-const st = { href: "/" }, ut = a.object({
-  __isRef: a.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: a.string().describe("Upstream block id"),
-  name: a.string().describe("Name of the output provided to the upstream block's output context")
-}).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."
-).strict().readonly();
-function at(t, n) {
-  return t.blockId === n.blockId && t.name === n.name;
+function A(n) {
+  return k(h(n));
+}
+function x(n, t) {
+  return JSON.stringify([n, t]);
+}
+class wn {
+  /**
+   * 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) {
+    d(this, "domains", /* @__PURE__ */ new Map());
+    d(this, "axes", /* @__PURE__ */ new Map());
+    /**
+     * Domain packs are used to group domain keys that can be anchored to the same anchor
+     * This is used to optimize the lookup of domain anchors
+     */
+    d(this, "domainPacks", []);
+    /**
+     * Maps domain packs to anchors
+     */
+    d(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
+    this.anchors = t;
+    const e = Object.entries(t);
+    e.sort((r, o) => r[0].localeCompare(o[0]));
+    for (const [r, o] of e) {
+      for (let i = 0; i < o.axesSpec.length; i++) {
+        const a = o.axesSpec[i], s = A(a);
+        this.axes.set(s, { anchor: r, idx: i });
+      }
+      if (o.domain !== void 0) {
+        const i = Object.entries(o.domain);
+        i.sort((a, s) => a[0].localeCompare(s[0])), this.domainPackToAnchor.set(JSON.stringify(i), r), this.domainPacks.push(i.map(([a]) => a));
+        for (const [a, s] of i) {
+          const c = x(a, s);
+          this.domains.set(c, r);
+        }
+      }
+    }
+  }
+  /**
+   * Derives an anchored column identifier from a column specification
+   * Replaces domain values and axes with anchored references when possible
+   * @param spec Column specification to anchor
+   * @returns An anchored column identifier that can be used to identify columns similar to the input specification
+   */
+  derive(t) {
+    const e = {
+      name: t.name,
+      axes: []
+    };
+    let r;
+    if (t.domain !== void 0)
+      n:
+        for (const o of this.domainPacks) {
+          const i = [];
+          for (const s of o) {
+            const c = t.domain[s];
+            if (c !== void 0)
+              i.push([s, c]);
+            else
+              break n;
+          }
+          const a = this.domainPackToAnchor.get(JSON.stringify(i));
+          if (a !== void 0) {
+            e.domainAnchor = a, r = new Set(o);
+            break;
+          }
+        }
+    for (const [o, i] of Object.entries(t.domain ?? {})) {
+      if (r !== void 0 && r.has(o))
+        continue;
+      const a = x(o, i), s = this.domains.get(a);
+      e.domain ?? (e.domain = {}), e.domain[o] = s ? { anchor: s } : i;
+    }
+    return e.axes = t.axesSpec.map((o) => {
+      const i = A(o);
+      return this.axes.get(i) ?? o;
+    }), e;
+  }
+  /**
+   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column
+   * @param spec Column specification to anchor
+   * @returns A canonicalized string representation of the anchored column identifier
+   */
+  deriveString(t) {
+    const e = this.derive(t);
+    return k(e);
+  }
+}
+function An(n, t) {
+  const e = { ...t };
+  if (e.domainAnchor !== void 0) {
+    const r = n[e.domainAnchor];
+    if (!r)
+      throw new Error(`Anchor "${e.domainAnchor}" not found`);
+    const o = r.domain || {};
+    e.domain = { ...o, ...e.domain }, delete e.domainAnchor;
+  }
+  if (e.domain) {
+    const r = {};
+    for (const [o, i] of Object.entries(e.domain))
+      if (typeof i == "string")
+        r[o] = i;
+      else {
+        const a = n[i.anchor];
+        if (!a)
+          throw new Error(`Anchor "${i.anchor}" not found for domain key "${o}"`);
+        if (!a.domain || a.domain[o] === void 0)
+          throw new Error(`Domain key "${o}" not found in anchor "${i.anchor}"`);
+        r[o] = a.domain[o];
+      }
+    e.domain = r;
+  }
+  return e.axes && (e.axes = e.axes.map((r) => Y(n, r))), e;
 }
-function i(t) {
-  return t.kind === "PColumn";
+function Y(n, t) {
+  if (!Z(t))
+    return t;
+  const e = t.anchor, r = n[e];
+  if (!r)
+    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 o = r.axesSpec.filter((i) => i.name === t.name);
+    if (o.length > 1)
+      throw new Error(`Multiple axes with name "${t.name}" found in anchor "${e}"`);
+    if (o.length === 0)
+      throw new Error(`Axis with name "${t.name}" not found in anchor "${e}"`);
+    return o[0];
+  } else if ("id" in t) {
+    const o = r.axesSpec.filter((i) => z(t.id, h(i)));
+    if (o.length > 1)
+      throw new Error(`Multiple matching axes found for matcher in anchor "${e}"`);
+    if (o.length === 0)
+      throw new Error(`No matching axis found for matcher in anchor "${e}"`);
+    return o[0];
+  }
+  throw new Error("Unsupported axis reference type");
+}
+function Z(n) {
+  return typeof n == "object" && "anchor" in n;
 }
-function W(t) {
-  return i(t.spec);
+function f(n) {
+  return n.kind === "PColumn";
 }
-function ct(t) {
-  return i(t.obj);
+function q(n) {
+  return f(n.spec);
 }
-function ft(t) {
-  return i(t.obj.spec);
+function xn(n) {
+  return f(n.obj);
 }
-function dt(t) {
-  if (!W(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
-  return t;
+function Pn(n) {
+  return f(n.obj.spec);
 }
-function lt(t, n) {
-  return t === void 0 ? void 0 : {
-    ...t,
-    data: n(t.data)
+function En(n) {
+  if (!q(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
+  return n;
+}
+function kn(n, t) {
+  return n === void 0 ? void 0 : {
+    ...n,
+    data: t(n.data)
   };
 }
-function pt(t) {
-  const n = /* @__PURE__ */ new Map(), e = (r) => {
+function In(n) {
+  const t = /* @__PURE__ */ new Map(), e = (r) => {
     switch (r.type) {
       case "column":
-        n.set(r.column.id, r.column);
+        t.set(r.column.id, r.column);
         return;
       case "full":
       case "inner":
@@ -246,145 +387,231 @@ function pt(t) {
         for (const o of r.secondary) e(o);
         return;
       default:
-        b(r);
+        g(r);
     }
   };
-  return e(t), [...n.values()];
+  return e(n), [...t.values()];
 }
-function j(t) {
-  throw new Error("Unexpected object: " + t);
+function v(n) {
+  throw new Error("Unexpected object: " + n);
 }
-function m(t, n) {
-  switch (t.type) {
+function b(n, t) {
+  switch (n.type) {
     case "and":
-      for (const e of t.operands)
-        if (!m(e, n)) return !1;
+      for (const e of n.operands)
+        if (!b(e, t)) return !1;
       return !0;
     case "or":
-      for (const e of t.operands)
-        if (m(e, n)) return !0;
+      for (const e of n.operands)
+        if (b(e, t)) return !0;
       return !1;
     case "not":
-      return !m(t.operand, n);
+      return !b(n.operand, t);
     case "name":
-      return i(n) && n.name === t.name;
+      return f(t) && t.name === n.name;
     case "name_pattern":
-      return i(n) && !!n.name.match(t.pattern);
+      return f(t) && !!t.name.match(n.pattern);
     case "annotation":
-      return i(n) && n.annotations !== void 0 && n.annotations[t.annotation] === t.value;
+      return f(t) && t.annotations !== void 0 && t.annotations[n.annotation] === n.value;
     case "annotation_pattern":
-      return i(n) && n.annotations !== void 0 && n.annotations[t.annotation] !== void 0 && !!n.annotations[t.annotation].match(t.pattern);
+      return f(t) && t.annotations !== void 0 && t.annotations[n.annotation] !== void 0 && !!t.annotations[n.annotation].match(n.pattern);
     case "has_axes":
-      return i(n) && t.axes.every(
-        (e) => n.axesSpec.some(
+      return f(t) && n.axes.every(
+        (e) => t.axesSpec.some(
           (r) => (e.type === void 0 || e.type === r.type) && (e.name === void 0 || e.name === r.name) && (e.domain === void 0 || Object.keys(e.domain).length === 0 || r.domain !== void 0 && Object.entries(e.domain).every(
-            ([o, l]) => r.domain[o] === l
+            ([o, i]) => r.domain[o] === i
           ))
         )
       );
     default:
-      j(t);
+      v(n);
+  }
+}
+function P(n, t) {
+  if (n.name !== void 0 && n.name !== t.name)
+    return !1;
+  if (n.type !== void 0) {
+    if (Array.isArray(n.type)) {
+      if (!n.type.includes(t.type))
+        return !1;
+    } else if (n.type !== t.type)
+      return !1;
+  }
+  if (n.domain !== void 0) {
+    const e = t.domain || {};
+    for (const [r, o] of Object.entries(n.domain))
+      if (e[r] !== o)
+        return !1;
+  }
+  return !0;
+}
+function E(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 (t.type !== void 0) {
+    if (Array.isArray(t.type)) {
+      if (!t.type.includes(n.valueType))
+        return !1;
+    } else if (t.type !== n.valueType)
+      return !1;
+  }
+  if (t.domain !== void 0) {
+    const e = n.domain || {};
+    for (const [r, o] of Object.entries(t.domain))
+      if (e[r] !== o)
+        return !1;
+  }
+  if (t.axes !== void 0) {
+    const e = n.axesSpec.map(h);
+    if (t.partialAxesMatch) {
+      for (const r of t.axes)
+        if (!e.some((o) => P(r, o)))
+          return !1;
+    } else {
+      if (e.length !== t.axes.length)
+        return !1;
+      for (let r = 0; r < t.axes.length; r++)
+        if (!P(t.axes[r], e[r]))
+          return !1;
+    }
   }
+  if (t.annotations !== void 0) {
+    const e = n.annotations || {};
+    for (const [r, o] of Object.entries(t.annotations))
+      if (e[r] !== o)
+        return !1;
+  }
+  if (t.annotationPatterns !== void 0) {
+    const e = n.annotations || {};
+    for (const [r, o] of Object.entries(t.annotationPatterns)) {
+      const i = e[r];
+      if (i === void 0 || !new RegExp(o).test(i))
+        return !1;
+    }
+  }
+  return !0;
+}
+function Nn(n) {
+  return Array.isArray(n) ? (t) => n.some((e) => f(t) && E(t, e)) : (t) => f(t) && E(t, n);
+}
+const Cn = { href: "/" }, Sn = m.object({
+  __isRef: m.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: m.string().describe("Upstream block id"),
+  name: m.string().describe("Name of the output provided to the upstream block's output context")
+}).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."
+).strict().readonly();
+function Vn(n) {
+  return typeof n == "object" && n !== null && "__isRef" in n && n.__isRef === !0 && "blockId" in n && "name" in n;
+}
+function $n(n, t) {
+  return n.blockId === t.blockId && n.name === t.name;
 }
-function mt(t, n) {
-  return t.ok ? { ok: !0, value: n(t.value) } : t;
+function Fn(n, t) {
+  return n.ok ? { ok: !0, value: t(n.value) } : n;
 }
-function M(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 nn(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 K = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", X = "0123456789ABCDEFGHIJKLMNOPQRSTUV", G = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-function P(t, n, e) {
+const tn = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", en = "0123456789ABCDEFGHIJKLMNOPQRSTUV", rn = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function C(n, t, e) {
   e = e || {};
   let r, o;
-  switch (n) {
+  switch (t) {
     case "RFC3548":
     case "RFC4648":
-      r = K, o = !0;
+      r = tn, o = !0;
       break;
     case "RFC4648-HEX":
-      r = X, o = !0;
+      r = en, o = !0;
       break;
     case "Crockford":
-      r = G, o = !1;
+      r = rn, o = !1;
       break;
     default:
-      throw new Error("Unknown base32 variant: " + n);
+      throw new Error("Unknown base32 variant: " + t);
   }
-  const l = e.padding !== void 0 ? e.padding : o, y = M(t);
+  const i = e.padding !== void 0 ? e.padding : o, a = nn(n);
   let s = 0, c = 0, u = "";
-  for (let p = 0; p < y.byteLength; p++)
-    for (c = c << 8 | y.getUint8(p), s += 8; s >= 5; )
+  for (let y = 0; y < a.byteLength; y++)
+    for (c = c << 8 | a.getUint8(y), s += 8; s >= 5; )
       u += r[c >>> s - 5 & 31], s -= 5;
-  if (s > 0 && (u += r[c << 5 - s & 31]), l)
+  if (s > 0 && (u += r[c << 5 - s & 31]), i)
     for (; u.length % 8 !== 0; )
       u += "=";
   return u;
 }
-const N = 15, Q = 24, A = a.string().length(Q).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-function bt() {
-  const t = new Uint8Array(N);
-  return crypto.getRandomValues(t), A.parse(P(t, "RFC4648"));
+const S = 15, on = 24, V = m.string().length(on).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function Dn() {
+  const n = new Uint8Array(S);
+  return crypto.getRandomValues(n), V.parse(C(n, "RFC4648"));
 }
-function T(t) {
-  if (t.length !== N) throw new Error(`Wrong number of bytes: ${t.length}`);
-  return A.parse(P(t, "RFC4648"));
+function an(n) {
+  if (n.length !== S) throw new Error(`Wrong number of bytes: ${n.length}`);
+  return V.parse(C(n, "RFC4648"));
 }
-async function yt(t) {
-  const n = new TextEncoder(), e = await crypto.subtle.digest("SHA-256", n.encode(t));
-  return T(new Uint8Array(e.slice(0, 15)));
+async function Un(n) {
+  const t = new TextEncoder(), e = await crypto.subtle.digest("SHA-256", t.encode(n));
+  return an(new Uint8Array(e.slice(0, 15)));
 }
 export {
-  st as DefaultNavigationState,
-  O as PTableAbsent,
-  H as PTableNA,
-  k as PValueBytesNA,
-  R as PValueDoubleNA,
-  x as PValueFloatNA,
-  F as PValueIntNA,
-  g as PValueLongNA,
-  U as PValueStringNA,
-  A as PlId,
-  N as PlIdBytes,
-  Q as PlIdLength,
-  ut as PlRef,
-  yt as digestPlId,
-  q as ensureNotNAPValue,
-  dt as ensurePColumn,
-  m as executePSpecPredicate,
-  pt as extractAllColumns,
-  rt as getAxesId,
-  J as getAxisId,
-  z as getFileNameFromHandle,
-  C as getFilePathFromHandle,
-  I as isImportFileHandleIndex,
-  E as isImportFileHandleUpload,
-  Z as isLiveLog,
-  B as isNotNAPValue,
-  W as isPColumn,
-  ft as isPColumnResult,
-  i as isPColumnSpec,
-  ct as isPColumnSpecResult,
-  nt as isPTableAbsent,
-  S as isPValue,
-  L as isValueAbsent,
-  d as isValueNA,
-  f as mapJoinEntry,
-  lt as mapPObjectData,
-  it as mapPTableDef,
-  mt as mapValueInVOE,
-  ot as matchAxisId,
-  et as pTableValue,
-  tt as pValueToStringOrNumber,
-  $ as pValueToStringOrNumberOrNull,
-  T as plId,
-  at as plRefsEqual,
-  D as safeConvertToPValue,
-  v as toJsonSafePValue,
-  bt as uniquePlId
+  wn as AnchorIdDeriver,
+  Cn as DefaultNavigationState,
+  X as PTableAbsent,
+  G as PTableNA,
+  _ as PValueBytesNA,
+  L as PValueDoubleNA,
+  j as PValueFloatNA,
+  R as PValueIntNA,
+  w as PValueLongNA,
+  M as PValueStringNA,
+  V as PlId,
+  S as PlIdBytes,
+  on as PlIdLength,
+  Sn as PlRef,
+  Un as digestPlId,
+  mn as ensureNotNAPValue,
+  En as ensurePColumn,
+  b as executePSpecPredicate,
+  In as extractAllColumns,
+  bn as getAxesId,
+  h as getAxisId,
+  dn as getFileNameFromHandle,
+  O as getFilePathFromHandle,
+  U as isImportFileHandleIndex,
+  D as isImportFileHandleUpload,
+  un as isLiveLog,
+  H as isNotNAPValue,
+  q as isPColumn,
+  Pn as isPColumnResult,
+  f as isPColumnSpec,
+  xn as isPColumnSpecResult,
+  hn as isPTableAbsent,
+  J as isPValue,
+  Vn as isPlRef,
+  W as isValueAbsent,
+  p as isValueNA,
+  l as mapJoinEntry,
+  kn as mapPObjectData,
+  gn as mapPTableDef,
+  Fn as mapValueInVOE,
+  P as matchAxis,
+  z as matchAxisId,
+  E as matchPColumn,
+  yn as pTableValue,
+  pn as pValueToStringOrNumber,
+  T as pValueToStringOrNumberOrNull,
+  an as plId,
+  $n as plRefsEqual,
+  An as resolveAnchors,
+  K as safeConvertToPValue,
+  Nn as selectorsToPredicate,
+  ln as toJsonSafePValue,
+  Dn as uniquePlId
 };
 //# sourceMappingURL=index.mjs.map