@cooljs123/easyjs 0.1.0

package/src/easy.js

@@ -0,0 +1,1457 @@
+/**
+ * Return the input unchanged.
+ * @template T
+ * @param {T} x
+ * @returns {T}
+ */
+function identity(x) {
+  return x;
+}
+
+/**
+ * Do nothing.
+ * @returns {void}
+ */
+function noop() {}
+
+/**
+ * Check for null or undefined.
+ * @param {*} v
+ * @returns {boolean}
+ */
+function isNil(v) {
+  return v === null || v === undefined;
+}
+
+/**
+ * Check if a value is "empty" (null/undefined, empty string/array/object/map/set).
+ * @param {*} v
+ * @returns {boolean}
+ */
+function isEmpty(v) {
+  if (isNil(v)) return true;
+  if (typeof v === "string") return v.length === 0;
+  if (Array.isArray(v)) return v.length === 0;
+  if (v instanceof Map || v instanceof Set) return v.size === 0;
+  if (typeof v === "object") return Object.keys(v).length === 0;
+  return false;
+}
+
+/**
+ * Return fallback if value is null/undefined.
+ * @template T
+ * @param {T} v
+ * @param {T} fallback
+ * @returns {T}
+ */
+function defaultTo(v, fallback) {
+  return isNil(v) ? fallback : v;
+}
+
+/**
+ * Convert to lowercase string.
+ * @param {*} s
+ * @returns {string}
+ */
+function toLower(s) {
+  return String(s).toLowerCase();
+}
+
+/**
+ * Convert to uppercase string.
+ * @param {*} s
+ * @returns {string}
+ */
+function toUpper(s) {
+  return String(s).toUpperCase();
+}
+
+/**
+ * Capitalize first letter.
+ * @param {*} s
+ * @returns {string}
+ */
+function capitalize(s) {
+  const str = String(s);
+  return str.length ? str[0].toUpperCase() + str.slice(1) : "";
+}
+
+/**
+ * Trim whitespace.
+ * @param {*} s
+ * @returns {string}
+ */
+function trim(s) {
+  return String(s).trim();
+}
+
+/**
+ * Lowercase + trim.
+ * @param {*} s
+ * @returns {string}
+ */
+function normalizeString(s) {
+  return trim(toLower(s));
+}
+
+/**
+ * Slugify a string (lowercase, hyphenated).
+ * @param {*} s
+ * @returns {string}
+ */
+function slugify(s) {
+  return String(s)
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Left pad a string.
+ * @param {*} s
+ * @param {number} length
+ * @param {string} [padChar=" "]
+ * @returns {string}
+ */
+function padLeft(s, length, padChar = " ") {
+  return String(s).padStart(length, padChar);
+}
+
+/**
+ * Right pad a string.
+ * @param {*} s
+ * @param {number} length
+ * @param {string} [padChar=" "]
+ * @returns {string}
+ */
+function padRight(s, length, padChar = " ") {
+  return String(s).padEnd(length, padChar);
+}
+
+/**
+ * Repeat a string n times.
+ * @param {*} s
+ * @param {number} times
+ * @returns {string}
+ */
+function repeat(s, times) {
+  return String(s).repeat(times);
+}
+
+/**
+ * Remove non-alphanumeric characters.
+ * @param {*} s
+ * @returns {string}
+ */
+function stripNonAlpha(s) {
+  return String(s).replace(/[^a-z0-9]+/gi, "");
+}
+
+/**
+ * Check if string is blank (empty or whitespace).
+ * @param {*} s
+ * @returns {boolean}
+ */
+function isBlank(s) {
+  return String(s).trim().length === 0;
+}
+
+/**
+ * Wrap non-array value in array; null/undefined -> [].
+ * @param {*} v
+ * @returns {Array}
+ */
+function asArray(v) {
+  if (isNil(v)) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+function arrayFromArgs(args, fallback) {
+  if (args.length === 0) return fallback || [];
+  if (Array.isArray(args[0])) return args[0];
+  return Array.prototype.slice.call(args);
+}
+
+/**
+ * Check if value is in a list of candidates.
+ * @param {*} value
+ * @param {Array|*} candidates
+ * @returns {boolean}
+ */
+function anyOf(value, candidates) {
+  const list = Array.isArray(candidates) ? candidates : Array.prototype.slice.call(arguments, 1);
+  return list.includes(value);
+}
+
+/**
+ * Alias for anyOf.
+ * @param {*} value
+ * @param {Array|*} candidates
+ * @returns {boolean}
+ */
+function eqAny(value, candidates) {
+  return anyOf.apply(null, arguments);
+}
+
+/**
+ * Check if value is included in array.
+ * @param {*} value
+ * @param {Array} arr
+ * @returns {boolean}
+ */
+function inArray(value, arr) {
+  if (Array.isArray(arr)) return arr.includes(value);
+  if (arguments.length > 2) {
+    const list = Array.prototype.slice.call(arguments, 1);
+    return list.includes(value);
+  }
+  return false;
+}
+
+/**
+ * Clamp a number to a range.
+ * @param {*} n
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+function clamp(n, min, max) {
+  const num = Number(n);
+  return Math.min(max, Math.max(min, num));
+}
+
+/**
+ * Check if a number is between min and max.
+ * @param {*} n
+ * @param {number} min
+ * @param {number} max
+ * @param {boolean} [inclusive=true]
+ * @returns {boolean}
+ */
+function between(n, min, max, inclusive = true) {
+  const num = Number(n);
+  return inclusive ? num >= min && num <= max : num > min && num < max;
+}
+
+/**
+ * Parse integer with fallback to 0.
+ * @param {*} v
+ * @param {number} [base=10]
+ * @returns {number}
+ */
+function toInt(v, base = 10) {
+  const n = parseInt(v, base);
+  return Number.isNaN(n) ? 0 : n;
+}
+
+/**
+ * Parse float with fallback to 0.
+ * @param {*} v
+ * @returns {number}
+ */
+function toFloat(v) {
+  const n = parseFloat(v);
+  return Number.isNaN(n) ? 0 : n;
+}
+
+/**
+ * Convert to number with fallback 0.
+ * @param {*} v
+ * @returns {number}
+ */
+function toNumber(v) {
+  const n = Number(v);
+  return Number.isNaN(n) ? 0 : n;
+}
+
+/**
+ * Check if value is a finite number.
+ * @param {*} v
+ * @returns {boolean}
+ */
+function isNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+
+/**
+ * Check if value is an integer.
+ * @param {*} v
+ * @returns {boolean}
+ */
+function isInt(v) {
+  return Number.isInteger(v);
+}
+
+/**
+ * Filter an array by predicate or remove null/undefined.
+ * @param {Array} arr
+ * @param {Function} [predicate]
+ * @returns {Array}
+ */
+function compact(arr, predicate) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    const last = args[args.length - 1];
+    if (typeof last === "function") {
+      predicate = last;
+      arr = args.slice(0, -1);
+    } else {
+      arr = args;
+    }
+  }
+  if (typeof predicate === "function") return arr.filter(predicate);
+  return arr.filter(v => !isNil(v));
+}
+
+/**
+ * Unique values from array.
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function uniq(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  return Array.from(new Set(arr));
+}
+
+/**
+ * Flatten one level.
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function flatten(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  return arr.reduce((acc, v) => acc.concat(v), []);
+}
+
+/**
+ * Split array into chunks.
+ * @param {Array} arr
+ * @param {number} size
+ * @returns {Array<Array>}
+ */
+function chunk(arr, size) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    size = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr) || size <= 0) return [];
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) {
+    out.push(arr.slice(i, i + size));
+  }
+  return out;
+}
+
+/**
+ * Create a numeric range (end exclusive).
+ * @param {number} start
+ * @param {number} [end]
+ * @param {number} [step=1]
+ * @returns {Array<number>}
+ */
+function range(start, end, step = 1) {
+  let s = start;
+  let e = end;
+  if (end === undefined) {
+    s = 0;
+    e = start;
+  }
+  if (step === 0) return [];
+  const out = [];
+  const inc = step > 0;
+  for (let i = s; inc ? i < e : i > e; i += step) {
+    out.push(i);
+  }
+  return out;
+}
+
+/**
+ * Minimum of array or args.
+ * @param {Array|number} arr
+ * @returns {number}
+ */
+function min(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (arr.length === 0) return 0;
+  return Math.min.apply(null, arr.map(Number));
+}
+
+/**
+ * Maximum of array or args.
+ * @param {Array|number} arr
+ * @returns {number}
+ */
+function max(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (arr.length === 0) return 0;
+  return Math.max.apply(null, arr.map(Number));
+}
+
+/**
+ * Sum array values.
+ * @param {Array} arr
+ * @returns {number}
+ */
+function sum(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  return arr.reduce((a, b) => a + Number(b || 0), 0);
+}
+
+/**
+ * Average array values.
+ * @param {Array} arr
+ * @returns {number}
+ */
+function avg(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (arr.length === 0) return 0;
+  return sum(arr) / arr.length;
+}
+
+/**
+ * Median of array or args.
+ * @param {Array|number} arr
+ * @returns {number}
+ */
+function median(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (arr.length === 0) return 0;
+  const sorted = arr.map(Number).slice().sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+/**
+ * Mode (most frequent) of array or args.
+ * @param {Array|number} arr
+ * @returns {number}
+ */
+function mode(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (arr.length === 0) return 0;
+  const counts = new Map();
+  let best = arr[0];
+  let bestCount = 0;
+  for (const v of arr) {
+    const c = (counts.get(v) || 0) + 1;
+    counts.set(v, c);
+    if (c > bestCount) {
+      bestCount = c;
+      best = v;
+    }
+  }
+  return Number(best);
+}
+
+/**
+ * Percentile (0-100) of array or args.
+ * @param {Array|number} arr
+ * @param {number} p
+ * @returns {number}
+ */
+function percentile(arr, p) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    p = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr) || arr.length === 0) return 0;
+  const sorted = arr.map(Number).slice().sort((a, b) => a - b);
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.round((p / 100) * (sorted.length - 1))));
+  return sorted[idx];
+}
+
+/**
+ * Group by key or key function.
+ * @param {Array} arr
+ * @param {Function|string} keyFn
+ * @returns {Object}
+ */
+function groupBy(arr, keyFn) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    keyFn = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr)) return {};
+  const fn = typeof keyFn === "function" ? keyFn : (x) => x[keyFn];
+  return arr.reduce((acc, item) => {
+    const key = fn(item);
+    if (!acc[key]) acc[key] = [];
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
+
+/**
+ * First element of array.
+ * @param {Array} arr
+ * @returns {*}
+ */
+function first(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  return arr[0];
+}
+
+/**
+ * Last element of array.
+ * @param {Array} arr
+ * @returns {*}
+ */
+function last(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  return arr[arr.length - 1];
+}
+
+/**
+ * Take first n items.
+ * @param {Array} arr
+ * @param {number} n
+ * @returns {Array}
+ */
+function take(arr, n) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    n = args.pop();
+    arr = args;
+  }
+  return Array.isArray(arr) ? arr.slice(0, n) : [];
+}
+
+/**
+ * Take last n items.
+ * @param {Array} arr
+ * @param {number} n
+ * @returns {Array}
+ */
+function takeRight(arr, n) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    n = args.pop();
+    arr = args;
+  }
+  return Array.isArray(arr) ? arr.slice(Math.max(0, arr.length - n)) : [];
+}
+
+/**
+ * Drop first n items.
+ * @param {Array} arr
+ * @param {number} n
+ * @returns {Array}
+ */
+function drop(arr, n) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    n = args.pop();
+    arr = args;
+  }
+  return Array.isArray(arr) ? arr.slice(n) : [];
+}
+
+/**
+ * Drop last n items.
+ * @param {Array} arr
+ * @param {number} n
+ * @returns {Array}
+ */
+function dropRight(arr, n) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    n = args.pop();
+    arr = args;
+  }
+  return Array.isArray(arr) ? arr.slice(0, Math.max(0, arr.length - n)) : [];
+}
+
+/**
+ * Zip arrays into array of tuples.
+ * @param {Array} arrs
+ * @returns {Array<Array>}
+ */
+function zip(arrs) {
+  const lists = Array.isArray(arrs) && Array.isArray(arrs[0]) ? arrs : Array.prototype.slice.call(arguments);
+  if (lists.length === 0) return [];
+  const minLen = Math.min.apply(null, lists.map(a => a.length));
+  const out = [];
+  for (let i = 0; i < minLen; i++) {
+    out.push(lists.map(a => a[i]));
+  }
+  return out;
+}
+
+/**
+ * Unzip array of tuples.
+ * @param {Array<Array>} arr
+ * @returns {Array<Array>}
+ */
+function unzip(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) return [];
+  return zip.apply(null, arr);
+}
+
+/**
+ * Intersection of arrays.
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function intersection(arr) {
+  const lists = Array.isArray(arr) && Array.isArray(arr[0]) ? arr : Array.prototype.slice.call(arguments);
+  if (lists.length === 0) return [];
+  return lists.reduce((acc, cur) => acc.filter(x => cur.includes(x)));
+}
+
+/**
+ * Difference of arrays (first minus rest).
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function difference(arr) {
+  const lists = Array.isArray(arr) && Array.isArray(arr[0]) ? arr : Array.prototype.slice.call(arguments);
+  if (lists.length === 0) return [];
+  const [firstArr, ...rest] = lists;
+  const exclude = new Set(flatten(rest));
+  return firstArr.filter(x => !exclude.has(x));
+}
+
+/**
+ * Union of arrays.
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function union(arr) {
+  const lists = Array.isArray(arr) && Array.isArray(arr[0]) ? arr : Array.prototype.slice.call(arguments);
+  return uniq(flatten(lists));
+}
+
+/**
+ * Pick keys from an object.
+ * @param {Object} obj
+ * @param {Array|string} keys
+ * @returns {Object}
+ */
+function pick(obj, keys) {
+  if (!obj || typeof obj !== "object") return {};
+  const list = Array.isArray(keys) ? keys : Array.prototype.slice.call(arguments, 1);
+  const out = {};
+  list.forEach(k => {
+    if (k in obj) out[k] = obj[k];
+  });
+  return out;
+}
+
+/**
+ * Omit keys from an object.
+ * @param {Object} obj
+ * @param {Array|string} keys
+ * @returns {Object}
+ */
+function omit(obj, keys) {
+  if (!obj || typeof obj !== "object") return {};
+  const list = new Set(Array.isArray(keys) ? keys : Array.prototype.slice.call(arguments, 1));
+  const out = {};
+  Object.keys(obj).forEach(k => {
+    if (!list.has(k)) out[k] = obj[k];
+  });
+  return out;
+}
+
+/**
+ * Check if object has own property.
+ * @param {Object} obj
+ * @param {string} key
+ * @returns {boolean}
+ */
+function has(obj, key) {
+  return !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+/**
+ * Object.keys shortcut.
+ * @param {Object} obj
+ * @returns {Array<string>}
+ */
+function keys(obj) {
+  return obj ? Object.keys(obj) : [];
+}
+
+/**
+ * Object.values shortcut.
+ * @param {Object} obj
+ * @returns {Array}
+ */
+function values(obj) {
+  return obj ? Object.values(obj) : [];
+}
+
+/**
+ * Object.entries shortcut.
+ * @param {Object} obj
+ * @returns {Array<Array>}
+ */
+function entries(obj) {
+  return obj ? Object.entries(obj) : [];
+}
+
+/**
+ * Object.fromEntries shortcut.
+ * @param {Array<Array>} arr
+ * @returns {Object}
+ */
+function fromEntries(arr) {
+  return Object.fromEntries(Array.isArray(arr) ? arr : []);
+}
+
+/**
+ * Shallow merge objects (right wins).
+ * @param {Object} obj
+ * @returns {Object}
+ */
+function merge(obj) {
+  const list = Array.isArray(obj) && !Array.isArray(obj[0]) ? obj : Array.prototype.slice.call(arguments);
+  return Object.assign({}, ...list);
+}
+
+/**
+ * Deep merge objects (plain objects only).
+ * @param {Object} obj
+ * @returns {Object}
+ */
+function deepMerge(obj) {
+  const list = Array.prototype.slice.call(arguments);
+  const isPlain = (v) => v && typeof v === "object" && !Array.isArray(v);
+  const out = {};
+  list.forEach(src => {
+    if (!isPlain(src)) return;
+    Object.keys(src).forEach(k => {
+      if (isPlain(src[k]) && isPlain(out[k])) {
+        out[k] = deepMerge(out[k], src[k]);
+      } else {
+        out[k] = src[k];
+      }
+    });
+  });
+  return out;
+}
+
+/**
+ * Check if value is a plain object.
+ * @param {*} v
+ * @returns {boolean}
+ */
+function isObject(v) {
+  return v && typeof v === "object" && !Array.isArray(v);
+}
+
+/**
+ * Size of array/string/object/map/set.
+ * @param {*} v
+ * @returns {number}
+ */
+function size(v) {
+  if (isNil(v)) return 0;
+  if (typeof v === "string" || Array.isArray(v)) return v.length;
+  if (v instanceof Map || v instanceof Set) return v.size;
+  if (typeof v === "object") return Object.keys(v).length;
+  return 0;
+}
+
+/**
+ * Normalize a path to array form.
+ * @param {string|Array} path
+ * @returns {Array<string>}
+ */
+function parsePath(path) {
+  if (Array.isArray(path)) return path;
+  return String(path)
+    .replace(/\[(\d+)\]/g, ".$1")
+    .split(".")
+    .filter(Boolean);
+}
+
+/**
+ * Safe get by path with fallback.
+ * @param {Object} obj
+ * @param {string|Array} path
+ * @param {*} fallback
+ * @returns {*}
+ */
+function safeGet(obj, path, fallback) {
+  const parts = parsePath(path);
+  let cur = obj;
+  for (let i = 0; i < parts.length; i++) {
+    if (cur == null) return fallback;
+    cur = cur[parts[i]];
+  }
+  return cur === undefined ? fallback : cur;
+}
+
+/**
+ * Safe set by path (creates objects).
+ * @param {Object} obj
+ * @param {string|Array} path
+ * @param {*} value
+ * @returns {Object}
+ */
+function safeSet(obj, path, value) {
+  const parts = parsePath(path);
+  if (!parts.length) return obj;
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (cur[key] == null || typeof cur[key] !== "object") cur[key] = {};
+    cur = cur[key];
+  }
+  cur[parts[parts.length - 1]] = value;
+  return obj;
+}
+
+/**
+ * Try/catch helper with fallback value or handler.
+ * @param {Function} fn
+ * @param {*|Function} fallback
+ * @returns {*}
+ */
+function tryCatch(fn, fallback) {
+  try {
+    return fn();
+  } catch (err) {
+    return typeof fallback === "function" ? fallback(err) : fallback;
+  }
+}
+
+/**
+ * Run a side-effect function and return the original value.
+ * @param {*} value
+ * @param {Function} fn
+ * @returns {*}
+ */
+function tap(value, fn) {
+  if (typeof fn === "function") fn(value);
+  return value;
+}
+
+/**
+ * Sleep for ms.
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if string includes any of the candidates.
+ * @param {*} str
+ * @param {Array|string} candidates
+ * @returns {boolean}
+ */
+function containsAny(str, candidates) {
+  const s = String(str);
+  const list = Array.isArray(candidates) ? candidates : Array.prototype.slice.call(arguments, 1);
+  return list.some(c => s.includes(String(c)));
+}
+
+/**
+ * Check if string starts with any of the candidates.
+ * @param {*} str
+ * @param {Array|string} candidates
+ * @returns {boolean}
+ */
+function startsWithAny(str, candidates) {
+  const s = String(str);
+  const list = Array.isArray(candidates) ? candidates : Array.prototype.slice.call(arguments, 1);
+  return list.some(c => s.startsWith(String(c)));
+}
+
+/**
+ * Check if string ends with any of the candidates.
+ * @param {*} str
+ * @param {Array|string} candidates
+ * @returns {boolean}
+ */
+function endsWithAny(str, candidates) {
+  const s = String(str);
+  const list = Array.isArray(candidates) ? candidates : Array.prototype.slice.call(arguments, 1);
+  return list.some(c => s.endsWith(String(c)));
+}
+
+/**
+ * Safe JSON parse with fallback.
+ * @param {string} s
+ * @param {*} fallback
+ * @returns {*}
+ */
+function safeJsonParse(s, fallback) {
+  try {
+    return JSON.parse(s);
+  } catch (err) {
+    return fallback;
+  }
+}
+
+/**
+ * Run a function only once.
+ * @param {Function} fn
+ * @returns {Function}
+ */
+function once(fn) {
+  let called = false;
+  let value;
+  return function wrapped() {
+    if (!called) {
+      called = true;
+      value = fn.apply(this, arguments);
+    }
+    return value;
+  };
+}
+
+/**
+ * Debounce a function.
+ * @param {Function} fn
+ * @param {number} wait
+ * @returns {Function}
+ */
+function debounce(fn, wait) {
+  let timer = null;
+  return function debounced() {
+    const args = arguments;
+    const ctx = this;
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(ctx, args), wait);
+  };
+}
+
+/**
+ * Throttle a function.
+ * @param {Function} fn
+ * @param {number} wait
+ * @returns {Function}
+ */
+function throttle(fn, wait) {
+  let last = 0;
+  let timer = null;
+  return function throttled() {
+    const now = Date.now();
+    const remaining = wait - (now - last);
+    const ctx = this;
+    const args = arguments;
+    if (remaining <= 0) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      last = now;
+      fn.apply(ctx, args);
+    } else if (!timer) {
+      timer = setTimeout(() => {
+        last = Date.now();
+        timer = null;
+        fn.apply(ctx, args);
+      }, remaining);
+    }
+  };
+}
+
+/**
+ * Unique by key or key function.
+ * @param {Array} arr
+ * @param {Function|string} keyFn
+ * @returns {Array}
+ */
+function uniqueBy(arr, keyFn) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    keyFn = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr)) return [];
+  const fn = typeof keyFn === "function" ? keyFn : (x) => x[keyFn];
+  const seen = new Set();
+  const out = [];
+  for (const item of arr) {
+    const key = fn(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push(item);
+    }
+  }
+  return out;
+}
+
+/**
+ * Pluck a property from array of objects.
+ * @param {Array} arr
+ * @param {string} key
+ * @returns {Array}
+ */
+function pluck(arr, key) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    key = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr)) return [];
+  return arr.map(x => x && x[key]);
+}
+
+/**
+ * Sort by key or key function (ascending).
+ * @param {Array} arr
+ * @param {Function|string} keyFn
+ * @returns {Array}
+ */
+function sortBy(arr, keyFn) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    keyFn = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr)) return [];
+  const fn = typeof keyFn === "function" ? keyFn : (x) => x[keyFn];
+  return arr.slice().sort((a, b) => {
+    const ka = fn(a);
+    const kb = fn(b);
+    if (ka < kb) return -1;
+    if (ka > kb) return 1;
+    return 0;
+  });
+}
+
+/**
+ * Round to a number of decimals.
+ * @param {number} n
+ * @param {number} decimals
+ * @returns {number}
+ */
+function roundTo(n, decimals) {
+  // If a place value like 100 or 1000 is provided, round to that place.
+  if (typeof decimals === "number" && Number.isInteger(decimals) && Math.abs(decimals) >= 10) {
+    const place = decimals;
+    if (place === 0) return 0;
+    return Math.round(Number(n) / place) * place;
+  }
+  const p = Math.pow(10, decimals || 0);
+  return Math.round(Number(n) * p) / p;
+}
+
+/**
+ * Round to decimal places (e.g. hundredths = 2).
+ * @param {number} n
+ * @param {number|string} place
+ * @returns {number}
+ */
+function roundDecimal(n, place) {
+  const map = {
+    tenths: 1,
+    hundredths: 2,
+    thousandths: 3,
+  };
+  const dec = typeof place === "string" ? (map[place] ?? 0) : place;
+  const p = Math.pow(10, dec || 0);
+  return Math.round(Number(n) * p) / p;
+}
+
+/**
+ * Floor a number.
+ * @param {number} n
+ * @returns {number}
+ */
+function roundDown(n) {
+  return Math.floor(n);
+}
+
+/**
+ * Ceil a number.
+ * @param {number} n
+ * @returns {number}
+ */
+function roundUp(n) {
+  return Math.ceil(n);
+}
+
+/**
+ * Linear interpolation.
+ * @param {number} a
+ * @param {number} b
+ * @param {number} t
+ * @returns {number}
+ */
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+
+/**
+ * Convert part/total to percentage.
+ * @param {number} part
+ * @param {number} total
+ * @returns {number}
+ */
+function percent(part, total) {
+  if (total === 0) return 0;
+  return (Number(part) / Number(total)) * 100;
+}
+
+/**
+ * Clamp to [0, 1].
+ * @param {number} n
+ * @returns {number}
+ */
+function clamp01(n) {
+  return clamp(n, 0, 1);
+}
+
+/**
+ * Random integer between min and max inclusive.
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+function randomInt(min, max) {
+  const a = Math.ceil(min);
+  const b = Math.floor(max);
+  return Math.floor(Math.random() * (b - a + 1)) + a;
+}
+
+/**
+ * Random float between min and max.
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+function randomFloat(min, max) {
+  return Math.random() * (max - min) + min;
+}
+
+/**
+ * Shuffle array (Fisher-Yates).
+ * @param {Array} arr
+ * @returns {Array}
+ */
+function shuffle(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (!Array.isArray(arr)) return [];
+  const out = arr.slice();
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+
+/**
+ * Sample one element from array.
+ * @param {Array} arr
+ * @returns {*}
+ */
+function sample(arr) {
+  if (!Array.isArray(arr)) arr = arrayFromArgs(arguments, []);
+  if (!Array.isArray(arr) || arr.length === 0) return undefined;
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+/**
+ * Deep clone (uses structuredClone when available).
+ * @param {*} value
+ * @returns {*}
+ */
+function deepClone(value) {
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value));
+}
+
+/**
+ * Safe JSON stringify with fallback.
+ * @param {*} value
+ * @param {*} fallback
+ * @returns {string}
+ */
+function safeJsonStringify(value, fallback = "") {
+  try {
+    return JSON.stringify(value);
+  } catch (err) {
+    return String(fallback);
+  }
+}
+
+/**
+ * Move an item within an array.
+ * @param {Array} arr
+ * @param {number} fromIndex
+ * @param {number} toIndex
+ * @returns {Array}
+ */
+function move(arr, fromIndex, toIndex) {
+  if (!Array.isArray(arr)) {
+    const args = Array.prototype.slice.call(arguments);
+    toIndex = args.pop();
+    fromIndex = args.pop();
+    arr = args;
+  }
+  if (!Array.isArray(arr)) return [];
+  const out = arr.slice();
+  const len = out.length;
+  const from = fromIndex < 0 ? len + fromIndex : fromIndex;
+  const to = toIndex < 0 ? len + toIndex : toIndex;
+  if (from < 0 || from >= len || to < 0 || to >= len) return out;
+  const [item] = out.splice(from, 1);
+  out.splice(to, 0, item);
+  return out;
+}
+
+/**
+ * Group array items by key function.
+ * @param {Array} arr
+ * @param {Function} keyFn
+ * @returns {Object}
+ */
+function arrayGroupBy(arr, keyFn) {
+  return groupBy(arr, keyFn);
+}
+
+/**
+ * Map object keys to a new object.
+ * @param {Object} obj
+ * @param {Function} keyFn
+ * @returns {Object}
+ */
+function mapKeys(obj, keyFn) {
+  if (!obj || typeof obj !== "object") return {};
+  const out = {};
+  Object.keys(obj).forEach(k => {
+    const nk = keyFn(k, obj[k], obj);
+    out[nk] = obj[k];
+  });
+  return out;
+}
+
+/**
+ * Invert keys and values.
+ * @param {Object} obj
+ * @returns {Object}
+ */
+function invert(obj) {
+  if (!obj || typeof obj !== "object") return {};
+  const out = {};
+  Object.keys(obj).forEach(k => {
+    out[String(obj[k])] = k;
+  });
+  return out;
+}
+
+/**
+ * Remove null/undefined/empty properties from object.
+ * @param {Object} obj
+ * @returns {Object}
+ */
+function objectCompact(obj) {
+  if (!obj || typeof obj !== "object") return {};
+  const out = {};
+  Object.keys(obj).forEach(k => {
+    if (!isEmpty(obj[k])) out[k] = obj[k];
+  });
+  return out;
+}
+
+/**
+ * Convert a string to Title Case.
+ * @param {*} s
+ * @returns {string}
+ */
+function toTitleCase(s) {
+  return String(s)
+    .toLowerCase()
+    .replace(/\b\w/g, c => c.toUpperCase());
+}
+
+/**
+ * Truncate string to length with ellipsis.
+ * @param {*} s
+ * @param {number} length
+ * @returns {string}
+ */
+function truncate(s, length) {
+  const str = String(s);
+  if (length <= 3) return str.slice(0, length);
+  if (str.length <= length) return str;
+  return str.slice(0, length - 3) + "...";
+}
+
+/**
+ * Replace all occurrences of substring.
+ * @param {*} s
+ * @param {string} substring
+ * @param {string} newSub
+ * @returns {string}
+ */
+function replaceAll(s, substring, newSub) {
+  return String(s).split(substring).join(newSub);
+}
+
+/**
+ * Count words in a string.
+ * @param {*} s
+ * @returns {number}
+ */
+function countWords(s) {
+  const words = String(s).trim().match(/\b[\w']+\b/g);
+  return words ? words.length : 0;
+}
+
+/**
+ * Install convenience methods on Array/Object/String prototypes.
+ * @returns {void}
+ */
+function install() {
+  const define = (proto, name, fn) => {
+    if (!Object.prototype.hasOwnProperty.call(proto, name)) {
+      Object.defineProperty(proto, name, {
+        value: fn,
+        enumerable: false,
+        configurable: true,
+        writable: true,
+      });
+    }
+  };
+
+  define(Array.prototype, "shuffle", function () { return shuffle(this); });
+  define(Array.prototype, "unique", function () { return uniq(this); });
+  define(Array.prototype, "chunk", function (size) { return chunk(this, size); });
+  define(Array.prototype, "move", function (from, to) { return move(this, from, to); });
+  define(Array.prototype, "groupBy", function (fn) { return arrayGroupBy(this, fn); });
+  define(Array.prototype, "compact", function (fn) { return compact(this, fn); });
+  define(Array.prototype, "flatten", function () { return flatten(this); });
+  define(Array.prototype, "first", function () { return first(this); });
+  define(Array.prototype, "last", function () { return last(this); });
+  define(Array.prototype, "take", function (n) { return take(this, n); });
+  define(Array.prototype, "takeRight", function (n) { return takeRight(this, n); });
+  define(Array.prototype, "drop", function (n) { return drop(this, n); });
+  define(Array.prototype, "dropRight", function (n) { return dropRight(this, n); });
+
+  define(Object.prototype, "mapKeys", function (fn) { return mapKeys(this, fn); });
+  define(Object.prototype, "pick", function (keys) { return pick(this, keys); });
+  define(Object.prototype, "invert", function () { return invert(this); });
+  define(Object.prototype, "compact", function () { return objectCompact(this); });
+  define(Object.prototype, "omit", function (keys) { return omit(this, keys); });
+  define(Object.prototype, "has", function (key) { return has(this, key); });
+  define(Object.prototype, "merge", function () { return merge.apply(null, [this].concat(Array.prototype.slice.call(arguments))); });
+  define(Object.prototype, "deepMerge", function () { return deepMerge.apply(null, [this].concat(Array.prototype.slice.call(arguments))); });
+  define(Object.prototype, "size", function () { return size(this); });
+
+  define(String.prototype, "toTitleCase", function () { return toTitleCase(this); });
+  define(String.prototype, "truncate", function (len) { return truncate(this, len); });
+  define(String.prototype, "replaceAllEasy", function (sub, rep) { return replaceAll(this, sub, rep); });
+  define(String.prototype, "countWords", function () { return countWords(this); });
+  define(String.prototype, "slugify", function () { return slugify(this); });
+  define(String.prototype, "padLeft", function (len, ch) { return padLeft(this, len, ch); });
+  define(String.prototype, "padRight", function (len, ch) { return padRight(this, len, ch); });
+  define(String.prototype, "repeatEasy", function (times) { return repeat(this, times); });
+  define(String.prototype, "stripNonAlpha", function () { return stripNonAlpha(this); });
+  define(String.prototype, "isBlank", function () { return isBlank(this); });
+  define(String.prototype, "normalizeString", function () { return normalizeString(this); });
+}
+
+module.exports = {
+  identity,
+  noop,
+  isNil,
+  isEmpty,
+  defaultTo,
+  toLower,
+  toUpper,
+  capitalize,
+  trim,
+  normalizeString,
+  slugify,
+  padLeft,
+  padRight,
+  repeat,
+  stripNonAlpha,
+  isBlank,
+  asArray,
+  anyOf,
+  eqAny,
+  inArray,
+  clamp,
+  between,
+  toInt,
+  toFloat,
+  toNumber,
+  isNumber,
+  isInt,
+  compact,
+  uniq,
+  flatten,
+  chunk,
+  range,
+  min,
+  max,
+  sum,
+  avg,
+  median,
+  mode,
+  percentile,
+  groupBy,
+  first,
+  last,
+  take,
+  takeRight,
+  drop,
+  dropRight,
+  zip,
+  unzip,
+  intersection,
+  difference,
+  union,
+  pick,
+  omit,
+  has,
+  keys,
+  values,
+  entries,
+  fromEntries,
+  merge,
+  deepMerge,
+  isObject,
+  size,
+  safeGet,
+  safeSet,
+  tryCatch,
+  tap,
+  sleep,
+  containsAny,
+  startsWithAny,
+  endsWithAny,
+  safeJsonParse,
+  once,
+  debounce,
+  throttle,
+  uniqueBy,
+  pluck,
+  sortBy,
+  roundTo,
+  roundDecimal,
+  roundDown,
+  roundUp,
+  lerp,
+  percent,
+  clamp01,
+  randomInt,
+  randomFloat,
+  shuffle,
+  sample,
+  deepClone,
+  safeJsonStringify,
+  move,
+  arrayGroupBy,
+  mapKeys,
+  invert,
+  objectCompact,
+  toTitleCase,
+  truncate,
+  replaceAll,
+  countWords,
+  install,
+};