blessing-ui 0.1.0 → 0.3.0

package/dist/composables/cropBox.js

@@ -0,0 +1,39 @@
+//#region src/composables/cropBox.ts
+var e = .05, t = (e, t, n) => Math.min(Math.max(e, t), n);
+function n(e, t = .9) {
+	let n = t, r = t;
+	return e > 0 && (e > 1 ? r = n / e : n = r * e), {
+		l: (1 - n) / 2,
+		t: (1 - r) / 2,
+		r: (1 + n) / 2,
+		b: (1 + r) / 2
+	};
+}
+function r(e, n, r) {
+	let i = e.r - e.l, a = e.b - e.t, o = t(e.l + n, 0, 1 - i), s = t(e.t + r, 0, 1 - a);
+	return {
+		l: o,
+		t: s,
+		r: o + i,
+		b: s + a
+	};
+}
+function i(n, r, i, a, o = 0) {
+	let s = { ...n };
+	if (r.includes("w") && (s.l = t(i, 0, n.r - e)), r.includes("e") && (s.r = t(i, n.l + e, 1)), r.includes("n") && (s.t = t(a, 0, n.b - e)), r.includes("s") && (s.b = t(a, n.t + e, 1)), o > 0 && r.length === 2) {
+		let e = s.r - s.l, t = s.b - s.t, n = e / t > o ? t * o : e, i = e / t > o ? t : e / o;
+		r.includes("e") ? s.r = s.l + n : s.l = s.r - n, r.includes("s") ? s.b = s.t + i : s.t = s.b - i;
+	}
+	return s;
+}
+function a(n, r) {
+	let i = n.r - n.l, a = n.b - n.t, o = t((Math.min(i, a) + r) / Math.min(i, a), e / Math.min(i, a), 1 / Math.max(i, a)), s = i * o, c = a * o, l = t((n.l + n.r) / 2, s / 2, 1 - s / 2), u = t((n.t + n.b) / 2, c / 2, 1 - c / 2);
+	return {
+		l: l - s / 2,
+		t: u - c / 2,
+		r: l + s / 2,
+		b: u + c / 2
+	};
+}
+//#endregion
+export { e as MIN, n as initialBox, r as moveBox, i as resizeBox, a as scaleBox };

package/dist/composables/dayBlocks.d.ts

@@ -0,0 +1,11 @@
+export interface DayBlock {
+    start: string;
+    end: string;
+    count: number;
+}
+/** Every day from `a` to `b` inclusive, whichever comes first, as ISO strings. */
+export declare function rangeBetween(a: string, b: string): string[];
+/** Runs of consecutive days in a set of dates, in order. */
+export declare function blocks(dates: readonly string[]): DayBlock[];
+/** `current` with `range` added (`set`) or removed (`clear`), skipping days `ok` refuses; sorted. */
+export declare function applyRange(current: readonly string[], range: readonly string[], mode: "set" | "clear", ok?: (iso: string) => boolean): string[];

package/dist/composables/dayBlocks.js

@@ -0,0 +1,26 @@
+import { addDays as e, fromISO as t, toISO as n } from "./date.js";
+//#region src/composables/dayBlocks.ts
+function r(r, i) {
+	let [a, o] = r <= i ? [r, i] : [i, r], s = [];
+	for (let r = t(a), i = t(o); r <= i; r = e(r, 1)) s.push(n(r));
+	return s;
+}
+function i(r) {
+	let i = [...new Set(r)].sort(), a = [];
+	for (let r of i) {
+		let i = a.at(-1);
+		i && n(e(t(i.end), 1)) === r ? (i.end = r, i.count++) : a.push({
+			start: r,
+			end: r,
+			count: 1
+		});
+	}
+	return a;
+}
+function a(e, t, n, r = () => !0) {
+	let i = new Set(e);
+	for (let e of t) r(e) && (n === "set" ? i.add(e) : i.delete(e));
+	return [...i].sort();
+}
+//#endregion
+export { a as applyRange, i as blocks, r as rangeBetween };

package/dist/composables/diffLines.d.ts

@@ -0,0 +1,10 @@
+export interface DiffRow {
+    type: "same" | "add" | "del";
+    /** 1-based line number in the old text (not on `add`) */
+    a?: number;
+    /** 1-based line number in the new text (not on `del`) */
+    b?: number;
+    text: string;
+}
+/** Line diff of two texts: common prefix and suffix are peeled off, the middle is an LCS. */
+export declare function diffLines(oldText: string, newText: string): DiffRow[];

package/dist/composables/diffLines.js

@@ -0,0 +1,55 @@
+//#region src/composables/diffLines.ts
+var e = (e) => e === "" ? [] : e.replace(/\n$/, "").split("\n"), t = 4e6;
+function n(n, r) {
+	let i = e(n), a = e(r), o = 0;
+	for (; o < i.length && o < a.length && i[o] === a[o];) o++;
+	let s = i.length, c = a.length;
+	for (; s > o && c > o && i[s - 1] === a[c - 1];) s--, c--;
+	let l = [];
+	for (let e = 0; e < o; e++) l.push({
+		type: "same",
+		a: e + 1,
+		b: e + 1,
+		text: i[e]
+	});
+	let u = s - o, d = c - o;
+	if (u * d > t || !u || !d) {
+		for (let e = o; e < s; e++) l.push({
+			type: "del",
+			a: e + 1,
+			text: i[e]
+		});
+		for (let e = o; e < c; e++) l.push({
+			type: "add",
+			b: e + 1,
+			text: a[e]
+		});
+	} else {
+		let e = d + 1, t = new Uint32Array((u + 1) * e);
+		for (let n = u - 1; n >= 0; n--) for (let r = d - 1; r >= 0; r--) t[n * e + r] = i[o + n] === a[o + r] ? t[(n + 1) * e + r + 1] + 1 : Math.max(t[(n + 1) * e + r], t[n * e + r + 1]);
+		let n = 0, r = 0;
+		for (; n < u || r < d;) n < u && r < d && i[o + n] === a[o + r] ? (l.push({
+			type: "same",
+			a: o + n + 1,
+			b: o + r + 1,
+			text: i[o + n]
+		}), n++, r++) : r < d && (n === u || t[n * e + r + 1] > t[(n + 1) * e + r]) ? (l.push({
+			type: "add",
+			b: o + r + 1,
+			text: a[o + r]
+		}), r++) : (l.push({
+			type: "del",
+			a: o + n + 1,
+			text: i[o + n]
+		}), n++);
+	}
+	for (let e = 0; e < i.length - s; e++) l.push({
+		type: "same",
+		a: s + e + 1,
+		b: c + e + 1,
+		text: i[s + e]
+	});
+	return l;
+}
+//#endregion
+export { n as diffLines };

package/dist/composables/formula.d.ts

@@ -0,0 +1,28 @@
+export type FormulaErrorCode = "empty" | "unexpected" | "unclosed" | "unknown-variable" | "unknown-function" | "arity" | "divide-by-zero" | "not-finite";
+export interface FormulaError {
+    code: FormulaErrorCode;
+    /** where in the source it went wrong (0-based), and how many characters */
+    pos: number;
+    length: number;
+    /** the variable or function the error is about, or the unexpected text */
+    name?: string;
+    /** the closest known name, when there is one */
+    suggestion?: string;
+}
+export type FormulaResult = {
+    ok: true;
+    value: number;
+} | {
+    ok: false;
+    error: FormulaError;
+};
+export type FormulaFns = Record<string, (...args: number[]) => number>;
+export declare const builtins: FormulaFns;
+export declare function closest(name: string, known: readonly string[]): string | undefined;
+/**
+ * Evaluate `+ - * / ^`, brackets, numbers, named values and functions. There is no `eval`: the
+ * source is parsed by recursive descent, so only numbers can come out and nothing can run.
+ */
+export declare function evaluate(src: string, vars?: Readonly<Record<string, number>>, fns?: FormulaFns): FormulaResult;
+/** The names the formula refers to as values (not function names). */
+export declare function usedNames(src: string): string[];

package/dist/composables/formula.js

@@ -0,0 +1,161 @@
+//#region src/composables/formula.ts
+var e = {
+	sum: (...e) => e.reduce((e, t) => e + t, 0),
+	min: (...e) => Math.min(...e),
+	max: (...e) => Math.max(...e),
+	avg: (...e) => e.reduce((e, t) => e + t, 0) / e.length,
+	abs: (e) => Math.abs(e),
+	sqrt: (e) => Math.sqrt(e),
+	floor: (e) => Math.floor(e),
+	ceil: (e) => Math.ceil(e),
+	round: (e, t = 0) => {
+		let n = 10 ** t;
+		return Math.round(e * n) / n;
+	}
+};
+function t(e) {
+	let t = [], n = /\s+|(\d+\.?\d*|\.\d+)|([A-Za-z_][A-Za-z0-9_]*)|([-+*/^(),])|(.)/gy, r;
+	for (; n.lastIndex < e.length && (r = n.exec(e));) if (r[1]) t.push({
+		t: "num",
+		v: r[1],
+		pos: r.index
+	});
+	else if (r[2]) t.push({
+		t: "id",
+		v: r[2],
+		pos: r.index
+	});
+	else if (r[3]) t.push({
+		t: "op",
+		v: r[3],
+		pos: r.index
+	});
+	else if (r[4]) return {
+		code: "unexpected",
+		pos: r.index,
+		length: 1,
+		name: r[4]
+	};
+	return t.push({
+		t: "end",
+		v: "",
+		pos: e.length
+	}), t;
+}
+function n(e, t) {
+	let n = Array.from({ length: e.length + 1 }, (e, n) => [n, ...Array(t.length).fill(0)]);
+	for (let e = 1; e <= t.length; e++) n[0][e] = e;
+	for (let r = 1; r <= e.length; r++) for (let i = 1; i <= t.length; i++) n[r][i] = Math.min(n[r - 1][i] + 1, n[r][i - 1] + 1, n[r - 1][i - 1] + (e[r - 1].toLowerCase() === t[i - 1].toLowerCase() ? 0 : 1));
+	for (let r = 2; r <= e.length; r++) for (let i = 2; i <= t.length; i++) e[r - 1] === t[i - 2] && e[r - 2] === t[i - 1] && (n[r][i] = Math.min(n[r][i], n[r - 2][i - 2] + 1));
+	return n[e.length][t.length];
+}
+function r(e, t) {
+	let r, i = Math.min(2, Math.max(1, Math.floor(e.length / 3)));
+	for (let a of t) {
+		let t = n(e, a);
+		t <= i && (i = t, r = a);
+	}
+	return r;
+}
+var i = class extends Error {
+	error;
+	constructor(e) {
+		super(e.code), this.error = e;
+	}
+};
+function a(n, a = {}, o = {}) {
+	let s = Object.assign(Object.create(null), e, o), c = t(n);
+	if (!Array.isArray(c)) return {
+		ok: !1,
+		error: c
+	};
+	if (c.length === 1) return {
+		ok: !1,
+		error: {
+			code: "empty",
+			pos: 0,
+			length: 0
+		}
+	};
+	let l = 0, u = () => c[l], d = () => c[l++], f = (e) => {
+		throw new i(e);
+	}, p = (e, t, n = {}) => f({
+		code: t,
+		pos: e.pos,
+		length: Math.max(1, e.v.length),
+		name: e.v || void 0,
+		...n
+	}), m = (e, t) => Number.isFinite(e) ? e : p(t, "not-finite");
+	function h() {
+		let e = g();
+		for (; u().t === "op" && (u().v === "+" || u().v === "-");) {
+			let t = d().v, n = g();
+			e = t === "+" ? e + n : e - n;
+		}
+		return e;
+	}
+	function g() {
+		let e = _();
+		for (; u().t === "op" && (u().v === "*" || u().v === "/");) {
+			let t = d(), n = _();
+			t.v === "/" && n === 0 && p(t, "divide-by-zero"), e = t.v === "*" ? e * n : e / n;
+		}
+		return e;
+	}
+	function _() {
+		if (u().t === "op" && (u().v === "-" || u().v === "+")) {
+			let e = d().v, t = _();
+			return e === "-" ? -t : t;
+		}
+		return v();
+	}
+	function v() {
+		let e = y();
+		if (u().t === "op" && u().v === "^") {
+			let t = d();
+			return m(e ** _(), t);
+		}
+		return e;
+	}
+	function y() {
+		let e = d();
+		if (e.t === "num") return Number(e.v);
+		if (e.t === "id") {
+			if (u().t === "op" && u().v === "(") {
+				d();
+				let t = [];
+				if (u().t !== "op" || u().v !== ")") do
+					t.push(h());
+				while (u().t === "op" && u().v === "," && d());
+				(u().t !== "op" || u().v !== ")") && p(u(), "unclosed"), d();
+				let n = Object.hasOwn(s, e.v) ? s[e.v] : void 0;
+				return n ? !t.length && n.length > 0 ? p(e, "arity") : m(n(...t), e) : p(e, "unknown-function", { suggestion: r(e.v, Object.keys(s)) });
+			}
+			return Object.hasOwn(a, e.v) ? a[e.v] : p(e, "unknown-variable", { suggestion: r(e.v, Object.keys(a)) });
+		}
+		if (e.t === "op" && e.v === "(") {
+			let e = h();
+			return (u().t !== "op" || u().v !== ")") && p(u(), "unclosed"), d(), e;
+		}
+		return p(e, (e.t, "unexpected"));
+	}
+	try {
+		let e = h();
+		return u().t !== "end" && p(u(), "unexpected"), {
+			ok: !0,
+			value: m(e, c[0])
+		};
+	} catch (e) {
+		if (e instanceof i) return {
+			ok: !1,
+			error: e.error
+		};
+		throw e;
+	}
+}
+function o(e) {
+	let n = t(e);
+	return Array.isArray(n) ? [...new Set(n.filter((e, t) => e.t === "id" && (n[t + 1]?.t !== "op" || n[t + 1]?.v !== "(")).map((e) => e.v))] : [];
+}
+//#endregion
+export { e as builtins, r as closest, a as evaluate, o as usedNames };

package/dist/composables/graph.d.ts

@@ -0,0 +1,19 @@
+export interface GraphEdge {
+    from: string;
+    to: string;
+    label?: string;
+}
+export declare const edgeKey: (e: Pick<GraphEdge, "from" | "to">) => string;
+/** True when `target` can be reached from `start` by following edges forward. */
+export declare function reaches(edges: readonly GraphEdge[], start: string, target: string): boolean;
+/** Why `from -> to` cannot be added, or null when it can. */
+export declare function linkProblem(edges: readonly GraphEdge[], from: string, to: string, acyclic?: boolean): "self" | "exists" | "cycle" | null;
+/** A smooth S-curve from an output port at `a` to an input port at `b`. */
+export declare function edgePath(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}): string;
+export declare const snapTo: (v: number, grid: number) => number;

package/dist/composables/graph.js

@@ -0,0 +1,16 @@
+//#region src/composables/graph.ts
+var e = (e) => `${e.from}->${e.to}`;
+function t(e, t, n) {
+	let r = /* @__PURE__ */ new Set(), i = (t) => t === n || !r.has(t) && (r.add(t), e.some((e) => e.from === t && i(e.to)));
+	return i(t);
+}
+function n(e, n, r, i = !1) {
+	return n === r ? "self" : e.some((e) => e.from === n && e.to === r) ? "exists" : i && t(e, r, n) ? "cycle" : null;
+}
+function r(e, t) {
+	let n = Math.max(48, Math.abs(t.x - e.x) / 2);
+	return `M${e.x} ${e.y}C${e.x + n} ${e.y} ${t.x - n} ${t.y} ${t.x} ${t.y}`;
+}
+var i = (e, t) => t > 0 ? Math.round(e / t) * t : e;
+//#endregion
+export { e as edgeKey, r as edgePath, n as linkProblem, t as reaches, i as snapTo };

package/dist/composables/radial.d.ts

@@ -0,0 +1,15 @@
+/** Offset of item `i` of `n` from the centre, laid out clockwise from the top. */
+export declare function polar(i: number, n: number, radius: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Which of `n` sectors a point (dx, dy from the centre) lies in, sector 0 centred on the top;
+ * `null` inside the `dead` radius, where nothing is aimed at yet.
+ */
+export declare function sectorAt(dx: number, dy: number, n: number, dead?: number): number | null;
+/** Centre moved so a circle of `half` px stays `pad` inside a `w` x `h` box. */
+export declare function keepInside(x: number, y: number, half: number, w: number, h: number, pad?: number): {
+    x: number;
+    y: number;
+};

package/dist/composables/radial.js

@@ -0,0 +1,22 @@
+//#region src/composables/radial.ts
+function e(e, t, n) {
+	let r = e / t * 2 * Math.PI - Math.PI / 2;
+	return {
+		x: Math.round(Math.cos(r) * n * 100) / 100,
+		y: Math.round(Math.sin(r) * n * 100) / 100
+	};
+}
+function t(e, t, n, r = 24) {
+	if (!n || Math.hypot(e, t) < r) return null;
+	let i = (Math.atan2(t, e) + Math.PI / 2 + 2 * Math.PI) % (2 * Math.PI);
+	return Math.round(i / (2 * Math.PI) * n) % n;
+}
+function n(e, t, n, r, i, a = 8) {
+	let o = n + a;
+	return {
+		x: Math.min(Math.max(e, o), Math.max(o, r - o)),
+		y: Math.min(Math.max(t, o), Math.max(o, i - o))
+	};
+}
+//#endregion
+export { n as keepInside, e as polar, t as sectorAt };

package/dist/composables/schedule.d.ts

@@ -0,0 +1,27 @@
+/** An event on one day. `start` and `end` are minutes after midnight, local time, `start < end`. */
+export interface ScheduleEvent {
+    id: string;
+    title: string;
+    /** `YYYY-MM-DD` */
+    date: string;
+    start: number;
+    end: number;
+}
+export declare const snapTo: (m: number, step: number) => number;
+/** `540` -> "09:00" (24 h), or the locale's style with `locale`. */
+export declare function fmtTime(minutes: number, locale?: string): string;
+/** The first day of the week (`weekStart` 0 = Sunday, 1 = Monday) that contains `iso`. */
+export declare function weekOf(iso: string, weekStart: 0 | 1): string;
+/**
+ * Side-by-side columns for events that overlap: an event gets a `lane` (0, 1, …) and the number of
+ * `lanes` its cluster of overlapping events needs, so each is drawn `1 / lanes` wide.
+ */
+export declare function layoutDay(events: readonly ScheduleEvent[]): Map<string, {
+    lane: number;
+    lanes: number;
+}>;
+/** `e` shifted by `minutes` and `days`, keeping its length and staying inside [lo, hi]. */
+export declare function moveEvent(e: ScheduleEvent, minutes: number, days: number, lo: number, hi: number): ScheduleEvent;
+/** `e` with its end moved by `minutes`: at least `min` long, and not past `hi`. */
+export declare function resizeEvent(e: ScheduleEvent, minutes: number, min: number, hi: number): ScheduleEvent;
+export declare function nextEventId(events: readonly ScheduleEvent[]): string;

package/dist/composables/schedule.js

@@ -0,0 +1,54 @@
+import { addDays as e, fromISO as t, toISO as n } from "./date.js";
+//#region src/composables/schedule.ts
+var r = (e, t) => Math.round(e / t) * t, i = (e, t, n) => Math.min(n, Math.max(t, e));
+function a(e, t) {
+	let n = new Date(2e3, 0, 1, Math.floor(e / 60) % 24, e % 60);
+	return t ? new Intl.DateTimeFormat(t, {
+		hour: "numeric",
+		minute: "2-digit"
+	}).format(n) : `${String(n.getHours()).padStart(2, "0")}:${String(n.getMinutes()).padStart(2, "0")}`;
+}
+function o(r, i) {
+	let a = t(r);
+	return n(e(a, -((a.getDay() - i + 7) % 7)));
+}
+function s(e) {
+	let t = /* @__PURE__ */ new Map(), n = [...e].sort((e, t) => e.start - t.start || e.end - t.end), r = [], i = [], a = -Infinity, o = () => {
+		for (let e of r) t.set(e.id, {
+			lane: e.lane,
+			lanes: i.length
+		});
+		r = [], i = [];
+	};
+	for (let e of n) {
+		e.start >= a && o();
+		let t = i.findIndex((t) => t <= e.start);
+		t < 0 && (t = i.length), i[t] = e.end, r.push({
+			id: e.id,
+			lane: t
+		}), a = Math.max(a, e.end);
+	}
+	return o(), t;
+}
+function c(r, a, o, s, c) {
+	let l = r.end - r.start, u = i(r.start + a, s, Math.max(s, c - l));
+	return {
+		...r,
+		date: o ? n(e(t(r.date), o)) : r.date,
+		start: u,
+		end: u + l
+	};
+}
+function l(e, t, n, r) {
+	return {
+		...e,
+		end: i(e.end + t, e.start + n, Math.max(e.start + n, r))
+	};
+}
+function u(e) {
+	let t = new Set(e.map((e) => e.id)), n = 1;
+	for (; t.has(`e${n}`);) n++;
+	return `e${n}`;
+}
+//#endregion
+export { a as fmtTime, s as layoutDay, c as moveEvent, u as nextEventId, l as resizeEvent, r as snapTo, o as weekOf };

package/dist/composables/shortcut.d.ts

@@ -0,0 +1,12 @@
+/** is this key just a modifier being held? */
+export declare const isModifierKey: (e: Pick<KeyboardEvent, "key">) => boolean;
+/**
+ * The combo a key event stands for, e.g. `Ctrl+Shift+K`, modifiers in a fixed order. Letters and
+ * digits come from the physical key (`code`), so Shift+1 is `Shift+1`, not `Shift+!`.
+ * Returns `null` while only modifiers are down.
+ */
+export declare function shortcutFromEvent(e: Pick<KeyboardEvent, "key" | "code" | "ctrlKey" | "altKey" | "shiftKey" | "metaKey">): string | null;
+/** does `e` press exactly the combo `combo`? */
+export declare const matchShortcut: (combo: string, e: KeyboardEvent) => boolean;
+/** the parts of a combo, for display: `"Ctrl+K"` → `["Ctrl", "K"]` (a literal "+" key survives) */
+export declare const splitShortcut: (combo: string) => string[];

package/dist/composables/shortcut.js

@@ -0,0 +1,35 @@
+//#region src/composables/shortcut.ts
+var e = [
+	"Ctrl",
+	"Alt",
+	"Shift",
+	"Meta"
+], t = {
+	" ": "Space",
+	ArrowUp: "↑",
+	ArrowDown: "↓",
+	ArrowLeft: "←",
+	ArrowRight: "→",
+	Escape: "Esc",
+	Delete: "Del"
+}, n = (e) => [
+	"Control",
+	"Alt",
+	"Shift",
+	"Meta",
+	"AltGraph",
+	"OS"
+].includes(e.key);
+function r(r) {
+	if (n(r)) return null;
+	let i = /^(?:Key|Digit)(.)$/.exec(r.code), a = i ? i[1] : t[r.key] ?? (r.key.length === 1 ? r.key.toUpperCase() : r.key), o = [
+		r.ctrlKey && "Ctrl",
+		r.altKey && "Alt",
+		r.shiftKey && "Shift",
+		r.metaKey && "Meta"
+	];
+	return [...e.filter((e, t) => o[t]), a].join("+");
+}
+var i = (e, t) => r(t) === e, a = (e) => e.endsWith("++") ? [...e.slice(0, -2).split("+").filter(Boolean), "+"] : e.split("+");
+//#endregion
+export { n as isModifierKey, i as matchShortcut, r as shortcutFromEvent, a as splitShortcut };

package/dist/composables/treemap.d.ts

@@ -0,0 +1,23 @@
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface TreemapNode {
+    id: string;
+    label: string;
+    /** a leaf's size; a node with `children` is the sum of them */
+    value?: number;
+    children?: TreemapNode[];
+    /** a token name (`chart-2`, `success`…) or any CSS colour; children inherit it */
+    color?: string;
+}
+export declare const totalOf: (n: TreemapNode) => number;
+/**
+ * Squarified treemap (Bruls, Huijsmans, van Wijk): tiles whose areas are proportional to
+ * `values`, kept close to square so they stay readable. Rects come back in the input order.
+ */
+export declare function squarify(values: readonly number[], w: number, h: number): Rect[];
+/** The tile in direction `dir` from tile `from`: the nearest centre that lies that way. */
+export declare function neighbour(rects: readonly Rect[], from: number, dir: "left" | "right" | "up" | "down"): number;

package/dist/composables/treemap.js

@@ -0,0 +1,77 @@
+//#region src/composables/treemap.ts
+var e = (t) => t.children?.length ? t.children.reduce((t, n) => t + e(n), 0) : Math.max(0, t.value ?? 0);
+function t(e, t, n) {
+	let r = e.map(() => ({
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	})), i = e.reduce((e, t) => e + Math.max(0, t), 0);
+	if (!i || t <= 0 || n <= 0) return r;
+	let a = e.map((e, t) => t).sort((t, n) => e[n] - e[t]), o = a.map((r) => Math.max(0, e[r]) / i * t * n), s = [...r], c = {
+		x: 0,
+		y: 0,
+		w: t,
+		h: n
+	}, l = (e, t) => {
+		let n = e.reduce((e, t) => e + t, 0), r = Math.min(...e), i = Math.max(...e);
+		return Math.max(t * t * i / (n * n), n * n / (t * t * r));
+	}, u = (e, t) => {
+		let n = t.reduce((e, t) => e + t, 0);
+		if (c.w >= c.h) {
+			let r = n / c.h, i = c.y;
+			t.forEach((t, n) => {
+				let o = t / r;
+				s[a[e + n]] = {
+					x: c.x,
+					y: i,
+					w: r,
+					h: o
+				}, i += o;
+			}), c = {
+				x: c.x + r,
+				y: c.y,
+				w: c.w - r,
+				h: c.h
+			};
+		} else {
+			let r = n / c.w, i = c.x;
+			t.forEach((t, n) => {
+				let o = t / r;
+				s[a[e + n]] = {
+					x: i,
+					y: c.y,
+					w: o,
+					h: r
+				}, i += o;
+			}), c = {
+				x: c.x,
+				y: c.y + r,
+				w: c.w,
+				h: c.h - r
+			};
+		}
+	}, d = 0, f = [];
+	for (let e = 0; e < o.length; e++) {
+		let t = o[e];
+		if (!t) continue;
+		let n = Math.min(c.w, c.h);
+		!f.length || l([...f, t], n) <= l(f, n) ? f.push(t) : (u(d, f), d = e, f = [t]);
+	}
+	return f.length && u(d, f), s;
+}
+function n(e, t, n) {
+	let r = (e) => ({
+		x: e.x + e.w / 2,
+		y: e.y + e.h / 2
+	}), i = r(e[t]), a = -1, o = Infinity;
+	return e.forEach((e, s) => {
+		if (s === t || !e.w) return;
+		let c = r(e), l = c.x - i.x, u = c.y - i.y, d = n === "left" ? -l : n === "right" ? l : n === "up" ? -u : u;
+		if (d <= 0) return;
+		let f = d + Math.abs(n === "left" || n === "right" ? u : l) * 2;
+		f < o && (o = f, a = s);
+	}), a < 0 ? t : a;
+}
+//#endregion
+export { n as neighbour, t as squarify, e as totalOf };

package/dist/composables/useAutoScroll.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pixels to scroll per frame for a pointer at `pos` on an axis running from `min` to `max`:
+ * 0 in the middle, growing to ±`top` as it nears either end (negative = toward `min`).
+ */
+export declare function edgeSpeed(pos: number, min: number, max: number, edge?: number, top?: number): number;
+/**
+ * While a drag is held near the edge of `box` (sideways) or of the window (up and down), keep
+ * scrolling it; `onScroll` fires after each nudge so the drop target can be worked out again.
+ * Call `point` from the pointer-move handler, `start` on grab and `stop` on drop or cancel.
+ */
+export declare function useAutoScroll(box: () => HTMLElement | null | undefined, onScroll: () => void): {
+    point(px: number, py: number): void;
+    start(): void;
+    stop(): void;
+};