@ixfx/components 0.3.1 → 0.4.0

package/dist/{xy-axis-DL0tfJDr.js → xy-axis-CK64haaK.js}

@@ -1,10 +1,487 @@
-import { n as safeCustomElement, t as __decorate } from "./decorate-D7rC1gLP.js";
-import { A as isPoint3d, C as guard$3, D as isNull, E as isNaN$1, M as __exportAll$2, O as isPlaceholder, S as toString, T as isEmpty$1, _ as getTwoPointParameters, a as Unit3d, b as to3d, c as angleRadianThreePoint, d as fromCartesian, f as rotate, g as getPointParameter$1, h as distance2d, i as Unit, j as test, k as isPoint, l as average$1, m as distance, n as Empty$1, o as angleRadian, p as toCartesian$1, r as Empty3d, s as angleRadianCircle, t as colour_exports, u as averager, v as subtract, w as guardNonZeroPoint, x as toIntegerValues, y as to2d } from "./colour-C3MQIjFJ-BLXg8W3U.js";
-import { C as resultThrow, S as percentTest, _ as functionTest, c as round, f as wrap, l as scale, o as quantiseEvery, r as dotProduct, s as rangeStream, t as clamp, w as stringTest, x as numberTest } from "./dist-TAGYwaju.js";
-import { c as isEqualDefault, n as intervalToMs, s as getOrGenerateSync, t as continuously } from "./dist-BX0OVIm7.js";
+import { n as safeCustomElement, t as __decorate } from "./decorate-DdjvVHS-.js";
+import { a as radiansNormalise, c as isEmpty$1, d as isPlaceholder, f as isPoint, i as piPi$1, l as isNaN$1, m as pointTest, n as average$1, o as guard$2, p as isPoint3d, r as averager, s as guardNonZeroPoint, t as colour_exports, u as isNull } from "./colour-C3MQIjFJ-vRCdr8W-.js";
+import { C as resultThrow, S as percentTest, _ as functionTest, c as round, f as wrap, l as scale, o as quantiseEvery, r as dotProduct, s as rangeStream, t as clamp, v as integerTest, w as stringTest, x as numberTest } from "./dist-CA13FvMn.js";
 import { LitElement, css, html, svg } from "lit";
 import { property, state } from "lit/decorators.js";
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/max-NDZ04wx6.js
+import { repeat } from "lit/directives/repeat.js";
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/chunk-pbuEa-1d.js
+var __defProp$2 = Object.defineProperty;
+var __exportAll$2 = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp$2(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp$2(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/to-oKNQeMO-.js
+function getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6) {
+	if (isPoint3d(a1) && isPoint3d(ab2)) return [a1, ab2];
+	if (isPoint(a1) && isPoint(ab2)) return [a1, ab2];
+	if (isPoint3d(a1)) {
+		const b = {
+			x: ab2,
+			y: ab3,
+			z: ab4
+		};
+		if (!isPoint3d(b)) throw new Error(`Expected x, y & z parameters`);
+		return [a1, b];
+	}
+	if (isPoint(a1)) {
+		const b = {
+			x: ab2,
+			y: ab3
+		};
+		if (!isPoint(b)) throw new Error(`Expected x & y parameters`);
+		return [a1, b];
+	}
+	if (typeof ab5 !== `undefined` && typeof ab4 !== `undefined`) {
+		const a = {
+			x: a1,
+			y: ab2,
+			z: ab3
+		};
+		const b = {
+			x: ab4,
+			y: ab5,
+			z: ab6
+		};
+		if (!isPoint3d(a)) throw new Error(`Expected x,y,z for first point`);
+		if (!isPoint3d(b)) throw new Error(`Expected x,y,z for second point`);
+		return [a, b];
+	}
+	const a = {
+		x: a1,
+		y: ab2
+	};
+	const b = {
+		x: ab3,
+		y: ab4
+	};
+	if (!isPoint(a)) throw new Error(`Expected x,y for first point`);
+	if (!isPoint(b)) throw new Error(`Expected x,y for second point`);
+	return [a, b];
+}
+/**
+* Returns a Point form of either a point, x,y params or x,y,z params.
+* If parameters are undefined, an empty point is returned (0, 0)
+* @ignore
+* @param a
+* @param b
+* @returns
+*/
+function getPointParameter$1(a, b, c) {
+	if (a === void 0) return {
+		x: 0,
+		y: 0
+	};
+	if (Array.isArray(a)) {
+		if (a.length === 0) return Object.freeze({
+			x: 0,
+			y: 0
+		});
+		if (a.length === 1) return Object.freeze({
+			x: a[0],
+			y: 0
+		});
+		if (a.length === 2) return Object.freeze({
+			x: a[0],
+			y: a[1]
+		});
+		if (a.length === 3) return Object.freeze({
+			x: a[0],
+			y: a[1],
+			z: a[2]
+		});
+		throw new Error(`Expected array to be 1-3 elements in length. Got ${a.length}.`);
+	}
+	if (isPoint(a)) return a;
+	else if (typeof a !== `number` || typeof b !== `number`) throw new TypeError(`Expected point or x,y as parameters. Got: a: ${JSON.stringify(a)} b: ${JSON.stringify(b)}`);
+	if (typeof c === `number`) return Object.freeze({
+		x: a,
+		y: b,
+		z: c
+	});
+	return Object.freeze({
+		x: a,
+		y: b
+	});
+}
+/**
+* Calculate distance between two points.
+* If both points have a `z` property, the distance is 3D distance is calculated.
+* If only one point has a `z`, it is ignored. To force 2D distance, use {@link distance2d}
+*
+* ```js
+* // Distance between two points
+* const ptA = { x: 0.5, y:0.8 };
+* const ptB = { x: 1, y: 0.4 };
+* distance(ptA, ptB);
+* // Or, provide x,y as parameters
+* distance(ptA, 0.4, 0.9);
+*
+* // Distance from ptA to x: 0.5, y:0.8, z: 0.1
+* const ptC = { x: 0.5, y:0.5, z: 0.3 };
+* // With x,y,z as parameters:
+* distance(ptC, 0.5, 0.8, 0.1);
+* ```
+* @param a First point
+* @param xOrB Second point, or x coord
+* @param y y coord, if x coord is given
+* @param z Optional z coord, if x and y are given.
+* @returns
+*/
+function distance(a, xOrB, y, z) {
+	const pt = getPointParameter$1(xOrB, y, z);
+	guard$2(pt, `b`);
+	guard$2(a, `a`);
+	return isPoint3d(pt) && isPoint3d(a) ? Math.hypot(pt.x - a.x, pt.y - a.y, pt.z - a.z) : Math.hypot(pt.x - a.x, pt.y - a.y);
+}
+/**
+* As {@link distance} but always compares by x,y only.
+* @param a
+* @param xOrB 
+* @param y
+* @returns 
+*/
+function distance2d(a, xOrB, y) {
+	const pt = getPointParameter$1(xOrB, y);
+	guard$2(pt, `b`);
+	guard$2(a, `a`);
+	return Math.hypot(pt.x - a.x, pt.y - a.y);
+}
+/**
+* Returns a Point with the x,y,z values of two points subtracted (a-b).
+* 
+* `z` parameter is used if present. Uses a default value of 0 for 'z' when subtracting a 2D point with a 3D one.
+*
+* Examples:
+*
+* ```js
+* subtract(ptA, ptB);
+* subtract(x1, y1, x2, y2);
+* subtract(ptA, x2, y2);
+* ```
+*/
+function subtract(a1, ab2, ab3, ab4, ab5, ab6) {
+	const [ptA, ptB] = getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6);
+	guard$2(ptA, `a`);
+	guard$2(ptB, `b`);
+	const pt = {
+		x: ptA.x - ptB.x,
+		y: ptA.y - ptB.y
+	};
+	if (isPoint3d(ptA) || isPoint3d(ptB)) pt.z = (ptA.z ?? 0) - (ptB.z ?? 0);
+	return Object.freeze(pt);
+}
+/**
+* Returns a point with rounded x,y coordinates. By default uses `Math.round` to round.
+* ```js
+* toIntegerValues({x:1.234, y:5.567}); // Yields: {x:1, y:6}
+* ```
+*
+* ```js
+* toIntegerValues(pt, Math.ceil); // Use Math.ceil to round x,y of `pt`.
+* ```
+* @param pt Point to round
+* @param rounder Rounding function, or Math.round by default
+* @returns
+*/
+const toIntegerValues = (pt, rounder = Math.round) => {
+	guard$2(pt, `pt`);
+	return Object.freeze({
+		x: rounder(pt.x),
+		y: rounder(pt.y)
+	});
+};
+/**
+* Returns a copy of `pt` with `z` field omitted.
+* If it didn't have one to begin within, a copy is still returned.
+* @param pt 
+* @returns 
+*/
+const to2d = (pt) => {
+	guard$2(pt, `pt`);
+	let copy = { ...pt };
+	delete copy.z;
+	return Object.freeze(copy);
+};
+/**
+* Returns a copy of `pt` with a `z` field set.
+* Defaults to a z value of 0.
+* @param pt Point
+* @param z Z-value, defaults to 0
+* @returns 
+*/
+const to3d = (pt, z = 0) => {
+	guard$2(pt, `pt`);
+	return Object.freeze({
+		...pt,
+		z
+	});
+};
+/**
+* Returns a human-friendly string representation `(x, y)`.
+* If `precision` is supplied, this will be the number of significant digits.
+* @param p
+* @returns
+*/
+function toString(p, digits) {
+	if (p === void 0) return `(undefined)`;
+	if (p === null) return `(null)`;
+	guard$2(p, `pt`);
+	const x = digits ? p.x.toFixed(digits) : p.x;
+	const y = digits ? p.y.toFixed(digits) : p.y;
+	if (p.z === void 0) return `(${x},${y})`;
+	else return `(${x},${y},${digits ? p.z.toFixed(digits) : p.z})`;
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/polar-ZdU4ci-4.js
+/**
+* Returns true if `p` seems to be a {@link Polar.Coord} (ie has both distance & angleRadian fields)
+* @param p
+* @returns True if `p` seems to be a PolarCoord
+*/
+const isPolarCoord = (p) => {
+	if (p.distance === void 0) return false;
+	if (p.angleRadian === void 0) return false;
+	return true;
+};
+/**
+* Returns a rotated coordinate
+* @param c Coordinate
+* @param amountRadian Amount to rotate, in radians
+* @returns
+*/
+const rotate = (c, amountRadian) => Object.freeze({
+	...c,
+	angleRadian: c.angleRadian + amountRadian
+});
+/**
+* An empty point of `{ x: 0, y: 0 }`.
+*
+* Use `isEmpty` to check if a point is empty.
+* Use `Empty3d` to get an empty point with `z`.
+*/
+const Empty$1 = {
+	x: 0,
+	y: 0
+};
+/**
+* Returns { x:1, y:1 }
+*/
+const Unit = {
+	x: 1,
+	y: 1
+};
+/**
+* An empty Point of `{ x: 0, y: 0, z: 0}`
+* Use `isEmpty` to check if a point is empty.
+* Use `Empty` to get an empty point without `z`.
+*/
+const Empty3d = {
+	x: 0,
+	y: 0,
+	z: 0
+};
+/**
+* Returns { x:1,y:1,z:1 }
+*/
+const Unit3d = {
+	x: 1,
+	y: 1,
+	z: 1
+};
+/**
+* Converts to Cartesian coordinate from polar.
+*
+* ```js
+*
+* const origin = { x: 50, y: 50}; // Polar origin
+* // Yields: { x, y }
+* const polar = Polar.toCartesian({ distance: 10, angleRadian: 0 }, origin);
+* ```
+*
+* Distance and angle can be provided as numbers intead:
+*
+* ```
+* // Yields: { x, y }
+* const polar = Polar.toCartesian(10, 0, origin);
+* ```
+*
+* @param a
+* @param b
+* @param c
+* @returns
+*/
+const toCartesian$1 = (a, b, c) => {
+	if (isPolarCoord(a)) {
+		if (typeof b === `undefined`) b = Empty$1;
+		if (isPoint(b)) return polarToCartesian(a.distance, a.angleRadian, b);
+		throw new Error(`Expecting (Coord, Point). Second parameter is not a point`);
+	} else if (typeof a === `object`) throw new TypeError(`First param is an object, but not a Coord: ${JSON.stringify(a)}`);
+	else if (typeof a === `number` && typeof b === `number`) {
+		if (typeof c === `undefined`) c = Empty$1;
+		if (!isPoint(c)) throw new Error(`Expecting (number, number, Point). Point param wrong type`);
+		return polarToCartesian(a, b, c);
+	} else throw new TypeError(`Expecting parameters of (number, number). Got: (${typeof a}, ${typeof b}, ${typeof c}). a: ${JSON.stringify(a)}`);
+};
+/**
+* Converts a Cartesian coordinate to polar
+*
+* ```js
+*
+* // Yields: { angleRadian, distance }
+* const polar = Polar.fromCartesian({x: 50, y: 50}, origin);
+* ```
+*
+* Any additional properties of `point` are copied to object.
+* 
+* Options:
+* * fullCircle: If _true_ (default) returns values on 0..2PI range. If _false_, 0....PI..-PI range.
+* * digits: Rounding to apply
+* @param point Point
+* @param origin Origin. If unspecified, {x:0,y:0} is used
+* @param options Options
+* @returns
+*/
+const fromCartesian = (point, origin, options = {}) => {
+	if (typeof point !== `object`) throw new TypeError(`Param 'point' wrong. Expecting a Point, got: ${typeof point}`);
+	const fullCircle = options.fullCircle ?? true;
+	if (typeof origin === `object`) point = subtract(point, origin);
+	let angle = Math.atan2(point.y, point.x);
+	if (fullCircle) angle = radiansNormalise(angle);
+	let distance = Math.hypot(point.x, point.y);
+	if (typeof options.digits === `number`) {
+		angle = parseFloat(angle.toFixed(options.digits));
+		distance = parseFloat(distance.toFixed(options.digits));
+	}
+	const polar = {
+		...point,
+		angleRadian: angle,
+		distance
+	};
+	delete polar.x;
+	delete polar.y;
+	return Object.freeze(polar);
+};
+/**
+* Converts a polar coordinate to Cartesian
+* @param distance Distance
+* @param angleRadians Angle in radians
+* @param origin Origin, or 0,0 by default.
+* @returns
+*/
+const polarToCartesian = (distance, angleRadians, origin = Empty$1) => {
+	guard$2(origin);
+	return Object.freeze({
+		x: origin.x + distance * Math.cos(angleRadians),
+		y: origin.y + distance * Math.sin(angleRadians)
+	});
+};
+/**
+* Returns the angle in radians between `a` and `b`.
+*
+* Eg if `a` is the origin, and `b` is another point,
+* in degrees one would get 0 to -180 when `b` was above `a`.
+*  -180 would be `b` in line with `a`.
+* Same for under `a`.
+*
+* Providing a third point `c` gives the interior angle, where `b` is the middle point.
+* 
+* See also {@link angleRadianCircle} which returns coordinates on 0..Math.Pi*2
+* range. This avoids negative numbers.
+* 
+* @example Calculate angle between a middle of canvas and the cursor
+* ```js
+* const canvasEl = document.querySelector('canvas');
+* const middle = { x: canvasEl.width/2, y: canvasEl.height /2 }
+* 
+* canvasEl.addEventListener(`pointermove`, event => { 
+*  const cursor = {
+*    x: event.offsetX,
+*    y: event.offsetY
+*  }
+*  const a = G.Points.angleRadian(middle, cursor);
+*});
+* ```
+* @param a
+* @param b
+* @param c
+* @returns
+*/
+const angleRadian = (a, b, c) => {
+	guard$2(a, `a`);
+	if (b === void 0) return Math.atan2(a.y, a.x);
+	guard$2(b, `b`);
+	if (c === void 0) return Math.atan2(b.y - a.y, b.x - a.x);
+	guard$2(c, `c`);
+	return Math.atan2(b.y - a.y, b.x - a.x) - Math.atan2(c.y - a.y, c.x - a.x);
+};
+/**
+* Returns the angle between point(s) using a radian circle system.
+* ```
+*       90deg
+*       Pi/2
+*        |
+* Pi  ---+--- 0
+* 180    |
+*       3PI/2
+*       270deg
+* ```
+* @param a 
+* @param b 
+* @param c 
+* @returns 
+*/
+const angleRadianCircle = (a, b, c) => {
+	const angle = angleRadian(a, b, c);
+	if (angle < 0) return angle + piPi$1;
+	return angle;
+};
+/**
+* Return the angle of a wedge, defined by a, b and C points, where 'b'
+* could be thought of as the origin or pivot.
+* 
+* @param a 
+* @param b 
+* @param c 
+* @returns 
+*/
+const angleRadianThreePoint = (a, b, c) => {
+	const ab = Math.sqrt(Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2));
+	const bc = Math.sqrt(Math.pow(b.x - c.x, 2) + Math.pow(b.y - c.y, 2));
+	const ac = Math.sqrt(Math.pow(c.x - a.x, 2) + Math.pow(c.y - a.y, 2));
+	return Math.acos((bc * bc + ab * ab - ac * ac) / (2 * bc * ab));
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/from-points-hWl1SWEr.js
+/**
+* Returns a line from two points
+* 
+* ```js
+* // Line from 0,1 to 10,15
+* const line = Lines.fromPoints( { x:0, y:1 }, { x:10, y:15 });
+* // line is: { a: { x: 0, y: 1}, b: { x: 10, y: 15 } };
+* ```
+* @param a Start point
+* @param b End point
+* @returns 
+*/
+const fromPoints = (a, b) => {
+	guard$2(a, `a`);
+	guard$2(b, `b`);
+	a = Object.freeze({ ...a });
+	b = Object.freeze({ ...b });
+	return Object.freeze({
+		a,
+		b
+	});
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/max-NDZ04wx6.js
 /**
 * Returns a rectangle based on provided four corners.
 *
@@ -32,7 +509,7 @@ const maxFromCorners = (topLeft, topRight, bottomRight, bottomLeft) => {
 	};
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/bbox-DKUDfXRz.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/bbox-BH5rnhlc.js
 /**
 * Returns the 'minimum' point from an array of points, using a comparison function.
 *
@@ -106,31 +583,7 @@ const bbox3d = (...points) => {
 	};
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/from-points-BZ9J-ip2.js
-/**
-* Returns a line from two points
-* 
-* ```js
-* // Line from 0,1 to 10,15
-* const line = Lines.fromPoints( { x:0, y:1 }, { x:10, y:15 });
-* // line is: { a: { x: 0, y: 1}, b: { x: 10, y: 15 } };
-* ```
-* @param a Start point
-* @param b End point
-* @returns 
-*/
-const fromPoints = (a, b) => {
-	guard$3(a, `a`);
-	guard$3(b, `b`);
-	a = Object.freeze({ ...a });
-	b = Object.freeze({ ...b });
-	return Object.freeze({
-		a,
-		b
-	});
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/guard-CN6d2Djl.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/guard-Bg57Xzmd.js
 /**
 * Returns true if `p` is a valid line, containing `a` and `b` Points.
 * ```js
@@ -139,40 +592,53 @@ const fromPoints = (a, b) => {
 * @param p Value to check
 * @returns True if a valid line.
 */
-const isLine = (p) => {
+function isLine(p) {
 	if (p === void 0) return false;
 	if (p.a === void 0) return false;
 	if (p.b === void 0) return false;
 	if (!isPoint(p.a)) return false;
 	if (!isPoint(p.b)) return false;
 	return true;
-};
+}
 /**
 * Returns true if `p` is a {@link PolyLine}, ie. an array of {@link Line}s.
 * Validates all items in array.
-* @param p 
+* @param p
 * @returns
 */
-const isPolyLine = (p) => {
+function isPolyLine(p) {
 	if (!Array.isArray(p)) return false;
 	return !p.some((v) => !isLine(v));
-};
+}
 /**
-* Throws an exception if:
-* * line is undefined
-* * a or b parameters are missing
-* 
+* Returns a failure if:
+* - line is undefined
+* - a or b parameters are missing
+*
 * Does not validate points
-* @param line 
-* @param name 
+* @param line
+* @param name
 */
-const guard$2 = (line, name = `line`) => {
-	if (line === void 0) throw new Error(`${name} undefined`);
-	if (line.a === void 0) throw new Error(`${name}.a undefined. Expected {a:Point, b:Point}. Got: ${JSON.stringify(line)}`);
-	if (line.b === void 0) throw new Error(`${name}.b undefined. Expected {a:Point, b:Point} Got: ${JSON.stringify(line)}`);
-};
+function lineTest(line, name = `line`) {
+	if (line === void 0) return {
+		success: false,
+		error: `${name} undefined`
+	};
+	if (line.a === void 0) return {
+		success: false,
+		error: `${name}.a undefined. Expected {a:Point, b:Point}. Got: ${JSON.stringify(line)}`
+	};
+	if (line.b === void 0) return {
+		success: false,
+		error: `${name}.b undefined. Expected {a:Point, b:Point} Got: ${JSON.stringify(line)}`
+	};
+	return {
+		success: true,
+		value: true
+	};
+}
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/length-UXbCPu0p.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/length-ChosppvJ.js
 /**
 * Returns [a,b] points from either a line parameter, or two points.
 * It additionally applies the guardPoint function to ensure validity.
@@ -191,8 +657,8 @@ const getPointParameter = (aOrLine, b) => {
 		a = aOrLine;
 		if (b === void 0) throw new Error(`Since first parameter is not a line, two points are expected. Got a: ${JSON.stringify(a)} b: ${JSON.stringify(b)}`);
 	}
-	guard$3(a, `a`);
-	guard$3(a, `b`);
+	guard$2(a, `a`);
+	guard$2(a, `b`);
 	return [a, b];
 };
 /**
@@ -217,15 +683,14 @@ function length$1(aOrLine, pointBOrForce2d, force2d) {
 	} else return Math.hypot(x, y);
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/interpolate-DBpjKdqZ.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/interpolate-DhLKNStN.js
 /**
 * Calculates a point in-between a line's start and end points.
-* 
+*
 * @param amount Interpolation amount
 * @param aOrLine Line, or first point
 * @param pointBOrAllowOverflow Second point (if needed) or allowOverflow.
 * @param allowOverflow If true, interpolation amount is permitted to exceed 0..1, extending the line.
-* @returns 
 */
 function interpolate$1(amount, aOrLine, pointBOrAllowOverflow, allowOverflow) {
 	if (typeof pointBOrAllowOverflow === `boolean`) {
@@ -235,26 +700,47 @@ function interpolate$1(amount, aOrLine, pointBOrAllowOverflow, allowOverflow) {
 	if (!allowOverflow) resultThrow(percentTest(amount, `amount`));
 	else resultThrow(numberTest(amount, ``, `amount`));
 	const [a, b] = getPointParameter(aOrLine, pointBOrAllowOverflow);
-	const d = length$1(a, b);
-	const d2 = d * (1 - amount);
-	if (d === 0 && d2 === 0) return Object.freeze({ ...b });
-	const x = b.x - d2 * (b.x - a.x) / d;
-	const y = b.y - d2 * (b.y - a.y) / d;
-	return Object.freeze({
-		...b,
-		x,
-		y
-	});
+	return interpolator$2({
+		a,
+		b
+	}, allowOverflow)(amount);
 }
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/guard-DTK6wbGV.js
 /**
-* Throws an error if the dimensions of the rectangle are undefined, NaN or negative.
-* @param d 
-* @param name 
+* Returns a function that interpolates along `line`, returning a {@link Point}.
+* ```js
+* const i = interpolator(a: {x:0,y:0}, b:{x:100, y:100});
+* i(0.5); // Returns point 50% between a and b.
+* ```
+* @param line Line to interpolate along
+* @param allowOverflow If _true_ interpolation amount can exceed 0..1, extending the line.
 */
-const guardDim = (d, name = `Dimension`) => {
-	if (d === void 0) throw new Error(`${name} is undefined`);
+function interpolator$2(line, allowOverflow = false) {
+	resultThrow(lineTest(line));
+	const d = length$1(line);
+	const { a, b } = line;
+	return (amount) => {
+		if (!allowOverflow) resultThrow(percentTest(amount, `amount`));
+		else resultThrow(numberTest(amount, ``, `amount`));
+		const d2 = d * (1 - amount);
+		if (d === 0 && d2 === 0) return Object.freeze({ ...b });
+		const x = b.x - d2 * (b.x - a.x) / d;
+		const y = b.y - d2 * (b.y - a.y) / d;
+		return Object.freeze({
+			...b,
+			x,
+			y
+		});
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/guard-C2opUnGy.js
+/**
+* Throws an error if the dimensions of the rectangle are undefined, NaN or negative.
+* @param d 
+* @param name 
+*/
+const guardDim = (d, name = `Dimension`) => {
+	if (d === void 0) throw new Error(`${name} is undefined`);
 	if (Number.isNaN(d)) throw new Error(`${name} is NaN`);
 	if (d < 0) throw new Error(`${name} cannot be negative`);
 };
@@ -273,7 +759,7 @@ const guardDim = (d, name = `Dimension`) => {
 */
 const guard$1 = (rect, name = `rect`) => {
 	if (rect === void 0) throw new Error(`{$name} undefined`);
-	if (isPositioned$1(rect)) guard$3(rect, name);
+	if (isPositioned$1(rect)) guard$2(rect, name);
 	guardDim(rect.width, name + `.width`);
 	guardDim(rect.height, name + `.height`);
 };
@@ -312,7 +798,7 @@ const isRect = (rect) => {
 */
 const isRectPositioned = (rect) => isRect(rect) && isPositioned$1(rect);
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/from-top-left-_m03rKOS.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/from-top-left-D_I93JN9.js
 /**
 * Creates a rectangle from its top-left coordinate, a width and height.
 *
@@ -323,25 +809,24 @@ const isRectPositioned = (rect) => isRect(rect) && isPositioned$1(rect);
 * @param origin
 * @param width
 * @param height
-* @returns
 */
-const fromTopLeft = (origin, width, height) => {
+function fromTopLeft(origin, width, height) {
 	guardDim(width, `width`);
 	guardDim(height, `height`);
-	guard$3(origin, `origin`);
+	guard$2(origin, `origin`);
 	return {
 		x: origin.x,
 		y: origin.y,
 		width,
 		height
 	};
-};
+}
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/guard-C80ayJ0B.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/guard-D8jtfB4t.js
 const isQuadraticBezier = (path) => path.quadratic !== void 0;
 const isCubicBezier = (path) => path.cubic1 !== void 0 && path.cubic2 !== void 0;
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/bezier-0J_WsCxz.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/bezier-NMQ88x8M.js
 const { abs: abs$1, cos: cos$1, sin: sin$1, acos: acos$1, atan2, sqrt: sqrt$1, pow: pow$2 } = Math;
 function crt(v) {
 	return v < 0 ? -pow$2(-v, 1 / 3) : pow$2(v, 1 / 3);
@@ -1455,7 +1940,7 @@ var Bezier = class Bezier {
 		pass1.forEach(function(p1) {
 			t1 = 0;
 			t2 = 0;
-			while (t2 <= 1) for (t2 = t1 + step; t2 <= 1 + step; t2 += step) {
+			while (t2 <= 1) for (t2 = t1 + step; t2 <= 1.01; t2 += step) {
 				segment = p1.split(t1, t2);
 				if (!segment.simple()) {
 					t2 -= step;
@@ -1741,7 +2226,7 @@ var Bezier = class Bezier {
 };
 var bezier_exports = /* @__PURE__ */ __exportAll$2({
 	cubic: () => cubic,
-	interpolator: () => interpolator,
+	interpolator: () => interpolator$1,
 	isCubicBezier: () => isCubicBezier,
 	isQuadraticBezier: () => isQuadraticBezier,
 	quadratic: () => quadratic,
@@ -1806,7 +2291,7 @@ const quadraticSimple = (start, end, bend = 0) => {
 * @param q 
 * @returns 
 */
-const interpolator = (q) => {
+const interpolator$1 = (q) => {
 	const bzr = isCubicBezier(q) ? new Bezier(q.a.x, q.a.y, q.cubic1.x, q.cubic1.y, q.cubic2.x, q.cubic2.y, q.b.x, q.b.y) : new Bezier(q.a, q.quadratic, q.b);
 	return (amount) => bzr.compute(amount);
 };
@@ -1891,14 +2376,14 @@ const quadratictoPath = (quadraticBezier) => {
 	});
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/intersects-skBCWN7w.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/intersects-BOuj4lnQ.js
 /**
 * Throws if radius is out of range. If x,y is present, these will be validated too.
 * @param circle 
 * @param parameterName 
 */
 const guard = (circle, parameterName = `circle`) => {
-	if (isCirclePositioned(circle)) guard$3(circle, `circle`);
+	if (isCirclePositioned(circle)) guard$2(circle, `circle`);
 	if (Number.isNaN(circle.radius)) throw new Error(`${parameterName}.radius is NaN`);
 	if (circle.radius <= 0) throw new Error(`${parameterName}.radius must be greater than zero`);
 };
@@ -1943,8 +2428,8 @@ const isCirclePositioned = (p) => isCircle(p) && isPositioned(p);
 */
 function sum(a1, ab2, ab3, ab4, ab5, ab6) {
 	const [ptA, ptB] = getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6);
-	guard$3(ptA, `a`);
-	guard$3(ptB, `b`);
+	guard$2(ptA, `a`);
+	guard$2(ptB, `b`);
 	const pt = {
 		x: ptA.x + ptB.x,
 		y: ptA.y + ptB.y
@@ -1953,131 +2438,762 @@ function sum(a1, ab2, ab3, ab4, ab5, ab6) {
 	return Object.freeze(pt);
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/multiply-DfdMPARS.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/multiply-CwzF4Hcr.js
 /**
 * Returns the distance between two circle centers.
 * 
 * ```js
-* const circleA = { radius: 5, x: 5, y: 5 }
-* const circleB = { radius: 10, x: 20, y: 20 }
-* const distance = Circles.distanceCenter(circleA, circleB);
+* const circleA = { radius: 5, x: 5, y: 5 }
+* const circleB = { radius: 10, x: 20, y: 20 }
+* const distance = Circles.distanceCenter(circleA, circleB);
+* ```
+* Throws an error if either is lacking position.
+* @param a 
+* @param b 
+* @returns Distance
+*/
+const distanceCenter = (a, b) => {
+	guardPositioned(a, `a`);
+	if (isCirclePositioned(b)) guardPositioned(b, `b`);
+	return distance(a, b);
+};
+/**
+* Returns the distance between the exterior of two circles, or between the exterior of a circle and point.
+* If `b` overlaps or is enclosed by `a`, distance is 0.
+* 
+* ```js
+* const circleA = { radius: 5, x: 5, y: 5 }
+* const circleB = { radius: 10, x: 20, y: 20 }
+* const distance = Circles.distanceCenter(circleA, circleB);
+* ```
+* @param a
+* @param b 
+*/
+const distanceFromExterior$1 = (a, b) => {
+	guardPositioned(a, `a`);
+	if (isCirclePositioned(b)) return Math.max(0, distanceCenter(a, b) - a.radius - b.radius);
+	else if (isPoint(b)) {
+		const distribution = distance(a, b);
+		if (distribution < a.radius) return 0;
+		return distribution;
+	} else throw new Error(`Second parameter invalid type`);
+};
+/**
+* Returns a Point with the x,y,z values of two points multiply (a/b).
+* 
+* `z` parameter is used, if present. Uses a default value of 0 for 'z' when multiplying a 2D point with a 3D one.
+*
+* Examples:
+*
+* ```js
+* multiply(ptA, ptB);
+* multiply(x1, y1, x2, y2);
+* multiply(ptA, x2, y2);
+* ```
+*/
+function multiply(a1, ab2, ab3, ab4, ab5, ab6) {
+	const [ptA, ptB] = getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6);
+	guard$2(ptA, `a`);
+	guard$2(ptB, `b`);
+	const pt = {
+		x: ptA.x * ptB.x,
+		y: ptA.y * ptB.y
+	};
+	if (isPoint3d(ptA) || isPoint3d(ptB)) pt.z = (ptA.z ?? 0) * (ptB.z ?? 0);
+	return Object.freeze(pt);
+}
+/**
+* Multiplies all components by `v`.
+* Existing properties of `pt` are maintained.
+*
+* ```js
+* multiplyScalar({ x:2, y:4 }, 2);
+* // Yields: { x:4, y:8 }
+* ```
+* @param pt Point
+* @param v Value to multiply by
+* @returns
+*/
+const multiplyScalar = (pt, v) => {
+	return isPoint3d(pt) ? Object.freeze({
+		...pt,
+		x: pt.x * v,
+		y: pt.y * v,
+		z: pt.z * v
+	}) : Object.freeze({
+		...pt,
+		x: pt.x * v,
+		y: pt.y * v
+	});
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/is-equal-BS9hk_L_.js
+/**
+* Returns _true_ if the points have identical values
+*
+* ```js
+* const a = {x: 10, y: 10};
+* const b = {x: 10, y: 10;};
+* a === b        // False, because a and be are different objects
+* isEqual(a, b)   // True, because a and b are same value
+* ```
+* @param p Points
+* @returns _True_ if points are equal
+*/
+const isEqual = (...p) => {
+	if (p === void 0) throw new Error(`parameter 'p' is undefined`);
+	if (p.length < 2) return true;
+	for (let index = 1; index < p.length; index++) {
+		if (p[index].x !== p[0].x) return false;
+		if (p[index].y !== p[0].y) return false;
+	}
+	return true;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/compare-DzZYeaAF.js
+/**
+* Returns -2 if both x & y of a is less than b
+* Returns -1 if either x/y of a is less than b
+*
+* Returns 2 if both x & y of a is greater than b
+* Returns 1 if either x/y of a is greater than b's x/y
+*
+* Returns 0 if x/y of a and b are equal
+* @param a
+* @param b
+*/
+function compare(a, b) {
+	if (a.x < b.x && a.y < b.y) return -2;
+	if (a.x > b.x && a.y > b.y) return 2;
+	if (a.x < b.x || a.y < b.y) return -1;
+	if (a.x > b.x || a.y > b.y) return 1;
+	if (a.x === b.x && a.x === b.y) return 0;
+	return NaN;
+}
+/**
+* Compares points row-wise.
+*
+* A point is considered less if has a lower `y` value, or if `y` values are equal, a lower `x` value.
+*
+* Returns 0 if points are equal, -1 if a is less than b, 1 if a is greater than b.
+*
+* This can be used for sorting points in a row-wise manner, for example:
+* ```js
+* arrayOfPoints.sort(Points.compareRowwise);
+* ```
+* @param a
+* @param b
+*/
+function compareRowwise(a, b) {
+	if (a.y < b.y) return -1;
+	if (a.y > b.y) return 1;
+	if (a.x < b.x) return -1;
+	if (a.x > b.x) return 1;
+	return 0;
+}
+/**
+* Returns a rectangle from two points, where it's uncertain if
+* a/b ought to be top-left or bottom-right.
+*
+* To resolve this, we use Points.compareRowwise to determine which point is top-left and which is bottom-right.
+* @param a
+* @param b
+*/
+function getAsBounds(a, b) {
+	const topLeft = compareRowwise(a, b) <= 0 ? a : b;
+	return {
+		topLeft,
+		bottomRight: topLeft === a ? b : a
+	};
+}
+/**
+* Compares points based on x value. Y value is ignored.
+*
+* Return values:
+* 0: If a.x === b.x
+* 1: a is to the right of b (ie. a.x > b.x)
+* -1: a is to the left of b (ie. a.x < b.x)
+*
+* @example Sorting by x
+* ```js
+* arrayOfPoints.sort(Points.compareByX);
+* ```
+*
+* @param a
+* @param b
+* @returns
+*/
+function compareByX(a, b) {
+	if (a.x === b.x) return 0;
+	if (a.x < b.x) return -1;
+	return 1;
+}
+/**
+* Compares points based on Y value. X value is ignored.
+*
+* Return values:
+* 0: If a.y === b.y
+* 1: A is below B (ie. a.y > b.y)
+* -1: A is above B (ie. a.y < b.y)
+*
+* @example Sorting by Y
+* ```js
+* arrayOfPoints.sort(Points.compareByY);
+* ```
+* @param a
+* @param b
+* @returns
+*/
+function compareByY(a, b) {
+	if (a.y === b.y) return 0;
+	if (a.y < b.y) return -1;
+	return 1;
+}
+/**
+* Compares points based on Z value. XY values are ignored.
+*
+* Return values:
+* 0: If a.z === b.z
+* 1: A is below B (ie. a.z > b.z)
+* -1: A is above B (ie. a.z < b.z)
+*
+* @example Sorting by Y
+* ```js
+* arrayOfPoints.sort(Points.compareByZ);
+* ```
+* @param a
+* @param b
+* @returns
+*/
+function compareByZ(a, b) {
+	if (a.z === b.z) return 0;
+	if (a.z < b.z) return -1;
+	return 1;
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+core@0.56.13/node_modules/@ixfx/core/dist/is-equal-BOIjfI3O.js
+const removeCircularReferences = (value, replaceWith = null, seen = /* @__PURE__ */ new WeakSet(), path = ``) => {
+	if (value === null) return value;
+	if (typeof value !== `object`) throw new TypeError(`Param 'value' must be an object. Got type: ${typeof value}`);
+	seen.add(value);
+	const entries = Object.entries(value);
+	for (const entry of entries) {
+		if (entry[1] === null) continue;
+		if (typeof entry[1] !== `object`) continue;
+		if (seen.has(entry[1])) {
+			entry[1] = replaceWith;
+			continue;
+		}
+		entry[1] = removeCircularReferences(entry[1], replaceWith, seen, `${entry[0]}.`);
+	}
+	return Object.fromEntries(entries);
+};
+/**
+* A default converter to string that uses JSON.stringify if its an object, or the thing itself if it's a string
+*/
+function toStringDefault(itemToMakeStringFor) {
+	return typeof itemToMakeStringFor === `string` ? itemToMakeStringFor : JSON.stringify(itemToMakeStringFor);
+}
+/**
+* Converts a value to string form.
+* For simple objects, .toString() is used, other JSON.stringify is used.
+* It is meant for creating debugging output or 'hash' versions of objects, and does
+* not necessarily maintain full fidelity of the input
+* @param value
+* @returns
+*/
+function defaultToString(value) {
+	if (value === null) return `null`;
+	if (typeof value === `boolean` || typeof value === `number`) return value.toString();
+	if (typeof value === `string`) return value;
+	if (typeof value === `symbol`) throw new TypeError(`Symbol cannot be converted to string`);
+	try {
+		return JSON.stringify(value);
+	} catch (error) {
+		if (typeof value === `object`) return JSON.stringify(removeCircularReferences(value, `(circular)`));
+		else throw error;
+	}
+}
+/**
+* If input is a string, it is returned.
+* Otherwise, it returns the result of JSON.stringify() with fields ordered.
+*
+* This allows for more consistent comparisons when object field orders are different but values the same.
+* @param itemToMakeStringFor
+*/
+function toStringOrdered(itemToMakeStringFor) {
+	if (typeof itemToMakeStringFor === `string`) return itemToMakeStringFor;
+	const replacer = (key, value) => value instanceof Object && !Array.isArray(value) ? Object.keys(value).sort().reduce((sorted, key) => {
+		sorted[key] = value[key];
+		return sorted;
+	}, {}) : value;
+	return JSON.stringify(itemToMakeStringFor, replacer);
+}
+/**
+* Default comparer function is equiv to checking `a === b`.
+* Use {@link isEqualValueDefault} to compare by value, via comparing JSON string representation.
+*/
+const isEqualDefault = (a, b) => a === b;
+/**
+* Comparer returns true if string representation of `a` and `b` are equal.
+* Use {@link isEqualDefault} to compare using === semantics
+* Uses `toStringDefault` to generate a string representation (via `JSON.stringify`).
+*
+* Returns _false_ if the ordering of fields is different, even though values are identical:
+* ```js
+* isEqualValueDefault({ a: 10, b: 20}, { b: 20, a: 10 }); // false
+* ```
+*
+* Use {@link isEqualValueIgnoreOrder} to ignore order (with an overhead of additional processing).
+* ```js
+* isEqualValueIgnoreOrder({ a: 10, b: 20}, { b: 20, a: 10 }); // true
+* ```
+*
+* Use {@link isEqualValuePartial} to partially match `b` against `a`.
+* @returns True if the contents of `a` and `b` are equal
+*/
+function isEqualValueDefault(a, b) {
+	if (a === b) return true;
+	return toStringDefault(a) === toStringDefault(b);
+}
+/**
+* Comparer returns true if string representation of `a` and `b` are equal, regardless of field ordering.
+* Uses `toStringOrdered` to generate a string representation (via JSON.stringify`).
+*
+* ```js
+* isEqualValueIgnoreOrder({ a: 10, b: 20}, { b: 20, a: 10 }); // true
+* isEqualValue({ a: 10, b: 20}, { b: 20, a: 10 }); // false, fields are different order
+* ```
+*
+* There is an overhead to ordering fields. Use {@link isEqualValueDefault} if it's not possible that field ordering will change.
+* @returns True if the contents of `a` and `b` are equal
+* @typeParam T - Type of objects being compared
+*/
+function isEqualValueIgnoreOrder(a, b) {
+	if (a === b) return true;
+	return toStringOrdered(a) === toStringOrdered(b);
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+core@0.56.13/node_modules/@ixfx/core/dist/maps-D25APhug.js
+/**
+* Sort numbers in ascending order.
+*
+* ```js
+* [10, 4, 5, 0].sort(numericComparer);
+* // Yields: [0, 4, 5, 10]
+* [10, 4, 5, 0].sort(comparerInverse(numericComparer));
+* // Yields: [ 10, 5, 4, 0]
+* ```
+*
+* Returns:
+* 0: values are equal
+* negative: `a` should be before `b`
+* positive: `a` should come after `b`
+* @param a
+* @param b
+* @returns
+*/
+function numericComparer(a, b) {
+	if (a === b) return 0;
+	if (a > b) return 1;
+	return -1;
+}
+/**
+* Default sort comparer, following same sematics as Array.sort.
+* Consider using {@link defaultComparer} to get more logical sorting of numbers.
+*
+* Note: numbers are sorted in alphabetical order, eg:
+* ```js
+* [ 10, 20, 5, 100 ].sort(jsComparer); // same as .sort()
+* // Yields: [10, 100, 20, 5]
+* ```
+*
+* Returns -1 if x is less than y
+* Returns 1 if x is greater than y
+* Returns 0 if x is the same as y
+* @param x
+* @param y
+* @returns
+*/
+function jsComparer(x, y) {
+	if (x === void 0 && y === void 0) return 0;
+	if (x === void 0) return 1;
+	if (y === void 0) return -1;
+	const xString = defaultToString(x);
+	const yString = defaultToString(y);
+	if (xString < yString) return -1;
+	if (xString > yString) return 1;
+	return 0;
+}
+/**
+* Compares numbers by numeric value, otherwise uses the default
+* logic of string comparison.
+*
+* Is an ascending sort:
+* b, a, c -> a, b, c
+* 10, 5, 100 -> 5, 10, 100
+*
+* Returns -1 if x is less than y
+* Returns 1 if x is greater than y
+* Returns 0 if x is the same as y
+* @param x
+* @param y
+* @see {@link comparerInverse} Inverted order
+* @returns
+*/
+function defaultComparer(x, y) {
+	if (typeof x === `number` && typeof y === `number`) return numericComparer(x, y);
+	return jsComparer(x, y);
+}
+/**
+* @inheritDoc getOrGenerate
+* @param map
+* @param fn
+* @returns
+*/
+const getOrGenerateSync = (map, fn) => (key, args) => {
+	let value = map.get(key);
+	if (value !== void 0) return value;
+	value = fn(key, args);
+	map.set(key, value);
+	return value;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/chunk-ZRW5x4aP.js
+var __defProp$1 = Object.defineProperty;
+var __exportAll$1 = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp$1(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+core@0.56.13/node_modules/@ixfx/core/dist/text-CovhuGNs.js
+/**
+* Given a long string, abbreviates it with ...
+* ```js
+* abbreviate(`This is something`, 7); // `This is...`
+* ```
+*
+* If `source` is under `maxLength` the original is returned.
+* @param source
+* @param maxLength Maximum length. Defaults to 20
+* @returns
+*/
+function abbreviate(source, maxLength = 15) {
+	resultThrow(integerTest(maxLength, `aboveZero`, `maxLength`));
+	if (typeof source !== `string`) throw new Error(`Parameter 'source' is not a string`);
+	if (source.length > maxLength && source.length > 3) {
+		if (maxLength > 15) {
+			const chunk = Math.round((maxLength - 2) / 2);
+			return `${source.slice(0, chunk)}...${source.slice(-chunk)}`;
+		}
+		return `${source.slice(0, maxLength)}...`;
+	}
+	return source;
+}
+/**
+* Uses JSON.toString() on `source`, but abbreviates result.
+* @param source Object to stringify
+* @param maxLength Default 20
+* @returns
+*/
+function toStringAbbreviate(source, maxLength = 20) {
+	if (source === void 0) return `(undefined)`;
+	if (source === null) return `(null)`;
+	return abbreviate(JSON.stringify(source), maxLength);
+}
+//#endregion
+//#region node_modules/.pnpm/@ixfx+core@0.56.13/node_modules/@ixfx/core/dist/src-C6LGm3yY.js
+/**
+* Returns _true_ if `value` is number, string, bigint or boolean.
+* Returns _false_ if `value` is an object, null, undefined
+* 
+* Use {@link isPrimitiveOrObject} to also return true if `value` is an object.
+* @param value Value to check
+* @returns _True_ if value is number, string, bigint or boolean.
+*/
+function isPrimitive(value) {
+	if (typeof value === `number`) return true;
+	if (typeof value === `string`) return true;
+	if (typeof value === `bigint`) return true;
+	if (typeof value === `boolean`) return true;
+	return false;
+}
+/**
+* Returns a {@link Continuously} that continually executes `callback` at `interval` rate.
+* 
+* By default, first the sleep period happens and then the callback happens.
+*
+* Call `start` to begin/reset loop. The looping stops when `cancel` is called, or when `callback` returns _false_.
+*
+* @example
+* Animation loop
+* ```js
+* const draw = () => {
+*  // Draw on canvas
+* }
+*
+* // Run draw() synchronised with monitor refresh rate via `window.requestAnimationFrame`
+* continuously(draw).start();
+* ```
+*
+* @example
+* With delay
+* ```js
+* const fn = () => {
+*  // Runs after one minute
+* }
+* const c = continuously(fn, { mins: 1 } );
+* c.start(); // Runs `fn` every minute
+* ```
+*
+* @example
+* Control a 'continuously'
+* ```js
+* c.cancel();   // Stop the loop, cancelling any up-coming calls to `fn`
+* c.elapsedMs;  // How many milliseconds have elapsed since start
+* c.ticks;      // How many iterations of loop since start
+* c.interval;   // Get/set speed of loop. Change kicks-in at next loop.
+*               // Use .start() to reset to new interval immediately
+* ```
+*
+* Asynchronous callback functions are supported too:
+* ```js
+* continuously(async () => { ..});
+* ```
+*
+* The `callback` function can receive a few arguments:
+* 
+* ```js
+* continuously( (ticks, elapsedMs) => {
+*  // ticks: how many times loop has run
+*  // elapsedMs:  how long since last loop
+* }).start();
 * ```
-* Throws an error if either is lacking position.
-* @param a 
-* @param b 
-* @returns Distance
-*/
-const distanceCenter = (a, b) => {
-	guardPositioned(a, `a`);
-	if (isCirclePositioned(b)) guardPositioned(b, `b`);
-	return distance(a, b);
-};
-/**
-* Returns the distance between the exterior of two circles, or between the exterior of a circle and point.
-* If `b` overlaps or is enclosed by `a`, distance is 0.
+*
+* If the callback explicitly returns _false_, the loop will be cancelled.
 * 
 * ```js
-* const circleA = { radius: 5, x: 5, y: 5 }
-* const circleB = { radius: 10, x: 20, y: 20 }
-* const distance = Circles.distanceCenter(circleA, circleB);
+* continuously(ticks => {
+*  // Stop after 100 iterations
+*  if (ticks > 100) return false;
+* }).start();
 * ```
-* @param a
-* @param b 
+*
+* You can intercept the logic for calls to `start()` with `onStartCalled`. It can determine
+* whether the `start()` proceeds, if the loop is cancelled, or the whole thing disposed,
+* so it can't run any longer.
+* 
+* ```js
+* continuously(callback, intervalMs, {
+*  onStartCalled:(ticks, elapsedMs) => {
+*    // Cancel the loop after 1000ms has elapsed
+*    if (elapsedMs > 1000) return `cancel`;
+*  }
+* }).start();
+* ```
+*
+* To run `callback` *before* the sleep happens, set `fireBeforeWait`:
+* ```js
+* continuously(callback, intervalMs, { fireBeforeWait: true });
+* ```
+* @param callback - Function to run. If it returns _false_, loop exits.
+* @param options - {@link ContinuouslyOpts ContinuouslyOpts}
+* @param interval - Speed of loop (default: 0)
+* @returns Instance to control looping.
+* @see Flow.timeout if you want to trigger something once.
 */
-const distanceFromExterior$1 = (a, b) => {
-	guardPositioned(a, `a`);
-	if (isCirclePositioned(b)) return Math.max(0, distanceCenter(a, b) - a.radius - b.radius);
-	else if (isPoint(b)) {
-		const distribution = distance(a, b);
-		if (distribution < a.radius) return 0;
-		return distribution;
-	} else throw new Error(`Second parameter invalid type`);
+const continuously = (callback, interval = 0, options = {}) => {
+	let intervalMs = intervalToMs(interval, 0);
+	resultThrow(integerTest(intervalMs, `positive`, `interval`));
+	const fireBeforeWait = options.fireBeforeWait ?? false;
+	const onStartCalled = options.onStartCalled;
+	const signal = options.signal;
+	let disposed = false;
+	let runState = `idle`;
+	let startCount = 0;
+	let startCountTotal = 0;
+	let startedAt = performance.now();
+	let intervalUsed = interval ?? 0;
+	let cancelled = false;
+	let currentTimer;
+	const deschedule = () => {
+		if (currentTimer === void 0) return;
+		globalThis.clearTimeout(currentTimer);
+		currentTimer = void 0;
+		startCount = 0;
+		startedAt = NaN;
+	};
+	const schedule = (scheduledCallback) => {
+		if (intervalMs === 0) if (typeof requestAnimationFrame === `undefined`) currentTimer = globalThis.setTimeout(scheduledCallback, 0);
+		else {
+			currentTimer = void 0;
+			requestAnimationFrame(scheduledCallback);
+		}
+		else currentTimer = globalThis.setTimeout(scheduledCallback, intervalMs);
+	};
+	const cancel = () => {
+		if (cancelled) return;
+		cancelled = true;
+		if (runState === `idle`) return;
+		runState = `idle`;
+		deschedule();
+	};
+	const loop = async () => {
+		if (signal?.aborted) runState = `idle`;
+		if (runState === `idle`) return;
+		runState = `running`;
+		startCount++;
+		startCountTotal++;
+		const valueOrPromise = callback(startCount, performance.now() - startedAt);
+		const value = typeof valueOrPromise === `object` ? await valueOrPromise : valueOrPromise;
+		if (cancelled) return;
+		runState = `scheduled`;
+		if (value !== void 0 && !value) {
+			cancel();
+			return;
+		}
+		if (cancelled) return;
+		schedule(loop);
+	};
+	const start = () => {
+		if (disposed) throw new Error(`Disposed`);
+		cancelled = false;
+		if (onStartCalled !== void 0) switch (onStartCalled(startCount, performance.now() - startedAt)) {
+			case `cancel`:
+				cancel();
+				return;
+			case `reset`:
+				reset();
+				return;
+			case `dispose`:
+				disposed = true;
+				cancel();
+				return;
+		}
+		if (runState === `idle`) {
+			startCount = 0;
+			startedAt = performance.now();
+			runState = `scheduled`;
+			if (fireBeforeWait) loop();
+			else schedule(loop);
+		}
+	};
+	const reset = () => {
+		if (disposed) throw new Error(`Disposed`);
+		cancelled = false;
+		startCount = 0;
+		startedAt = NaN;
+		if (runState !== `idle`) cancel();
+		start();
+	};
+	return {
+		start,
+		reset,
+		cancel,
+		get interval() {
+			return intervalUsed;
+		},
+		get runState() {
+			return runState;
+		},
+		get startCountTotal() {
+			return startCountTotal;
+		},
+		get startCount() {
+			return startCount;
+		},
+		set interval(interval) {
+			const ms = intervalToMs(interval, 0);
+			resultThrow(integerTest(ms, `positive`, `interval`));
+			intervalMs = ms;
+			intervalUsed = interval;
+		},
+		get isDisposed() {
+			return disposed;
+		},
+		get elapsedMs() {
+			return performance.now() - startedAt;
+		}
+	};
 };
 /**
-* Returns a Point with the x,y,z values of two points multiply (a/b).
+* Return the millisecond value of an Interval.
 * 
-* `z` parameter is used, if present. Uses a default value of 0 for 'z' when multiplying a 2D point with a 3D one.
+* ```js
+* intervalToMs(100); // 100
+* intervalToMs({ millis: 100 }); // 100
+* ```
 *
-* Examples:
+* Use `defaultNumber` to return a default in the case of
+* _undefined_ or invalid input.
 *
 * ```js
-* multiply(ptA, ptB);
-* multiply(x1, y1, x2, y2);
-* multiply(ptA, x2, y2);
+* intervalToMs(undefined);      // throws error
+* intervalToMs(undefined, 100); // 100
 * ```
+*
+* If no default is provided, an exception is thrown.
+* @param interval Interval
+* @param defaultNumber Default value if `interval` is _undefined_ or invalid
+* @returns Milliseconds
 */
-function multiply(a1, ab2, ab3, ab4, ab5, ab6) {
-	const [ptA, ptB] = getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6);
-	guard$3(ptA, `a`);
-	guard$3(ptB, `b`);
-	const pt = {
-		x: ptA.x * ptB.x,
-		y: ptA.y * ptB.y
-	};
-	if (isPoint3d(ptA) || isPoint3d(ptB)) pt.z = (ptA.z ?? 0) * (ptB.z ?? 0);
-	return Object.freeze(pt);
+function intervalToMs(interval, defaultNumber) {
+	if (isInterval(interval)) {
+		if (typeof interval === `number`) return interval;
+		let ms = interval.millis ?? 0;
+		ms += (interval.hours ?? 0) * 60 * 60 * 1e3;
+		ms += (interval.mins ?? 0) * 60 * 1e3;
+		ms += (interval.secs ?? 0) * 1e3;
+		return ms;
+	} else {
+		if (typeof defaultNumber !== `undefined`) return defaultNumber;
+		throw new Error(`Not a valid interval: ${JSON.stringify(interval)}`);
+	}
 }
 /**
-* Multiplies all components by `v`.
-* Existing properties of `pt` are maintained.
-*
-* ```js
-* multiplyScalar({ x:2, y:4 }, 2);
-* // Yields: { x:4, y:8 }
-* ```
-* @param pt Point
-* @param v Value to multiply by
-* @returns
+* Returns _true_ if `interval` matches the {@link Interval} type.
+* @param interval 
+* @returns _True_ if `interval` is an {@link Interval}.
 */
-const multiplyScalar = (pt, v) => {
-	return isPoint3d(pt) ? Object.freeze({
-		...pt,
-		x: pt.x * v,
-		y: pt.y * v,
-		z: pt.z * v
-	}) : Object.freeze({
-		...pt,
-		x: pt.x * v,
-		y: pt.y * v
-	});
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/is-equal-BIRq9vnk.js
+function isInterval(interval) {
+	if (typeof interval === `undefined`) return false;
+	if (interval === null) return false;
+	if (typeof interval === `number`) {
+		if (Number.isNaN(interval)) return false;
+		if (!Number.isFinite(interval)) return false;
+		return true;
+	}
+	if (typeof interval !== `object`) return false;
+	const hasMillis = `millis` in interval;
+	const hasSecs = `secs` in interval;
+	const hasMins = `mins` in interval;
+	const hasHours = `hours` in interval;
+	if (hasMillis && !numberTest(interval.millis).success) return false;
+	if (hasSecs && !numberTest(interval.secs).success) return false;
+	if (hasMins && !numberTest(interval.mins).success) return false;
+	if (hasHours && !numberTest(interval.hours).success) return false;
+	if (hasMillis || hasSecs || hasHours || hasMins) return true;
+	return false;
+}
 /**
-* Returns _true_ if the points have identical values
+* Returns a function that resolves `object`.
 *
-* ```js
-* const a = {x: 10, y: 10};
-* const b = {x: 10, y: 10;};
-* a === b        // False, because a and be are different objects
-* isEqual(a, b)   // True, because a and b are same value
-* ```
-* @param p Points
-* @returns _True_ if points are equal
+* Use {@link resolveFields} to resolve an object directly.
+* @param object
+* @returns
 */
-const isEqual = (...p) => {
-	if (p === void 0) throw new Error(`parameter 'p' is undefined`);
-	if (p.length < 2) return true;
-	for (let index = 1; index < p.length; index++) {
-		if (p[index].x !== p[0].x) return false;
-		if (p[index].y !== p[0].y) return false;
-	}
-	return true;
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.12/node_modules/@ixfx/collections/dist/chunk-ZRW5x4aP.js
-var __defProp$1 = Object.defineProperty;
-var __exportAll$1 = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp$1(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp$1(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
+if (typeof window === `undefined` || !(`requestAnimationFrame` in window)) {
+	if (typeof window === `undefined`) globalThis.requestAnimationFrame = (callback) => {
+		setTimeout(callback, 1);
+	};
+}
 //#endregion
-//#region node_modules/.pnpm/@ixfx+events@0.56.12/node_modules/@ixfx/events/dist/index.js
+//#region node_modules/.pnpm/@ixfx+events@0.56.13/node_modules/@ixfx/events/dist/index.js
 var MapOfSimple = class {
 	#store = /* @__PURE__ */ new Map();
 	/**
@@ -2194,7 +3310,7 @@ var SimpleEventEmitter = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/join-points-to-lines-4r_A2U2k.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/join-points-to-lines-CEdHRF9i.js
 /**
 * Returns true if point is within or on boundary of `rect`.
 *
@@ -2242,14 +3358,14 @@ function intersectsPoint(rect, a, b) {
 * @param pt Point
 * @returns Distance
 */
-const distanceFromExterior = (rect, pt) => {
+function distanceFromExterior(rect, pt) {
 	guardPositioned$1(rect, `rect`);
-	guard$3(pt, `pt`);
+	guard$2(pt, `pt`);
 	if (intersectsPoint(rect, pt)) return 0;
 	const dx = Math.max(rect.x - pt.x, 0, pt.x - rect.x + rect.width);
 	const dy = Math.max(rect.y - pt.y, 0, pt.y - rect.y + rect.height);
 	return Math.hypot(dx, dy);
-};
+}
 /**
 * Returns an array of lines that connects provided points. Note that line is not closed.
 * 
@@ -2272,7 +3388,7 @@ const joinPointsToLines = (...points) => {
 	return lines;
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.12/node_modules/@ixfx/collections/dist/queue-mutable-lrZyCqgq.js
+//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/queue-mutable-lrZyCqgq.js
 const debug = (opts, message) => {
 	opts.debug && console.log(`queue:${message}`);
 };
@@ -2475,14 +3591,14 @@ function mutable(options = {}, ...startingItems) {
 	return new QueueMutable({ ...options }, [...startingItems]);
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+iterables@0.56.12/node_modules/@ixfx/iterables/dist/guard-COHp1bP0.js
+//#region node_modules/.pnpm/@ixfx+iterables@0.56.13/node_modules/@ixfx/iterables/dist/guard-COHp1bP0.js
 const isAsyncIterable = (v) => {
 	if (typeof v !== `object`) return false;
 	if (v === null) return false;
 	return Symbol.asyncIterator in v;
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+iterables@0.56.12/node_modules/@ixfx/iterables/dist/sync-CP_0yIYe.js
+//#region node_modules/.pnpm/@ixfx+iterables@0.56.13/node_modules/@ixfx/iterables/dist/sync-CP_0yIYe.js
 /**
 * Returns last value from an iterable, or _undefined_
 * if no values are generated
@@ -2522,7 +3638,7 @@ function* min$2(it, gt = (a, b) => a > b) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+iterables@0.56.12/node_modules/@ixfx/iterables/dist/async.js
+//#region node_modules/.pnpm/@ixfx+iterables@0.56.13/node_modules/@ixfx/iterables/dist/async.js
 /**
 * Returns last value from an iterable, or _undefined_
 * if no values are generated
@@ -2588,7 +3704,7 @@ async function* min$1(it, gt = (a, b) => a > b) {
 	return min;
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+iterables@0.56.12/node_modules/@ixfx/iterables/dist/index.js
+//#region node_modules/.pnpm/@ixfx+iterables@0.56.13/node_modules/@ixfx/iterables/dist/index.js
 /**
 * Returns a stream of minimum values.
 * 
@@ -2640,7 +3756,7 @@ function last(it) {
 	return isAsyncIterable(it) ? last$1(it) : last$2(it);
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.12/node_modules/@ixfx/collections/dist/priority-mutable-C9pMxKNT.js
+//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/priority-mutable-C9pMxKNT.js
 /**
 * Simple priority queue implementation.
 * Higher numbers mean higher priority.
@@ -2732,7 +3848,7 @@ function priority(opts = {}) {
 	return new PriorityMutable(opts);
 }
 //#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.12/node_modules/@ixfx/collections/dist/queue-CCn_cD23.js
+//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/queue-CCn_cD23.js
 var QueueImmutable = class QueueImmutable {
 	opts;
 	#data;
@@ -3167,7 +4283,7 @@ const timerWithFunction = (fn, timer) => {
 	};
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+trackers@0.56.12/node_modules/@ixfx/trackers/dist/index.js
+//#region node_modules/.pnpm/@ixfx+trackers@0.56.13/node_modules/@ixfx/trackers/dist/index.js
 /**
 * Base tracker class
 */
@@ -3456,7 +4572,7 @@ var TrackedValueMap = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/line-Betvd7tG.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/line-DZj7hi4y.js
 /**
 * Normalises a point so it is on a 0..1 scale
 * 
@@ -3512,8 +4628,8 @@ function normaliseByRect$1(a, b, c, d) {
 */
 function divide$2(a1, ab2, ab3, ab4, ab5, ab6) {
 	const [ptA, ptB] = getTwoPointParameters(a1, ab2, ab3, ab4, ab5, ab6);
-	guard$3(ptA, `a`);
-	guard$3(ptB, `b`);
+	guard$2(ptA, `a`);
+	guard$2(ptB, `b`);
 	if (ptB.x === 0) throw new TypeError("Cannot divide by zero (b.x is 0)");
 	if (ptB.y === 0) throw new TypeError("Cannot divide by zero (b.y is 0)");
 	const pt = {
@@ -3614,7 +4730,7 @@ function abs(pt) {
 * @returns
 */
 function apply$1(pt, fn) {
-	guard$3(pt, `pt`);
+	guard$2(pt, `pt`);
 	if (isPoint3d(pt)) return Object.freeze({
 		...pt,
 		x: fn(pt.x, `x`),
@@ -3632,136 +4748,52 @@ function apply$1(pt, fn) {
 * Undefined values are skipped over. Calculation and return value is 2D.
 *
 * ```js
-* // Find centroid of a list of points
-* const c1 = centroid(p1, p2, p3, ...);
-*
-* // Find centroid of an array of points
-* const c2 = centroid(...pointsArray);
-* ```
-* @param points
-* @returns A single point
-*/
-const centroid = (...points) => {
-	if (!Array.isArray(points)) throw new Error(`Expected list of points`);
-	const sum = points.reduce((previous, p) => {
-		if (p === void 0) return previous;
-		if (Array.isArray(p)) throw new TypeError(`'points' list contains an array. Did you mean: centroid(...myPoints)?`);
-		if (!isPoint(p)) throw new Error(`'points' contains something which is not a point: ${JSON.stringify(p)}`);
-		return {
-			x: previous.x + p.x,
-			y: previous.y + p.y
-		};
-	}, {
-		x: 0,
-		y: 0
-	});
-	return Object.freeze({
-		x: sum.x / points.length,
-		y: sum.y / points.length
-	});
-};
-/**
-* Clamps a point to be between `min` and `max` (0 & 1 by default)
-* @param pt Point
-* @param min Minimum value (0 by default)
-* @param max Maximum value (1 by default)
-*/
-function clamp$1(a, min = 0, max = 1) {
-	if (isPoint3d(a)) return Object.freeze({
-		x: clamp(a.x, min, max),
-		y: clamp(a.y, min, max),
-		z: clamp(a.z, min, max)
-	});
-	else return Object.freeze({
-		x: clamp(a.x, min, max),
-		y: clamp(a.y, min, max)
-	});
-}
-/**
-* Returns -2 if both x & y of a is less than b
-* Returns -1 if either x/y of a is less than b
-*
-* Returns 2 if both x & y of a is greater than b
-* Returns 1 if either x/y of a is greater than b's x/y
-*
-* Returns 0 if x/y of a and b are equal
-* @param a
-* @param b
-* @returns
-*/
-const compare = (a, b) => {
-	if (a.x < b.x && a.y < b.y) return -2;
-	if (a.x > b.x && a.y > b.y) return 2;
-	if (a.x < b.x || a.y < b.y) return -1;
-	if (a.x > b.x || a.y > b.y) return 1;
-	if (a.x === b.x && a.x === b.y) return 0;
-	return NaN;
-};
-/**
-* Compares points based on x value. Y value is ignored.
-* 
-* Return values:
-* * 0: If a.x === b.x
-* * 1: a is to the right of b (ie. a.x > b.x)
-* * -1: a is to the left of b (ie. a.x < b.x)
-*
-* @example Sorting by x
-* ```js
-* arrayOfPoints.sort(Points.compareByX);
-* ```
-* 
-* @param a
-* @param b
-* @returns
-*/
-const compareByX = (a, b) => {
-	if (a.x === b.x) return 0;
-	if (a.x < b.x) return -1;
-	return 1;
-};
-/**
-* Compares points based on Y value. X value is ignored.
-* 
-* Return values:
-* * 0: If a.y === b.y
-* * 1: A is below B (ie. a.y > b.y)
-* * -1: A is above B (ie. a.y < b.y)
-*
-* @example Sorting by Y
-* ```js
-* arrayOfPoints.sort(Points.compareByY);
-* ```
-* @param a
-* @param b
-* @returns
-*/
-const compareByY = (a, b) => {
-	if (a.y === b.y) return 0;
-	if (a.y < b.y) return -1;
-	return 1;
-};
-/**
-* Compares points based on Z value. XY values are ignored.
-* 
-* Return values:
-* * 0: If a.z === b.z
-* * 1: A is below B (ie. a.z > b.z)
-* * -1: A is above B (ie. a.z < b.z)
-*
-* @example Sorting by Y
-* ```js
-* arrayOfPoints.sort(Points.compareByZ);
+* // Find centroid of a list of points
+* const c1 = centroid(p1, p2, p3, ...);
+*
+* // Find centroid of an array of points
+* const c2 = centroid(...pointsArray);
 * ```
-* @param a
-* @param b
-* @returns
+* @param points
+* @returns A single point
 */
-const compareByZ = (a, b) => {
-	if (a.z === b.z) return 0;
-	if (a.z < b.z) return -1;
-	return 1;
+const centroid = (...points) => {
+	if (!Array.isArray(points)) throw new Error(`Expected list of points`);
+	const sum = points.reduce((previous, p) => {
+		if (p === void 0) return previous;
+		if (Array.isArray(p)) throw new TypeError(`'points' list contains an array. Did you mean: centroid(...myPoints)?`);
+		if (!isPoint(p)) throw new Error(`'points' contains something which is not a point: ${JSON.stringify(p)}`);
+		return {
+			x: previous.x + p.x,
+			y: previous.y + p.y
+		};
+	}, {
+		x: 0,
+		y: 0
+	});
+	return Object.freeze({
+		x: sum.x / points.length,
+		y: sum.y / points.length
+	});
 };
 /**
+* Clamps a point to be between `min` and `max` (0 & 1 by default)
+* @param pt Point
+* @param min Minimum value (0 by default)
+* @param max Maximum value (1 by default)
+*/
+function clamp$1(a, min = 0, max = 1) {
+	if (isPoint3d(a)) return Object.freeze({
+		x: clamp(a.x, min, max),
+		y: clamp(a.y, min, max),
+		z: clamp(a.z, min, max)
+	});
+	else return Object.freeze({
+		x: clamp(a.x, min, max),
+		y: clamp(a.y, min, max)
+	});
+}
+/**
 * Simple convex hull impementation. Returns a set of points which
 * enclose `pts`.
 *
@@ -3977,20 +5009,41 @@ const fromNumbers = (...coords) => {
 };
 /**
 * Returns a relative point between two points.
-* 
+*
 * ```js
 * interpolate(0.5, { x:0, y:0 }, { x:10, y:10 }); // Halfway { x, y }
 * ```
 *
 * Alias for Lines.interpolate(amount, a, b);
 *
+* If you find yourself calling `interpolate` repeatedly with the same points, consider using {@link interpolator} to create a function that bakes in the points.
 * @param amount Relative amount, 0-1
 * @param a
 * @param b
 * @param allowOverflow If true, length of line can be exceeded for `amount` of below 0 and above `1`.
-* @returns {@link Point}
+* @returns {@link Point} Point
+*/
+function interpolate(amount, a, b, allowOverflow = false) {
+	return interpolate$1(amount, a, b, allowOverflow);
+}
+/**
+* Returns a function that interpolates between two points. If you just want to interpolate between two points, use {@link interpolate}.
+*
+* ```js
+* const i = interpolator({ x:0, y:0 }, { x:10, y:10 });
+* i(0.5); // Halfway { x, y }
+* ```
+*
+* If you find yourself not needing to reuse the function because you're always calling `interpolator` with different point values all the time, use {@link interpolate} instead.
+* @param a
+* @param b
+* @param allowOverflow
+* @returns Function to interpolate
 */
-const interpolate = (amount, a, b, allowOverflow = false) => interpolate$1(amount, a, b, allowOverflow);
+const interpolator = (a, b, allowOverflow = false) => interpolator$2({
+	a,
+	b
+}, allowOverflow);
 /**
 * Inverts one or more axis of a point
 * ```js
@@ -4148,7 +5201,7 @@ const pi$1 = Math.PI;
 * @param origin Origin to calculate vector from or 0,0 if left empty
 * @returns
 */
-const fromPointPolar = (pt, angleNormalisation = ``, origin = EmptyCartesian) => {
+function fromPointPolar(pt, angleNormalisation = ``, origin = EmptyCartesian) {
 	pt = subtract(pt, origin);
 	let direction = Math.atan2(pt.y, pt.x);
 	if (angleNormalisation === `unipolar` && direction < 0) direction += piPi;
@@ -4160,22 +5213,24 @@ const fromPointPolar = (pt, angleNormalisation = ``, origin = EmptyCartesian) =>
 		distance: distance(pt),
 		angleRadian: direction
 	});
-};
+}
 /**
 * Returns a Cartesian-coordinate vector from a line a -> b
 * @param line
 * @returns
 */
-const fromLineCartesian = (line) => subtract(line.b, line.a);
+function fromLineCartesian(line) {
+	return subtract(line.b, line.a);
+}
 /**
 * Returns a polar-coordinate vector from a line a -> b
 * @param line
 * @returns
 */
-const fromLinePolar = (line) => {
-	guard$2(line, `line`);
+function fromLinePolar(line) {
+	resultThrow(lineTest(line, `line`));
 	return fromPointPolar(subtract(line.b, line.a));
-};
+}
 /**
 * Tracks the relation between two points.
 * 
@@ -4620,8 +5675,8 @@ const project = (origin, distance, angle) => {
 * @returns 
 */
 function quantiseEvery$1(pt, snap, middleRoundsUp = true) {
-	guard$3(pt, `pt`);
-	guard$3(snap, `snap`);
+	guard$2(pt, `pt`);
+	guard$2(snap, `snap`);
 	if (isPoint3d(pt)) {
 		if (!isPoint3d(snap)) throw new TypeError(`Param 'snap' is missing 'z' field`);
 		return Object.freeze({
@@ -4710,13 +5765,13 @@ function rotate$1(pt, amountRadian, origin) {
 		x: 0,
 		y: 0
 	};
-	guard$3(origin, `origin`);
+	guard$2(origin, `origin`);
 	resultThrow(numberTest(amountRadian, ``, `amountRadian`));
 	const arrayInput = Array.isArray(pt);
 	if (amountRadian === 0) return pt;
 	if (!arrayInput) pt = [pt];
 	const ptAr = pt;
-	for (const [index, p] of ptAr.entries()) guard$3(p, `pt[${index}]`);
+	for (const [index, p] of ptAr.entries()) guard$2(p, `pt[${index}]`);
 	const asCartesisan = ptAr.map((p) => fromCartesian(p, origin)).map((p) => rotate(p, amountRadian)).map((p) => toCartesian$1(p, origin));
 	return arrayInput ? asCartesisan : asCartesisan[0];
 }
@@ -4763,15 +5818,15 @@ const round$1 = (ptOrX, yOrDigits, digits) => {
 * @returns
 */
 const withinRange$1 = (a, b, maxRange) => {
-	guard$3(a, `a`);
-	guard$3(b, `b`);
+	guard$2(a, `a`);
+	guard$2(b, `b`);
 	if (typeof maxRange === `number`) {
 		resultThrow(numberTest(maxRange, `positive`, `maxRange`));
 		maxRange = {
 			x: maxRange,
 			y: maxRange
 		};
-	} else guard$3(maxRange, `maxRange`);
+	} else guard$2(maxRange, `maxRange`);
 	const x = Math.abs(b.x - a.x);
 	const y = Math.abs(b.y - a.y);
 	return x <= maxRange.x && y <= maxRange.y;
@@ -4805,9 +5860,9 @@ const wrap$1 = (pt, ptMax, ptMin) => {
 		x: 0,
 		y: 0
 	};
-	guard$3(pt, `pt`);
-	guard$3(ptMax, `ptMax`);
-	guard$3(ptMin, `ptMin`);
+	guard$2(pt, `pt`);
+	guard$2(ptMax, `ptMax`);
+	guard$2(ptMin, `ptMin`);
 	return Object.freeze({
 		x: wrap(pt.x, ptMin.x, ptMax.x),
 		y: wrap(pt.y, ptMin.y, ptMax.y)
@@ -4840,6 +5895,7 @@ var point_exports = /* @__PURE__ */ __exportAll$2({
 	compareByX: () => compareByX,
 	compareByY: () => compareByY,
 	compareByZ: () => compareByZ,
+	compareRowwise: () => compareRowwise,
 	convexHull: () => convexHull,
 	cross: () => cross,
 	crossProductRaw: () => crossProductRaw,
@@ -4854,11 +5910,13 @@ var point_exports = /* @__PURE__ */ __exportAll$2({
 	from: () => from,
 	fromNumbers: () => fromNumbers,
 	fromString: () => fromString,
+	getAsBounds: () => getAsBounds,
 	getPointParameter: () => getPointParameter$1,
 	getTwoPointParameters: () => getTwoPointParameters,
-	guard: () => guard$3,
+	guard: () => guard$2,
 	guardNonZeroPoint: () => guardNonZeroPoint,
 	interpolate: () => interpolate,
+	interpolator: () => interpolator,
 	invert: () => invert,
 	isEmpty: () => isEmpty$1,
 	isEqual: () => isEqual,
@@ -4874,6 +5932,7 @@ var point_exports = /* @__PURE__ */ __exportAll$2({
 	normaliseByRect: () => normaliseByRect$1,
 	pipeline: () => pipeline,
 	pipelineApply: () => pipelineApply,
+	pointTest: () => pointTest,
 	progressBetween: () => progressBetween,
 	project: () => project,
 	quantiseEvery: () => quantiseEvery$1,
@@ -4887,7 +5946,6 @@ var point_exports = /* @__PURE__ */ __exportAll$2({
 	round: () => round$1,
 	subtract: () => subtract,
 	sum: () => sum,
-	test: () => test,
 	to2d: () => to2d,
 	to3d: () => to3d,
 	toArray: () => toArray,
@@ -4917,7 +5975,7 @@ Object.freeze({
 	})
 });
 //#endregion
-//#region node_modules/.pnpm/@ixfx+modulation@0.56.12/node_modules/@ixfx/modulation/dist/chunk-pbuEa-1d.js
+//#region node_modules/.pnpm/@ixfx+modulation@0.56.13/node_modules/@ixfx/modulation/dist/chunk-pbuEa-1d.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -4929,7 +5987,7 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+modulation@0.56.12/node_modules/@ixfx/modulation/dist/easing-CUDB77wc.js
+//#region node_modules/.pnpm/@ixfx+modulation@0.56.13/node_modules/@ixfx/modulation/dist/easing-BCATR3oC.js
 const pow$1 = Math.pow;
 const gaussianA = 1 / Math.sqrt(2 * Math.PI);
 /**
@@ -5026,17 +6084,15 @@ const expoInOut = (x) => x === 0 ? 0 : x === 1 ? 1 : x < .5 ? pow(2, 20 * x - 10
 const circIn = (x) => 1 - sqrt(1 - pow(x, 2));
 const circOut = (x) => sqrt(1 - pow(x - 1, 2));
 const backIn = (x) => {
-	const c1 = 1.70158;
-	return (c1 + 1) * x * x * x - c1 * x * x;
+	return 2.70158 * x * x * x - 1.70158 * x * x;
 };
 const backOut = (x) => {
-	const c1 = 1.70158;
-	return 1 + (c1 + 1) * pow(x - 1, 3) + c1 * pow(x - 1, 2);
+	return 1 + 2.70158 * pow(x - 1, 3) + 1.70158 * pow(x - 1, 2);
 };
 const circInOut = (x) => x < .5 ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2;
 const backInOut = (x) => {
 	const c2 = 1.70158 * 1.525;
-	return x < .5 ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+	return x < .5 ? pow(2 * x, 2) * (3.5949095 * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * (3.5949095 * (x * 2 - 2) + c2) + 2) / 2;
 };
 const elasticIn = (x) => {
 	const c4 = 2 * pi / 3;
@@ -5563,7 +6619,6 @@ function ensureTooltip() {
     padding: 2px 6px;
     font-size: 10px;
     font-family: ui-monospace, monospace;
-    white-space: nowrap;
     opacity: 0;
     transition: opacity 0.1s ease;
   `;
@@ -5575,6 +6630,16 @@ function showTooltip(owner, clientX, clientY, text) {
 	const el = ensureTooltip();
 	_tooltipOwner = owner;
 	el.textContent = text;
+	el.style.whiteSpace = `nowrap`;
+	el.style.left = `${clientX + 14}px`;
+	el.style.top = `${clientY + 14}px`;
+	el.style.opacity = `1`;
+}
+function showTooltipHTML(owner, clientX, clientY, html) {
+	const el = ensureTooltip();
+	_tooltipOwner = owner;
+	el.innerHTML = html;
+	el.style.whiteSpace = `normal`;
 	el.style.left = `${clientX + 14}px`;
 	el.style.top = `${clientY + 14}px`;
 	el.style.opacity = `1`;
@@ -5601,6 +6666,387 @@ function scaleValue(v, min, max) {
 	return range === 0 ? .5 : (v - min) / range;
 }
 //#endregion
+//#region src/plots/multi-axis.ts
+const PLOT_PALETTE = [
+	`oklch(60% 0.15 30)`,
+	`oklch(60% 0.15 90)`,
+	`oklch(60% 0.15 150)`,
+	`oklch(60% 0.15 210)`,
+	`oklch(60% 0.15 270)`,
+	`oklch(60% 0.15 330)`,
+	`oklch(60% 0.15 60)`,
+	`oklch(60% 0.15 180)`
+];
+let PlotMultiAxis = class PlotMultiAxis extends LitElement {
+	constructor(..._args) {
+		super(..._args);
+		this.layout = `overlap`;
+		this.gridMinWidth = 200;
+		this.valueFormat = (v) => v ? v.toFixed(2) : ``;
+		this.#instances = /* @__PURE__ */ new Map();
+		this.#seriesOrder = [];
+		this.#seriesSet = /* @__PURE__ */ new Set();
+		this.#pendingStyles = /* @__PURE__ */ new Map();
+	}
+	#instances;
+	#seriesOrder;
+	#seriesSet;
+	#pendingStyles;
+	addData(nameOrData, value) {
+		if (typeof nameOrData === `object` && nameOrData !== null) {
+			const entries = Object.entries(nameOrData);
+			for (const [name, val] of entries) this.#addToSeries(name, val);
+		} else this.#addToSeries(nameOrData, value);
+		this.requestUpdate();
+	}
+	styleSeries(name, styles) {
+		const normalized = {};
+		for (const [key, val] of Object.entries(styles)) normalized[key.startsWith(`--`) ? key : `--${key}`] = val;
+		const el = this.#instances.get(name);
+		if (!el) {
+			this.#pendingStyles.set(name, normalized);
+			return;
+		}
+		for (const [key, val] of Object.entries(normalized)) el.style.setProperty(key, val);
+	}
+	clear() {
+		for (const el of this.#instances.values()) el.clear();
+	}
+	clearSeries(name) {
+		const el = this.#instances.get(name);
+		if (el) el.clear();
+	}
+	get series() {
+		return [...this.#seriesOrder];
+	}
+	#addToSeries(name, value) {
+		const el = this.#ensurePlot(name);
+		if (!this.#seriesSet.has(name)) {
+			this.#seriesSet.add(name);
+			this.#seriesOrder.push(name);
+		}
+		el.add(value);
+	}
+	#ensurePlot(name) {
+		let el = this.#instances.get(name);
+		if (el) return el;
+		el = document.createElement(`ixfx-plot-single-axis`);
+		el.tooltips = false;
+		this.#instances.set(name, el);
+		const colorIndex = this.#instances.size % PLOT_PALETTE.length;
+		el.style.setProperty(`--plot-color`, PLOT_PALETTE[colorIndex]);
+		const pending = this.#pendingStyles.get(name);
+		if (pending) {
+			for (const [key, val] of Object.entries(pending)) el.style.setProperty(key, val);
+			this.#pendingStyles.delete(name);
+		}
+		el.addEventListener(`plot-datapoint-click`, (e) => {
+			const ce = e;
+			this.dispatchEvent(new CustomEvent(`plot-datapoint-click`, {
+				detail: {
+					...ce.detail,
+					series: name
+				},
+				bubbles: true,
+				composed: true
+			}));
+		});
+		el.addEventListener(`plot-pointer-move`, (e) => {
+			const ce = e;
+			this.#onSubPlotPointerMove(ce.detail.clientX, ce.detail.clientY, ce.detail.index);
+		});
+		el.addEventListener(`plot-pointer-leave`, () => {
+			this.#onSubPlotPointerLeave();
+		});
+		return el;
+	}
+	#onSubPlotPointerMove(clientX, clientY, index) {
+		if (index < 0) {
+			hideTooltip(this);
+			return;
+		}
+		const parts = [];
+		for (const [name, inst] of this.#instances) {
+			const val = inst.getValueAt(index);
+			if (val === void 0) continue;
+			const color = getComputedStyle(inst).getPropertyValue(`--plot-color`).trim();
+			parts.push(`<span style="color:${color}">${this.#escapeHTML(name)}</span> ${this.valueFormat(val)}`);
+		}
+		if (parts.length === 0) {
+			hideTooltip(this);
+			return;
+		}
+		showTooltipHTML(this, clientX, clientY, parts.join(`<br>`));
+	}
+	#onSubPlotPointerLeave() {
+		hideTooltip(this);
+	}
+	#escapeHTML(s) {
+		return s.replace(/&/g, `&amp;`).replace(/</g, `&lt;`).replace(/>/g, `&gt;`).replace(/"/g, `&quot;`);
+	}
+	render() {
+		const gridStyle = this.layout === `grid` ? `--grid-min-width: ${this.gridMinWidth}px` : ``;
+		return html`
+      <div
+        id="container"
+        class="layout layout-${this.layout}"
+        part="container"
+        style=${gridStyle}
+      >
+        ${repeat(this.#seriesOrder, (name) => name, (name) => this.#ensurePlot(name))}
+      </div>
+    `;
+	}
+	static {
+		this.styles = css`
+    :host {
+      display: block;
+      width: 100%;
+      height: 100%;
+      min-height: 40px;
+      --plot-color: var(--accent);
+    }
+
+    #container {
+      width: 100%;
+      height: 100%;
+    }
+
+    #container.layout-overlap {
+      display: grid;
+    }
+    #container.layout-overlap > * {
+      grid-area: 1 / 1;
+      background: transparent;
+    }
+
+    #container.layout-horizontal {
+      display: flex;
+      flex-direction: row;
+      gap: var(--space-s, 4px);
+    }
+    #container.layout-horizontal > * {
+      flex: 1;
+      min-width: 0;
+    }
+
+    #container.layout-vertical {
+      display: flex;
+      flex-direction: column;
+      gap: var(--space-s, 4px);
+    }
+    #container.layout-vertical > * {
+      flex: 1;
+      min-height: 0;
+    }
+
+    #container.layout-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(var(--grid-min-width, 200px), 1fr));
+      gap: var(--space-s, 4px);
+    }
+  `;
+	}
+};
+__decorate([property()], PlotMultiAxis.prototype, "layout", void 0);
+__decorate([property({
+	attribute: `grid-min-width`,
+	type: Number
+})], PlotMultiAxis.prototype, "gridMinWidth", void 0);
+PlotMultiAxis = __decorate([safeCustomElement(`ixfx-plot-multi-axis`)], PlotMultiAxis);
+//#endregion
+//#region src/plots/plot-histogram.ts
+let PlotHistogram = class PlotHistogram extends LitElement {
+	constructor(..._args) {
+		super(..._args);
+		this.orientation = "horizontal";
+		this.resolution = .1;
+		this.capacity = 100;
+		this.title = "";
+		this.paused = false;
+		this._width = 100;
+		this._height = 40;
+		this.#series = new PlotDataSeries({
+			capacityLimit: 100,
+			persistentScaling: true
+		});
+		this.#hasProgrammaticData = false;
+	}
+	#series;
+	#hasProgrammaticData;
+	#parseDeclarativeData(text) {
+		if (!text) return [];
+		return text.trim().split(/[,\s;]+/).map((t) => Number.parseFloat(t)).filter((n) => !isNaN(n));
+	}
+	add(v) {
+		this.#hasProgrammaticData = true;
+		this.#series.add(v);
+		if (this.paused) return;
+		this.requestUpdate();
+	}
+	set(values) {
+		this.#hasProgrammaticData = true;
+		this.#series.set(values);
+		if (this.paused) return;
+		this.requestUpdate();
+	}
+	clear() {
+		this.#series.clear();
+		this.requestUpdate();
+	}
+	firstUpdated(_changed) {
+		this._width = this.clientWidth || 100;
+		this._height = this.clientHeight || 40;
+		new ResizeObserver((entries) => {
+			const e = entries[0];
+			this._width = e.contentRect.width;
+			this._height = e.contentRect.height;
+		}).observe(this);
+		if (!this.#hasProgrammaticData) {
+			const data = this.#parseDeclarativeData(this.textContent ?? "");
+			if (data.length > 0) this.#series.set(data);
+		}
+	}
+	updated(changed) {
+		if (changed.has("capacity")) {
+			const old = [...this.#series.values];
+			this.#series = new PlotDataSeries({
+				capacityLimit: this.capacity,
+				persistentScaling: true
+			});
+			if (old.length > 0) this.#series.set(old);
+		}
+	}
+	#readCssVar(name) {
+		return getComputedStyle(this).getPropertyValue(name).trim();
+	}
+	#getGapPx() {
+		const val = this.#readCssVar("--plot-histogram-gap");
+		if (val === "") return 1;
+		const parsed = parseFloat(val);
+		return isFinite(parsed) ? Math.max(0, parsed) : 1;
+	}
+	#getBarLengthOverride() {
+		const val = this.#readCssVar("--plot-histogram-bar-length");
+		if (val === "" || val === "auto") return null;
+		const parsed = parseFloat(val);
+		return isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : null;
+	}
+	#emitClick(i, valueMin, valueMax, relativeValue) {
+		this.dispatchEvent(new CustomEvent("plot-bucket-click", {
+			detail: {
+				bucketIndex: i,
+				valueMin,
+				valueMax,
+				relativeValue
+			},
+			bubbles: true,
+			composed: true
+		}));
+	}
+	render() {
+		const { values, range } = this.#series;
+		const w = this._width;
+		const h = this._height;
+		const isHorizontal = this.orientation === "horizontal";
+		const padding = Math.min(4, (isHorizontal ? h : w) * .05);
+		const dataMin = this.min ?? range.min;
+		const dataSpan = (this.max ?? range.max) - dataMin || 1;
+		const bucketCount = Math.max(1, Math.floor(1 / this.resolution));
+		const availableMain = (isHorizontal ? w : h) - padding * 2;
+		const availableCross = (isHorizontal ? h : w) - padding * 2;
+		const bucketSize = availableMain / bucketCount;
+		const gap = this.#getGapPx();
+		const barLengthOverride = this.#getBarLengthOverride();
+		const buckets = new Array(bucketCount).fill(0);
+		for (const v of values) {
+			const normalized = (v - dataMin) / dataSpan;
+			const index = Math.min(bucketCount - 1, Math.max(0, Math.floor(normalized * bucketCount)));
+			buckets[index]++;
+		}
+		const maxCount = Math.max(1, ...buckets);
+		return html`
+      <svg width=${w} height=${h} viewBox="0 0 ${w} ${h}"
+        xmlns="http://www.w3.org/2000/svg">
+        <rect width=${w} height=${h} fill="transparent" />
+        ${buckets.map((count, i) => {
+			const relativeValue = count / maxCount;
+			const barLen = barLengthOverride !== null ? barLengthOverride * availableCross : relativeValue * availableCross;
+			const valueMin = dataMin + i / bucketCount * dataSpan;
+			const valueMax = dataMin + (i + 1) / bucketCount * dataSpan;
+			if (isHorizontal) {
+				const x = padding + i * bucketSize;
+				const bw = i === bucketCount - 1 ? Math.max(0, padding + availableMain - x) : Math.max(0, bucketSize - gap);
+				return svg`
+          <rect class="bar" x=${x} y=${padding + availableCross - barLen} width=${bw} height=${barLen}
+            style="--value: ${relativeValue}"
+            @click=${() => this.#emitClick(i, valueMin, valueMax, relativeValue)} />
+        `;
+			} else {
+				const y = padding + i * bucketSize;
+				return svg`
+          <rect class="bar" x=${padding} y=${y} width=${barLen} height=${i === bucketCount - 1 ? Math.max(0, padding + availableMain - y) : Math.max(0, bucketSize - gap)}
+            style="--value: ${relativeValue}"
+            @click=${() => this.#emitClick(i, valueMin, valueMax, relativeValue)} />
+        `;
+			}
+		})}
+        ${this.title ? svg`<text x=${padding + 2} y=${padding + Math.min(10, h * .6)}
+          class="overlay-text" fill=${"var(--plot-text, var(--surface-2-text, #fff))"}
+          style="opacity: 0.6">${this.title}</text>` : svg``}
+      </svg>
+    `;
+	}
+	static {
+		this.styles = css`
+    :host {
+      display: inline-block;
+      width: 100%;
+      height: 100%;
+      min-width: 20px;
+      min-height: 20px;
+
+      --plot-histogram-fill: currentColor;
+      --plot-histogram-gap: 1px;
+      --plot-histogram-border-radius: 0;
+      --plot-histogram-bar-length: auto;
+    }
+
+    svg {
+      display: block;
+      cursor: crosshair;
+      overflow: visible;
+    }
+
+    rect.bar {
+      fill: var(--plot-histogram-fill, currentColor);
+      rx: var(--plot-histogram-border-radius, 0);
+      opacity: calc(0.15 + var(--value) * 0.85);
+    }
+
+    .overlay-text {
+      font-family: var(--font-mono, ui-monospace, monospace);
+      font-size: 9px;
+      dominant-baseline: hanging;
+      pointer-events: none;
+    }
+  `;
+	}
+};
+__decorate([property({ attribute: "orientation" })], PlotHistogram.prototype, "orientation", void 0);
+__decorate([property({ type: Number })], PlotHistogram.prototype, "resolution", void 0);
+__decorate([property({ type: Number })], PlotHistogram.prototype, "min", void 0);
+__decorate([property({ type: Number })], PlotHistogram.prototype, "max", void 0);
+__decorate([property({ type: Number })], PlotHistogram.prototype, "capacity", void 0);
+__decorate([property()], PlotHistogram.prototype, "title", void 0);
+__decorate([property({
+	type: Boolean,
+	reflect: true
+})], PlotHistogram.prototype, "paused", void 0);
+__decorate([state()], PlotHistogram.prototype, "_width", void 0);
+__decorate([state()], PlotHistogram.prototype, "_height", void 0);
+PlotHistogram = __decorate([safeCustomElement("ixfx-plot-histogram")], PlotHistogram);
+//#endregion
 //#region src/plots/single-axis.ts
 function buildLinePath(points) {
 	if (points.length === 0) return ``;
@@ -5721,11 +7167,25 @@ let PlotSingleAxis = class PlotSingleAxis extends LitElement {
 			this.#lastClientX = e.clientX;
 			this.#lastClientY = e.clientY;
 			this.#updateTooltip(e.clientX, e.clientY);
+			const index = this.#getIndexFromX(e.clientX, this.getBoundingClientRect());
+			this.dispatchEvent(new CustomEvent(`plot-pointer-move`, {
+				detail: {
+					clientX: e.clientX,
+					clientY: e.clientY,
+					index
+				},
+				bubbles: true,
+				composed: true
+			}));
 		};
 		this.#onPointerLeave = () => {
 			this.#lastClientX = null;
 			this.#lastClientY = null;
 			hideTooltip(this);
+			this.dispatchEvent(new CustomEvent(`plot-pointer-leave`, {
+				bubbles: true,
+				composed: true
+			}));
 		};
 		this.#onClick = (e) => {
 			if (this.clickPauses) this.paused = !this.paused;
@@ -5747,6 +7207,18 @@ let PlotSingleAxis = class PlotSingleAxis extends LitElement {
 		if (!text) return [];
 		return text.trim().split(/[,\s;]+/).map((t) => Number.parseFloat(t)).filter((n) => !isNaN(n));
 	}
+	get values() {
+		return this.#series.values;
+	}
+	get dataCount() {
+		return this.#series.values.length;
+	}
+	getValueAt(index) {
+		return this.#series.values[index];
+	}
+	getIndexFromClientX(clientX) {
+		return this.#getIndexFromX(clientX, this.getBoundingClientRect());
+	}
 	#lastClientX;
 	#lastClientY;
 	add(v) {
@@ -6238,6 +7710,6 @@ __decorate([state()], PlotXyAxis.prototype, "_width", void 0);
 __decorate([state()], PlotXyAxis.prototype, "_height", void 0);
 PlotXyAxis = __decorate([safeCustomElement(`ixfx-plot-xy-axis`)], PlotXyAxis);
 //#endregion
-export { computeColour as a, last$2 as c, applyAgeModification as i, QueueMutable as l, PlotSingleAxis as n, parseColourScaleAttr as o, PlotDataSeries as r, readBaseColour as s, PlotXyAxis as t, __exportAll$1 as u };
+export { isEqualValueDefault as _, PlotDataSeries as a, parseColourScaleAttr as c, QueueMutable as d, isPrimitive as f, isEqualDefault as g, defaultComparer as h, PlotMultiAxis as i, readBaseColour as l, __exportAll$1 as m, PlotSingleAxis as n, applyAgeModification as o, toStringAbbreviate as p, PlotHistogram as r, computeColour as s, PlotXyAxis as t, last$2 as u, isEqualValueIgnoreOrder as v };
 
-//# sourceMappingURL=xy-axis-DL0tfJDr.js.map
+//# sourceMappingURL=xy-axis-CK64haaK.js.map