@life-exe/wiki-engine 0.1.0

package/dist/chunks/dagre-GXQ25YYZ-Ds09_NdN.js

@@ -0,0 +1,461 @@
+import { _ as m, ar as D, c as A, T as Y, l as p, as as _, at as T, au as b, av as z, aw as H, ax as J, ay as C, az as F, aA as W, aB as R, ak as P, ai as j, aC as q, aD as U } from "./index-f7Uzykhj.js";
+import { l as K } from "./layout-CgV9vOdp.js";
+var v = /* @__PURE__ */ m((t, e, d) => Math.max(e, Math.min(d, t)), "clamp"), B = /* @__PURE__ */ m((t = "TB") => {
+  switch (t) {
+    case "BT":
+      return "bottom";
+    case "LR":
+      return "right";
+    case "RL":
+      return "left";
+    case "TB":
+    default:
+      return "top";
+  }
+}, "getDefaultSelfLoopSide"), Q = /* @__PURE__ */ m((t) => t === "flowchart" || t === "flowchart-v2" || t === "stateDiagram" || t === "er" || t === "classDiagram", "shouldMergeSelfLoopSegments"), V = [
+  "x",
+  "y",
+  "width",
+  "height",
+  "labelBBox",
+  "intersect",
+  "calcIntersect",
+  "diff",
+  "clusterNode"
+], Z = /* @__PURE__ */ m((t, e, d, g, s) => {
+  const h = [], L = /* @__PURE__ */ new Set();
+  if (d.forEach(({ start: l, end: r }) => {
+    l !== g && L.add(l), r !== g && L.add(r);
+  }), L.forEach((l) => {
+    const r = t.node(l);
+    typeof (r == null ? void 0 : r.x) == "number" && typeof (r == null ? void 0 : r.y) == "number" && h.push(r);
+  }), h.length === 0 && d.forEach(({ edge: l }) => {
+    (l.points ?? []).forEach((r) => {
+      typeof (r == null ? void 0 : r.x) == "number" && typeof (r == null ? void 0 : r.y) == "number" && h.push(r);
+    });
+  }), h.length === 0)
+    return B(s);
+  const c = h.reduce(
+    (l, r) => ({
+      x: l.x + r.x / h.length,
+      y: l.y + r.y / h.length
+    }),
+    { x: 0, y: 0 }
+  ), i = c.x - e.x, o = c.y - e.y;
+  return Math.abs(i) > Math.abs(o) ? i > 0 ? "right" : "left" : Math.abs(o) > 0 ? o > 0 ? "bottom" : "top" : B(s);
+}, "getSelfLoopSide"), $ = /* @__PURE__ */ m((t, e = "top", d = 0, g = 0) => {
+  const s = t.x, h = t.y - d, L = t.width / 2, c = t.height / 2, i = Math.max(36, Math.min(100, t.width * 0.8)), o = v(Math.max(g, t.width * 0.35), 36, i), l = v(Math.min(t.width, t.height) * 0.45, 24, 48);
+  switch (e) {
+    case "bottom": {
+      const r = h + c;
+      return [
+        { x: s - o / 2, y: r },
+        { x: s - o / 2, y: r + l },
+        { x: s + o / 2, y: r + l },
+        { x: s + o / 2, y: r }
+      ];
+    }
+    case "right": {
+      const r = s + L;
+      return [
+        { x: r, y: h - o / 2 },
+        { x: r + l, y: h - o / 2 },
+        { x: r + l, y: h + o / 2 },
+        { x: r, y: h + o / 2 }
+      ];
+    }
+    case "left": {
+      const r = s - L;
+      return [
+        { x: r, y: h - o / 2 },
+        { x: r - l, y: h - o / 2 },
+        { x: r - l, y: h + o / 2 },
+        { x: r, y: h + o / 2 }
+      ];
+    }
+    case "top":
+    default: {
+      const r = h - c;
+      return [
+        { x: s - o / 2, y: r },
+        { x: s - o / 2, y: r - l },
+        { x: s + o / 2, y: r - l },
+        { x: s + o / 2, y: r }
+      ];
+    }
+  }
+}, "getSelfLoopPoints"), ee = /* @__PURE__ */ m((t, e, d = "top", g = 0, s = {}) => {
+  const L = t.x, c = t.y - g, i = s.width ?? 0, o = s.height ?? 0;
+  switch (d) {
+    case "bottom":
+      return { x: L, y: Math.max(...e.map((l) => l.y)) + o / 2 + 4 };
+    case "right":
+      return { x: Math.max(...e.map((l) => l.x)) + i / 2 + 4, y: c };
+    case "left":
+      return { x: Math.min(...e.map((l) => l.x)) - i / 2 - 4, y: c };
+    case "top":
+    default:
+      return { x: L, y: Math.min(...e.map((l) => l.y)) - o / 2 - 4 };
+  }
+}, "getSelfLoopLabelPosition"), M = /* @__PURE__ */ m((t, e = 0, { mergeSelfLoops: d = !0 } = {}) => {
+  var L;
+  const g = /* @__PURE__ */ new Map(), s = [], h = (L = t.graph()) == null ? void 0 : L.rankdir;
+  return t.edges().forEach((c) => {
+    const i = t.edge(c);
+    if (d && i.selfLoop) {
+      const o = i.selfLoop.id;
+      g.has(o) || g.set(o, []), g.get(o).push({ edge: i, start: c.v, end: c.w });
+    } else
+      s.push({ edge: i, start: c.v, end: c.w });
+  }), g.forEach((c) => {
+    if (c.length !== 3) {
+      c.forEach((E) => s.push(E));
+      return;
+    }
+    c.sort((E, x) => E.edge.selfLoop.order - x.edge.selfLoop.order);
+    const [i, o, l] = c, r = i.edge.originalEdge ?? o.edge.originalEdge ?? l.edge.originalEdge ?? o.edge, a = t.node(r.start);
+    if (!a) {
+      c.forEach((E) => s.push(E));
+      return;
+    }
+    const w = {
+      width: o.edge.width,
+      height: o.edge.height
+    }, y = Z(t, a, c, r.start, h), f = $(a, y, e, w.width ?? 0), n = ee(a, f, y, e, w), u = {
+      ...o.edge,
+      ...r,
+      id: r.id,
+      points: f,
+      start: r.start,
+      end: r.end,
+      x: n.x,
+      y: n.y,
+      width: w.width,
+      height: w.height,
+      labelStyle: o.edge.labelStyle,
+      fromCluster: i.edge.fromCluster ?? o.edge.fromCluster ?? l.edge.fromCluster,
+      toCluster: i.edge.toCluster ?? o.edge.toCluster ?? l.edge.toCluster
+    };
+    delete u.selfLoop, delete u.originalEdge, s.push({ edge: u, start: u.start, end: u.end });
+  }), s;
+}, "getEdgesToRender"), k = /* @__PURE__ */ m(async ({
+  element: t,
+  graph: e,
+  diagramType: d,
+  id: g,
+  parentCluster: s,
+  siteConfig: h
+}) => {
+  const L = e.graph().rankdir;
+  p.trace("Dir in recursive render - dir:", L);
+  const {
+    clusters: c,
+    edgePaths: i,
+    edgeLabels: o,
+    nodes: l,
+    rootGroups: r
+  } = z(t, {
+    edgePathsClass: "edgePaths"
+  });
+  e.nodes() ? p.info("Recursive render XXX", e.nodes()) : p.info("No nodes found for", e), e.edges().length > 0 && p.info("Recursive edges", e.edge(e.edges()[0]));
+  const a = Q(d);
+  await Promise.all(
+    e.nodes().map(async function(f) {
+      const n = e.node(f);
+      if (s !== void 0) {
+        const u = JSON.parse(JSON.stringify(s.clusterData));
+        p.trace(
+          `Setting data for parent cluster XXX
+ Node.id = `,
+          f,
+          `
+ data=`,
+          u.height,
+          `
+Parent cluster`,
+          s.height
+        ), e.setNode(s.id, u), e.parent(f) || (p.trace("Setting parent", f, s.id), e.setParent(f, s.id, u));
+      }
+      if (p.info("(Insert) Node XXX" + f + ": " + JSON.stringify(e.node(f))), n != null && n.clusterNode) {
+        p.info("Cluster identified XBX", f, n.width, e.node(f));
+        const { ranksep: u, nodesep: E } = e.graph();
+        n.graph.setGraph({
+          ...n.graph.graph(),
+          ranksep: u + 25,
+          nodesep: E
+        });
+        const x = await ne({
+          element: l,
+          graph: n.graph,
+          diagramType: d,
+          id: g,
+          parentCluster: e.node(f),
+          siteConfig: h
+        }), S = x.elem;
+        H(n, S), n.diff = x.diff || 0, p.info(
+          "New compound node after recursive render XAX",
+          f,
+          "width",
+          // node,
+          n.width,
+          "height",
+          n.height
+          // node.x,
+          // node.y
+        ), J(S, n);
+      } else
+        e.children(f).length > 0 ? (p.trace(
+          "Cluster - the non recursive path XBX",
+          f,
+          n.id,
+          n,
+          n.width,
+          "Graph:",
+          e
+        ), p.trace(C(n.id, e)), b.set(n.id, { id: C(n.id, e), node: n })) : (p.trace("Node - the non recursive path XAX", f, l, e.node(f), L), await F(l, e.node(f), { config: h, dir: L }));
+    })
+  ), await (/* @__PURE__ */ m(async () => {
+    const f = e.edges().map(async function(n) {
+      var E, x, S, X;
+      const u = e.edge(n.v, n.w, n.name);
+      if (p.info("Edge " + n.v + " -> " + n.w + ": " + JSON.stringify(n)), p.info("Edge " + n.v + " -> " + n.w + ": ", n, " ", JSON.stringify(e.edge(n))), p.info(
+        "Fix",
+        b,
+        "ids:",
+        n.v,
+        n.w,
+        "Translating: ",
+        b.get(n.v),
+        b.get(n.w)
+      ), a && u.selfLoop) {
+        if (u.selfLoop.order !== 1)
+          return;
+        const N = {
+          ...u.originalEdge,
+          ...u,
+          id: u.selfLoop.id,
+          startLabelLeft: ((E = u.originalEdge) == null ? void 0 : E.startLabelLeft) ?? u.startLabelLeft,
+          startLabelRight: ((x = u.originalEdge) == null ? void 0 : x.startLabelRight) ?? u.startLabelRight,
+          endLabelLeft: ((S = u.originalEdge) == null ? void 0 : S.endLabelLeft) ?? u.endLabelLeft,
+          endLabelRight: ((X = u.originalEdge) == null ? void 0 : X.endLabelRight) ?? u.endLabelRight
+        };
+        await R(o, N), u.width = N.width, u.height = N.height, u.labelStyle = N.labelStyle;
+        return;
+      }
+      await R(o, u);
+    });
+    await Promise.all(f);
+  }, "processEdges"))();
+  const { subGraphTitleTotalMargin: y } = W(h);
+  return {
+    elem: r,
+    graph: e,
+    groups: { clusters: c, edgePaths: i, edgeLabels: o, nodes: l, rootGroups: r },
+    diagramType: d,
+    id: g,
+    mergeSelfLoops: a,
+    subGraphTitleTotalMargin: y
+  };
+}, "measureDagreGraph"), G = /* @__PURE__ */ m((t) => {
+  p.info("############################################# XXX"), p.info("###                Layout                 ### XXX"), p.info("############################################# XXX"), K(t);
+}, "runDagreGraphLayout"), te = /* @__PURE__ */ m((t, e, d) => {
+  const g = t.node(e);
+  if (!g)
+    return;
+  const s = { ...g };
+  return g != null && g.clusterNode ? s.y = (g.y ?? 0) + d : t.children(e).length > 0 ? s.height = (g.height ?? 0) + d : s.y = (g.y ?? 0) + d / 2, s;
+}, "normalizeDagreNode"), I = /* @__PURE__ */ m((t, e) => {
+  V.forEach((d) => {
+    e[d] !== void 0 && (t[d] = e[d]);
+  });
+}, "applyDagreNodeLayout"), re = /* @__PURE__ */ m((t, e, d, g) => ({
+  ...t,
+  start: t.start ?? e,
+  end: t.end ?? d,
+  points: (t.points ?? []).map((s) => ({
+    ...s,
+    y: typeof s.y == "number" ? s.y + g : s.y
+  }))
+}), "normalizeDagreEdge"), ae = /* @__PURE__ */ m((t, e) => {
+  const { graph: d, mergeSelfLoops: g, subGraphTitleTotalMargin: s = 0 } = e, h = new Map(t.nodes.map((c) => [c.id, c]));
+  D(d).forEach((c) => {
+    const i = te(d, c, s);
+    if (!i)
+      return;
+    I(d.node(c), i);
+    const o = h.get(c);
+    o && I(o, i);
+  });
+  const L = s / 2;
+  return t.edges = M(d, L, { mergeSelfLoops: g }).map(
+    ({ edge: c, start: i, end: o }) => re(c, i, o, L)
+  ), t;
+}, "applyDagreLayoutResult"), oe = /* @__PURE__ */ m(async ({
+  elem: t,
+  graph: e,
+  groups: { clusters: d, edgePaths: g },
+  diagramType: s,
+  id: h,
+  mergeSelfLoops: L,
+  subGraphTitleTotalMargin: c
+}) => {
+  let i = 0;
+  await Promise.all(
+    D(e).map(async function(r) {
+      var w;
+      const a = e.node(r);
+      if (p.info(
+        "Position XBX => " + r + ": (" + a.x,
+        "," + a.y,
+        ") width: ",
+        a.width,
+        " height: ",
+        a.height
+      ), a != null && a.clusterNode)
+        a.y += c, p.info(
+          "A tainted cluster node XBX1",
+          r,
+          a.id,
+          a.width,
+          a.height,
+          a.x,
+          a.y,
+          e.parent(r)
+        ), b.get(a.id).node = a, P(a);
+      else if (e.children(r).length > 0) {
+        p.info(
+          "A pure cluster node XBX1",
+          r,
+          a.id,
+          a.x,
+          a.y,
+          a.width,
+          a.height,
+          e.parent(r)
+        ), a.height += c, e.node(a.parentId);
+        const y = (a == null ? void 0 : a.padding) / 2 || 0, f = ((w = a == null ? void 0 : a.labelBBox) == null ? void 0 : w.height) || 0, n = f - y || 0;
+        p.debug("OffsetY", n, "labelHeight", f, "halfPadding", y), await j(d, a), b.get(a.id).node = a;
+      } else {
+        const y = e.node(a.parentId);
+        a.y += c / 2, p.info(
+          "A regular node XBX1 - using the padding",
+          a.id,
+          "parent",
+          a.parentId,
+          a.width,
+          a.height,
+          a.x,
+          a.y,
+          "offsetY",
+          a.offsetY,
+          "parent",
+          y,
+          y == null ? void 0 : y.offsetY,
+          a
+        ), P(a);
+      }
+    })
+  );
+  const o = c / 2;
+  return M(e, o, { mergeSelfLoops: L }).forEach(function({ edge: r, start: a, end: w }) {
+    p.info("Edge " + a + " -> " + w + ": " + JSON.stringify(r), r), r.points.forEach((u) => u.y += o);
+    const y = e.node(a), f = e.node(w), n = q(g, r, b, s, y, f, h);
+    U(r, n);
+  }), e.nodes().forEach(function(r) {
+    const a = e.node(r);
+    p.info(r, a.type, a.diff), a.isGroup && (i = a.diff);
+  }), p.warn("Returning from recursive render XAX", t, i), { elem: t, diff: i };
+}, "paintDagreLayoutCore"), ne = /* @__PURE__ */ m(async (t) => {
+  const e = await k(t);
+  return G(e.graph), await oe(e);
+}, "renderDagreSubgraph"), O = /* @__PURE__ */ m((t) => {
+  var d, g, s, h, L, c;
+  const e = new Y({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: t.direction,
+    // Precedence: an explicit top-level config override (only present when a
+    // user sets it - it has no schema default) > the value the diagram's own
+    // renderer put on data4Layout (usually derived from that diagram's config)
+    // > the flowchart config as a generic fallback. The flowchart keys have
+    // schema defaults and therefore always exist, so they must come last or
+    // they silently shadow every diagram's own spacing (see #7932).
+    nodesep: ((d = t.config) == null ? void 0 : d.nodeSpacing) || t.nodeSpacing || ((s = (g = t.config) == null ? void 0 : g.flowchart) == null ? void 0 : s.nodeSpacing),
+    ranksep: ((h = t.config) == null ? void 0 : h.rankSpacing) || t.rankSpacing || ((c = (L = t.config) == null ? void 0 : L.flowchart) == null ? void 0 : c.rankSpacing),
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  });
+  return t.nodes.forEach((i) => {
+    e.setNode(i.id, { ...i }), i.parentId && e.setParent(i.id, i.parentId);
+  }), p.debug("Edges:", t.edges), t.edges.forEach((i) => {
+    if (i.start === i.end) {
+      const o = i.start, l = o + "---" + o + "---1", r = o + "---" + o + "---2", a = e.node(o);
+      e.setNode(l, {
+        domId: l,
+        id: l,
+        parentId: a.parentId,
+        labelStyle: "",
+        label: "",
+        padding: 0,
+        shape: "labelRect",
+        // shape: 'rect',
+        style: "",
+        width: 10,
+        height: 10
+      }), e.setParent(l, a.parentId), e.setNode(r, {
+        domId: r,
+        id: r,
+        parentId: a.parentId,
+        labelStyle: "",
+        padding: 0,
+        // shape: 'rect',
+        shape: "labelRect",
+        label: "",
+        style: "",
+        width: 10,
+        height: 10
+      }), e.setParent(r, a.parentId);
+      const w = structuredClone(i), y = structuredClone(i), f = structuredClone(i), n = structuredClone(i);
+      y.originalEdge = w, y.selfLoop = { id: w.id, order: 0 }, f.originalEdge = w, f.selfLoop = { id: w.id, order: 1 }, n.originalEdge = w, n.selfLoop = { id: w.id, order: 2 }, y.label = "", y.arrowTypeEnd = "none", y.endLabelLeft = "", y.endLabelRight = "", y.startLabelLeft = "", y.id = o + "-cyclic-special-1", f.startLabelRight = "", f.startLabelLeft = "", f.endLabelLeft = "", f.endLabelRight = "", f.arrowTypeStart = "none", f.arrowTypeEnd = "none", f.id = o + "-cyclic-special-mid", n.label = "", n.startLabelRight = "", n.startLabelLeft = "", n.arrowTypeStart = "none", a.isGroup && (y.fromCluster = o, n.toCluster = o), n.id = o + "-cyclic-special-2", n.arrowTypeStart = "none", e.setEdge(o, l, y, o + "-cyclic-special-0"), e.setEdge(l, r, f, o + "-cyclic-special-1"), e.setEdge(r, o, n, o + "-cyclic-special-2");
+    } else
+      e.setEdge(i.start, i.end, { ...i }, i.id);
+  }), _(e), { graph: e };
+}, "prepareLayoutForDagre"), se = /* @__PURE__ */ m(async (t, { element: e, preparedLayout: d }) => {
+  const g = d ?? O(t), s = A(), h = await k({
+    element: e,
+    graph: g.graph,
+    diagramType: t.type,
+    id: t.diagramId,
+    parentCluster: void 0,
+    siteConfig: s
+  });
+  return g.measuredLayout = h, h;
+}, "measureDagreLayout"), ie = /* @__PURE__ */ m((t, e) => {
+  var g;
+  const d = (g = e.preparedLayout) == null ? void 0 : g.measuredLayout;
+  if (!d)
+    throw new Error("runDagreLayoutCore requires measureDagreLayout to run first");
+  return G(d.graph), ae(t, d), d;
+}, "runDagreLayoutCore"), de = /* @__PURE__ */ m((t, { measure: e }) => D(e.graph).map((d) => e.graph.node(d)).filter(Boolean), "getDagrePaintNodes"), le = /* @__PURE__ */ m((t, e, { measure: d }) => t ? d.graph.node(t) : void 0, "getDagreEdgeNode"), fe = T({
+  prepareLayout: O,
+  measureLayout: se,
+  runLayoutCore: ie,
+  paintOptions: {
+    clusterDb: b,
+    getNodes: de,
+    getEdgeNode: le,
+    skipNode: /* @__PURE__ */ m((t, { measure: e }) => !e.graph.hasNode(t.id), "skipNode"),
+    isCluster: /* @__PURE__ */ m((t, { measure: e }) => e.graph.hasNode(t.id) && (e.graph.children(t.id) ?? []).length > 0, "isCluster")
+  }
+});
+export {
+  ae as applyDagreLayoutResult,
+  M as getEdgesToRender,
+  se as measureDagreLayout,
+  O as prepareLayoutForDagre,
+  fe as render,
+  ie as runDagreLayoutCore
+};

package/dist/chunks/defaultLocale-BgPVtth8.js

@@ -0,0 +1,171 @@
+function J(n) {
+  return Math.abs(n = Math.round(n)) >= 1e21 ? n.toLocaleString("en").replace(/,/g, "") : n.toString(10);
+}
+function j(n, t) {
+  if (!isFinite(n) || n === 0) return null;
+  var e = (n = t ? n.toExponential(t - 1) : n.toExponential()).indexOf("e"), i = n.slice(0, e);
+  return [
+    i.length > 1 ? i[0] + i.slice(2) : i,
+    +n.slice(e + 1)
+  ];
+}
+function K(n) {
+  return n = j(Math.abs(n)), n ? n[1] : NaN;
+}
+function Q(n, t) {
+  return function(e, i) {
+    for (var o = e.length, a = [], c = 0, h = n[0], M = 0; o > 0 && h > 0 && (M + h + 1 > i && (h = Math.max(1, i - M)), a.push(e.substring(o -= h, o + h)), !((M += h + 1) > i)); )
+      h = n[c = (c + 1) % n.length];
+    return a.reverse().join(t);
+  };
+}
+function V(n) {
+  return function(t) {
+    return t.replace(/[0-9]/g, function(e) {
+      return n[+e];
+    });
+  };
+}
+var W = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;
+function $(n) {
+  if (!(t = W.exec(n))) throw new Error("invalid format: " + n);
+  var t;
+  return new L({
+    fill: t[1],
+    align: t[2],
+    sign: t[3],
+    symbol: t[4],
+    zero: t[5],
+    width: t[6],
+    comma: t[7],
+    precision: t[8] && t[8].slice(1),
+    trim: t[9],
+    type: t[10]
+  });
+}
+$.prototype = L.prototype;
+function L(n) {
+  this.fill = n.fill === void 0 ? " " : n.fill + "", this.align = n.align === void 0 ? ">" : n.align + "", this.sign = n.sign === void 0 ? "-" : n.sign + "", this.symbol = n.symbol === void 0 ? "" : n.symbol + "", this.zero = !!n.zero, this.width = n.width === void 0 ? void 0 : +n.width, this.comma = !!n.comma, this.precision = n.precision === void 0 ? void 0 : +n.precision, this.trim = !!n.trim, this.type = n.type === void 0 ? "" : n.type + "";
+}
+L.prototype.toString = function() {
+  return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;
+};
+function _(n) {
+  n: for (var t = n.length, e = 1, i = -1, o; e < t; ++e)
+    switch (n[e]) {
+      case ".":
+        i = o = e;
+        break;
+      case "0":
+        i === 0 && (i = e), o = e;
+        break;
+      default:
+        if (!+n[e]) break n;
+        i > 0 && (i = 0);
+        break;
+    }
+  return i > 0 ? n.slice(0, i) + n.slice(o + 1) : n;
+}
+var N;
+function v(n, t) {
+  var e = j(n, t);
+  if (!e) return N = void 0, n.toPrecision(t);
+  var i = e[0], o = e[1], a = o - (N = Math.max(-8, Math.min(8, Math.floor(o / 3))) * 3) + 1, c = i.length;
+  return a === c ? i : a > c ? i + new Array(a - c + 1).join("0") : a > 0 ? i.slice(0, a) + "." + i.slice(a) : "0." + new Array(1 - a).join("0") + j(n, Math.max(0, t + a - 1))[0];
+}
+function X(n, t) {
+  var e = j(n, t);
+  if (!e) return n + "";
+  var i = e[0], o = e[1];
+  return o < 0 ? "0." + new Array(-o).join("0") + i : i.length > o + 1 ? i.slice(0, o + 1) + "." + i.slice(o + 1) : i + new Array(o - i.length + 2).join("0");
+}
+const O = {
+  "%": (n, t) => (n * 100).toFixed(t),
+  b: (n) => Math.round(n).toString(2),
+  c: (n) => n + "",
+  d: J,
+  e: (n, t) => n.toExponential(t),
+  f: (n, t) => n.toFixed(t),
+  g: (n, t) => n.toPrecision(t),
+  o: (n) => Math.round(n).toString(8),
+  p: (n, t) => X(n * 100, t),
+  r: X,
+  s: v,
+  X: (n) => Math.round(n).toString(16).toUpperCase(),
+  x: (n) => Math.round(n).toString(16)
+};
+function R(n) {
+  return n;
+}
+var U = Array.prototype.map, Y = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];
+function nn(n) {
+  var t = n.grouping === void 0 || n.thousands === void 0 ? R : Q(U.call(n.grouping, Number), n.thousands + ""), e = n.currency === void 0 ? "" : n.currency[0] + "", i = n.currency === void 0 ? "" : n.currency[1] + "", o = n.decimal === void 0 ? "." : n.decimal + "", a = n.numerals === void 0 ? R : V(U.call(n.numerals, String)), c = n.percent === void 0 ? "%" : n.percent + "", h = n.minus === void 0 ? "−" : n.minus + "", M = n.nan === void 0 ? "NaN" : n.nan + "";
+  function T(f, g) {
+    f = $(f);
+    var b = f.fill, p = f.align, m = f.sign, w = f.symbol, S = f.zero, E = f.width, F = f.comma, y = f.precision, C = f.trim, d = f.type;
+    d === "n" ? (F = !0, d = "g") : O[d] || (y === void 0 && (y = 12), C = !0, d = "g"), (S || b === "0" && p === "=") && (S = !0, b = "0", p = "=");
+    var q = (g && g.prefix !== void 0 ? g.prefix : "") + (w === "$" ? e : w === "#" && /[boxX]/.test(d) ? "0" + d.toLowerCase() : ""), B = (w === "$" ? i : /[%p]/.test(d) ? c : "") + (g && g.suffix !== void 0 ? g.suffix : ""), D = O[d], H = /[defgprs%]/.test(d);
+    y = y === void 0 ? 6 : /[gprs]/.test(d) ? Math.max(1, Math.min(21, y)) : Math.max(0, Math.min(20, y));
+    function G(r) {
+      var l = q, u = B, x, I, k;
+      if (d === "c")
+        u = D(r) + u, r = "";
+      else {
+        r = +r;
+        var P = r < 0 || 1 / r < 0;
+        if (r = isNaN(r) ? M : D(Math.abs(r), y), C && (r = _(r)), P && +r == 0 && m !== "+" && (P = !1), l = (P ? m === "(" ? m : h : m === "-" || m === "(" ? "" : m) + l, u = (d === "s" && !isNaN(r) && N !== void 0 ? Y[8 + N / 3] : "") + u + (P && m === "(" ? ")" : ""), H) {
+          for (x = -1, I = r.length; ++x < I; )
+            if (k = r.charCodeAt(x), 48 > k || k > 57) {
+              u = (k === 46 ? o + r.slice(x + 1) : r.slice(x)) + u, r = r.slice(0, x);
+              break;
+            }
+        }
+      }
+      F && !S && (r = t(r, 1 / 0));
+      var z = l.length + r.length + u.length, s = z < E ? new Array(E - z + 1).join(b) : "";
+      switch (F && S && (r = t(s + r, s.length ? E - u.length : 1 / 0), s = ""), p) {
+        case "<":
+          r = l + r + u + s;
+          break;
+        case "=":
+          r = l + s + r + u;
+          break;
+        case "^":
+          r = s.slice(0, z = s.length >> 1) + l + r + u + s.slice(z);
+          break;
+        default:
+          r = s + l + r + u;
+          break;
+      }
+      return a(r);
+    }
+    return G.toString = function() {
+      return f + "";
+    }, G;
+  }
+  function Z(f, g) {
+    var b = Math.max(-8, Math.min(8, Math.floor(K(g) / 3))) * 3, p = Math.pow(10, -b), m = T((f = $(f), f.type = "f", f), { suffix: Y[8 + b / 3] });
+    return function(w) {
+      return m(p * w);
+    };
+  }
+  return {
+    format: T,
+    formatPrefix: Z
+  };
+}
+var A, tn, rn;
+en({
+  thousands: ",",
+  grouping: [3],
+  currency: ["$", ""]
+});
+function en(n) {
+  return A = nn(n), tn = A.format, rn = A.formatPrefix, A;
+}
+export {
+  rn as a,
+  tn as b,
+  K as e,
+  $ as f
+};