@floegence/floe-webapp-core 0.86.5 → 0.86.8

package/dist/components/graph/positions.js

@@ -1,174 +1,75 @@
-const T = (r, a = 0) => ({
-  left: r.x - a,
-  top: r.y - a,
-  right: r.x + r.width + a,
-  bottom: r.y + r.height + a
-}), S = (r, a) => r.x > a.left && r.x < a.right && r.y > a.top && r.y < a.bottom, O = (r, a, w) => !w.some(
-  (c) => r.x === a.x ? r.x > c.left && r.x < c.right && Math.max(r.y, a.y) > c.top && Math.min(r.y, a.y) < c.bottom : r.y > c.top && r.y < c.bottom && Math.max(r.x, a.x) > c.left && Math.min(r.x, a.x) < c.right
-);
-function P(r, a, w) {
-  if (w.some((e) => S(r, e) || S(a, e)))
-    throw new Error("Pinned graph positions obstruct an edge endpoint");
-  const c = [
-    .../* @__PURE__ */ new Set([r.x, a.x, ...w.flatMap((e) => [e.left, e.right])])
-  ].sort((e, i) => e - i), m = [
-    .../* @__PURE__ */ new Set([r.y, a.y, ...w.flatMap((e) => [e.top, e.bottom])])
-  ].sort((e, i) => e - i), l = (e) => ({ x: c[e % c.length], y: m[Math.floor(e / c.length)] }), g = m.indexOf(r.y) * c.length + c.indexOf(r.x), n = m.indexOf(a.y) * c.length + c.indexOf(a.x), M = /* @__PURE__ */ new Map([[g, 0]]), d = /* @__PURE__ */ new Map(), t = [], u = (e) => {
-    let i = t.length;
-    for (t.push(e); i > 0; ) {
-      const x = i - 1 >> 1;
-      if (t[x].score <= e.score) break;
-      t[i] = t[x], i = x;
-    }
-    t[i] = e;
-  }, I = () => {
-    const e = t[0], i = t.pop();
-    if (t.length) {
-      let x = 0;
-      for (; x * 2 + 1 < t.length; ) {
-        let h = x * 2 + 1;
-        if (h + 1 < t.length && t[h + 1].score < t[h].score && h++, t[h].score >= i.score) break;
-        t[x] = t[h], x = h;
-      }
-      t[x] = i;
-    }
-    return e;
-  };
-  u({ id: g, score: 0, cost: 0 });
-  let v = 0;
-  for (; t.length && v++ < 5e4; ) {
-    const e = I();
-    if (e.cost !== M.get(e.id)) continue;
-    if (e.id === n) {
-      const y = [l(n)];
-      let o = n;
-      for (; o !== g; )
-        o = d.get(o), y.push(l(o));
-      return y.reverse(), y.filter((p, f) => {
-        const E = y[f - 1], b = y[f + 1];
-        return !E || !b || !(E.x === p.x && p.x === b.x || E.y === p.y && p.y === b.y);
-      });
-    }
-    const i = l(e.id), x = e.id % c.length, h = Math.floor(e.id / c.length), s = [
-      x ? e.id - 1 : -1,
-      x + 1 < c.length ? e.id + 1 : -1,
-      h ? e.id - c.length : -1,
-      h + 1 < m.length ? e.id + c.length : -1
-    ];
-    for (const y of s) {
-      if (y < 0) continue;
-      const o = l(y), p = e.cost + Math.abs(i.x - o.x) + Math.abs(i.y - o.y);
-      p >= (M.get(y) ?? 1 / 0) || !O(i, o, w) || (M.set(y, p), d.set(y, e.id), u({ id: y, cost: p, score: p + Math.abs(o.x - a.x) + Math.abs(o.y - a.y) }));
-    }
-  }
-  throw new Error("Pinned graph positions cannot be routed within the layout budget");
-}
-function k(r, a, w) {
-  if (!a.positions?.length) return r;
-  const c = new Map(r.nodes.map((t) => [t.id, { ...t }])), m = /* @__PURE__ */ new Map();
-  for (const t of a.positions) {
-    if (!c.has(t.nodeId) || m.has(t.nodeId) || !Number.isFinite(t.x) || !Number.isFinite(t.y))
+import { routeGraphGeometry as G } from "./routing.js";
+function E(d, p, v) {
+  if (!p.positions?.length || p.positionMode === "compact") return d;
+  const f = new Map(d.nodes.map((t) => [t.id, { ...t }])), l = /* @__PURE__ */ new Map();
+  for (const t of p.positions) {
+    if (!f.has(t.nodeId) || l.has(t.nodeId) || !Number.isFinite(t.x) || !Number.isFinite(t.y))
       throw new Error(`Invalid graph position: ${t.nodeId}`);
-    m.set(t.nodeId, t);
+    l.set(t.nodeId, t);
   }
-  const l = /* @__PURE__ */ new Map();
-  for (const t of c.values())
+  const y = /* @__PURE__ */ new Map();
+  for (const t of f.values())
     if (t.parentId) {
-      const u = l.get(t.parentId) ?? [];
-      u.push(t), l.set(t.parentId, u);
+      const m = y.get(t.parentId) ?? [];
+      m.push(t), y.set(t.parentId, m);
     }
-  const g = a.groupPadding ?? { top: 64, left: 28, right: 28, bottom: 28 }, n = a.positionMode === "preferred", M = new Map(w.map((t) => [t.id, t])), d = (t, u, I) => {
-    const v = { x: t.x, y: t.y }, e = m.get(t.id);
-    t.x = e?.x ?? t.x + u, t.y = e?.y ?? t.y + I;
-    const i = l.get(t.id) ?? [];
-    for (const o of i) d(o, t.x - v.x, t.y - v.y);
-    if (!i.length || n) return;
-    const x = Math.min(...i.map((o) => o.x)) - g.left, h = Math.min(...i.map((o) => o.y)) - g.top;
-    if (e && (x < t.x || h < t.y))
+  const x = p.groupPadding ?? { top: 64, left: 28, right: 28, bottom: 28 }, u = p.positionMode === "preferred", I = new Map(v.map((t) => [t.id, t])), b = (t, m, M) => {
+    const g = { x: t.x, y: t.y }, c = l.get(t.id);
+    t.x = c?.x ?? t.x + m, t.y = c?.y ?? t.y + M;
+    const i = y.get(t.id) ?? [];
+    for (const a of i) b(a, t.x - g.x, t.y - g.y);
+    if (!i.length || u) return;
+    const r = Math.min(...i.map((a) => a.x)) - x.left, h = Math.min(...i.map((a) => a.y)) - x.top;
+    if (c && (r < t.x || h < t.y))
       throw new Error(`Pinned child lies outside group content: ${t.id}`);
     const s = Math.max(
       t.x + t.width,
-      ...i.map((o) => o.x + o.width + g.right)
-    ), y = Math.max(
+      ...i.map((a) => a.x + a.width + x.right)
+    ), n = Math.max(
       t.y + t.height,
-      ...i.map((o) => o.y + o.height + g.bottom)
+      ...i.map((a) => a.y + a.height + x.bottom)
     );
-    e || (t.x = Math.min(t.x, x), t.y = Math.min(t.y, h)), t.width = s - t.x, t.height = y - t.y;
+    c || (t.x = Math.min(t.x, r), t.y = Math.min(t.y, h)), t.width = s - t.x, t.height = n - t.y;
   };
-  for (const t of c.values()) t.parentId || d(t, 0, 0);
-  if (n) {
-    const t = Math.max(16, a.spacing ?? 64), u = (i, x, h) => {
-      i.x += x, i.y += h;
-      for (const s of l.get(i.id) ?? []) u(s, x, h);
-    }, I = (i) => {
-      const x = [];
+  for (const t of f.values()) t.parentId || b(t, 0, 0);
+  if (u) {
+    const t = Math.max(16, p.spacing ?? 64), m = (i, r, h) => {
+      i.x += r, i.y += h;
+      for (const s of y.get(i.id) ?? []) m(s, r, h);
+    }, M = (i) => {
+      const r = [];
       for (const h of [...i].sort(
-        (s, y) => s.y - y.y || s.x - y.x || s.id.localeCompare(y.id)
+        (s, n) => s.y - n.y || s.x - n.x || s.id.localeCompare(n.id)
       )) {
         const s = { x: h.x, y: h.y };
-        for (const p of [...x].sort((f, E) => f.x - E.x))
-          h.y < p.y + p.height + t && h.y + h.height + t > p.y && s.x < p.x + p.width + t && s.x + h.width + t > p.x && (s.x = p.x + p.width + t);
-        const y = { x: h.x, y: h.y };
-        for (const p of [...x].sort((f, E) => f.y - E.y))
-          h.x < p.x + p.width + t && h.x + h.width + t > p.x && y.y < p.y + p.height + t && y.y + h.height + t > p.y && (y.y = p.y + p.height + t);
-        const o = s.x - h.x < y.y - h.y ? s : y;
-        u(h, o.x - h.x, o.y - h.y), x.push(h);
+        for (const o of [...r].sort((e, w) => e.x - w.x))
+          h.y < o.y + o.height + t && h.y + h.height + t > o.y && s.x < o.x + o.width + t && s.x + h.width + t > o.x && (s.x = o.x + o.width + t);
+        const n = { x: h.x, y: h.y };
+        for (const o of [...r].sort((e, w) => e.y - w.y))
+          h.x < o.x + o.width + t && h.x + h.width + t > o.x && n.y < o.y + o.height + t && n.y + h.height + t > o.y && (n.y = o.y + o.height + t);
+        const a = s.x - h.x < n.y - h.y ? s : n;
+        m(h, a.x - h.x, a.y - h.y), r.push(h);
       }
-    }, v = (i) => {
-      const x = l.get(i.id) ?? [];
-      if (!x.length) return;
-      for (const f of x) v(f);
-      I(x);
-      const h = Math.max(12, g.left), s = Math.max(12, g.top), y = Math.max(12, g.right), o = Math.max(12, g.bottom), p = m.get(i.id);
-      i.x = Math.min(p?.x ?? 1 / 0, Math.min(...x.map((f) => f.x)) - h), i.y = Math.min(p?.y ?? 1 / 0, Math.min(...x.map((f) => f.y)) - s), i.width = Math.max(
-        M.get(i.id).width,
-        Math.max(...x.map((f) => f.x + f.width)) + y - i.x
+    }, g = (i) => {
+      const r = y.get(i.id) ?? [];
+      if (!r.length) return;
+      for (const e of r) g(e);
+      M(r);
+      const h = Math.max(12, x.left), s = Math.max(12, x.top), n = Math.max(12, x.right), a = Math.max(12, x.bottom), o = l.get(i.id);
+      i.x = Math.min(o?.x ?? 1 / 0, Math.min(...r.map((e) => e.x)) - h), i.y = Math.min(o?.y ?? 1 / 0, Math.min(...r.map((e) => e.y)) - s), i.width = Math.max(
+        I.get(i.id).width,
+        Math.max(...r.map((e) => e.x + e.width)) + n - i.x
       ), i.height = Math.max(
-        M.get(i.id).height,
-        Math.max(...x.map((f) => f.y + f.height)) + o - i.y
+        I.get(i.id).height,
+        Math.max(...r.map((e) => e.y + e.height)) + a - i.y
       );
-    }, e = [...c.values()].filter((i) => !i.parentId);
-    for (const i of e) v(i);
-    I(e);
+    }, c = [...f.values()].filter((i) => !i.parentId);
+    for (const i of c) g(i);
+    M(c);
   }
-  return N({ ...r, nodes: [...c.values()] });
-}
-function N(r) {
-  if (!r.nodes.length) return r;
-  const a = new Map(r.nodes.map((n) => [n.id, n])), w = r.edges.map((n) => {
-    const M = a.get(n.source), d = a.get(n.target), t = (s, y, o) => s.ports?.find((p) => p.id === y)?.side ?? o, u = M.x + M.width / 2 <= d.x + d.width / 2, I = (s, y) => {
-      const o = { x: s.x + s.width / 2, y: s.y + s.height / 2 };
-      return y === "NORTH" ? [
-        { x: o.x, y: s.y },
-        { x: o.x, y: s.y - 8 }
-      ] : y === "SOUTH" ? [
-        { x: o.x, y: s.y + s.height },
-        { x: o.x, y: s.y + s.height + 8 }
-      ] : y === "WEST" ? [
-        { x: s.x, y: o.y },
-        { x: s.x - 8, y: o.y }
-      ] : [
-        { x: s.x + s.width, y: o.y },
-        { x: s.x + s.width + 8, y: o.y }
-      ];
-    }, [v, e] = I(M, t(M, n.sourcePort, u ? "EAST" : "WEST")), [i, x] = I(
-      d,
-      t(d, n.targetPort, M === d ? "NORTH" : u ? "WEST" : "EAST")
-    ), h = [...a.values()].filter((s) => s.kind !== "group").map((s) => T(s, 4));
-    return { ...n, sections: [[v, ...P(e, x, h), i]] };
-  }), c = [...a.values()], m = w.flatMap((n) => n.sections.flat()), l = Math.min(...c.map((n) => n.x), ...m.map((n) => n.x)), g = Math.min(...c.map((n) => n.y), ...m.map((n) => n.y));
-  return {
-    nodes: c,
-    edges: w,
-    bounds: {
-      x: l,
-      y: g,
-      width: Math.max(...c.map((n) => n.x + n.width), ...m.map((n) => n.x)) - l,
-      height: Math.max(...c.map((n) => n.y + n.height), ...m.map((n) => n.y)) - g
-    }
-  };
+  return G({ ...d, nodes: [...f.values()] });
 }
 export {
-  k as applyGraphPositions,
-  N as routeGraphGeometry
+  E as applyGraphPositions,
+  G as routeGraphGeometry
 };

package/dist/components/graph/routing.d.ts

@@ -0,0 +1,3 @@
+import type { GraphLayout } from './types';
+/** Joint orthogonal routing through the final rectangular geometry. */
+export declare function routeGraphGeometry(layout: GraphLayout): Promise<GraphLayout>;

package/dist/components/graph/routing.js

@@ -0,0 +1,202 @@
+import { AvoidLib as H } from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/index.js";
+import W from "../../node_modules/.pnpm/libavoid-js@0.5.0-beta.5/node_modules/libavoid-js/dist/libavoid.wasm.js";
+let N;
+const B = { NORTH: 1, SOUTH: 2, WEST: 4, EAST: 8 }, v = ["NORTH", "EAST", "SOUTH", "WEST"], m = (t) => t.delete();
+async function F(t) {
+  if (!t.nodes.length) return t;
+  if (!t.edges.length) return C(t);
+  await (N ??= H.load(W).catch((h) => {
+    throw N = void 0, h;
+  }));
+  const e = H.getInstance(), s = new Map(t.nodes.map((h) => [h.id, h])), d = (h) => {
+    const y = [];
+    for (let r = s.get(h).parentId; r; r = s.get(r).parentId)
+      y.push(r);
+    return y;
+  }, i = /* @__PURE__ */ new Map();
+  for (const h of t.edges) {
+    const y = /* @__PURE__ */ new Set([...d(h.source), ...d(h.target)]), r = JSON.stringify([...y].sort()), S = i.get(r) ?? { open: y, edges: [] };
+    S.edges.push(h), i.set(r, S);
+  }
+  const f = /* @__PURE__ */ new Map();
+  for (const { open: h, edges: y } of i.values()) {
+    const r = new e.Router(2);
+    try {
+      r.setRoutingParameter(e.RoutingParameter.shapeBufferDistance, 4), r.setRoutingParameter(e.RoutingParameter.idealNudgingDistance, 8), r.setRoutingParameter(e.RoutingParameter.crossingPenalty, 80), r.setRoutingParameter(e.RoutingParameter.fixedSharedPathPenalty, 120), r.setRoutingParameter(e.RoutingParameter.portDirectionPenalty, 0), r.setRoutingOption(e.RoutingOption.nudgeOrthogonalSegmentsConnectedToShapes, !1), r.setRoutingOption(e.RoutingOption.nudgeSharedPathsWithCommonEndPoint, !0);
+      const S = new Map(
+        t.nodes.filter((n) => !h.has(n.id) && d(n.id).every((a) => h.has(a))).map((n) => {
+          const a = new e.Point(n.x, n.y), p = new e.Point(n.x + n.width, n.y + n.height), o = new e.Rectangle(a, p), c = new e.ShapeRef(r, o);
+          return m(a), m(p), m(o), [n.id, c];
+        })
+      ), P = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map();
+      y.forEach((n) => {
+        const a = s.get(n.source), p = s.get(n.target), o = D(a, p), c = n.sourcePort ? a.ports.find((u) => u.id === n.sourcePort).side : n.targetPort ? O(p.ports.find((u) => u.id === n.targetPort).side) : o.source, g = n.targetPort ? p.ports.find((u) => u.id === n.targetPort).side : n.sourcePort ? O(a.ports.find((u) => u.id === n.sourcePort).side) : o.target, w = [n.source, n.target].sort().join("\0"), x = R.get(w) ?? 0;
+        R.set(w, x + 1), P.set(n.id, {
+          sourceSide: c,
+          targetSide: g,
+          offset: x % 2 === 0 ? -6 : 6
+        });
+      });
+      for (const n of t.nodes) {
+        const a = S.get(n.id);
+        if (!a) continue;
+        const p = (o, c, g, w, x) => {
+          const u = new e.ShapeConnectionPin(
+            a,
+            o,
+            c / n.width,
+            g / n.height,
+            !0,
+            0,
+            w
+          );
+          u.setExclusive(x), u.setConnectionCost(
+            n.width / 2 + n.height / 2 - Math.abs(c - n.width / 2) - Math.abs(g - n.height / 2)
+          );
+        };
+        for (const o of new Set(n.ports?.map((c) => c.side))) {
+          const { x: c, y: g } = A(n, o);
+          p(v.indexOf(o) + 2, c - n.x, g - n.y, B[o], !1);
+        }
+      }
+      const l = (n, a, p) => {
+        const o = s.get(n), c = S.get(n);
+        if (c && a)
+          return new e.ConnEnd(
+            c,
+            v.indexOf(o.ports.find((u) => u.id === a).side) + 2
+          );
+        const g = a ? A(o, o.ports.find((u) => u.id === a).side) : p, w = new e.Point(g.x, g.y), x = new e.ConnEnd(w);
+        return m(w), x;
+      }, M = y.map((n) => {
+        const a = s.get(n.source), p = s.get(n.target), o = P.get(n.id), c = l(
+          n.source,
+          n.sourcePort,
+          n.source === n.target ? { x: a.x + a.width, y: a.y + a.height / 3 } : k(a, o.sourceSide, p, o.offset)
+        ), g = l(
+          n.target,
+          n.targetPort,
+          n.source === n.target ? {
+            x: p.x + p.width,
+            y: p.y + p.height * 2 / 3
+          } : k(p, o.targetSide, a, o.offset)
+        ), w = new e.ConnRef(r, c, g);
+        if (m(c), m(g), n.source === n.target) {
+          const x = s.get(n.source), u = new e.CheckpointVector();
+          for (const U of [x.y + x.height / 3, x.y + x.height * 2 / 3]) {
+            const E = new e.Point(x.x + x.width + 24, U), b = new e.Checkpoint(E);
+            u.push_back(b), m(E), m(b);
+          }
+          w.setRoutingCheckpoints(u), m(u);
+        }
+        return { edge: n, connection: w };
+      });
+      r.processTransaction();
+      for (const { edge: n, connection: a } of M) {
+        const p = a.displayRoute(), o = Array.from({ length: p.size() }, (c, g) => {
+          const w = p.at(g), x = { x: w.x, y: w.y };
+          return m(w), x;
+        });
+        if (m(p), !a.hasValidRoute() || o.length < 2 || o.some((c) => !Number.isFinite(c.x) || !Number.isFinite(c.y)) || o.some((c, g) => g > 0 && c.x !== o[g - 1].x && c.y !== o[g - 1].y))
+          throw new Error(`Graph edge cannot be routed: ${n.id}`);
+        f.set(n.id, o);
+      }
+    } finally {
+      r.delete();
+    }
+  }
+  const T = t.edges.map((h) => ({ ...h, sections: [f.get(h.id)] }));
+  return C({
+    nodes: t.nodes,
+    edges: T,
+    bounds: t.bounds
+  });
+}
+function C(t) {
+  const e = [
+    ...t.nodes.flatMap((i) => [
+      { x: i.x, y: i.y },
+      { x: i.x + i.width, y: i.y + i.height }
+    ]),
+    ...t.edges.flatMap((i) => i.sections.flat())
+  ], s = Math.min(...e.map((i) => i.x)), d = Math.min(...e.map((i) => i.y));
+  return {
+    nodes: t.nodes,
+    edges: t.edges,
+    bounds: {
+      x: s,
+      y: d,
+      width: Math.max(...e.map((i) => i.x)) - s,
+      height: Math.max(...e.map((i) => i.y)) - d
+    }
+  };
+}
+function A(t, e) {
+  return {
+    x: e === "WEST" ? t.x : e === "EAST" ? t.x + t.width : t.x + t.width / 2,
+    y: e === "NORTH" ? t.y : e === "SOUTH" ? t.y + t.height : t.y + t.height / 2
+  };
+}
+function O(t) {
+  return {
+    NORTH: "SOUTH",
+    EAST: "WEST",
+    SOUTH: "NORTH",
+    WEST: "EAST"
+  }[t];
+}
+function D(t, e) {
+  const s = e.x + e.width / 2 - (t.x + t.width / 2), d = e.y + e.height / 2 - (t.y + t.height / 2), i = Math.max(t.x - (e.x + e.width), e.x - (t.x + t.width), 0), f = Math.max(
+    t.y - (e.y + e.height),
+    e.y - (t.y + t.height),
+    0
+  ), h = (f === 0 && i > 0 ? !0 : i === 0 && f > 0 ? !1 : i === 0 && f === 0 ? Math.abs(s) >= Math.abs(d) : i <= f) ? s >= 0 ? "EAST" : "WEST" : d >= 0 ? "SOUTH" : "NORTH";
+  return { source: h, target: O(h) };
+}
+function k(t, e, s, d = 0) {
+  const i = (r) => Math.min(8, r / 4), f = (r, S, P) => Math.max(S + i(P), Math.min(S + P - i(P), r)), T = (r, S, P, R) => {
+    const l = Math.max(r, P), M = Math.min(r + S, P + R);
+    return l < M ? (l + M) / 2 + d : void 0;
+  }, h = s.x + s.width / 2, y = s.y + s.height / 2;
+  switch (e) {
+    case "NORTH":
+      return {
+        x: f(
+          T(t.x, t.width, s.x, s.width) ?? h + d,
+          t.x,
+          t.width
+        ),
+        y: t.y
+      };
+    case "EAST":
+      return {
+        x: t.x + t.width,
+        y: f(
+          T(t.y, t.height, s.y, s.height) ?? y + d,
+          t.y,
+          t.height
+        )
+      };
+    case "SOUTH":
+      return {
+        x: f(
+          T(t.x, t.width, s.x, s.width) ?? h + d,
+          t.x,
+          t.width
+        ),
+        y: t.y + t.height
+      };
+    case "WEST":
+      return {
+        x: t.x,
+        y: f(
+          T(t.y, t.height, s.y, s.height) ?? y + d,
+          t.y,
+          t.height
+        )
+      };
+  }
+}
+export {
+  F as routeGraphGeometry
+};

package/dist/components/graph/types.d.ts

@@ -52,8 +52,10 @@ export interface GraphLayoutOptions {
     positions?: readonly (GraphPoint & {
         nodeId: string;
     })[];
-    /** Fixed (default) rejects impossible geometry. Preferred retains clear positions and separates colliding siblings, resizing groups around their content before routing. */
-    positionMode?: 'fixed' | 'preferred';
+    /** Root-level ranks. Unassigned roots are placed deterministically near their closest ranked neighbors. */
+    layers?: readonly (readonly string[])[];
+    /** Fixed (default) rejects impossible geometry. Preferred retains positions; compact uses them only as stable ordering hints. */
+    positionMode?: 'fixed' | 'preferred' | 'compact';
     direction?: 'RIGHT' | 'DOWN' | 'LEFT' | 'UP';
     spacing?: number;
     groupPadding?: {

package/dist/licenses/graph-notice.txt

@@ -3,3 +3,14 @@ Copyright (c) 2017 Kiel University and others.
 Licensed under the Eclipse Public License 2.0. A copy is in elkjs.txt.
 Unmodified upstream source is available at https://github.com/kieler/elkjs/tree/0.12.0
 and https://registry.npmjs.org/elkjs/-/elkjs-0.12.0.tgz.
+
+Orthogonal routing uses libavoid-js 0.5.0-beta.5 and its separate unmodified
+libavoid.wasm library. libavoid is Copyright (C) Monash University and others;
+libavoid-js is maintained by Vladyslav Hnatiuk. Licensed under LGPL-2.1-or-later;
+a copy is in libavoid.txt. Corresponding source and build instructions are
+included in libavoid-sources.tar.gz. The unmodified source revisions are:
+https://github.com/Aksem/libavoid-js/tree/5062a42fbd82fff562afeebcbb7b1ed45eed8e75
+https://github.com/Aksem/adaptagrams/tree/0ab3467b4ed3523bb3e404a0dd7da7647d9eb13d
+The separate WASM library can be replaced with an API-compatible build.
+Extract the source archive, enter libavoid-js, and run python3 tools/generate.py
+(requires Docker), npm install, and npm run build to rebuild the library.