@graphty/graphty-element 2.3.0 → 2.3.1

package/dist/chunks/paletteRegistry-DnWHQsAD.js

@@ -1,3166 +0,0 @@
-import { z as j } from "zod/v4";
-import { b as Le, q as Z, G as De } from "./GraphtyLogger-5KEttFUo.js";
-import { A as Ce } from "./Algorithm-RQ629NLb.js";
-import { G as w } from "./GraphtyError-BwcnblTH.js";
-import { a as Ge, b as Ue, d as He } from "./types-B7bX5c0K.js";
-import { remapArray as se, INVALID_INDEX as W } from "@graphty/graph-format";
-import { c as Be } from "./common-DWNKjpH_.js";
-const We = 12;
-function Rn(t, e = {}) {
-  return (Je(t) ? Ve(t) : qe(t)).map((r) => {
-    const i = { ...r.meta, ...e.meta?.[r.name] }, s = r.node === null ? Ke(r.name, i, r.failure ?? "the schema could not be converted") : Xe(r.name, r.node, i), o = e.overrides?.[r.name];
-    return o === void 0 ? s : { ...s, ...o };
-  });
-}
-function Je(t) {
-  return typeof t != "object" || t === null ? !1 : "_zod" in t || "_def" in t;
-}
-function Ve(t) {
-  const e = Oe(t);
-  if (e === null)
-    return [];
-  const { properties: n } = e;
-  return n === void 0 ? [] : Object.entries(n).map(([r, i]) => ({ name: r, node: ke(i, e) }));
-}
-function qe(t) {
-  const e = Object.entries(t), n = {};
-  for (const [s, o] of e)
-    n[s] = o.schema;
-  const r = Ye(n), i = r?.properties;
-  return e.map(([s, o]) => {
-    const a = i?.[s];
-    return r === null || a === void 0 ? {
-      name: s,
-      node: null,
-      failure: "the schema could not be converted to JSON Schema",
-      meta: o.meta
-    } : { name: s, node: ke(a, r), meta: o.meta };
-  });
-}
-function Oe(t) {
-  try {
-    return j.toJSONSchema(t, { io: "input", unrepresentable: "any" });
-  } catch {
-    return null;
-  }
-}
-function Ye(t) {
-  try {
-    return Oe(j.object(t));
-  } catch {
-    return null;
-  }
-}
-const oe = "#/$defs/";
-function ke(t, e) {
-  const n = t.$ref;
-  if (n === void 0 || !n.startsWith(oe))
-    return t;
-  const r = n.slice(oe.length).replaceAll("~1", "/").replaceAll("~0", "~");
-  return e.$defs?.[r] ?? t;
-}
-function Xe(t, e, n) {
-  const r = Se(e, 0), i = Ze(r), s = {
-    name: t,
-    plainName: n.label ?? Q(t),
-    technicalName: t,
-    type: i.type
-  }, o = n.description ?? e.description ?? i.node?.description;
-  o !== void 0 && (s.description = o), "default" in e && (s.default = e.default);
-  const a = i.node;
-  if (a !== void 0 && (i.type === "number" || i.type === "integer")) {
-    const c = ae(a.minimum ?? a.exclusiveMinimum), p = ae(a.maximum ?? a.exclusiveMaximum);
-    c !== void 0 && (s.min = c), p !== void 0 && (s.max = p);
-  }
-  const l = n.step ?? a?.multipleOf;
-  return l !== void 0 && (s.step = l), i.values !== void 0 && (s.values = i.values), n.group !== void 0 && (s.group = n.group), n.advanced !== void 0 && (s.advanced = n.advanced), i.unsupportedReason !== void 0 && (s.unsupportedReason = i.unsupportedReason), s;
-}
-function Ke(t, e, n) {
-  const r = {
-    name: t,
-    plainName: e.label ?? Q(t),
-    technicalName: t,
-    type: "unknown",
-    unsupportedReason: n
-  };
-  return e.description !== void 0 && (r.description = e.description), e.step !== void 0 && (r.step = e.step), e.group !== void 0 && (r.group = e.group), e.advanced !== void 0 && (r.advanced = e.advanced), r;
-}
-function Se(t, e) {
-  if (e >= We)
-    return { arms: [], nullable: !1, unresolvedRef: !0 };
-  if (t.$ref !== void 0)
-    return { arms: [], nullable: !1, unresolvedRef: !0 };
-  const n = t.anyOf ?? t.oneOf;
-  if (n === void 0)
-    return t.type === "null" ? { arms: [], nullable: !0, unresolvedRef: !1 } : { arms: [t], nullable: !1, unresolvedRef: !1 };
-  const r = { arms: [], nullable: !1, unresolvedRef: !1 };
-  for (const i of n) {
-    const s = Se(i, e + 1);
-    r.arms.push(...s.arms), r.nullable = r.nullable || s.nullable, r.unresolvedRef = r.unresolvedRef || s.unresolvedRef;
-  }
-  return r;
-}
-function Ze(t) {
-  if (t.arms.length === 0)
-    return t.unresolvedRef ? {
-      type: "unknown",
-      unsupportedReason: "the schema is recursive, so it has no single value type"
-    } : {
-      type: "unknown",
-      unsupportedReason: t.nullable ? "the only value the schema accepts is null" : "the schema declares no value type"
-    };
-  const e = et(t.arms);
-  if (e !== void 0)
-    return { type: "enum", node: t.arms[0], values: e };
-  if (t.arms.length === 1)
-    return Qe(t.arms[0]);
-  const n = t.arms.map((r) => Ae(r));
-  return n.length === 2 && n.includes("string") && n.includes("number") ? { type: "node-id" } : {
-    type: "unknown",
-    unsupportedReason: `the schema is a union of ${n.join(" and ")}, which has no single control`
-  };
-}
-function Qe(t) {
-  switch (Ae(t)) {
-    case "integer":
-      return { type: "integer", node: t };
-    case "number":
-      return { type: "number", node: t };
-    case "boolean":
-      return { type: "boolean", node: t };
-    case "string":
-      return { type: "string", node: t };
-    case "array":
-      return {
-        type: "unknown",
-        node: t,
-        unsupportedReason: "an array option has no descriptor type; give it one with an override"
-      };
-    case "object":
-      return {
-        type: "unknown",
-        node: t,
-        unsupportedReason: "an object or record option has no descriptor type; give it one with an override"
-      };
-    default:
-      return {
-        type: "unknown",
-        node: t,
-        unsupportedReason: "the Zod construct has no JSON Schema type, so its values cannot be classified"
-      };
-  }
-}
-function et(t) {
-  const e = [];
-  for (const r of t)
-    if (r.enum !== void 0)
-      e.push(...r.enum);
-    else if ("const" in r)
-      e.push(r.const);
-    else
-      return;
-  if (e.length === 0)
-    return;
-  const n = [];
-  for (const r of e) {
-    if (typeof r != "string" && typeof r != "number" && typeof r != "boolean")
-      return;
-    const i = String(r);
-    n.push({ value: i, label: Q(i) });
-  }
-  return n;
-}
-function Ae(t) {
-  const { type: e } = t;
-  return typeof e == "string" ? e : Array.isArray(e) && e.length > 0 ? e[0] : "none";
-}
-function ae(t) {
-  if (!(t === Number.MAX_SAFE_INTEGER || t === -Number.MAX_SAFE_INTEGER))
-    return t;
-}
-function Q(t) {
-  const e = t.replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/[_-]+/gu, " ").trim();
-  return e === "" ? t : e.split(/\s+/u).map((n) => n.charAt(0).toUpperCase() + n.slice(1)).join(" ");
-}
-const ce = 3, tt = 0.1;
-function f(t, e) {
-  return Number.isInteger(t) ? t.toLocaleString(e) : Number(t.toFixed(ce)).toLocaleString(e, { maximumFractionDigits: ce });
-}
-function nt(t, e, n) {
-  const r = t.fields.find((i) => i.name === e);
-  return r === void 0 ? e : n === "technical" ? r.technicalName : r.plainName.toLowerCase();
-}
-function G(t, e, n) {
-  const r = t.fields.find((i) => i.name === e)?.unit;
-  return r === void 0 ? "" : n === 1 && r.endsWith("s") ? ` ${r.slice(0, -1)}` : ` ${r}`;
-}
-function R(t, e) {
-  const n = t.graph[e];
-  return typeof n == "number" && Number.isFinite(n) ? n : void 0;
-}
-function rt(t) {
-  return t[0];
-}
-function it(t, e, n) {
-  const { locale: r, audience: i } = n, s = nt(t, "value", i), o = rt(e.top);
-  if (o === void 0 || e.median === null)
-    return `Nothing was measured, so there is no ${s} to report.`;
-  const a = [
-    `${o.label} has the highest ${s}, at ${f(o.value, r)}${G(t, "value", o.value)}.`,
-    `The typical element sits at ${f(e.median, r)}${G(t, "value", e.median)}.`
-  ];
-  return e.measured > 0 && e.tiedAtMin / e.measured >= tt && e.min !== null && a.push(
-    `${f(e.tiedAtMin, r)} of ${f(e.measured, r)} sit at the lowest value, ${f(e.min, r)}${G(t, "value", e.min)}.`
-  ), e.count > e.measured && a.push(`${f(e.count - e.measured, r)} were not measured.`), a.join(" ");
-}
-function st(t, e, n) {
-  const { locale: r } = n, i = e.groups ?? [];
-  if (i.length === 0)
-    return "Nothing was grouped, so there are no groups to report.";
-  const s = i[0], o = [
-    `${f(i.length, r)} ${i.length === 1 ? "group" : "groups"} were found,`,
-    `the largest holding ${f(s.size, r)} of ${f(e.measured, r)}.`
-  ], a = R(t, "modularity");
-  return a !== void 0 && o.push(`Modularity is ${f(a, r)}.`), o.join(" ");
-}
-function ot(t, e) {
-  const { locale: n } = e, r = R(t, "hops"), i = R(t, "cost");
-  if (r === void 0 && i === void 0)
-    return "No route was found.";
-  const s = [];
-  return r !== void 0 && s.push(`The route runs ${f(r, n)} ${r === 1 ? "hop" : "hops"}.`), i !== void 0 && s.push(`Its total cost is ${f(i, n)}.`), s.join(" ");
-}
-function at(t, e, n) {
-  const { locale: r } = n, i = R(t, "count") ?? e.measured, s = t.shape === "edge-set" ? "edge" : "node";
-  return i === 0 ? `No ${s}s were selected.` : `${f(i, r)} ${i === 1 ? s : `${s}s`} were selected.`;
-}
-function ct(t, e) {
-  const { pairs: n } = t.graph, r = Array.isArray(n) ? n.length : 0;
-  return r === 0 ? "No pairs were found." : `${f(r, e.locale)} ${r === 1 ? "pair was" : "pairs were"} found.`;
-}
-function lt(t, e) {
-  const n = R(t, "steps");
-  return n === void 0 || n === 0 ? "The series is empty." : `The series covers ${f(n, e.locale)} ${n === 1 ? "step" : "steps"}.`;
-}
-function le(t, e) {
-  return t.measured === 0 ? "The run produced no values." : `The run covered ${f(t.measured, e.locale)} of ${f(t.count, e.locale)}.`;
-}
-function ut(t, e) {
-  const n = t.summary(), { shape: r } = t;
-  switch (r) {
-    case "node-metric":
-    case "edge-metric":
-      return it(t, n, e);
-    case "community":
-    case "layered-grouping":
-    case "category-table":
-      return st(t, n, e);
-    case "path":
-      return ot(t, e);
-    case "node-set":
-    case "edge-set":
-      return at(t, n, e);
-    case "pair-list":
-      return ct(t, e);
-    case "temporal":
-      return lt(t, e);
-    case "fact":
-      return le(n, e);
-    default:
-      return le(n, e);
-  }
-}
-function _n(t, e) {
-  const n = e === "node", r = n ? t.nodeValue : t.edgeValue, i = n ? t.nodeHas : t.edgeHas, s = n ? t.nodeIdOf : t.edgeIdOf;
-  return {
-    value: r,
-    has: i ?? ((o, a) => dt(r(o, a))),
-    idOf: s ?? null
-  };
-}
-function dt(t) {
-  return t != null;
-}
-function M(t) {
-  return t == null || t === !1 || t === "" ? !1 : Array.isArray(t) ? t.length > 0 : typeof t == "object" ? Object.keys(t).length > 0 : !0;
-}
-function J(t, e) {
-  if (t === e)
-    return !0;
-  if (Array.isArray(t) && Array.isArray(e))
-    return t.length === e.length && t.every((n, r) => J(n, e[r]));
-  if (ue(t) && ue(e)) {
-    const n = Object.keys(t);
-    return n.length === Object.keys(e).length && n.every((r) => J(t[r], e[r]));
-  }
-  return !1;
-}
-function ue(t) {
-  return typeof t == "object" && t !== null && !Array.isArray(t);
-}
-function m(t, e, n, r = {}) {
-  return new w({
-    code: "E_BAD_SELECTOR",
-    message: `${t} (at character ${String(n)} of ${JSON.stringify(e)})`,
-    source: "style",
-    details: { ...r, position: n, where: e }
-  });
-}
-const ht = Object.freeze({
-  "[": "index, slice, wildcard and filter expressions",
-  "]": "index, slice, wildcard and filter expressions",
-  "{": "multi-select hashes",
-  "}": "multi-select hashes",
-  ",": "multi-select lists",
-  "*": "wildcards",
-  "@": "the current-node reference",
-  ":": "slices"
-}), pt = ["&&", "||", "==", "!=", "<=", ">=", "!", "<", ">", ".", "(", ")"];
-function Fe(t) {
-  return /[A-Za-z_]/.test(t);
-}
-function Ee(t) {
-  return /[A-Za-z0-9_]/.test(t);
-}
-function U(t, e, n) {
-  for (let r = e + 1; r < t.length; r++) {
-    if (t[r] === "\\") {
-      r++;
-      continue;
-    }
-    if (t[r] === n)
-      return r;
-  }
-  throw m(`A ${n} is opened and never closed`, t, e, { delimiter: n });
-}
-function ft(t) {
-  let e = "";
-  for (let n = 0; n < t.length; n++) {
-    if (t[n] === "\\" && (t[n + 1] === "'" || t[n + 1] === "\\")) {
-      e += t[n + 1], n++;
-      continue;
-    }
-    e += t[n];
-  }
-  return e;
-}
-function mt(t, e, n) {
-  const r = n.replace(/\\`/g, "`");
-  try {
-    return JSON.parse(r);
-  } catch {
-    throw m(
-      `A literal between backticks must be JSON, so a bare word needs quotes: write \`"${r}"\` rather than \`${r}\``,
-      t,
-      e,
-      { literal: r }
-    );
-  }
-}
-function gt(t, e, n) {
-  try {
-    const r = JSON.parse(n);
-    if (typeof r == "string")
-      return r;
-  } catch {
-  }
-  throw m(
-    `A quoted attribute name follows JSON's rules for a string, and ${n} does not`,
-    t,
-    e,
-    { name: n }
-  );
-}
-function yt(t) {
-  const e = [];
-  let n = 0;
-  for (; n < t.length; ) {
-    const r = t.charAt(n);
-    if (/\s/.test(r)) {
-      n++;
-      continue;
-    }
-    const i = ht[r];
-    if (i !== void 0)
-      throw m(`A selector does not support ${i}`, t, n, { construct: i });
-    if (r === "|" && t.charAt(n + 1) !== "|")
-      throw m("A selector does not support pipe expressions", t, n, { construct: "pipe expressions" });
-    if (r === "&" && t.charAt(n + 1) !== "&")
-      throw m("A selector does not support expression references", t, n, {
-        construct: "expression references"
-      });
-    const s = pt.find((o) => t.startsWith(o, n));
-    if (s !== void 0) {
-      e.push({ kind: "operator", text: s, at: n }), n += s.length;
-      continue;
-    }
-    if (r === "`") {
-      const o = U(t, n, "`");
-      e.push({ kind: "literal", text: "", value: mt(t, n, t.slice(n + 1, o)), at: n }), n = o + 1;
-      continue;
-    }
-    if (r === "'") {
-      const o = U(t, n, "'");
-      e.push({ kind: "literal", text: "", value: ft(t.slice(n + 1, o)), at: n }), n = o + 1;
-      continue;
-    }
-    if (r === '"') {
-      const o = U(t, n, '"');
-      e.push({ kind: "identifier", text: gt(t, n, t.slice(n, o + 1)), at: n }), n = o + 1;
-      continue;
-    }
-    if (Fe(r)) {
-      let o = n + 1;
-      for (; o < t.length && Ee(t.charAt(o)); )
-        o++;
-      e.push({ kind: "identifier", text: t.slice(n, o), at: n }), n = o;
-      continue;
-    }
-    throw /[0-9-]/.test(r) ? m(
-      "A number in a selector goes between backticks, so write `5` rather than 5",
-      t,
-      n,
-      { character: r }
-    ) : m(`${JSON.stringify(r)} is not something a selector can contain`, t, n, {
-      character: r
-    });
-  }
-  return e.push({ kind: "end", text: "", at: t.length }), e;
-}
-const bt = Object.freeze({
-  "!=": "!=",
-  "<": "<",
-  "<=": "<=",
-  "==": "==",
-  ">": ">",
-  ">=": ">="
-});
-function F(t) {
-  return t.tokens[t.index];
-}
-function E(t, e) {
-  const n = F(t);
-  return n.kind === "operator" && n.text === e;
-}
-function wt(t) {
-  const e = F(t), n = [];
-  for (; ; ) {
-    const r = F(t);
-    if (r.kind !== "identifier")
-      throw m("A `.` must be followed by an attribute name", t.where, r.at);
-    if (r.text.includes("."))
-      throw m(
-        `A quoted attribute name may not contain a dot: ${JSON.stringify(r.text)} would be indistinguishable from two names`,
-        t.where,
-        r.at,
-        { segment: r.text }
-      );
-    if (t.index++, E(t, "("))
-      throw m(
-        `A selector does not support functions, so ${r.text}(...) cannot be called here`,
-        t.where,
-        r.at,
-        { construct: "functions", function: r.text }
-      );
-    if (n.push(r.text), !E(t, "."))
-      return { kind: "path", path: n.join("."), at: e.at };
-    t.index++;
-  }
-}
-function vt(t) {
-  const e = F(t);
-  if (e.kind === "literal")
-    return t.index++, { kind: "literal", value: e.value };
-  if (e.kind === "identifier")
-    return wt(t);
-  if (E(t, "(")) {
-    t.index++;
-    const n = Ie(t);
-    if (!E(t, ")"))
-      throw m("A `(` is opened and never closed", t.where, e.at);
-    return t.index++, { kind: "group", inner: n };
-  }
-  throw m(
-    e.kind === "end" ? "The selector ends where an attribute name, a literal or a `(` should be" : `${JSON.stringify(e.text)} is where an attribute name, a literal or a \`(\` should be`,
-    t.where,
-    e.at
-  );
-}
-function V(t) {
-  if (!E(t, "!"))
-    return vt(t);
-  const e = F(t);
-  t.index++;
-  const n = V(t);
-  if (n.kind === "path" && n.path.includes("."))
-    throw m(
-      `In JMESPath \`!\` binds tighter than \`.\`, so !${n.path} means (!${n.path.split(".")[0]})${n.path.slice(n.path.indexOf("."))} rather than the opposite of ${n.path}. Write !(${n.path}) for that`,
-      t.where,
-      e.at,
-      { path: n.path }
-    );
-  return { kind: "not", operand: n };
-}
-function de(t) {
-  const e = V(t), n = F(t), r = n.kind === "operator" ? bt[n.text] : void 0;
-  return r === void 0 ? e : (t.index++, { kind: "compare", operator: r, left: e, right: V(t) });
-}
-function he(t) {
-  let e = de(t);
-  for (; E(t, "&&"); )
-    t.index++, e = { kind: "and", left: e, right: de(t) };
-  return e;
-}
-function Ie(t) {
-  let e = he(t);
-  for (; E(t, "||"); )
-    t.index++, e = { kind: "or", left: e, right: he(t) };
-  return e;
-}
-function Nt(t) {
-  const e = { where: t, tokens: yt(t), index: 0 }, n = Ie(e), r = F(e);
-  if (r.kind !== "end")
-    throw m(
-      `${JSON.stringify(r.text)} is left over at the end of the selector`,
-      t,
-      r.at
-    );
-  return n;
-}
-function $(t, e) {
-  switch (t.kind) {
-    case "path":
-      e.includes(t.path) || e.push(t.path);
-      return;
-    case "group":
-      $(t.inner, e);
-      return;
-    case "not":
-      $(t.operand, e);
-      return;
-    case "and":
-    case "or":
-    case "compare":
-      $(t.left, e), $(t.right, e);
-      return;
-    default:
-      return;
-  }
-}
-function b(t, e) {
-  switch (t.kind) {
-    case "path": {
-      const { path: n } = t, { value: r } = e;
-      return (i) => {
-        const s = r(i, n);
-        return s === void 0 ? null : s;
-      };
-    }
-    case "literal": {
-      const { value: n } = t;
-      return () => n;
-    }
-    case "group":
-      return b(t.inner, e);
-    case "not": {
-      const n = b(t.operand, e);
-      return (r) => !M(n(r));
-    }
-    case "and": {
-      const n = b(t.left, e), r = b(t.right, e);
-      return (i) => {
-        const s = n(i);
-        return M(s) ? r(i) : s;
-      };
-    }
-    case "or": {
-      const n = b(t.left, e), r = b(t.right, e);
-      return (i) => {
-        const s = n(i);
-        return M(s) ? s : r(i);
-      };
-    }
-    default:
-      return St(t.operator, t.left, t.right, e);
-  }
-}
-const Ot = Object.freeze({
-  "<": (t, e) => t < e,
-  "<=": (t, e) => t <= e,
-  ">": (t, e) => t > e,
-  ">=": (t, e) => t >= e
-});
-function kt(t, e) {
-  return t.kind === "literal" ? t : e.kind === "literal" ? e : null;
-}
-function St(t, e, n, r) {
-  if (t === "==" || t === "!=") {
-    const a = t === "==", l = e.kind === "literal", c = kt(e, n), p = l ? n : e;
-    if (c !== null && c.value === null && p.kind === "path") {
-      const { path: d } = p, { has: v } = r;
-      return (O) => v(O, d) !== a;
-    }
-    const h = b(e, r), u = b(n, r);
-    if (c !== null && c.value !== null && typeof c.value != "object") {
-      const { value: d } = c, v = l ? u : h;
-      return (O) => v(O) === d === a;
-    }
-    return (d) => J(h(d), u(d)) === a;
-  }
-  const i = b(e, r), s = b(n, r), o = Ot[t];
-  return (a) => {
-    const l = i(a), c = s(a);
-    return typeof l == "number" && typeof c == "number" ? o(l, c) : null;
-  };
-}
-function x(t, e) {
-  switch (t.kind) {
-    case "compare":
-    case "not": {
-      const n = b(t, e);
-      return (r) => n(r) === !0;
-    }
-    case "group":
-      return x(t.inner, e);
-    case "and": {
-      const n = x(t.left, e), r = x(t.right, e);
-      return (i) => n(i) && r(i);
-    }
-    case "or": {
-      const n = x(t.left, e), r = x(t.right, e);
-      return (i) => n(i) || r(i);
-    }
-    default: {
-      const n = b(t, e);
-      return (r) => M(n(r));
-    }
-  }
-}
-function At(t) {
-  return t.split(".").map((e) => Ft(e) ? e : JSON.stringify(e)).join(".");
-}
-function Ft(t) {
-  if (t === "" || !Fe(t[0]))
-    return !1;
-  for (let e = 1; e < t.length; e++)
-    if (!Ee(t[e]))
-      return !1;
-  return !0;
-}
-function zn(t, e) {
-  const { has: n } = t;
-  return (r) => n(r, e);
-}
-function Mn(t, e) {
-  const { idOf: n } = t;
-  if (n === null)
-    throw new w({
-      code: "E_UNSUPPORTED",
-      message: 'This session cannot evaluate an "ids" selector, because it cannot say which id sits at which row. Painting the layer anyway would colour elements it never named.',
-      source: "style",
-      details: { match: "ids" }
-    });
-  return (r) => e.has(n(r));
-}
-function Pn(t, e) {
-  const n = Nt(t), r = [];
-  if ($(n, r), r.length === 0) {
-    let i = n;
-    for (; i.kind === "group"; )
-      i = i.inner;
-    const s = i.kind === "literal" && typeof i.value == "string";
-    throw m(
-      s ? "The selector is a quoted string literal, which is always true, so it would match every element. Remove the outer quotes so it is read as an expression" : 'The selector reads no attribute of the element, so it answers the same for every element. Write { match: "everything" } for a layer that really is meant to paint the whole graph',
-      t,
-      0,
-      { constant: !0 }
-    );
-  }
-  return { paths: Object.freeze(r), test: x(n, e) };
-}
-const q = "results", Et = "$";
-function P(t, e) {
-  return e === void 0 ? `${q}.${t}` : `${q}.${t}.${e}`;
-}
-const xe = {
-  // -- per element ---------------------------------------------------------------------
-  value: {
-    meaning: "The number this metric measured for this element.",
-    scope: "element",
-    types: ["number", "integer"]
-  },
-  rank: {
-    meaning: "Where this element sits when every measured element is ordered best first, starting at 1.",
-    scope: "element",
-    types: ["integer"]
-  },
-  percentile: {
-    meaning: "The share of measured elements this one ranks at or above, from 0 to 1.",
-    scope: "element",
-    types: ["number"]
-  },
-  group: {
-    meaning: "Which group this node was placed in.",
-    scope: "element",
-    types: ["integer", "string"]
-  },
-  groupSize: {
-    meaning: "How many nodes share this node's group.",
-    scope: "element",
-    types: ["integer"]
-  },
-  level: {
-    meaning: "How many levels out from the start this node sits, counting the start as 0.",
-    scope: "element",
-    types: ["integer"]
-  },
-  levelSize: {
-    meaning: "How many nodes share this node's level.",
-    scope: "element",
-    types: ["integer"]
-  },
-  category: {
-    meaning: "The category this node was sorted into.",
-    scope: "element",
-    types: ["string"]
-  },
-  score: {
-    meaning: "How strongly this node belongs to its category.",
-    scope: "element",
-    types: ["number"]
-  },
-  onPath: {
-    meaning: "Whether this element is on the route the run found.",
-    scope: "element",
-    types: ["boolean"]
-  },
-  order: {
-    meaning: "This node's position along the route, counting the source as 0.",
-    scope: "element",
-    types: ["integer"]
-  },
-  in: {
-    meaning: "Whether this element is in the set the run selected.",
-    scope: "element",
-    types: ["boolean"]
-  },
-  // -- per graph -----------------------------------------------------------------------
-  min: {
-    meaning: "The lowest value any measured element carries.",
-    scope: "graph",
-    types: ["number"]
-  },
-  max: {
-    meaning: "The highest value any measured element carries.",
-    scope: "graph",
-    types: ["number"]
-  },
-  median: {
-    meaning: "The middle value once the measured elements are ordered.",
-    scope: "graph",
-    types: ["number"]
-  },
-  mean: {
-    meaning: "The average value across the measured elements.",
-    scope: "graph",
-    types: ["number"]
-  },
-  measured: {
-    meaning: "How many elements the run produced a value for. Smaller than the scope when some elements have nothing to measure. Distinct from RunResult.measured, which counts the nodes and edges the run looked at.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  normalization: {
-    meaning: 'How the values were scaled before publication: "max", "min-max" or "none".',
-    scope: "graph",
-    types: ["string"]
-  },
-  tiedAtMin: {
-    meaning: "How many measured elements sit at the lowest value, which is what says whether a colour ramp is about to paint most of the graph one colour.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  groupCount: {
-    meaning: "How many groups the partition has.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  modularity: {
-    meaning: "How much better this partition is than a random one, from -0.5 to 1.",
-    scope: "graph",
-    types: ["number"]
-  },
-  sizes: {
-    meaning: "The size of each group or level, largest first.",
-    scope: "graph",
-    types: ["table"]
-  },
-  levelCount: {
-    meaning: "How many levels the walk reached.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  categories: {
-    meaning: "One row per category, with its name and how many elements fell into it.",
-    scope: "graph",
-    types: ["table"]
-  },
-  length: {
-    meaning: "How many nodes are on the route.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  cost: {
-    meaning: "What the route costs in total, summing the weight of every edge on it.",
-    scope: "graph",
-    types: ["number"]
-  },
-  hops: {
-    meaning: "How many edges are on the route.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  count: {
-    meaning: "How many elements are in the set.",
-    scope: "graph",
-    types: ["integer"]
-  },
-  pairs: {
-    meaning: "One row per scored pair of elements, best first.",
-    scope: "graph",
-    types: ["table"]
-  },
-  steps: {
-    meaning: "One row per time step, with the step's window and what was visible in it.",
-    scope: "graph",
-    types: ["table"]
-  },
-  series: {
-    meaning: "One row per tracked quantity, carrying its value at every step.",
-    scope: "graph",
-    types: ["table"]
-  },
-  rates: {
-    meaning: "One row per tracked quantity, carrying how fast it changed between steps.",
-    scope: "graph",
-    types: ["table"]
-  },
-  changeThreshold: {
-    meaning: "The rate of change above which a step counts as a change rather than drift.",
-    scope: "graph",
-    types: ["number"]
-  }
-}, jn = Object.keys(xe), ee = {
-  "node-metric": {
-    shape: "node-metric",
-    primaryField: "value",
-    nodeFields: ["value", "rank", "percentile"],
-    edgeFields: [],
-    graphFields: ["min", "max", "median", "mean", "measured", "normalization", "tiedAtMin"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "encoding"
-  },
-  "edge-metric": {
-    shape: "edge-metric",
-    primaryField: "value",
-    nodeFields: [],
-    edgeFields: ["value", "rank", "percentile"],
-    graphFields: ["min", "max", "median", "mean", "measured", "normalization", "tiedAtMin"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "encoding"
-  },
-  community: {
-    shape: "community",
-    primaryField: "group",
-    nodeFields: ["group", "groupSize"],
-    edgeFields: [],
-    graphFields: ["groupCount", "sizes"],
-    // Only an algorithm that scores its own partition can publish modularity. Label
-    // propagation and connected components do not, and a required field they cannot fill
-    // would be a number invented to satisfy a table.
-    optionalGraphFields: ["modularity"],
-    headlineScalar: !1,
-    layer: "encoding"
-  },
-  "layered-grouping": {
-    shape: "layered-grouping",
-    primaryField: "level",
-    nodeFields: ["level", "levelSize"],
-    edgeFields: [],
-    graphFields: ["levelCount", "sizes"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "encoding"
-  },
-  "category-table": {
-    shape: "category-table",
-    primaryField: "category",
-    nodeFields: ["category", "score", "rank"],
-    edgeFields: [],
-    graphFields: ["categories"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "encoding"
-  },
-  path: {
-    shape: "path",
-    primaryField: "onPath",
-    nodeFields: ["onPath", "order"],
-    // The edges of the route carry membership but not a position: an edge's place in the
-    // route is the order of the node it leaves.
-    edgeFields: ["onPath"],
-    graphFields: ["length", "cost", "hops"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "highlight"
-  },
-  "node-set": {
-    shape: "node-set",
-    primaryField: "in",
-    nodeFields: ["in"],
-    edgeFields: [],
-    graphFields: ["count"],
-    optionalGraphFields: [],
-    headlineScalar: !0,
-    layer: "highlight"
-  },
-  "edge-set": {
-    shape: "edge-set",
-    primaryField: "in",
-    nodeFields: [],
-    edgeFields: ["in"],
-    graphFields: ["count"],
-    optionalGraphFields: [],
-    headlineScalar: !0,
-    layer: "highlight"
-  },
-  "pair-list": {
-    shape: "pair-list",
-    primaryField: "pairs",
-    nodeFields: [],
-    edgeFields: [],
-    graphFields: ["pairs"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "none"
-  },
-  temporal: {
-    shape: "temporal",
-    primaryField: "series",
-    nodeFields: [],
-    edgeFields: [],
-    graphFields: ["steps", "series", "rates", "changeThreshold"],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "none"
-  },
-  fact: {
-    shape: "fact",
-    primaryField: null,
-    nodeFields: [],
-    edgeFields: [],
-    graphFields: [],
-    optionalGraphFields: [],
-    headlineScalar: !1,
-    layer: "none"
-  }
-};
-function Y(t) {
-  return ee[t];
-}
-function Ln(t) {
-  return ee[t].layer === "highlight";
-}
-function Dn(t, e) {
-  const n = ee[t], r = [], i = [
-    { names: n.nodeFields, kind: "node" },
-    { names: n.edgeFields, kind: "edge" },
-    { names: n.graphFields, kind: "graph" }
-  ];
-  for (const { names: s, kind: o } of i)
-    for (const a of s) {
-      const l = e.find((p) => p.name === a && p.kind === o);
-      if (l === void 0) {
-        r.push({
-          field: a,
-          kind: o,
-          reason: `shape "${t}" requires a ${o} field named "${a}"`
-        });
-        continue;
-      }
-      const c = xe[a].types;
-      c.includes(l.type) || r.push({
-        field: a,
-        kind: o,
-        reason: `${o} field "${a}" is typed "${l.type}", not ${c.map((p) => `"${p}"`).join(" or ")}`
-      });
-    }
-  return n.headlineScalar && !It(n, e) && r.push({
-    field: null,
-    kind: "graph",
-    reason: `shape "${t}" requires one graph-level scalar of its own beside "count"`
-  }), r;
-}
-function It(t, e) {
-  const n = [...t.graphFields, ...t.optionalGraphFields];
-  return e.some((r) => r.kind === "graph" && !n.includes(r.name));
-}
-const xt = 3;
-function Tt(t, e) {
-  if (t === e)
-    return 0;
-  const n = new Uint32Array(e.length + 1), r = new Uint32Array(e.length + 1);
-  for (let i = 0; i <= e.length; i++)
-    n[i] = i;
-  for (let i = 1; i <= t.length; i++) {
-    r[0] = i;
-    for (let s = 1; s <= e.length; s++) {
-      const o = n[s - 1] + (t[i - 1] === e[s - 1] ? 0 : 1);
-      r[s] = Math.min(r[s - 1] + 1, n[s] + 1, o);
-    }
-    n.set(r);
-  }
-  return n[e.length];
-}
-function $t(t, e, n = xt) {
-  const r = t.toLowerCase(), i = e.map((s) => ({
-    candidate: s,
-    distance: Tt(r, s.toLowerCase())
-  }));
-  return i.sort((s, o) => s.distance - o.distance || s.candidate.localeCompare(o.candidate)), Object.freeze(i.slice(0, Math.max(n, 0)).map((s) => s.candidate));
-}
-function pe(t) {
-  return typeof t == "string" ? t : "runId" in t ? t.runId : t.id;
-}
-function Rt(t) {
-  return typeof t == "string" ? void 0 : t.shape;
-}
-function _t(t, e) {
-  return t.fields.some((n) => n.name === e) || e in t.graph;
-}
-class zt {
-  #e;
-  /**
-   * Build the API over a registry.
-   * @param registry - Where runs are looked up.
-   */
-  constructor(e) {
-    this.#e = e;
-  }
-  /**
-   * The published path of a run's field.
-   *
-   * With no field the path names the run's primary field -- `value` for a metric, `group` for a
-   * partition, `onPath` for a route -- so a caller binds an encoding to a run without knowing
-   * what that algorithm calls its number. A `fact` result has no primary field and addresses
-   * its whole result object instead.
-   * @param run - The run, its result, or its id.
-   * @param field - The field name; the shape's primary field when absent.
-   * @returns The path.
-   */
-  path(e, n) {
-    const r = pe(e);
-    if (n !== void 0)
-      return P(r, n);
-    const i = Rt(e) ?? this.#e.entry(r)?.shape, s = i === void 0 ? null : Y(i).primaryField;
-    return s === null ? P(r) : P(r, s);
-  }
-  /**
-   * The same field, written so a selector expression can read it.
-   *
-   * The quoting is the whole point: a run id carries its algorithm's name, and a hyphenated
-   * name lexes its hyphen as subtraction, so a path pasted into an expression unquoted is a
-   * refused selector rather than a comparison. Nothing here decides WHICH field -- that is
-   * {@link ResultsApi.path}'s job and this defers to it -- so the two can never name different
-   * columns.
-   * @param run - The run, its result, or its id.
-   * @param field - The field name; the shape's primary field when absent.
-   * @returns The path with every segment quoted that needs it.
-   */
-  term(e, n) {
-    return At(n === void 0 ? this.path(e) : this.path(e, n));
-  }
-  /**
-   * One run's result.
-   *
-   * The answer always comes from the registry, even when the caller passed a result object: the
-   * question is what this session holds, and a result the session never registered is not it.
-   * @param run - The run, its result, or its id.
-   * @returns The result, or undefined when the session holds no such run or it has not
-   *   finished.
-   */
-  get(e) {
-    return this.#e.entry(pe(e))?.result;
-  }
-  /**
-   * Whether a run, or one of its fields, is available to read.
-   * @param run - The run, its result, or its id.
-   * @param field - The field name; asks only about the run itself when absent.
-   * @returns True when the path would resolve.
-   */
-  has(e, n) {
-    const r = this.get(e);
-    return r === void 0 ? !1 : n === void 0 || _t(r, n);
-  }
-  /**
-   * Every run that has published a result, as an expression editor reads them.
-   * @returns One root per finished run, in the order the runs were started.
-   */
-  get roots() {
-    const e = [];
-    for (const n of this.#e.entries())
-      n.result !== void 0 && e.push(Object.freeze({ runId: n.id, label: n.label, fields: n.result.fields }));
-    return Object.freeze(e);
-  }
-}
-function Cn(t) {
-  return new zt(t);
-}
-const Mt = 20, H = 100, Pt = 100, jt = Object.freeze([]), Lt = Object.freeze(["max", "min-max", "none"]);
-function Te(t) {
-  return typeof t == "string" && Lt.includes(t);
-}
-function Gn(t) {
-  return {
-    length: t.length,
-    get: (e) => t[e]
-  };
-}
-const Dt = Object.freeze({
-  measured: 0,
-  min: Number.NaN,
-  max: Number.NaN,
-  mean: Number.NaN,
-  median: Number.NaN,
-  tiedAtMin: 0,
-  smallestPositive: null
-});
-function $e(t) {
-  const { length: e } = t, n = new Float64Array(e);
-  let r = 0;
-  for (let u = 0; u < e; u++) {
-    const d = t.get(u);
-    Number.isFinite(d) && (n[r] = d, r++);
-  }
-  if (r === 0)
-    return { length: e, ...Dt };
-  let i = Number.POSITIVE_INFINITY, s = Number.NEGATIVE_INFINITY, o = Number.POSITIVE_INFINITY, a = 0, l = 0;
-  for (let u = 0; u < r; u++) {
-    const d = n[u];
-    d < i && (i = d), d > s && (s = d), d > 0 && d < o && (o = d);
-    const v = d - l, O = a + v;
-    l = O - a - v, a = O;
-  }
-  const c = n.slice(0, r).sort(), p = c[Math.floor((r - 1) / 2)];
-  let h = 0;
-  for (; h < r && c[h] === i; )
-    h++;
-  return {
-    length: e,
-    measured: r,
-    min: i,
-    max: s,
-    mean: a / r,
-    median: p,
-    tiedAtMin: h,
-    smallestPositive: Number.isFinite(o) ? o : null
-  };
-}
-function Re(t) {
-  const e = $e(t);
-  return { view: Object.freeze({
-    length: t.length,
-    get: (r) => t.get(r),
-    min: e.min,
-    max: e.max,
-    mean: e.mean,
-    median: e.median
-  }), statistics: e };
-}
-function te(t) {
-  const e = t.filter((o) => Number.isFinite(o.value)).map((o) => ({ entry: o, label: String(o.id) }));
-  e.sort((o, a) => o.entry.value !== a.entry.value ? a.entry.value - o.entry.value : o.label === a.label ? 0 : o.label < a.label ? -1 : 1);
-  const n = e.length, r = [];
-  let i = 0, s = Number.NaN;
-  for (let o = 0; o < n; o++) {
-    const { entry: a } = e[o];
-    a.value !== s && (i = o + 1, s = a.value), r.push(
-      Object.freeze({
-        id: a.id,
-        value: a.value,
-        rank: i,
-        percentile: (n - i + 1) / n
-      })
-    );
-  }
-  return Object.freeze(r);
-}
-function Ct(t) {
-  const { smallestPositive: e } = t;
-  if (t.measured === 0 || !(t.max > 0) || e === null)
-    return !1;
-  const n = t.min > 0 ? t.min : e;
-  return Math.log10(t.max) > Math.log10(n);
-}
-function Gt(t) {
-  return t.measured === 0 || !(t.median > 0) || t.max / t.median <= Pt ? "linear" : Ct(t) ? "log" : "linear";
-}
-function Ut(t, e, n, r) {
-  if (!(e > t))
-    return { binCount: 1, indexOf: () => 0, rangeOf: () => [t, e] };
-  if (r) {
-    const s = e - t + 1, o = Math.ceil(s / Math.min(s, n)), a = Math.ceil(s / o);
-    return {
-      binCount: a,
-      indexOf: (l) => Math.min(Math.floor((l - t) / o), a - 1),
-      rangeOf: (l) => {
-        const c = t + l * o;
-        return [c, Math.min(c + o - 1, e)];
-      }
-    };
-  }
-  const i = (e - t) / n;
-  return {
-    binCount: n,
-    indexOf: (s) => Math.min(Math.floor((s - t) / i), n - 1),
-    rangeOf: (s) => [
-      t + s * i,
-      s === n - 1 ? e : t + (s + 1) * i
-    ]
-  };
-}
-function Ht(t, e, n, r, i) {
-  const s = t > 0 ? 0 : 1, o = s === 0 ? t : n;
-  if (!(e > 0) || o === null || !(o > 0))
-    return null;
-  const a = Math.log10(o), l = Math.log10(e);
-  if (!(l > a))
-    return null;
-  const c = r - s;
-  if (c < 1)
-    return null;
-  const p = (l - a) / c;
-  return {
-    binCount: r,
-    indexOf: (h) => {
-      if (!(h > 0))
-        return 0;
-      const u = Math.floor((Math.log10(h) - a) / p);
-      return s + Math.min(Math.max(u, 0), c - 1);
-    },
-    rangeOf: (h) => {
-      if (h < s)
-        return [t, 0];
-      const u = h - s, d = u === 0 ? o : 10 ** (a + u * p), v = u === c - 1 ? e : 10 ** (a + (u + 1) * p);
-      if (!i)
-        return [d, v];
-      const O = u === 0 ? o : Math.ceil(d);
-      return [O, u === c - 1 ? e : Math.max(O, Math.ceil(v) - 1)];
-    }
-  };
-}
-function Bt(t) {
-  if (t === void 0)
-    return Mt;
-  if (!Number.isInteger(t) || t < 1 || t > H)
-    throw new w({
-      code: "E_OPTION_RANGE",
-      source: "run",
-      message: `A histogram takes between 1 and ${H} bins; ${String(t)} was asked for.`,
-      details: { option: "bins", value: t, min: 1, max: H }
-    });
-  return t;
-}
-function Wt(t, e) {
-  const n = /* @__PURE__ */ new Map();
-  for (let r = 0; r < t.length; r++) {
-    const i = t.get(r);
-    if (!Number.isFinite(i))
-      continue;
-    const s = n.get(i);
-    if (s === void 0) {
-      if (n.size >= e)
-        return null;
-      n.set(i, 1);
-      continue;
-    }
-    n.set(i, s + 1);
-  }
-  return n;
-}
-function Jt(t, e) {
-  const n = Bt(e?.bins), r = e?.integerValued ?? !1, i = $e(t), s = Gt(i), o = Wt(t, n);
-  if (o !== null) {
-    if (o.size === 0)
-      return Object.freeze({
-        bins: jt,
-        // Nothing was measured, so nothing is on any axis. Reported as linear rather
-        // than as the request, because "log scale" over an empty chart is the same false
-        // caption this whole return type exists to prevent.
-        scale: "linear",
-        suggestedScale: "linear",
-        binning: "empty"
-      });
-    const h = [...o.entries()].sort((u, d) => u[0] - d[0]).map(([u, d]) => Object.freeze({ from: u, to: u, count: d }));
-    return Object.freeze({
-      bins: Object.freeze(h),
-      // One bar per distinct value has no bands to space, so neither axis was applied to
-      // it. Saying "linear" here is what stops a caption claiming a logarithmic layout of
-      // a chart that has none.
-      scale: "linear",
-      suggestedScale: s,
-      binning: "per-value"
-    });
-  }
-  const l = e?.scale === "log" || e?.scale === "auto" && s === "log" ? Ht(i.min, i.max, i.smallestPositive, n, r) : null, c = l ?? Ut(i.min, i.max, n, r), p = new Array(c.binCount).fill(0);
-  for (let h = 0; h < t.length; h++) {
-    const u = t.get(h);
-    Number.isFinite(u) && (p[c.indexOf(u)] += 1);
-  }
-  return Object.freeze({
-    bins: Object.freeze(
-      p.map((h, u) => {
-        const [d, v] = c.rangeOf(u);
-        return Object.freeze({ from: d, to: v, count: h });
-      })
-    ),
-    // `plan` is null exactly when a logarithmic layout was asked for and could not be built,
-    // which is the case a caption must not get wrong.
-    scale: l === null ? "linear" : "log",
-    suggestedScale: s,
-    binning: "banded"
-  });
-}
-const Vt = 10, qt = 10;
-function fe(t) {
-  const e = { ids: [], records: [], index: /* @__PURE__ */ new Map() };
-  if (t === void 0)
-    return e;
-  for (const n of t) {
-    const r = e.index.get(n.id);
-    if (r === void 0) {
-      e.index.set(n.id, e.ids.length), e.ids.push(n.id), e.records.push({ ...n.values });
-      continue;
-    }
-    Object.assign(e.records[r], n.values);
-  }
-  return e;
-}
-function X(t, e) {
-  const { records: n } = t;
-  return {
-    length: n.length,
-    get: (r) => _e(n[r][e])
-  };
-}
-function ne(t, e) {
-  return t.ids.map((n, r) => ({ id: n, value: _e(t.records[r][e]) }));
-}
-function _e(t) {
-  return typeof t == "number" ? t : Number.NaN;
-}
-function re(t) {
-  return typeof t == "string" || typeof t == "number";
-}
-function B(t) {
-  return t.type === "number" || t.type === "integer";
-}
-function y(t, e, n) {
-  t[e] === void 0 && (t[e] = n);
-}
-function L(t, e, n) {
-  t[e] === void 0 && (t[e] = n);
-}
-function ze(t, e) {
-  const n = /* @__PURE__ */ new Map();
-  for (const r of t.records) {
-    const i = r[e];
-    re(i) && n.set(i, (n.get(i) ?? 0) + 1);
-  }
-  return n;
-}
-function Me(t, e) {
-  const n = String(t), r = String(e);
-  return n === r ? 0 : n < r ? -1 : 1;
-}
-function Yt(t) {
-  const e = [...t.entries()].map(([n, r]) => ({ group: n, size: r }));
-  return e.sort((n, r) => r.size - n.size || Me(n.group, r.group)), Object.freeze(e.map((n) => Object.freeze(n)));
-}
-function Pe(t, e) {
-  const n = t.find((r) => r.name === e)?.normalization;
-  return Te(n) ? n : "none";
-}
-function me(t, e, n) {
-  const { statistics: r } = Re(X(t, "value"));
-  for (const i of te(ne(t, "value"))) {
-    const s = t.index.get(i.id);
-    s !== void 0 && (L(t.records[s], "rank", i.rank), L(t.records[s], "percentile", i.percentile));
-  }
-  r.measured > 0 && (y(e, "min", r.min), y(e, "max", r.max), y(e, "median", r.median), y(e, "mean", r.mean)), y(e, "measured", r.measured), y(e, "tiedAtMin", r.tiedAtMin), y(e, "normalization", Pe(n, "value"));
-}
-function ge(t, e, n, r, i) {
-  const s = ze(t, n);
-  for (const o of t.records) {
-    const a = o[n];
-    re(a) && L(o, r, s.get(a));
-  }
-  y(e, i, s.size), y(e, "sizes", Yt(s));
-}
-function Xt(t, e) {
-  for (const r of te(ne(t, "score"))) {
-    const i = t.index.get(r.id);
-    i !== void 0 && L(t.records[i], "rank", r.rank);
-  }
-  const n = [...ze(t, "category").entries()].map(([r, i]) => ({
-    category: String(r),
-    count: i
-  }));
-  n.sort((r, i) => i.count - r.count || Me(r.category, i.category)), y(e, "categories", Object.freeze(n.map((r) => Object.freeze(r))));
-}
-function z(t, e) {
-  let n = 0;
-  for (const r of t.records)
-    r[e] === !0 && n++;
-  return n;
-}
-function ye(t, e) {
-  let n = 0;
-  for (const r of t.records)
-    r[e] !== void 0 && n++;
-  return n;
-}
-function Kt(t, e, n, r, i) {
-  switch (t) {
-    case "node-metric":
-      me(e, r, i);
-      break;
-    case "edge-metric":
-      me(n, r, i);
-      break;
-    case "community":
-      ge(e, r, "group", "groupSize", "groupCount");
-      break;
-    case "layered-grouping":
-      ge(e, r, "level", "levelSize", "levelCount");
-      break;
-    case "category-table":
-      Xt(e, r);
-      break;
-    case "path":
-      y(r, "length", z(e, "onPath")), y(r, "hops", z(n, "onPath"));
-      break;
-    case "node-set":
-      y(r, "count", z(e, "in"));
-      break;
-    case "edge-set":
-      y(r, "count", z(n, "in"));
-      break;
-  }
-}
-function Zt(t) {
-  switch (t) {
-    case "node-metric":
-    case "edge-metric":
-      return "value";
-    case "category-table":
-      return "score";
-    case "layered-grouping":
-      return "level";
-    default:
-      return null;
-  }
-}
-function Qt(t, e) {
-  if (!Array.isArray(t))
-    return;
-  const n = [];
-  for (const r of t) {
-    if (typeof r != "object" || r === null)
-      continue;
-    const i = r, s = i.group ?? i.category, o = i.size ?? i.count;
-    if (re(s) && typeof o == "number" && n.push(Object.freeze({ group: s, size: o })), n.length === e)
-      break;
-  }
-  return Object.freeze(n);
-}
-class en {
-  #e;
-  #t;
-  #n;
-  #r;
-  #i;
-  #s;
-  #o = /* @__PURE__ */ new Map();
-  #a = /* @__PURE__ */ new Map();
-  #c;
-  /**
-   * Build a result around storage that has already been filled and frozen.
-   * @param init - What the run published.
-   * @param nodes - The published nodes.
-   * @param edges - The published edges.
-   * @param graph - The graph half, frozen.
-   */
-  constructor(e, n, r, i) {
-    this.runId = e.runId, this.shape = e.shape, this.fields = Object.freeze([...e.fields]), this.measured = Object.freeze({ nodes: e.measured.nodes, edges: e.measured.edges }), this.graph = i, this.#e = n, this.#t = r, this.#n = e.caveats, this.#r = e.durationMs, this.#i = e.labelOf ?? (() => {
-    }), this.#s = e.reading ?? ut;
-  }
-  /**
-   * One node's fields.
-   * @param id - The node id.
-   * @returns The fields, or undefined when the run produced nothing for that node.
-   */
-  node(e) {
-    const n = this.#e.index.get(e);
-    return n === void 0 ? void 0 : this.#e.records[n];
-  }
-  /**
-   * One edge's fields.
-   * @param id - The edge id.
-   * @returns The fields, or undefined when the run produced nothing for that edge.
-   */
-  edge(e) {
-    const n = this.#t.index.get(e);
-    return n === void 0 ? void 0 : this.#t.records[n];
-  }
-  /**
-   * One numeric field as a column.
-   *
-   * The view reads straight through to the result's own storage and its four figures were
-   * computed on the first call, so a histogram, a colour ramp's domain and a summary all walk
-   * one column rather than three copies of it.
-   * @param field - The field name.
-   * @returns A view over the values, without an object per element.
-   * @throws A GraphtyError coded E_UNKNOWN_ATTRIBUTE when the run published no such field, or
-   *   E_BAD_COMMAND when the field is not a number published per element.
-   */
-  column(e) {
-    return this.#d(e).view;
-  }
-  /**
-   * The highest-ranked elements on one field.
-   *
-   * Elements with equal values share a rank and come back in printed-id order, so the top of a
-   * ranking does not reshuffle between two runs that measured the same thing.
-   * @param field - The field to rank on.
-   * @param limit - How many entries to return; the whole ranking when absent.
-   * @returns The entries, best first.
-   * @throws A GraphtyError coded E_OPTION_RANGE when the limit is not a whole number of
-   *   entries, E_UNKNOWN_ATTRIBUTE when the run published no such field, or E_BAD_COMMAND when
-   *   the field is not a number published per element.
-   */
-  ranking(e, n) {
-    if (n !== void 0 && (!Number.isInteger(n) || n < 0))
-      throw new w({
-        code: "E_OPTION_RANGE",
-        source: "run",
-        message: `A ranking limit is a whole number of entries, not ${String(n)}.`,
-        details: { option: "limit", value: n, min: 0 },
-        target: { kind: "run", id: this.runId }
-      });
-    const r = this.#a.get(e) ?? this.#p(e);
-    return n === void 0 ? r : Object.freeze(r.slice(0, n));
-  }
-  /**
-   * The distribution of one numeric field.
-   *
-   * Whether the field counts things is read off its own descriptor rather than passed in, so a
-   * count metric gets whole-number band edges without the caller knowing that it should.
-   * @param field - The field to bin.
-   * @param options - How to cut the bins.
-   * @returns The distribution, carrying the scale that was applied as well as the bars.
-   * @throws A GraphtyError coded E_OPTION_RANGE when the bin count is outside the permitted
-   *   range, E_UNKNOWN_ATTRIBUTE when the run published no such field, or E_BAD_COMMAND when
-   *   the field is not a number published per element.
-   */
-  histogram(e, n) {
-    const r = this.#l(e), i = r.kind === "edge" ? this.#t : this.#e;
-    return Jt(X(i, e), {
-      ...n,
-      integerValued: r.type === "integer"
-    });
-  }
-  /**
-   * The bounded form of this result.
-   *
-   * Everything on it is either a single figure or a list the element cut to a fixed length, so
-   * the object is the same size for a graph of a hundred nodes and a graph of a million.
-   * @returns The summary.
-   */
-  summary() {
-    return this.#c ??= this.#f(), this.#c;
-  }
-  /**
-   * What this result means, in one sentence of plain language.
-   * @param options - The locale and how technical to be.
-   * @returns The sentence.
-   */
-  reading(e) {
-    return this.#s(this, e ?? {});
-  }
-  /**
-   * The descriptor of one numeric per-element field, without complaining when there is none.
-   *
-   * A summary asks this rather than {@link Result.#descriptorFor} because a summary must not
-   * throw: a run whose field list does not declare the field its shape calls primary is a
-   * defect in that run, and the summary's job is to say what it can about the result rather
-   * than to refuse to describe it at all.
-   * @param field - The field name.
-   * @returns Its descriptor, or null when the run published no numeric field under that name.
-   */
-  #h(e) {
-    const n = this.fields.find((r) => r.name === e && r.kind !== "graph");
-    return n !== void 0 && B(n) ? n : null;
-  }
-  /**
-   * The descriptor of one numeric field the run published per element.
-   * @param field - The field name.
-   * @returns Its descriptor.
-   * @throws A GraphtyError naming what went wrong, with the readable fields in its details.
-   */
-  #l(e) {
-    const n = this.fields.filter((s) => s.name === e), r = n.find((s) => s.kind !== "graph"), i = this.fields.filter((s) => s.kind !== "graph" && B(s)).map((s) => s.name);
-    if (r === void 0)
-      throw n.length > 0 ? new w({
-        code: "E_BAD_COMMAND",
-        source: "run",
-        message: `"${e}" is a graph-level field of run "${this.runId}"; read it from result.graph.`,
-        details: { field: e, kind: "graph", available: i },
-        target: { kind: "run", id: this.runId }
-      }) : new w({
-        code: "E_UNKNOWN_ATTRIBUTE",
-        source: "run",
-        message: `Run "${this.runId}" published no field named "${e}".`,
-        details: { field: e, available: i, candidates: $t(e, i) },
-        target: { kind: "run", id: this.runId }
-      });
-    if (!B(r))
-      throw new w({
-        code: "E_BAD_COMMAND",
-        source: "run",
-        message: `"${e}" is typed "${r.type}", which is not a column of numbers.`,
-        details: { field: e, type: r.type, available: i },
-        target: { kind: "run", id: this.runId }
-      });
-    return r;
-  }
-  /**
-   * The half of the result a per-element field belongs to.
-   * @param field - The field name.
-   * @returns The nodes or the edges.
-   * @throws A GraphtyError naming what went wrong.
-   */
-  #u(e) {
-    return this.#l(e).kind === "edge" ? this.#t : this.#e;
-  }
-  /**
-   * One field's column and statistics, computed on the first ask and kept.
-   * @param field - The field name.
-   * @returns The view and the statistics behind it.
-   * @throws A GraphtyError naming what went wrong.
-   */
-  #d(e) {
-    const n = this.#o.get(e);
-    if (n !== void 0)
-      return n;
-    const r = Re(X(this.#u(e), e));
-    return this.#o.set(e, r), r;
-  }
-  /**
-   * Rank one field for the first time and keep the answer.
-   * @param field - The field to rank on.
-   * @returns The whole ranking, best first.
-   * @throws A GraphtyError naming what went wrong.
-   */
-  #p(e) {
-    const n = te(ne(this.#u(e), e));
-    return this.#a.set(e, n), n;
-  }
-  /**
-   * Build the bounded form of this result.
-   * @returns The summary.
-   */
-  #f() {
-    const e = Zt(this.shape), n = e === null || this.#h(e) === null ? null : e, r = n === null ? null : this.#d(n).statistics, i = r !== null && r.measured > 0 ? r : null, s = n === null ? [] : this.ranking(n, Vt).map(
-      (c) => Object.freeze({
-        id: c.id,
-        label: this.#i(c.id) ?? String(c.id),
-        value: c.value,
-        rank: c.rank,
-        percentile: c.percentile
-      })
-    ), o = {
-      count: this.#m(),
-      measured: r === null ? this.#g() : r.measured,
-      min: i === null ? null : i.min,
-      max: i === null ? null : i.max,
-      median: i === null ? null : i.median,
-      mean: i === null ? null : i.mean,
-      tiedAtMin: r === null ? 0 : r.tiedAtMin,
-      normalization: this.#y(n),
-      top: Object.freeze(s),
-      caveats: this.#n,
-      durationMs: this.#r
-    }, a = this.graph.sizes ?? this.graph.categories, l = Qt(a, qt);
-    return Object.freeze(l === void 0 ? o : { ...o, groups: l });
-  }
-  /**
-   * How many elements this result was computed over.
-   *
-   * A shape publishes per-element fields for nodes, for edges or for neither, and the scope a
-   * summary reports is the half or halves it actually measures. A shape that publishes nothing
-   * per element reports none, rather than borrowing the graph's size to look busy.
-   * @returns The count.
-   */
-  #m() {
-    const e = Y(this.shape), n = e.nodeFields.length > 0 ? this.measured.nodes : 0, r = e.edgeFields.length > 0 ? this.measured.edges : 0;
-    return n + r;
-  }
-  /**
-   * How many elements carry the shape's primary field, for a shape that measures no number.
-   * @returns The count.
-   */
-  #g() {
-    const e = Y(this.shape), { primaryField: n } = e;
-    if (n === null)
-      return 0;
-    const r = e.nodeFields.includes(n) ? ye(this.#e, n) : 0, i = e.edgeFields.includes(n) ? ye(this.#t, n) : 0;
-    return r + i;
-  }
-  /**
-   * How this result's values were scaled.
-   * @param valueField - The field a summary describes, or null when the shape measures no
-   *   number.
-   * @returns The normalisation the run published, the one its field declares, or "none".
-   */
-  #y(e) {
-    const n = this.graph.normalization;
-    return Te(n) ? n : e === null ? "none" : Pe(this.fields, e);
-  }
-}
-function tn(t) {
-  const e = fe(t.nodes), n = fe(t.edges), r = { ...t.graph };
-  Kt(t.shape, e, n, r, t.fields);
-  for (const i of e.records)
-    Object.freeze(i);
-  for (const i of n.records)
-    Object.freeze(i);
-  return new en(t, e, n, Object.freeze(r));
-}
-function nn(t) {
-  const e = t.styles?.config.data.knownFields.nodeLabelPath ?? null;
-  if (e === null)
-    return;
-  const n = t.getDataManager();
-  return (r) => {
-    const i = n.getNode(r)?.data[e];
-    return typeof i == "string" || typeof i == "number" ? String(i) : void 0;
-  };
-}
-function Un(t) {
-  return { exact: !0, precision: "f64", notes: [], ...t };
-}
-const rn = 1024, sn = 16;
-function on() {
-  return {
-    signal: new AbortController().signal,
-    report: () => {
-    },
-    yieldNow: () => new Promise((t) => {
-      setTimeout(t, 0);
-    })
-  };
-}
-async function Hn(t, e, n, r) {
-  const i = n.length;
-  t.report({ phase: e, completed: 0, total: i });
-  let s = performance.now();
-  for (let o = 0; o < i; o++)
-    o > 0 && o % rn === 0 && (t.signal.throwIfAborted(), t.report({ phase: e, completed: o, total: i }), performance.now() - s >= sn && (await t.yieldNow(), s = performance.now())), r(n[o], o);
-  t.signal.throwIfAborted(), t.report({ phase: e, completed: i, total: i });
-}
-function an(t, e, n) {
-  const r = n?.find((s) => s.name === t.name && s.kind === t.kind), i = {
-    name: t.name,
-    plainName: r?.plainName ?? t.name,
-    technicalName: r?.technicalName ?? t.name,
-    kind: t.kind,
-    type: t.type,
-    path: P(e, t.name),
-    ...r?.unit === void 0 ? {} : { unit: r.unit }
-  };
-  return t.normalization === void 0 ? i : { ...i, normalization: t.normalization };
-}
-class Bn extends Ce {
-  /** What the last run published, kept so a caller holding the algorithm can read the result. */
-  #e;
-  /**
-   * Fill in what the caller did not pass, and refuse what this algorithm does not declare.
-   *
-   * ONE DECLARATION, NOT TWO. `descriptor.options` is the only list a declared algorithm
-   * writes, and this is what makes that true at the point the values reach the running code:
-   * the same descriptors the catalogue hands a picker are what the caller's values are checked
-   * against. The older `static optionsSchema` remains the answer for a class that declares no
-   * descriptor, which is every algorithm the element itself ships.
-   *
-   * It also fixes the failure vocabulary on the way in. The older schema throws an uncoded
-   * `Error` for a bad value and SILENTLY DROPS a name it does not know, where the run path
-   * refuses the same name with `E_UNKNOWN_OPTION` -- so the same mistake produced three
-   * different outcomes depending on which door the caller came through.
-   * @param options - What the caller asked for.
-   * @returns Every declared option, with the caller's values where they were given and the
-   *   declared defaults everywhere else.
-   * @throws A `GraphtyError` with `E_UNKNOWN_OPTION` for a name this algorithm does not
-   *   declare, or `E_OPTION_RANGE` for a value it would not accept.
-   */
-  resolveOptions(e) {
-    const { descriptor: n } = this.constructor;
-    return n === void 0 ? super.resolveOptions(e) : Le(n.options, e ?? {}, {
-      kind: "algorithm",
-      id: n.key
-    });
-  }
-  /**
-   * What the last run published.
-   *
-   * THE REPLACEMENT FOR `algorithmResults`. The 1.x entry point used to scatter its numbers onto
-   * the render objects under names it chose for itself, and the only way back to them was to
-   * walk the graph. It returns a result object now, and this is where the 1.x `run()` leaves it,
-   * so the old call shape still has somewhere to read from.
-   * @returns The result, or undefined when nothing has run or there was nothing to compute.
-   */
-  get result() {
-    return this.#e;
-  }
-  /**
-   * Run the algorithm and publish what it produced on the 1.x result paths.
-   *
-   * The 1.x entry point: it returns nothing, and it publishes under the algorithm's own type
-   * rather than under a run id, because there is no run behind it. Whoever wants the result
-   * calls {@link DeclaredAlgorithm.computeRun}, which is the same work with a run in front of
-   * it.
-   * @returns A promise that settles when the result has been published.
-   */
-  async run() {
-    await this.computeRun(on(), this.type);
-  }
-  /**
-   * Compute on behalf of a run, and hand the result back.
-   *
-   * The run machinery's entry point, which is {@link DeclaredAlgorithm.computeRun} under the
-   * name every algorithm answers to.
-   * @param context - A signal, a progress channel and a yield.
-   * @param runId - The id the result is published under.
-   * @param fields - The catalogue's descriptors for this algorithm's fields.
-   * @returns The result, or undefined when there was nothing to compute.
-   * @throws Whatever the context's signal throws once the run has been cancelled.
-   */
-  publishResult(e, n, r) {
-    return this.computeRun(e, n, r);
-  }
-  /**
-   * Compute this algorithm's result, publish it under a run id, and project the 1.x view of it.
-   *
-   * This is what the run executor calls. The catalogue's own field descriptors are passed in
-   * because the catalogue states what a reader sees a field called and cannot be imported here
-   * without a cycle -- it reads these classes to publish their options.
-   * @param context - What the element gave the run: a signal, a progress channel and a yield.
-   * @param runId - The id the result is published under, which is the `<runId>` in
-   *   `results.<runId>`.
-   * @param declared - The catalogue's descriptors for this algorithm's fields, when the caller
-   *   holds them.
-   * @returns The result, or undefined when there was nothing to compute.
-   * @throws Whatever the context's signal throws once the run has been cancelled, which is a
-   *   `DOMException` named `AbortError`.
-   */
-  async computeRun(e, n, r) {
-    const i = Date.now(), s = await this.compute(e);
-    if (s === null)
-      return;
-    const o = this.graph.getDataManager(), a = nn(this.graph), l = tn({
-      ...a === void 0 ? {} : { labelOf: a },
-      runId: n,
-      shape: s.shape,
-      fields: s.fields.map((c) => an(c, n, r)),
-      measured: { nodes: o.nodes.size, edges: o.edges.size },
-      graph: s.graph,
-      nodes: s.nodes,
-      edges: s.edges,
-      caveats: s.caveats,
-      durationMs: Date.now() - i
-    });
-    return this.#e = l, l;
-  }
-}
-function Wn(t, e = "number") {
-  return [
-    { name: "value", kind: t, type: e },
-    { name: "rank", kind: t, type: "integer" },
-    { name: "percentile", kind: t, type: "number" },
-    { name: "min", kind: "graph", type: "number" },
-    { name: "max", kind: "graph", type: "number" },
-    { name: "median", kind: "graph", type: "number" },
-    { name: "mean", kind: "graph", type: "number" },
-    { name: "measured", kind: "graph", type: "integer" },
-    { name: "normalization", kind: "graph", type: "string" },
-    { name: "tiedAtMin", kind: "graph", type: "integer" }
-  ];
-}
-const be = [
-  { name: "group", kind: "node", type: "integer" },
-  { name: "groupSize", kind: "node", type: "integer" },
-  { name: "groupCount", kind: "graph", type: "integer" },
-  { name: "sizes", kind: "graph", type: "table" }
-];
-function Jn(t) {
-  return t ? [...be, { name: "modularity", kind: "graph", type: "number" }] : be;
-}
-const Vn = [
-  { name: "level", kind: "node", type: "integer" },
-  { name: "levelSize", kind: "node", type: "integer" },
-  { name: "levelCount", kind: "graph", type: "integer" },
-  { name: "sizes", kind: "graph", type: "table" }
-], qn = [
-  { name: "onPath", kind: "node", type: "boolean" },
-  { name: "order", kind: "node", type: "integer" },
-  { name: "onPath", kind: "edge", type: "boolean" },
-  { name: "length", kind: "graph", type: "integer" },
-  { name: "cost", kind: "graph", type: "number" },
-  { name: "hops", kind: "graph", type: "integer" }
-];
-function Yn(t, e) {
-  return [
-    { name: "in", kind: t, type: "boolean" },
-    { name: "count", kind: "graph", type: "integer" },
-    { ...e, kind: "graph" }
-  ];
-}
-const cn = `${q}.${Et}`;
-function N(t) {
-  return { ...t, path: `${cn}.${t.name}` };
-}
-function Xn(t) {
-  return [
-    N({
-      name: "value",
-      plainName: t.plainName,
-      technicalName: t.technicalName,
-      kind: "node",
-      type: t.type ?? "number",
-      ...t.unit === void 0 ? {} : { unit: t.unit }
-    }),
-    N({ name: "rank", plainName: "Rank", technicalName: "rank", kind: "node", type: "integer" }),
-    N({
-      name: "percentile",
-      plainName: "Percentile",
-      technicalName: "percentile",
-      kind: "node",
-      type: "number"
-    }),
-    N({ name: "min", plainName: "Lowest", technicalName: "min", kind: "graph", type: "number" }),
-    N({ name: "max", plainName: "Highest", technicalName: "max", kind: "graph", type: "number" }),
-    N({ name: "median", plainName: "Middle", technicalName: "median", kind: "graph", type: "number" }),
-    N({ name: "mean", plainName: "Average", technicalName: "mean", kind: "graph", type: "number" }),
-    N({
-      name: "measured",
-      plainName: "Measured",
-      technicalName: "measured",
-      kind: "graph",
-      type: "integer"
-    }),
-    N({
-      name: "normalization",
-      plainName: "Normalization",
-      technicalName: "normalization",
-      kind: "graph",
-      type: "string"
-    }),
-    N({
-      name: "tiedAtMin",
-      plainName: "Tied at the lowest value",
-      technicalName: "tiedAtMin",
-      kind: "graph",
-      type: "integer"
-    })
-  ];
-}
-const _ = Z({
-  kind: "format",
-  idOf: (t) => t.descriptor.id,
-  descriptorOf: (t) => t.descriptor,
-  implementationOf: (t) => t.descriptor,
-  builtInIds: () => Ge
-});
-function Kn(t, e) {
-  _.register(t, e);
-}
-function Zn() {
-  return _.entries();
-}
-function ln() {
-  return _.descriptors();
-}
-function un(t) {
-  return _.byId(t);
-}
-function Qn() {
-  _.clearForTesting();
-}
-const dn = {
-  "edge-list": "Edge List",
-  "node-list": "Node List",
-  "adjacency-list": "Adjacency List",
-  neo4j: "Neo4j Export",
-  gephi: "Gephi Export",
-  cytoscape: "Cytoscape Export",
-  generic: "Generic"
-}, hn = [
-  {
-    name: "delimiter",
-    plainName: "Column Separator",
-    technicalName: "delimiter",
-    type: "string",
-    description: "The character between one column and the next. Worked out from the first line (comma, tab, semicolon or pipe) when it is not set."
-  },
-  {
-    name: "variant",
-    plainName: "File Shape",
-    technicalName: "variant",
-    type: "enum",
-    values: Object.entries(dn).map(([t, e]) => ({ value: t, label: e })),
-    description: "Which CSV shape to read. Worked out from the header row when it is not set."
-  },
-  {
-    name: "idColumn",
-    plainName: "Node Id Column",
-    technicalName: "idColumn",
-    type: "string",
-    description: "The column holding each node's identity, when the file lists nodes."
-  }
-], S = [
-  {
-    name: "edgeSource",
-    plainName: "Edge Start Field",
-    technicalName: "edgeSource",
-    type: "string",
-    description: "Where to find the node an edge starts at. Left unset, the element looks for source, then src, then from."
-  },
-  {
-    name: "edgeTarget",
-    plainName: "Edge End Field",
-    technicalName: "edgeTarget",
-    type: "string",
-    description: "Where to find the node an edge ends at. Left unset, the element looks for target, then dst, then to."
-  }
-], pn = [
-  {
-    name: "nodeIdPath",
-    plainName: "Node Id Field",
-    technicalName: "nodeIdPath",
-    type: "string",
-    description: "An expression selecting each node's identity out of the node record."
-  }
-], je = [
-  {
-    id: "json",
-    plainName: "JSON",
-    extensions: [".json"],
-    mimeTypes: ["application/json"],
-    canImport: !0,
-    canExport: !1,
-    options: [...pn, ...S]
-  },
-  {
-    id: "csv",
-    plainName: "CSV",
-    extensions: [".csv", ".tsv", ".tab", ".edges", ".edgelist"],
-    mimeTypes: ["text/csv", "text/tab-separated-values", "text/plain"],
-    canImport: !0,
-    canExport: !1,
-    options: [...hn, ...S]
-  },
-  {
-    id: "graphml",
-    plainName: "GraphML",
-    extensions: [".graphml", ".xml"],
-    mimeTypes: ["application/graphml+xml", "application/xml", "text/xml"],
-    canImport: !0,
-    canExport: !1,
-    options: S
-  },
-  {
-    id: "gexf",
-    plainName: "GEXF",
-    // ".xml" is claimed here as well as by GraphML because both formats are XML and both are
-    // routinely saved under the generic extension. Two claimants is what lets detection ask
-    // each one's content sniffer which of them the file actually is, instead of a private
-    // branch inside the detector hard-coding the two namespace strings -- which is the same
-    // route a third party's XML dialect now takes.
-    extensions: [".gexf", ".xml"],
-    mimeTypes: ["application/gexf+xml", "application/xml", "text/xml"],
-    canImport: !0,
-    canExport: !1,
-    options: S
-  },
-  {
-    id: "gml",
-    plainName: "GML",
-    extensions: [".gml"],
-    mimeTypes: ["text/plain"],
-    canImport: !0,
-    canExport: !1,
-    options: S
-  },
-  {
-    id: "dot",
-    plainName: "DOT",
-    extensions: [".dot", ".gv"],
-    mimeTypes: ["text/vnd.graphviz", "text/plain"],
-    canImport: !0,
-    canExport: !1,
-    options: S
-  },
-  {
-    id: "pajek",
-    plainName: "Pajek NET",
-    extensions: [".net", ".paj"],
-    mimeTypes: ["text/plain"],
-    canImport: !0,
-    canExport: !1,
-    options: S
-  }
-], er = [
-  { id: "sif", reason: "No data source reads the Cytoscape simple interaction format." },
-  { id: "cx2", reason: "No data source reads the Cytoscape Exchange format." }
-];
-function tr(t) {
-  return je.find((e) => e.id === t) ?? un(t)?.descriptor;
-}
-function nr(t) {
-  const e = t.toLowerCase();
-  return [...je, ...ln()].filter(
-    (n) => n.extensions.includes(e)
-  );
-}
-const D = Z({
-  kind: "layout",
-  idOf: (t) => t.descriptor.id,
-  descriptorOf: (t) => t.descriptor,
-  implementationOf: (t) => t.descriptor,
-  builtInIds: () => Ue
-});
-function fn(t, e) {
-  D.register(t, e);
-}
-function rr() {
-  return D.descriptors();
-}
-function ir(t) {
-  return D.byId(t);
-}
-function sr() {
-  D.clearForTesting();
-}
-const g = 3, mn = 1024;
-function T(t, e) {
-  if (!Number.isInteger(t) || t < 0)
-    throw new RangeError(`ElementPositions: ${e} must be a non-negative integer, found ${String(t)}`);
-  return t;
-}
-function A(t) {
-  return Number.isFinite(Math.fround(t));
-}
-class we {
-  /**
-   * Allocate the backing array, every row unplaced and unpinned.
-   * @param capacity - rows to reserve before the first growth; a non-negative integer
-   */
-  constructor(e = mn) {
-    this.components = g, this.rows = 0, T(e, "capacity");
-    const n = Math.max(1, e);
-    this.array = new Float32Array(g * n), this.array.fill(Number.NaN), this.pins = new Uint8Array(n);
-  }
-  /**
-   * Rows the backing array can hold without reallocating.
-   * @returns the current capacity in rows
-   */
-  get capacity() {
-    return this.array.length / g;
-  }
-  /**
-   * Rows currently in use. Equals the last snapshot's nodeCount.
-   * @returns the live row count
-   */
-  get count() {
-    return this.rows;
-  }
-  /**
-   * How many live rows carry real coordinates, by the same test {@link ElementPositions.isPlaced}
-   * applies one row at a time.
-   *
-   * The question behind it is "did the file that loaded this graph place every node?", which is
-   * what decides whether the Keep Positions arrangement can be used at all: a fixed layout over a
-   * graph where half the rows are NaN draws half a picture. Compare it against
-   * {@link ElementPositions.count} to answer that -- equal means every node has somewhere to go.
-   *
-   * COUNTED ON EVERY READ, and it has to be. The array is lent to the snapshot as a mutable
-   * column, so a layout, a drag and a GPU readback all write coordinates without passing through
-   * this class; a counter kept up to date by `write()` would miss every one of those and would be
-   * most wrong exactly while a layout was running, which is when somebody is asking. The scan is
-   * one f32 read per node and touches only the x lane.
-   *
-   * This is deliberately NOT on `GraphStatistics`. Those are memoised against the snapshot they
-   * were computed from, and how many nodes carry a coordinate changes while a layout runs WITHIN
-   * one snapshot, so a cached answer would be stale in the one moment it mattered.
-   * @returns how many rows in `[0, count)` carry a storable x
-   */
-  get placedCount() {
-    let e = 0;
-    for (let n = 0; n < g * this.rows; n += g)
-      this.hasStorableX(n) && e++;
-    return e;
-  }
-  /**
-   * The exact view to hand to `snapshot.nodes.set("position", ...)`.
-   *
-   * Bounded by the LIVE ROW COUNT, like every other row accessor here. `subarray` CLAMPS rather
-   * than throwing, so without a check a caller that forgot to `grow()` first would get a short
-   * array: E_COLUMN_LENGTH from inside graph-format if it is attached, and a layout that silently
-   * places only the first `count` nodes if it is not. Bounding by the CAPACITY instead would hand
-   * out a writable window over the spare rows -- rows this class reports unplaced, whose NaN fill
-   * every later `grow()` and `remap()` depends on, and whose contents the next growth erases.
-   * @param nodeCount - the snapshot's node count
-   * @returns a subarray of length `3 * nodeCount` over the same buffer
-   * @throws RangeError when `nodeCount` is not a non-negative integer, or exceeds the live count
-   */
-  view(e) {
-    if (T(e, "nodeCount"), e > this.rows)
-      throw new RangeError(
-        `ElementPositions: view(${e}) needs ${e} live rows but only ${this.rows} exist; call grow(${e}) first`
-      );
-    return this.array.subarray(0, g * e);
-  }
-  /**
-   * Prefix-stable growth: existing rows keep their coordinates, EVERY row at or above the new
-   * count is unplaced -- including the spare capacity, which a later grow() will hand out.
-   *
-   * Past the capacity this REPLACES the array object; see the staleness contract on the class.
-   * @param nodeCount - the new row count; may be smaller than the current one (append-only
-   *     builders never shrink, but a caller that does gets a truncation, not a throw). `grow(0)`
-   *     is how a dataset is discarded while the reserve is kept
-   * @throws RangeError when `nodeCount` is not a non-negative integer
-   */
-  grow(e) {
-    if (T(e, "nodeCount"), e > this.capacity) {
-      const n = Math.max(this.capacity * 2, e), r = new Float32Array(g * n);
-      r.set(this.array), r.fill(Number.NaN, g * this.rows), this.array = r;
-      const i = new Uint8Array(n);
-      i.set(this.pins), i.fill(0, this.rows), this.pins = i;
-    } else e > this.rows ? (this.array.fill(Number.NaN, g * this.rows, g * e), this.pins.fill(0, this.rows, e)) : e < this.rows && (this.array.fill(Number.NaN, g * e, g * this.rows), this.pins.fill(0, e, this.rows));
-    this.rows = e;
-  }
-  /**
-   * Apply a freeze report's `nodeRemap` (previous index space -> new index or INVALID_INDEX).
-   *
-   * `remapArray` ALLOCATES, so this replaces the array object and collapses the capacity to
-   * exactly `nodeCount` (PLAN DECISION 3: a removal is rare and never per frame, so paying one
-   * reallocation on the next growth is cheaper than copying the remapped rows a second time into
-   * a re-reserved array). Every holder of the old object is stale afterwards, which is why
-   * GraphStore re-attaches the column on every freeze and emits `snapshot-replaced`.
-   * @param nodeRemap - the report's nodeRemap
-   * @param nodeCount - the new snapshot's node count
-   * @throws RangeError when `nodeCount` is not a non-negative integer
-   */
-  remap(e, n) {
-    T(n, "nodeCount"), this.array = se(this.array, e, n, Number.NaN, g), this.pins = se(this.pins, e, n, 0, 1), this.rows = n;
-  }
-  /**
-   * Whether the reader has fixed this row's node in place.
-   *
-   * A row outside the live count is UNPINNED, never pinned, for the same reason
-   * {@link ElementPositions.isPlaced} answers false there: a node with no row is a node the
-   * graph builder has not taken, and answering "pinned" for one would freeze a node that does
-   * not exist yet and that nothing could release.
-   * @param index - node index
-   * @returns true when the row is inside the live count AND carries a pin
-   */
-  isPinned(e) {
-    return !Number.isInteger(e) || e < 0 || e >= this.rows ? !1 : this.pins[e] === 1;
-  }
-  /**
-   * Record or release a pin, GROWING the lane to reach the row.
-   *
-   * It grows rather than throwing for the same reason `LayoutEngine.writeNodePosition` does: a
-   * node's index is handed out the moment the graph builder takes its record, but its row only
-   * appears when the graph is next frozen, and a reader who drags a node in between would
-   * otherwise have the pin thrown away in silence.
-   *
-   * It REFUSES rather than throwing for an index that is not a row number at all -- the
-   * `INVALID_INDEX` a record the builder would not take carries for its whole life, or a
-   * negative or fractional number. Pinning happens from a pointer gesture, and a throw on that
-   * path takes the frame with it.
-   * @param index - node index
-   * @param pinned - true to pin, false to release
-   * @returns true when the lane was written, false when the index names no row
-   */
-  setPinned(e, n) {
-    return e === W || !Number.isInteger(e) || e < 0 ? !1 : (e >= this.rows && this.grow(e + 1), this.pins[e] = n ? 1 : 0, !0);
-  }
-  /**
-   * How many live rows are pinned.
-   * @returns the count of pinned rows in `[0, count)`
-   */
-  get pinnedCount() {
-    let e = 0;
-    for (let n = 0; n < this.rows; n++)
-      this.pins[n] === 1 && e++;
-    return e;
-  }
-  /**
-   * The exact view to hand to `snapshot.nodes.set("graphty.pinned", ...)`.
-   *
-   * Bounded by the live row count, like {@link ElementPositions.view} and for the same reasons.
-   * @param nodeCount - the snapshot's node count
-   * @returns a subarray of length `nodeCount` over the same buffer
-   * @throws RangeError when `nodeCount` is not a non-negative integer, or exceeds the live count
-   */
-  pinnedView(e) {
-    if (T(e, "nodeCount"), e > this.rows)
-      throw new RangeError(
-        `ElementPositions: pinnedView(${e}) needs ${e} live rows but only ${this.rows} exist; call grow(${e}) first`
-      );
-    return this.pins.subarray(0, e);
-  }
-  /**
-   * Report whether a row carries real coordinates.
-   *
-   * A row outside the live count is UNPLACED, never placed: this predicate is used to decide
-   * whether an importer seed may be written, and answering "placed" for a row that does not
-   * exist is how a coordinate gets thrown away without an error. So is a row whose x is an
-   * infinity, which only a writer that bypassed `write()` -- that is, one writing through the
-   * column this array is lent to -- can produce; see the class comment.
-   * @param index - node index
-   * @returns true when the row is inside the live count AND carries a storable x
-   */
-  isPlaced(e) {
-    return !Number.isInteger(e) || e < 0 || e >= this.rows ? !1 : this.hasStorableX(g * e);
-  }
-  /**
-   * Read one row into a caller-supplied object (14.4 rule 7: never return a shared vector).
-   * @param index - node index
-   * @param out - the object to fill
-   * @param out.x - receives the scene-unit x
-   * @param out.y - receives the scene-unit y
-   * @param out.z - receives the scene-unit z
-   * @throws RangeError when `index` is not an integer in `[0, count)`
-   */
-  read(e, n) {
-    const r = this.rowBase(e);
-    n.x = this.array[r] ?? Number.NaN, n.y = this.array[r + 1] ?? Number.NaN, n.z = this.array[r + 2] ?? Number.NaN;
-  }
-  /**
-   * Write one row.
-   *
-   * This is the ONE choke point every layout, every drag and (from E1) every GPU readback goes
-   * through, so it is where an unstorable coordinate is stopped. NaN is this class's unplaced
-   * marker: letting one in through here would unplace a placed node from the inside, and an
-   * infinity would be stored and then reported placed. The test is `isStorableCoordinate`, NOT
-   * `Number.isFinite`, because the array is f32: a finite double of 1e39 passes `isFinite` and
-   * lands as Infinity. A caller holding such a coordinate has a bug upstream and must drop the
-   * update, not hand it on.
-   * @param index - node index
-   * @param x - scene-unit x
-   * @param y - scene-unit y
-   * @param z - scene-unit z
-   * @throws RangeError when `index` is not an integer in `[0, count)`. A node added since the
-   *     last freeze has no row yet: freeze first (which grows this array), then write
-   * @throws RangeError when any component is NaN, an infinity, or a double that overflows f32
-   */
-  write(e, n, r, i) {
-    const s = this.rowBase(e);
-    if (!A(n) || !A(r) || !A(i))
-      throw new RangeError(
-        `ElementPositions: row ${String(e)} was written the unstorable coordinate (${String(n)}, ${String(r)}, ${String(i)}); NaN is this class's UNPLACED marker, and an infinity -- including one an f32 overflow produces -- poisons the scene bounds`
-      );
-    this.array[s] = n, this.array[s + 1] = r, this.array[s + 2] = i;
-  }
-  /**
-   * Write a row ONLY when it is unplaced. This is how importer-seeded coordinates reach a new
-   * node without overwriting anything a layout or a drag already produced.
-   *
-   * `false` means exactly one thing -- the row was ALREADY PLACED, by the same test `isPlaced()`
-   * applies. A row that does not exist yet throws instead of returning `false`, so a caller that
-   * seeds before growing finds out rather than losing the coordinate.
-   * @param index - node index
-   * @param x - scene-unit x
-   * @param y - scene-unit y
-   * @param z - scene-unit z
-   * @returns true when the row was written, false when it was already placed
-   * @throws RangeError when `index` is not an integer in `[0, count)`
-   * @throws RangeError when any component is NaN, an infinity, or a double that overflows f32,
-   *     through `write()`
-   */
-  fillUnplaced(e, n, r, i) {
-    const s = this.rowBase(e);
-    return this.hasStorableX(s) ? !1 : (this.write(e, n, r, i), !0);
-  }
-  /**
-   * Whether the row at this offset carries a storable x, which is the one test "placed" means.
-   * @param base - the array offset of the row's x component
-   * @returns true when the stored x is neither NaN nor an infinity
-   */
-  hasStorableX(e) {
-    return A(this.array[e] ?? Number.NaN);
-  }
-  /**
-   * The array offset of a live row, rejecting anything else.
-   * @param index - node index
-   * @returns the offset of the row's x component
-   */
-  rowBase(e) {
-    if (!Number.isInteger(e) || e < 0 || e >= this.rows)
-      throw new RangeError(
-        e === W ? "ElementPositions: INVALID_INDEX is the graph-format 'no node' sentinel, not a row" : `ElementPositions: row ${String(e)} is outside the live range [0, ${this.rows})`
-      );
-    return g * e;
-  }
-}
-const k = /* @__PURE__ */ new Map(), gn = Object.freeze([
-  "arf",
-  "bfs",
-  "bipartite",
-  "circular",
-  "d3",
-  "fixed",
-  "forceatlas2",
-  "kamada-kawai",
-  "multipartite",
-  "ngraph",
-  "planar",
-  "random",
-  "shell",
-  "spectral",
-  "spiral",
-  "spring",
-  "spring-electrical"
-]), yn = De.getLogger(["graphty", "layout"]), ve = 1e-6;
-function bn(t, e) {
-  return JSON.stringify([t, e]);
-}
-const wn = 10;
-function Ne(t) {
-  return new w({
-    code: "E_DUPLICATE_PLUGIN",
-    message: `"${t}" is a layout engine the element ships, and a built-in name may not be taken: a saved document that named it yesterday has to mean the same thing today`,
-    source: "registry",
-    details: { kind: "layout", name: t, builtIn: !0 }
-  });
-}
-const ie = class ie {
-  constructor() {
-    this.positionArrayAttached = !1;
-  }
-  /**
-   * Add multiple nodes to the layout engine
-   * @param nodes - Array of nodes to add
-   */
-  addNodes(e) {
-    for (const n of e)
-      this.addNode(n);
-  }
-  /**
-   * Add multiple edges to the layout engine
-   * @param edges - Array of edges to add
-   */
-  addEdges(e) {
-    for (const n of e)
-      this.addEdge(n);
-  }
-  /**
-   * Take a node out of the layout, before the element disposes the mesh that drew it.
-   *
-   * Declared here, with a default that does nothing, because it used to be duck-typed by the
-   * element's data manager and implemented by none of the seventeen engines that ship here: an
-   * author learned it existed by reading the element's source, and got no worked example. An
-   * engine that keeps its own node list must override this, or it holds every removed node --
-   * and everything that node references -- for as long as the engine lives.
-   * @param _n - the node leaving the graph
-   */
-  removeNode(e) {
-  }
-  /**
-   * The edge half of {@link LayoutEngine.removeNode}, with the same default and the same reason.
-   * @param _e - the edge leaving the graph
-   */
-  removeEdge(e) {
-  }
-  /**
-   * Settle nodes that reached the graph after this layout was already running.
-   *
-   * THE DEFAULT IS THE ELEMENT'S OWN FALLBACK -- up to ten steps, stopping early if the engine
-   * settles -- so a simulation behaves exactly as it did before the hook was declared, and an
-   * engine that can place a newcomer without re-running the whole simulation overrides it. It
-   * lives on the base class rather than in the manager because the manager cannot tell "did not
-   * implement it" from "implemented it as a deliberate no-op", and the difference decides
-   * whether ten steps run.
-   * @param _nodes - the nodes that have just arrived
-   */
-  updatePositions(e) {
-    for (let n = 0; n < wn; n++) {
-      if (this.isSettled)
-        return;
-      this.step();
-    }
-  }
-  /**
-   * Release whatever this engine holds. The element calls it when the reader switches layouts
-   * and when the graph is torn down, and never uses the engine again afterwards.
-   *
-   * Declared with a do-nothing default for the same reason as {@link LayoutEngine.removeNode}:
-   * it was duck-typed, undeclared and unimplemented by every engine here.
-   */
-  dispose() {
-  }
-  /**
-   * The array this engine publishes node coordinates into.
-   *
-   * Allocated on demand, so reading it is enough to make an engine that has never been handed an
-   * element's array produce one of its own.
-   * @returns the position array in use
-   */
-  get nodePositions() {
-    return this.positionArray ??= new we(0), this.positionArray;
-  }
-  /**
-   * Hand this engine the array it must publish into, and stop it adopting any other.
-   *
-   * This is how a host says "these coordinates are mine": the engine writes into the array the
-   * host already lends to its snapshots, so a layout, a drag and a GPU readback all land in the
-   * one place and a re-freeze loses none of them.
-   * @param positions - the element-owned array
-   */
-  attachPositions(e) {
-    this.positionArray = e, this.positionArrayAttached = !0;
-  }
-  /**
-   * Copy every node's current coordinates out of the engine and into the position array.
-   *
-   * Engines call this at the end of a step, so that by the time anything draws, the array is the
-   * answer rather than a copy of it. The default walks the engine's own nodes through
-   * {@link LayoutEngine.getNodePosition}, which is correct for any engine but allocates one
-   * object per node; an engine that can read its own state without allocating overrides it, and
-   * an engine that already writes straight into the array overrides it to do nothing.
-   */
-  publishPositions() {
-    for (const e of this.nodes) {
-      const n = this.getNodePosition(e);
-      this.writeNodePosition(e, n.x, n.y, n.z ?? 0);
-    }
-  }
-  /**
-   * Read a node's published coordinates into an object the CALLER owns.
-   *
-   * The point of the out parameter is that a renderer can pass the vector it is about to draw
-   * with and allocate nothing per node per frame. A row that no engine has placed answers false
-   * and leaves `out` untouched, so the caller keeps whatever it had rather than being handed a
-   * NaN or an origin it cannot tell from a real coordinate.
-   * @param n - the node to read
-   * @param out - the object to fill; a Babylon `Vector3` is one, which is the point
-   * @param out.x - receives the scene-unit x
-   * @param out.y - receives the scene-unit y
-   * @param out.z - receives the scene-unit z
-   * @returns true when the node has a placed row
-   */
-  readNodePosition(e, n) {
-    const r = this.positionsFor(e);
-    return r.isPlaced(e.index) ? (r.read(e.index, n), !0) : !1;
-  }
-  /**
-   * Publish one node's coordinates, growing the array to reach its row.
-   *
-   * Three things are silently skipped rather than thrown, because this runs inside a layout step
-   * and a throw there kills the frame: a node with no row in the graph (`INVALID_INDEX`, which a
-   * record whose id the graph builder would not take carries for its whole life), a node whose
-   * index is not a row number at all, and a coordinate that cannot be stored. That last one is
-   * the important one -- a force layout that divided by a zero distance produces NaN, and an
-   * overflow of the f32 the array stores produces an infinity. Either one, written, would make
-   * the row read back as a place: the mesh vanishes and the scene bounds and camera framing go
-   * with it. Left alone, the row stays unplaced and the node keeps the coordinates it had.
-   *
-   * The array is GROWN to reach the row rather than the write being refused. A node's index is
-   * handed out the moment its record is taken, but its row only appears when the graph is next
-   * frozen, and a layout that ran in between would otherwise be thrown away in silence. Growth is
-   * prefix-stable and fills what it adds with NaN, so it cannot disturb a row anything else
-   * placed; the one thing it does change is that a node this engine placed before the first
-   * freeze counts as placed, which is what makes a file's own coordinates yield to it.
-   *
-   * A PINNED ROW REFUSES A LAYOUT STEP. This is the whole of "a pin is meaningful under every
-   * arrangement": twelve of the element's seventeen engines implement `pin()` as a no-op and
-   * `setNodePosition` as a no-op too, so before this guard a reader who dragged a node under a
-   * static layout watched it snap back the next time the layout recomputed. One refusal here
-   * covers every engine, including one written by a third party that has never heard of pinning,
-   * because every engine reaches the shared array through this method.
-   *
-   * A DRAG IS NOT A LAYOUT STEP. `intent: "placement"` writes straight through, so a reader can
-   * move a pinned node and have it stay where they put it; without that distinction the guard
-   * would make a pinned node undraggable, which is the opposite of what a pin is for. The
-   * default is `"layout"` so that an engine written before the parameter existed -- a plugin's
-   * step loop -- is guarded without knowing it, and only the placement paths have to opt out.
-   * @param n - the node being placed
-   * @param x - scene-unit x
-   * @param y - scene-unit y
-   * @param z - scene-unit z
-   * @param intent - `"layout"` for a simulation step, `"placement"` for a drag or a replay
-   * @returns true when the row was written
-   */
-  writeNodePosition(e, n, r, i, s = "layout") {
-    const { index: o } = e;
-    if (o === W || !Number.isInteger(o) || o < 0 || !A(n) || !A(r) || !A(i))
-      return !1;
-    const a = this.positionsFor(e);
-    return s === "layout" && a.isPinned(o) ? !1 : (o >= a.count && a.grow(o + 1), a.write(o, n, r, i), !0);
-  }
-  /**
-   * The weight of every ordered endpoint pair this batch of edges covers, or null when the
-   * graph's weights carry no information.
-   *
-   * WHY A PAIR AND NOT AN EDGE. `@graphty/layout`'s one weight channel is
-   * `graph.getEdgeData(source, target, attr)`, which is asked by endpoint pair, and both layout
-   * functions that read it write the answer into a matrix cell -- `A[i][j]` in ForceAtlas2,
-   * `distances[s][t]` in Kamada-Kawai. There is no cell for a second edge between the same two
-   * nodes, so parallel edges are SUMMED into one number rather than left to last-writer-wins,
-   * where the order the file happened to list them in would decide the arrangement. Summing is
-   * also what the element does when it simplifies a multigraph for an algorithm, so a graph's
-   * weights mean the same thing to a layout and to a metric.
-   *
-   * READ ONCE PER LAYOUT COMPUTATION, not per frame and not per edge: the weights come from the
-   * current snapshot's edge list, indexed by the same logical edge index `Edge.index` holds.
-   *
-   * NULL MEANS "DO NOT ATTACH A CALLBACK". graph-format stores an all-ones graph with no weight
-   * column at all, and a graph whose every weight is 1 carries no information a layout could
-   * arrange by -- so the caller leaves `getEdgeData` off the graph object entirely and the
-   * arrangement is bit-identical to the one the same seed produced before weights existed.
-   *
-   * THIS IS A SLIGHTLY NARROWER QUESTION THAN `statistics().weighted`, deliberately. The status
-   * chip asks whether the SNAPSHOT's weight column carries anything but ones; this asks it of
-   * the edges this engine is actually about to arrange. They answer differently only when the
-   * engine holds a strict subset of the graph's edges whose weights are all 1, and there the
-   * narrower answer is the correct one: a layout cannot be moved by a weight on an edge it is
-   * not laying out. A consumer who sees "weighted" on the status bar and an unmoved arrangement
-   * is looking at that case.
-   * @param edges - the edges this engine is about to lay out
-   * @returns pair key (see {@link pairWeightKey}) to summed weight, or null
-   */
-  pairWeights(e) {
-    if (e.length === 0)
-      return null;
-    const r = e[0].parentGraph?.getDataManager?.()?.getSnapshot?.()?.edgeList().weights ?? null;
-    if (r === null)
-      return null;
-    const i = /* @__PURE__ */ new Map();
-    let s = !1;
-    for (const o of e) {
-      const a = o.index >= 0 && o.index < r.length ? r[o.index] : 1;
-      a !== 1 && (s = !0);
-      const l = bn(o.srcId, o.dstId);
-      i.set(l, (i.get(l) ?? 0) + a);
-    }
-    return s ? i : null;
-  }
-  /**
-   * Say once, per layout computation, how many pairs were clamped off zero.
-   *
-   * ONCE PER RUN AND NOT PER EDGE: a graph whose weights are all zero would otherwise produce
-   * one line per edge, which buries every other message in the run it happened during. It is
-   * reported at all because a clamp changes the picture -- a zero-weight edge is drawn as the
-   * weakest connection the solver can express rather than as no connection -- and the record
-   * that carried the zero is the reader's, not the element's, so they are the one who can fix
-   * it.
-   * @param layout - the layout name, for the message
-   * @param weights - the pair weights about to be handed to the layout function
-   */
-  reportClampedWeights(e, n) {
-    let r = 0;
-    for (const i of n.values())
-      i < ve && r++;
-    r > 0 && yn.warn("Edge weights at or below zero were clamped before the layout read them", {
-      layout: e,
-      clamped: r,
-      epsilon: ve
-    });
-  }
-  /**
-   * The array to use for this node: the one its own graph owns, unless a host attached one.
-   *
-   * Resolved on every call rather than cached, because the element REPLACES its array when a
-   * dataset is discarded -- the store and everything keyed into it is thrown away and rebuilt --
-   * and an engine outlives that. A cached reference would keep publishing into the array of a
-   * graph that no longer exists, which is invisible: every write succeeds and nothing draws.
-   * @param n - the node being published or read
-   * @returns the array to write to and read from
-   */
-  positionsFor(e) {
-    if (!this.positionArrayAttached) {
-      const n = e.parentGraph?.getDataManager?.()?.positions;
-      n instanceof we && (this.positionArray = n);
-    }
-    return this.nodePositions;
-  }
-  /**
-   * Get the type identifier for this layout engine
-   * @returns The layout engine type string
-   */
-  get type() {
-    return this.constructor.type;
-  }
-  /**
-   * File a layout engine class under the name it declares, and publish what it says about
-   * itself to the catalogue.
-   *
-   * WHAT CHANGED AND WHY. This used to read `cls.type` through a cast and put the class in a
-   * map, which meant a class with no `static type` registered under the string "undefined", a
-   * second class under a taken name silently replaced the first, and a registered engine
-   * reached no catalogue at all -- so a third party's layout could run but could never be
-   * offered by a picker, described in a reader's language, or found by `layoutIdForEngine`.
-   *
-   * A third party's class must declare a `static descriptor` whose `id` equals its
-   * `static type`. The element's own seventeen are the one exemption, because their arrangements
-   * are authored centrally in the layout catalogue where several engines may sit behind one
-   * public name.
-   * @param cls - The layout engine class.
-   * @returns The same class, so a declaration can register itself in one expression.
-   * @throws A `GraphtyError` with `E_BAD_COMMAND` when the class declares no `static type`, no
-   * `static descriptor`, or a descriptor whose `id` disagrees with its `static type`; or with
-   * `E_DUPLICATE_PLUGIN` when the name or the descriptor id is one the element itself ships.
-   */
-  static register(e) {
-    const n = e, { type: r, descriptor: i } = n;
-    if (typeof r != "string" || r === "")
-      throw new w({
-        code: "E_BAD_COMMAND",
-        message: "a layout engine is filed under its `static type`, and this class declares none",
-        source: "registry",
-        details: { kind: "layout", field: "type" }
-      });
-    if (k.get(r) === e)
-      return e;
-    const s = gn.includes(r);
-    if (i === void 0) {
-      if (!s)
-        throw new w({
-          code: "E_BAD_COMMAND",
-          message: `the layout "${r}" declares no \`static descriptor\`, so nothing could offer it: a picker reads the catalogue, and an engine the catalogue does not carry is reachable only by a consumer who already knows its name`,
-          source: "registry",
-          details: { kind: "layout", name: r, field: "descriptor" }
-        });
-      if (k.has(r))
-        throw Ne(r);
-      return k.set(r, e), e;
-    }
-    if (s)
-      throw Ne(r);
-    if (i.id !== r)
-      throw new w({
-        code: "E_BAD_COMMAND",
-        message: `the layout "${r}" describes itself as "${i.id}". A layout has ONE key: the name \`setLayout\` takes and the name the catalogue publishes are the same string, so nothing has to be named twice and a saved document means one thing`,
-        source: "registry",
-        details: { kind: "layout", name: r, field: "descriptor.id", id: i.id }
-      });
-    return fn({
-      descriptor: { ...i, honoursWeights: n.honoursWeights ?? !1 },
-      type: r
-    }), k.set(r, e), e;
-  }
-  /**
-   * Get a layout engine instance by type
-   * @param type - The layout engine type identifier
-   * @param opts - Configuration options for the layout engine
-   * @returns A new layout engine instance or null if type not found
-   */
-  static get(e, n = {}) {
-    const r = k.get(e);
-    return r ? new r(n) : null;
-  }
-  /**
-   * Get dimension-specific options for this layout
-   * @param dimension - The desired dimension (2 or 3)
-   * @returns Options object for the dimension or null if unsupported
-   */
-  static getOptionsForDimension(e) {
-    return e > this.maxDimensions ? null : {};
-  }
-  /**
-   * Get dimension-specific options for a layout by type
-   * @param type - The layout engine type identifier
-   * @param dimension - The desired dimension (2 or 3)
-   * @returns Options object for the dimension or null if type not found or unsupported
-   */
-  static getOptionsForDimensionByType(e, n) {
-    const r = k.get(e);
-    return r ? r.getOptionsForDimension(n) : null;
-  }
-  /**
-   * Get the Zod-based options schema for this layout
-   * @returns The options schema, or an empty object if no schema defined
-   */
-  static getZodOptionsSchema() {
-    return this.zodOptionsSchema ?? {};
-  }
-  /**
-   * Check if this layout has a Zod-based options schema
-   * @returns true if the layout has options defined
-   */
-  static hasZodOptions() {
-    return this.zodOptionsSchema !== void 0 && Object.keys(this.zodOptionsSchema).length > 0;
-  }
-  /**
-   * Get a list of all registered layout types
-   * @returns Array of registered layout type identifiers
-   */
-  static getRegisteredTypes() {
-    return Array.from(k.keys());
-  }
-  /**
-   * Get a layout class by type
-   * @param type - The layout engine type identifier
-   * @returns The layout engine class or null if not found
-   */
-  static getClass(e) {
-    return k.get(e) ?? null;
-  }
-};
-ie.honoursWeights = !1;
-let K = ie;
-const vn = j.looseObject({
-  scalingFactor: j.number().default(100)
-});
-class or extends K {
-  /**
-   * Create a simple layout engine
-   * @param opts - Configuration options including scalingFactor
-   */
-  constructor(e = {}) {
-    super(), this._nodes = [], this._edges = [], this.stale = !0, this.positions = {}, this.scalingFactor = 100, this.isSettled = !0;
-    const n = vn.parse(e);
-    this.scalingFactor = n.scalingFactor;
-  }
-  /**
-   * Get dimension-specific options for simple layouts
-   * @param dimension - The desired dimension (2 or 3)
-   * @returns Options object with dim parameter or null if unsupported
-   */
-  static getOptionsForDimension(e) {
-    return e > this.maxDimensions ? null : { dim: e };
-  }
-  // basic functionality
-  /**
-   * Initialize the layout engine
-   *
-   * Simple layouts compute positions synchronously and don't require initialization.
-   */
-  async init() {
-  }
-  /**
-   * Add a node to the layout and mark positions as stale
-   * @param n - The node to add
-   */
-  addNode(e) {
-    this._nodes.push(e), this.stale = !0;
-  }
-  /**
-   * Add an edge to the layout and mark positions as stale
-   * @param e - The edge to add
-   */
-  addEdge(e) {
-    this._edges.push(e), this.stale = !0;
-  }
-  /**
-   * Get the position of a node, computing layout if stale
-   *
-   * The coordinates come from the shared position array, which `SimpleLayoutEngine.refresh`
-   * fills from `positions` as soon as the layout is recomputed. They are the same numbers the
-   * record holds, rounded to the f32 the array stores -- so an arrangement never moves, but a
-   * coordinate may differ in its last digit or two from the double the layout function returned.
-   * A node with no row falls back to the record, which is every node in an engine driven by hand.
-   * @param n - The node to get position for
-   * @returns The node's position coordinates
-   */
-  getNodePosition(e) {
-    return this.refresh(), this.publishedOr(e, e.id);
-  }
-  /**
-   * Record where the reader has just put a node.
-   *
-   * A static layout recomputes every coordinate from scratch, so it has no per-node state a
-   * placement could live in -- which is why this used to do nothing at all, and why a drag
-   * under any of the fourteen static arrangements was discarded by the next `refresh()`. The
-   * placement is written into the SHARED array instead, with `"placement"` intent so that it
-   * lands even on a pinned row, and into the computed record so that a read which falls back to
-   * the record (a node with no row of its own) answers the same.
-   * @param n - the node that moved
-   * @param p - where it moved to
-   */
-  setNodePosition(e, n) {
-    const r = n.z ?? 0;
-    this.writeNodePosition(e, n.x, n.y, r, "placement"), this.positions[e.id] = [n.x / this.scalingFactor, n.y / this.scalingFactor, r / this.scalingFactor];
-  }
-  /**
-   * Get the position of an edge based on its endpoints
-   * @param e - The edge to get position for
-   * @returns The edge's source and destination positions
-   */
-  getEdgePosition(e) {
-    return this.refresh(), {
-      src: this.publishedOr(e.srcNode, e.srcId),
-      dst: this.publishedOr(e.dstNode, e.dstId)
-    };
-  }
-  /**
-   * Copy the computed layout into the shared position array, recomputing it first if it is stale.
-   */
-  publishPositions() {
-    if (this.stale) {
-      this.refresh();
-      return;
-    }
-    this.publishRecord();
-  }
-  // for animated layouts
-  /**
-   * Step the layout animation
-   *
-   * Simple layouts are static and don't animate, so stepping has no effect.
-   */
-  step() {
-  }
-  /**
-   * Take a node out of the layout.
-   *
-   * WITHOUT THIS the engine holds the removed node -- and through it the node's Babylon mesh,
-   * its data record and its endpoints -- for as long as the engine lives, and the frame loop
-   * keeps walking it, so a node the reader deleted still draws at wherever it last was.
-   *
-   * The computed record is left alone and the layout is marked stale instead. Every layout
-   * function here returns a WHOLE new record, which `doLayout` assigns over the old one, and
-   * `refresh()` runs before any read -- so the removed node's entry is gone by the time anything
-   * could read it, without this method having to reach into a keyed object by a computed name.
-   * @param n - the node leaving the graph
-   */
-  removeNode(e) {
-    const n = this._nodes.indexOf(e);
-    n >= 0 && this._nodes.splice(n, 1), this.stale = !0;
-  }
-  /**
-   * The edge half of {@link SimpleLayoutEngine.removeNode}, with the same reason.
-   * @param e - the edge leaving the graph
-   */
-  removeEdge(e) {
-    const n = this._edges.indexOf(e);
-    n >= 0 && this._edges.splice(n, 1), this.stale = !0;
-  }
-  /**
-   * Pin a node in place
-   *
-   * A static layout has nothing of its own to hold still -- it recomputes every position from
-   * scratch -- so the pin is kept by the element's position array instead, and
-   * `writeNodePosition` refuses to move a pinned row. That is what makes a
-   * pin mean something under all fourteen of these engines, none of which could hold one.
-   */
-  pin() {
-  }
-  /**
-   * Unpin a node
-   *
-   * The element's position array holds the pin; see {@link SimpleLayoutEngine.pin}.
-   */
-  unpin() {
-  }
-  // properties
-  /**
-   * Get all nodes in the layout
-   * @returns Iterable of nodes
-   */
-  get nodes() {
-    return this._nodes;
-  }
-  /**
-   * Get all edges in the layout
-   * @returns Iterable of edges
-   */
-  get edges() {
-    return this._edges;
-  }
-  /**
-   * Recompute the layout when it is stale, and publish what it produced.
-   *
-   * A simple layout is computed once and then held, so this is the ONE place the shared array is
-   * filled: every reader below goes through here first, which is why a node added after the last
-   * read still gets a row before anything asks for its coordinates.
-   */
-  refresh() {
-    this.stale && (this.doLayout(), this.stale = !1, this.publishRecord());
-  }
-  /**
-   * Write the computed record into the shared array, scaled to scene units.
-   *
-   * A node the layout function returned nothing for is LEFT UNPLACED rather than published at
-   * the origin: the two are indistinguishable once stored, and the origin is a place a reader
-   * would draw at.
-   */
-  publishRecord() {
-    for (const e of this._nodes) {
-      const n = this.positions[e.id];
-      !n || n.length === 0 || this.writeNodePosition(
-        e,
-        n[0] * this.scalingFactor,
-        n[1] * this.scalingFactor,
-        (n[2] ?? 0) * this.scalingFactor
-      );
-    }
-  }
-  /**
-   * A node's published row, or the computed record when it has no row of its own.
-   *
-   * The fallback is not a rare path: an engine driven directly -- by a test, or by a host that
-   * keeps no graph -- has nodes whose index is `INVALID_INDEX`, and none of them is ever
-   * published. Both branches produce the same arrangement; only the rounding differs.
-   * @param n - the node, when the caller has one
-   * @param id - the node's id, which is how the computed record is keyed
-   * @returns a fresh coordinate triple
-   */
-  publishedOr(e, n) {
-    const r = { x: 0, y: 0, z: 0 };
-    return e !== void 0 && this.readNodePosition(e, r) ? r : Nn(this.positions[n], this.scalingFactor);
-  }
-}
-function Nn(t, e) {
-  if (!t || t.length === 0)
-    return { x: 0, y: 0, z: 0 };
-  const n = t[0] * e, r = t[1] * e, i = (t[2] ?? 0) * e;
-  return { x: n, y: r, z: i };
-}
-const On = /^#[0-9a-f]{6}$/i;
-function kn(t) {
-  if (typeof t != "string" || t.trim() === "")
-    return null;
-  try {
-    const e = Be(t.trim());
-    if (e === void 0)
-      return null;
-    const n = e.length === 9 ? e.slice(0, 7) : e;
-    return On.test(n) ? n.toUpperCase() : null;
-  } catch {
-    return null;
-  }
-}
-function Sn(t) {
-  return JSON.stringify([t.id, t.kind, t.colors, t.capacity, t.colorblindSafe]);
-}
-const C = Z({
-  kind: "palette",
-  idOf: (t) => t.id,
-  descriptorOf: (t) => t,
-  implementationOf: Sn,
-  builtInIds: () => He
-});
-function I(t, e, n) {
-  throw new w({
-    code: "E_BAD_COMMAND",
-    message: n,
-    source: "registry",
-    details: { kind: "palette", name: typeof t == "string" ? t : "", field: e }
-  });
-}
-function ar(t, e) {
-  typeof t != "object" && I("", "descriptor", "registerPalette takes a palette descriptor"), (t.plainName === void 0 || t.plainName === "") && I(t.id, "plainName", `the palette "${String(t.id)}" was registered without a plain name`), t.kind !== "sequential" && t.kind !== "diverging" && t.kind !== "categorical" && I(
-    t.id,
-    "kind",
-    `the palette "${String(t.id)}" must be sequential, diverging or categorical`
-  ), (!Array.isArray(t.colors) || t.colors.length === 0) && I(t.id, "colors", `the palette "${String(t.id)}" was registered with no colours`);
-  const n = [];
-  for (const i of t.colors) {
-    const s = kn(i);
-    s === null && I(t.id, "colors", `"${String(i)}" in the palette "${String(t.id)}" is not a colour`), n.push(s);
-  }
-  const r = t.kind === "categorical" ? n.length : null;
-  t.capacity !== void 0 && t.capacity !== r && I(
-    t.id,
-    "capacity",
-    `the palette "${String(t.id)}" is ${t.kind}, so its capacity is ${r === null ? "null" : String(r)} rather than ${String(t.capacity)}`
-  ), C.register(
-    Object.freeze({
-      ...t,
-      colors: Object.freeze(n),
-      capacity: r,
-      colorblindSafe: Object.freeze(t.colorblindSafe ?? [])
-    }),
-    e
-  );
-}
-function cr() {
-  return C.descriptors();
-}
-function lr(t) {
-  return C.byId(t);
-}
-function ur() {
-  C.clearForTesting();
-}
-export {
-  lr as $,
-  Kn as A,
-  g as B,
-  A as C,
-  Bn as D,
-  we as E,
-  je as F,
-  $e as G,
-  Gn as H,
-  Pn as I,
-  _n as J,
-  Y as K,
-  Vn as L,
-  $t as M,
-  Mn as N,
-  zn as O,
-  qn as P,
-  Ln as Q,
-  jn as R,
-  vn as S,
-  Cn as T,
-  er as U,
-  nn as V,
-  tn as W,
-  bn as X,
-  sn as Y,
-  ve as Z,
-  ir as _,
-  K as a,
-  or as b,
-  Dn as c,
-  Qn as d,
-  sr as e,
-  ur as f,
-  Jn as g,
-  Un as h,
-  Hn as i,
-  Wn as j,
-  ln as k,
-  rr as l,
-  N as m,
-  Xn as n,
-  Rn as o,
-  cr as p,
-  Zn as q,
-  ar as r,
-  Yn as s,
-  q as t,
-  ee as u,
-  ut as v,
-  At as w,
-  P as x,
-  tr as y,
-  nr as z
-};