@nxgt/material 1.12.3 → 1.16.0

package/dist/chunk-NETBCI7D-TXZM0vKz.js

@@ -0,0 +1,236 @@
+import { n as e } from "./chunk-Y2CYZVJY-i11wjrBe.js";
+import { o as t } from "./chunk-Z7XXMR3K-BoDf6lxl.js";
+//#region node_modules/mermaid/dist/chunks/mermaid.core/chunk-NETBCI7D.mjs
+var n = 5, r = 1e-5, i = 2, a = .6, o = 1e-6;
+function s(e) {
+	let t = [];
+	for (let n = 0; n < e.length - 1; n++) t.push({
+		a: e[n],
+		b: e[n + 1]
+	});
+	return t;
+}
+e(s, "buildSegmentList");
+function c(e, t, n, r) {
+	let i = t.x - e.x, a = t.y - e.y, s = r.x - n.x, c = r.y - n.y, l = i * c - a * s;
+	if (l === 0) return null;
+	let u = n.x - e.x, d = n.y - e.y, f = (u * c - d * s) / l, p = (u * a - d * i) / l;
+	return f <= o || f >= 1 - o || p <= o || p >= 1 - o ? null : {
+		point: {
+			x: e.x + f * i,
+			y: e.y + f * a
+		},
+		tA: f,
+		tB: p
+	};
+}
+e(c, "segmentIntersection");
+function l(e) {
+	return Math.abs(e.b.x - e.a.x) >= Math.abs(e.b.y - e.a.y);
+}
+e(l, "isHorizontalSeg");
+function u(e, t, r) {
+	if (e.curve !== "rounded") return !1;
+	let i = e.points, a = i[t], o = i[t + 1];
+	if (!a || !o) return !1;
+	let s = Math.hypot(o.x - a.x, o.y - a.y), c = r * s, l = t > 0 ? _(i[t - 1], a, o, n) : null;
+	if (l && c < l.cutLen) return !0;
+	let u = t + 2 < i.length ? _(a, o, i[t + 2], n) : null;
+	return u !== null && s - c < u.cutLen;
+}
+e(u, "crossingSitsInRoundedCorner");
+function d(e) {
+	let t = [];
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n], i = s(r.points);
+		for (let a = n + 1; a < e.length; a++) {
+			let n = e[a], o = s(n.points);
+			for (let [e, a] of i.entries()) for (let [i, s] of o.entries()) {
+				let o = c(a.a, a.b, s.a, s.b);
+				if (!o || u(r, e, o.tA) || u(n, i, o.tB)) continue;
+				let d = l(a);
+				d !== l(s) && d ? t.push({
+					jumpEdgeId: r.id,
+					otherEdgeId: n.id,
+					segIndex: e,
+					t: o.tA,
+					point: o.point
+				}) : t.push({
+					jumpEdgeId: n.id,
+					otherEdgeId: r.id,
+					segIndex: i,
+					t: o.tB,
+					point: o.point
+				});
+			}
+		}
+	}
+	return t;
+}
+e(d, "findEdgeIntersections");
+function f(e) {
+	return `${Math.round(e * 1e3) / 1e3}`;
+}
+e(f, "fmt");
+function p(e) {
+	return `${f(e.x)},${f(e.y)}`;
+}
+e(p, "pointToString");
+function m(e) {
+	let t = e.b.x - e.a.x, n = e.b.y - e.a.y;
+	return Math.abs(t) >= Math.abs(n) ? +(t >= 0) : +(n >= 0);
+}
+e(m, "getArcSweepFlag");
+function h(e, n) {
+	if (e.length < 2) return e.map((e) => ({ ...e }));
+	let r = e.map((e) => ({ ...e })), i = n.arrowTypeStart && t[n.arrowTypeStart];
+	if (i) {
+		let t = e[0], n = e[1], a = Math.atan2(n.y - t.y, n.x - t.x);
+		r[0].x = t.x + i * Math.cos(a), r[0].y = t.y + i * Math.sin(a);
+	}
+	let a = n.arrowTypeEnd && t[n.arrowTypeEnd];
+	if (a) {
+		let t = e.length, n = e[t - 2], i = e[t - 1], o = Math.atan2(i.y - n.y, i.x - n.x);
+		r[t - 1].x = i.x - a * Math.cos(o), r[t - 1].y = i.y - a * Math.sin(o);
+	}
+	return r;
+}
+e(h, "applyMarkerOffsets");
+function g(e, t, n, r, i) {
+	let a = e.point.x, o = e.point.y, s = {
+		x: a - t * e.r,
+		y: o - n * e.r
+	}, c = {
+		x: a + t * e.r,
+		y: o + n * e.r
+	}, l = [`L${p(s)}`];
+	return i === "arc" ? l.push(`A${f(e.r)},${f(e.r)} 0 0 ${r} ${p(c)}`) : l.push(`M${p(c)}`), l;
+}
+e(g, "emitJump");
+function _(e, t, n, i) {
+	let a = t.x - e.x, o = t.y - e.y, s = n.x - t.x, c = n.y - t.y, l = Math.hypot(a, o), u = Math.hypot(s, c);
+	if (l < r || u < r) return null;
+	let d = a / l, f = o / l, p = s / u, m = c / u, h = d * p + f * m, g = Math.acos(Math.max(-1, Math.min(1, h)));
+	if (g < r || Math.abs(Math.PI - g) < r) return null;
+	let _ = Math.min(i / Math.sin(g / 2), l / 2, u / 2);
+	return {
+		startX: t.x - d * _,
+		startY: t.y - f * _,
+		endX: t.x + p * _,
+		endY: t.y + m * _,
+		ctrlX: t.x,
+		ctrlY: t.y,
+		cutLen: _
+	};
+}
+e(_, "computeRoundedCorner");
+function v(e, t, r) {
+	let o = e.points;
+	if (o.length < 2) return "";
+	let c = h(o, e), l = e.curve === "rounded", u = s(c), d = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = u[e.segIndex];
+		if (!t) continue;
+		let n = Math.hypot(t.b.x - t.a.x, t.b.y - t.a.y), i = d.get(e.segIndex) ?? [];
+		i.push({
+			t: e.t,
+			point: e.point,
+			d: e.t * n,
+			r: r.jumpRadius
+		}), d.set(e.segIndex, i);
+	}
+	let v = [`M${p(c[0])}`];
+	for (let e = 0; e < u.length; e++) {
+		let t = u[e], o = Math.hypot(t.b.x - t.a.x, t.b.y - t.a.y), s = o === 0 ? 0 : (t.b.x - t.a.x) / o, h = o === 0 ? 0 : (t.b.y - t.a.y) / o, y = m(t), b = 0;
+		if (l && e > 0) {
+			let t = _(c[e - 1], c[e], c[e + 1] ?? c[e], n);
+			t && (b = t.cutLen);
+		}
+		let x = o, S = null;
+		l && e < u.length - 1 && (S = _(c[e], c[e + 1], c[e + 2] ?? c[e + 1], n), S && (x = o - S.cutLen));
+		let C = r.jumpRadius * a, w = [...d.get(e) ?? []].sort((e, t) => e.t - t.t).filter((e) => {
+			let t = Math.min(e.d - b, x - e.d) - i;
+			return e.r = Math.min(e.r, t), e.r >= C;
+		});
+		for (let e = 0; e < w.length - 1; e++) {
+			let t = w[e + 1].d - w[e].d;
+			if (w[e].r + w[e + 1].r > t) {
+				let n = t / 2;
+				w[e].r = Math.min(w[e].r, n), w[e + 1].r = Math.min(w[e + 1].r, n);
+			}
+		}
+		for (let e of w) e.r < C || v.push(...g(e, s, h, y, r.jumpStyle));
+		l && S ? (v.push(`L${f(S.startX)},${f(S.startY)}`), v.push(`Q${f(S.ctrlX)},${f(S.ctrlY)} ${f(S.endX)},${f(S.endY)}`)) : v.push(`L${p(t.b)}`);
+	}
+	return v.join(" ");
+}
+e(v, "rewriteEdgePath");
+function y(e) {
+	return /^[\d\s+,.LMelm-]*$/.test(e);
+}
+e(y, "isStraightPath");
+function b(e) {
+	return !e || e === "linear" || e === "rounded" || e === "step" || e === "stepBefore" || e === "stepAfter";
+}
+e(b, "curveSupportsLineHops");
+function x(e) {
+	if (!e) return null;
+	try {
+		let t = typeof atob == "function" ? atob(e) : Buffer.from(e, "base64").toString(), n = JSON.parse(t);
+		if (!Array.isArray(n)) return null;
+		let r = [];
+		for (let e of n) e && typeof e.x == "number" && typeof e.y == "number" && r.push({
+			x: e.x,
+			y: e.y
+		});
+		return r.length >= 2 ? r : null;
+	} catch {
+		return null;
+	}
+}
+e(x, "decodeDataPoints");
+function S(e, t, n) {
+	if (!n.enabled) return;
+	let r = e.node();
+	if (!r) return;
+	let i = /* @__PURE__ */ new Map();
+	for (let e of t) i.set(e.id, e);
+	let a = /* @__PURE__ */ new Map();
+	for (let e of r.querySelectorAll("path[data-id]")) {
+		let t = e.getAttribute("data-id");
+		t !== null && !a.has(t) && a.set(t, e);
+	}
+	let o = [];
+	for (let e of t) {
+		let t = a.get(e.id);
+		if (!t) continue;
+		let n = x(t.getAttribute("data-points")) ?? e.points;
+		o.push({
+			...e,
+			points: n
+		});
+	}
+	let s = d(o);
+	if (s.length === 0) return;
+	let c = /* @__PURE__ */ new Map();
+	for (let e of s) {
+		let t = c.get(e.jumpEdgeId) ?? [];
+		t.push(e), c.set(e.jumpEdgeId, t);
+	}
+	for (let e of o) {
+		let t = c.get(e.id);
+		if (!t || t.length === 0) continue;
+		let r = i.get(e.id)?.curve;
+		if (r !== void 0 && !b(r)) continue;
+		let o = a.get(e.id);
+		if (!o || r === void 0 && !y(o.getAttribute("d") ?? "")) continue;
+		let s = o.getAttribute("style") ?? "", l = /stroke-dasharray\s*:\s*0\s+([\d.]+)\s+[\d.]+\s+([\d.]+)/.exec(s), u = l ? Number.parseFloat(l[1]) : null, d = l ? Number.parseFloat(l[2]) : null, f = v(e, t, n);
+		if (o.setAttribute("d", f), u !== null && d !== null && typeof o.getTotalLength == "function") {
+			let e = o.getTotalLength(), t = `0 ${u} ${Math.max(0, e - u - d)} ${d}`, n = s.replace(/stroke-dasharray\s*:[^;]*;?/g, `stroke-dasharray: ${t};`).replace(/;\s*;+/g, ";");
+			o.setAttribute("style", n);
+		}
+	}
+}
+e(S, "applyLineJumpsToSvg");
+//#endregion
+export { S as t };