@ixfx/components 0.2.4 → 0.2.6

package/dist/dist-D7kJgnSE.js

@@ -0,0 +1,1039 @@
+//#region node_modules/.pnpm/@ixfx+guards@0.56.12/node_modules/@ixfx/guards/dist/index.js
+function getErrorMessage(ex) {
+	if (typeof ex === `string`) return ex;
+	if (ex instanceof Error) return ex.message;
+	return String(ex);
+}
+/**
+* Throws an error if any result is a failure.
+* Error message will be the combined from all errors.
+* @param results
+*/
+function throwIfFailed(...results) {
+	const failed = results.filter((r) => resultIsError(r));
+	if (failed.length === 0) return;
+	const messages = failed.map((f) => resultErrorToString(f));
+	throw new Error(messages.join(`, `));
+}
+/**
+* If any of `results` is an error, throws it, otherwise ignored.
+* @param results
+* @returns _true_ or throws
+*/
+function resultThrow$1(...results) {
+	for (const r of results) {
+		if (r === void 0) continue;
+		if (typeof r === `boolean`) if (!r) throw IxfxError$1.fromString(`Guard failed: false result`);
+		else continue;
+		const rr = typeof r === `object` ? r : r();
+		if (rr === void 0) continue;
+		if (rr.success) continue;
+		throw resultToError$1(rr);
+	}
+	return true;
+}
+/**
+* Returns _true_ if `result` is an error
+* @param result
+*/
+function resultIsError(result) {
+	if (typeof result !== `object` || result === null) return false;
+	return !result.success;
+}
+var IxfxError$1 = class IxfxError extends Error {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+	}
+	static fromError(error, cause) {
+		const message = error.message;
+		const stack = error.stack;
+		const name = error.name;
+		const newError = new IxfxError(message, cause);
+		newError.stack = stack;
+		newError.name = `IxfxError(${name})`;
+		return newError;
+	}
+	static fromString(message, cause) {
+		const newError = new IxfxError(message, cause);
+		newError.name = `IxfxError`;
+		return newError;
+	}
+};
+/**
+* Gets the result as an Error
+* @param result
+*/
+function resultToError$1(result) {
+	if (typeof result.error === `string`) return IxfxError$1.fromString(result.error, result.info);
+	if (result.error instanceof Error) return IxfxError$1.fromError(result.error, result.info);
+	return IxfxError$1.fromString(JSON.stringify(result.error), result.info);
+}
+/**
+* Returns the error as a string.
+* @param result
+*/
+function resultErrorToString(result) {
+	if (result.error instanceof Error) return getErrorMessage(result.error);
+	if (typeof result.error === `string`) return result.error;
+	return JSON.stringify(result.error);
+}
+/**
+* Returns a {@link ResultError} using 'error' as the message.
+* @param error
+* @param info
+*/
+function errorResult(error, info) {
+	return {
+		success: false,
+		error,
+		info
+	};
+}
+/**
+* Returns first failed result or final value.
+* @param results
+*/
+function resultsCollate(...results) {
+	let rr;
+	for (const r of results) {
+		if (typeof r === `boolean`) {
+			if (r) continue;
+			return {
+				success: false,
+				error: `Guard failed: false result`
+			};
+		}
+		rr = typeof r === `object` ? r : r();
+		if (rr === void 0) continue;
+		if (!rr.success) return rr;
+	}
+	if (!rr) throw new Error(`No results`);
+	return rr;
+}
+/**
+* Checks if `t` is not a number or within specified range.
+* Returns `[false, reason:string]` if invalid or `[true]` if valid.
+* 
+* Alternatives: {@link integerTest} for additional integer check, {@link percentTest} for percentage-range.
+*
+* * (empty, default): must be a number type and not NaN.
+* * finite: must be a number, not NaN and not infinite
+* * positive: must be at least zero
+* * negative: must be zero or lower
+* * aboveZero: must be above zero
+* * belowZero: must be below zero
+* * percentage: must be within 0-1, inclusive
+* * nonZero: can be anything except zero
+* * bipolar: can be -1 to 1, inclusive
+* @param value Value to check
+* @param parameterName Name of parameter (for more helpful exception messages)
+* @param range Range to enforce
+* @returns
+*/
+const numberTest = (value, range = ``, parameterName = `?`, info) => {
+	if (value === null) return {
+		success: false,
+		error: `Parameter '${parameterName}' is null`,
+		info
+	};
+	if (typeof value === `undefined`) return {
+		success: false,
+		error: `Parameter '${parameterName}' is undefined`,
+		info
+	};
+	if (Number.isNaN(value)) return {
+		success: false,
+		error: `Parameter '${parameterName}' is NaN`,
+		info
+	};
+	if (typeof value !== `number`) return {
+		success: false,
+		error: `Parameter '${parameterName}' is not a number (${JSON.stringify(value)})`,
+		info
+	};
+	switch (range) {
+		case `finite`:
+			if (!Number.isFinite(value)) return {
+				success: false,
+				error: `Parameter '${parameterName} must be finite (Got: ${value})`,
+				info
+			};
+			break;
+		case `positive`:
+			if (value < 0) return {
+				success: false,
+				error: `Parameter '${parameterName}' must be at least zero (${value})`,
+				info
+			};
+			break;
+		case `negative`:
+			if (value > 0) return {
+				success: false,
+				error: `Parameter '${parameterName}' must be zero or lower (${value})`,
+				info
+			};
+			break;
+		case `aboveZero`:
+			if (value <= 0) return {
+				success: false,
+				error: `Parameter '${parameterName}' must be above zero (${value})`,
+				info
+			};
+			break;
+		case `belowZero`:
+			if (value >= 0) return {
+				success: false,
+				error: `Parameter '${parameterName}' must be below zero (${value})`,
+				info
+			};
+			break;
+		case `percentage`:
+			if (value > 1 || value < 0) return {
+				success: false,
+				error: `Parameter '${parameterName}' must be in percentage range (0 to 1). (${value})`,
+				info
+			};
+			break;
+		case `nonZero`:
+			if (value === 0) return {
+				success: false,
+				error: `Parameter '${parameterName}' must non-zero. (${value})`,
+				info
+			};
+			break;
+		case `bipolar`:
+			if (value > 1 || value < -1) return {
+				success: false,
+				error: `Parameter '${parameterName}' must be in bipolar percentage range (-1 to 1). (${value})`,
+				info
+			};
+			break;
+	}
+	return {
+		success: true,
+		value,
+		info
+	};
+};
+/**
+* Returns test of `value` being in the range of 0-1.
+* Equiv to `number(value, `percentage`);`
+*
+* This is the same as calling ```number(t, `percentage`)```
+* @param value Value to check
+* @param parameterName Param name for customising exception message
+* @returns
+*/
+const percentTest = (value, parameterName = `?`, info) => numberTest(value, `percentage`, parameterName, info);
+/**
+* Checks if `value` an integer and meets additional criteria.
+* See {@link numberTest} for guard details, or use that if integer checking is not required.
+*
+* Note:
+* * `bipolar` will mean -1, 0 or 1.
+* * positive: must be at least zero
+* * negative: must be zero or lower
+* * aboveZero: must be above zero
+* * belowZero: must be below zero
+* * percentage: must be within 0-1, inclusive
+* * nonZero: can be anything except zero
+* @param value Value to check
+* @param parameterName Param name for customising exception message
+* @param range Guard specifier.
+*/
+const integerTest = (value, range = ``, parameterName = `?`) => {
+	return resultsCollate(numberTest(value, range, parameterName), () => {
+		if (!Number.isInteger(value)) return {
+			success: false,
+			error: `Param '${parameterName}' is not an integer`
+		};
+		return {
+			success: true,
+			value
+		};
+	});
+};
+const numberInclusiveRangeTest = (value, min, max, parameterName = `?`) => {
+	if (typeof value !== `number`) return {
+		success: false,
+		error: `Param '${parameterName}' is not a number type. Got type: '${typeof value}' value: '${JSON.stringify(value)}'`
+	};
+	if (Number.isNaN(value)) return {
+		success: false,
+		error: `Param '${parameterName}' is not within range ${min}-${max}. Got: NaN`
+	};
+	if (Number.isFinite(value)) {
+		if (value < min) return {
+			success: false,
+			error: `Param '${parameterName}' is below range ${min}-${max}. Got: ${value}`
+		};
+		else if (value > max) return {
+			success: false,
+			error: `Param '${parameterName}' is above range ${min}-${max}. Got: ${value}`
+		};
+		return {
+			success: true,
+			value
+		};
+	} else return {
+		success: false,
+		error: `Param '${parameterName}' is not within range ${min}-${max}. Got: infinite`
+	};
+};
+const nullUndefTest = (value, parameterName = `?`) => {
+	if (typeof value === `undefined`) return {
+		success: false,
+		error: `${parameterName} param is undefined`
+	};
+	if (value === null) return {
+		success: false,
+		error: `${parameterName} param is null`
+	};
+	return {
+		success: true,
+		value
+	};
+};
+const functionTest$1 = (value, parameterName = `?`) => {
+	if (value === void 0) return {
+		success: false,
+		error: `Param '${parameterName}' is undefined. Expected: function.`
+	};
+	if (value === null) return {
+		success: false,
+		error: `Param '${parameterName}' is null. Expected: function.`
+	};
+	if (typeof value !== `function`) return {
+		success: false,
+		error: `Param '${parameterName}' is type '${typeof value}'. Expected: function`
+	};
+	return {
+		success: true,
+		value
+	};
+};
+/**
+* Tests_if `value` is a plain object
+* 
+* ```js
+* isPlainObject(`text`); // false
+* isPlainObject(document); // false
+* isPlainObject({ hello: `there` }); // true
+* ```
+* @param value 
+* @returns 
+*/
+const testPlainObject = (value) => {
+	if (typeof value !== `object` || value === null) return {
+		success: false,
+		error: `Value is null or not object type`
+	};
+	const prototype = Object.getPrototypeOf(value);
+	if ((prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value)) return {
+		success: true,
+		value
+	};
+	return {
+		success: false,
+		error: `Fancy object`
+	};
+};
+/**
+* Tests if `value` is primitive value (bigint,number,string or boolean) or plain object
+* @param value 
+* @returns 
+*/
+const testPlainObjectOrPrimitive = (value) => {
+	const t = typeof value;
+	if (t === `symbol`) return {
+		success: false,
+		error: `Symbol type`
+	};
+	if (t === `function`) return {
+		success: false,
+		error: `Function type`
+	};
+	if (t === `bigint`) return {
+		success: true,
+		value
+	};
+	if (t === `number`) return {
+		success: true,
+		value
+	};
+	if (t === `string`) return {
+		success: true,
+		value
+	};
+	if (t === `boolean`) return {
+		success: true,
+		value
+	};
+	return testPlainObject(value);
+};
+/**
+* Throws an error if parameter is not an string
+* @param value
+* @param parameterName
+*/
+const stringTest = (value, range = ``, parameterName = `?`) => {
+	if (typeof value !== `string`) return {
+		success: false,
+		error: `Param '${parameterName} is not type string. Got: ${typeof value}`
+	};
+	switch (range) {
+		case `non-empty`:
+			if (value.length === 0) return {
+				success: false,
+				error: `Param '${parameterName} is empty`
+			};
+			break;
+	}
+	return {
+		success: true,
+		value
+	};
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+arrays@0.56.12/node_modules/@ixfx/arrays/dist/index.js
+/**
+* If any of `results` is an error, throws it, otherwise ignored.
+* @param results
+* @returns _true_ or throws
+*/
+function resultThrow(...results) {
+	for (const r of results) {
+		if (r === void 0) continue;
+		if (typeof r === `boolean`) if (!r) throw IxfxError.fromString(`Guard failed: false result`);
+		else continue;
+		const rr = typeof r === `object` ? r : r();
+		if (rr === void 0) continue;
+		if (rr.success) continue;
+		throw resultToError(rr);
+	}
+	return true;
+}
+var IxfxError = class IxfxError extends Error {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+	}
+	static fromError(error, cause) {
+		const message = error.message;
+		const stack = error.stack;
+		const name = error.name;
+		const newError = new IxfxError(message, cause);
+		newError.stack = stack;
+		newError.name = `IxfxError(${name})`;
+		return newError;
+	}
+	static fromString(message, cause) {
+		const newError = new IxfxError(message, cause);
+		newError.name = `IxfxError`;
+		return newError;
+	}
+};
+/**
+* Gets the result as an Error
+* @param result
+*/
+function resultToError(result) {
+	if (typeof result.error === `string`) return IxfxError.fromString(result.error, result.info);
+	if (result.error instanceof Error) return IxfxError.fromError(result.error, result.info);
+	return IxfxError.fromString(JSON.stringify(result.error), result.info);
+}
+/**
+* Throws an error if parameter is not an array
+* @param value
+* @param parameterName
+*/
+const arrayTest = (value, parameterName = `?`) => {
+	if (!Array.isArray(value)) return {
+		success: false,
+		error: `Parameter '${parameterName}' is expected to be an array'`
+	};
+	return {
+		success: true,
+		value
+	};
+};
+const functionTest = (value, parameterName = `?`) => {
+	if (value === void 0) return {
+		success: false,
+		error: `Param '${parameterName}' is undefined. Expected: function.`
+	};
+	if (value === null) return {
+		success: false,
+		error: `Param '${parameterName}' is null. Expected: function.`
+	};
+	if (typeof value !== `function`) return {
+		success: false,
+		error: `Param '${parameterName}' is type '${typeof value}'. Expected: function`
+	};
+	return {
+		success: true,
+		value
+	};
+};
+/**
+* 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 
+* @returns 
+*/
+/**
+* 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;
+/**
+* Returns _true_ if array contains duplicate instances based on `===` equality checking.
+* 
+* ```js
+* const o1 = { hello: `there` };
+* const o2 = { hello: `there` };
+* containsDuplicateInstances([ o1, o2 ]); // False
+* containsDuplicateInstances([ o1, o1 ]); // True
+* ```
+* 
+* Primitive values are compared by value:
+* ```js
+* containsDuplicateInstances([ 1, 2, 1 ]); // True
+* containsDuplicateInstances([ `a`, `b`, `a` ]); // True
+* ```
+* 
+* Use {@link containsDuplicateValues} if you'd rather compare by value.
+* @param array 
+* @throws {TypeError} If `array` parameter is not an array
+* @returns 
+*/
+const containsDuplicateInstances = (array) => {
+	resultThrow(arrayTest(array, `array`));
+	for (let index = 0; index < array.length; index++) for (let x = 0; x < array.length; x++) {
+		if (index === x) continue;
+		if (array[index] === array[x]) return true;
+	}
+	return false;
+};
+/**
+* Yields pairs made up of overlapping items from the input array.
+* 
+* Throws an error if there are less than two entries.
+* 
+* ```js
+* pairwise([1, 2, 3, 4, 5]);
+* Yields:
+* [ [1,2], [2,3], [3,4], [4,5] ]
+* ```
+* @param values 
+*/
+function* pairwise(values) {
+	resultThrow(arrayTest(values, `values`));
+	if (values.length < 2) throw new Error(`Array needs to have at least two entries. Length: ${values.length}`);
+	for (let index = 1; index < values.length; index++) yield [values[index - 1], values[index]];
+}
+/**
+* Returns an array with value(s) omitted. 
+* 
+* If value is not found, result will be a copy of input.
+* Value checking is completed via the provided `comparer` function.
+* By default checking whether `a === b`. To compare based on value, use the `isEqualValueDefault` comparer.
+*
+* @example
+* ```js
+* const data = [100, 20, 40];
+* const filtered = without(data, 20); // [100, 40]
+* ```
+*
+* @example Using value-based comparison
+* ```js
+* const data = [{ name: `Alice` }, { name:`Sam` }];
+*
+* // This wouldn't work as expected, because the default comparer uses instance,
+* // not value:
+* without(data, { name: `Alice` });
+*
+* // So instead we can use a value comparer:
+* without(data, { name:`Alice` }, isEqualValueDefault);
+* ```
+*
+* @example Use a function
+* ```js
+* const data = [ { name: `Alice` }, { name:`Sam` }];
+* without(data, { name:`ALICE` }, (a, b) => {
+*  return (a.name.toLowerCase() === b.name.toLowerCase());
+* });
+* ```
+*
+* Consider {@link remove} to remove an item by index.
+*
+* @typeParam V - Type of array items
+* @param sourceArray Source array
+* @param toRemove Value(s) to remove
+* @param comparer Comparison function. If not provided `isEqualDefault` is used, which compares using `===`
+* @throws {TypeError} If `sourceArray` is not an array, or compare function is not a function
+* @return Copy of array without value.
+*/
+const without = (sourceArray, toRemove, comparer = isEqualDefault) => {
+	resultThrow(arrayTest(sourceArray, `sourceArray`), functionTest(comparer, `comparer`));
+	if (Array.isArray(toRemove)) {
+		const returnArray = [];
+		for (const source of sourceArray) if (!toRemove.some((v) => comparer(source, v))) returnArray.push(source);
+		return returnArray;
+	} else return sourceArray.filter((v) => !comparer(v, toRemove));
+};
+//#endregion
+//#region node_modules/.pnpm/@ixfx+numbers@0.56.12/node_modules/@ixfx/numbers/dist/index.js
+/**
+* Returns the dot product of arbitrary-sized arrays. Assumed they are of the same length.
+* @param values
+* @param nonNumber What to do if array contains an invalid number. Error: throw an exception, 'treat-as-zero' use as 0 instead, 'ignore', let math run with invalid number
+* @returns
+*/
+const dotProduct = (values, nonNumber = `ignore`) => {
+	let r = 0;
+	const length = values[0].length;
+	for (let index = 0; index < length; index++) {
+		let t = 0;
+		for (const [p, value] of values.entries()) {
+			let v = value[index];
+			if (Number.isNaN(v) || !Number.isFinite(v)) {
+				if (nonNumber === `treat-as-zero`) v = 0;
+				else if (nonNumber === `error`) throw new TypeError(`Invalid number at index ${index},${p}`);
+			}
+			if (p === 0) t = v;
+			else t *= v;
+		}
+		r += t;
+	}
+	return r;
+};
+/**
+* Clamps a value between min and max (both inclusive)
+* Defaults to a 0-1 range, useful for percentages.
+*
+* @example Usage
+* ```js
+* // 0.5 - just fine, within default of 0 to 1
+* clamp(0.5);
+* // 1 - above default max of 1
+* clamp(1.5);
+* // 0 - below range
+* clamp(-50, 0, 100);
+* // 50 - within range
+* clamp(50, 0, 50);
+* ```
+*
+* For clamping integer ranges, consider {@link clampIndex }
+* For clamping `{ x, y }` points, consider {@link https://api.ixfx.fun/_ixfx/geometry/Points/clamp/ @ixfx/geometry/Points.clamp}.
+* For clamping bipolar values: {@link Bipolar.clamp}
+* @param value Value to clamp
+* @param min value (inclusive)
+* @param max value (inclusive)
+* @returns Clamped value
+*/
+function clamp(value, min = 0, max = 1) {
+	if (Number.isNaN(value)) throw new Error(`Param 'value' is NaN`);
+	if (Number.isNaN(min)) throw new Error(`Param 'min' is NaN`);
+	if (Number.isNaN(max)) throw new Error(`Param 'max' is NaN`);
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+}
+/**
+* Returns a function that clamps values.
+*
+* ```js
+* const c = clamper(0,100);
+* c(50);   // 50
+* c(101); // 100
+* c(-5);  // 0
+* ```
+* @param min Minimum value. Default: 0
+* @param max Maximum value. Default: 1
+*/
+function clamper(min = 0, max = 1) {
+	if (Number.isNaN(min)) throw new Error(`Param 'min' is NaN`);
+	if (Number.isNaN(max)) throw new Error(`Param 'max' is NaN`);
+	return (v) => {
+		if (v > max) return max;
+		if (v < min) return min;
+		return v;
+	};
+}
+/**
+* Wraps floating point numbers to be within a range (default: 0..1). Use {@link wrapInteger} if you want to wrap integer values.
+*
+* This logic makes sense for some things like rotation angle.
+*
+* If you just want to lock values to a range without wrapping, consider {@link clamp}.
+*
+* ```js
+* wrap(1.2);   // 0.2
+* wrap(2);     // 1.0
+* wrap(-0.2); // 0.8
+* ```
+*
+* A range can be provided too:
+* ```js
+* wrap(30, 20, 50);  	 // 30
+* wrap(60, 20, 50);    //  30
+* ```
+* @param v
+* @param min
+* @param max
+* @returns
+*/
+const wrap = (v, min = 0, max = 1) => {
+	resultThrow$1(numberTest(v, ``, `min`), numberTest(min, ``, `min`), numberTest(max, ``, `max`));
+	if (v === min) return min;
+	if (v === max) return min;
+	while (v <= min || v >= max) {
+		if (v === max) break;
+		if (v === min) break;
+		if (v > max) v = min + (v - max);
+		else if (v < min) v = max - (min - v);
+	}
+	return v;
+};
+Math.PI * 2;
+/**
+* Interpolates between `a` and `b` by `amount`. Aka `lerp`.
+*
+* [ixfx Guide on Interpolation](https://ixfx.fun/data/interpolation/overview/)
+*
+* @example Get the halfway point between 30 and 60
+* ```js
+* interpolate(0.5, 30, 60);
+* ```
+*
+* See also {@link interpolatorStepped} and {@link https://api.ixfx.fun/_ixfx/modulation/interpolatorInterval/} for functions
+* which help to manage progression from A->B over steps or interval.
+* 
+* Usually interpolation amount is on a 0...1 scale, inclusive. What is the interpolation result
+* if this scale is exceeded? By default it is clamped to 0..1, so the return value is always between `a` and `b` (inclusive).
+* 
+* Alternatively, set the `limits` option to process `amount`:
+* * 'wrap': wrap amount, eg 1.5 is the same as 0.5, 2 is the same as 1
+* * 'ignore': allow exceeding values. eg 1.5 will yield b*1.5.
+* * 'clamp': default behaviour of clamping interpolation amount to 0..1
+* 
+* Interpolation can be non-linear using 'easing' option or 'transform' funciton.
+* ```js
+* interpolate(0.1, 0, 100, { easing: `quadIn` });
+* ```
+* There are a few variations when calling `interpolate`, depending on what parameters are fixed.
+* * `interpolate(amount)`: returns a function that needs a & b 
+* * `interpolate(a, b)`:  returns a function that needs the interpolation amount
+*/
+function interpolate(pos1, pos2, pos3, pos4) {
+	let amountProcess;
+	let limits = `clamp`;
+	const handleAmount = (amount) => {
+		if (amountProcess) amount = amountProcess(amount);
+		if (limits === void 0 || limits === `clamp`) amount = clamp(amount);
+		else if (limits === `wrap`) {
+			if (amount > 1) amount = amount % 1;
+			else if (amount < 0) amount = 1 + amount % 1;
+		}
+		return amount;
+	};
+	const doTheEase = (_amt, _a, _b) => {
+		resultThrow$1(numberTest(_a, ``, `a`), numberTest(_b, ``, `b`), numberTest(_amt, ``, `amount`));
+		_amt = handleAmount(_amt);
+		return (1 - _amt) * _a + _amt * _b;
+	};
+	const readOpts = (o = {}) => {
+		if (o.transform !== void 0) {
+			if (typeof o.transform !== `function`) throw new Error(`Param 'transform' is expected to be a function. Got: ${typeof o.transform}`);
+			amountProcess = o.transform;
+		}
+		limits = o.limits ?? `clamp`;
+	};
+	const rawEase = (_amt, _a, _b) => (1 - _amt) * _a + _amt * _b;
+	if (typeof pos1 !== `number`) throw new TypeError(`First param is expected to be a number. Got: ${typeof pos1}`);
+	if (typeof pos2 === `number`) {
+		let a;
+		let b;
+		if (pos3 === void 0 || typeof pos3 === `object`) {
+			a = pos1;
+			b = pos2;
+			readOpts(pos3);
+			return (amount) => doTheEase(amount, a, b);
+		} else if (typeof pos3 === `number`) {
+			a = pos2;
+			b = pos3;
+			readOpts(pos4);
+			return doTheEase(pos1, a, b);
+		} else throw new Error(`Values for 'a' and 'b' not defined`);
+	} else if (pos2 === void 0 || typeof pos2 === `object`) {
+		const amount = handleAmount(pos1);
+		readOpts(pos2);
+		resultThrow$1(numberTest(amount, ``, `amount`));
+		return (aValue, bValue) => rawEase(amount, aValue, bValue);
+	}
+}
+/**
+* Rounds a number.
+*
+* If one parameter is given, it's the decimal places,
+* and a rounding function is returned:
+* ```js
+* const r = round(2);
+* r(10.12355); // 10.12
+* ```
+*
+* If two parameters are given, the first is decimal places,
+* the second the value to round.
+* ```js
+* round(2, 10.12355); // 10.12
+* ```
+* @param decimalPlaces
+* @returns
+*/
+function round(a, b, roundUp) {
+	resultThrow$1(integerTest(a, `positive`, `decimalPlaces`));
+	const up = typeof b === `boolean` ? b : roundUp ?? false;
+	let rounder;
+	if (a === 0) rounder = Math.round;
+	else {
+		const p = Math.pow(10, a);
+		if (up) rounder = (v) => Math.ceil(v * p) / p;
+		else rounder = (v) => Math.floor(v * p) / p;
+	}
+	if (typeof b === `number`) return rounder(b);
+	return rounder;
+}
+Math.PI * 2;
+/**
+* A moving average calculator (exponential weighted moving average) which does not keep track of
+* previous samples. Less accurate, but uses less system resources.
+*
+* The `scaling` parameter determines smoothing. A value of `1` means that
+* the latest value is used as the average - that is, no smoothing. Higher numbers
+* introduce progressively more smoothing by weighting the accumulated prior average more heavily.
+*
+* ```
+* const ma = movingAverageLight(); // default scaling of 3
+* ma(50);  // 50
+* ma(100); // 75
+* ma(75);  // 75
+* ma(0);   // 50
+* ```
+*
+* Note that the final average of 50 is pretty far from the last value of 0. To make it more responsive,
+* we could use a lower scaling factor: `movingAverageLight(2)`. This yields a final average of `37.5` instead.
+*
+* @param scaling Scaling factor. 1 is no smoothing. Default: 3
+* @returns Function that adds to average.
+*/
+const movingAverageLight = (scaling = 3) => {
+	resultThrow$1(numberTest(scaling, `aboveZero`, `scaling`));
+	let average = 0;
+	let count = 0;
+	return (v) => {
+		if (numberTest(v, ``, `v`).success && v !== void 0) {
+			count++;
+			average = average + (v - average) / Math.min(count, scaling);
+		}
+		return average;
+	};
+};
+/**
+* Rounds `v` by `every`. Middle values are rounded up by default.
+*
+* ```js
+* quantiseEvery(11, 10);  // 10
+* quantiseEvery(25, 10);  // 30
+* quantiseEvery(0, 10);   // 0
+* quantiseEvery(4, 10);   // 0
+* quantiseEvery(100, 10); // 100
+* ```
+* 
+* Also works with decimals
+* ```js
+* quantiseEvery(1.123, 0.1); // 1.1
+* quantiseEvery(1.21, 0.1);  // 1.2
+* ```
+*
+* @param v Value to quantise
+* @param every Number to quantise to
+* @param middleRoundsUp If _true_ (default), the exact middle rounds up to next step.
+* @returns
+*/
+const quantiseEvery = (v, every, middleRoundsUp = true) => {
+	const everyString = every.toString();
+	const decimal = everyString.indexOf(`.`);
+	let multiplier = 1;
+	if (decimal >= 0) {
+		multiplier = 10 * everyString.substring(decimal + 1).length;
+		every = Math.floor(multiplier * every);
+		v = v * multiplier;
+	}
+	resultThrow$1(numberTest(v, ``, `v`), integerTest(every, ``, `every`));
+	let div = v / every;
+	const divModule = div % 1;
+	div = Math.floor(div);
+	if (divModule === .5 && middleRoundsUp || divModule > .5) div++;
+	return every * div / multiplier;
+};
+/**
+* Scales `v` from an input range to an output range (aka `map`)
+*
+* For example, if a sensor's useful range is 100-500, scale it to a percentage:
+*
+* ```js
+*
+* scale(sensorReading, 100, 500, 0, 1);
+* ```
+*
+* `scale` defaults to a percentage-range output, so you can get away with:
+* ```js
+* scale(sensorReading, 100, 500);
+* ```
+*
+* If `v` is outside of the input range, it will likewise be outside of the output range.
+* Use {@link scaleClamped} to clip value to range.
+*
+* If inMin and inMax are equal, outMax will be returned.
+*
+* An easing function can be provided for non-linear scaling. In this case
+* the input value is 'pre scaled' using the function before it is applied to the
+* output range.
+*
+* ```js
+* scale(sensorReading, 100, 500, 0, 1, Easings.gaussian());
+* ```
+* @param v Value to scale
+* @param inMin Input minimum
+* @param inMax Input maximum
+* @param outMin Output minimum. If not specified, 0
+* @param outMax Output maximum. If not specified, 1
+* @param easing Easing function
+* @returns Scaled value
+*/
+const scale = (v, inMin, inMax, outMin, outMax, easing) => scaler(inMin, inMax, outMin, outMax, easing)(v);
+/**
+* Returns a scaling function
+* @param inMin Input minimum
+* @param inMax Input maximum
+* @param outMin Output minimum. If not specified, 0
+* @param outMax Output maximum. If not specified, 1
+* @param easing Easing function
+* @param clamped If true, value is clamped. Default: false
+* @returns
+*/
+const scaler = (inMin, inMax, outMin, outMax, easing, clamped) => {
+	resultThrow$1(numberTest(inMin, `finite`, `inMin`), numberTest(inMax, `finite`, `inMax`));
+	const oMax = outMax ?? 1;
+	const oMin = outMin ?? 0;
+	const clampFunction = clamped ? clamper(outMin, outMax) : void 0;
+	return (v) => {
+		if (inMin === inMax) return oMax;
+		let a = (v - inMin) / (inMax - inMin);
+		if (easing !== void 0) a = easing(a);
+		const x = a * (oMax - oMin) + oMin;
+		if (clampFunction) return clampFunction(x);
+		return x;
+	};
+};
+/**
+* As {@link scale}, but result is clamped to be
+* within `outMin` and `outMax`. Useful if you can't be sure
+* that `v` is in 0..1 range.
+*
+* @param value
+* @param inMin
+* @param inMax
+* @param outMin 1 by default
+* @param outMax 0 by default d
+* @param easing
+* @returns
+*/
+const scaleClamped = (value, inMin, inMax, outMin, outMax, easing) => {
+	if (typeof outMax === `undefined`) outMax = 1;
+	if (typeof outMin === `undefined`) outMin = 0;
+	if (inMin === inMax) return outMax;
+	return clamp(scale(value, inMin, inMax, outMin, outMax, easing), outMin, outMax);
+};
+/**
+* Returns an empty range:
+* ```js
+* { 
+*  min: Number.MAX_SAFE_INTEGER, 
+*  max: Number.MIN_SAFE_INTEGER 
+* }
+* ```
+* @returns 
+*/
+const rangeInit = () => ({
+	min: Number.MAX_SAFE_INTEGER,
+	max: Number.MIN_SAFE_INTEGER
+});
+/**
+* Keeps track of min/max values.
+* 
+* ```js
+* const s = rangeStream();
+* s.seen(10);  // { min: 10, max: 10 }
+* s.seen(5);   // { min: 5,  max: 10 }
+* ```
+* 
+* When calling `seen()`, non-numbers, or non-finite numbers are silently ignored.
+* 
+* ```js
+* s.reset();   // Reset
+* s.min/s.max; // Current min/max
+* s.range;     // Current { min, max }
+* ```
+* @param initWith 
+* @returns 
+*/
+const rangeStream = (initWith = rangeInit()) => {
+	let { min, max } = initWith;
+	const seen = (v) => {
+		if (typeof v === `number`) {
+			if (!Number.isNaN(v) && Number.isFinite(v)) {
+				min = Math.min(min, v);
+				max = Math.max(max, v);
+			}
+		}
+		return {
+			min,
+			max
+		};
+	};
+	const reset = () => {
+		min = Number.MAX_SAFE_INTEGER;
+		max = Number.MIN_SAFE_INTEGER;
+		return {
+			min,
+			max
+		};
+	};
+	return {
+		seen,
+		reset,
+		get range() {
+			return {
+				min,
+				max
+			};
+		},
+		get min() {
+			return min;
+		},
+		get max() {
+			return max;
+		}
+	};
+};
+//#endregion
+export { resultThrow$1 as C, throwIfFailed as E, percentTest as S, testPlainObjectOrPrimitive as T, functionTest$1 as _, movingAverageLight as a, numberInclusiveRangeTest as b, round as c, scaler as d, wrap as f, errorResult as g, without as h, interpolate as i, scale as l, pairwise as m, clamper as n, quantiseEvery as o, containsDuplicateInstances as p, dotProduct as r, rangeStream as s, clamp as t, scaleClamped as u, integerTest as v, stringTest as w, numberTest as x, nullUndefTest as y };
+
+//# sourceMappingURL=dist-D7kJgnSE.js.map