@octanejs/recharts 0.1.0

package/src/util/isDomainSpecifiedByUser.js

@@ -0,0 +1,255 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/isDomainSpecifiedByUser.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+function _slicedToArray(r, e) {
+	return (
+		_arrayWithHoles(r) ||
+		_iterableToArrayLimit(r, e) ||
+		_unsupportedIterableToArray(r, e) ||
+		_nonIterableRest()
+	);
+}
+function _nonIterableRest() {
+	throw new TypeError(
+		'Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
+	);
+}
+function _unsupportedIterableToArray(r, a) {
+	if (r) {
+		if ('string' == typeof r) return _arrayLikeToArray(r, a);
+		var t = {}.toString.call(r).slice(8, -1);
+		return (
+			'Object' === t && r.constructor && (t = r.constructor.name),
+			'Map' === t || 'Set' === t
+				? Array.from(r)
+				: 'Arguments' === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
+					? _arrayLikeToArray(r, a)
+					: void 0
+		);
+	}
+}
+function _arrayLikeToArray(r, a) {
+	(null == a || a > r.length) && (a = r.length);
+	for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+	return n;
+}
+function _iterableToArrayLimit(r, l) {
+	var t =
+		null == r ? null : ('undefined' != typeof Symbol && r[Symbol.iterator]) || r['@@iterator'];
+	if (null != t) {
+		var e,
+			n,
+			i,
+			u,
+			a = [],
+			f = !0,
+			o = !1;
+		try {
+			if (((i = (t = t.call(r)).next), 0 === l)) {
+				if (Object(t) !== t) return;
+				f = !1;
+			} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+		} catch (r) {
+			((o = !0), (n = r));
+		} finally {
+			try {
+				if (!f && null != t.return && ((u = t.return()), Object(u) !== u)) return;
+			} finally {
+				if (o) throw n;
+			}
+		}
+		return a;
+	}
+}
+function _arrayWithHoles(r) {
+	if (Array.isArray(r)) return r;
+}
+import { MAX_VALUE_REG, MIN_VALUE_REG } from './ChartUtils';
+import { isNumber } from './DataUtils';
+import { isWellBehavedNumber } from './isWellBehavedNumber';
+export function isWellFormedNumberDomain(v) {
+	if (Array.isArray(v) && v.length === 2) {
+		var _v = _slicedToArray(v, 2),
+			min = _v[0],
+			max = _v[1];
+		if (isWellBehavedNumber(min) && isWellBehavedNumber(max)) {
+			return true;
+		}
+	}
+	return false;
+}
+export function extendDomain(providedDomain, boundaryDomain, allowDataOverflow) {
+	if (allowDataOverflow) {
+		// If the data are allowed to overflow - we're fine with whatever user provided
+		return providedDomain;
+	}
+	/*
+	 * If the data are not allowed to overflow - we need to extend the domain.
+	 * Means that effectively the user is allowed to make the domain larger
+	 * but not smaller.
+	 */
+	return [
+		Math.min(providedDomain[0], boundaryDomain[0]),
+		Math.max(providedDomain[1], boundaryDomain[1]),
+	];
+}
+
+/**
+ * So Recharts allows users to provide their own domains,
+ * but it also places some expectations on what the domain is.
+ * We can improve on the typescript typing, but we also need a runtime test
+ to observe that the user-provided domain is well-formed,
+ * that is: an array with exactly two numbers.
+ *
+ * This function does not accept data as an argument.
+ * This is to enable a performance optimization - if the domain is there,
+ * and we know what it is without traversing all the data,
+ * then we don't have to traverse all the data!
+ *
+ * If the user-provided domain is not well-formed,
+ * this function will return undefined - in which case we should traverse the data to calculate the real domain.
+ *
+ * This function is for parsing the numerical domain only.
+ *
+ * @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+ * @param allowDataOverflow boolean, provided by users. If true then the data domain wins
+ *
+ * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+ */
+export function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDataOverflow) {
+	if (!allowDataOverflow) {
+		// Cannot compute data overflow if the data is not provided
+		return undefined;
+	}
+	if (typeof userDomain === 'function') {
+		// The user function expects the data to be provided as an argument
+		return undefined;
+	}
+	if (Array.isArray(userDomain) && userDomain.length === 2) {
+		var _userDomain = _slicedToArray(userDomain, 2),
+			providedMin = _userDomain[0],
+			providedMax = _userDomain[1];
+		var finalMin, finalMax;
+		if (isWellBehavedNumber(providedMin)) {
+			finalMin = providedMin;
+		} else if (typeof providedMin === 'function') {
+			// The user function expects the data to be provided as an argument
+			return undefined;
+		}
+		if (isWellBehavedNumber(providedMax)) {
+			finalMax = providedMax;
+		} else if (typeof providedMax === 'function') {
+			// The user function expects the data to be provided as an argument
+			return undefined;
+		}
+		var candidate = [finalMin, finalMax];
+		if (isWellFormedNumberDomain(candidate)) {
+			return candidate;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * So Recharts allows users to provide their own domains,
+ * but it also places some expectations on what the domain is.
+ * We can improve on the typescript typing, but we also need a runtime test
+ * to observe that the user-provided domain is well-formed,
+ * that is: an array with exactly two numbers.
+ * If the user-provided domain is not well-formed,
+ * this function will return undefined - in which case we should traverse the data to calculate the real domain.
+ *
+ * This function is for parsing the numerical domain only.
+ *
+ * You are probably thinking, why does domain need tick count?
+ * Well it adjusts the domain based on where the "nice ticks" land, and nice ticks depend on the tick count.
+ *
+ * @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+ * @param dataDomain calculated from data. Can be undefined, as an option for performance optimization
+ * @param allowDataOverflow provided by users. If true then the data domain wins
+ *
+ * @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+ */
+export function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverflow) {
+	if (!allowDataOverflow && dataDomain == null) {
+		// Cannot compute data overflow if the data is not provided
+		return undefined;
+	}
+	if (typeof userDomain === 'function' && dataDomain != null) {
+		try {
+			var result = userDomain(dataDomain, allowDataOverflow);
+			if (isWellFormedNumberDomain(result)) {
+				return extendDomain(result, dataDomain, allowDataOverflow);
+			}
+		} catch (_unused) {
+			/* ignore the exception and compute domain from data later */
+		}
+	}
+	if (Array.isArray(userDomain) && userDomain.length === 2) {
+		var _userDomain2 = _slicedToArray(userDomain, 2),
+			providedMin = _userDomain2[0],
+			providedMax = _userDomain2[1];
+		var finalMin, finalMax;
+		if (providedMin === 'auto') {
+			if (dataDomain != null) {
+				finalMin = Math.min(...dataDomain);
+			}
+		} else if (isNumber(providedMin)) {
+			finalMin = providedMin;
+		} else if (typeof providedMin === 'function') {
+			try {
+				if (dataDomain != null) {
+					finalMin = providedMin(
+						dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[0],
+					);
+				}
+			} catch (_unused2) {
+				/* ignore the exception and compute domain from data later */
+			}
+		} else if (typeof providedMin === 'string' && MIN_VALUE_REG.test(providedMin)) {
+			var match = MIN_VALUE_REG.exec(providedMin);
+			if (match == null || match[1] == null || dataDomain == null) {
+				finalMin = undefined;
+			} else {
+				var value = +match[1];
+				finalMin = dataDomain[0] - value;
+			}
+		} else {
+			finalMin = dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[0];
+		}
+		if (providedMax === 'auto') {
+			if (dataDomain != null) {
+				finalMax = Math.max(...dataDomain);
+			}
+		} else if (isNumber(providedMax)) {
+			finalMax = providedMax;
+		} else if (typeof providedMax === 'function') {
+			try {
+				if (dataDomain != null) {
+					finalMax = providedMax(
+						dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[1],
+					);
+				}
+			} catch (_unused3) {
+				/* ignore the exception and compute domain from data later */
+			}
+		} else if (typeof providedMax === 'string' && MAX_VALUE_REG.test(providedMax)) {
+			var _match = MAX_VALUE_REG.exec(providedMax);
+			if (_match == null || _match[1] == null || dataDomain == null) {
+				finalMax = undefined;
+			} else {
+				var _value = +_match[1];
+				finalMax = dataDomain[1] + _value;
+			}
+		} else {
+			finalMax = dataDomain === null || dataDomain === void 0 ? void 0 : dataDomain[1];
+		}
+		var candidate = [finalMin, finalMax];
+		if (isWellFormedNumberDomain(candidate)) {
+			if (dataDomain == null) {
+				return candidate;
+			}
+			return extendDomain(candidate, dataDomain, allowDataOverflow);
+		}
+	}
+	return undefined;
+}

package/src/util/isWellBehavedNumber.js

@@ -0,0 +1,8 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/isWellBehavedNumber.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+export function isWellBehavedNumber(n) {
+	return Number.isFinite(n);
+}
+export function isPositiveNumber(n) {
+	return typeof n === 'number' && n > 0 && Number.isFinite(n);
+}

package/src/util/propsAreEqual.js

@@ -0,0 +1,96 @@
+// Vendored from recharts@3.9.2 es6/util/propsAreEqual.js with ONE adaptation:
+// shallowEqual comes from @octanejs/redux instead of react-redux (identical
+// algorithm). Update by re-vendoring when the recharts devDependency moves.
+import { shallowEqual } from '@octanejs/redux';
+var propsToShallowCompare = new Set([
+	'axisLine',
+	'tickLine',
+	'activeBar',
+	'activeDot',
+	'activeLabel',
+	'activeShape',
+	'allowEscapeViewBox',
+	'background',
+	'cursor',
+	'dot',
+	'label',
+	'line',
+	'margin',
+	'padding',
+	'position',
+	'shape',
+	'style',
+	'tick',
+	'wrapperStyle',
+	// radius can be an array of 4 numbers, easy to compare shallowly
+	'radius',
+	'throttledEvents',
+]);
+
+/**
+ * When comparing two values, returns true if they are the same value or
+ * are both NaN.
+ *
+ * If we used just a simple triple equals, we would get false negatives for two NaNs
+ * which could cause extra re-renders so let's have this instead.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Equality_comparisons_and_sameness#same-value-zero_equality
+ *
+ * @param x first value to compare
+ * @param y second value to compare
+ * return true if the same, false if different
+ */
+function sameValueZero(x, y) {
+	if (x == null && y == null) {
+		/*
+		 * treat null and undefined as equal. Internally in Recharts we make no difference between these two
+		 * so there is no need to re-render.
+		 */
+		return true;
+	}
+	if (typeof x === 'number' && typeof y === 'number') {
+		// x and y are equal (this is true for -0 and 0) or they are both NaN
+		// eslint-disable-next-line no-self-compare
+		return x === y || (x !== x && y !== y);
+	}
+	return x === y;
+}
+
+/**
+ * So usually React would compare only the first level of props using Object.is.
+ * However, in our case many props are objects or arrays, and our own docs recommend to do that!
+ * Therefore, we need a custom comparison function that does a shallow comparison of each prop value.
+ *
+ * Because charts can and do receive large props (typically the data array),
+ * we only limit this to a subset of known props that are likely to be objects/arrays.
+ *
+ * @param prevProps
+ * @param nextProps
+ */
+export function propsAreEqual(prevProps, nextProps) {
+	var allKeys = new Set([...Object.keys(prevProps), ...Object.keys(nextProps)]);
+	for (var key of allKeys) {
+		/*
+		 * If a key is on a special allowlist, go one level deeper
+		 * and do a shallow comparison of the values.
+		 */
+		if (propsToShallowCompare.has(key)) {
+			if (prevProps[key] == null && nextProps[key] == null) {
+				/*
+				 * treat null and undefined as equal. Internally in Recharts we make no difference between these two
+				 * so there is no need to re-render.
+				 */
+				continue;
+			}
+			if (!shallowEqual(prevProps[key], nextProps[key])) {
+				return false;
+			}
+			/*
+			 * Otherwise do a simple same-value comparison (with NaN support).
+			 */
+		} else if (!sameValueZero(prevProps[key], nextProps[key])) {
+			return false;
+		}
+	}
+	return true;
+}

package/src/util/resolveDefaultProps.js

@@ -0,0 +1,131 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/resolveDefaultProps.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		(r &&
+			(o = o.filter(function (r) {
+				return Object.getOwnPropertyDescriptor(e, r).enumerable;
+			})),
+			t.push.apply(t, o));
+	}
+	return t;
+}
+function _objectSpread(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2
+			? ownKeys(Object(t), !0).forEach(function (r) {
+					_defineProperty(e, r, t[r]);
+				})
+			: Object.getOwnPropertyDescriptors
+				? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t))
+				: ownKeys(Object(t)).forEach(function (r) {
+						Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+					});
+	}
+	return e;
+}
+function _defineProperty(e, r, t) {
+	return (
+		(r = _toPropertyKey(r)) in e
+			? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 })
+			: (e[r] = t),
+		e
+	);
+}
+function _toPropertyKey(t) {
+	var i = _toPrimitive(t, 'string');
+	return 'symbol' == typeof i ? i : i + '';
+}
+function _toPrimitive(t, r) {
+	if ('object' != typeof t || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || 'default');
+		if ('object' != typeof i) return i;
+		throw new TypeError('@@toPrimitive must return a primitive value.');
+	}
+	return ('string' === r ? String : Number)(t);
+}
+/**
+ * This function mimics the behavior of the `defaultProps` static property in React.
+ * Functional components do not have a defaultProps property, so this function is useful to resolve default props.
+ *
+ * The common recommendation is to use ES6 destructuring with default values in the function signature,
+ * but you need to be careful there and make sure you destructure all the individual properties
+ * and not the whole object. See the test file for example.
+ *
+ * And because destructuring all properties one by one is a faff, and it's easy to miss one property,
+ * this function exists.
+ *
+ * @param realProps - the props object passed to the component by the user
+ * @param defaultProps - the default props object defined in the component by Recharts
+ * @returns - the props object with all the default props resolved. All `undefined` values are replaced with the default value.
+ */
+export function resolveDefaultProps(realProps, defaultProps) {
+	/*
+	 * To avoid mutating the original `realProps` object passed to the function, create a shallow copy of it.
+	 * `resolvedProps` will be modified directly with the defaults.
+	 */
+	var resolvedProps = _objectSpread({}, realProps);
+	/*
+	 * Since the function guarantees `D extends Partial<T>`, this assignment is safe.
+	 * It allows TypeScript to work with the well-defined `Partial<T>` type inside the loop,
+	 * making subsequent type inference (especially for `dp[key]`) much more straightforward for the compiler.
+	 * This is a key step to improve type safety *without* value assertions later.
+	 */
+	var dp = defaultProps;
+	/*
+	 * `Object.keys` doesn't preserve strong key types - it always returns Array<string>.
+	 * However, due to the `D extends Partial<T>` constraint,
+	 * we know these keys *must* also be valid keys of `T`.
+	 * This assertion informs TypeScript of this relationship, avoiding type errors when using `key` to index `acc` (type T).
+	 *
+	 * Type assertions are not sound but in this case it's necessary
+	 * as `Object.keys` does not do what we want it to do.
+	 */
+	var keys = Object.keys(defaultProps);
+	var withDefaults = keys.reduce((acc, key) => {
+		if (acc[key] === undefined && dp[key] !== undefined) {
+			acc[key] = dp[key];
+		}
+		return acc;
+	}, resolvedProps);
+	/*
+	 * And again type assertions are not safe but here we have done the runtime work
+	 * so let's bypass the lack of static type safety and tell the compiler what happened.
+	 */
+	return withDefaults;
+}
+
+/**
+ * Helper type to extract the keys of T that are required.
+ * It iterates through each key K in T. If Pick<T, K> cannot be assigned an empty object {},
+ * it means K is required, so we keep K; otherwise, we discard it (never).
+ * [keyof T] at the end creates a union of the kept keys.
+ */
+
+/**
+ * Helper type to extract the keys of T that are optional.
+ * It iterates through each key K in T. If Pick<T, K> can be assigned an empty object {},
+ * it means K is optional (or potentially missing), so we keep K; otherwise, we discard it (never).
+ * [keyof T] at the end creates a union of the kept keys.
+ */
+
+/**
+ * Helper type to ensure keys of D exist in T.
+ * For each key K in D, if K is also a key of T, keep the type D[K].
+ * If K is NOT a key of T, map it to type `never`.
+ * An object cannot have a property of type `never`, effectively disallowing extra keys.
+ */
+
+/**
+ * This type will take a source type `Props` and a default type `Defaults` and will return a new type
+ * where all properties that are optional in `Props` but required in `Defaults` are made required in the result.
+ * Properties that are required in `Props` and optional in `Defaults` will remain required.
+ * Properties that are optional in both `Props` and `Defaults` will remain optional.
+ *
+ * This is useful for creating a type that represents the resolved props of a component with default props.
+ */

package/src/util/round.js

@@ -0,0 +1,39 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/round.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+// if you go lower than 3, wild wild things happen during rendering
+var defaultRoundPrecision = 4;
+export function round(num) {
+	var roundPrecision =
+		arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultRoundPrecision;
+	var factor = 10 ** roundPrecision;
+	var rounded = Math.round(num * factor) / factor;
+	if (Object.is(rounded, -0)) {
+		return 0;
+	}
+	return rounded;
+}
+
+/**
+ * This function will accept a string template literal and for each
+ * variable placeholder, it will round the value to avoid long float numbers in
+ * the SVG path which might cause rendering issues in some browsers.
+ */
+export function roundTemplateLiteral(strings) {
+	for (
+		var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1;
+		_key < _len;
+		_key++
+	) {
+		values[_key - 1] = arguments[_key];
+	}
+	return strings.reduce((result, string, i) => {
+		var value = values[i - 1];
+		if (typeof value === 'string') {
+			return result + value + string;
+		}
+		if (value !== undefined) {
+			return result + round(value) + string;
+		}
+		return result + string;
+	}, '');
+}

package/src/util/scale/RechartsScale.js

@@ -0,0 +1,68 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/scale/RechartsScale.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+/**
+ * This is internal representation of scale used in Recharts.
+ * Users will provide CustomScaleDefinition or a string, which we will parse into RechartsScale.
+ * Most importantly, RechartsScale is fully immutable - there are no setters that mutate the scale in place.
+ * This is important for React integration - if the scale changes, we want to trigger re-renders.
+ * Mutating the scale in place would not trigger re-renders, leading to stale UI.
+ */
+
+/**
+ * Position within a band for banded scales.
+ * In scales that are not banded, this parameter is ignored.
+ *
+ * @inline
+ */
+
+export function rechartsScaleFactory(d3Scale) {
+	if (d3Scale == null) {
+		return undefined;
+	}
+	var ticksFn = d3Scale.ticks;
+	var bandwidthFn = d3Scale.bandwidth;
+	var d3Range = d3Scale.range();
+	var range = [Math.min(...d3Range), Math.max(...d3Range)];
+	return {
+		domain: () => d3Scale.domain(),
+		range: (function (_range) {
+			function range() {
+				return _range.apply(this, arguments);
+			}
+			range.toString = function () {
+				return _range.toString();
+			};
+			return range;
+		})(() => range),
+		rangeMin: () => range[0],
+		rangeMax: () => range[1],
+		isInRange(value) {
+			var first = range[0];
+			var last = range[1];
+			return first <= last ? value >= first && value <= last : value >= last && value <= first;
+		},
+		bandwidth: bandwidthFn ? () => bandwidthFn.call(d3Scale) : undefined,
+		ticks: ticksFn ? (count) => ticksFn.call(d3Scale, count) : undefined,
+		map: (input, options) => {
+			var baseValue = d3Scale(input);
+			if (baseValue == null) {
+				return undefined;
+			}
+			if (d3Scale.bandwidth && options !== null && options !== void 0 && options.position) {
+				var bandWidth = d3Scale.bandwidth();
+				switch (options.position) {
+					case 'middle':
+						baseValue += bandWidth / 2;
+						break;
+					case 'end':
+						baseValue += bandWidth;
+						break;
+					default:
+						// 'start' requires no adjustment
+						break;
+				}
+			}
+			return baseValue;
+		},
+	};
+}

package/src/util/scale/createCategoricalInverse.js

@@ -0,0 +1,77 @@
+// Vendored verbatim from recharts@3.9.2 es6/util/scale/createCategoricalInverse.js (framework-agnostic).
+// Do not edit — update by re-vendoring when the recharts devDependency moves.
+/**
+ * Binary search to find the index where x would fit in array a.
+ * Works for arrays that are sorted both ascending and descending.
+ *
+ * Unlike d3.bisect, this implementation handles both ascending and descending arrays.
+ *
+ * @param haystack Sorted array of numbers
+ * @param needle Number to find the insertion index for
+ * @returns Index where x would fit in array a
+ */
+export function bisect(haystack, needle) {
+	var lo = 0;
+	var hi = haystack.length;
+	var ascending = haystack[0] < haystack[haystack.length - 1];
+	while (lo < hi) {
+		var mid = Math.floor((lo + hi) / 2);
+		if (ascending ? haystack[mid] < needle : haystack[mid] > needle) {
+			lo = mid + 1;
+		} else {
+			hi = mid;
+		}
+	}
+	return lo;
+}
+
+/**
+ * Computes an inverse scale function for categorical/ordinal scales.
+ * Uses bisect to find the closest domain value for a given pixel coordinate.
+ */
+export function createCategoricalInverse(scale, allDataPointsOnAxis) {
+	if (!scale) {
+		return undefined;
+	}
+	var domain =
+		allDataPointsOnAxis !== null && allDataPointsOnAxis !== void 0
+			? allDataPointsOnAxis
+			: scale.domain();
+	// Build an array of pixel positions for each domain value
+	// @ts-expect-error we're attempting to scale unknown without having guarantee that it is a Domain type
+	var pixelPositions = domain.map((d) => {
+		var _scale;
+		return (_scale = scale(d)) !== null && _scale !== void 0 ? _scale : 0;
+	});
+	var range = scale.range();
+	if (domain.length === 0 || range.length < 2) {
+		return undefined;
+	}
+	return (pixelValue) => {
+		var _pixelPositions, _pixelPositions$index;
+		// Find the closest domain value using bisect
+		var index = bisect(pixelPositions, pixelValue);
+
+		// Clamp to valid range
+		if (index <= 0) {
+			return domain[0];
+		}
+		if (index >= domain.length) {
+			return domain[domain.length - 1];
+		}
+
+		// Check which neighbor is closer
+		var leftPixel =
+			(_pixelPositions = pixelPositions[index - 1]) !== null && _pixelPositions !== void 0
+				? _pixelPositions
+				: 0;
+		var rightPixel =
+			(_pixelPositions$index = pixelPositions[index]) !== null && _pixelPositions$index !== void 0
+				? _pixelPositions$index
+				: 0;
+		if (Math.abs(pixelValue - leftPixel) <= Math.abs(pixelValue - rightPixel)) {
+			return domain[index - 1];
+		}
+		return domain[index];
+	};
+}