@elmethis/core 1.0.0-alpha.134 → 1.0.0-alpha.136

package/dist/dagre-4EVJKHTY-C7YsHY3S.js

@@ -0,0 +1,447 @@
+import { _ as X, av as F, aw as Y, ax as _, ay as H, l as i, d as V, az as z, aA as U, ah as $, am as q, ai as P, ag as K, aB as Q, aC as W, aD as Z } from "./mermaid.core-gtllNrzr.js";
+import { G as B } from "./graph-CKV5wesZ.js";
+import { l as I } from "./layout-Cycesmdu.js";
+import { i as S } from "./_baseUniq-DBXEmOed.js";
+import { c as L } from "./clone-DMQ2a__4.js";
+import { m as A } from "./_basePickBy-BjVOtBbf.js";
+function p(e) {
+  var t = {
+    options: {
+      directed: e.isDirected(),
+      multigraph: e.isMultigraph(),
+      compound: e.isCompound()
+    },
+    nodes: ee(e),
+    edges: ne(e)
+  };
+  return S(e.graph()) || (t.value = L(e.graph())), t;
+}
+function ee(e) {
+  return A(e.nodes(), function(t) {
+    var n = e.node(t), o = e.parent(t), c = { v: t };
+    return S(n) || (c.value = n), S(o) || (c.parent = o), c;
+  });
+}
+function ne(e) {
+  return A(e.edges(), function(t) {
+    var n = e.edge(t), o = { v: t.v, w: t.w };
+    return S(t.name) || (o.name = t.name), S(n) || (o.value = n), o;
+  });
+}
+var f = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), J = /* @__PURE__ */ new Map(), te = /* @__PURE__ */ X(() => {
+  b.clear(), J.clear(), f.clear();
+}, "clear"), O = /* @__PURE__ */ X((e, t) => {
+  const n = b.get(t) || [];
+  return i.trace("In isDescendant", t, " ", e, " = ", n.includes(e)), n.includes(e);
+}, "isDescendant"), se = /* @__PURE__ */ X((e, t) => {
+  const n = b.get(t) || [];
+  return i.info("Descendants of ", t, " is ", n), i.info("Edge is ", e), e.v === t || e.w === t ? !1 : n ? n.includes(e.v) || O(e.v, t) || O(e.w, t) || n.includes(e.w) : (i.debug("Tilt, ", t, ",not in descendants"), !1);
+}, "edgeInCluster"), G = /* @__PURE__ */ X((e, t, n, o) => {
+  i.warn(
+    "Copying children of ",
+    e,
+    "root",
+    o,
+    "data",
+    t.node(e),
+    o
+  );
+  const c = t.children(e) || [];
+  e !== o && c.push(e), i.warn("Copying (nodes) clusterId", e, "nodes", c), c.forEach((a) => {
+    if (t.children(a).length > 0)
+      G(a, t, n, o);
+    else {
+      const r = t.node(a);
+      i.info("cp ", a, " to ", o, " with parent ", e), n.setNode(a, r), o !== t.parent(a) && (i.warn("Setting parent", a, t.parent(a)), n.setParent(a, t.parent(a))), e !== o && a !== e ? (i.debug("Setting parent", a, e), n.setParent(a, e)) : (i.info("In copy ", e, "root", o, "data", t.node(e), o), i.debug(
+        "Not Setting parent for node=",
+        a,
+        "cluster!==rootId",
+        e !== o,
+        "node!==clusterId",
+        a !== e
+      ));
+      const u = t.edges(a);
+      i.debug("Copying Edges", u), u.forEach((l) => {
+        i.info("Edge", l);
+        const v = t.edge(l.v, l.w, l.name);
+        i.info("Edge data", v, o);
+        try {
+          se(l, o) ? (i.info("Copying as ", l.v, l.w, v, l.name), n.setEdge(l.v, l.w, v, l.name), i.info("newGraph edges ", n.edges(), n.edge(n.edges()[0]))) : i.info(
+            "Skipping copy of edge ",
+            l.v,
+            "-->",
+            l.w,
+            " rootId: ",
+            o,
+            " clusterId:",
+            e
+          );
+        } catch (C) {
+          i.error(C);
+        }
+      });
+    }
+    i.debug("Removing node", a), t.removeNode(a);
+  });
+}, "copy"), R = /* @__PURE__ */ X((e, t) => {
+  const n = t.children(e);
+  let o = [...n];
+  for (const c of n)
+    J.set(c, e), o = [...o, ...R(c, t)];
+  return o;
+}, "extractDescendants"), ie = /* @__PURE__ */ X((e, t, n) => {
+  const o = e.edges().filter((l) => l.v === t || l.w === t), c = e.edges().filter((l) => l.v === n || l.w === n), a = o.map((l) => ({ v: l.v === t ? n : l.v, w: l.w === t ? t : l.w })), r = c.map((l) => ({ v: l.v, w: l.w }));
+  return a.filter((l) => r.some((v) => l.v === v.v && l.w === v.w));
+}, "findCommonEdges"), D = /* @__PURE__ */ X((e, t, n) => {
+  const o = t.children(e);
+  if (i.trace("Searching children of id ", e, o), o.length < 1)
+    return e;
+  let c;
+  for (const a of o) {
+    const r = D(a, t, n), u = ie(t, n, r);
+    if (r)
+      if (u.length > 0)
+        c = r;
+      else
+        return r;
+  }
+  return c;
+}, "findNonClusterChild"), k = /* @__PURE__ */ X((e) => !f.has(e) || !f.get(e).externalConnections ? e : f.has(e) ? f.get(e).id : e, "getAnchorId"), re = /* @__PURE__ */ X((e, t) => {
+  if (!e || t > 10) {
+    i.debug("Opting out, no graph ");
+    return;
+  } else
+    i.debug("Opting in, graph ");
+  e.nodes().forEach(function(n) {
+    e.children(n).length > 0 && (i.warn(
+      "Cluster identified",
+      n,
+      " Replacement id in edges: ",
+      D(n, e, n)
+    ), b.set(n, R(n, e)), f.set(n, { id: D(n, e, n), clusterData: e.node(n) }));
+  }), e.nodes().forEach(function(n) {
+    const o = e.children(n), c = e.edges();
+    o.length > 0 ? (i.debug("Cluster identified", n, b), c.forEach((a) => {
+      const r = O(a.v, n), u = O(a.w, n);
+      r ^ u && (i.warn("Edge: ", a, " leaves cluster ", n), i.warn("Descendants of XXX ", n, ": ", b.get(n)), f.get(n).externalConnections = !0);
+    })) : i.debug("Not a cluster ", n, b);
+  });
+  for (let n of f.keys()) {
+    const o = f.get(n).id, c = e.parent(o);
+    c !== n && f.has(c) && !f.get(c).externalConnections && (f.get(n).id = c);
+  }
+  e.edges().forEach(function(n) {
+    const o = e.edge(n);
+    i.warn("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(n)), i.warn("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(e.edge(n)));
+    let c = n.v, a = n.w;
+    if (i.warn(
+      "Fix XXX",
+      f,
+      "ids:",
+      n.v,
+      n.w,
+      "Translating: ",
+      f.get(n.v),
+      " --- ",
+      f.get(n.w)
+    ), f.get(n.v) || f.get(n.w)) {
+      if (i.warn("Fixing and trying - removing XXX", n.v, n.w, n.name), c = k(n.v), a = k(n.w), e.removeEdge(n.v, n.w, n.name), c !== n.v) {
+        const r = e.parent(c);
+        f.get(r).externalConnections = !0, o.fromCluster = n.v;
+      }
+      if (a !== n.w) {
+        const r = e.parent(a);
+        f.get(r).externalConnections = !0, o.toCluster = n.w;
+      }
+      i.warn("Fix Replacing with XXX", c, a, n.name), e.setEdge(c, a, o, n.name);
+    }
+  }), i.warn("Adjusted Graph", p(e)), T(e, 0), i.trace(f);
+}, "adjustClustersAndEdges"), T = /* @__PURE__ */ X((e, t) => {
+  var c, a;
+  if (i.warn("extractor - ", t, p(e), e.children("D")), t > 10) {
+    i.error("Bailing out");
+    return;
+  }
+  let n = e.nodes(), o = !1;
+  for (const r of n) {
+    const u = e.children(r);
+    o = o || u.length > 0;
+  }
+  if (!o) {
+    i.debug("Done, no node has children", e.nodes());
+    return;
+  }
+  i.debug("Nodes = ", n, t);
+  for (const r of n)
+    if (i.debug(
+      "Extracting node",
+      r,
+      f,
+      f.has(r) && !f.get(r).externalConnections,
+      !e.parent(r),
+      e.node(r),
+      e.children("D"),
+      " Depth ",
+      t
+    ), !f.has(r))
+      i.debug("Not a cluster", r, t);
+    else if (!f.get(r).externalConnections && e.children(r) && e.children(r).length > 0) {
+      i.warn(
+        "Cluster without external connections, without a parent and with children",
+        r,
+        t
+      );
+      let l = e.graph().rankdir === "TB" ? "LR" : "TB";
+      (a = (c = f.get(r)) == null ? void 0 : c.clusterData) != null && a.dir && (l = f.get(r).clusterData.dir, i.warn("Fixing dir", f.get(r).clusterData.dir, l));
+      const v = new B({
+        multigraph: !0,
+        compound: !0
+      }).setGraph({
+        rankdir: l,
+        nodesep: 50,
+        ranksep: 50,
+        marginx: 8,
+        marginy: 8
+      }).setDefaultEdgeLabel(function() {
+        return {};
+      });
+      i.warn("Old graph before copy", p(e)), G(r, e, v, r), e.setNode(r, {
+        clusterNode: !0,
+        id: r,
+        clusterData: f.get(r).clusterData,
+        label: f.get(r).label,
+        graph: v
+      }), i.warn("New graph after copy node: (", r, ")", p(v)), i.debug("Old graph after copy", p(e));
+    } else
+      i.warn(
+        "Cluster ** ",
+        r,
+        " **not meeting the criteria !externalConnections:",
+        !f.get(r).externalConnections,
+        " no parent: ",
+        !e.parent(r),
+        " children ",
+        e.children(r) && e.children(r).length > 0,
+        e.children("D"),
+        t
+      ), i.debug(f);
+  n = e.nodes(), i.warn("New list of nodes", n);
+  for (const r of n) {
+    const u = e.node(r);
+    i.warn(" Now next level", r, u), u != null && u.clusterNode && T(u.graph, t + 1);
+  }
+}, "extractor"), M = /* @__PURE__ */ X((e, t) => {
+  if (t.length === 0)
+    return [];
+  let n = Object.assign([], t);
+  return t.forEach((o) => {
+    const c = e.children(o), a = M(e, c);
+    n = [...n, ...a];
+  }), n;
+}, "sorter"), oe = /* @__PURE__ */ X((e) => M(e, e.children()), "sortNodesByHierarchy"), j = /* @__PURE__ */ X(async (e, t, n, o, c, a) => {
+  i.warn("Graph in recursive render:XAX", p(t), c);
+  const r = t.graph().rankdir;
+  i.trace("Dir in recursive render - dir:", r);
+  const u = e.insert("g").attr("class", "root");
+  t.nodes() ? i.info("Recursive render XXX", t.nodes()) : i.info("No nodes found for", t), t.edges().length > 0 && i.info("Recursive edges", t.edge(t.edges()[0]));
+  const l = u.insert("g").attr("class", "clusters"), v = u.insert("g").attr("class", "edgePaths"), C = u.insert("g").attr("class", "edgeLabels"), g = u.insert("g").attr("class", "nodes");
+  await Promise.all(
+    t.nodes().map(async function(d) {
+      const s = t.node(d);
+      if (c !== void 0) {
+        const m = JSON.parse(JSON.stringify(c.clusterData));
+        i.trace(
+          `Setting data for parent cluster XXX
+ Node.id = `,
+          d,
+          `
+ data=`,
+          m.height,
+          `
+Parent cluster`,
+          c.height
+        ), t.setNode(c.id, m), t.parent(d) || (i.trace("Setting parent", d, c.id), t.setParent(d, c.id, m));
+      }
+      if (i.info("(Insert) Node XXX" + d + ": " + JSON.stringify(t.node(d))), s != null && s.clusterNode) {
+        i.info("Cluster identified XBX", d, s.width, t.node(d));
+        const { ranksep: m, nodesep: h } = t.graph();
+        s.graph.setGraph({
+          ...s.graph.graph(),
+          ranksep: m + 25,
+          nodesep: h
+        });
+        const N = await j(
+          g,
+          s.graph,
+          n,
+          o,
+          t.node(d),
+          a
+        ), x = N.elem;
+        z(s, x), s.diff = N.diff || 0, i.info(
+          "New compound node after recursive render XAX",
+          d,
+          "width",
+          // node,
+          s.width,
+          "height",
+          s.height
+          // node.x,
+          // node.y
+        ), U(x, s);
+      } else
+        t.children(d).length > 0 ? (i.trace(
+          "Cluster - the non recursive path XBX",
+          d,
+          s.id,
+          s,
+          s.width,
+          "Graph:",
+          t
+        ), i.trace(D(s.id, t)), f.set(s.id, { id: D(s.id, t), node: s })) : (i.trace("Node - the non recursive path XAX", d, g, t.node(d), r), await $(g, t.node(d), { config: a, dir: r }));
+    })
+  ), await (/* @__PURE__ */ X(async () => {
+    const d = t.edges().map(async function(s) {
+      const m = t.edge(s.v, s.w, s.name);
+      i.info("Edge " + s.v + " -> " + s.w + ": " + JSON.stringify(s)), i.info("Edge " + s.v + " -> " + s.w + ": ", s, " ", JSON.stringify(t.edge(s))), i.info(
+        "Fix",
+        f,
+        "ids:",
+        s.v,
+        s.w,
+        "Translating: ",
+        f.get(s.v),
+        f.get(s.w)
+      ), await Z(C, m);
+    });
+    await Promise.all(d);
+  }, "processEdges"))(), i.info("Graph before layout:", JSON.stringify(p(t))), i.info("############################################# XXX"), i.info("###                Layout                 ### XXX"), i.info("############################################# XXX"), I(t), i.info("Graph after layout:", JSON.stringify(p(t)));
+  let E = 0, { subGraphTitleTotalMargin: y } = q(a);
+  return await Promise.all(
+    oe(t).map(async function(d) {
+      var m;
+      const s = t.node(d);
+      if (i.info(
+        "Position XBX => " + d + ": (" + s.x,
+        "," + s.y,
+        ") width: ",
+        s.width,
+        " height: ",
+        s.height
+      ), s != null && s.clusterNode)
+        s.y += y, i.info(
+          "A tainted cluster node XBX1",
+          d,
+          s.id,
+          s.width,
+          s.height,
+          s.x,
+          s.y,
+          t.parent(d)
+        ), f.get(s.id).node = s, P(s);
+      else if (t.children(d).length > 0) {
+        i.info(
+          "A pure cluster node XBX1",
+          d,
+          s.id,
+          s.x,
+          s.y,
+          s.width,
+          s.height,
+          t.parent(d)
+        ), s.height += y, t.node(s.parentId);
+        const h = (s == null ? void 0 : s.padding) / 2 || 0, N = ((m = s == null ? void 0 : s.labelBBox) == null ? void 0 : m.height) || 0, x = N - h || 0;
+        i.debug("OffsetY", x, "labelHeight", N, "halfPadding", h), await K(l, s), f.get(s.id).node = s;
+      } else {
+        const h = t.node(s.parentId);
+        s.y += y / 2, i.info(
+          "A regular node XBX1 - using the padding",
+          s.id,
+          "parent",
+          s.parentId,
+          s.width,
+          s.height,
+          s.x,
+          s.y,
+          "offsetY",
+          s.offsetY,
+          "parent",
+          h,
+          h == null ? void 0 : h.offsetY,
+          s
+        ), P(s);
+      }
+    })
+  ), t.edges().forEach(function(d) {
+    const s = t.edge(d);
+    i.info("Edge " + d.v + " -> " + d.w + ": " + JSON.stringify(s), s), s.points.forEach((x) => x.y += y / 2);
+    const m = t.node(d.v);
+    var h = t.node(d.w);
+    const N = Q(v, s, f, n, m, h, o);
+    W(s, N);
+  }), t.nodes().forEach(function(d) {
+    const s = t.node(d);
+    i.info(d, s.type, s.diff), s.isGroup && (E = s.diff);
+  }), i.warn("Returning from recursive render XAX", u, E), { elem: u, diff: E };
+}, "recursiveRender"), ge = /* @__PURE__ */ X(async (e, t) => {
+  var a, r, u, l, v, C;
+  const n = new B({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: e.direction,
+    nodesep: ((a = e.config) == null ? void 0 : a.nodeSpacing) || ((u = (r = e.config) == null ? void 0 : r.flowchart) == null ? void 0 : u.nodeSpacing) || e.nodeSpacing,
+    ranksep: ((l = e.config) == null ? void 0 : l.rankSpacing) || ((C = (v = e.config) == null ? void 0 : v.flowchart) == null ? void 0 : C.rankSpacing) || e.rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  }), o = t.select("g");
+  F(o, e.markers, e.type, e.diagramId), Y(), _(), H(), te(), e.nodes.forEach((g) => {
+    n.setNode(g.id, { ...g }), g.parentId && n.setParent(g.id, g.parentId);
+  }), i.debug("Edges:", e.edges), e.edges.forEach((g) => {
+    if (g.start === g.end) {
+      const w = g.start, E = w + "---" + w + "---1", y = w + "---" + w + "---2", d = n.node(w);
+      n.setNode(E, {
+        domId: E,
+        id: E,
+        parentId: d.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      }), n.setParent(E, d.parentId), n.setNode(y, {
+        domId: y,
+        id: y,
+        parentId: d.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      }), n.setParent(y, d.parentId);
+      const s = structuredClone(g), m = structuredClone(g), h = structuredClone(g);
+      s.label = "", s.arrowTypeEnd = "none", s.id = w + "-cyclic-special-1", m.arrowTypeEnd = "none", m.id = w + "-cyclic-special-mid", h.label = "", d.isGroup && (s.fromCluster = w, h.toCluster = w), h.id = w + "-cyclic-special-2", n.setEdge(w, E, s, w + "-cyclic-special-0"), n.setEdge(E, y, m, w + "-cyclic-special-1"), n.setEdge(y, w, h, w + "-cyc<lic-special-2");
+    } else
+      n.setEdge(g.start, g.end, { ...g }, g.id);
+  }), i.warn("Graph at first:", JSON.stringify(p(n))), re(n), i.warn("Graph after XAX:", JSON.stringify(p(n)));
+  const c = V();
+  await j(
+    o,
+    n,
+    e.type,
+    e.diagramId,
+    void 0,
+    c
+  );
+}, "render");
+export {
+  ge as render
+};

package/dist/diagram-QW4FP2JN-iDbrW_yI.js

@@ -0,0 +1,126 @@
+import { p as w } from "./chunk-TMUBEWPD-LmMMNIqt.js";
+import { D as B, s as S, g as F, q as z, r as P, b as W, c as D, _ as n, l as m, E as v, F as T, x as E, I as _, k as A } from "./mermaid.core-gtllNrzr.js";
+import { p as N } from "./mermaid-parser.core-CL_REaxY.js";
+var C = {
+  packet: []
+}, x = structuredClone(C), I = B.packet, L = /* @__PURE__ */ n(() => {
+  const t = v({
+    ...I,
+    ...T().packet
+  });
+  return t.showBits && (t.paddingY += 10), t;
+}, "getConfig"), Y = /* @__PURE__ */ n(() => x.packet, "getPacket"), M = /* @__PURE__ */ n((t) => {
+  t.length > 0 && x.packet.push(t);
+}, "pushWord"), O = /* @__PURE__ */ n(() => {
+  E(), x = structuredClone(C);
+}, "clear"), h = {
+  pushWord: M,
+  getPacket: Y,
+  getConfig: L,
+  clear: O,
+  setAccTitle: S,
+  getAccTitle: F,
+  setDiagramTitle: z,
+  getDiagramTitle: P,
+  getAccDescription: W,
+  setAccDescription: D
+}, q = 1e4, G = /* @__PURE__ */ n((t) => {
+  w(t, h);
+  let e = -1, o = [], s = 1;
+  const { bitsPerRow: i } = h.getConfig();
+  for (let { start: a, end: r, label: p } of t.blocks) {
+    if (r && r < a)
+      throw new Error(`Packet block ${a} - ${r} is invalid. End must be greater than start.`);
+    if (a !== e + 1)
+      throw new Error(
+        `Packet block ${a} - ${r ?? a} is not contiguous. It should start from ${e + 1}.`
+      );
+    for (e = r ?? a, m.debug(`Packet block ${a} - ${e} with label ${p}`); o.length <= i + 1 && h.getPacket().length < q; ) {
+      const [b, c] = H({ start: a, end: r, label: p }, s, i);
+      if (o.push(b), b.end + 1 === s * i && (h.pushWord(o), o = [], s++), !c)
+        break;
+      ({ start: a, end: r, label: p } = c);
+    }
+  }
+  h.pushWord(o);
+}, "populate"), H = /* @__PURE__ */ n((t, e, o) => {
+  if (t.end === void 0 && (t.end = t.start), t.start > t.end)
+    throw new Error(`Block start ${t.start} is greater than block end ${t.end}.`);
+  return t.end + 1 <= e * o ? [t, void 0] : [
+    {
+      start: t.start,
+      end: e * o - 1,
+      label: t.label
+    },
+    {
+      start: e * o,
+      end: t.end,
+      label: t.label
+    }
+  ];
+}, "getNextFittingBlock"), K = {
+  parse: /* @__PURE__ */ n(async (t) => {
+    const e = await N("packet", t);
+    m.debug(e), G(e);
+  }, "parse")
+}, R = /* @__PURE__ */ n((t, e, o, s) => {
+  const i = s.db, a = i.getConfig(), { rowHeight: r, paddingY: p, bitWidth: b, bitsPerRow: c } = a, u = i.getPacket(), l = i.getDiagramTitle(), g = r + p, d = g * (u.length + 1) - (l ? 0 : r), k = b * c + 2, f = _(e);
+  f.attr("viewbox", `0 0 ${k} ${d}`), A(f, d, k, a.useMaxWidth);
+  for (const [$, y] of u.entries())
+    U(f, y, $, a);
+  f.append("text").text(l).attr("x", k / 2).attr("y", d - g / 2).attr("dominant-baseline", "middle").attr("text-anchor", "middle").attr("class", "packetTitle");
+}, "draw"), U = /* @__PURE__ */ n((t, e, o, { rowHeight: s, paddingX: i, paddingY: a, bitWidth: r, bitsPerRow: p, showBits: b }) => {
+  const c = t.append("g"), u = o * (s + a) + a;
+  for (const l of e) {
+    const g = l.start % p * r + 1, d = (l.end - l.start + 1) * r - i;
+    if (c.append("rect").attr("x", g).attr("y", u).attr("width", d).attr("height", s).attr("class", "packetBlock"), c.append("text").attr("x", g + d / 2).attr("y", u + s / 2).attr("class", "packetLabel").attr("dominant-baseline", "middle").attr("text-anchor", "middle").text(l.label), !b)
+      continue;
+    const k = l.end === l.start, f = u - 2;
+    c.append("text").attr("x", g + (k ? d / 2 : 0)).attr("y", f).attr("class", "packetByte start").attr("dominant-baseline", "auto").attr("text-anchor", k ? "middle" : "start").text(l.start), k || c.append("text").attr("x", g + d).attr("y", f).attr("class", "packetByte end").attr("dominant-baseline", "auto").attr("text-anchor", "end").text(l.end);
+  }
+}, "drawWord"), X = { draw: R }, j = {
+  byteFontSize: "10px",
+  startByteColor: "black",
+  endByteColor: "black",
+  labelColor: "black",
+  labelFontSize: "12px",
+  titleColor: "black",
+  titleFontSize: "14px",
+  blockStrokeColor: "black",
+  blockStrokeWidth: "1",
+  blockFillColor: "#efefef"
+}, J = /* @__PURE__ */ n(({ packet: t } = {}) => {
+  const e = v(j, t);
+  return `
+	.packetByte {
+		font-size: ${e.byteFontSize};
+	}
+	.packetByte.start {
+		fill: ${e.startByteColor};
+	}
+	.packetByte.end {
+		fill: ${e.endByteColor};
+	}
+	.packetLabel {
+		fill: ${e.labelColor};
+		font-size: ${e.labelFontSize};
+	}
+	.packetTitle {
+		fill: ${e.titleColor};
+		font-size: ${e.titleFontSize};
+	}
+	.packetBlock {
+		stroke: ${e.blockStrokeColor};
+		stroke-width: ${e.blockStrokeWidth};
+		fill: ${e.blockFillColor};
+	}
+	`;
+}, "styles"), tt = {
+  parser: K,
+  db: h,
+  renderer: X,
+  styles: J
+};
+export {
+  tt as diagram
+};