@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

package/browser/esm/BkBhLS0l6z8sxI6D.mjs

@@ -0,0 +1,441 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.11
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { i as e, n as t, r as n, t as r } from "./BjkCiv5Jz6WYKZeu.mjs";
+var i = 6e4, a = Math.PI / 180 / i, o = 108e5 / Math.PI, s = /^[+-]?\d+$/, c = (e) => s.test(e) ? Number(e) : e, l = /* @__PURE__ */ new WeakMap();
+function u(e) {
+	let t = l.get(e);
+	return t || (t = {
+		av: (e.av ?? []).map((e) => {
+			let t = e.split(" ");
+			if (t[1] !== "val" || t.length !== 3) throw Error(`adjust value "${e}" is not "name val N"`);
+			return {
+				name: t[0],
+				value: Number(t[2])
+			};
+		}),
+		gd: (e.gd ?? []).map((e) => {
+			let t = e.split(" ");
+			return {
+				name: t[0],
+				op: t[1],
+				args: t.slice(2).map(c)
+			};
+		})
+	}, l.set(e, t), t);
+}
+var d = class {
+	constructor(e, t) {
+		this._values = /* @__PURE__ */ new Map(), this.w = e, this.h = t;
+	}
+	get(e) {
+		if (typeof e == "number") return e;
+		let t = this._values.get(e);
+		if (t !== void 0) return t;
+		let n = function(e, t, n) {
+			switch (e) {
+				case "l":
+				case "t": return 0;
+				case "r":
+				case "w": return t;
+				case "b":
+				case "h": return n;
+				case "hc":
+				case "wd2": return t / 2;
+				case "vc":
+				case "hd2": return n / 2;
+				case "wd3": return t / 3;
+				case "wd4": return t / 4;
+				case "wd5": return t / 5;
+				case "wd6": return t / 6;
+				case "wd8": return t / 8;
+				case "wd10": return t / 10;
+				case "wd12": return t / 12;
+				case "wd32": return t / 32;
+				case "hd3": return n / 3;
+				case "hd4": return n / 4;
+				case "hd5": return n / 5;
+				case "hd6": return n / 6;
+				case "hd8": return n / 8;
+				case "hd10": return n / 10;
+				case "hd12": return n / 12;
+				case "ss": return Math.min(t, n);
+				case "ls": return Math.max(t, n);
+				case "ssd2": return Math.min(t, n) / 2;
+				case "ssd4": return Math.min(t, n) / 4;
+				case "ssd6": return Math.min(t, n) / 6;
+				case "ssd8": return Math.min(t, n) / 8;
+				case "ssd16": return Math.min(t, n) / 16;
+				case "ssd32": return Math.min(t, n) / 32;
+				case "cd2": return 108e5;
+				case "cd3": return 72e5;
+				case "cd4": return 54e5;
+				case "cd8": return 27e5;
+				case "3cd4": return 162e5;
+				case "3cd8": return 81e5;
+				case "5cd8": return 135e5;
+				case "7cd8": return 189e5;
+				default: return;
+			}
+		}(e, this.w, this.h);
+		if (n === void 0) throw Error(`undefined guide "${e}"`);
+		return n;
+	}
+	has(e) {
+		return this._values.has(e);
+	}
+	set(e, t) {
+		this._values.set(e, t);
+	}
+};
+function f(e, t, n, r) {
+	switch (e) {
+		case "*/": return r === 0 ? 0 : t * n / r;
+		case "+-": return t + n - r;
+		case "+/": return r === 0 ? 0 : (t + n) / r;
+		case "?:": return t > 0 ? n : r;
+		case "abs": return Math.abs(t);
+		case "at2": return Math.atan2(n, t) * o;
+		case "cat2": return t * Math.cos(Math.atan2(r, n));
+		case "sat2": return t * Math.sin(Math.atan2(r, n));
+		case "cos": return t * Math.cos(n * a);
+		case "sin": return t * Math.sin(n * a);
+		case "tan": return t * Math.tan(n * a);
+		case "max": return Math.max(t, n);
+		case "min": return Math.min(t, n);
+		case "mod": return Math.sqrt(t * t + n * n + r * r);
+		case "pin": return n < t ? t : n > r ? r : n;
+		case "sqrt": return Math.sqrt(Math.abs(t));
+		case "val": return t;
+		default: throw Error(`unknown guide op "${e}"`);
+	}
+}
+function p(e, t, n, r) {
+	let { av: i, gd: a } = u(e), o = new d(t, n);
+	for (let e of i) {
+		let t = r?.[e.name];
+		o.set(e.name, t !== void 0 && Number.isFinite(t) ? t : e.value);
+	}
+	for (let e of a) {
+		let t = e.args;
+		o.set(e.name, f(e.op, t.length > 0 ? o.get(t[0]) : 0, t.length > 1 ? o.get(t[1]) : 0, t.length > 2 ? o.get(t[2]) : 0));
+	}
+	return o;
+}
+var m = {
+	M: 2,
+	L: 2,
+	Q: 4,
+	C: 6,
+	A: 4,
+	Z: 0
+}, h = /* @__PURE__ */ new WeakMap();
+function g(e) {
+	let t = e.d.length === 0 ? [] : e.d.split(" "), n = [], r = 0;
+	for (; r < t.length;) {
+		let i = t[r++], a = m[i];
+		if (a === void 0) throw Error(`unknown path command "${i}" in "${e.d}"`);
+		n.push({
+			c: i,
+			args: t.slice(r, r + a).map(c)
+		}), r += a;
+	}
+	let i = {
+		fill: e.f ?? "norm",
+		stroke: e.s !== 0,
+		cmds: n
+	};
+	return e.w !== void 0 && (i.w = e.w), e.h !== void 0 && (i.h = e.h), i;
+}
+var _ = Math.PI / 180 / i, v = 2 * Math.PI;
+function y(e, t, n, r) {
+	let i = [], a = 0, o = 0, s = 0, c = 0, l = null, u = (e) => {
+		let t = {
+			x: a * n,
+			y: o * r,
+			segments: [],
+			closed: !1
+		};
+		return e && (t.implicit = !0), i.push(t), l = t, t;
+	}, d = () => l ?? u(!0);
+	for (let i of e.cmds) {
+		let e = i.args;
+		switch (i.c) {
+			case "M":
+				a = s = t.get(e[0]), o = c = t.get(e[1]), u(!1);
+				break;
+			case "L": {
+				let i = t.get(e[0]), s = t.get(e[1]);
+				d().segments.push({
+					k: "L",
+					x0: a * n,
+					y0: o * r,
+					x1: i * n,
+					y1: s * r
+				}), a = i, o = s;
+				break;
+			}
+			case "Q": {
+				let i = t.get(e[2]), s = t.get(e[3]);
+				d().segments.push({
+					k: "Q",
+					x0: a * n,
+					y0: o * r,
+					cx: t.get(e[0]) * n,
+					cy: t.get(e[1]) * r,
+					x1: i * n,
+					y1: s * r
+				}), a = i, o = s;
+				break;
+			}
+			case "C": {
+				let i = t.get(e[4]), s = t.get(e[5]);
+				d().segments.push({
+					k: "C",
+					x0: a * n,
+					y0: o * r,
+					c1x: t.get(e[0]) * n,
+					c1y: t.get(e[1]) * r,
+					c2x: t.get(e[2]) * n,
+					c2y: t.get(e[3]) * r,
+					x1: i * n,
+					y1: s * r
+				}), a = i, o = s;
+				break;
+			}
+			case "Z":
+				d().closed = !0, l = null, a = s, o = c;
+				break;
+			case "A": {
+				let i = t.get(e[0]), s = t.get(e[1]), c = t.get(e[2]) * _, l = t.get(e[3]) * _;
+				if (i === 0 || s === 0 || l === 0) break;
+				let u = (e) => Math.atan2(i * Math.sin(e), s * Math.cos(e)), f = u(c), p = a - i * Math.cos(f), m = o - s * Math.sin(f), h = u(c + l), g = p + i * Math.cos(h), y = m + s * Math.sin(h), b;
+				Math.abs(l) >= v ? b = l > 0 ? v : -v : (b = h - f, (l > 0 ? b <= 0 : b >= 0) && (b += l > 0 ? v : -v)), d().segments.push({
+					k: "A",
+					cx: p * n,
+					cy: m * r,
+					rx: i * n,
+					ry: s * r,
+					phi: 0,
+					t0: f,
+					dt: b,
+					x0: a * n,
+					y0: o * r,
+					x1: g * n,
+					y1: y * r
+				}), a = g, o = y;
+				break;
+			}
+		}
+	}
+	return i;
+}
+var b = /* @__PURE__ */ new WeakMap(), x = (e) => e === "_" ? void 0 : e, S = (e) => e === void 0 || e === "_" ? void 0 : c(e);
+function C(e) {
+	let t = b.get(e);
+	return t || (t = {
+		handles: (e.ah ?? []).map((e) => {
+			let t = e.split(" "), n = {
+				type: t[0],
+				ref1: x(t[1]),
+				ref2: x(t[2]),
+				x: c(t[3]),
+				y: c(t[4])
+			};
+			return t.length > 5 && (n.bounds = [
+				S(t[5]),
+				S(t[6]),
+				S(t[7]),
+				S(t[8])
+			]), n;
+		}),
+		cxn: (e.cxn ?? []).map((e) => {
+			let t = e.split(" ");
+			return {
+				ang: c(t[0]),
+				x: c(t[1]),
+				y: c(t[2])
+			};
+		})
+	}, e.rect !== void 0 && (t.rect = e.rect.split(" ").map(c)), b.set(e, t), t);
+}
+function w(e, t) {
+	let n = (e) => t.get(e), r = (e) => e === void 0 ? void 0 : t.get(e), a = (e) => e === void 0 ? void 0 : t.get(e) / i;
+	return e.handles.map((e) => {
+		let t = e.bounds ?? [];
+		return e.type === "xy" ? O({
+			type: "xy",
+			x: n(e.x),
+			y: n(e.y),
+			refX: e.ref1,
+			minX: r(t[0]),
+			maxX: r(t[1]),
+			refY: e.ref2,
+			minY: r(t[2]),
+			maxY: r(t[3])
+		}) : O({
+			type: "polar",
+			x: n(e.x),
+			y: n(e.y),
+			refR: e.ref1,
+			minR: r(t[0]),
+			maxR: r(t[1]),
+			refAng: e.ref2,
+			minAng: a(t[2]),
+			maxAng: a(t[3])
+		});
+	});
+}
+function T(e, t, n, r) {
+	return w(C(e), p(e, t, n, r));
+}
+var E = (e, t, n, r) => {
+	let i = t === n ? e.head : void 0, a = t === r ? e.tail : void 0;
+	if (!i && !a) return null;
+	let o = { ...e };
+	return i || delete o.head, a || delete o.tail, o;
+};
+function D(a, o, s, c, l) {
+	let d = l?.precision ?? 2, f = p(a, o, s, c), m = /* @__PURE__ */ new Map(), _ = l?.line, v = [], b = n(), x = [];
+	for (let e of function(e) {
+		let t = h.get(e);
+		return t || (t = e.paths.map(g), h.set(e, t), t);
+	}(a)) {
+		let t = f, n = 1, r = 1;
+		if (e.w !== void 0 && e.h !== void 0) {
+			let i = `${e.w}x${e.h}`, l = m.get(i);
+			l || (l = p(a, e.w, e.h, c), m.set(i, l)), t = l, n = o / e.w, r = s / e.h;
+		}
+		x.push({
+			fill: e.fill,
+			stroke: e.stroke,
+			subpaths: y(e, t, n, r)
+		});
+	}
+	let S = -1, T = -1;
+	_ && x.forEach((e, t) => {
+		var n;
+		e.stroke && (n = e.subpaths).some((e) => e.segments.length > 0) && !n.some((e) => e.closed) && (S < 0 && (S = t), T = t);
+	});
+	for (let n = 0; n < x.length; n++) {
+		let i = x[n], a = i.subpaths, o = _ && S >= 0 ? E(_, n, S, T) : null, s = o ? r(a, o) : null;
+		(i.fill !== "none" || i.stroke) && t(b, a), s && t(b, s.ends), s ? (i.fill !== "none" && v.push({
+			d: e(a, d),
+			fill: i.fill,
+			stroke: !1
+		}), v.push({
+			d: e(s.stroke, d),
+			fill: "none",
+			stroke: !0
+		}), v.push({
+			d: e(s.ends, d),
+			fill: "line",
+			stroke: !1
+		})) : v.push({
+			d: e(a, d),
+			fill: i.fill,
+			stroke: i.stroke
+		});
+	}
+	let D = C(a), O = (e) => f.get(e), k = D.rect ? {
+		l: O(D.rect[0]),
+		t: O(D.rect[1]),
+		r: O(D.rect[2]),
+		b: O(D.rect[3])
+	} : {
+		l: 0,
+		t: 0,
+		r: o,
+		b: s
+	}, A = w(D, f), j = D.cxn.map((e) => ({
+		x: O(e.x),
+		y: O(e.y),
+		ang: f.get(e.ang) / i
+	})), M = {};
+	for (let e of u(a).av) M[e.name] = f.get(e.name);
+	return {
+		paths: v,
+		textRect: k,
+		pathBounds: b.l <= b.r ? b : {
+			l: 0,
+			t: 0,
+			r: o,
+			b: s
+		},
+		handles: A,
+		connections: j,
+		adjustments: M
+	};
+}
+function O(e) {
+	for (let t of Object.keys(e)) e[t] === void 0 && delete e[t];
+	return e;
+}
+var k = 2147483647, A = .01;
+function j(e, t, n, r, i, a = (e, t) => e - t) {
+	let o = ((e, t) => (n) => Math.min(t, Math.max(e, n)))(r, i), s = o(n), c = a(e(s), t);
+	if (Math.abs(c) < A) return s;
+	let l = i - r, u = Number.isFinite(l) && l < k ? Math.max(l / 100, 1) : Math.max(Math.abs(s) / 10, 1e3), d = o(s + u);
+	if (d === s && (d = o(s - u)), d === s) return s;
+	let f = a(e(d), t);
+	for (let n = 0; n < 24; n++) {
+		if (Math.abs(f) < A) return d;
+		if (f === c) break;
+		let n = o(d - f * (d - s) / (f - c));
+		if (n === d) break;
+		s = d, c = f, d = n, f = a(e(d), t);
+	}
+	return Math.abs(f) <= Math.abs(c) ? d : s;
+}
+function M(e, t, n, r, a, o, s) {
+	let c = { ...r }, l = T(e, t, n, c)[a];
+	if (!l) return c;
+	let u = (r, i) => T(e, t, n, {
+		...c,
+		[r]: i
+	})[a], d = (t) => c[t] ?? function(e, t) {
+		for (let n of e.av ?? []) {
+			let e = n.split(" ");
+			if (e[0] === t && e[1] === "val") return Number(e[2]);
+		}
+		return 0;
+	}(e, t);
+	if (l.type === "xy") {
+		if (l.refX) {
+			let e = l.refX;
+			c[e] = j((t) => u(e, t).x, o, d(e), l.minX ?? -2147483647, l.maxX ?? k);
+		}
+		if (l.refY) {
+			let e = l.refY;
+			c[e] = j((t) => u(e, t).y, s, d(e), l.minY ?? -2147483647, l.maxY ?? k);
+		}
+		return c;
+	}
+	let f = t / 2, p = n / 2;
+	if (l.refAng) {
+		let e = l.refAng, t = 180 * Math.atan2(s - p, o - f) / Math.PI, n = (t) => {
+			let n = u(e, t);
+			return 180 * Math.atan2(n.y - p, n.x - f) / Math.PI;
+		}, r = l.minAng === void 0 ? -2147483647 : l.minAng * i, a = l.maxAng === void 0 ? k : l.maxAng * i;
+		c[e] = function(e, t, n, r, i) {
+			let a = (n) => ((e, t) => {
+				let n = (e - t) % 360;
+				return n <= -180 && (n += 360), n > 180 && (n -= 360), n;
+			})(e(n), t), o = 216e5, s = i - r, c = s <= 2 * o ? r : Math.max(r, n - o), l = s <= 2 * o ? i : Math.min(i, n + o), u = Math.min(i, Math.max(r, n)), d = Math.abs(a(u));
+			for (let e = 0; e <= 12 && d >= A; e++) {
+				let t = c + (l - c) * e / 12, n = Math.abs(a(t));
+				n < d && (u = t, d = n);
+			}
+			return d < A ? u : j(a, 0, u, r, i);
+		}(n, t, d(e), r, a);
+	}
+	if (l.refR) {
+		let e = l.refR, t = Math.hypot(o - f, s - p), n = (e) => Math.hypot(e.x - f, e.y - p);
+		c[e] = j((t) => n(u(e, t)), t, d(e), l.minR ?? -2147483647, l.maxR ?? k);
+	}
+	return c;
+}
+export { M as adjustmentsFromHandle, D as evaluateGeometry };

package/browser/esm/BnG31I6Oj_HEtSPS.mjs

@@ -0,0 +1,167 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.11
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = [], t = Object.freeze({
+	mathDivide: {
+		av: [
+			"adj1 val 23520",
+			"adj2 val 5880",
+			"adj3 val 11760"
+		],
+		gd: [
+			"a1 pin 1000 adj1 36745",
+			"ma1 +- 0 0 a1",
+			"ma3h +/ 73490 ma1 4",
+			"ma3w */ 36745 w h",
+			"maxAdj3 min ma3h ma3w",
+			"a3 pin 1000 adj3 maxAdj3",
+			"m4a3 */ -4 a3 1",
+			"maxAdj2 +- 73490 m4a3 a1",
+			"a2 pin 0 adj2 maxAdj2",
+			"dy1 */ h a1 200000",
+			"yg */ h a2 100000",
+			"rad */ h a3 100000",
+			"dx1 */ w 73490 200000",
+			"y3 +- vc 0 dy1",
+			"y4 +- vc dy1 0",
+			"a +- yg rad 0",
+			"y2 +- y3 0 a",
+			"y1 +- y2 0 rad",
+			"y5 +- b 0 y1",
+			"x1 +- hc 0 dx1",
+			"x3 +- hc dx1 0",
+			"x2 +- hc 0 rad"
+		],
+		ah: [
+			"xy _ adj1 l y3 _ _ 1000 36745",
+			"xy _ adj2 r y2 _ _ 0 maxAdj2",
+			"xy adj3 _ x2 t 1000 maxAdj3 _ _"
+		],
+		cxn: [
+			"0 x3 vc",
+			"cd4 hc y5",
+			"cd2 x1 vc",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y3 x3 y4",
+		paths: [{ d: "M hc y1 A rad rad 3cd4 21600000 Z M hc y5 A rad rad cd4 21600000 Z M x1 y3 L x3 y3 L x3 y4 L x1 y4 Z" }]
+	},
+	mathEqual: {
+		av: ["adj1 val 23520", "adj2 val 11760"],
+		gd: [
+			"a1 pin 0 adj1 36745",
+			"2a1 */ a1 2 1",
+			"mAdj2 +- 100000 0 2a1",
+			"a2 pin 0 adj2 mAdj2",
+			"dy1 */ h a1 100000",
+			"dy2 */ h a2 200000",
+			"dx1 */ w 73490 200000",
+			"y2 +- vc 0 dy2",
+			"y3 +- vc dy2 0",
+			"y1 +- y2 0 dy1",
+			"y4 +- y3 dy1 0",
+			"x1 +- hc 0 dx1",
+			"x2 +- hc dx1 0",
+			"yC1 +/ y1 y2 2",
+			"yC2 +/ y3 y4 2"
+		],
+		ah: ["xy _ adj1 l y1 _ _ 0 36745", "xy _ adj2 r y2 _ _ 0 mAdj2"],
+		cxn: [
+			"0 x2 yC1",
+			"0 x2 yC2",
+			"cd4 hc y4",
+			"cd2 x1 yC1",
+			"cd2 x1 yC2",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y1 x2 y4",
+		paths: [{ d: "M x1 y1 L x2 y1 L x2 y2 L x1 y2 Z M x1 y3 L x2 y3 L x2 y4 L x1 y4 Z" }]
+	},
+	mathMinus: {
+		av: ["adj1 val 23520"],
+		gd: [
+			"a1 pin 0 adj1 100000",
+			"dy1 */ h a1 200000",
+			"dx1 */ w 73490 200000",
+			"y1 +- vc 0 dy1",
+			"y2 +- vc dy1 0",
+			"x1 +- hc 0 dx1",
+			"x2 +- hc dx1 0"
+		],
+		ah: ["xy _ adj1 l y1 _ _ 0 100000"],
+		cxn: [
+			"0 x2 vc",
+			"cd4 hc y2",
+			"cd2 x1 vc",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y1 x2 y2",
+		paths: [{ d: "M x1 y1 L x2 y1 L x2 y2 L x1 y2 Z" }]
+	},
+	mathMultiply: {
+		av: ["adj1 val 23520"],
+		gd: /* @__PURE__ */ "a1 pin 0 adj1 51965.th */ ss a1 100000.a at2 w h.sa sin 1 a.ca cos 1 a.ta tan 1 a.dl mod w h 0.rw */ dl 51965 100000.lM +- dl 0 rw.xM */ ca lM 2.yM */ sa lM 2.dxAM */ sa th 2.dyAM */ ca th 2.xA +- xM 0 dxAM.yA +- yM dyAM 0.xB +- xM dxAM 0.yB +- yM 0 dyAM.xBC +- hc 0 xB.yBC */ xBC ta 1.yC +- yBC yB 0.xD +- r 0 xB.xE +- r 0 xA.yFE +- vc 0 yA.xFE */ yFE 1 ta.xF +- xE 0 xFE.xL +- xA xFE 0.yG +- b 0 yA.yH +- b 0 yB.yI +- b 0 yC.xC2 +- r 0 xM.yC3 +- b 0 yM".split("."),
+		ah: ["xy _ adj1 l th _ _ 0 51965"],
+		cxn: [
+			"cd2 xM yM",
+			"3cd4 xC2 yM",
+			"0 xC2 yC3",
+			"cd4 xM yC3"
+		],
+		rect: "xA yB xE yH",
+		paths: [{ d: "M xA yA L xB yB L hc yC L xD yB L xE yA L xF vc L xE yG L xD yH L hc yI L xB yH L xA yG L xL vc Z" }]
+	},
+	mathNotEqual: {
+		av: [
+			"adj1 val 23520",
+			"adj2 val 6600000",
+			"adj3 val 11760"
+		],
+		gd: /* @__PURE__ */ "a1 pin 0 adj1 50000.crAng pin 4200000 adj2 6600000.2a1 */ a1 2 1.maxAdj3 +- 100000 0 2a1.a3 pin 0 adj3 maxAdj3.dy1 */ h a1 100000.dy2 */ h a3 200000.dx1 */ w 73490 200000.x1 +- hc 0 dx1.x8 +- hc dx1 0.y2 +- vc 0 dy2.y3 +- vc dy2 0.y1 +- y2 0 dy1.y4 +- y3 dy1 0.cadj2 +- crAng 0 cd4.xadj2 tan hd2 cadj2.len mod xadj2 hd2 0.bhw */ len dy1 hd2.bhw2 */ bhw 1 2.x7 +- hc xadj2 bhw2.dx67 */ xadj2 y1 hd2.x6 +- x7 0 dx67.dx57 */ xadj2 y2 hd2.x5 +- x7 0 dx57.dx47 */ xadj2 y3 hd2.x4 +- x7 0 dx47.dx37 */ xadj2 y4 hd2.x3 +- x7 0 dx37.dx27 */ xadj2 2 1.x2 +- x7 0 dx27.rx7 +- x7 bhw 0.rx6 +- x6 bhw 0.rx5 +- x5 bhw 0.rx4 +- x4 bhw 0.rx3 +- x3 bhw 0.rx2 +- x2 bhw 0.dx7 */ dy1 hd2 len.rxt +- x7 dx7 0.lxt +- rx7 0 dx7.rx ?: cadj2 rxt rx7.lx ?: cadj2 x7 lxt.dy3 */ dy1 xadj2 len.dy4 +- 0 0 dy3.ry ?: cadj2 dy3 t.ly ?: cadj2 t dy4.dlx +- w 0 rx.drx +- w 0 lx.dly +- h 0 ry.dry +- h 0 ly.xC1 +/ rx lx 2.xC2 +/ drx dlx 2.yC1 +/ ry ly 2.yC2 +/ y1 y2 2.yC3 +/ y3 y4 2.yC4 +/ dry dly 2".split("."),
+		ah: [
+			"xy _ adj1 l y1 _ _ 0 50000",
+			"polar _ adj2 lx t _ _ 4200000 6600000",
+			"xy _ adj3 r y2 _ _ 0 maxAdj3"
+		],
+		cxn: [
+			"0 x8 yC2",
+			"0 x8 yC3",
+			"cd4 xC2 yC4",
+			"cd2 x1 yC2",
+			"cd2 x1 yC3",
+			"3cd4 xC1 yC1"
+		],
+		rect: "x1 y1 x8 y4",
+		paths: [{ d: "M x1 y1 L x6 y1 L lx ly L rx ry L rx6 y1 L x8 y1 L x8 y2 L rx5 y2 L rx4 y3 L x8 y3 L x8 y4 L rx3 y4 L drx dry L dlx dly L x3 y4 L x1 y4 L x1 y3 L x4 y3 L x5 y2 L x1 y2 Z" }]
+	},
+	mathPlus: {
+		av: ["adj1 val 23520"],
+		gd: [
+			"a1 pin 0 adj1 73490",
+			"dx1 */ w 73490 200000",
+			"dy1 */ h 73490 200000",
+			"dx2 */ ss a1 200000",
+			"x1 +- hc 0 dx1",
+			"x2 +- hc 0 dx2",
+			"x3 +- hc dx2 0",
+			"x4 +- hc dx1 0",
+			"y1 +- vc 0 dy1",
+			"y2 +- vc 0 dx2",
+			"y3 +- vc dx2 0",
+			"y4 +- vc dy1 0"
+		],
+		ah: ["xy _ adj1 l y2 _ _ 0 73490"],
+		cxn: [
+			"0 x4 vc",
+			"cd4 hc y4",
+			"cd2 x1 vc",
+			"3cd4 hc y1"
+		],
+		rect: "x1 y2 x4 y3",
+		paths: [{ d: "M x1 y2 L x2 y2 L x2 y1 L x3 y1 L x3 y2 L x4 y2 L x4 y3 L x3 y3 L x3 y4 L x2 y4 L x2 y3 L x1 y3 Z" }]
+	}
+});
+export { t as BUILT_IN, e as CXN_SHARED };