@ixfx/components 0.3.2 → 0.4.0

package/dist/{colour-C3MQIjFJ-BLXg8W3U.js → colour-C3MQIjFJ-vRCdr8W-.js}

@@ -1,17 +1,5 @@
-import { C as resultThrow, S as percentTest, a as movingAverageLight, b as numberInclusiveRangeTest, g as errorResult, i as interpolate, m as pairwise, t as clamp, u as scaleClamped, x as numberTest } from "./dist-TAGYwaju.js";
-//#region node_modules/.pnpm/@ixfx+visual@0.56.12/node_modules/@ixfx/visual/dist/chunk-pbuEa-1d.js
-var __defProp$2 = Object.defineProperty;
-var __exportAll$1 = (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.12/node_modules/@ixfx/geometry/dist/chunk-pbuEa-1d.js
+import { C as resultThrow, S as percentTest, a as movingAverageLight, b as numberInclusiveRangeTest, g as errorResult, i as interpolate, m as pairwise, t as clamp, u as scaleClamped, x as numberTest } from "./dist-CA13FvMn.js";
+//#region node_modules/.pnpm/@ixfx+visual@0.56.13/node_modules/@ixfx/visual/dist/chunk-pbuEa-1d.js
 var __defProp$1 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -23,28 +11,28 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/guard-CqkBirEd.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/guard-hlhkAOMZ.js
 /**
 * Returns true if xy (and z, if present) are _null_.
 * @param p
-* @returns
+* @returns True if all props are null
 */
-const isNull = (p) => {
+function isNull(p) {
 	if (isPoint3d(p)) {
 		if (p.z !== null) return false;
 	}
 	return p.x === null && p.y === null;
-};
+}
 /***
 * Returns true if either x, y, z isNaN.
 */
-const isNaN = (p) => {
+function isNaN(p) {
 	if (isPoint3d(p)) {
 		if (!Number.isNaN(p.z)) return false;
 	}
 	return Number.isNaN(p.x) || Number.isNaN(p.y);
-};
-function test(p, name = `Point`, extraInfo = ``) {
+}
+function pointTest(p, name = `Point`, extraInfo = ``) {
 	if (p === void 0) return errorResult(`'${name}' is undefined. Expected {x,y} got ${JSON.stringify(p)}`, extraInfo);
 	if (p === null) return errorResult(`'${name}' is null. Expected {x,y} got ${JSON.stringify(p)}`, extraInfo);
 	if (typeof p !== `object`) return errorResult(`'${name}' is type '${typeof p}'. Expected object.`, extraInfo);
@@ -71,26 +59,26 @@ function test(p, name = `Point`, extraInfo = ``) {
 * @param name
 */
 function guard$5(p, name = `Point`, info) {
-	resultThrow(test(p, name, info));
+	resultThrow(pointTest(p, name, info));
 }
 /**
 * Throws if parameter is not a valid point, or either x or y is 0
 * @param pt
-* @returns
+* @returns Throws an error if not a valid point or zero.
 */
-const guardNonZeroPoint = (pt, name = `pt`) => {
+function guardNonZeroPoint(pt, name = `pt`) {
 	guard$5(pt, name);
 	resultThrow(numberTest(pt.x, `nonZero`, `${name}.x`), numberTest(pt.y, `nonZero`, `${name}.y`), () => {
 		if (typeof pt.z !== `undefined`) return numberTest(pt.z, `nonZero`, `${name}.z`);
 	});
 	return true;
-};
+}
 /**
 * Returns _true_ if `p` has x & y properties.
 * Returns _false_ if `p` is undefined, null or does not contain properties.
 * Use {@link isPoint3d} to check further check for `z`.
-* @param p 
-* @returns 
+* @param p
+* @returns True if `p` has x & y props
 */
 function isPoint(p) {
 	if (p === void 0) return false;
@@ -102,267 +90,45 @@ function isPoint(p) {
 /**
 * Returns _true_ if `p` has x, y, & z properties.
 * Returns _false_ if `p` is undefined, null or does not contain properties.
-* @param p 
-* @returns 
+* @param p
+* @returns _True_ if `p` has x, y, & z props
 */
-const isPoint3d = (p) => {
+function isPoint3d(p) {
 	if (p === void 0) return false;
 	if (p === null) return false;
 	if (p.x === void 0) return false;
 	if (p.y === void 0) return false;
 	if (p.z === void 0) return false;
 	return true;
-};
+}
 /**
 * Returns true if both xy (and z, if present) are 0.
 * Use `Points.Empty` to return an empty point.
 * @param p
-* @returns
+* @returns _True_ is all props are 0
 */
-const isEmpty = (p) => {
+function isEmpty(p) {
 	if (isPoint3d(p)) {
 		if (p.z !== 0) return false;
 	}
 	return p.x === 0 && p.y === 0;
-};
+}
 /**
 * Returns true if point is a placeholder, where xy (and z, if present)
 * are `NaN`.
 *
 * Use Points.Placeholder to return a placeholder point.
 * @param p
-* @returns
+* @returns True if all props are NaN
 */
-const isPlaceholder = (p) => {
+function isPlaceholder(p) {
 	if (isPoint3d(p)) {
 		if (!Number.isNaN(p.z)) return false;
 	}
 	return Number.isNaN(p.x) && Number.isNaN(p.y);
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+geometry@0.56.12/node_modules/@ixfx/geometry/dist/to-jujzVMAL.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(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(xOrB, y, z);
-	guard$5(pt, `b`);
-	guard$5(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(xOrB, y);
-	guard$5(pt, `b`);
-	guard$5(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$5(ptA, `a`);
-	guard$5(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$5(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$5(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$5(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$5(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.12/node_modules/@ixfx/geometry/dist/polar-LvwxTwIf.js
+//#region node_modules/.pnpm/@ixfx+geometry@0.56.13/node_modules/@ixfx/geometry/dist/angles-BkBEzlEN.js
 const piPi = Math.PI * 2;
 /**
 * Averages a set of points, by default as a 'mean'.
@@ -436,9 +202,9 @@ function degreeToGradian(angleInDegrees) {
 /**
 * Returns the gradian value converted to degrees.
 * By default it wraps, so any value 360 or greater wraps around.
-* @param angleInGradians 
-* @param wrap 
-* @returns 
+* @param angleInGradians
+* @param wrap
+* @returns Degrees
 */
 function gradianToDegree(angleInGradians, wrap = true) {
 	if (wrap) return angleInGradians * .9 % 360;
@@ -455,24 +221,31 @@ function radianToDegree(angleInRadians) {
 }
 /**
 * Parses CSS-style angle strings into an 'Angle' type. By default assumes degrees.
-* 
+*
 * ```js
 * angleParse(`100`);     // { value: 100, unit: `deg` }
 * angleParse(100);       // { value: 100, unit: `deg` }
 * angleParse(`100deg`);  // { value: 100, unit: `deg` }
-* 
+*
 * // More exotic units:
 * angleParse(`100rad`);  // { value: 100, unit: `rad` }
 * angleParse(`100turn`); // { value: 100, unit: `turn` }
 * angleParse(`100grad`); // { value: 100, unit: `grad` }
+* angleParse(`n`); // { value: 90, unit: `deg` }
+* angleParse(`e`); // { value: 0, unit: `deg` }
+* angleParse(`s`); // { value: 270, unit: `deg` }
+* angleParse(`w`); // { value: 180, unit: `deg` }
+* angleParse(`ne`); // ne/nw/se/sw supported
+* // Once parsed, use angleConvert to convert to a different unit:
+* angleConvert(`100rad`, `deg`); // { value: 5729.57795, unit: `deg` }
 * ```
-* 
+*
 * Once parsed in this format, use {@link angleConvert} to convert to
 * a different unit.
-* @param value 
-* @returns 
+* @param value
+* @returns Angle
 */
-const angleParse = (value) => {
+function angleParse(value) {
 	if (isAngleType(value)) return value;
 	if (typeof value === `number`) return {
 		value,
@@ -494,14 +267,46 @@ const angleParse = (value) => {
 		numberValue = Number.parseFloat(value.substring(0, value.length - 3));
 		unit = `deg`;
 	} else numberValue = Number.parseFloat(value);
-	if (Number.isNaN(numberValue)) throw new Error(`Invalid angle (bad value?)`);
+	if (Number.isNaN(numberValue)) if (value === `n`) return {
+		value: 90,
+		unit: `deg`
+	};
+	else if (value === `e`) return {
+		value: 0,
+		unit: `deg`
+	};
+	else if (value === `s`) return {
+		value: 270,
+		unit: `deg`
+	};
+	else if (value === `w`) return {
+		value: 180,
+		unit: `deg`
+	};
+	else if (value === `ne`) return {
+		value: 45,
+		unit: `deg`
+	};
+	else if (value === `se`) return {
+		value: 315,
+		unit: `deg`
+	};
+	else if (value === `sw`) return {
+		value: 225,
+		unit: `deg`
+	};
+	else if (value === `nw`) return {
+		value: 135,
+		unit: `deg`
+	};
+	else throw new Error(`Invalid angle (bad value?): '${value}'. If using cardinals, use: 'n', 'se', etc.`);
 	if (unit.length === 0) throw new Error(`Invalid angle (no unit)`);
 	return {
 		value: numberValue,
 		unit
 	};
-};
-const isAngleType = (v) => {
+}
+function isAngleType(v) {
 	if (typeof v !== `object`) return false;
 	if (`unit` in v && `value` in v) {
 		if (typeof v.unit !== `string`) return false;
@@ -509,337 +314,126 @@ const isAngleType = (v) => {
 		return true;
 	}
 	return false;
-};
+}
 /**
 * Converts an angle to another representation.
 * Input value is assumed degrees unless it's an {@link Angle} type of has the unit.
-* 
+*
 * These are all identical inputs: 100, `100`, `100deg`
 * ```js
 * angleConvert(100, `rad`); // Converts 100deg to radians
 * ```
-* 
+*
 * Other units can be used for string input: `2turn`, `1grad`, `2rad`.
 * ```js
 * angleConvert(`2rad`, `deg`); // Converts 2radians to degrees
 * ```
-* 
+*
 * Can also use an object input:
 * ```js
 * angleConvert({ value: 10, unit: `deg`}, `rad`);
 * ```
-* @param angleOrDegrees 
-* @param destination 
-* @returns 
+* @param angleOrDegrees
+* @param destination
+* @returns Angle
 */
-const angleConvert = (angleOrDegrees, destination) => {
-	const angle = typeof angleOrDegrees === `object` ? angleOrDegrees : angleParse(angleOrDegrees);
+function angleConvert(angleOrDegrees, destination) {
+	const input = typeof angleOrDegrees === `object` ? angleOrDegrees : angleParse(angleOrDegrees);
 	switch (destination) {
 		case `deg`:
-			if (angle.unit === `deg`) return angle;
-			if (angle.unit === `rad`) return {
-				value: radianToDegree(angle.value),
+			if (input.unit === `deg`) return input;
+			if (input.unit === `rad`) return {
+				value: radianToDegree(input.value),
 				unit: `deg`
 			};
-			if (angle.unit === `grad`) return {
-				value: gradianToDegree(angle.value),
+			if (input.unit === `grad`) return {
+				value: gradianToDegree(input.value),
 				unit: `deg`
 			};
-			if (angle.unit === `turn`) return {
-				value: turnToDegree(angle.value),
+			if (input.unit === `turn`) return {
+				value: turnToDegree(input.value),
 				unit: `deg`
 			};
-			throw new Error(`Unknown unit: ${angle.unit}`);
+			throw new Error(`Unknown unit: ${input.unit}`);
 		case `grad`:
-			if (angle.unit === `deg`) return {
-				value: degreeToGradian(angle.value),
+			if (input.unit === `deg`) return {
+				value: degreeToGradian(input.value),
 				unit: `grad`
 			};
-			if (angle.unit === `rad`) return {
-				value: radianToGradian(angle.value),
+			if (input.unit === `rad`) return {
+				value: radianToGradian(input.value),
 				unit: `grad`
 			};
-			if (angle.unit === `grad`) return angle;
-			if (angle.unit === `turn`) return {
-				value: radianToGradian(turnToRadian(angle.value)),
+			if (input.unit === `grad`) return input;
+			if (input.unit === `turn`) return {
+				value: radianToGradian(turnToRadian(input.value)),
 				unit: `grad`
 			};
-			throw new Error(`Unknown unit: ${angle.unit}`);
+			throw new Error(`Unknown unit: ${input.unit}`);
 		case `rad`:
-			if (angle.unit === `deg`) return {
-				value: degreeToRadian(angle.value),
+			if (input.unit === `deg`) return {
+				value: degreeToRadian(input.value),
 				unit: `rad`
 			};
-			if (angle.unit === `rad`) return angle;
-			if (angle.unit === `grad`) return {
-				value: gradianToRadian(angle.value),
+			if (input.unit === `rad`) return input;
+			if (input.unit === `grad`) return {
+				value: gradianToRadian(input.value),
 				unit: `rad`
 			};
-			if (angle.unit === `turn`) return {
-				value: radianToGradian(turnToRadian(angle.value)),
-				unit: `grad`
+			if (input.unit === `turn`) return {
+				value: turnToRadian(input.value),
+				unit: `rad`
 			};
-			throw new Error(`Unknown unit: ${angle.unit}`);
+			throw new Error(`Unknown unit: ${input.unit}`);
 		case `turn`:
-			if (angle.unit === `deg`) return {
-				value: degreeToTurn(angle.value),
+			if (input.unit === `deg`) return {
+				value: degreeToTurn(input.value),
 				unit: `turn`
 			};
-			if (angle.unit === `rad`) return {
-				value: radianToTurn(angle.value),
+			if (input.unit === `rad`) return {
+				value: radianToTurn(input.value),
 				unit: `turn`
 			};
-			if (angle.unit === `grad`) return {
-				value: radianToTurn(gradianToRadian(angle.value)),
+			if (input.unit === `grad`) return {
+				value: radianToTurn(gradianToRadian(input.value)),
 				unit: `turn`
 			};
-			if (angle.unit === `turn`) return angle;
-			throw new Error(`Unknown unit: ${angle.unit}`);
+			if (input.unit === `turn`) return input;
+			throw new Error(`Unknown unit: ${input.unit}`);
 		default: throw new Error(`Destination unit unknown ('${destination}). Expects: deg, grad, rad or turn`);
 	}
-};
+}
 /**
-* Converts 'turns' to degrees. By defaults wraps the value, so 
+* Converts 'turns' to degrees. By defaults wraps the value, so
 * turn value of 1 or 2 equal 0deg instead of 360 or 720deg.
-* @param turns 
-* @param wrap 
-* @returns 
+* @param turns
+* @param wrap
+* @returns Degrees
 */
-const turnToDegree = (turns, wrap = true) => {
+function turnToDegree(turns, wrap = true) {
 	if (wrap) return turns * 360 % 360;
 	return turns * 360;
-};
-const turnToRadian = (turns) => turns * piPi;
-const degreeToTurn = (degrees) => degrees / 360;
-const radianToTurn = (radians) => radians / piPi;
+}
 /**
 * Normalise a radian angle to 0..2*PI range
-* @param angleRadian 
-* @returns 
+* @param angleRadian
+* @returns Normalised angle
 */
-const radiansNormalise = (angleRadian) => {
+function radiansNormalise(angleRadian) {
 	angleRadian %= piPi;
 	return angleRadian < 0 ? angleRadian + piPi : angleRadian;
-};
-/**
-* 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$1 = (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 = {
-	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;
-		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;
-		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) => {
-	guard$5(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$5(a, `a`);
-	if (b === void 0) return Math.atan2(a.y, a.x);
-	guard$5(b, `b`);
-	if (c === void 0) return Math.atan2(b.y - a.y, b.x - a.x);
-	guard$5(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;
-	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));
-};
+}
+function turnToRadian(turns) {
+	return turns * piPi;
+}
+function degreeToTurn(degrees) {
+	return degrees / 360;
+}
+function radianToTurn(radians) {
+	return radians / piPi;
+}
 //#endregion
-//#region node_modules/.pnpm/@ixfx+visual@0.56.12/node_modules/@ixfx/visual/dist/colour-C3MQIjFJ.js
+//#region node_modules/.pnpm/@ixfx+visual@0.56.13/node_modules/@ixfx/visual/dist/colour-C3MQIjFJ.js
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
 	enumerable: true,
@@ -2377,7 +1971,7 @@ function wrapScalarHue(value) {
 	if (value < 0) return (1 - Math.abs(value)) % 1;
 	return value;
 }
-var hsl_exports = /* @__PURE__ */ __exportAll$1({
+var hsl_exports = /* @__PURE__ */ __exportAll({
 	absolute: () => absolute$1,
 	changeLightness: () => changeLightness$1,
 	fromCss: () => fromCss$3,
@@ -2714,7 +2308,7 @@ function toLibraryRgb(hsl) {
 		alpha: (hsl.opacity ?? 100) / 100 * 255
 	};
 }
-var srgb_exports = /* @__PURE__ */ __exportAll$1({
+var srgb_exports = /* @__PURE__ */ __exportAll({
 	changeLightness: () => changeLightness,
 	eightBit: () => eightBit$1,
 	fromCss: () => fromCss$2,
@@ -3025,7 +2619,7 @@ function toLibraryHsl(rgb) {
 		alpha: (rgb.opacity ?? 255) / 255
 	};
 }
-var oklch_exports = /* @__PURE__ */ __exportAll$1({
+var oklch_exports = /* @__PURE__ */ __exportAll({
 	OKLCH_CHROMA_MAX: () => OKLCH_CHROMA_MAX,
 	absolute: () => absolute,
 	fromCss: () => fromCss$1,
@@ -3968,7 +3562,7 @@ function decodeRgbFrom16Bit565(colour) {
 		space: `srgb`
 	};
 }
-var ycbcr_exports = /* @__PURE__ */ __exportAll$1({
+var ycbcr_exports = /* @__PURE__ */ __exportAll({
 	eightBit: () => eightBit,
 	fromCss: () => fromCss,
 	fromHexString: () => fromHexString,
@@ -4092,7 +3686,7 @@ function guard(rgb) {
 function toHexString(ycbcr) {
 	return toHexString$2(toSrgb8bit(ycbcr));
 }
-var colour_exports = /* @__PURE__ */ __exportAll$1({
+var colour_exports = /* @__PURE__ */ __exportAll({
 	HslSpace: () => hsl_exports,
 	OklchSpace: () => oklch_exports,
 	SrgbSpace: () => srgb_exports,
@@ -4133,6 +3727,6 @@ var colour_exports = /* @__PURE__ */ __exportAll$1({
 	withOpacity: () => withOpacity
 });
 //#endregion
-export { isPoint3d as A, guard$5 as C, isNull as D, isNaN as E, __exportAll as M, isPlaceholder as O, toString as S, isEmpty as T, getTwoPointParameters as _, Unit3d as a, to3d as b, angleRadianThreePoint as c, fromCartesian as d, rotate$1 as f, getPointParameter as g, distance2d as h, Unit as i, test as j, isPoint as k, average$1 as l, distance as m, Empty as n, angleRadian as o, toCartesian$1 as p, Empty3d as r, angleRadianCircle as s, colour_exports as t, averager as u, subtract as v, guardNonZeroPoint as w, toIntegerValues as x, to2d as y };
+export { radiansNormalise as a, isEmpty as c, isPlaceholder as d, isPoint as f, piPi as i, isNaN as l, pointTest as m, average$1 as n, guard$5 as o, isPoint3d as p, averager as r, guardNonZeroPoint as s, colour_exports as t, isNull as u };
 
-//# sourceMappingURL=colour-C3MQIjFJ-BLXg8W3U.js.map
+//# sourceMappingURL=colour-C3MQIjFJ-vRCdr8W-.js.map