@sprawlify/primitives 0.0.1

package/dist/utils-_6frwjgJ.cjs

@@ -0,0 +1,1040 @@
+const require_defineProperty = require('./defineProperty-BoUOT9Ie.cjs');
+
+//#region src/shared/utils/array.ts
+function toArray(v) {
+	if (v == null) return [];
+	return Array.isArray(v) ? v : [v];
+}
+const fromLength = (length) => Array.from(Array(length).keys());
+const first = (v) => v[0];
+const last = (v) => v[v.length - 1];
+const isEmpty = (v) => v.length === 0;
+const has = (v, t) => v.indexOf(t) !== -1;
+const add = (v, ...items) => v.concat(items);
+const remove = (v, ...items) => v.filter((t) => !items.includes(t));
+const removeAt = (v, i) => v.filter((_, idx) => idx !== i);
+const insertAt = (v, i, ...items) => [
+	...v.slice(0, i),
+	...items,
+	...v.slice(i)
+];
+const uniq = (v) => Array.from(new Set(v));
+const diff = (a, b) => {
+	const set = new Set(b);
+	return a.filter((t) => !set.has(t));
+};
+const addOrRemove = (v, item) => has(v, item) ? remove(v, item) : add(v, item);
+function clear(v) {
+	while (v.length > 0) v.pop();
+	return v;
+}
+function nextIndex(v, idx, opts = {}) {
+	const { step = 1, loop = true } = opts;
+	const next$1 = idx + step;
+	const len = v.length;
+	const last$1 = len - 1;
+	if (idx === -1) return step > 0 ? 0 : last$1;
+	if (next$1 < 0) return loop ? last$1 : 0;
+	if (next$1 >= len) return loop ? 0 : idx > len ? len : idx;
+	return next$1;
+}
+function next(v, idx, opts = {}) {
+	return v[nextIndex(v, idx, opts)];
+}
+function prevIndex(v, idx, opts = {}) {
+	const { step = 1, loop = true } = opts;
+	return nextIndex(v, idx, {
+		step: -step,
+		loop
+	});
+}
+function prev(v, index, opts = {}) {
+	return v[prevIndex(v, index, opts)];
+}
+function chunk(v, size) {
+	return v.reduce((rows, value, index) => {
+		if (index % size === 0) rows.push([value]);
+		else last(rows)?.push(value);
+		return rows;
+	}, []);
+}
+function flatArray(arr) {
+	return arr.reduce((flat, item) => {
+		if (Array.isArray(item)) return flat.concat(flatArray(item));
+		return flat.concat(item);
+	}, []);
+}
+function partition(arr, fn) {
+	return arr.reduce(([pass, fail], value) => {
+		if (fn(value)) pass.push(value);
+		else fail.push(value);
+		return [pass, fail];
+	}, [[], []]);
+}
+
+//#endregion
+//#region src/shared/utils/equal.ts
+const isArrayLike = (value) => value?.constructor.name === "Array";
+const isArrayEqual = (a, b) => {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!isEqual(a[i], b[i])) return false;
+	return true;
+};
+const isEqual = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (a == null && b != null || a != null && b == null) return false;
+	if (typeof a?.isEqual === "function" && typeof b?.isEqual === "function") return a.isEqual(b);
+	if (typeof a === "function" && typeof b === "function") return a.toString() === b.toString();
+	if (isArrayLike(a) && isArrayLike(b)) return isArrayEqual(Array.from(a), Array.from(b));
+	if (!(typeof a === "object") || !(typeof b === "object")) return false;
+	const keys = Object.keys(b ?? Object.create(null));
+	const length = keys.length;
+	for (let i = 0; i < length; i++) if (!Reflect.has(a, keys[i])) return false;
+	for (let i = 0; i < length; i++) {
+		const key = keys[i];
+		if (!isEqual(a[key], b[key])) return false;
+	}
+	return true;
+};
+
+//#endregion
+//#region src/shared/utils/guard.ts
+const isDev = () => process.env.NODE_ENV !== "production";
+const isArray = (v) => Array.isArray(v);
+const isBoolean = (v) => v === true || v === false;
+const isObjectLike = (v) => v != null && typeof v === "object";
+const isObject = (v) => isObjectLike(v) && !isArray(v);
+const isNumber = (v) => typeof v === "number" && !Number.isNaN(v);
+const isString = (v) => typeof v === "string";
+const isFunction = (v) => typeof v === "function";
+const isNull = (v) => v == null;
+const hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+const baseGetTag = (v) => Object.prototype.toString.call(v);
+const fnToString = Function.prototype.toString;
+const objectCtorString = fnToString.call(Object);
+const isPlainObject = (v) => {
+	if (!isObjectLike(v) || baseGetTag(v) != "[object Object]" || isFrameworkElement(v)) return false;
+	const proto = Object.getPrototypeOf(v);
+	if (proto === null) return true;
+	const Ctor = hasProp(proto, "constructor") && proto.constructor;
+	return typeof Ctor == "function" && Ctor instanceof Ctor && fnToString.call(Ctor) == objectCtorString;
+};
+const isReactElement = (x) => typeof x === "object" && x !== null && "$$typeof" in x && "props" in x;
+const isVueElement = (x) => typeof x === "object" && x !== null && "__v_isVNode" in x;
+const isFrameworkElement = (x) => isReactElement(x) || isVueElement(x);
+
+//#endregion
+//#region src/shared/utils/functions.ts
+const runIfFn = (v, ...a) => {
+	return (typeof v === "function" ? v(...a) : v) ?? void 0;
+};
+const cast = (v) => v;
+const identity = (v) => v();
+const noop = () => {};
+const callAll = (...fns) => (...a) => {
+	fns.forEach(function(fn) {
+		fn?.(...a);
+	});
+};
+const uuid = (() => {
+	let id = 0;
+	return () => {
+		id++;
+		return id.toString(36);
+	};
+})();
+function match(key, record, ...args) {
+	if (key in record) {
+		const fn = record[key];
+		return isFunction(fn) ? fn(...args) : fn;
+	}
+	const error = /* @__PURE__ */ new Error(`No matching key: ${JSON.stringify(key)} in ${JSON.stringify(Object.keys(record))}`);
+	Error.captureStackTrace?.(error, match);
+	throw error;
+}
+const tryCatch = (fn, fallback) => {
+	try {
+		return fn();
+	} catch (error) {
+		if (error instanceof Error) Error.captureStackTrace?.(error, tryCatch);
+		return fallback?.();
+	}
+};
+function throttle(fn, wait = 0) {
+	let lastCall = 0;
+	let timeout = null;
+	return ((...args) => {
+		const now = Date.now();
+		const timeSinceLastCall = now - lastCall;
+		if (timeSinceLastCall >= wait) {
+			if (timeout) {
+				clearTimeout(timeout);
+				timeout = null;
+			}
+			fn(...args);
+			lastCall = now;
+		} else if (!timeout) timeout = setTimeout(() => {
+			fn(...args);
+			lastCall = Date.now();
+			timeout = null;
+		}, wait - timeSinceLastCall);
+	});
+}
+function debounce(fn, wait = 0) {
+	let timeout = null;
+	return ((...args) => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = null;
+		}
+		timeout = setTimeout(() => {
+			fn(...args);
+		}, wait);
+	});
+}
+
+//#endregion
+//#region src/shared/utils/number.ts
+const { floor, abs, round, min, max, pow, sign } = Math;
+const isNaN = (v) => Number.isNaN(v);
+const nan = (v) => isNaN(v) ? 0 : v;
+const mod = (v, m) => (v % m + m) % m;
+const wrap = (v, vmax) => (v % vmax + vmax) % vmax;
+const getMinValueAtIndex = (i, v, vmin) => i === 0 ? vmin : v[i - 1];
+const getMaxValueAtIndex = (i, v, vmax) => i === v.length - 1 ? vmax : v[i + 1];
+const isValueAtMax = (v, vmax) => nan(v) >= vmax;
+const isValueAtMin = (v, vmin) => nan(v) <= vmin;
+const isValueWithinRange = (v, vmin, vmax) => {
+	const value = nan(v);
+	return (vmin == null || value >= vmin) && (vmax == null || value <= vmax);
+};
+const roundValue = (v, vmin, step) => round((nan(v) - vmin) / step) * step + vmin;
+const clampValue = (v, vmin, vmax) => min(max(nan(v), vmin), vmax);
+const clampPercent = (v) => clampValue(v, 0, 1);
+const getValuePercent = (v, vmin, vmax) => (nan(v) - vmin) / (vmax - vmin);
+const getPercentValue = (p, vmin, vmax, step) => clampValue(roundValue(p * (vmax - vmin) + vmin, vmin, step), vmin, vmax);
+const roundToStepPrecision = (v, step) => {
+	let rv = v;
+	let ss = step.toString();
+	let pi = ss.indexOf(".");
+	let p = pi >= 0 ? ss.length - pi : 0;
+	if (p > 0) {
+		let pw = pow(10, p);
+		rv = round(rv * pw) / pw;
+	}
+	return rv;
+};
+const roundToDpr = (v, dpr) => typeof dpr === "number" ? floor(v * dpr + .5) / dpr : round(v);
+const snapValueToStep = (v, vmin, vmax, step) => {
+	const min$1 = vmin != null ? Number(vmin) : 0;
+	const max$1 = Number(vmax);
+	const remainder = (v - min$1) % step;
+	let snapped = abs(remainder) * 2 >= step ? v + sign(remainder) * (step - abs(remainder)) : v - remainder;
+	snapped = roundToStepPrecision(snapped, step);
+	if (!isNaN(min$1) && snapped < min$1) snapped = min$1;
+	else if (!isNaN(max$1) && snapped > max$1) {
+		const stepsInRange = floor((max$1 - min$1) / step);
+		const largestValidStep = min$1 + stepsInRange * step;
+		snapped = stepsInRange <= 0 || largestValidStep < min$1 ? max$1 : largestValidStep;
+	}
+	return roundToStepPrecision(snapped, step);
+};
+const setValueAtIndex = (vs, i, v) => {
+	if (vs[i] === v) return vs;
+	return [
+		...vs.slice(0, i),
+		v,
+		...vs.slice(i + 1)
+	];
+};
+function getValueSetterAtIndex(index, ctx) {
+	const minValueAtIndex = getMinValueAtIndex(index, ctx.values, ctx.min);
+	const maxValueAtIndex = getMaxValueAtIndex(index, ctx.values, ctx.max);
+	let nextValues = ctx.values.slice();
+	return function setValue(value) {
+		let nextValue = snapValueToStep(value, minValueAtIndex, maxValueAtIndex, ctx.step);
+		nextValues = setValueAtIndex(nextValues, index, value);
+		nextValues[index] = nextValue;
+		return nextValues;
+	};
+}
+function getNextStepValue(index, ctx) {
+	const nextValue = ctx.values[index] + ctx.step;
+	return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+function getPreviousStepValue(index, ctx) {
+	const nextValue = ctx.values[index] - ctx.step;
+	return getValueSetterAtIndex(index, ctx)(nextValue);
+}
+const getClosestValueIndex = (vs, t) => {
+	let i = vs.findIndex((v) => t - v < 0);
+	if (i === 0) return i;
+	if (i === -1) return vs.length - 1;
+	let vLeft = vs[i - 1];
+	let vRight = vs[i];
+	if (abs(vLeft - t) < abs(vRight - t)) return i - 1;
+	return i;
+};
+const getClosestValue = (vs, t) => vs[getClosestValueIndex(vs, t)];
+const getValueRanges = (vs, vmin, vmax, gap) => vs.map((v, i) => ({
+	min: i === 0 ? vmin : vs[i - 1] + gap,
+	max: i === vs.length - 1 ? vmax : vs[i + 1] - gap,
+	value: v
+}));
+const getValueTransformer = (va, vb) => {
+	const [a, b] = va;
+	const [c, d] = vb;
+	return (v) => a === b || c === d ? c : c + (d - c) / (b - a) * (v - a);
+};
+const toFixedNumber = (v, d = 0, b = 10) => {
+	const pow$1 = Math.pow(b, d);
+	return round(v * pow$1) / pow$1;
+};
+const countDecimals = (value) => {
+	if (!Number.isFinite(value)) return 0;
+	let e = 1, p = 0;
+	while (Math.round(value * e) / e !== value) {
+		e *= 10;
+		p += 1;
+	}
+	return p;
+};
+const decimalOp = (a, op, b) => {
+	let result = op === "+" ? a + b : a - b;
+	if (a % 1 !== 0 || b % 1 !== 0) {
+		const multiplier = 10 ** Math.max(countDecimals(a), countDecimals(b));
+		a = Math.round(a * multiplier);
+		b = Math.round(b * multiplier);
+		result = op === "+" ? a + b : a - b;
+		result /= multiplier;
+	}
+	return result;
+};
+const incrementValue = (v, s) => decimalOp(nan(v), "+", s);
+const decrementValue = (v, s) => decimalOp(nan(v), "-", s);
+const toPx = (v) => typeof v === "number" ? `${v}px` : v;
+
+//#endregion
+//#region src/shared/utils/object.ts
+function compact(obj) {
+	if (!isPlainObject(obj) || obj === void 0) return obj;
+	const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+	const filtered = {};
+	for (const key of keys) {
+		const value = obj[key];
+		if (value !== void 0) filtered[key] = compact(value);
+	}
+	return filtered;
+}
+const json = (v) => JSON.parse(JSON.stringify(v));
+function pick(obj, keys) {
+	const filtered = {};
+	for (const key of keys) {
+		const value = obj[key];
+		if (value !== void 0) filtered[key] = value;
+	}
+	return filtered;
+}
+function splitProps(props, keys) {
+	const rest = {};
+	const result = {};
+	const keySet = new Set(keys);
+	const ownKeys = Reflect.ownKeys(props);
+	for (const key of ownKeys) if (keySet.has(key)) result[key] = props[key];
+	else rest[key] = props[key];
+	return [result, rest];
+}
+const createSplitProps = (keys) => {
+	return function split(props) {
+		return splitProps(props, keys);
+	};
+};
+function omit(obj, keys) {
+	return createSplitProps(keys)(obj)[1];
+}
+
+//#endregion
+//#region src/shared/utils/store.ts
+function createStore(initialState, compare = Object.is) {
+	let state = { ...initialState };
+	const listeners = /* @__PURE__ */ new Set();
+	const subscribe = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const publish = () => {
+		listeners.forEach((listener) => listener());
+	};
+	const get = (key) => {
+		return state[key];
+	};
+	const set = (key, value) => {
+		if (!compare(state[key], value)) {
+			state[key] = value;
+			publish();
+		}
+	};
+	const update = (updates) => {
+		let hasChanges = false;
+		for (const key in updates) {
+			const value = updates[key];
+			if (value !== void 0 && !compare(state[key], value)) {
+				state[key] = value;
+				hasChanges = true;
+			}
+		}
+		if (hasChanges) publish();
+	};
+	const snapshot = () => ({ ...state });
+	return {
+		subscribe,
+		get,
+		set,
+		update,
+		snapshot
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region src/shared/utils/timers.ts
+const currentTime = () => performance.now();
+var _tick = /* @__PURE__ */ new WeakMap();
+var Timer = class {
+	constructor(onTick) {
+		this.onTick = onTick;
+		require_defineProperty._defineProperty(this, "frameId", null);
+		require_defineProperty._defineProperty(this, "pausedAtMs", null);
+		require_defineProperty._defineProperty(this, "context", void 0);
+		require_defineProperty._defineProperty(this, "cancelFrame", () => {
+			if (this.frameId === null) return;
+			cancelAnimationFrame(this.frameId);
+			this.frameId = null;
+		});
+		require_defineProperty._defineProperty(this, "setStartMs", (startMs) => {
+			this.context.startMs = startMs;
+		});
+		require_defineProperty._defineProperty(this, "start", () => {
+			if (this.frameId !== null) return;
+			const now = currentTime();
+			if (this.pausedAtMs !== null) {
+				this.context.startMs += now - this.pausedAtMs;
+				this.pausedAtMs = null;
+			} else this.context.startMs = now;
+			this.frameId = requestAnimationFrame(_classPrivateFieldGet2(_tick, this));
+		});
+		require_defineProperty._defineProperty(this, "pause", () => {
+			if (this.frameId === null) return;
+			this.cancelFrame();
+			this.pausedAtMs = currentTime();
+		});
+		require_defineProperty._defineProperty(this, "stop", () => {
+			if (this.frameId === null) return;
+			this.cancelFrame();
+			this.pausedAtMs = null;
+		});
+		_classPrivateFieldInitSpec(this, _tick, (now) => {
+			this.context.now = now;
+			this.context.deltaMs = now - this.context.startMs;
+			if (this.onTick(this.context) === false) {
+				this.stop();
+				return;
+			}
+			this.frameId = requestAnimationFrame(_classPrivateFieldGet2(_tick, this));
+		});
+		this.context = {
+			now: 0,
+			startMs: currentTime(),
+			deltaMs: 0
+		};
+	}
+	get elapsedMs() {
+		if (this.pausedAtMs !== null) return this.pausedAtMs - this.context.startMs;
+		return currentTime() - this.context.startMs;
+	}
+};
+function setRafInterval(fn, intervalMs) {
+	const timer = new Timer(({ now, deltaMs }) => {
+		if (deltaMs >= intervalMs) {
+			const startMs = intervalMs > 0 ? now - deltaMs % intervalMs : now;
+			timer.setStartMs(startMs);
+			fn({
+				startMs,
+				deltaMs
+			});
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+function setRafTimeout(fn, delayMs) {
+	const timer = new Timer(({ deltaMs }) => {
+		if (deltaMs >= delayMs) {
+			fn();
+			return false;
+		}
+	});
+	timer.start();
+	return () => timer.stop();
+}
+
+//#endregion
+//#region src/shared/utils/warning.ts
+function warn(...a) {
+	const m = a.length === 1 ? a[0] : a[1];
+	if ((a.length === 2 ? a[0] : true) && process.env.NODE_ENV !== "production") console.warn(m);
+}
+function invariant(...a) {
+	const m = a.length === 1 ? a[0] : a[1];
+	if ((a.length === 2 ? a[0] : true) && process.env.NODE_ENV !== "production") throw new Error(m);
+}
+function ensure(c, m) {
+	if (c == null) throw new Error(m());
+}
+function ensureProps(props, keys, scope) {
+	let missingKeys = [];
+	for (const key of keys) if (props[key] == null) missingKeys.push(key);
+	if (missingKeys.length > 0) throw new Error(`[sprawlify-js${scope ? ` > ${scope}` : ""}] missing required props: ${missingKeys.join(", ")}`);
+}
+
+//#endregion
+Object.defineProperty(exports, 'Timer', {
+  enumerable: true,
+  get: function () {
+    return Timer;
+  }
+});
+Object.defineProperty(exports, 'add', {
+  enumerable: true,
+  get: function () {
+    return add;
+  }
+});
+Object.defineProperty(exports, 'addOrRemove', {
+  enumerable: true,
+  get: function () {
+    return addOrRemove;
+  }
+});
+Object.defineProperty(exports, 'callAll', {
+  enumerable: true,
+  get: function () {
+    return callAll;
+  }
+});
+Object.defineProperty(exports, 'cast', {
+  enumerable: true,
+  get: function () {
+    return cast;
+  }
+});
+Object.defineProperty(exports, 'chunk', {
+  enumerable: true,
+  get: function () {
+    return chunk;
+  }
+});
+Object.defineProperty(exports, 'clampPercent', {
+  enumerable: true,
+  get: function () {
+    return clampPercent;
+  }
+});
+Object.defineProperty(exports, 'clampValue', {
+  enumerable: true,
+  get: function () {
+    return clampValue;
+  }
+});
+Object.defineProperty(exports, 'clear', {
+  enumerable: true,
+  get: function () {
+    return clear;
+  }
+});
+Object.defineProperty(exports, 'compact', {
+  enumerable: true,
+  get: function () {
+    return compact;
+  }
+});
+Object.defineProperty(exports, 'createSplitProps', {
+  enumerable: true,
+  get: function () {
+    return createSplitProps;
+  }
+});
+Object.defineProperty(exports, 'createStore', {
+  enumerable: true,
+  get: function () {
+    return createStore;
+  }
+});
+Object.defineProperty(exports, 'debounce', {
+  enumerable: true,
+  get: function () {
+    return debounce;
+  }
+});
+Object.defineProperty(exports, 'decrementValue', {
+  enumerable: true,
+  get: function () {
+    return decrementValue;
+  }
+});
+Object.defineProperty(exports, 'diff', {
+  enumerable: true,
+  get: function () {
+    return diff;
+  }
+});
+Object.defineProperty(exports, 'ensure', {
+  enumerable: true,
+  get: function () {
+    return ensure;
+  }
+});
+Object.defineProperty(exports, 'ensureProps', {
+  enumerable: true,
+  get: function () {
+    return ensureProps;
+  }
+});
+Object.defineProperty(exports, 'first', {
+  enumerable: true,
+  get: function () {
+    return first;
+  }
+});
+Object.defineProperty(exports, 'flatArray', {
+  enumerable: true,
+  get: function () {
+    return flatArray;
+  }
+});
+Object.defineProperty(exports, 'fromLength', {
+  enumerable: true,
+  get: function () {
+    return fromLength;
+  }
+});
+Object.defineProperty(exports, 'getClosestValue', {
+  enumerable: true,
+  get: function () {
+    return getClosestValue;
+  }
+});
+Object.defineProperty(exports, 'getClosestValueIndex', {
+  enumerable: true,
+  get: function () {
+    return getClosestValueIndex;
+  }
+});
+Object.defineProperty(exports, 'getMaxValueAtIndex', {
+  enumerable: true,
+  get: function () {
+    return getMaxValueAtIndex;
+  }
+});
+Object.defineProperty(exports, 'getMinValueAtIndex', {
+  enumerable: true,
+  get: function () {
+    return getMinValueAtIndex;
+  }
+});
+Object.defineProperty(exports, 'getNextStepValue', {
+  enumerable: true,
+  get: function () {
+    return getNextStepValue;
+  }
+});
+Object.defineProperty(exports, 'getPercentValue', {
+  enumerable: true,
+  get: function () {
+    return getPercentValue;
+  }
+});
+Object.defineProperty(exports, 'getPreviousStepValue', {
+  enumerable: true,
+  get: function () {
+    return getPreviousStepValue;
+  }
+});
+Object.defineProperty(exports, 'getValuePercent', {
+  enumerable: true,
+  get: function () {
+    return getValuePercent;
+  }
+});
+Object.defineProperty(exports, 'getValueRanges', {
+  enumerable: true,
+  get: function () {
+    return getValueRanges;
+  }
+});
+Object.defineProperty(exports, 'getValueSetterAtIndex', {
+  enumerable: true,
+  get: function () {
+    return getValueSetterAtIndex;
+  }
+});
+Object.defineProperty(exports, 'getValueTransformer', {
+  enumerable: true,
+  get: function () {
+    return getValueTransformer;
+  }
+});
+Object.defineProperty(exports, 'has', {
+  enumerable: true,
+  get: function () {
+    return has;
+  }
+});
+Object.defineProperty(exports, 'hasProp', {
+  enumerable: true,
+  get: function () {
+    return hasProp;
+  }
+});
+Object.defineProperty(exports, 'identity', {
+  enumerable: true,
+  get: function () {
+    return identity;
+  }
+});
+Object.defineProperty(exports, 'incrementValue', {
+  enumerable: true,
+  get: function () {
+    return incrementValue;
+  }
+});
+Object.defineProperty(exports, 'insertAt', {
+  enumerable: true,
+  get: function () {
+    return insertAt;
+  }
+});
+Object.defineProperty(exports, 'invariant', {
+  enumerable: true,
+  get: function () {
+    return invariant;
+  }
+});
+Object.defineProperty(exports, 'isArray', {
+  enumerable: true,
+  get: function () {
+    return isArray;
+  }
+});
+Object.defineProperty(exports, 'isBoolean', {
+  enumerable: true,
+  get: function () {
+    return isBoolean;
+  }
+});
+Object.defineProperty(exports, 'isDev', {
+  enumerable: true,
+  get: function () {
+    return isDev;
+  }
+});
+Object.defineProperty(exports, 'isEmpty', {
+  enumerable: true,
+  get: function () {
+    return isEmpty;
+  }
+});
+Object.defineProperty(exports, 'isEqual', {
+  enumerable: true,
+  get: function () {
+    return isEqual;
+  }
+});
+Object.defineProperty(exports, 'isFunction', {
+  enumerable: true,
+  get: function () {
+    return isFunction;
+  }
+});
+Object.defineProperty(exports, 'isNaN', {
+  enumerable: true,
+  get: function () {
+    return isNaN;
+  }
+});
+Object.defineProperty(exports, 'isNull', {
+  enumerable: true,
+  get: function () {
+    return isNull;
+  }
+});
+Object.defineProperty(exports, 'isNumber', {
+  enumerable: true,
+  get: function () {
+    return isNumber;
+  }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () {
+    return isObject;
+  }
+});
+Object.defineProperty(exports, 'isObjectLike', {
+  enumerable: true,
+  get: function () {
+    return isObjectLike;
+  }
+});
+Object.defineProperty(exports, 'isPlainObject', {
+  enumerable: true,
+  get: function () {
+    return isPlainObject;
+  }
+});
+Object.defineProperty(exports, 'isString', {
+  enumerable: true,
+  get: function () {
+    return isString;
+  }
+});
+Object.defineProperty(exports, 'isValueAtMax', {
+  enumerable: true,
+  get: function () {
+    return isValueAtMax;
+  }
+});
+Object.defineProperty(exports, 'isValueAtMin', {
+  enumerable: true,
+  get: function () {
+    return isValueAtMin;
+  }
+});
+Object.defineProperty(exports, 'isValueWithinRange', {
+  enumerable: true,
+  get: function () {
+    return isValueWithinRange;
+  }
+});
+Object.defineProperty(exports, 'json', {
+  enumerable: true,
+  get: function () {
+    return json;
+  }
+});
+Object.defineProperty(exports, 'last', {
+  enumerable: true,
+  get: function () {
+    return last;
+  }
+});
+Object.defineProperty(exports, 'match', {
+  enumerable: true,
+  get: function () {
+    return match;
+  }
+});
+Object.defineProperty(exports, 'mod', {
+  enumerable: true,
+  get: function () {
+    return mod;
+  }
+});
+Object.defineProperty(exports, 'nan', {
+  enumerable: true,
+  get: function () {
+    return nan;
+  }
+});
+Object.defineProperty(exports, 'next', {
+  enumerable: true,
+  get: function () {
+    return next;
+  }
+});
+Object.defineProperty(exports, 'nextIndex', {
+  enumerable: true,
+  get: function () {
+    return nextIndex;
+  }
+});
+Object.defineProperty(exports, 'noop', {
+  enumerable: true,
+  get: function () {
+    return noop;
+  }
+});
+Object.defineProperty(exports, 'omit', {
+  enumerable: true,
+  get: function () {
+    return omit;
+  }
+});
+Object.defineProperty(exports, 'partition', {
+  enumerable: true,
+  get: function () {
+    return partition;
+  }
+});
+Object.defineProperty(exports, 'pick', {
+  enumerable: true,
+  get: function () {
+    return pick;
+  }
+});
+Object.defineProperty(exports, 'prev', {
+  enumerable: true,
+  get: function () {
+    return prev;
+  }
+});
+Object.defineProperty(exports, 'prevIndex', {
+  enumerable: true,
+  get: function () {
+    return prevIndex;
+  }
+});
+Object.defineProperty(exports, 'remove', {
+  enumerable: true,
+  get: function () {
+    return remove;
+  }
+});
+Object.defineProperty(exports, 'removeAt', {
+  enumerable: true,
+  get: function () {
+    return removeAt;
+  }
+});
+Object.defineProperty(exports, 'roundToDpr', {
+  enumerable: true,
+  get: function () {
+    return roundToDpr;
+  }
+});
+Object.defineProperty(exports, 'roundToStepPrecision', {
+  enumerable: true,
+  get: function () {
+    return roundToStepPrecision;
+  }
+});
+Object.defineProperty(exports, 'roundValue', {
+  enumerable: true,
+  get: function () {
+    return roundValue;
+  }
+});
+Object.defineProperty(exports, 'runIfFn', {
+  enumerable: true,
+  get: function () {
+    return runIfFn;
+  }
+});
+Object.defineProperty(exports, 'setRafInterval', {
+  enumerable: true,
+  get: function () {
+    return setRafInterval;
+  }
+});
+Object.defineProperty(exports, 'setRafTimeout', {
+  enumerable: true,
+  get: function () {
+    return setRafTimeout;
+  }
+});
+Object.defineProperty(exports, 'setValueAtIndex', {
+  enumerable: true,
+  get: function () {
+    return setValueAtIndex;
+  }
+});
+Object.defineProperty(exports, 'snapValueToStep', {
+  enumerable: true,
+  get: function () {
+    return snapValueToStep;
+  }
+});
+Object.defineProperty(exports, 'splitProps', {
+  enumerable: true,
+  get: function () {
+    return splitProps;
+  }
+});
+Object.defineProperty(exports, 'throttle', {
+  enumerable: true,
+  get: function () {
+    return throttle;
+  }
+});
+Object.defineProperty(exports, 'toArray', {
+  enumerable: true,
+  get: function () {
+    return toArray;
+  }
+});
+Object.defineProperty(exports, 'toFixedNumber', {
+  enumerable: true,
+  get: function () {
+    return toFixedNumber;
+  }
+});
+Object.defineProperty(exports, 'toPx', {
+  enumerable: true,
+  get: function () {
+    return toPx;
+  }
+});
+Object.defineProperty(exports, 'tryCatch', {
+  enumerable: true,
+  get: function () {
+    return tryCatch;
+  }
+});
+Object.defineProperty(exports, 'uniq', {
+  enumerable: true,
+  get: function () {
+    return uniq;
+  }
+});
+Object.defineProperty(exports, 'uuid', {
+  enumerable: true,
+  get: function () {
+    return uuid;
+  }
+});
+Object.defineProperty(exports, 'warn', {
+  enumerable: true,
+  get: function () {
+    return warn;
+  }
+});
+Object.defineProperty(exports, 'wrap', {
+  enumerable: true,
+  get: function () {
+    return wrap;
+  }
+});