@sourcegraph/amp 0.0.1749585689-g82b91d → 0.0.1749600114-g5c00b8

package/dist/create_file.node-Co0Uh1F3.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import p from "node:path";
+import { b as u, d as f, r as l } from "./console-CoE5Qzyz.js";
+const w = ({ args: t }, { dir: n, dirs: a, trackFileChange: c, filesystem: r }) => u(async (e) => {
+  if (f(n), typeof t.content != "string")
+    throw new Error("create_file: content must be specified");
+  e.throwIfAborted();
+  const o = await l(r, a, t.path, e), i = p.dirname(o);
+  await r.mkdirp(i, e);
+  const s = t.content;
+  return await c(o, async (d) => {
+    await r.writeFile(d, s, e);
+  }), {
+    status: "done",
+    result: `Successfully created file ${t.path}`,
+    files: [t.path]
+  };
+});
+export {
+  w as nodeCreateFileTool
+};

package/dist/dagre-CMTPJJKG-UDPzd9Iy.js

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+import { l as F } from "./chunk-IHYUGLNO-DJcRQIf7.js";
+import { G as k } from "./chunk-EOAU2GW5-CpRNAcjo.js";
+import { _ as g, bS as H, bT as V, bU as U, bV as W, A as i, y as Z, bW as $, bX as q, bC as z, bH as K, bD as P, bB as Q, bY as I, bZ as L, b_ as ee } from "./console-CoE5Qzyz.js";
+import { i as N, B as ne, b as A } from "./chunk-TGZYFRKZ-BYBLXoJz.js";
+function h(e) {
+  var t = {
+    options: {
+      directed: e.isDirected(),
+      multigraph: e.isMultigraph(),
+      compound: e.isCompound()
+    },
+    nodes: J(e),
+    edges: T(e)
+  };
+  return N(e.graph()) || (t.value = ne(e.graph())), t;
+}
+g(h, "write");
+function J(e) {
+  return A(e.nodes(), function(t) {
+    var n = e.node(t), a = e.parent(t), r = { v: t };
+    return N(n) || (r.value = n), N(a) || (r.parent = a), r;
+  });
+}
+g(J, "writeNodes");
+function T(e) {
+  return A(e.edges(), function(t) {
+    var n = e.edge(t), a = { v: t.v, w: t.w };
+    return N(t.name) || (a.name = t.name), N(n) || (a.value = n), a;
+  });
+}
+g(T, "writeEdges");
+var d = /* @__PURE__ */ new Map(), X = /* @__PURE__ */ new Map(), G = /* @__PURE__ */ new Map(), te = /* @__PURE__ */ g(() => {
+  X.clear(), G.clear(), d.clear();
+}, "clear"), D = /* @__PURE__ */ g((e, t) => {
+  const n = X.get(t) || [];
+  return i.trace("In isDescendant", t, " ", e, " = ", n.includes(e)), n.includes(e);
+}, "isDescendant"), se = /* @__PURE__ */ g((e, t) => {
+  const n = X.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) || D(e.v, t) || D(e.w, t) || n.includes(e.w) : (i.debug("Tilt, ", t, ",not in descendants"), !1);
+}, "edgeInCluster"), R = /* @__PURE__ */ g((e, t, n, a) => {
+  i.warn(
+    "Copying children of ",
+    e,
+    "root",
+    a,
+    "data",
+    t.node(e),
+    a
+  );
+  const r = t.children(e) || [];
+  e !== a && r.push(e), i.warn("Copying (nodes) clusterId", e, "nodes", r), r.forEach((o) => {
+    if (t.children(o).length > 0)
+      R(o, t, n, a);
+    else {
+      const l = t.node(o);
+      i.info("cp ", o, " to ", a, " with parent ", e), n.setNode(o, l), a !== t.parent(o) && (i.warn("Setting parent", o, t.parent(o)), n.setParent(o, t.parent(o))), e !== a && o !== e ? (i.debug("Setting parent", o, e), n.setParent(o, e)) : (i.info("In copy ", e, "root", a, "data", t.node(e), a), i.debug(
+        "Not Setting parent for node=",
+        o,
+        "cluster!==rootId",
+        e !== a,
+        "node!==clusterId",
+        o !== e
+      ));
+      const u = t.edges(o);
+      i.debug("Copying Edges", u), u.forEach((c) => {
+        i.info("Edge", c);
+        const m = t.edge(c.v, c.w, c.name);
+        i.info("Edge data", m, a);
+        try {
+          se(c, a) ? (i.info("Copying as ", c.v, c.w, m, c.name), n.setEdge(c.v, c.w, m, c.name), i.info("newGraph edges ", n.edges(), n.edge(n.edges()[0]))) : i.info(
+            "Skipping copy of edge ",
+            c.v,
+            "-->",
+            c.w,
+            " rootId: ",
+            a,
+            " clusterId:",
+            e
+          );
+        } catch (v) {
+          i.error(v);
+        }
+      });
+    }
+    i.debug("Removing node", o), t.removeNode(o);
+  });
+}, "copy"), _ = /* @__PURE__ */ g((e, t) => {
+  const n = t.children(e);
+  let a = [...n];
+  for (const r of n)
+    G.set(r, e), a = [...a, ..._(r, t)];
+  return a;
+}, "extractDescendants"), ie = /* @__PURE__ */ g((e, t, n) => {
+  const a = e.edges().filter((c) => c.v === t || c.w === t), r = e.edges().filter((c) => c.v === n || c.w === n), o = a.map((c) => ({ v: c.v === t ? n : c.v, w: c.w === t ? t : c.w })), l = r.map((c) => ({ v: c.v, w: c.w }));
+  return o.filter((c) => l.some((m) => c.v === m.v && c.w === m.w));
+}, "findCommonEdges"), C = /* @__PURE__ */ g((e, t, n) => {
+  const a = t.children(e);
+  if (i.trace("Searching children of id ", e, a), a.length < 1)
+    return e;
+  let r;
+  for (const o of a) {
+    const l = C(o, t, n), u = ie(t, n, l);
+    if (l)
+      if (u.length > 0)
+        r = l;
+      else
+        return l;
+  }
+  return r;
+}, "findNonClusterChild"), B = /* @__PURE__ */ g((e) => !d.has(e) || !d.get(e).externalConnections ? e : d.has(e) ? d.get(e).id : e, "getAnchorId"), re = /* @__PURE__ */ g((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: ",
+      C(n, e, n)
+    ), X.set(n, _(n, e)), d.set(n, { id: C(n, e, n), clusterData: e.node(n) }));
+  }), e.nodes().forEach(function(n) {
+    const a = e.children(n), r = e.edges();
+    a.length > 0 ? (i.debug("Cluster identified", n, X), r.forEach((o) => {
+      const l = D(o.v, n), u = D(o.w, n);
+      l ^ u && (i.warn("Edge: ", o, " leaves cluster ", n), i.warn("Descendants of XXX ", n, ": ", X.get(n)), d.get(n).externalConnections = !0);
+    })) : i.debug("Not a cluster ", n, X);
+  });
+  for (let n of d.keys()) {
+    const a = d.get(n).id, r = e.parent(a);
+    r !== n && d.has(r) && !d.get(r).externalConnections && (d.get(n).id = r);
+  }
+  e.edges().forEach(function(n) {
+    const a = 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 r = n.v, o = n.w;
+    if (i.warn(
+      "Fix XXX",
+      d,
+      "ids:",
+      n.v,
+      n.w,
+      "Translating: ",
+      d.get(n.v),
+      " --- ",
+      d.get(n.w)
+    ), d.get(n.v) || d.get(n.w)) {
+      if (i.warn("Fixing and trying - removing XXX", n.v, n.w, n.name), r = B(n.v), o = B(n.w), e.removeEdge(n.v, n.w, n.name), r !== n.v) {
+        const l = e.parent(r);
+        d.get(l).externalConnections = !0, a.fromCluster = n.v;
+      }
+      if (o !== n.w) {
+        const l = e.parent(o);
+        d.get(l).externalConnections = !0, a.toCluster = n.w;
+      }
+      i.warn("Fix Replacing with XXX", r, o, n.name), e.setEdge(r, o, a, n.name);
+    }
+  }), i.warn("Adjusted Graph", h(e)), M(e, 0), i.trace(d);
+}, "adjustClustersAndEdges"), M = /* @__PURE__ */ g((e, t) => {
+  if (i.warn("extractor - ", t, h(e), e.children("D")), t > 10) {
+    i.error("Bailing out");
+    return;
+  }
+  let n = e.nodes(), a = !1;
+  for (const r of n) {
+    const o = e.children(r);
+    a = a || o.length > 0;
+  }
+  if (!a) {
+    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,
+      d,
+      d.has(r) && !d.get(r).externalConnections,
+      !e.parent(r),
+      e.node(r),
+      e.children("D"),
+      " Depth ",
+      t
+    ), !d.has(r))
+      i.debug("Not a cluster", r, t);
+    else if (!d.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";
+      d.get(r)?.clusterData?.dir && (l = d.get(r).clusterData.dir, i.warn("Fixing dir", d.get(r).clusterData.dir, l));
+      const u = new k({
+        multigraph: !0,
+        compound: !0
+      }).setGraph({
+        rankdir: l,
+        nodesep: 50,
+        ranksep: 50,
+        marginx: 8,
+        marginy: 8
+      }).setDefaultEdgeLabel(function() {
+        return {};
+      });
+      i.warn("Old graph before copy", h(e)), R(r, e, u, r), e.setNode(r, {
+        clusterNode: !0,
+        id: r,
+        clusterData: d.get(r).clusterData,
+        label: d.get(r).label,
+        graph: u
+      }), i.warn("New graph after copy node: (", r, ")", h(u)), i.debug("Old graph after copy", h(e));
+    } else
+      i.warn(
+        "Cluster ** ",
+        r,
+        " **not meeting the criteria !externalConnections:",
+        !d.get(r).externalConnections,
+        " no parent: ",
+        !e.parent(r),
+        " children ",
+        e.children(r) && e.children(r).length > 0,
+        e.children("D"),
+        t
+      ), i.debug(d);
+  n = e.nodes(), i.warn("New list of nodes", n);
+  for (const r of n) {
+    const o = e.node(r);
+    i.warn(" Now next level", r, o), o?.clusterNode && M(o.graph, t + 1);
+  }
+}, "extractor"), Y = /* @__PURE__ */ g((e, t) => {
+  if (t.length === 0)
+    return [];
+  let n = Object.assign([], t);
+  return t.forEach((a) => {
+    const r = e.children(a), o = Y(e, r);
+    n = [...n, ...o];
+  }), n;
+}, "sorter"), oe = /* @__PURE__ */ g((e) => Y(e, e.children()), "sortNodesByHierarchy"), j = /* @__PURE__ */ g(async (e, t, n, a, r, o) => {
+  i.warn("Graph in recursive render:XAX", h(t), r);
+  const l = t.graph().rankdir;
+  i.trace("Dir in recursive render - dir:", l);
+  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 c = u.insert("g").attr("class", "clusters"), m = u.insert("g").attr("class", "edgePaths"), v = u.insert("g").attr("class", "edgeLabels"), b = u.insert("g").attr("class", "nodes");
+  await Promise.all(
+    t.nodes().map(async function(f) {
+      const s = t.node(f);
+      if (r !== void 0) {
+        const w = JSON.parse(JSON.stringify(r.clusterData));
+        i.trace(
+          `Setting data for parent cluster XXX
+ Node.id = `,
+          f,
+          `
+ data=`,
+          w.height,
+          `
+Parent cluster`,
+          r.height
+        ), t.setNode(r.id, w), t.parent(f) || (i.trace("Setting parent", f, r.id), t.setParent(f, r.id, w));
+      }
+      if (i.info("(Insert) Node XXX" + f + ": " + JSON.stringify(t.node(f))), s?.clusterNode) {
+        i.info("Cluster identified XBX", f, s.width, t.node(f));
+        const { ranksep: w, nodesep: E } = t.graph();
+        s.graph.setGraph({
+          ...s.graph.graph(),
+          ranksep: w + 25,
+          nodesep: E
+        });
+        const p = await j(
+          b,
+          s.graph,
+          n,
+          a,
+          t.node(f),
+          o
+        ), x = p.elem;
+        $(s, x), s.diff = p.diff || 0, i.info(
+          "New compound node after recursive render XAX",
+          f,
+          "width",
+          // node,
+          s.width,
+          "height",
+          s.height
+          // node.x,
+          // node.y
+        ), q(x, s);
+      } else
+        t.children(f).length > 0 ? (i.trace(
+          "Cluster - the non recursive path XBX",
+          f,
+          s.id,
+          s,
+          s.width,
+          "Graph:",
+          t
+        ), i.trace(C(s.id, t)), d.set(s.id, { id: C(s.id, t), node: s })) : (i.trace("Node - the non recursive path XAX", f, b, t.node(f), l), await z(b, t.node(f), { config: o, dir: l }));
+    })
+  ), await (/* @__PURE__ */ g(async () => {
+    const f = t.edges().map(async function(s) {
+      const w = 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",
+        d,
+        "ids:",
+        s.v,
+        s.w,
+        "Translating: ",
+        d.get(s.v),
+        d.get(s.w)
+      ), await ee(v, w);
+    });
+    await Promise.all(f);
+  }, "processEdges"))(), i.info("Graph before layout:", JSON.stringify(h(t))), i.info("############################################# XXX"), i.info("###                Layout                 ### XXX"), i.info("############################################# XXX"), F(t), i.info("Graph after layout:", JSON.stringify(h(t)));
+  let O = 0, { subGraphTitleTotalMargin: S } = K(o);
+  return await Promise.all(
+    oe(t).map(async function(f) {
+      const s = t.node(f);
+      if (i.info(
+        "Position XBX => " + f + ": (" + s.x,
+        "," + s.y,
+        ") width: ",
+        s.width,
+        " height: ",
+        s.height
+      ), s?.clusterNode)
+        s.y += S, i.info(
+          "A tainted cluster node XBX1",
+          f,
+          s.id,
+          s.width,
+          s.height,
+          s.x,
+          s.y,
+          t.parent(f)
+        ), d.get(s.id).node = s, P(s);
+      else if (t.children(f).length > 0) {
+        i.info(
+          "A pure cluster node XBX1",
+          f,
+          s.id,
+          s.x,
+          s.y,
+          s.width,
+          s.height,
+          t.parent(f)
+        ), s.height += S, t.node(s.parentId);
+        const w = s?.padding / 2 || 0, E = s?.labelBBox?.height || 0, p = E - w || 0;
+        i.debug("OffsetY", p, "labelHeight", E, "halfPadding", w), await Q(c, s), d.get(s.id).node = s;
+      } else {
+        const w = t.node(s.parentId);
+        s.y += S / 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",
+          w,
+          w?.offsetY,
+          s
+        ), P(s);
+      }
+    })
+  ), t.edges().forEach(function(f) {
+    const s = t.edge(f);
+    i.info("Edge " + f.v + " -> " + f.w + ": " + JSON.stringify(s), s), s.points.forEach((x) => x.y += S / 2);
+    const w = t.node(f.v);
+    var E = t.node(f.w);
+    const p = I(m, s, d, n, w, E, a);
+    L(s, p);
+  }), t.nodes().forEach(function(f) {
+    const s = t.node(f);
+    i.info(f, s.type, s.diff), s.isGroup && (O = s.diff);
+  }), i.warn("Returning from recursive render XAX", u, O), { elem: u, diff: O };
+}, "recursiveRender"), fe = /* @__PURE__ */ g(async (e, t) => {
+  const n = new k({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: e.direction,
+    nodesep: e.config?.nodeSpacing || e.config?.flowchart?.nodeSpacing || e.nodeSpacing,
+    ranksep: e.config?.rankSpacing || e.config?.flowchart?.rankSpacing || e.rankSpacing,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  }), a = t.select("g");
+  H(a, e.markers, e.type, e.diagramId), V(), U(), W(), te(), e.nodes.forEach((o) => {
+    n.setNode(o.id, { ...o }), o.parentId && n.setParent(o.id, o.parentId);
+  }), i.debug("Edges:", e.edges), e.edges.forEach((o) => {
+    if (o.start === o.end) {
+      const l = o.start, u = l + "---" + l + "---1", c = l + "---" + l + "---2", m = n.node(l);
+      n.setNode(u, {
+        domId: u,
+        id: u,
+        parentId: m.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      }), n.setParent(u, m.parentId), n.setNode(c, {
+        domId: c,
+        id: c,
+        parentId: m.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      }), n.setParent(c, m.parentId);
+      const v = structuredClone(o), b = structuredClone(o), y = structuredClone(o);
+      v.label = "", v.arrowTypeEnd = "none", v.id = l + "-cyclic-special-1", b.arrowTypeStart = "none", b.arrowTypeEnd = "none", b.id = l + "-cyclic-special-mid", y.label = "", m.isGroup && (v.fromCluster = l, y.toCluster = l), y.id = l + "-cyclic-special-2", y.arrowTypeStart = "none", n.setEdge(l, u, v, l + "-cyclic-special-0"), n.setEdge(u, c, b, l + "-cyclic-special-1"), n.setEdge(c, l, y, l + "-cyc<lic-special-2");
+    } else
+      n.setEdge(o.start, o.end, { ...o }, o.id);
+  }), i.warn("Graph at first:", JSON.stringify(h(n))), re(n), i.warn("Graph after XAX:", JSON.stringify(h(n)));
+  const r = Z();
+  await j(
+    a,
+    n,
+    e.type,
+    e.diagramId,
+    void 0,
+    r
+  );
+}, "render");
+export {
+  fe as render
+};

package/dist/diagram-BIPOGRU5-B7TV59-n.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import { p as y } from "./chunk-K2ZEYYM2-CbqHhUqy.js";
+import { p as B } from "./radar-MK3ICKWK-55CS4JTO-afihMdR4.js";
+import { _ as n, u as S, v as F, U as z, T as P, w as T, x as W, a4 as x, av as A, C as D, Z as _, a5 as E, a6 as N, A as m } from "./console-CoE5Qzyz.js";
+import "./chunk-TGZYFRKZ-BYBLXoJz.js";
+var C = {
+  packet: []
+}, v = structuredClone(C), L = N.packet, Y = /* @__PURE__ */ n(() => {
+  const t = x({
+    ...L,
+    ...E().packet
+  });
+  return t.showBits && (t.paddingY += 10), t;
+}, "getConfig"), I = /* @__PURE__ */ n(() => v.packet, "getPacket"), M = /* @__PURE__ */ n((t) => {
+  t.length > 0 && v.packet.push(t);
+}, "pushWord"), O = /* @__PURE__ */ n(() => {
+  _(), v = structuredClone(C);
+}, "clear"), h = {
+  pushWord: M,
+  getPacket: I,
+  getConfig: Y,
+  clear: O,
+  setAccTitle: W,
+  getAccTitle: T,
+  setDiagramTitle: P,
+  getDiagramTitle: z,
+  getAccDescription: F,
+  setAccDescription: S
+}, U = 1e4, G = /* @__PURE__ */ n((t) => {
+  y(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 < U; ) {
+      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 B("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 = A(e);
+  f.attr("viewbox", `0 0 ${k} ${d}`), D(f, d, k, a.useMaxWidth);
+  for (const [$, w] of u.entries())
+    X(f, w, $, 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"), X = /* @__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"), Z = { draw: R }, j = {
+  byteFontSize: "10px",
+  startByteColor: "black",
+  endByteColor: "black",
+  labelColor: "black",
+  labelFontSize: "12px",
+  titleColor: "black",
+  titleFontSize: "14px",
+  blockStrokeColor: "black",
+  blockStrokeWidth: "1",
+  blockFillColor: "#efefef"
+}, q = /* @__PURE__ */ n(({ packet: t } = {}) => {
+  const e = x(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"), et = {
+  parser: K,
+  db: h,
+  renderer: Z,
+  styles: q
+};
+export {
+  et as diagram
+};