@catbee/utils 2.0.0-next.0 → 2.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,11 +1,5 @@
 # @catbee/utils
 
-<!-- <div style="width: 100%; display: flex; align-items: center; justify-content: space-between;">
-  <b style="font-size: 24px; text-decoration: none;">@catbee/utils</b>
-  <a href="https://sonarcloud.io/summary/new_code?id=catbee-technologies_catbee-utils">
-    <img src="https://sonarcloud.io/images/project_badges/sonarcloud-dark.svg" alt="SonarQube Cloud" width="200"/>
-  </a>
-</div> -->
 
 ## 🧰 Utility Modules for Node.js
 
@@ -20,7 +14,7 @@ A modular, production-grade utility toolkit for Node.js and TypeScript, designed
   <img src="https://img.shields.io/npm/v/@catbee/utils/next" alt="NPM Next Version" /> -->
   <img src="https://img.shields.io/npm/dt/@catbee/utils" alt="NPM Downloads" />
   <img src="https://img.shields.io/npm/types/@catbee/utils" alt="TypeScript Types" />
-  <img src="https://img.shields.io/maintenance/yes/2025" alt="Maintenance" />
+  <img src="https://img.shields.io/maintenance/yes/2050" alt="Maintenance" />
   <img src="https://snyk.io/test/github/catbee-technologies/catbee-utils/badge.svg" alt="Snyk Vulnerabilities" />
   <img src="https://sonarcloud.io/api/project_badges/measure?project=catbee-technologies_catbee-utils&metric=alert_status&token=93da835f2d48d37b41fa628cc7fc764c873bd700" alt="Quality Gate Status" />
   <img src="https://sonarcloud.io/api/project_badges/measure?project=catbee-technologies_catbee-utils&metric=ncloc&token=93da835f2d48d37b41fa628cc7fc764c873bd700" alt="Lines of Code" />
@@ -53,66 +47,122 @@ npm i @catbee/utils
 ## ⚡ Quick Start
 
 ```ts
-import { chunk, sleep, getLogger, uuid, isEmail } from "@catbee/utils";
-
-// Chunk an array
-const result = chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
-
-// Sleep for 1 second
-await sleep(1000);
-
-// Log with context
-getLogger().info("App started");
-
-// Generate a secure UUID
-console.log(uuid()); // e.g. 2a563ec1-caf6-4fe2-b60c-9cf7fb1bdb7f
-
-// Basic validation
-console.log(isEmail("user@example.com")); // true
+import { ServerConfigBuilder, ExpressServer } from '@catbee/utils/server';
+import { Router } from 'express';
+
+const config = new ServerConfigBuilder()
+  .withPort(3000)
+  .withCors({ origin: '*' })
+  .enableRateLimit({ max: 50, windowMs: 60000 })
+  .enableRequestLogging({ ignorePaths: ['/healthz', '/metrics'] })
+  .withHealthCheck({ path: '/health', detailed: true })
+  .enableOpenApi('./openapi.yaml', { mountPath: '/docs' })
+  .withGlobalHeaders({ 'X-Powered-By': 'Catbee' })
+  .withGlobalPrefix('/api')
+  .withRequestId({ headerName: 'X-Request-Id', exposeHeader: true })
+  .enableResponseTime({ addHeader: true, logOnComplete: true })
+  .build();
+
+const server = new ExpressServer(config, {
+  beforeInit: srv => console.log('Initializing server...'),
+  afterInit: srv => console.log('Server initialized'),
+  beforeStart: app => console.log('Starting server...'),
+  afterStart: srv => console.log('Server started!'),
+  beforeStop: srv => console.log('Stopping server...'),
+  afterStop: () => console.log('Server stopped.'),
+  onRequest: (req, res, next) => {
+    console.log('Processing request:', req.method, req.url);
+    next();
+  },
+  onResponse: (req, res, next) => {
+    res.setHeader('X-Processed-By', 'ExpressServer');
+    next();
+  },
+  onError: (err, req, res, next) => {
+    console.error('Custom error handler:', err);
+    res.status(500).json({ error: 'Custom error: ' + err.message });
+  }
+});
+
+// Register routes
+const router = server.createRouter('/users');
+router.get('/', (req, res) => res.json({ users: [] }));
+router.post('/', (req, res) => res.json({ created: true }));
+
+// Or set a base router for all routes
+const baseRouter = Router();
+baseRouter.use('/users', router);
+server.setBaseRouter(baseRouter);
+
+server.registerHealthCheck('database', async () => await checkDatabaseConnection());
+server.useMiddleware(loggingMiddleware, errorMiddleware);
+
+await server.start();
+server.enableGracefulShutdown();
 ```
 
 ---
 
 ## 📚 Modules Overview
 
-| Module | Description |
-| ------ | ----------- |
-| [Express Server](https://catbee.in/docs/@catbee/utils/express-server) | Fast, secure, and scalable server setup |
-| [Array Utilities](https://catbee.in/docs/@catbee/utils/modules/array) | Advanced array manipulation |
-| [Async Utilities](https://catbee.in/docs/@catbee/utils/modules/async) | Promise helpers, concurrency, timing |
-| [Cache Utilities](https://catbee.in/docs/@catbee/utils/modules/cache) | In-memory caching with TTL |
-| [Context Store](https://catbee.in/docs/@catbee/utils/modules/context-store) | Per-request context via AsyncLocalStorage |
-| [Crypto Utilities](https://catbee.in/docs/@catbee/utils/modules/crypto) | Hashing, encryption, tokens |
-| [Date Utilities](https://catbee.in/docs/@catbee/utils/modules/date) | Date/time manipulation |
-| [Decorators Utilities](https://catbee.in/docs/@catbee/utils/modules/decorators) | TypeScript decorators for Express |
-| [Directory Utilities](https://catbee.in/docs/@catbee/utils/modules/directory) | Directory and file system helpers |
-| [Environment Utilities](https://catbee.in/docs/@catbee/utils/modules/environment) | Env variable management |
-| [Exception Utilities](https://catbee.in/docs/@catbee/utils/modules/exception) | HTTP and error handling |
-| [File System Utilities](https://catbee.in/docs/@catbee/utils/modules/file-system) | File operations |
-| [HTTP Status Codes](https://catbee.in/docs/@catbee/utils/modules/http-status-codes) | Typed status codes |
-| [ID Utilities](https://catbee.in/docs/@catbee/utils/modules/id) | UUID and ID generation |
-| [Logger Utilities](https://catbee.in/docs/@catbee/utils/modules/logger) | Structured logging with Pino |
-| [Middleware Utilities](https://catbee.in/docs/@catbee/utils/modules/middleware) | Express middleware collection |
-| [Object Utilities](https://catbee.in/docs/@catbee/utils/modules/object) | Deep merge, flatten, pick/omit, etc. |
-| [Performance Utilities](https://catbee.in/docs/@catbee/utils/modules/performance) | Timing, memoization, memory tracking |
-| [Request Utilities](https://catbee.in/docs/@catbee/utils/modules/request) | HTTP request parameter parsing/validation |
-| [Response Utilities](https://catbee.in/docs/@catbee/utils/modules/response) | Standardized API response formatting |
-| [Stream Utilities](https://catbee.in/docs/@catbee/utils/modules/stream) | Stream conversion, batching, throttling, line splitting |
-| [String Utilities](https://catbee.in/docs/@catbee/utils/modules/string) | Casing, masking, slugifying, formatting |
-| [Type Utilities](https://catbee.in/docs/@catbee/utils/modules/type) | Type checking, conversion, guards |
-| [URL Utilities](https://catbee.in/docs/@catbee/utils/modules/url) | URL parsing, query manipulation, normalization |
-| [Validate Utilities](https://catbee.in/docs/@catbee/utils/modules/validation) | Input validation functions |
+| Module                                                                      | Description                                             |
+| --------------------------------------------------------------------------- | ------------------------------------------------------- |
+| [Express Server](https://catbee.in/docs/@catbee/utils/server)               | Fast, secure, and scalable server setup                 |
+| [Array Utilities](https://catbee.in/docs/@catbee/utils/array)               | Advanced array manipulation                             |
+| [Async Utilities](https://catbee.in/docs/@catbee/utils/async)               | Promise helpers, concurrency, timing                    |
+| [Cache Utilities](https://catbee.in/docs/@catbee/utils/cache)               | In-memory caching with TTL                              |
+| [Context Store](https://catbee.in/docs/@catbee/utils/context-store)         | Per-request context via AsyncLocalStorage               |
+| [Crypto Utilities](https://catbee.in/docs/@catbee/utils/crypto)             | Hashing, encryption, tokens                             |
+| [Date Utilities](https://catbee.in/docs/@catbee/utils/date)                 | Date/time manipulation                                  |
+| [Decorators Utilities](https://catbee.in/docs/@catbee/utils/decorator)      | TypeScript decorators for Express                       |
+| [Directory Utilities](https://catbee.in/docs/@catbee/utils/directory)       | Directory and file system helpers                       |
+| [Environment Utilities](https://catbee.in/docs/@catbee/utils/environment)   | Env variable management                                 |
+| [Exception Utilities](https://catbee.in/docs/@catbee/utils/exception)       | HTTP and error handling                                 |
+| [File System Utilities](https://catbee.in/docs/@catbee/utils/fs)            | File operations                                         |
+| [HTTP Status Codes](https://catbee.in/docs/@catbee/utils/http-status-codes) | Typed status codes                                      |
+| [ID Utilities](https://catbee.in/docs/@catbee/utils/id)                     | UUID and ID generation                                  |
+| [Logger Utilities](https://catbee.in/docs/@catbee/utils/logger)             | Structured logging with Pino                            |
+| [Middleware Utilities](https://catbee.in/docs/@catbee/utils/middleware)     | Express middleware collection                           |
+| [Object Utilities](https://catbee.in/docs/@catbee/utils/object)             | Deep merge, flatten, pick/omit, etc.                    |
+| [Performance Utilities](https://catbee.in/docs/@catbee/utils/performance)   | Timing, memoization, memory tracking                    |
+| [Request Utilities](https://catbee.in/docs/@catbee/utils/request)           | HTTP request parameter parsing/validation               |
+| [Response Utilities](https://catbee.in/docs/@catbee/utils/response)         | Standardized API response formatting                    |
+| [Stream Utilities](https://catbee.in/docs/@catbee/utils/stream)             | Stream conversion, batching, throttling, line splitting |
+| [String Utilities](https://catbee.in/docs/@catbee/utils/string)             | Casing, masking, slugifying, formatting                 |
+| [Type Utilities](https://catbee.in/docs/@catbee/utils/type)                 | Type checking, conversion, guards                       |
+| [Types Utilities](https://catbee.in/docs/@catbee/utils/types)               | Common TypeScript types and interfaces                  |
+| [URL Utilities](https://catbee.in/docs/@catbee/utils/url)                   | URL parsing, query manipulation, normalization          |
+| [Validate Utilities](https://catbee.in/docs/@catbee/utils/validation)       | Input validation functions                              |
 
 ---
 
 ## 🏁 Usage
 
-Import only what you need:
+This library supports flexible import patterns to suit your needs:
+
+### Root-level imports (everything available)
+Import any utility directly from the root package:
 
 ```ts
-import { chunk, sleep, TTLCache, getLogger } from "@catbee/utils";
+import { chunk, sleep, TTLCache, getLogger, ServerConfigBuilder } from '@catbee/utils';
 ```
 
+### Module-level imports (scoped imports)
+Import only from specific modules for better organization and smaller bundles:
+
+```ts
+// Import only server-related exports
+import { ServerConfigBuilder, ExpressServer } from '@catbee/utils/server';
+
+// Import only date utilities
+import { formatDate, addDays, DateBuilder } from '@catbee/utils/date';
+
+// Import only crypto utilities
+import { hashPassword, verifyPassword } from '@catbee/utils/crypto';
+```
+
+Both import styles are fully supported and tree-shakable. Use whichever fits your project structure best!
+
 ---
 
 ## 📖 Documentation

package/array/index.cjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,7 +24,8 @@
 
 'use strict';
 
-var obj = require('@catbee/utils/obj');
+var object = require('@catbee/utils/object');
+var crypto = require('crypto');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -43,49 +44,64 @@ function unique(array, keyFn) {
   if (!Array.isArray(array) || array.length === 0) return [];
   if (!keyFn) return Array.from(new Set(array));
   const seen = /* @__PURE__ */ new Set();
-  return array.filter((item) => {
+  const result = [];
+  for (const item of array) {
     const key = keyFn(item);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
 }
 __name(unique, "unique");
 function flattenDeep(array) {
   if (!Array.isArray(array)) return [];
   const result = [];
-  for (const val of array) {
+  const stack = [
+    ...array
+  ];
+  while (stack.length) {
+    const val = stack.pop();
     if (Array.isArray(val)) {
-      result.push(...flattenDeep(val));
+      stack.push(...val);
     } else {
       result.push(val);
     }
   }
-  return result;
+  return result.reverse();
 }
 __name(flattenDeep, "flattenDeep");
 function random(array) {
   if (!Array.isArray(array) || array.length === 0) return void 0;
-  const idx = Math.floor(Math.random() * array.length);
-  return array[idx];
+  return array[secureIndex(array.length)];
 }
 __name(random, "random");
 function groupBy(array, keyOrFn) {
   if (!Array.isArray(array) || array.length === 0) return {};
-  const keyFn = typeof keyOrFn === "function" ? keyOrFn : (item) => item[keyOrFn];
-  return array.reduce((acc, item) => {
-    const key = keyFn(item);
-    if (!acc[key]) acc[key] = [];
-    acc[key].push(item);
-    return acc;
-  }, {});
+  const keyFn = typeof keyOrFn === "function" ? keyOrFn : (item) => String(object.getValueByPath(item, keyOrFn));
+  const result = {};
+  for (const item of array) {
+    const key = String(keyFn(item));
+    if (Object.hasOwn(result, key)) {
+      result[key].push(item);
+    } else {
+      result[key] = [
+        item
+      ];
+    }
+  }
+  return Object.fromEntries(Object.entries(result).map(([k, v]) => [
+    k,
+    v
+  ]));
 }
 __name(groupBy, "groupBy");
 function shuffle(array) {
   if (!Array.isArray(array)) throw new TypeError("Expected an array");
   const copy = array.slice();
   for (let i = copy.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
+    const j = secureIndex(i + 1);
     [copy[i], copy[j]] = [
       copy[j],
       copy[i]
@@ -96,7 +112,7 @@ function shuffle(array) {
 __name(shuffle, "shuffle");
 function pluck(array, key) {
   if (!Array.isArray(array)) return [];
-  return array.map((item) => item[key]);
+  return array.map((item) => item?.[key]);
 }
 __name(pluck, "pluck");
 function difference(a, b) {
@@ -111,35 +127,41 @@ function intersect(a, b) {
   return a.filter((item) => setB.has(item));
 }
 __name(intersect, "intersect");
-function mergeSort(array, key, direction = "asc") {
+function mergeSort(array, key, direction = "asc", compareFn) {
   if (!Array.isArray(array)) throw new TypeError("Expected array");
-  if (array.length <= 1) return array.slice();
-  const keyFn = typeof key === "function" ? key : (item) => obj.getValueByPath(item, key);
-  const compare = /* @__PURE__ */ __name((a, b) => {
+  const arr = array.slice();
+  if (arr.length <= 1) return arr;
+  const keyFn = typeof key === "function" ? key : (item) => object.getValueByPath(item, key);
+  const collator = new Intl.Collator("en", {
+    numeric: true
+  });
+  const compare = compareFn ?? function(a, b) {
     const aVal = keyFn(a);
     const bVal = keyFn(b);
     if (aVal === bVal) return 0;
     if (aVal == null) return direction === "asc" ? 1 : -1;
     if (bVal == null) return direction === "asc" ? -1 : 1;
-    return direction === "asc" ? aVal < bVal ? -1 : 1 : aVal > bVal ? -1 : 1;
-  }, "compare");
+    return direction === "asc" ? collator.compare(String(aVal), String(bVal)) : collator.compare(String(bVal), String(aVal));
+  };
   const merge = /* @__PURE__ */ __name((left, right) => {
     const result = [];
     let i = 0, j = 0;
     while (i < left.length && j < right.length) {
-      if (compare(left[i], right[j]) <= 0) result.push(left[i++]);
-      else result.push(right[j++]);
+      result.push(compare(left[i], right[j]) <= 0 ? left[i++] : right[j++]);
     }
-    return result.concat(left.slice(i)).concat(right.slice(j));
+    while (i < left.length) result.push(left[i++]);
+    while (j < right.length) result.push(right[j++]);
+    return result;
   }, "merge");
-  const sort = /* @__PURE__ */ __name((arr) => {
-    if (arr.length <= 1) return arr;
-    const mid = Math.floor(arr.length / 2);
-    const left = sort(arr.slice(0, mid));
-    const right = sort(arr.slice(mid));
+  const sort = /* @__PURE__ */ __name((input) => {
+    const len = input.length;
+    if (len <= 1) return input;
+    const mid = len >> 1;
+    const left = sort(input.slice(0, mid));
+    const right = sort(input.slice(mid));
     return merge(left, right);
   }, "sort");
-  return sort(array);
+  return sort(arr);
 }
 __name(mergeSort, "mergeSort");
 function zip(...arrays) {
@@ -156,28 +178,20 @@ function zip(...arrays) {
 }
 __name(zip, "zip");
 function partition(array, predicate) {
+  const pass = [];
+  const fail = [];
   if (!Array.isArray(array)) return [
-    [],
-    []
+    pass,
+    fail
+  ];
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    (predicate(item, i, array) ? pass : fail).push(item);
+  }
+  return [
+    pass,
+    fail
   ];
-  return array.reduce(([pass, fail], item, index) => {
-    return predicate(item, index, array) ? [
-      [
-        ...pass,
-        item
-      ],
-      fail
-    ] : [
-      pass,
-      [
-        ...fail,
-        item
-      ]
-    ];
-  }, [
-    [],
-    []
-  ]);
 }
 __name(partition, "partition");
 function range(start, end, step = 1) {
@@ -185,62 +199,189 @@ function range(start, end, step = 1) {
     throw new TypeError("Arguments must be finite numbers");
   }
   if (step === 0) throw new Error("Step cannot be zero");
-  const isAscending = step > 0;
-  if (isAscending && start >= end || !isAscending && start <= end) {
-    return [];
-  }
-  const length = Math.max(Math.ceil((end - start) / step), 0);
-  const result = new Array(length);
-  for (let i = 0, value = start; i < length; i++, value += step) {
-    result[i] = value;
+  const result = [];
+  if (step > 0) {
+    for (let i = start; i < end; i += step) result.push(i);
+  } else {
+    for (let i = start; i > end; i += step) result.push(i);
   }
   return result;
 }
 __name(range, "range");
 function take(array, n = 1) {
   if (!Array.isArray(array) || n <= 0) return [];
-  return array.slice(0, n);
+  return n >= array.length ? array.slice() : array.slice(0, n);
 }
 __name(take, "take");
 function takeWhile(array, predicate) {
-  if (!Array.isArray(array)) return [];
   const result = [];
-  for (let i = 0; i < array.length; i++) {
-    if (!predicate(array[i], i)) break;
-    result.push(array[i]);
+  if (!Array.isArray(array)) return result;
+  const len = array.length;
+  for (let i = 0; i < len; i++) {
+    const item = array[i];
+    if (!predicate(item, i)) break;
+    result.push(item);
   }
   return result;
 }
 __name(takeWhile, "takeWhile");
 function compact(array) {
   if (!Array.isArray(array)) return [];
-  return array.filter(Boolean);
+  const result = [];
+  for (const v of array) {
+    if (v) result.push(v);
+  }
+  return result;
 }
 __name(compact, "compact");
 function countBy(array, keyFn) {
   if (!Array.isArray(array)) return {};
-  return array.reduce((acc, item) => {
+  const result = {};
+  for (const item of array) {
     const key = String(keyFn(item));
-    acc[key] = (acc[key] || 0) + 1;
-    return acc;
-  }, {});
+    result[key] = (result[key] ?? 0) + 1;
+  }
+  return result;
 }
 __name(countBy, "countBy");
+function toggle(array, item) {
+  if (!Array.isArray(array)) return [
+    item
+  ];
+  const exists = array.includes(item);
+  if (exists) return array.filter((x) => x !== item);
+  return [
+    ...array,
+    item
+  ];
+}
+__name(toggle, "toggle");
+function secureIndex(max) {
+  if (!Number.isInteger(max) || max <= 0) throw new RangeError("Max must be a positive integer");
+  const limit = 4294967295 - 4294967295 % max;
+  let rand;
+  do {
+    rand = crypto.randomBytes(4).readUInt32BE(0);
+  } while (rand >= limit);
+  return rand % max;
+}
+__name(secureIndex, "secureIndex");
+var secureRandom = /* @__PURE__ */ __name((array) => {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const idx = secureIndex(array.length);
+  return array[idx];
+}, "secureRandom");
+function findLast(array, predicate) {
+  if (!Array.isArray(array)) return void 0;
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) return array[i];
+  }
+  return void 0;
+}
+__name(findLast, "findLast");
+function findLastIndex(array, predicate) {
+  if (!Array.isArray(array)) return -1;
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) return i;
+  }
+  return -1;
+}
+__name(findLastIndex, "findLastIndex");
+function chunkBy(array, predicate) {
+  if (!Array.isArray(array) || array.length === 0) return [];
+  const result = [];
+  let chunk2 = [];
+  for (let i = 0; i < array.length; i++) {
+    if (predicate(array[i], i, array) && chunk2.length) {
+      result.push(chunk2);
+      chunk2 = [];
+    }
+    chunk2.push(array[i]);
+  }
+  if (chunk2.length) result.push(chunk2);
+  return result;
+}
+__name(chunkBy, "chunkBy");
+function remove(array, value) {
+  if (!Array.isArray(array)) return [];
+  return array.filter((item) => item !== value);
+}
+__name(remove, "remove");
+function isSorted(array, direction = "asc", compareFn) {
+  if (!Array.isArray(array) || array.length <= 1) return true;
+  const cmp = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (let i = 1; i < array.length; i++) {
+    const res = cmp(array[i - 1], array[i]);
+    if (direction === "asc" && res > 0 || direction === "desc" && res < 0) return false;
+  }
+  return true;
+}
+__name(isSorted, "isSorted");
+function headOfArr(array) {
+  return Array.isArray(array) && array.length > 0 ? array[0] : void 0;
+}
+__name(headOfArr, "headOfArr");
+function lastOfArr(array) {
+  return Array.isArray(array) && array.length > 0 ? array.at(-1) : void 0;
+}
+__name(lastOfArr, "lastOfArr");
+function drop(array, n) {
+  if (!Array.isArray(array) || n <= 0) return [
+    ...array
+  ];
+  return array.slice(n);
+}
+__name(drop, "drop");
+function dropWhile(array, predicate) {
+  if (!Array.isArray(array)) return [];
+  let i = 0;
+  while (i < array.length && predicate(array[i], i)) {
+    i++;
+  }
+  return array.slice(i);
+}
+__name(dropWhile, "dropWhile");
+function maxBy(array, keyOrFn) {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const fn = typeof keyOrFn === "function" ? keyOrFn : (item) => item[keyOrFn];
+  return array.reduce((max, item) => fn(item) > fn(max) ? item : max, array[0]);
+}
+__name(maxBy, "maxBy");
+function minBy(array, keyOrFn) {
+  if (!Array.isArray(array) || array.length === 0) return void 0;
+  const fn = typeof keyOrFn === "function" ? keyOrFn : (item) => item[keyOrFn];
+  return array.reduce((min, item) => fn(item) < fn(min) ? item : min, array[0]);
+}
+__name(minBy, "minBy");
 
 exports.chunk = chunk;
+exports.chunkBy = chunkBy;
 exports.compact = compact;
 exports.countBy = countBy;
 exports.difference = difference;
+exports.drop = drop;
+exports.dropWhile = dropWhile;
+exports.findLast = findLast;
+exports.findLastIndex = findLastIndex;
 exports.flattenDeep = flattenDeep;
 exports.groupBy = groupBy;
+exports.headOfArr = headOfArr;
 exports.intersect = intersect;
+exports.isSorted = isSorted;
+exports.lastOfArr = lastOfArr;
+exports.maxBy = maxBy;
 exports.mergeSort = mergeSort;
+exports.minBy = minBy;
 exports.partition = partition;
 exports.pluck = pluck;
 exports.random = random;
 exports.range = range;
+exports.remove = remove;
+exports.secureIndex = secureIndex;
+exports.secureRandom = secureRandom;
 exports.shuffle = shuffle;
 exports.take = take;
 exports.takeWhile = takeWhile;
+exports.toggle = toggle;
 exports.unique = unique;
 exports.zip = zip;