typetify 0.1.1

package/dist/chunk-ZE4FDBRI.mjs

@@ -0,0 +1,79 @@
+import { __export } from './chunk-J5LGTIGS.mjs';
+
+// src/fn/index.ts
+var fn_exports = {};
+__export(fn_exports, {
+  ary: () => ary,
+  curry: () => curry,
+  flip: () => flip,
+  memoize: () => memoize,
+  negate: () => negate,
+  partial: () => partial,
+  unary: () => unary
+});
+
+// src/fn/memoize.ts
+function memoize(fn, resolver) {
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = resolver ? resolver(...args) : args[0];
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
+  };
+  return memoized;
+}
+
+// src/fn/negate.ts
+function negate(fn) {
+  return function(...args) {
+    return !fn(...args);
+  };
+}
+
+// src/fn/flip.ts
+function flip(fn) {
+  return function(b, a) {
+    return fn(a, b);
+  };
+}
+
+// src/fn/partial.ts
+function partial(fn, ...partialArgs) {
+  return function(...args) {
+    return fn(...partialArgs, ...args);
+  };
+}
+
+// src/fn/curry.ts
+function curry(fn) {
+  const arity = fn.length;
+  function curried(...args) {
+    if (args.length >= arity) {
+      return fn(...args);
+    }
+    return (...moreArgs) => curried(...args, ...moreArgs);
+  }
+  return curried;
+}
+
+// src/fn/ary.ts
+function ary(fn, n) {
+  return function(...args) {
+    return fn(...args.slice(0, n));
+  };
+}
+
+// src/fn/unary.ts
+function unary(fn) {
+  return function(arg) {
+    return fn(arg);
+  };
+}
+
+export { ary, curry, flip, fn_exports, memoize, negate, partial, unary };
+//# sourceMappingURL=chunk-ZE4FDBRI.mjs.map
+//# sourceMappingURL=chunk-ZE4FDBRI.mjs.map

package/dist/chunk-ZE4FDBRI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/fn/index.ts","../src/fn/memoize.ts","../src/fn/negate.ts","../src/fn/flip.ts","../src/fn/partial.ts","../src/fn/curry.ts","../src/fn/ary.ts","../src/fn/unary.ts"],"names":[],"mappings":";;;AAAA,IAAA,UAAA,GAAA;AAAA,QAAA,CAAA,UAAA,EAAA;AAAA,EAAA,GAAA,EAAA,MAAA,GAAA;AAAA,EAAA,KAAA,EAAA,MAAA,KAAA;AAAA,EAAA,IAAA,EAAA,MAAA,IAAA;AAAA,EAAA,OAAA,EAAA,MAAA,OAAA;AAAA,EAAA,MAAA,EAAA,MAAA,MAAA;AAAA,EAAA,OAAA,EAAA,MAAA,OAAA;AAAA,EAAA,KAAA,EAAA,MAAA;AAAA,CAAA,CAAA;;;ACYO,SAAS,OAAA,CACd,IACA,QAAA,EACG;AACH,EAAA,MAAM,KAAA,uBAAY,GAAA,EAA4B;AAE9C,EAAA,MAAM,QAAA,GAAW,YAA4B,IAAA,EAAoC;AAC/E,IAAA,MAAM,MAAM,QAAA,GAAW,QAAA,CAAS,GAAG,IAAI,CAAA,GAAI,KAAK,CAAC,CAAA;AAEjD,IAAA,IAAI,KAAA,CAAM,GAAA,CAAI,GAAG,CAAA,EAAG;AAClB,MAAA,OAAO,KAAA,CAAM,IAAI,GAAG,CAAA;AAAA,IACtB;AAEA,IAAA,MAAM,MAAA,GAAS,EAAA,CAAG,KAAA,CAAM,IAAA,EAAM,IAAI,CAAA;AAClC,IAAA,KAAA,CAAM,GAAA,CAAI,KAAK,MAAM,CAAA;AACrB,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,OAAO,QAAA;AACT;;;ACtBO,SAAS,OACd,EAAA,EACqC;AACrC,EAAA,OAAO,YAAa,IAAA,EAA8B;AAChD,IAAA,OAAO,CAAC,EAAA,CAAG,GAAG,IAAI,CAAA;AAAA,EACpB,CAAA;AACF;;;ACPO,SAAS,KACd,EAAA,EACmB;AACnB,EAAA,OAAO,SAAU,GAAM,CAAA,EAAS;AAC9B,IAAA,OAAO,EAAA,CAAG,GAAG,CAAC,CAAA;AAAA,EAChB,CAAA;AACF;;;ACNO,SAAS,OAAA,CACd,OACG,WAAA,EACgC;AACnC,EAAA,OAAO,YAAa,IAAA,EAA4B;AAC9C,IAAA,OAAO,EAAA,CAAG,GAAG,WAAA,EAAa,GAAG,IAAI,CAAA;AAAA,EACnC,CAAA;AACF;;;ACHO,SAAS,MACd,EAAA,EACyB;AACzB,EAAA,MAAM,QAAQ,EAAA,CAAG,MAAA;AAEjB,EAAA,SAAS,WAAW,IAAA,EAAkB;AACpC,IAAA,IAAI,IAAA,CAAK,UAAU,KAAA,EAAO;AACxB,MAAA,OAAO,EAAA,CAAG,GAAG,IAAI,CAAA;AAAA,IACnB;AACA,IAAA,OAAO,IAAI,QAAA,KAAoB,OAAA,CAAQ,GAAG,IAAA,EAAM,GAAG,QAAQ,CAAA;AAAA,EAC7D;AAEA,EAAA,OAAO,OAAA;AACT;;;AClBO,SAAS,GAAA,CACd,IACA,CAAA,EACmC;AACnC,EAAA,OAAO,YAAa,IAAA,EAA4B;AAC9C,IAAA,OAAO,GAAG,GAAG,IAAA,CAAK,KAAA,CAAM,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,EAC/B,CAAA;AACF;;;ACRO,SAAS,MACd,EAAA,EAC0C;AAC1C,EAAA,OAAO,SAAU,GAAA,EAAsC;AACrD,IAAA,OAAO,GAAG,GAAG,CAAA;AAAA,EACf,CAAA;AACF","file":"chunk-ZE4FDBRI.mjs","sourcesContent":["export { memoize } from './memoize'\nexport { negate } from './negate'\nexport { flip } from './flip'\nexport { partial } from './partial'\nexport { curry } from './curry'\nexport { ary } from './ary'\nexport { unary } from './unary'\n","/**\n * Creates a memoized version of a function.\n * Results are cached based on the first argument (by default).\n *\n * @example\n * const expensive = memoize((n: number) => {\n *   console.log('computing...')\n *   return n * 2\n * })\n * expensive(5) // logs 'computing...', returns 10\n * expensive(5) // returns 10 (cached)\n */\nexport function memoize<T extends (...args: any[]) => any>(\n  fn: T,\n  resolver?: (...args: Parameters<T>) => unknown\n): T {\n  const cache = new Map<unknown, ReturnType<T>>()\n\n  const memoized = function (this: unknown, ...args: Parameters<T>): ReturnType<T> {\n    const key = resolver ? resolver(...args) : args[0]\n\n    if (cache.has(key)) {\n      return cache.get(key)!\n    }\n\n    const result = fn.apply(this, args)\n    cache.set(key, result)\n    return result\n  }\n\n  return memoized as T\n}\n","/**\n * Creates a function that negates the result of the predicate.\n *\n * @example\n * const isEven = (n: number) => n % 2 === 0\n * const isOdd = negate(isEven)\n * isOdd(3) // true\n * isOdd(4) // false\n */\nexport function negate<T extends (...args: any[]) => boolean>(\n  fn: T\n): (...args: Parameters<T>) => boolean {\n  return function (...args: Parameters<T>): boolean {\n    return !fn(...args)\n  }\n}\n","/**\n * Creates a function that invokes the original function with arguments reversed.\n *\n * @example\n * const divide = (a: number, b: number) => a / b\n * const flipped = flip(divide)\n * flipped(2, 10) // 5 (10 / 2)\n */\nexport function flip<A, B, R>(\n  fn: (a: A, b: B) => R\n): (b: B, a: A) => R {\n  return function (b: B, a: A): R {\n    return fn(a, b)\n  }\n}\n","/**\n * Creates a function with some arguments pre-filled.\n *\n * @example\n * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`\n * const sayHello = partial(greet, 'Hello')\n * sayHello('World') // 'Hello, World!'\n */\nexport function partial<T extends (...args: any[]) => any, A extends any[]>(\n  fn: T,\n  ...partialArgs: A\n): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]): ReturnType<T> {\n    return fn(...partialArgs, ...args)\n  }\n}\n","/**\n * Creates a curried version of a function.\n * The curried function can be called with fewer arguments,\n * returning a new function that takes the remaining arguments.\n *\n * @example\n * const add = (a: number, b: number, c: number) => a + b + c\n * const curriedAdd = curry(add)\n * curriedAdd(1)(2)(3) // 6\n * curriedAdd(1, 2)(3) // 6\n * curriedAdd(1)(2, 3) // 6\n */\nexport function curry<T extends (...args: any[]) => any>(\n  fn: T\n): (...args: any[]) => any {\n  const arity = fn.length\n\n  function curried(...args: any[]): any {\n    if (args.length >= arity) {\n      return fn(...args)\n    }\n    return (...moreArgs: any[]) => curried(...args, ...moreArgs)\n  }\n\n  return curried\n}\n","/**\n * Creates a function that accepts up to n arguments, ignoring additional arguments.\n *\n * @example\n * const fn = ary(parseInt, 1)\n * ['1', '2', '3'].map(fn) // [1, 2, 3] instead of [1, NaN, NaN]\n */\nexport function ary<T extends (...args: any[]) => any>(\n  fn: T,\n  n: number\n): (...args: any[]) => ReturnType<T> {\n  return function (...args: any[]): ReturnType<T> {\n    return fn(...args.slice(0, n))\n  }\n}\n","/**\n * Creates a function that accepts only one argument, ignoring additional arguments.\n *\n * @example\n * ['1', '2', '3'].map(unary(parseInt)) // [1, 2, 3]\n */\nexport function unary<T extends (...args: any[]) => any>(\n  fn: T\n): (arg: Parameters<T>[0]) => ReturnType<T> {\n  return function (arg: Parameters<T>[0]): ReturnType<T> {\n    return fn(arg)\n  }\n}\n"]}

package/dist/collection/index.d.mts

@@ -0,0 +1,291 @@
+/**
+ * Returns an array with unique values.
+ * Optionally accepts a key function to determine uniqueness.
+ *
+ * @example
+ * unique([1, 2, 2, 3]) // [1, 2, 3]
+ * unique([{ id: 1 }, { id: 1 }, { id: 2 }], item => item.id) // [{ id: 1 }, { id: 2 }]
+ */
+declare function unique<T>(array: readonly T[]): T[];
+declare function unique<T, K>(array: readonly T[], keyFn: (item: T) => K): T[];
+
+/**
+ * Groups array elements by a key function.
+ *
+ * @example
+ * const users = [
+ *   { name: 'Alice', role: 'admin' },
+ *   { name: 'Bob', role: 'user' },
+ *   { name: 'Charlie', role: 'admin' },
+ * ]
+ * groupBy(users, user => user.role)
+ * // { admin: [{ name: 'Alice', ... }, { name: 'Charlie', ... }], user: [{ name: 'Bob', ... }] }
+ */
+declare function groupBy<T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, T[]>;
+
+/**
+ * Creates an object indexed by a key function.
+ * If multiple items have the same key, the last one wins.
+ *
+ * @example
+ * const users = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ * ]
+ * indexBy(users, user => user.id)
+ * // { 1: { id: 1, name: 'Alice' }, 2: { id: 2, name: 'Bob' } }
+ */
+declare function indexBy<T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, T>;
+
+/**
+ * Splits an array into two arrays based on a predicate.
+ * First array contains items that pass, second contains items that fail.
+ *
+ * @example
+ * const [evens, odds] = partition([1, 2, 3, 4], n => n % 2 === 0)
+ * // evens: [2, 4], odds: [1, 3]
+ */
+declare function partition<T>(array: readonly T[], predicate: (item: T) => boolean): [T[], T[]];
+
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * @example
+ * chunk([1, 2, 3, 4, 5], 2)
+ * // [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(array: readonly T[], size: number): T[][];
+
+/**
+ * Removes null and undefined values from an array.
+ * Properly narrows the type.
+ *
+ * @example
+ * compact([1, null, 2, undefined, 3])
+ * // [1, 2, 3] with type number[]
+ */
+declare function compact<T>(array: readonly (T | null | undefined)[]): T[];
+
+/**
+ * Flattens an array one level deep.
+ *
+ * @example
+ * flatten([[1, 2], [3, 4], [5]])
+ * // [1, 2, 3, 4, 5]
+ */
+declare function flatten<T>(array: readonly (T | readonly T[])[]): T[];
+
+/**
+ * Sorts an array by a key function. Returns a new array.
+ *
+ * @example
+ * const users = [{ name: 'Bob' }, { name: 'Alice' }]
+ * sortBy(users, user => user.name)
+ * // [{ name: 'Alice' }, { name: 'Bob' }]
+ */
+declare function sortBy<T>(array: readonly T[], keyFn: (item: T) => string | number, order?: 'asc' | 'desc'): T[];
+
+/**
+ * Returns the first element of an array, or undefined if empty.
+ *
+ * @example
+ * first([1, 2, 3]) // 1
+ * first([]) // undefined
+ */
+declare function first<T>(array: readonly T[]): T | undefined;
+
+/**
+ * Returns the last element of an array, or undefined if empty.
+ *
+ * @example
+ * last([1, 2, 3]) // 3
+ * last([]) // undefined
+ */
+declare function last<T>(array: readonly T[]): T | undefined;
+
+/**
+ * Creates an array of numbers from start to end (exclusive).
+ *
+ * @example
+ * range(0, 5) // [0, 1, 2, 3, 4]
+ * range(1, 10, 2) // [1, 3, 5, 7, 9]
+ */
+declare function range(start: number, end: number, step?: number): number[];
+
+/**
+ * Returns a new array with elements randomly shuffled.
+ * Uses Fisher-Yates algorithm.
+ *
+ * @example
+ * shuffle([1, 2, 3, 4, 5])
+ * // [3, 1, 5, 2, 4] (random order)
+ */
+declare function shuffle<T>(array: readonly T[]): T[];
+
+/**
+ * Returns a random element from an array.
+ *
+ * @example
+ * sample([1, 2, 3, 4, 5]) // random element
+ * sample([]) // undefined
+ */
+declare function sample<T>(array: readonly T[]): T | undefined;
+
+/**
+ * Zips two arrays together into an array of tuples.
+ * Stops at the shorter array.
+ *
+ * @example
+ * zip([1, 2, 3], ['a', 'b', 'c'])
+ * // [[1, 'a'], [2, 'b'], [3, 'c']]
+ */
+declare function zip<A, B>(a: readonly A[], b: readonly B[]): [A, B][];
+
+/**
+ * Unzips an array of tuples into two arrays.
+ *
+ * @example
+ * unzip([[1, 'a'], [2, 'b'], [3, 'c']])
+ * // [[1, 2, 3], ['a', 'b', 'c']]
+ */
+declare function unzip<A, B>(array: readonly (readonly [A, B])[]): [A[], B[]];
+
+/**
+ * Returns elements in the first array that are not in the second.
+ *
+ * @example
+ * difference([1, 2, 3, 4], [2, 4])
+ * // [1, 3]
+ */
+declare function difference<T>(a: readonly T[], b: readonly T[]): T[];
+
+/**
+ * Returns elements that exist in both arrays.
+ *
+ * @example
+ * intersection([1, 2, 3], [2, 3, 4])
+ * // [2, 3]
+ */
+declare function intersection<T>(a: readonly T[], b: readonly T[]): T[];
+
+/**
+ * Returns the first n elements of an array.
+ *
+ * @example
+ * take([1, 2, 3, 4, 5], 3) // [1, 2, 3]
+ * take([1, 2], 5) // [1, 2]
+ */
+declare function take<T>(arr: readonly T[], n: number): T[];
+
+/**
+ * Returns all but the first n elements of an array.
+ *
+ * @example
+ * drop([1, 2, 3, 4, 5], 2) // [3, 4, 5]
+ * drop([1, 2], 5) // []
+ */
+declare function drop<T>(arr: readonly T[], n: number): T[];
+
+/**
+ * Returns elements from the beginning of an array while the predicate returns true.
+ *
+ * @example
+ * takeWhile([1, 2, 3, 4, 1], n => n < 3) // [1, 2]
+ * takeWhile([5, 1, 2], n => n < 3) // []
+ */
+declare function takeWhile<T>(arr: readonly T[], predicate: (item: T, index: number) => boolean): T[];
+
+/**
+ * Drops elements from the beginning of an array while the predicate returns true.
+ *
+ * @example
+ * dropWhile([1, 2, 3, 4, 1], n => n < 3) // [3, 4, 1]
+ * dropWhile([5, 1, 2], n => n < 3) // [5, 1, 2]
+ */
+declare function dropWhile<T>(arr: readonly T[], predicate: (item: T, index: number) => boolean): T[];
+
+/**
+ * Returns the last element in an array that satisfies the predicate.
+ *
+ * @example
+ * findLast([1, 2, 3, 4], n => n % 2 === 0) // 4
+ * findLast([1, 3, 5], n => n % 2 === 0) // undefined
+ */
+declare function findLast<T>(arr: readonly T[], predicate: (item: T, index: number) => boolean): T | undefined;
+
+/**
+ * Creates an object counting occurrences of each key returned by the function.
+ *
+ * @example
+ * countBy([1, 2, 3, 4, 5], n => n % 2 === 0 ? 'even' : 'odd')
+ * // { odd: 3, even: 2 }
+ *
+ * countBy(['one', 'two', 'three'], s => s.length)
+ * // { 3: 2, 5: 1 }
+ */
+declare function countBy<T>(arr: readonly T[], fn: (item: T) => PropertyKey): Record<PropertyKey, number>;
+
+/**
+ * Returns the element with the maximum value according to the function.
+ *
+ * @example
+ * maxBy([{ age: 20 }, { age: 30 }, { age: 25 }], u => u.age)
+ * // { age: 30 }
+ *
+ * maxBy([], u => u.age) // undefined
+ */
+declare function maxBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined;
+
+/**
+ * Returns the element with the minimum value according to the function.
+ *
+ * @example
+ * minBy([{ age: 20 }, { age: 30 }, { age: 25 }], u => u.age)
+ * // { age: 20 }
+ *
+ * minBy([], u => u.age) // undefined
+ */
+declare function minBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined;
+
+/**
+ * Sums the values returned by the function for each element.
+ *
+ * @example
+ * sumBy([{ price: 10 }, { price: 20 }, { price: 30 }], item => item.price)
+ * // 60
+ *
+ * sumBy([], item => item.price) // 0
+ */
+declare function sumBy<T>(arr: readonly T[], fn: (item: T) => number): number;
+
+/**
+ * Returns the first element of an array, or undefined if empty.
+ * Alias for first().
+ *
+ * @example
+ * head([1, 2, 3]) // 1
+ * head([]) // undefined
+ */
+declare function head<T>(arr: readonly T[]): T | undefined;
+
+/**
+ * Returns all elements except the first.
+ *
+ * @example
+ * tail([1, 2, 3]) // [2, 3]
+ * tail([1]) // []
+ * tail([]) // []
+ */
+declare function tail<T>(arr: readonly T[]): T[];
+
+/**
+ * Returns all elements except the last.
+ *
+ * @example
+ * init([1, 2, 3]) // [1, 2]
+ * init([1]) // []
+ * init([]) // []
+ */
+declare function init<T>(arr: readonly T[]): T[];
+
+export { chunk, compact, countBy, difference, drop, dropWhile, findLast, first, flatten, groupBy, head, indexBy, init, intersection, last, maxBy, minBy, partition, range, sample, shuffle, sortBy, sumBy, tail, take, takeWhile, unique, unzip, zip };

package/dist/collection/index.d.ts

@@ -0,0 +1,291 @@
+/**
+ * Returns an array with unique values.
+ * Optionally accepts a key function to determine uniqueness.
+ *
+ * @example
+ * unique([1, 2, 2, 3]) // [1, 2, 3]
+ * unique([{ id: 1 }, { id: 1 }, { id: 2 }], item => item.id) // [{ id: 1 }, { id: 2 }]
+ */
+declare function unique<T>(array: readonly T[]): T[];
+declare function unique<T, K>(array: readonly T[], keyFn: (item: T) => K): T[];
+
+/**
+ * Groups array elements by a key function.
+ *
+ * @example
+ * const users = [
+ *   { name: 'Alice', role: 'admin' },
+ *   { name: 'Bob', role: 'user' },
+ *   { name: 'Charlie', role: 'admin' },
+ * ]
+ * groupBy(users, user => user.role)
+ * // { admin: [{ name: 'Alice', ... }, { name: 'Charlie', ... }], user: [{ name: 'Bob', ... }] }
+ */
+declare function groupBy<T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, T[]>;
+
+/**
+ * Creates an object indexed by a key function.
+ * If multiple items have the same key, the last one wins.
+ *
+ * @example
+ * const users = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ * ]
+ * indexBy(users, user => user.id)
+ * // { 1: { id: 1, name: 'Alice' }, 2: { id: 2, name: 'Bob' } }
+ */
+declare function indexBy<T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, T>;
+
+/**
+ * Splits an array into two arrays based on a predicate.
+ * First array contains items that pass, second contains items that fail.
+ *
+ * @example
+ * const [evens, odds] = partition([1, 2, 3, 4], n => n % 2 === 0)
+ * // evens: [2, 4], odds: [1, 3]
+ */
+declare function partition<T>(array: readonly T[], predicate: (item: T) => boolean): [T[], T[]];
+
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * @example
+ * chunk([1, 2, 3, 4, 5], 2)
+ * // [[1, 2], [3, 4], [5]]
+ */
+declare function chunk<T>(array: readonly T[], size: number): T[][];
+
+/**
+ * Removes null and undefined values from an array.
+ * Properly narrows the type.
+ *
+ * @example
+ * compact([1, null, 2, undefined, 3])
+ * // [1, 2, 3] with type number[]
+ */
+declare function compact<T>(array: readonly (T | null | undefined)[]): T[];
+
+/**
+ * Flattens an array one level deep.
+ *
+ * @example
+ * flatten([[1, 2], [3, 4], [5]])
+ * // [1, 2, 3, 4, 5]
+ */
+declare function flatten<T>(array: readonly (T | readonly T[])[]): T[];
+
+/**
+ * Sorts an array by a key function. Returns a new array.
+ *
+ * @example
+ * const users = [{ name: 'Bob' }, { name: 'Alice' }]
+ * sortBy(users, user => user.name)
+ * // [{ name: 'Alice' }, { name: 'Bob' }]
+ */
+declare function sortBy<T>(array: readonly T[], keyFn: (item: T) => string | number, order?: 'asc' | 'desc'): T[];
+
+/**
+ * Returns the first element of an array, or undefined if empty.
+ *
+ * @example
+ * first([1, 2, 3]) // 1
+ * first([]) // undefined
+ */
+declare function first<T>(array: readonly T[]): T | undefined;
+
+/**
+ * Returns the last element of an array, or undefined if empty.
+ *
+ * @example
+ * last([1, 2, 3]) // 3
+ * last([]) // undefined
+ */
+declare function last<T>(array: readonly T[]): T | undefined;
+
+/**
+ * Creates an array of numbers from start to end (exclusive).
+ *
+ * @example
+ * range(0, 5) // [0, 1, 2, 3, 4]
+ * range(1, 10, 2) // [1, 3, 5, 7, 9]
+ */
+declare function range(start: number, end: number, step?: number): number[];
+
+/**
+ * Returns a new array with elements randomly shuffled.
+ * Uses Fisher-Yates algorithm.
+ *
+ * @example
+ * shuffle([1, 2, 3, 4, 5])
+ * // [3, 1, 5, 2, 4] (random order)
+ */
+declare function shuffle<T>(array: readonly T[]): T[];
+
+/**
+ * Returns a random element from an array.
+ *
+ * @example
+ * sample([1, 2, 3, 4, 5]) // random element
+ * sample([]) // undefined
+ */
+declare function sample<T>(array: readonly T[]): T | undefined;
+
+/**
+ * Zips two arrays together into an array of tuples.
+ * Stops at the shorter array.
+ *
+ * @example
+ * zip([1, 2, 3], ['a', 'b', 'c'])
+ * // [[1, 'a'], [2, 'b'], [3, 'c']]
+ */
+declare function zip<A, B>(a: readonly A[], b: readonly B[]): [A, B][];
+
+/**
+ * Unzips an array of tuples into two arrays.
+ *
+ * @example
+ * unzip([[1, 'a'], [2, 'b'], [3, 'c']])
+ * // [[1, 2, 3], ['a', 'b', 'c']]
+ */
+declare function unzip<A, B>(array: readonly (readonly [A, B])[]): [A[], B[]];
+
+/**
+ * Returns elements in the first array that are not in the second.
+ *
+ * @example
+ * difference([1, 2, 3, 4], [2, 4])
+ * // [1, 3]
+ */
+declare function difference<T>(a: readonly T[], b: readonly T[]): T[];
+
+/**
+ * Returns elements that exist in both arrays.
+ *
+ * @example
+ * intersection([1, 2, 3], [2, 3, 4])
+ * // [2, 3]
+ */
+declare function intersection<T>(a: readonly T[], b: readonly T[]): T[];
+
+/**
+ * Returns the first n elements of an array.
+ *
+ * @example
+ * take([1, 2, 3, 4, 5], 3) // [1, 2, 3]
+ * take([1, 2], 5) // [1, 2]
+ */
+declare function take<T>(arr: readonly T[], n: number): T[];
+
+/**
+ * Returns all but the first n elements of an array.
+ *
+ * @example
+ * drop([1, 2, 3, 4, 5], 2) // [3, 4, 5]
+ * drop([1, 2], 5) // []
+ */
+declare function drop<T>(arr: readonly T[], n: number): T[];
+
+/**
+ * Returns elements from the beginning of an array while the predicate returns true.
+ *
+ * @example
+ * takeWhile([1, 2, 3, 4, 1], n => n < 3) // [1, 2]
+ * takeWhile([5, 1, 2], n => n < 3) // []
+ */
+declare function takeWhile<T>(arr: readonly T[], predicate: (item: T, index: number) => boolean): T[];
+
+/**
+ * Drops elements from the beginning of an array while the predicate returns true.
+ *
+ * @example
+ * dropWhile([1, 2, 3, 4, 1], n => n < 3) // [3, 4, 1]
+ * dropWhile([5, 1, 2], n => n < 3) // [5, 1, 2]
+ */
+declare function dropWhile<T>(arr: readonly T[], predicate: (item: T, index: number) => boolean): T[];
+
+/**
+ * Returns the last element in an array that satisfies the predicate.
+ *
+ * @example
+ * findLast([1, 2, 3, 4], n => n % 2 === 0) // 4
+ * findLast([1, 3, 5], n => n % 2 === 0) // undefined
+ */
+declare function findLast<T>(arr: readonly T[], predicate: (item: T, index: number) => boolean): T | undefined;
+
+/**
+ * Creates an object counting occurrences of each key returned by the function.
+ *
+ * @example
+ * countBy([1, 2, 3, 4, 5], n => n % 2 === 0 ? 'even' : 'odd')
+ * // { odd: 3, even: 2 }
+ *
+ * countBy(['one', 'two', 'three'], s => s.length)
+ * // { 3: 2, 5: 1 }
+ */
+declare function countBy<T>(arr: readonly T[], fn: (item: T) => PropertyKey): Record<PropertyKey, number>;
+
+/**
+ * Returns the element with the maximum value according to the function.
+ *
+ * @example
+ * maxBy([{ age: 20 }, { age: 30 }, { age: 25 }], u => u.age)
+ * // { age: 30 }
+ *
+ * maxBy([], u => u.age) // undefined
+ */
+declare function maxBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined;
+
+/**
+ * Returns the element with the minimum value according to the function.
+ *
+ * @example
+ * minBy([{ age: 20 }, { age: 30 }, { age: 25 }], u => u.age)
+ * // { age: 20 }
+ *
+ * minBy([], u => u.age) // undefined
+ */
+declare function minBy<T>(arr: readonly T[], fn: (item: T) => number): T | undefined;
+
+/**
+ * Sums the values returned by the function for each element.
+ *
+ * @example
+ * sumBy([{ price: 10 }, { price: 20 }, { price: 30 }], item => item.price)
+ * // 60
+ *
+ * sumBy([], item => item.price) // 0
+ */
+declare function sumBy<T>(arr: readonly T[], fn: (item: T) => number): number;
+
+/**
+ * Returns the first element of an array, or undefined if empty.
+ * Alias for first().
+ *
+ * @example
+ * head([1, 2, 3]) // 1
+ * head([]) // undefined
+ */
+declare function head<T>(arr: readonly T[]): T | undefined;
+
+/**
+ * Returns all elements except the first.
+ *
+ * @example
+ * tail([1, 2, 3]) // [2, 3]
+ * tail([1]) // []
+ * tail([]) // []
+ */
+declare function tail<T>(arr: readonly T[]): T[];
+
+/**
+ * Returns all elements except the last.
+ *
+ * @example
+ * init([1, 2, 3]) // [1, 2]
+ * init([1]) // []
+ * init([]) // []
+ */
+declare function init<T>(arr: readonly T[]): T[];
+
+export { chunk, compact, countBy, difference, drop, dropWhile, findLast, first, flatten, groupBy, head, indexBy, init, intersection, last, maxBy, minBy, partition, range, sample, shuffle, sortBy, sumBy, tail, take, takeWhile, unique, unzip, zip };