blessing-ui 0.2.0 → 0.3.0

package/dist/composables/annotate.js

@@ -0,0 +1,33 @@
+//#region src/composables/annotate.ts
+var e = .02, t = (e) => e.w != null && e.h != null, n = (e, t, n) => Math.min(n, Math.max(t, e)), r = (e) => Math.round(e * 1e4) / 1e4;
+function i(e, t) {
+	let i = n(Math.min(e.x, t.x), 0, 1), a = n(Math.min(e.y, t.y), 0, 1), o = n(Math.max(e.x, t.x), 0, 1), s = n(Math.max(e.y, t.y), 0, 1);
+	return {
+		x: r(i),
+		y: r(a),
+		w: r(o - i),
+		h: r(s - a)
+	};
+}
+function a(e, t, i) {
+	let a = e.w ?? 0, o = e.h ?? 0;
+	return {
+		...e,
+		x: r(n(e.x + t, 0, 1 - a)),
+		y: r(n(e.y + i, 0, 1 - o))
+	};
+}
+function o(i, a, o) {
+	return t(i) ? {
+		...i,
+		w: r(n(i.w + a, e, 1 - i.x)),
+		h: r(n(i.h + o, e, 1 - i.y))
+	} : i;
+}
+function s(e) {
+	let t = new Set(e.map((e) => e.id)), n = 1;
+	for (; t.has(`r${n}`);) n++;
+	return `r${n}`;
+}
+//#endregion
+export { e as MIN_SIDE, i as boxFrom, t as isBox, a as moveRegion, s as nextId, o as resizeRegion };

package/dist/composables/canvasView.d.ts

@@ -0,0 +1,21 @@
+export interface CanvasView {
+    /** where the world's origin sits inside the viewport, px */
+    x: number;
+    y: number;
+    zoom: number;
+}
+export declare const clampZoom: (z: number, min: number, max: number) => number;
+/** The world point under a viewport point (px relative to the viewport's top-left). */
+export declare const toWorld: (v: CanvasView, px: number, py: number) => {
+    x: number;
+    y: number;
+};
+/** Zoom by `factor` keeping the world point under (`px`, `py`) where it is. */
+export declare function zoomAt(v: CanvasView, factor: number, px: number, py: number, min: number, max: number): CanvasView;
+/** The view that shows a world rectangle centred in a viewport of `w` × `h`, with `pad` px around. */
+export declare function fitRect(r: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, w: number, h: number, min: number, max: number, pad?: number): CanvasView;

package/dist/composables/canvasView.js

@@ -0,0 +1,23 @@
+//#region src/composables/canvasView.ts
+var e = (e, t, n) => Math.min(n, Math.max(t, e)), t = (e, t, n) => ({
+	x: (t - e.x) / e.zoom,
+	y: (n - e.y) / e.zoom
+});
+function n(t, n, r, i, a, o) {
+	let s = e(t.zoom * n, a, o), c = s / t.zoom;
+	return {
+		zoom: s,
+		x: r - (r - t.x) * c,
+		y: i - (i - t.y) * c
+	};
+}
+function r(t, n, r, i, a, o = 32) {
+	let s = e(Math.min((n - o * 2) / (t.width || 1), (r - o * 2) / (t.height || 1)), i, a);
+	return {
+		zoom: s,
+		x: (n - t.width * s) / 2 - t.x * s,
+		y: (r - t.height * s) / 2 - t.y * s
+	};
+}
+//#endregion
+export { e as clampZoom, r as fitRect, t as toWorld, n as zoomAt };

package/dist/composables/confetti.d.ts

@@ -0,0 +1,32 @@
+export interface Particle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    size: number;
+    rot: number;
+    vr: number;
+    color: string;
+    round: boolean;
+    /** 0..1 of its life left; fades out over the last part */
+    life: number;
+}
+export interface BurstOptions {
+    count: number;
+    /** viewport px */
+    origin: {
+        x: number;
+        y: number;
+    };
+    /** where the burst points, degrees, 0 = right, 270 = up */
+    angle: number;
+    /** total width of the cone, degrees */
+    spread: number;
+    /** px per second at launch (the strongest piece) */
+    power: number;
+    colors: string[];
+}
+/** The pieces of one burst; `rand` is injected so a test can fix it. */
+export declare function burst(o: BurstOptions, rand?: () => number): Particle[];
+/** Advance a piece by `dt` seconds: gravity pulls down, the air slows it, it fades near the end. */
+export declare function step(p: Particle, dt: number, gravity: number, lifetime: number): void;

package/dist/composables/confetti.js

@@ -0,0 +1,23 @@
+//#region src/composables/confetti.ts
+function e(e, t = Math.random) {
+	return Array.from({ length: e.count }, (n, r) => {
+		let i = (e.angle + (t() - .5) * e.spread) * Math.PI / 180, a = e.power * (.45 + t() * .55);
+		return {
+			x: e.origin.x,
+			y: e.origin.y,
+			vx: Math.cos(i) * a,
+			vy: Math.sin(i) * a,
+			size: 5 + t() * 6,
+			rot: t() * Math.PI * 2,
+			vr: (t() - .5) * 12,
+			color: e.colors[r % e.colors.length],
+			round: t() < .3,
+			life: 1
+		};
+	});
+}
+function t(e, t, n, r) {
+	e.vx *= 1 - 1.6 * t, e.vy = e.vy * (1 - 1.6 * t) + n * t, e.x += e.vx * t, e.y += e.vy * t, e.rot += e.vr * t, e.life -= t / r;
+}
+//#endregion
+export { e as burst, t as step };

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/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/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/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;
+};

package/dist/composables/useAutoScroll.js

@@ -0,0 +1,32 @@
+//#region src/composables/useAutoScroll.ts
+function e(e, t, n, r = 48, i = 18) {
+	return n - t < r * 2 ? 0 : e < t + r ? -Math.min(i, Math.ceil((t + r - e) / r * i)) : e > n - r ? Math.min(i, Math.ceil((e - (n - r)) / r * i)) : 0;
+}
+function t(t, n) {
+	let r = 0, i = 0, a = 0, o = () => {
+		let s = !1, c = t();
+		if (c) {
+			let t = c.getBoundingClientRect(), n = e(i, t.left, t.right), r = c.scrollLeft;
+			n && (c.scrollLeft += n), s ||= c.scrollLeft !== r;
+		}
+		let l = e(a, 0, window.innerHeight);
+		if (l) {
+			let e = window.scrollY;
+			window.scrollBy(0, l), s ||= window.scrollY !== e;
+		}
+		s && n(), r = requestAnimationFrame(o);
+	};
+	return {
+		point(e, t) {
+			i = e, a = t;
+		},
+		start() {
+			cancelAnimationFrame(r), r = requestAnimationFrame(o);
+		},
+		stop() {
+			cancelAnimationFrame(r), r = 0;
+		}
+	};
+}
+//#endregion
+export { e as edgeSpeed, t as useAutoScroll };