@graphty/graphty-element 2.6.1 → 3.0.0

package/dist/chunks/definePalette-BYt2Llxs.js

@@ -0,0 +1,1333 @@
+var se = (n) => {
+  throw TypeError(n);
+};
+var W = (n, e, t) => e.has(n) || se("Cannot " + t);
+var S = (n, e, t) => (W(n, e, "read from private field"), t ? t.call(n) : e.get(n)), I = (n, e, t) => e.has(n) ? se("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), O = (n, e, t, o) => (W(n, e, "write to private field"), o ? o.call(n, t) : e.set(n, t), t), z = (n, e, t) => (W(n, e, "access private method"), t);
+var R = (n, e, t, o) => ({
+  set _(s) {
+    O(n, e, s, t);
+  },
+  get _() {
+    return S(n, e, o);
+  }
+});
+import { T as Se, a as Ne, i as Fe, l as ze, p as Re, m as ie, h as Je, o as Ve, j as Ge, Y as Be, b as re, c as Ke } from "./fields-5uVC1Pll.js";
+import { G as P, i as te } from "./pluginRegistry-Ddfl6Mv2.js";
+import { G as L, r as Ue } from "./GraphtyLogger-BtcBJQPL.js";
+import { O as Ye } from "./types-DFchv4Ny.js";
+import { e as Ee, c as qe } from "./sources-BbAJCDIH.js";
+import { n as We, r as He } from "./paletteRegistry-De3CGdst.js";
+const Xe = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+function v(n) {
+  if (n == null)
+    return String(n);
+  if (Array.isArray(n))
+    return "an array";
+  switch (typeof n) {
+    case "string":
+      return `the string ${JSON.stringify(n)}`;
+    case "number":
+    case "boolean":
+    case "bigint":
+      return `the ${typeof n} ${String(n)}`;
+    case "function":
+      return "a function";
+    default:
+      return "an object";
+  }
+}
+function w(n, e, t, o) {
+  const s = e === void 0 ? `${n}()` : `${n}(${JSON.stringify(e)})`;
+  return new P({
+    code: "E_BAD_COMMAND",
+    message: `${s}: ${o}`,
+    source: "registry",
+    details: { field: t, ...e === void 0 ? {} : { extension: e } }
+  });
+}
+function U(n, e) {
+  if (typeof e != "object" || e === null || Array.isArray(e))
+    throw w(
+      n,
+      void 0,
+      "definition",
+      `the definition must be an object such as { id: "acme-example", ... }; got ${v(e)}.`
+    );
+  const { id: t } = e;
+  if (typeof t != "string" || t === "")
+    throw w(
+      n,
+      void 0,
+      "id",
+      `"id" must be a non-empty string such as "acme-example"; got ${v(t)}.`
+    );
+  if (!Xe.test(t))
+    throw w(
+      n,
+      t,
+      "id",
+      `"id" must be lower-case words joined by hyphens, starting with a letter and led by your own prefix, such as "acme-tiers"; got ${JSON.stringify(t)}. The id is saved in documents, so it cannot contain spaces, capitals, dots, colons or slashes.`
+    );
+  const o = e;
+  for (const s of ["name", "description", "version"])
+    Qe(n, o, s);
+  return o;
+}
+function ne(n, e, t) {
+  if (typeof e[t] != "function")
+    throw w(
+      n,
+      e.id,
+      t,
+      `"${t}" must be a function; got ${v(e[t])}.`
+    );
+}
+function Qe(n, e, t) {
+  const o = e[t];
+  if (o !== void 0 && typeof o != "string")
+    throw w(n, e.id, t, `"${t}" must be a string; got ${v(o)}.`);
+}
+function K(n, e, t, o) {
+  const s = e[t];
+  if (s !== void 0 && !o.includes(s)) {
+    const i = o.map((c) => JSON.stringify(c)).join(", ");
+    throw w(
+      n,
+      e.id,
+      t,
+      `"${t}" must be one of ${i}; got ${v(s)}.`
+    );
+  }
+}
+function ke(n) {
+  const t = n.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).filter((o) => o !== "").map((o) => o.toLowerCase()).join(" ");
+  return t.charAt(0).toUpperCase() + t.slice(1);
+}
+function Y(n) {
+  return typeof n.name == "string" && n.name !== "" ? n.name : ke(n.id);
+}
+function G(n, e) {
+  const t = e instanceof Error ? `${e.name}: ${e.message}` : String(e), o = n.subject === void 0 ? "" : ` for ${n.subject}`;
+  return new P({
+    code: "E_EXTENSION_FAILED",
+    message: `${n.id}: ${n.member}() threw${o} (${t}).`,
+    source: n.source,
+    details: {
+      extension: n.id,
+      member: n.member,
+      ...n.subject === void 0 ? {} : { subject: n.subject }
+    },
+    cause: e
+  });
+}
+function Ze(n, e) {
+  try {
+    return e();
+  } catch (t) {
+    throw te(t) ? t : G(n, t);
+  }
+}
+async function et(n, e) {
+  try {
+    return await e();
+  } catch (t) {
+    throw te(t) ? t : G(n, t);
+  }
+}
+function tt(n, e) {
+  return Se(n, e);
+}
+const Ae = /* @__PURE__ */ new WeakMap();
+function Oe(n, e) {
+  return `${n}\0${e}`;
+}
+function D(n) {
+  return typeof n == "number" ? String(n) : JSON.stringify(n);
+}
+function nt(n, e) {
+  return new P({
+    code: "E_BAD_COMMAND",
+    message: `${n.options.id}: ${e}() needs direction: "directed" in the definition. Without it the graph is read as undirected, and which way an edge points is not known.`,
+    source: n.options.source ?? "run",
+    details: { extension: n.options.id, member: e, field: "direction" }
+  });
+}
+function J(n, e) {
+  if (!n.options.directed)
+    throw nt(n, e);
+}
+function C(n, e, t) {
+  return t.run !== void 0 ? `${n}: ${e} reads ${t.path}, but no completed run is named "${t.run}"; run the algorithm that produces it first, with { as: "${t.run}" }.` : `${n}: ${e} names a ${t.target} attribute no ${t.target} carries; ${xe(t)}.`;
+}
+function xe(n) {
+  return n.carriers.length === 0 ? `no ${n.target} carries any attribute` : `${n.target}s carry: ${n.carriers.join(", ")}`;
+}
+function ot(n) {
+  const e = /^results\.([^.]+)\./.exec(n);
+  return e === null ? void 0 : e[1];
+}
+function _(n, e, t, o) {
+  const s = Oe(e, t);
+  if (n.checked.has(s))
+    return;
+  const { source: i } = n, c = e === "node" ? i.snapshot.nodeCount : i.snapshot.edgeCount;
+  let r = c === 0;
+  for (let a = 0; a < c && !r; a++) {
+    const d = e === "node" ? i.nodeValue(a, t) : i.edgeValue(a, t);
+    r = d != null;
+  }
+  if (!r) {
+    const a = ot(t), d = {
+      target: e,
+      path: t,
+      carriers: i.attributeNames?.(e) ?? [],
+      ...a === void 0 ? {} : { run: a }
+    };
+    throw new P({
+      code: "E_OPTION_RANGE",
+      message: o(d),
+      source: n.options.source ?? "run",
+      details: {
+        extension: n.options.id,
+        target: e,
+        path: t,
+        carriers: d.carriers,
+        ...a === void 0 ? {} : { run: a }
+      }
+    });
+  }
+  n.checked.set(s, { target: e, path: t });
+}
+function X(n, e, t, o, s) {
+  const i = Oe(e, t);
+  let c = n.tallies.get(i);
+  if (c === void 0 && (c = { target: e, path: t, missing: /* @__PURE__ */ new Set(), text: /* @__PURE__ */ new Set(), found: /* @__PURE__ */ new Set(), sample: void 0 }, n.tallies.set(i, c)), typeof s == "number" && Number.isFinite(s))
+    return c.found.add(o), s;
+  c.missing.add(o), typeof s == "string" && (c.text.add(o), c.sample ??= s);
+}
+function M(n) {
+  return Object.freeze(n);
+}
+class st {
+  #e;
+  #t;
+  #o = null;
+  #s = null;
+  #i = null;
+  #r = null;
+  #a = null;
+  #c = null;
+  #d = /* @__PURE__ */ new Map();
+  /**
+   * Build one node.
+   * @param state - The view.
+   * @param row - Its row in the snapshot.
+   * @param id - Its id.
+   */
+  constructor(e, t, o) {
+    this.#e = e, this.#t = t, this.id = o;
+  }
+  /**
+   * The node's row in the snapshot, for the view's own bookkeeping.
+   * @returns The row.
+   */
+  get row() {
+    return this.#t;
+  }
+  /**
+   * The number of edges touching the node.
+   * @returns edges().length: a self-loop counts once.
+   */
+  get degree() {
+    return this.edges().length;
+  }
+  /**
+   * Every edge touching this node.
+   * @returns The edges, in the view's order.
+   */
+  edges() {
+    return this.#o ??= M(this.#e.incident[this.#t].map((e) => this.#e.edges[e])), this.#o;
+  }
+  /**
+   * The adjacent nodes.
+   * @returns Every adjacent node once, never this node.
+   */
+  neighbors() {
+    return this.#s ??= this.#n(this.edges(), (e) => e.other(this)), this.#s;
+  }
+  /**
+   * The edges leaving this node; every edge, in undirected data.
+   * @returns The edges.
+   */
+  outEdges() {
+    return J(this.#e, "outEdges"), this.#i ??= this.#e.directedData ? M(this.edges().filter((e) => e.source === this)) : this.edges(), this.#i;
+  }
+  /**
+   * The edges entering this node; every edge, in undirected data.
+   * @returns The edges.
+   */
+  inEdges() {
+    return J(this.#e, "inEdges"), this.#r ??= this.#e.directedData ? M(this.edges().filter((e) => e.target === this)) : this.edges(), this.#r;
+  }
+  /**
+   * The nodes this node's edges lead to.
+   * @returns The nodes, never this node.
+   */
+  outNeighbors() {
+    return J(this.#e, "outNeighbors"), this.#a ??= this.#n(this.outEdges(), (e) => e.other(this)), this.#a;
+  }
+  /**
+   * The nodes whose edges lead here.
+   * @returns The nodes, never this node.
+   */
+  inNeighbors() {
+    return J(this.#e, "inNeighbors"), this.#c ??= this.#n(this.inEdges(), (e) => e.other(this)), this.#c;
+  }
+  /**
+   * The edges between this node and another.
+   * @param other - The other node.
+   * @returns The edges, parallel edges included; in a directed view only those from here to there.
+   */
+  edgesTo(e) {
+    const t = this.#e;
+    return t.options.directed && t.directedData ? M(this.outEdges().filter((o) => o.target === e)) : M(this.edges().filter((o) => o.other(this) === e));
+  }
+  /**
+   * The summed weight of the edges to another node.
+   * @param other - The other node.
+   * @param path - The weight path, or undefined to count each edge as 1.
+   * @returns The sum, or undefined when no edge between them has a weight.
+   */
+  weightTo(e, t) {
+    return ae(this.edgesTo(e), t);
+  }
+  /**
+   * The weighted degree.
+   * @param path - The weight path, or undefined for the degree.
+   * @param direction - All edges, or only outgoing or incoming ones.
+   * @returns The sum.
+   */
+  strength(e, t = "all") {
+    t !== "all" && J(this.#e, "strength");
+    const o = `${t}\0${e ?? ""}\0${e === void 0 ? "unbound" : "bound"}`;
+    let s = this.#d.get(o);
+    if (s === void 0) {
+      const i = { all: () => this.edges(), out: () => this.outEdges(), in: () => this.inEdges() }[t]();
+      s = e === void 0 ? i.length : ae(i, e) ?? 0, this.#d.set(o, s);
+    }
+    return s;
+  }
+  /**
+   * An attribute or a published result.
+   * @param path - The path, or undefined for an unbound option.
+   * @returns The value.
+   */
+  attr(e) {
+    if (e === void 0)
+      return;
+    const t = this.#e;
+    return _(
+      t,
+      "node",
+      e,
+      (o) => C(t.options.id, `node.attr(${JSON.stringify(e)})`, o)
+    ), t.source.nodeValue(this.#t, e);
+  }
+  /**
+   * attr(path) when it is a finite number.
+   * @param path - The path.
+   * @returns The number, or undefined.
+   */
+  number(e) {
+    if (e === void 0)
+      return;
+    const t = this.#e;
+    return _(
+      t,
+      "node",
+      e,
+      (o) => C(t.options.id, `node.number(${JSON.stringify(e)})`, o)
+    ), X(t, "node", e, this.#t, t.source.nodeValue(this.#t, e));
+  }
+  /**
+   * The distinct far ends of a list of edges, in the view's order, leaving this node out.
+   * @param list - The edges.
+   * @param end - Picks the end.
+   * @returns The nodes.
+   */
+  #n(e, t) {
+    const o = /* @__PURE__ */ new Set();
+    for (const i of e) {
+      const c = t(i);
+      c !== this && o.add(c);
+    }
+    const { nodePosition: s } = this.#e;
+    return M([...o].sort((i, c) => s[i.row] - s[c.row]));
+  }
+}
+function ae(n, e) {
+  let t = 0, o = !1;
+  for (const s of n) {
+    const i = s.weight(e);
+    i !== void 0 && (t += i, o = !0);
+  }
+  return o ? t : void 0;
+}
+class it {
+  #e;
+  #t;
+  /**
+   * Build one edge.
+   * @param state - The view.
+   * @param row - Its row in the snapshot.
+   * @param id - The element's edge id.
+   * @param source - The end the data named first.
+   * @param target - The other end.
+   */
+  constructor(e, t, o, s, i) {
+    this.#e = e, this.#t = t, this.id = o, this.source = s, this.target = i;
+  }
+  /**
+   * The end that is not `node`.
+   * @param node - One end.
+   * @returns The other end; a self-loop returns `node`.
+   */
+  other(e) {
+    if (e === this.source)
+      return this.target;
+    if (e === this.target)
+      return this.source;
+    const { options: t } = this.#e;
+    throw new P({
+      code: "E_BAD_COMMAND",
+      message: `${t.id}: edge.other() was given node ${D(e.id)}, which is not an end of edge "${this.id}" (its ends are ${D(this.source.id)} and ${D(this.target.id)}).`,
+      source: t.source ?? "run",
+      details: { extension: t.id, member: "other", edge: this.id, node: e.id }
+    });
+  }
+  /**
+   * The edge's weight at a path.
+   * @param path - The path, or undefined to count the edge as 1.
+   * @returns The weight, or undefined when there is no number.
+   */
+  weight(e) {
+    if (e === void 0)
+      return 1;
+    const t = this.#e;
+    return _(
+      t,
+      "edge",
+      e,
+      (o) => C(t.options.id, `edge.weight(${JSON.stringify(e)})`, o)
+    ), t.weightPaths.add(e), X(t, "edge", e, this.#t, t.source.edgeValue(this.#t, e));
+  }
+  /**
+   * An attribute or a published result.
+   * @param path - The path, or undefined for an unbound option.
+   * @returns The value.
+   */
+  attr(e) {
+    if (e === void 0)
+      return;
+    const t = this.#e;
+    return _(
+      t,
+      "edge",
+      e,
+      (o) => C(t.options.id, `edge.attr(${JSON.stringify(e)})`, o)
+    ), t.source.edgeValue(this.#t, e);
+  }
+  /**
+   * attr(path) when it is a finite number.
+   * @param path - The path.
+   * @returns The number, or undefined.
+   */
+  number(e) {
+    if (e === void 0)
+      return;
+    const t = this.#e;
+    return _(
+      t,
+      "edge",
+      e,
+      (o) => C(t.options.id, `edge.number(${JSON.stringify(e)})`, o)
+    ), X(t, "edge", e, this.#t, t.source.edgeValue(this.#t, e));
+  }
+}
+const ce = { number: 0, boolean: 1, string: 2 }, rt = new Intl.Collator("en", { numeric: !0 });
+function at(n, e) {
+  const t = ce[typeof n], o = ce[typeof e];
+  return t !== o ? t - o : typeof n == "string" && typeof e == "string" ? rt.compare(n, e) || Se(n, e) : Number(n) - Number(e);
+}
+function Me(n, e) {
+  const { snapshot: t } = n, { nodeCount: o, edgeCount: s } = t, i = [], c = Array.from({ length: o }, () => []), r = {
+    options: e,
+    source: n,
+    checked: /* @__PURE__ */ new Map(),
+    tallies: /* @__PURE__ */ new Map(),
+    weightPaths: /* @__PURE__ */ new Set(),
+    edges: i,
+    nodePosition: new Int32Array(o),
+    edgePosition: new Int32Array(s),
+    incident: c,
+    directedData: t.directed
+  }, a = [], d = /* @__PURE__ */ new Map();
+  for (let u = 0; u < o; u++) {
+    const p = new st(r, u, t.ids.idOf(u));
+    a.push(p), d.set(p.id, p);
+  }
+  const l = [...a].sort((u, p) => tt(u.id, p.id));
+  l.forEach((u, p) => {
+    r.nodePosition[u.row] = p;
+  });
+  const g = Ee(t), { src: b, dst: N } = s === 0 ? { src: new Uint32Array(0), dst: new Uint32Array(0) } : t.edgeList(), E = /* @__PURE__ */ new Map();
+  for (let u = 0; u < s; u++) {
+    const p = new it(r, u, g.idOf(u), a[b[u]], a[N[u]]);
+    i.push(p), E.set(p.id, p), c[b[u]].push(u), N[u] !== b[u] && c[N[u]].push(u);
+  }
+  const F = [...i.keys()].sort((u, p) => Number(i[u].id) - Number(i[p].id) || u - p);
+  F.forEach((u, p) => {
+    r.edgePosition[u] = p;
+  });
+  for (const u of c)
+    u.sort((p, h) => r.edgePosition[p] - r.edgePosition[h]);
+  const j = M(l), f = M(F.map((u) => i[u])), k = /* @__PURE__ */ new Map(), $ = {
+    directed: e.directed && t.directed,
+    nodeCount: o,
+    edgeCount: s,
+    nodes: () => j,
+    edges: () => f,
+    node: (u) => d.get(u),
+    edge: (u) => E.get(u),
+    groupBy(u) {
+      if (u === void 0)
+        return /* @__PURE__ */ new Map();
+      let p = k.get(u);
+      if (p === void 0) {
+        _(
+          r,
+          "node",
+          u,
+          (m) => C(e.id, `graph.groupBy(${JSON.stringify(u)})`, m)
+        );
+        const h = /* @__PURE__ */ new Map();
+        for (const m of j) {
+          const y = n.nodeValue(m.row, u);
+          if (typeof y == "string" || typeof y == "boolean" || typeof y == "number" && Number.isFinite(y)) {
+            const T = h.get(y) ?? [];
+            T.push(m), h.set(y, T);
+          }
+        }
+        p = new Map(
+          [...h.entries()].sort(([m], [y]) => at(m, y)).map(([m, y]) => [m, M(y)])
+        ), k.set(u, p);
+      }
+      return p;
+    }
+  };
+  return Ae.set($, r), $;
+}
+function q(n) {
+  const e = Ae.get(n);
+  if (e === void 0)
+    throw new P({
+      code: "E_INTERNAL",
+      message: "a graph view was used that graphty-element did not build",
+      source: "run"
+    });
+  return e;
+}
+function ct(n, e, t, o) {
+  _(q(n), e, t, o);
+}
+function dt(n) {
+  return [...q(n).checked.values()];
+}
+function ut(n) {
+  return [...q(n).weightPaths];
+}
+function Pe(n) {
+  const e = q(n), { id: t } = e.options, o = [];
+  for (const s of e.tallies.values()) {
+    const i = s.missing.size;
+    if (i === 0)
+      continue;
+    const c = `${s.target}s`, r = s.sample === void 0 ? "" : JSON.stringify(s.sample);
+    if (s.found.size === 0) {
+      o.push(
+        s.text.size > 0 ? `${t}: no ${s.target} has a number at "${s.path}": its values are text (e.g. ${r}), so every read of it was left out.` : `${t}: no ${s.target} has a number at "${s.path}", so every read of it was left out.`
+      );
+      continue;
+    }
+    const a = s.target === "node" ? e.source.snapshot.nodeCount : e.source.snapshot.edgeCount, d = s.text.size, l = d === 0 ? "" : ` (${d} ${d === 1 ? "holds" : "hold"} text, e.g. ${r})`;
+    o.push(
+      `${t}: ${i} of ${a} ${c} ${i === 1 ? "has" : "have"} no number at "${s.path}"${l}; they were left out.`
+    );
+  }
+  return o;
+}
+const de = Ye.filter((n) => n !== "unknown"), Te = /* @__PURE__ */ new Set(["attribute", "partition"]);
+function Ie(n, e, t) {
+  if (t === void 0)
+    return [];
+  if (typeof t != "object" || t === null || Array.isArray(t))
+    throw w(
+      n,
+      e,
+      "options",
+      `"options" must be an object such as { spacing: 2 }; got ${v(t)}.`
+    );
+  return Object.entries(t).map(([o, s]) => lt(n, e, o, s));
+}
+function lt(n, e, t, o) {
+  const s = `options.${t}`, i = ke(t);
+  if (typeof o == "number") {
+    if (!Number.isFinite(o))
+      throw w(n, e, s, `"${s}" must be a finite number; got ${v(o)}.`);
+    return { name: t, plainName: i, type: "number", default: o };
+  }
+  if (typeof o == "string")
+    return { name: t, plainName: i, type: "string", default: o };
+  if (typeof o == "boolean")
+    return { name: t, plainName: i, type: "boolean", default: o };
+  if (typeof o != "object" || o === null || Array.isArray(o))
+    throw w(
+      n,
+      e,
+      s,
+      `"${s}" must be a number, a string, a boolean, or an object with a "type" such as { type: "attribute", default: "weight" }; got ${v(o)}.`
+    );
+  const { type: c, on: r, ...a } = o;
+  if (typeof c != "string" || !de.includes(c))
+    throw w(
+      n,
+      e,
+      `${s}.type`,
+      `"${s}" needs a "type", one of ${de.map((l) => `"${l}"`).join(", ")}; got ${v(c)}.`
+    );
+  if (r !== void 0) {
+    if (!Te.has(c))
+      throw w(
+        n,
+        e,
+        `${s}.on`,
+        `"${s}" has "on", which only an "attribute" or "partition" option takes.`
+      );
+    if (r !== "node" && r !== "edge")
+      throw w(
+        n,
+        e,
+        `${s}.on`,
+        `"${s}.on" must be "node" or "edge"; got ${v(r)}.`
+      );
+  }
+  if (c === "enum" && !Array.isArray(a.values))
+    throw w(
+      n,
+      e,
+      `${s}.values`,
+      `"${s}" is an "enum" and needs "values", such as [{ value: "a", label: "A" }].`
+    );
+  const d = { ...a, name: t, plainName: a.plainName ?? i, type: c };
+  return r !== void 0 && (d.on = r), d.default === null && delete d.default, d;
+}
+function De(n, e, t, o, s = "run") {
+  for (const i of t) {
+    const c = o[i.name];
+    if (c != null) {
+      if (Te.has(i.type) && typeof c == "string") {
+        const r = i.on ?? "node";
+        ct(
+          n,
+          r,
+          c,
+          (a) => a.run === void 0 ? `${e}: option "${i.name}" names ${r} attribute "${c}", which no ${r} carries; ${xe(a)}.` : `${e}: option "${i.name}" reads ${c}, but no completed run is named "${a.run}"; run the algorithm that produces it first, with { as: "${a.run}" }.`
+        );
+      }
+      if (i.type === "node-id" && ue(n, e, i.name, c, s), i.type === "node-set" && Array.isArray(c))
+        for (const r of c)
+          ue(n, e, i.name, r, s);
+    }
+  }
+}
+function ue(n, e, t, o, s) {
+  if (n.node(o) === void 0)
+    throw new P({
+      code: "E_OPTION_RANGE",
+      message: `${e}: option "${t}" names node ${D(o)}, which the graph does not have.`,
+      source: s,
+      details: { extension: e, option: t, node: o }
+    });
+}
+const ft = {
+  node: /* @__PURE__ */ new Set(["id"]),
+  edge: /* @__PURE__ */ new Set(["id", "source", "target"])
+};
+function Le(n) {
+  const e = n.data.snapshot(), t = Ee(e), o = qe({
+    snapshot: () => e,
+    results: (s) => n.results.get(s),
+    records: {
+      nodeAttributes: (s, i) => n.data.node(i),
+      edgeAttributes: (s) => n.data.edge(t.idOf(s))
+    }
+  });
+  return {
+    snapshot: e,
+    nodeValue: (s, i) => o.nodeValue(s, i),
+    edgeValue: (s, i) => o.edgeValue(s, i),
+    attributeNames: (s) => n.data.attributes().filter((i) => i.kind === s && !ft[s].has(i.name)).map((i) => i.name)
+  };
+}
+const ht = ["node", "edge", "nodes", "groups"], _e = {
+  node: "node-metric",
+  edge: "edge-metric",
+  nodes: "node-metric",
+  groups: "community"
+}, le = /* @__PURE__ */ new WeakMap(), fe = 200, he = /* @__PURE__ */ new Set();
+function gt(n) {
+  const e = "defineAlgorithm", t = U(e, n), { id: o } = t, s = ht.filter((g) => t[g] !== void 0);
+  if (s.length === 0)
+    throw w(
+      e,
+      o,
+      "node",
+      'a definition needs one function that computes the result: "node", "edge", "nodes" or "groups"; it has none.'
+    );
+  if (s.length > 1)
+    throw w(
+      e,
+      o,
+      s[1],
+      `a definition carries exactly one of "node", "edge", "nodes" and "groups"; it has ${s.map((g) => `"${g}"`).join(" and ")}.`
+    );
+  const i = s[0];
+  ne(e, t, i), K(e, t, "direction", ["undirected", "directed"]);
+  const c = Ie(e, o, t.options), r = new Map(c.map((g) => [g.name, g])), { passes: a } = t;
+  if (a !== void 0 && (typeof a != "string" || r.get(a)?.type !== "integer")) {
+    const g = typeof a == "string" ? r.get(a) : void 0;
+    let b = ", which is not declared.";
+    throw typeof a != "string" ? b = "." : g !== void 0 && (b = `, a "${g.type}" option.`), w(
+      e,
+      o,
+      "passes",
+      `"passes" must name a declared "integer" option; got ${v(a)}${b}`
+    );
+  }
+  const d = t.weights;
+  if (d !== void 0) {
+    const g = typeof d.option == "string" ? r.get(d.option) : void 0;
+    if (g?.type !== "attribute" || g.on !== "edge")
+      throw w(
+        e,
+        o,
+        "weights.option",
+        `"weights.option" must name a declared "attribute" option with on: "edge"; got ${v(d.option)}.`
+      );
+    if (d.meaning !== "distance" && d.meaning !== "strength")
+      throw w(
+        e,
+        o,
+        "weights.meaning",
+        `"weights.meaning" must be "distance" or "strength"; got ${v(d.meaning)}.`
+      );
+  }
+  const l = Y(t);
+  return {
+    id: o,
+    name: l,
+    description: typeof t.description == "string" ? t.description : "",
+    member: i,
+    compute: t[i],
+    directed: t.direction === "directed",
+    options: c,
+    ...d === void 0 ? {} : { weights: d },
+    ...a === void 0 ? {} : { passes: a },
+    ...typeof t.version == "string" ? { version: t.version } : {}
+  };
+}
+function pt(n) {
+  const e = { plainName: n.name, technicalName: n.name }, t = _e[n.member], o = n.member === "node" || n.member === "edge";
+  return {
+    key: n.id,
+    ...e,
+    description: n.description,
+    category: "custom",
+    shape: t,
+    fields: t === "community" ? Fe(e) : (t === "edge-metric" ? ze : Re)(e),
+    options: n.options,
+    costClass: o ? "instant" : "iterative",
+    complexity: "O(n + m)"
+  };
+}
+function B(n) {
+  return typeof n == "number" && Number.isFinite(n);
+}
+function mt(n, e, t, o) {
+  const s = `${n.member}()`;
+  if (!(t instanceof Map))
+    throw G(
+      { id: n.id, member: n.member, source: "run" },
+      new TypeError(`${s} must return a Map from node id to value; got ${v(t)}`)
+    );
+  const i = [...t.entries()], c = i.filter(([a]) => e.node(a) !== void 0), r = i.filter(([a]) => e.node(a) === void 0).map(([a]) => D(a));
+  if (i.length > 0 && c.length === 0) {
+    const a = typeof e.nodes()[0]?.id == "number" ? "numbers" : "strings";
+    throw G(
+      { id: n.id, member: n.member, source: "run" },
+      new TypeError(
+        `${s} returned ${String(i.length)} values but no key matches a node id (got ${r[0]}; node ids here are ${a})`
+      )
+    );
+  }
+  return r.length > 0 && o.push(
+    `${n.id}: ${s} returned values for ${String(r.length)} keys that are not nodes (${r.slice(0, 5).join(", ")}); they were left out.`
+  ), c;
+}
+async function yt(n, e, t, o) {
+  if (e.nodeCount === 0)
+    return null;
+  const { id: s, member: i, name: c } = n;
+  De(e, s, n.options, t);
+  const r = [];
+  let a = 0, d = performance.now(), l, g = performance.now();
+  const b = {
+    options: t,
+    graph: e,
+    signal: o.signal,
+    async progress(h) {
+      a = Math.max(a, performance.now() - d), o.signal.throwIfAborted(), o.report({ phase: c, completed: Number.isFinite(h) ? h : 0, total: 1 }), performance.now() - g >= Be && (await o.yieldNow(), g = performance.now()), o.signal.throwIfAborted(), d = performance.now();
+    },
+    note(h) {
+      r.push(h);
+    },
+    converged(h, m) {
+      l = { converged: h, iterations: m };
+    }
+  }, N = [], E = [];
+  let F = "integer", j = e.nodeCount;
+  const f = (h, m) => {
+    const y = { id: s, member: i, subject: h, source: "run" }, A = performance.now(), T = Ze(y, () => n.compute(m, b));
+    if (a = Math.max(a, performance.now() - A), T instanceof Promise)
+      throw T.catch(() => {
+      }), new P({
+        code: "E_EXTENSION_FAILED",
+        message: `${s}: ${i}() returned a Promise for ${h}; it must return the score itself. Remove "async", or write a "nodes" function for work that has to wait.`,
+        source: "run",
+        details: { extension: s, member: i, subject: h }
+      });
+    return T;
+  };
+  if (i === "node")
+    await ie(o, c, e.nodes(), (h) => {
+      const m = f(`node ${D(h.id)}`, h);
+      B(m) && N.push({ id: h.id, values: { value: m } });
+    });
+  else if (i === "edge")
+    j = e.edgeCount, await ie(o, c, e.edges(), (h) => {
+      const m = f(`edge ${JSON.stringify(h.id)}`, h);
+      B(m) && E.push({ id: h.id, values: { value: m } });
+    });
+  else {
+    let h;
+    try {
+      d = performance.now();
+      const y = n.compute(e, b);
+      a = Math.max(a, performance.now() - d), h = await y;
+    } catch (y) {
+      throw o.signal.aborted || te(y) ? y : G({ id: s, member: i, source: "run" }, y);
+    }
+    let m = 0;
+    for (const [y, A] of mt(n, e, h, r))
+      typeof A == "boolean" && m++, i === "nodes" && B(A) ? N.push({ id: y, values: { value: A } }) : i === "groups" && (typeof A == "string" || B(A)) && ((typeof A == "string" || !Number.isInteger(A)) && (F = "string"), N.push({ id: y, values: { group: A } }));
+    if (m > 0) {
+      const y = i === "groups" ? "a group is a number or a string" : "a score is a number";
+      r.push(
+        `${s}: ${i}() returned true or false for ${String(m)} ${m === 1 ? "node" : "nodes"}; ${y}, so they were left out.`
+      );
+    }
+  }
+  const k = i === "edge" ? "edge" : "node";
+  if (j > 0 && N.length + E.length === 0 && r.push(`${s}: no ${k} was measured -- did the function return NaN or undefined for every ${k}?`), r.push(...Pe(e)), a > fe) {
+    const h = i === "node" || i === "edge" ? "each call should take a moment, with the slow work moved to a whole-graph function." : "await context.progress(i / n) inside its loop.", m = `${s}: ${i}() held the page for over ${String(fe)} ms at a time; ${h}`;
+    r.push(m), he.has(s) || (he.add(s), console.warn(m));
+  }
+  const $ = dt(e);
+  $.length > 0 && r.push(`${s} read: ${$.map(({ target: h, path: m }) => `${h} ${JSON.stringify(m)}`).join(", ")}.`);
+  const [u] = ut(e), p = i === "groups" ? Je(!1).map((h) => h.name === "group" ? { ...h, type: F } : h) : Ve(k);
+  return {
+    shape: _e[i],
+    fields: p,
+    ...i === "edge" ? { edges: E } : { nodes: N },
+    ...i === "groups" ? {} : { graph: { normalization: "none" } },
+    caveats: Ge({
+      method: c,
+      direction: e.directed ? "directed" : "undirected",
+      weight: u === void 0 ? null : { attribute: u, meaning: n.weights?.meaning ?? "strength" },
+      notes: r,
+      ...l ?? {},
+      // Stopping at a cap the caller set publishes what the run has, marked inexact
+      // (algorithm.md section 2.2 item 9).
+      ...l?.converged === !1 ? { exact: !1, partialReason: "iteration cap reached" } : {}
+    })
+  };
+}
+function wt(n) {
+  const { id: e, passes: t } = n, o = n.member === "node" || n.member === "edge", i = class i extends Ne {
+    /**
+     * Run the definition over the graph as it stands.
+     * @param context - What the element gave the run.
+     * @returns The output.
+     */
+    compute(r) {
+      const a = Me(Le(this.graph.getSession()), {
+        id: e,
+        directed: n.directed
+      });
+      return yt(n, a, this.schemaOptions, r);
+    }
+  };
+  i.namespace = e, i.type = e, i.descriptor = pt(n), i.parallelEdges = "none", i.version = n.version, i.costUnits = (r, a, d) => {
+    if (o)
+      return r + 2 * a;
+    const l = t === void 0 ? 1 : Number(d[t]);
+    return (r + a) * (Number.isFinite(l) && l > 0 ? l : 1);
+  };
+  let s = i;
+  return Object.defineProperty(s, "name", { value: `SimpleAlgorithm(${e})` }), s;
+}
+function Jt(n, e) {
+  const t = gt(n), { compute: o, ...s } = t, i = JSON.stringify(s);
+  let c = le.get(o);
+  c?.signature !== i && (c = { cls: wt(t), signature: i }, le.set(o, c)), Ne.register(c.cls, e);
+}
+const V = "defineLayout", ge = 200, $t = 1, bt = 5, Q = L.getLogger(["graphty", "layout", "simple"]), pe = /* @__PURE__ */ new Set(), me = /* @__PURE__ */ new Map();
+function Z(n, e, t = {}) {
+  Q.warn(e, { layout: n, ...t }), (!L.isEnabled() || !L.getSinks().some((o) => o.name === "console")) && console.warn(`[graphty] ${e}`);
+}
+function vt(n) {
+  let e = n >>> 0;
+  return () => {
+    e = e + 1831565813 >>> 0;
+    let t = e;
+    return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function St() {
+  return new Promise((n) => {
+    setTimeout(n, 0);
+  });
+}
+function H(n, e) {
+  return new P({
+    code: "E_EXTENSION_FAILED",
+    message: e,
+    source: "layout",
+    details: { extension: n, member: "place" }
+  });
+}
+function ye(n) {
+  return typeof n == "string" || typeof n == "number" ? D(n) : v(n);
+}
+function Nt(n) {
+  const e = new Set(n.nodes().map((t) => typeof t.id));
+  return e.size > 1 ? "strings and numbers" : e.has("number") ? "numbers" : "strings";
+}
+function Et(n, e, t, o) {
+  if (!(e instanceof Map))
+    throw H(
+      n,
+      `${n}: place() must return a Map from node id to [x, y] or [x, y, z]; got ${v(e)}.`
+    );
+  const s = {}, i = [];
+  let c = 0;
+  for (const [r, a] of e) {
+    const d = typeof r == "string" || typeof r == "number" ? t.node(r) : void 0;
+    if (d === void 0) {
+      i.push(r);
+      continue;
+    }
+    if (c++, a == null)
+      continue;
+    if (!Array.isArray(a) || a.length !== 2 && a.length !== 3 || !a.every((N) => typeof N == "number")) {
+      const N = Array.isArray(a) ? `[${a.map(String).join(", ")}]` : v(a);
+      throw H(
+        n,
+        `${n}: place() returned ${N} for node ${D(d.id)}. A position is two or three numbers; leave the node out to leave it unplaced.`
+      );
+    }
+    const [l, g] = a, b = a.length === 3 && !o ? a[2] : 0;
+    Number.isFinite(l) && Number.isFinite(g) && Number.isFinite(b) && (s[String(d.id)] = [l, g, b]);
+  }
+  if (c === 0 && e.size > 0)
+    throw H(
+      n,
+      `${n}: place() returned ${e.size} positions but no key matches a node id (got ${ye(i[0])}; node ids here are ${Nt(t)}). Key the map by node.id.`
+    );
+  if (i.length > 0) {
+    const r = i.slice(0, bt).map(ye);
+    Z(
+      n,
+      `${n}: place() returned positions for ${String(i.length)} keys that are not nodes (${r.join(", ")}); they were left out.`,
+      { count: i.length, keys: r }
+    );
+  }
+  return s;
+}
+function kt(n, e, t) {
+  var s, i, c, r, a, d, l, je, ee, Ce, E;
+  const { id: o } = n;
+  return E = class extends Ke {
+    constructor(f = {}) {
+      super(f);
+      I(this, l);
+      /** The resolved option values `place` receives. */
+      I(this, s);
+      /** The run in progress, aborted when a newer one starts or the engine is disposed. */
+      I(this, i, null);
+      /** A finished layout waiting for the next `doLayout` to adopt it, and the change count it saw. */
+      I(this, c, null);
+      /** Bumped by every node or edge change, so a layout computed over an older graph is redone. */
+      I(this, r, 0);
+      /** The change count the background run in flight saw, or null when none is. */
+      I(this, a, null);
+      I(this, d, !1);
+      this.scalingFactor = 1;
+      const k = f;
+      O(this, s, Object.fromEntries(
+        n.options.map(($) => [$.name, k[$.name] ?? $.default])
+      )), n.random && typeof S(this, s).seed != "number" && (S(this, s).seed = Math.floor(Math.random() * 2 ** 32), Q.info(`${o}: drew a layout seed`, { layout: o, seed: S(this, s).seed })), this.config = { ...S(this, s) };
+    }
+    /**
+     * Compute the first layout before the element starts drawing, so a refusal or a throw from
+     * `place` reaches the `setLayout` call that caused it.
+     */
+    async init() {
+      const f = S(this, r);
+      O(this, c, { positions: await z(this, l, ee).call(this), seen: f });
+    }
+    /** Adopt a finished layout; when the graph has changed since it started, place again. */
+    doLayout() {
+      this.stale = !1;
+      const f = S(this, c);
+      f !== null && (this.positions = f.positions, O(this, c, null), f.seen === S(this, r)) || S(this, a) !== S(this, r) && z(this, l, je).call(this);
+    }
+    addNode(f) {
+      super.addNode(f), R(this, r)._++;
+    }
+    addEdge(...f) {
+      super.addEdge(...f), R(this, r)._++;
+    }
+    removeNode(f) {
+      super.removeNode(f), R(this, r)._++;
+    }
+    removeEdge(...f) {
+      super.removeEdge(...f), R(this, r)._++;
+    }
+    /**
+     * Undo or redo restored an arrangement: drop any placement still being computed or waiting
+     * to be drawn, so it cannot land over the restored one.
+     */
+    loadArrangement() {
+      S(this, i)?.abort(), O(this, a, null), O(this, c, null), super.loadArrangement();
+    }
+    dispose() {
+      O(this, d, !0), S(this, i)?.abort(), super.dispose();
+    }
+  }, s = new WeakMap(), i = new WeakMap(), c = new WeakMap(), r = new WeakMap(), a = new WeakMap(), d = new WeakMap(), l = new WeakSet(), /** Place again in the background, off this frame, and draw the result when it arrives. */
+  je = function() {
+    const f = S(this, r);
+    O(this, a, f);
+    const k = () => S(this, a) === f && !S(this, d);
+    z(this, l, ee).call(this).then(
+      ($) => {
+        if (!k())
+          return;
+        O(this, a, null), O(this, c, { positions: $, seen: f }), this.stale = !0;
+        const u = this._nodes[0]?.parentGraph;
+        u && (u.getLayoutManager().running = !0);
+      },
+      ($) => {
+        if (!k())
+          return;
+        O(this, a, null);
+        const u = $ instanceof Error ? $ : new Error(String($));
+        Q.error(`${o}: the layout could not be recomputed`, u, { layout: o });
+        const p = this._nodes[0]?.parentGraph;
+        p?.getEventManager?.()?.emitGraphError(p, u, "layout", { layoutType: o });
+      }
+    );
+  }, ee = async function() {
+    S(this, i)?.abort();
+    const f = new AbortController();
+    O(this, i, f);
+    const k = this._nodes[0]?.parentGraph, $ = k?.getSession?.();
+    if (k === void 0 || $ === void 0)
+      return {};
+    const u = k.getStyles().config.graph.viewMode === "2d", p = Me(Le($), { id: o, directed: !1, source: "layout" });
+    De(p, o, n.options, S(this, s), "layout");
+    const h = new Map(this._nodes.map((x) => [x.id, x]));
+    let m = 0, y = 0;
+    const A = {
+      options: S(this, s),
+      dimensions: u ? 2 : 3,
+      fixed: (x) => z(this, l, Ce).call(this, h.get(x), u),
+      random: vt(n.random ? S(this, s).seed : $t),
+      signal: f.signal,
+      progress: async () => {
+        y = Math.max(y, performance.now() - m), f.signal.throwIfAborted(), await St(), f.signal.throwIfAborted(), m = performance.now();
+      }
+    };
+    f.signal.throwIfAborted();
+    const T = await et({ id: o, member: "place", source: "layout" }, () => {
+      m = performance.now();
+      const x = n.place(p, A);
+      return y = Math.max(y, performance.now() - m), x;
+    });
+    if (f.signal.throwIfAborted(), y > ge && !pe.has(o)) {
+      pe.add(o);
+      const x = `${o}: place() held the page for over ${ge} ms at a time; await context.progress(i / n) inside its loop.`;
+      Z(o, x);
+    }
+    for (const x of Pe(p))
+      Z(o, x);
+    return Et(o, T, p, u);
+  }, /**
+   * Where a pinned or held node is.
+   * @param node - The node, when the graph has it.
+   * @param twoD - Whether the view is 2D.
+   * @returns Its position, or null for a node the layout may place.
+   */
+  Ce = function(f, k) {
+    if (f === void 0 || !(f.isPinned() || this.isHeld(f.index)))
+      return null;
+    const $ = { x: 0, y: 0, z: 0 };
+    return this.readNodePosition(f, $) ? k ? [$.x, $.y] : [$.x, $.y, $.z] : null;
+  }, E.type = o, E.maxDimensions = t, E.scoped = !0, E.descriptor = e, E;
+}
+function At(n) {
+  const e = new Set(n.map((o) => o.type)), t = [];
+  return (e.has("node-id") || e.has("node-set")) && t.push("node"), e.has("partition") && t.push("partition"), e.has("ordering") && t.push("ordering"), t;
+}
+function Vt(n, e) {
+  const t = U(V, n), { id: o } = t;
+  ne(V, t, "place"), K(V, t, "dimensions", [2, 3]), K(V, t, "random", [!0, !1]);
+  const s = Ie(V, o, t.options), i = t.random === !0;
+  i && !s.some((N) => N.name === "seed") && s.push({ name: "seed", plainName: "Seed", type: "seed" });
+  const c = t.dimensions === 2 ? 2 : 3, r = Y(t), a = typeof t.description == "string" ? t.description : "", d = JSON.stringify([r, a, c, i, s]), l = me.get(o);
+  if (l !== void 0 && l.place === t.place && l.signature === d && re.getClass(o) === l.engine)
+    return;
+  const g = {
+    id: o,
+    plainName: r,
+    technicalName: r,
+    description: a,
+    family: "custom",
+    kind: "batch",
+    maxDimensions: c,
+    sizeRating: "any",
+    structuralInputs: At(s),
+    options: s,
+    engine: o
+  }, b = kt(
+    { id: o, options: s, random: i, place: t.place },
+    g,
+    c
+  );
+  re.register(b, e), me.set(o, { place: t.place, signature: d, engine: b });
+}
+const oe = ["error", "warn", "info", "debug", "trace"], Ot = 1e3, we = [1e3, 2e3, 4e3], xt = 5e3, $e = /* @__PURE__ */ new WeakMap();
+let be = !1;
+function Mt(n) {
+  const { error: e } = n;
+  return Object.freeze({
+    time: n.timestamp,
+    level: oe[n.level - 1] ?? "error",
+    category: n.category.join("."),
+    message: n.message,
+    ...n.data === void 0 ? {} : { data: n.data },
+    ...e === void 0 ? {} : {
+      error: Object.freeze({
+        name: e.name,
+        message: e.message,
+        ...e.stack === void 0 ? {} : { stack: e.stack }
+      })
+    }
+  });
+}
+async function Pt(n) {
+  try {
+    const e = await n;
+    if (typeof e == "object" && e !== null && "ok" in e && "status" in e && e.ok === !1) {
+      const t = Number(e.status);
+      return { ok: !1, retry: !(t >= 400 && t < 500 && t !== 408 && t !== 429), cause: `HTTP ${String(t)}` };
+    }
+    return { ok: !0 };
+  } catch (e) {
+    return { ok: !1, retry: !0, cause: e };
+  }
+}
+function Tt(n, e) {
+  const { write: t } = e, o = [];
+  let s = 0, i = !1, c;
+  const r = async (d, l) => {
+    let g = l ?? Promise.resolve().then(() => t(d));
+    for (let b = 0; ; b++) {
+      const N = await Pt(g);
+      if (N.ok)
+        return;
+      if (!N.retry || b === we.length || i) {
+        console.error(
+          `[GraphtyLogger] Log destination "${n}" could not send a record after ${String(b + 1)} attempt(s):`,
+          N.cause
+        );
+        return;
+      }
+      await new Promise((E) => setTimeout(E, we[b])), g = Promise.resolve().then(() => t(d));
+    }
+  }, a = async (d, l) => {
+    for (await r(d, l); !i && (o.length > 0 || s > 0); ) {
+      if (s > 0) {
+        const b = s;
+        s = 0, await r(
+          Object.freeze({
+            time: /* @__PURE__ */ new Date(),
+            level: "warn",
+            category: "graphty.logging",
+            message: `${String(b)} log records were dropped because "${n}" could not send them as fast as they were made.`
+          })
+        );
+      }
+      const g = o.shift();
+      g !== void 0 && await r(g);
+    }
+    c = void 0;
+  };
+  return {
+    name: n,
+    level: oe.indexOf(e.level ?? "warn") + 1,
+    ...e.categories === void 0 ? {} : { categories: [...e.categories] },
+    write(d) {
+      if (i)
+        return;
+      const l = Mt(d);
+      if (c !== void 0) {
+        o.push(l), o.length > Ot && (o.shift(), s += 1);
+        return;
+      }
+      const g = t(l);
+      (g instanceof Promise || typeof g == "object" && g !== null && "then" in g) && (c = a(l, g));
+    },
+    flush: () => c ?? Promise.resolve(),
+    async dispose() {
+      if (c !== void 0) {
+        let d;
+        await Promise.race([c, new Promise((l) => d = setTimeout(l, xt))]), clearTimeout(d);
+      }
+      i = !0, o.length = 0;
+    }
+  };
+}
+function It(n) {
+  const e = U("defineLogDestination", n);
+  ne("defineLogDestination", e, "write");
+  const { level: t, categories: o } = e;
+  if (t !== void 0 && !oe.includes(t))
+    throw w(
+      "defineLogDestination",
+      e.id,
+      "level",
+      `"level" must be one of "error", "warn", "info", "debug" or "trace"; got ${v(t)}.`
+    );
+  if (o !== void 0 && !(Array.isArray(o) && o.every((s) => typeof s == "string" && s !== "")))
+    throw w(
+      "defineLogDestination",
+      e.id,
+      "categories",
+      `"categories" must be a list of words such as ["layout"]; got ${v(o)}.`
+    );
+  return K("defineLogDestination", e, "attach", [!0, !1]), e;
+}
+function Gt(n, e) {
+  const t = It(n), { id: o } = t, s = $e.get(n) ?? {
+    descriptor: {
+      id: o,
+      plainName: Y(t),
+      description: typeof t.description == "string" ? t.description : "",
+      options: []
+    },
+    create: () => Tt(o, t)
+  };
+  Ue(s, e), $e.set(n, s), !be && typeof window < "u" && (be = !0, window.addEventListener("pagehide", () => {
+    L.flush();
+  }));
+  const i = t.attach === !1 ? void 0 : s.create({});
+  return i !== void 0 && L.addSink(i), () => {
+    i !== void 0 && L.getSinks().includes(i) && L.removeSink(o);
+  };
+}
+const Dt = ["sequential", "diverging", "categorical"], ve = 'Read the token first with getComputedStyle(document.documentElement).getPropertyValue("--brand-navy").trim(), after the stylesheet that defines it has loaded, and pass the colour that returns.';
+function Bt(n, e) {
+  const t = U("definePalette", n), { id: o } = t;
+  if (!Dt.includes(t.kind))
+    throw w(
+      "definePalette",
+      o,
+      "kind",
+      `"kind" must be "categorical", "sequential" or "diverging"; got ${v(t.kind)}.`
+    );
+  const { colors: s } = t;
+  if (!Array.isArray(s) || s.length === 0)
+    throw w(
+      "definePalette",
+      o,
+      "colors",
+      `"colors" must be a non-empty list of colours such as ["#0B1D51", "#1B7F79"]; got ${v(s)}.`
+    );
+  for (const r of s) {
+    if (typeof r == "string" && r.trim() === "")
+      throw w(
+        "definePalette",
+        o,
+        "colors",
+        `a colour is an empty string, which is what a design token reads as before its stylesheet has loaded. ${ve}`
+      );
+    if (typeof r == "string" && /var\s*\(/i.test(r))
+      throw w(
+        "definePalette",
+        o,
+        "colors",
+        `${JSON.stringify(r)} is a CSS variable, which a palette cannot hold. ${ve}`
+      );
+    if (typeof r != "string" || We(r) === null)
+      throw w(
+        "definePalette",
+        o,
+        "colors",
+        `${typeof r == "string" ? JSON.stringify(r) : v(r)} is not a colour. Write any CSS colour: "#0B1D51", "rgb(27, 127, 121)", "oklch(0.7 0.15 30)" or a colour name.`
+      );
+  }
+  const i = t.colorblindSafe ?? [];
+  if (!Array.isArray(i) || i.some((r) => !["deuteranopia", "protanopia", "tritanopia"].includes(r)))
+    throw w(
+      "definePalette",
+      o,
+      "colorblindSafe",
+      `"colorblindSafe" lists "deuteranopia", "protanopia" or "tritanopia"; got ${v(i)}.`
+    );
+  const c = {
+    id: o,
+    plainName: Y(t),
+    kind: t.kind,
+    colors: s,
+    ...t.colorblindSafe === void 0 ? {} : { colorblindSafe: t.colorblindSafe }
+  };
+  He(c, e);
+}
+export {
+  Vt as a,
+  Gt as b,
+  tt as c,
+  Jt as d,
+  Bt as e
+};