@milaboratories/graph-maker 1.1.140 → 1.1.141

package/dist/node_modules/@milaboratories/pf-plots/dist/node_modules/@milaboratories/pl-model-common/dist/index.js

@@ -0,0 +1,979 @@
+import u from "../../../zod/lib/index.js";
+import L from "../../../../_virtual/canonicalize.js";
+var F = Object.defineProperty, D = (n, e, t) => e in n ? F(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t, A = (n, e, t) => D(n, typeof e != "symbol" ? e + "" : e, t);
+u.object({
+  /** Included left border. */
+  from: u.number(),
+  /** Excluded right border. */
+  to: u.number()
+});
+function E(n) {
+  throw new Error("Unexpected object: " + n);
+}
+function le(n) {
+  if (!n || typeof n != "object")
+    return !1;
+  const e = n;
+  if (!("type" in e))
+    return !1;
+  switch (e.type) {
+    case "Json":
+      return typeof e.keyLength == "number" && e.data !== void 0 && typeof e.data == "object";
+    case "JsonPartitioned":
+    case "BinaryPartitioned":
+    case "ParquetPartitioned":
+      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
+    default:
+      return !1;
+  }
+}
+function de(n, e) {
+  if (n !== void 0)
+    switch (n.type) {
+      case "Json":
+        return n;
+      case "JsonPartitioned": {
+        const t = {};
+        for (const [r, o] of Object.entries(n.parts))
+          t[r] = e(o);
+        return {
+          ...n,
+          parts: t
+        };
+      }
+      case "BinaryPartitioned": {
+        const t = {};
+        for (const [r, o] of Object.entries(n.parts))
+          t[r] = {
+            index: e(o.index),
+            values: e(o.values)
+          };
+        return {
+          ...n,
+          parts: t
+        };
+      }
+      case "ParquetPartitioned": {
+        const t = {};
+        for (const [r, o] of Object.entries(n.parts))
+          t[r] = e(o);
+        return {
+          ...n,
+          parts: t
+        };
+      }
+    }
+}
+function q(n) {
+  if (!n || typeof n != "object")
+    return !1;
+  const e = n;
+  if (!("type" in e))
+    return !1;
+  switch (e.type) {
+    case "Json":
+      return typeof e.keyLength == "number" && Array.isArray(e.data);
+    case "JsonPartitioned":
+    case "BinaryPartitioned":
+    case "ParquetPartitioned":
+      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
+    default:
+      return !1;
+  }
+}
+function me(n) {
+  if (!q(n)) return !1;
+  switch (n.type) {
+    case "JsonPartitioned":
+    case "BinaryPartitioned":
+    case "ParquetPartitioned":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function he(n) {
+  switch (n.type) {
+    case "Json":
+      return {
+        type: "Json",
+        keyLength: n.keyLength,
+        data: Object.entries(n.data).map(([e, t]) => ({ key: JSON.parse(e), value: t }))
+      };
+    case "JsonPartitioned":
+      return {
+        type: "JsonPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.entries(n.parts).map(([e, t]) => ({ key: JSON.parse(e), value: t }))
+      };
+    case "BinaryPartitioned":
+      return {
+        type: "BinaryPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.entries(n.parts).map(([e, t]) => ({ key: JSON.parse(e), value: t }))
+      };
+    case "ParquetPartitioned":
+      return {
+        type: "ParquetPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.entries(n.parts).map(([e, t]) => ({ key: JSON.parse(e), value: t }))
+      };
+    default:
+      E(n);
+  }
+}
+function ye(n) {
+  switch (n.type) {
+    case "Json":
+      return {
+        type: "Json",
+        keyLength: n.keyLength,
+        data: Object.fromEntries(
+          n.data.map(({ key: e, value: t }) => [JSON.stringify(e), t])
+        )
+      };
+    case "JsonPartitioned":
+      return {
+        type: "JsonPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.fromEntries(
+          n.parts.map(({ key: e, value: t }) => [JSON.stringify(e), t])
+        )
+      };
+    case "BinaryPartitioned":
+      return {
+        type: "BinaryPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.fromEntries(
+          n.parts.map(({ key: e, value: t }) => [JSON.stringify(e), t])
+        )
+      };
+    case "ParquetPartitioned":
+      return {
+        type: "ParquetPartitioned",
+        partitionKeyLength: n.partitionKeyLength,
+        parts: Object.fromEntries(
+          n.parts.map(({ key: e, value: t }) => [JSON.stringify(e), t])
+        )
+      };
+    default:
+      E(n);
+  }
+}
+function B(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 (e) {
+      return `Non-serializable object was thrown (JSON.stringify failed: ${e instanceof Error ? e.message : String(e)}): ${String(n)}`;
+    }
+  return `Non-Error value (${typeof n}) was thrown: ${n}`;
+}
+function R(n) {
+  return n instanceof Error ? n : new Error(B(n));
+}
+function h(n) {
+  return L(n);
+}
+function V(n) {
+  return JSON.parse(n);
+}
+const g = {
+  Int: "Int",
+  Long: "Long",
+  Float: "Float",
+  Double: "Double",
+  String: "String",
+  Bytes: "Bytes"
+};
+function M(n, e) {
+  return n == null ? void 0 : n[e];
+}
+function W(n, e, t, r = "readMetadataJsonOrThrow") {
+  const o = M(n, t);
+  if (o === void 0) return;
+  const s = e[t];
+  try {
+    const a = JSON.parse(o);
+    return s.parse(a);
+  } catch (a) {
+    throw new Error(
+      `${r} failed, key: ${String(t)}, value: ${o}, error: ${R(a)}`
+    );
+  }
+}
+function U(n, e, t) {
+  try {
+    return W(n, e, t);
+  } catch {
+    return;
+  }
+}
+const y = {
+  DiscreteValues: "pl7.app/discreteValues",
+  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: {
+    OrderPriority: "pl7.app/table/orderPriority"
+  },
+  Trace: "pl7.app/trace"
+}, z = u.object({
+  type: u.nativeEnum(g),
+  name: u.string(),
+  domain: u.record(u.string(), u.string()).optional(),
+  annotations: u.record(u.string(), u.string()).optional(),
+  parentAxes: u.array(u.number()).optional()
+}).passthrough(), G = {
+  [y.DiscreteValues]: u.array(u.string()).or(u.array(u.number())),
+  [y.Graph.IsVirtual]: u.boolean(),
+  [y.HideDataFromUi]: u.boolean(),
+  [y.IsLinkerColumn]: u.boolean(),
+  [y.Max]: u.number(),
+  [y.Min]: u.number(),
+  [y.Parents]: u.array(z),
+  [y.Sequence.Annotation.Mapping]: u.record(u.string(), u.string()),
+  [y.Sequence.IsAnnotation]: u.boolean(),
+  [y.Table.OrderPriority]: u.number(),
+  [y.Trace]: u.record(u.string(), u.unknown())
+};
+function ge(n, e) {
+  return M(n == null ? void 0 : n.annotations, e);
+}
+function $(n, e) {
+  return U(n == null ? void 0 : n.annotations, G, e);
+}
+function S(n) {
+  return { axis: n, children: [] };
+}
+function w(n) {
+  const e = S(n);
+  let t = [e];
+  for (; t.length; ) {
+    const r = [];
+    for (const o of t)
+      o.children = o.axis.parentAxesSpec.map(S), r.push(...o.children);
+    t = r;
+  }
+  return e;
+}
+function k(n) {
+  const e = [n.axis];
+  let t = [n];
+  for (; t.length; ) {
+    const r = [];
+    for (const o of t)
+      for (const s of o.children)
+        e.push(s.axis), r.push(s);
+    t = r;
+  }
+  return e;
+}
+function O(n) {
+  return h(k(w(n)).map(d));
+}
+function H(n, e) {
+  if (n.name !== e.name)
+    return n.name < e.name ? 1 : -1;
+  if (n.type !== e.type)
+    return n.type < e.type ? 1 : -1;
+  const t = h(n.domain ?? {}), r = h(e.domain ?? {});
+  if (t !== r)
+    return t < r ? 1 : -1;
+  const o = O(n), s = O(e);
+  if (o !== s)
+    return o < s ? 1 : -1;
+  const a = h(n.annotations ?? {}), i = h(e.annotations ?? {});
+  return a !== i ? a < i ? 1 : -1 : 0;
+}
+function Q(n) {
+  const e = $(n, y.Parents);
+  return e === void 0 ? [] : e;
+}
+function T(n) {
+  n.parentAxesSpec.forEach(T), n.parentAxesSpec.sort(H);
+}
+function X(n) {
+  let e = [S(n)];
+  const t = new Set(h(d(n)));
+  for (; e.length; ) {
+    const r = [], o = /* @__PURE__ */ new Set();
+    for (const s of e) {
+      s.children = s.axis.parentAxesSpec.map(S);
+      for (const a of s.children) {
+        const i = h(d(a.axis));
+        if (!o.has(i)) {
+          if (r.push(a), o.add(i), t.has(i))
+            return !0;
+          t.add(i);
+        }
+      }
+    }
+    e = r;
+  }
+  return !1;
+}
+function K(n) {
+  if (!n.length)
+    return [];
+  const e = n.map((t) => {
+    const { parentAxes: r, ...o } = t;
+    return { ...o, annotations: { ...o.annotations }, parentAxesSpec: [] };
+  });
+  return n.forEach((t, r) => {
+    var o;
+    const s = e[r];
+    t.parentAxes ? s.parentAxesSpec = t.parentAxes.map((a) => e[a]) : (s.parentAxesSpec = K(Q(t)), (o = s.annotations) == null || delete o[y.Parents]);
+  }), e.some(X) ? e.forEach((t) => {
+    t.parentAxesSpec = [];
+  }) : e.forEach((t) => {
+    T(t);
+  }), e;
+}
+const xe = {
+  Label: "pl7.app/label"
+};
+function d(n) {
+  const { type: e, name: t, domain: r } = n, o = { type: e, name: t };
+  return r && Object.entries(r).length > 0 && Object.assign(o, { domain: r }), o;
+}
+function Y(n) {
+  return n.map(d);
+}
+function be(n) {
+  return h(d(n));
+}
+function Z(n, e) {
+  if (n === void 0) return e === void 0;
+  if (e === void 0) return !0;
+  for (const t in e)
+    if (n[t] !== e[t]) return !1;
+  return !0;
+}
+function _(n, e) {
+  return n.name === e.name && Z(n.domain, e.domain);
+}
+function C(n, e) {
+  const t = Math.floor(e / 8), r = 1 << 7 - e % 8;
+  return (n[t] & r) > 0;
+}
+function ee(n, e) {
+  return C(n.absent, e);
+}
+function ne(n, e) {
+  if (n.isNA) return C(n.isNA, e);
+  const t = n.type, r = n.data[e];
+  switch (t) {
+    case g.Int:
+      return r === -2147483648;
+    case g.Long:
+      return r === -9007199254740991n;
+    case g.Float:
+      return Number.isNaN(r);
+    case g.Double:
+      return Number.isNaN(r);
+    case g.String:
+      return r === null;
+    case g.Bytes:
+      return r === null;
+    default:
+      throw Error(`unsupported data type: ${t}`);
+  }
+}
+const te = { type: "absent" }, re = null;
+function oe(n, e, t) {
+  const r = n.type;
+  if (r === g.Bytes)
+    throw Error("Bytes not yet supported");
+  if (t && "dataType" in t && t.dataType !== void 0 && t.dataType !== r)
+    throw Error(`expected column of type ${t.dataType}, got ${r}`);
+  if (ee(n, e))
+    return (t == null ? void 0 : t.absent) !== void 0 ? t.absent : te;
+  if (ne(n, e))
+    return (t == null ? void 0 : t.na) !== void 0 ? t.na : re;
+  const o = n.data[e];
+  switch (r) {
+    case g.Int:
+      return o;
+    case g.Long:
+      return Number(o);
+    case g.Float:
+      return o;
+    case g.Double:
+      return o;
+    case g.String:
+      return o;
+  }
+}
+function Ae(n, e, t) {
+  return oe(n, e, t);
+}
+function we(n, e) {
+  return { ...n, src: v(n.src, e) };
+}
+function v(n, e) {
+  switch (n.type) {
+    case "column":
+      return {
+        type: "column",
+        column: e(n.column)
+      };
+    case "slicedColumn":
+      return {
+        type: "slicedColumn",
+        column: e(n.column),
+        newId: n.newId,
+        axisFilters: n.axisFilters
+      };
+    case "inlineColumn":
+      return n;
+    case "inner":
+    case "full":
+      return {
+        type: n.type,
+        entries: n.entries.map((t) => v(t, e))
+      };
+    case "outer":
+      return {
+        type: "outer",
+        primary: v(n.primary, e),
+        secondary: n.secondary.map((t) => v(t, e))
+      };
+    default:
+      E(n);
+  }
+}
+function ae(n) {
+  return L(n);
+}
+function J(n) {
+  return L(d(n));
+}
+function I(n, e) {
+  return JSON.stringify([n, e]);
+}
+class ke {
+  /**
+   * 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) {
+    A(this, "domains", /* @__PURE__ */ new Map()), A(this, "axes", /* @__PURE__ */ new Map()), A(this, "domainPacks", []), A(this, "domainPackToAnchor", /* @__PURE__ */ new Map()), this.anchors = e;
+    const t = Object.entries(e);
+    t.sort((r, o) => r[0].localeCompare(o[0]));
+    for (const [r, o] of t) {
+      for (let s = 0; s < o.axesSpec.length; s++) {
+        const a = o.axesSpec[s], i = J(a);
+        this.axes.set(i, { anchor: r, idx: s });
+      }
+      if (o.domain !== void 0) {
+        const s = Object.entries(o.domain);
+        s.sort((a, i) => a[0].localeCompare(i[0])), this.domainPackToAnchor.set(JSON.stringify(s), r), this.domainPacks.push(s.map(([a]) => a));
+        for (const [a, i] of s) {
+          const c = I(a, i);
+          this.domains.set(c, r);
+        }
+      }
+    }
+  }
+  /**
+   * Implementation of derive method
+   */
+  derive(e, t) {
+    const r = {
+      name: e.name,
+      axes: []
+    };
+    let o;
+    if (e.domain !== void 0)
+      e:
+        for (const a of this.domainPacks) {
+          const i = [];
+          for (const f of a) {
+            const l = e.domain[f];
+            if (l !== void 0)
+              i.push([f, l]);
+            else
+              break e;
+          }
+          const c = this.domainPackToAnchor.get(JSON.stringify(i));
+          if (c !== void 0) {
+            r.domainAnchor = c, o = new Set(a);
+            break;
+          }
+        }
+    for (const [a, i] of Object.entries(e.domain ?? {})) {
+      if (o !== void 0 && o.has(a))
+        continue;
+      const c = I(a, i), f = this.domains.get(c);
+      r.domain ?? (r.domain = {}), r.domain[a] = f ? { anchor: f } : i;
+    }
+    if (r.axes = e.axesSpec.map((a) => {
+      const i = J(a), c = this.axes.get(i);
+      return c === void 0 ? d(a) : c;
+    }), !t || t.length === 0)
+      return r;
+    const s = [];
+    for (const a of t) {
+      const [i, c] = a;
+      if (typeof i == "number") {
+        if (i < 0 || i >= e.axesSpec.length)
+          throw new Error(`Axis index ${i} is out of bounds (0-${e.axesSpec.length - 1})`);
+        s.push([i, c]);
+      } else {
+        const f = e.axesSpec.findIndex((l) => l.name === i);
+        if (f === -1)
+          throw new Error(`Axis with name "${i}" not found in the column specification`);
+        s.push([f, c]);
+      }
+    }
+    return s.sort((a, i) => a[0] - i[0]), {
+      source: r,
+      axisFilters: s
+    };
+  }
+  /**
+   * 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
+   * @param axisFilters Optional axis filters to apply to the column
+   * @returns A canonicalized string representation of the anchored column identifier
+   */
+  deriveS(e, t) {
+    return ae(this.derive(e, t));
+  }
+}
+function ve(n, e, t) {
+  const r = { ...e }, o = (t == null ? void 0 : t.ignoreMissingDomains) ?? !1;
+  if (r.domainAnchor !== void 0) {
+    const s = n[r.domainAnchor];
+    if (!s)
+      throw new Error(`Anchor "${r.domainAnchor}" not found`);
+    const a = s.domain || {};
+    r.domain = { ...a, ...r.domain }, delete r.domainAnchor;
+  }
+  if (r.domain) {
+    const s = {};
+    for (const [a, i] of Object.entries(r.domain))
+      if (typeof i == "string")
+        s[a] = i;
+      else {
+        const c = n[i.anchor];
+        if (!c)
+          throw new Error(`Anchor "${i.anchor}" not found for domain key "${a}"`);
+        if (!c.domain || c.domain[a] === void 0) {
+          if (!o)
+            throw new Error(`Domain key "${a}" not found in anchor "${i.anchor}"`);
+          continue;
+        }
+        s[a] = c.domain[a];
+      }
+    r.domain = s;
+  }
+  return r.axes && (r.axes = r.axes.map((s) => se(n, s))), r;
+}
+function se(n, e) {
+  if (!ie(e))
+    return e;
+  const t = e.anchor, r = n[t];
+  if (!r)
+    throw new Error(`Anchor "${t}" 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 "${t}"`);
+    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 "${t}"`);
+    if (o.length === 0)
+      throw new Error(`Axis with name "${e.name}" not found in anchor "${t}"`);
+    return o[0];
+  } else if ("id" in e) {
+    const o = r.axesSpec.filter((s) => _(e.id, d(s)));
+    if (o.length > 1)
+      throw new Error(`Multiple matching axes found for matcher in anchor "${t}"`);
+    if (o.length === 0)
+      throw new Error(`No matching axis found for matcher in anchor "${t}"`);
+    return o[0];
+  }
+  throw new Error("Unsupported axis reference type");
+}
+function ie(n) {
+  return typeof n == "object" && "anchor" in n;
+}
+function P(n) {
+  return n.kind === "PColumn";
+}
+function ce(n) {
+  return P(n.spec);
+}
+function Se(n) {
+  if (!ce(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
+  return n;
+}
+function Pe(n, e) {
+  return n === void 0 ? void 0 : {
+    ...n,
+    data: e(n.data)
+  };
+}
+function Le(n) {
+  const e = /* @__PURE__ */ new Map(), t = (r) => {
+    switch (r.type) {
+      case "column":
+        e.set(r.column.id, r.column);
+        return;
+      case "slicedColumn":
+        e.set(r.column.id, r.column);
+        return;
+      case "inlineColumn":
+        return;
+      case "full":
+      case "inner":
+        for (const o of r.entries) t(o);
+        return;
+      case "outer":
+        t(r.primary);
+        for (const o of r.secondary) t(o);
+        return;
+      default:
+        E(r);
+    }
+  };
+  return t(n), [...e.values()];
+}
+function N(n, e) {
+  if (n.name !== void 0 && n.name !== e.name)
+    return !1;
+  if (n.type !== void 0) {
+    if (Array.isArray(n.type)) {
+      if (!n.type.includes(e.type))
+        return !1;
+    } else if (n.type !== e.type)
+      return !1;
+  }
+  if (n.domain !== void 0) {
+    const t = e.domain || {};
+    for (const [r, o] of Object.entries(n.domain))
+      if (t[r] !== o)
+        return !1;
+  }
+  return !0;
+}
+function j(n, e) {
+  if (e.name !== void 0 && n.name !== e.name || e.namePattern !== void 0 && !new RegExp(e.namePattern).test(n.name))
+    return !1;
+  if (e.type !== void 0) {
+    if (Array.isArray(e.type)) {
+      if (!e.type.includes(n.valueType))
+        return !1;
+    } else if (e.type !== n.valueType)
+      return !1;
+  }
+  if (e.domain !== void 0) {
+    const t = n.domain || {};
+    for (const [r, o] of Object.entries(e.domain))
+      if (t[r] !== o)
+        return !1;
+  }
+  if (e.axes !== void 0) {
+    const t = n.axesSpec.map(d);
+    if (e.partialAxesMatch) {
+      for (const r of e.axes)
+        if (!t.some((o) => N(r, o)))
+          return !1;
+    } else {
+      if (t.length !== e.axes.length)
+        return !1;
+      for (let r = 0; r < e.axes.length; r++)
+        if (!N(e.axes[r], t[r]))
+          return !1;
+    }
+  }
+  if (e.annotations !== void 0) {
+    const t = n.annotations || {};
+    for (const [r, o] of Object.entries(e.annotations))
+      if (t[r] !== o)
+        return !1;
+  }
+  if (e.annotationPatterns !== void 0) {
+    const t = n.annotations || {};
+    for (const [r, o] of Object.entries(e.annotationPatterns)) {
+      const s = t[r];
+      if (s === void 0 || !new RegExp(o).test(s))
+        return !1;
+    }
+  }
+  return !0;
+}
+function Ee(n) {
+  return Array.isArray(n) ? (e) => n.some((t) => P(e) && j(e, t)) : (e) => P(e) && j(e, n);
+}
+function Oe(n) {
+  const e = {
+    kind: n.kind,
+    name: n.name
+  };
+  return n.domain !== void 0 && (e.domain = n.domain), P(n) && (e.axesSpec = Y(n.axesSpec)), L(e);
+}
+class x {
+  constructor(e) {
+    A(this, "data"), this.data = e;
+  }
+  get keys() {
+    return this.data.keys();
+  }
+  get keyAxesIds() {
+    return [...this.data.keys()].map(V);
+  }
+  static fromColumns(e) {
+    var t, r;
+    const o = /* @__PURE__ */ new Map();
+    for (const s of e.filter((a) => !!$(a.spec, y.IsLinkerColumn))) {
+      const a = x.getAxesGroups(K(s.spec.axesSpec));
+      if (a.length !== 2)
+        continue;
+      const [i, c] = a, f = x.getAxesRoots(i).map((p) => {
+        const m = k(w(p));
+        return [h(m.map(d)), m];
+      }), l = x.getAxesRoots(c).map((p) => {
+        const m = k(w(p));
+        return [h(m.map(d)), m];
+      });
+      for (const [p, m] of f)
+        o.has(p) || o.set(p, { keyAxesSpec: m, linkWith: /* @__PURE__ */ new Map() });
+      for (const [p, m] of l)
+        o.has(p) || o.set(p, { keyAxesSpec: m, linkWith: /* @__PURE__ */ new Map() });
+      for (const [p] of f)
+        for (const [m] of l)
+          (t = o.get(p)) == null || t.linkWith.set(m, s), (r = o.get(m)) == null || r.linkWith.set(p, s);
+    }
+    return new this(o);
+  }
+  /** Get all available nodes of linker graphs if start from sourceAxesKeys */
+  searchAvailableAxesKeys(e) {
+    const t = new Set(e), r = /* @__PURE__ */ new Set();
+    let o = e;
+    for (; o.length; ) {
+      const s = [];
+      for (const a of o) {
+        const i = this.data.get(a);
+        if (i)
+          for (const c of i.linkWith.keys())
+            !r.has(c) && !t.has(c) && (s.push(c), r.add(c));
+      }
+      o = s;
+    }
+    return r;
+  }
+  /** Get all linker columns that are necessary to reach endKey from startKey */
+  searchLinkerPath(e, t) {
+    const r = {};
+    let o = /* @__PURE__ */ new Set([e]);
+    const s = /* @__PURE__ */ new Set([e]);
+    for (; o.size; ) {
+      const a = /* @__PURE__ */ new Set();
+      for (const i of o) {
+        const c = this.data.get(i);
+        if (c)
+          for (const f of c.linkWith.keys())
+            if (r[f] = i, f === t) {
+              const l = [];
+              let p = t;
+              for (; r[p] !== e; )
+                l.push(p), p = r[p];
+              return l.push(p), l.map((m) => this.data.get(m).linkWith.get(r[m]));
+            } else s.has(f) || (a.add(f), s.add(f));
+      }
+      o = a;
+    }
+    return [];
+  }
+  getLinkerColumnsForAxes({
+    from: e,
+    to: t,
+    throwWhenNoLinkExists: r = !0
+  }) {
+    const o = e.map(x.getLinkerKeyFromAxisSpec);
+    return Array.from(
+      new Map(
+        x.getAxesRoots(t).map(x.getLinkerKeyFromAxisSpec).flatMap((s) => {
+          const a = o.map((i) => this.searchLinkerPath(i, s)).reduce(
+            (i, c) => i.length && i.length < c.length || !c.length ? i : c,
+            []
+          ).map((i) => [i.columnId, i]);
+          if (!a.length && r)
+            throw Error(`Unable to find linker column for ${s}`);
+          return a;
+        })
+      ).values()
+    );
+  }
+  /** Get list of axisSpecs from keys of linker columns map  */
+  getAxesListFromKeysList(e) {
+    return Array.from(
+      new Map(
+        e.flatMap((t) => {
+          var r;
+          return ((r = this.data.get(t)) == null ? void 0 : r.keyAxesSpec) ?? [];
+        }).map((t) => [h(d(t)), t])
+      ).values()
+    );
+  }
+  /** Get axes of target axes that are impossible to be linked to source axes with current linker map */
+  getNonLinkableAxes(e, t) {
+    const r = e.map(x.getLinkerKeyFromAxisSpec), o = t.map(x.getLinkerKeyFromAxisSpec);
+    return Array.from(
+      new Map(
+        t.filter((s, a) => {
+          const i = o[a];
+          return !r.some((c) => this.searchLinkerPath(c, i).length);
+        }).flatMap((s) => k(w(s)).map((a) => [h(d(a)), a]))
+      ).values()
+    );
+  }
+  /** Get all axes that can be connected to sourceAxes by linkers */
+  getReachableByLinkersAxesFromAxes(e) {
+    const t = e.map(x.getLinkerKeyFromAxisSpec), r = this.searchAvailableAxesKeys(t);
+    return this.getAxesListFromKeysList([...r]);
+  }
+  static getLinkerKeyFromAxisSpec(e) {
+    return h(k(w(e)).map(d));
+  }
+  /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.
+     There are no order inside every group. */
+  static getAxesGroups(e) {
+    switch (e.length) {
+      case 0:
+        return [];
+      case 1:
+        return [[e[0]]];
+    }
+    const t = e.map((c) => h(d(c))), r = e.map(
+      (c) => new Set(
+        c.parentAxesSpec.map((f) => h(d(f))).map((f) => {
+          const l = t.indexOf(f);
+          if (l === -1)
+            throw new Error(`malformed axesSpec: ${JSON.stringify(e)}, unable to locate parent ${f}`);
+          return l;
+        })
+      )
+    ), o = [...e.keys()], s = [], a = /* @__PURE__ */ new Set();
+    let i = o.find((c) => !a.has(c));
+    for (; i !== void 0; ) {
+      const c = [i];
+      a.add(i);
+      let f = [i];
+      for (; f.length; ) {
+        const l = /* @__PURE__ */ new Set();
+        for (const p of f) {
+          const m = r[p];
+          o.forEach((b) => {
+            b === p || a.has(b) || (r[b].has(p) || m.has(b)) && (c.push(b), l.add(b), a.add(b));
+          });
+        }
+        f = [...l];
+      }
+      s.push([...c]), i = o.find((l) => !a.has(l));
+    }
+    return s.map((c) => c.map((f) => e[f]));
+  }
+  /** Get all axes that are not parents of any other axis */
+  static getAxesRoots(e) {
+    const t = new Set(e.flatMap((r) => r.parentAxesSpec).map((r) => h(d(r))));
+    return e.filter((r) => !t.has(h(d(r))));
+  }
+}
+u.object({
+  __isRef: u.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: u.string().describe("Upstream block id"),
+  name: u.string().describe("Name of the output provided to the upstream block's output context"),
+  requireEnrichments: u.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 Je(n) {
+  return typeof n == "object" && n !== null && "__isRef" in n && n.__isRef === !0 && "blockId" in n && "name" in n;
+}
+function Ie(n, e = !0) {
+  if (e)
+    return {
+      ...n,
+      requireEnrichments: !0
+    };
+  {
+    const { requireEnrichments: t, ...r } = n;
+    return r;
+  }
+}
+function Ne(n, e) {
+  return n.ok ? { ok: !0, value: e(n.value) } : n;
+}
+const ue = 24;
+u.string().length(ue).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+export {
+  ke as AnchoredIdDeriver,
+  y as Annotation,
+  G as AnnotationJson,
+  z as AxisSpec,
+  x as LinkerMap,
+  xe as PColumnName,
+  te as PTableAbsent,
+  re as PTableNA,
+  ue as PlIdLength,
+  g as ValueType,
+  be as canonicalizeAxisId,
+  O as canonicalizeAxisWithParents,
+  h as canonicalizeJson,
+  he as dataInfoToEntries,
+  Oe as deriveNativeId,
+  R as ensureError,
+  Se as ensurePColumn,
+  ye as entriesToDataInfo,
+  Le as extractAllColumns,
+  k as getArrayFromAxisTree,
+  Y as getAxesId,
+  w as getAxesTree,
+  d as getAxisId,
+  K as getNormalizedAxesList,
+  le as isDataInfo,
+  q as isDataInfoEntries,
+  ce as isPColumn,
+  P as isPColumnSpec,
+  me as isPartitionedDataInfoEntries,
+  Je as isPlRef,
+  de as mapDataInfo,
+  v as mapJoinEntry,
+  Pe as mapPObjectData,
+  we as mapPTableDef,
+  Ne as mapValueInVOE,
+  N as matchAxis,
+  _ as matchAxisId,
+  j as matchPColumn,
+  Ae as pTableValue,
+  V as parseJson,
+  ge as readAnnotation,
+  $ as readAnnotationJson,
+  M as readMetadata,
+  U as readMetadataJson,
+  W as readMetadataJsonOrThrow,
+  ve as resolveAnchors,
+  Ee as selectorsToPredicate,
+  ae as stringifyColumnId,
+  Ie as withEnrichments
+};
+//# sourceMappingURL=index.js.map