{"version":3,"sources":["../src/functions/assert/assert.ts","../src/functions/capitalize/capitalize.ts","../src/functions/isArray/isArray.ts","../src/functions/castArray/castArrayIfDefined.ts","../src/functions/castArray/castArray.ts","../src/functions/chunk/chunk.ts","../src/functions/compact/compact.ts","../src/functions/constantCase/constantCase.ts","../src/functions/createKnownTypeGuard/createKnownTypeGuard.ts","../src/functions/ensurePrefix/ensurePrefix.ts","../src/functions/ensureSuffix/ensureSuffix.ts","../src/functions/hasKey/hasKey.ts","../src/functions/get/get.ts","../src/functions/groupBy/groupBy.ts","../src/functions/identity/identity.ts","../src/functions/intersection/intersection.ts","../src/functions/invert/invert.ts","../src/functions/isEmpty/isEmpty.ts","../src/functions/isNonNullable/isNonNullable.ts","../src/functions/join/join.ts","../src/functions/keyBy/keyBy.ts","../src/functions/objectEntries/objectEntries.ts","../src/functions/objectFromEntries/objectFromEntries.ts","../src/functions/mapValues/mapValues.ts","../src/functions/max/max.ts","../src/functions/memoize/memoize.ts","../src/functions/min/min.ts","../src/functions/negate/negate.ts","../src/functions/noop/noop.ts","../src/functions/objectKeys/objectKeys.ts","../src/functions/omit/omit.ts","../src/functions/partition/partition.ts","../src/functions/pick/pick.ts","../src/functions/pipe/pipe.ts","../src/functions/range/range.ts","../src/functions/sum/sum.ts","../src/functions/take/take.ts","../src/functions/toObject/toObject.ts","../src/functions/unique/unique.ts","../src/functions/uniqueId/uniqueId.ts","../src/functions/without/without.ts","../src/functions/zip/zip.ts"],"names":["createPropertiesPredicate"],"mappings":"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","sourcesContent":["/**\n * Asserts that a condition is true, throwing an Error if it is not.\n *\n * @param condition A condition that should be true\n * @param message A message to use in the Error that will be thrown if the condition is falsy\n */\nexport function assert(\n  condition?: unknown,\n  message?: string\n): asserts condition {\n  if (arguments.length === 0) {\n    return;\n  }\n\n  if (!condition) {\n    throw new AssertionError(message);\n  }\n}\n\nexport class AssertionError extends Error {\n  constructor(message?: string) {\n    super(`Assertion not satisfied: ${message ? `: \"${message}\"` : ''}`);\n  }\n}\n","/**\n * Capitalize the first letter of a string.\n */\nexport function capitalize<S extends string>(string: S): Capitalize<S> {\n  return `${string.charAt(0).toUpperCase()}${string.slice(1)}` as Capitalize<S>;\n}\n","import { Many } from '../../types';\n\n/**\n * The same as `Array.isArray` but with a better type guard.\n */\n// eslint-disable-next-line prefer-destructuring\nexport const isArray: IsArray = Array.isArray;\n\ninterface IsArray {\n  <T>(value: Many<T>): value is readonly T[];\n  <T>(value: unknown): value is readonly T[];\n}\n","import { Many, Maybe } from '../../types';\nimport { isArray } from '../isArray';\n\n/**\n * Converts the given value to an array if it's not already one, or returns an value as-is if it's not defined (i.e. `null` or `undefined`).\n * @note If the value is already an array, it is returned as-is (same reference).\n *\n * @example\n * ```ts\n * // Returns `[1, 2, 3]`\n * castArrayIfDefined([1, 2, 3])\n *\n * // Returns `[42]`\n * castArrayIfDefined(42)\n *\n * // Returns `null`\n * castArrayIfDefined(null)\n *\n * // Returns `undefined`\n * castArrayIfDefined(undefined)\n * ```\n */\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function castArrayIfDefined<T>(value: null): null;\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function castArrayIfDefined<T>(value: undefined): undefined;\nexport function castArrayIfDefined<T>(value: readonly T[]): readonly T[];\nexport function castArrayIfDefined<T>(value: T[]): T[];\nexport function castArrayIfDefined<T>(value: NonNullable<T>): T[];\nexport function castArrayIfDefined<T>(\n  value: Maybe<\n    Many<NonNullable<T>, 'mutable'> | Many<NonNullable<T>, 'immutable'>\n  >\n) {\n  if (value == null) {\n    return value;\n  }\n\n  if (isArray(value)) {\n    return value;\n  }\n\n  return [value];\n}\n","import { Many, Maybe } from '../../types';\n\nimport { castArrayIfDefined } from './castArrayIfDefined';\n\nexport function castArray<T>(value: null): T[];\nexport function castArray<T>(value: undefined): T[];\nexport function castArray<T>(value: readonly T[]): readonly T[];\nexport function castArray<T>(value: T[]): T[];\nexport function castArray<T>(value: NonNullable<T>): T[];\nexport function castArray<T>(\n  value: Maybe<\n    Many<NonNullable<T>, 'mutable'> | Many<NonNullable<T>, 'immutable'>\n  >\n) {\n  return castArrayIfDefined(value ?? []);\n}\n","import { Maybe } from '../../types';\n\n/**\n * Splits an array into chunks of the given size.\n *\n * @param array The array to split.\n * @param size The maximum size of each chunk.\n *\n * @returns An array of arrays where each sub-array has at most `size` elements.\n */\nexport function chunk<T>(array: Maybe<readonly T[]>, size: number): T[][] {\n  if (array == null) {\n    return [];\n  }\n\n  const chunks = [];\n  for (let index = 0; index < array.length; index += size) {\n    chunks.push(array.slice(index, index + size));\n  }\n\n  return chunks;\n}\n\n/**\n * Alias for {@link chunk}.\n */\nexport const chunkArray = chunk;\n","import { Maybe } from '../../types';\n\n/**\n * Creates an array with all falsey values removed.\n * The values `false`, `null`, `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n * @param array The array to compact.\n * @returns The new array of filtered values.\n */\nexport function compact<T>(array: Maybe<readonly T[]>): T[] {\n  return array?.filter(Boolean) ?? [];\n}\n","/**\n * Changes the casing of a string to constant case.\n * e.g. `\"fooBar\"` -> `\"FOO_BAR\"` or `\"foo bar\"` -> `\"FOO_BAR\"` or `\"foo-bar\"` -> `\"FOO_BAR\"`\n */\nexport function constantCase<S extends string>(string: S): ConstantCase<S> {\n  if (!/[a-z]+/i.test(string)) {\n    return '' as ConstantCase<S>;\n  }\n\n  // return string.replace(/[\\W_]+/g, '_').toUpperCase() as ConstantCase<S>;\n  return string\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s-]+/g, '_')\n    .toUpperCase() as ConstantCase<S>;\n}\n\nexport type ConstantCase<S extends string> = Uppercase<\n  S extends `${infer S1}${infer S2}`\n    ? `${S1 extends '-'\n        ? '_'\n        : S1 extends ' '\n        ? '_'\n        : S1 extends '_'\n        ? '_'\n        : S1 extends Capitalize<S1>\n        ? `_${Lowercase<S1>}`\n        : S1}${ConstantCase<S2>}`\n    : S\n>;\n","/**\n * Creates a type guard that checks if the given type is assignable to the given type.\n *\n * @param values The values to check against.\n * @template {TCheckedValue} The type to check against, `unknown` by default. Pass in if you want to have a narrowed type for the type predicate (e.g. `string`).\n * @returns A type guard that checks if the given type is assignable to the given type.\n *\n * @example\n * ```ts\n * const VALID_VALUES = ['foo', 'bar'] as const;\n * const isValidValue = createKnownTypeGuard(VALID_VALUES);\n *\n * const value: unknown = '...';\n * if (isValidValue(value)) {\n *   // ✅ value is of type `'foo' | 'bar'`\n * }\n * ```\n */\nexport function createKnownTypeGuard<\n  TValue,\n  TCheckedValue extends TValue | unknown = unknown\n>(values: Iterable<TValue>) {\n  const setValues = new Set<unknown>(values);\n  return function guardFunction(v: TCheckedValue): v is TCheckedValue & TValue {\n    return setValues.has(v);\n  };\n}\n","/**\n * Ensures that the string starts with the given prefix.\n *\n * @example\n * ```ts\n * ensurePrefix('foo', 'bar'); // 'barfoo'\n * ensurePrefix('foobar', 'foo'); // 'foobar'\n * ```\n */\nexport function ensurePrefix<S extends string, Prefix extends string>(\n  string: S,\n  prefix: Prefix\n): EnsurePrefix<S, Prefix> {\n  if (string.startsWith(prefix)) {\n    return string as EnsurePrefix<S, Prefix>;\n  }\n\n  return `${prefix}${string}` as EnsurePrefix<S, Prefix>;\n}\n\ntype EnsurePrefix<\n  S extends string,\n  Prefix extends string\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n> = S extends `${Prefix}${infer _Suffix}` ? S : `${Prefix}${S}`;\n","/**\n * Ensures that the string ends with the given suffix.\n *\n * @example\n * ```ts\n * ensureSuffix('foo', 'bar'); // 'foobar'\n * ensureSuffix('foobar', 'bar'); // 'foobar'\n * ```\n */\nexport function ensureSuffix<S extends string, Suffix extends string>(\n  string: S,\n  suffix: Suffix\n): EnsureSuffix<S, Suffix> {\n  if (string.endsWith(suffix)) {\n    return string as EnsureSuffix<S, Suffix>;\n  }\n\n  return `${string}${suffix}` as EnsureSuffix<S, Suffix>;\n}\n\ntype EnsureSuffix<\n  S extends string,\n  Suffix extends string\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n> = S extends `${infer _Prefix}${Suffix}` ? S : `${S}${Suffix}`;\n","import { KeysOfUnion, StringWithAutocomplete } from '../../types';\n\nexport function hasKey<\n  T extends object,\n  K extends StringWithAutocomplete<KeysOfUnion<T> & string> | PropertyKey\n>(value: T, key: K): value is T & Record<K, unknown> {\n  if (typeof value !== 'object' || value == null) {\n    return false;\n  }\n\n  return key in value;\n}\n","import type { Get } from 'type-fest';\n\nimport { Many } from '../../types';\nimport { hasKey } from '../hasKey';\nimport { isArray } from '../isArray';\n\n/**\n * Gets the value at path of object.\n *\n * Allows accessing properties in unions of objects and getting undefined if the property is not present.\n */\nexport function get<T, Path extends Many<string>>(\n  object: T,\n  path: Path\n): Get<T, Path> {\n  const keys: readonly string[] = isArray(path) ? path : path.split('.');\n\n  return keys.reduce<unknown>((value, key) => {\n    if (hasKey(value as object, key)) {\n      return (value as Record<typeof key, unknown>)[key];\n    }\n\n    // eslint-disable-next-line unicorn/no-useless-undefined -- default value, explicitly declare it\n    return undefined;\n  }, object as object) as Get<T, Path>;\n}\n","import { Maybe } from '../../types';\n\n/**\n * Takes an array and returns an object with the keys of the array\n * mapped to the items of the array\n */\nexport function groupBy<T, K extends string>(\n  array: Maybe<readonly T[]>,\n  getter: (item: T) => K\n) {\n  return (array ?? []).reduce((draftGroups, currentItem) => {\n    const key = getter(currentItem);\n\n    // eslint-disable-next-line no-param-reassign\n    draftGroups[key] ??= [];\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    draftGroups[key]!.push(currentItem);\n\n    return draftGroups;\n  }, {} as Partial<Record<K, T[]>>);\n}\n","export function identity<T>(value: T): T {\n  return value;\n}\n","import { createKnownTypeGuard } from '../createKnownTypeGuard';\n\n/**\n * Gets the intersection between two arrays.\n */\nexport function intersection<T, S extends T>(\n  array1: readonly T[],\n  array2: readonly S[]\n): (T & S)[] {\n  const isArray2Item = createKnownTypeGuard(array2);\n  return array1.filter((value) => isArray2Item(value)) as (T & S)[];\n}\n","export function invert<T extends Record<PropertyKey, PropertyKey>>(\n  object: T\n): Inverted<T> {\n  return Object.fromEntries(\n    Object.entries(object).map(([key, value]) => [value, key])\n  ) as Inverted<T>;\n}\n\ntype Inverted<T extends Record<PropertyKey, PropertyKey>> = {\n  [K in keyof T as T[K]]: K;\n};\n","import { EmptyObject, Maybe } from '../../types';\nimport { isArray } from '../isArray';\n\nexport function isEmpty(value: string): value is '';\nexport function isEmpty(value: number): value is number;\nexport function isEmpty(\n  value: Maybe<ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>>\n): boolean;\nexport function isEmpty<T extends ReadonlyArray<unknown> | EmptyArray>(\n  value: Maybe<T>\n): value is Maybe<T & EmptyArray>;\nexport function isEmpty<T extends object>(\n  value: Maybe<EmptyObject<T> | T>\n): value is T & Record<string, never>;\nexport function isEmpty<T>(value: Maybe<T>): boolean;\nexport function isEmpty<T>(value: Maybe<T>): boolean {\n  if (value == null) {\n    return true;\n  }\n\n  if (isArray(value) || typeof value === 'string') {\n    return value.length === 0;\n  }\n\n  if (value instanceof Map || value instanceof Set) {\n    return value.size === 0;\n  }\n\n  if (typeof value === 'number') {\n    return !value;\n  }\n\n  if (typeof value === 'object') {\n    return Object.keys(value).length === 0;\n  }\n\n  return false;\n}\n\ntype EmptyArray = [];\n","/**\n * Checks if a value is not null or undefined.\n *\n * @param value The value to inspect.\n * @returns Returns `true` if the value is NOT `null` or `undefined`, or `false` otherwise.\n */\nexport function isNonNullable<T>(value: T): value is NonNullable<T> {\n  return value != null;\n}\n","import { NonFunction } from '../../types/internal';\n\n/**\n * Same as `Array.prototype.join`, but allows specifying a non-`string` separator.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- only used as generic constraints\nexport function join<T extends NonFunction<any>, U extends NonFunction<any>>(\n  elements: ReadonlyArray<NonNullable<T>>,\n  separator: U | ((index: number) => U)\n) {\n  const emptySeparator = Symbol('emptySeparator');\n\n  const separatorFunction =\n    typeof separator === 'function'\n      ? (separator as (index: number) => NonNullable<U>)\n      : () => separator;\n\n  return elements\n    .flatMap((element, index, array) => [\n      element,\n      index < array.length - 1 ? separatorFunction(index) : emptySeparator,\n    ])\n    .filter((item) => item !== emptySeparator);\n}\n","/**\n * Same as Lodash's `keyBy` by more type-safe.\n */\nexport function keyBy<T, K extends string>(\n  array: readonly T[],\n  keyGetter: (item: T) => K\n): Partial<Record<K, T>> {\n  return array.reduce((draftObject, currentItem) => {\n    const key = keyGetter(currentItem);\n\n    // eslint-disable-next-line no-param-reassign\n    draftObject[key] = currentItem;\n\n    return draftObject;\n  }, {} as Partial<Record<K, T>>);\n}\n","export const objectEntries: ObjetEntries = Object.entries;\n\ninterface ObjetEntries {\n  <T extends object>(object: T): [keyof T, T[keyof T]][];\n}\n","export const objectFromEntries: ObjectFromEntries = Object.fromEntries;\n\ninterface ObjectFromEntries {\n  <K extends PropertyKey, V>(entries: Iterable<readonly [K, V]>): Record<K, V>;\n}\n","import { objectEntries } from '../objectEntries';\nimport { objectFromEntries } from '../objectFromEntries';\n\nexport function mapValues<T extends object, V>(\n  object: T,\n  mapperFunction: (value: T[keyof T], key: keyof T) => V\n): Record<keyof T, V> {\n  return objectFromEntries(\n    objectEntries(object).map(([key, value]) => [\n      key,\n      mapperFunction(value, key),\n    ])\n  );\n}\n","import { Maybe } from '../../types';\n\n/**\n * Computes the maximum value of array. If array is empty or nil, `undefined` is returned.\n */\nexport function max(array: readonly number[]): number;\nexport function max(array: Maybe<readonly number[]>): number | undefined;\nexport function max<T>(\n  array: Maybe<readonly T[]>,\n  valueExtractor: (value: T) => number\n): number;\nexport function max<T>(\n  array: Maybe<readonly T[]>,\n  valueExtractor: (value: T) => number = (value) => value as unknown as number\n): number | undefined {\n  if (array == null || array.length === 0) {\n    return undefined;\n  }\n\n  return Math.max(...array.map((element) => valueExtractor(element)));\n}\n","import { AnyFunction } from '../../types/internal';\n\nexport function memoize<TFunction extends AnyFunction>(\n  // eslint-disable-next-line unicorn/prevent-abbreviations -- `function` is a reserved word\n  fn: TFunction,\n  cacheKeyResolver?: (...args: Parameters<TFunction>) => string\n): TFunction {\n  const cache = new Map<string, ReturnType<TFunction>>();\n\n  return function memoizedFunction(...args: Parameters<TFunction>) {\n    const cacheKey = cacheKeyResolver ? cacheKeyResolver(...args) : args[0];\n\n    if (cache.has(cacheKey)) {\n      return cache.get(cacheKey);\n    }\n\n    const result = fn(...args);\n    cache.set(cacheKey, result);\n\n    return result;\n  } as TFunction;\n}\n","import { Maybe } from '../../types';\n\n/**\n * Computes the minimum value of array. If array is empty or nil, `undefined` is returned.\n */\nexport function min(array: readonly number[]): number;\nexport function min(array: Maybe<readonly number[]>): number | undefined;\nexport function min<T>(\n  array: Maybe<readonly T[]>,\n  valueExtractor: (value: T) => number\n): number;\nexport function min<T>(\n  array: Maybe<readonly T[]>,\n  valueExtractor: (value: T) => number = (value) => value as unknown as number\n): number | undefined {\n  if (array == null || array.length === 0) {\n    return undefined;\n  }\n\n  return Math.min(...array.map((element) => valueExtractor(element)));\n}\n","// eslint-disable-next-line @typescript-eslint/no-explicit-any -- we need to allow any function arguments\nexport function negate<T extends (...args: any[]) => boolean>(func: T) {\n  return (...args: Parameters<T>) => {\n    const result = func(...args);\n    return !result;\n  };\n}\n","/**\n * A no-operation function that returns `undefined` for any input.\n */\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- this is the whole point of the function\nexport function noop(...args: readonly unknown[]): void {}\n","import { StringKeyOf } from 'type-fest';\n\nimport { AnyFunction } from '../../types/internal';\n\nexport const objectKeys: ObjectKeys = Object.keys;\n\ninterface ObjectKeys {\n  <T extends object>(object: Exclude<T, AnyFunction>): StringKeyOf<T>[];\n}\n","import { KeysOfUnion, Many, Maybe, PropertyValueOfUnion } from '../../types';\nimport { castArray } from '../castArray';\nimport { createKnownTypeGuard } from '../createKnownTypeGuard';\nimport { objectEntries } from '../objectEntries';\nimport { objectFromEntries } from '../objectFromEntries';\n\nexport function omit<\n  T extends object,\n  const K extends keyof T | KeysOfUnion<T>\n>(object: Maybe<T>, properties: Many<K>): Omit<T, K>;\nexport function omit<T extends object>(\n  object: Maybe<T>,\n  predicate: ObjectPredicate<T>\n): Partial<T>;\nexport function omit<\n  T extends object,\n  const K extends keyof T | KeysOfUnion<T>\n>(object: T, propertiesOrPredicate: Many<K> | ObjectPredicate<T>) {\n  if (object == null) {\n    return {} as Omit<T, K>;\n  }\n\n  const predicate: ObjectPredicate<T> =\n    typeof propertiesOrPredicate === 'function'\n      ? propertiesOrPredicate\n      : createPropertiesPredicate(propertiesOrPredicate);\n\n  return objectFromEntries(\n    objectEntries(object).filter(([key, value]) => {\n      const shouldOmit = predicate(\n        // this is fine, `undefined` is the technical result of a key not existing on another union member.\n        // i.e. if we'd access `obj[key]` and `key` is not a key of `obj`, we'd get `undefined`.\n        // this is not the case while looping over an object, so we're fine and can safely cast.\n        value as Exclude<PropertyValueOfUnion<T, KeysOfUnion<T>>, undefined>,\n        key as KeysOfUnion<T>,\n        object\n      );\n\n      return !shouldOmit;\n    })\n  );\n}\n\nfunction createPropertiesPredicate<\n  T extends object,\n  const K extends keyof T | KeysOfUnion<T>\n>(properties: Many<K>): ObjectPredicate<T> {\n  const isKnownProperty = createKnownTypeGuard(castArray(properties));\n\n  return (_value, key) => isKnownProperty(key);\n}\n\ntype ObjectPredicate<T extends object> = (\n  value: Exclude<PropertyValueOfUnion<T, KeysOfUnion<T>>, undefined>,\n  key: KeysOfUnion<T>,\n  object: T\n) => boolean;\n","import { Maybe } from '../../types';\n\nexport function partition<T, S extends T>(\n  array: Maybe<readonly T[]>,\n  predicate: (item: T) => item is S\n): readonly [equals: S[], notEquals: Exclude<T, S>[]];\nexport function partition<T>(\n  array: Maybe<readonly T[]>,\n  predicate: (item: T) => boolean\n): readonly [equals: T[], notEquals: T[]];\nexport function partition<T, S extends T>(\n  array: Maybe<readonly T[]>,\n  predicate: ((item: T) => item is S) | ((item: T) => boolean)\n): readonly [S[], Exclude<T, S>[]] {\n  if (array == null) {\n    return [[], []];\n  }\n\n  const equals: S[] = [];\n  const notEquals: Exclude<T, S>[] = [];\n\n  for (const item of array) {\n    if (predicate(item)) {\n      equals.push(item);\n    } else {\n      notEquals.push(item as Exclude<T, S>);\n    }\n  }\n\n  return [equals, notEquals];\n}\n","import { KeysOfUnion, Many, Maybe } from '../../types';\nimport { castArray } from '../castArray';\nimport { createKnownTypeGuard } from '../createKnownTypeGuard';\nimport { objectEntries } from '../objectEntries';\n\nexport function pick<\n  T extends object,\n  const K extends keyof T | KeysOfUnion<T>\n>(object: Maybe<T>, properties: Many<K>): Pick<T, K>;\nexport function pick<T extends object>(\n  object: Maybe<T>,\n  predicate: ObjectPredicate<T>\n): Partial<T>;\nexport function pick<\n  T extends object,\n  const K extends keyof T | KeysOfUnion<T>\n>(object: Maybe<T>, propertiesOrPredicate: Many<K> | ObjectPredicate<T>) {\n  if (object == null) {\n    return {} as Pick<T, K>;\n  }\n\n  const predicate: ObjectPredicate<T> =\n    typeof propertiesOrPredicate === 'function'\n      ? propertiesOrPredicate\n      : createPropertiesPredicate(propertiesOrPredicate);\n\n  return Object.fromEntries(\n    objectEntries(object).filter(([key, value]) =>\n      predicate(value, key, object)\n    )\n  );\n}\n\nfunction createPropertiesPredicate<\n  T extends object,\n  const K extends keyof T | KeysOfUnion<T>\n>(properties: Many<K>): ObjectPredicate<T> {\n  const isKnownProperty = createKnownTypeGuard(castArray(properties));\n\n  return (_value, key) => isKnownProperty(key);\n}\n\ntype ObjectPredicate<T extends object> = <K extends keyof T>(\n  value: T[K],\n  key: K,\n  object: T\n) => boolean;\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable unicorn/prevent-abbreviations */\nimport { Func } from './types/Func';\nimport { UnaryFunction } from './types/UnaryFunction';\n\n/**\n * Type-enforcing left-to-right function composition function.\n * The first parameter can be a function of any arity, but the remaining parameters must be unary functions.\n * The return type of one function must be compatible with the argument of next function in the argument list\n *\n * @note The types here are only inferred for the first 20 functions.\n * If you need more, you have to type the functions explicitly.\n * please open an issue, but this should be enough to cover most use cases.\n *\n * @returns A function with the arguments of the *first* function in the argument list and a return type of the *last* function in the argument list\n */\nexport function pipe<TIn extends unknown[], TOut>(\n  f0: Func<TIn, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, T2, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, T2, T3, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, T2, T3, T4, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, T2, T3, T4, T5, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, T2, T3, T4, T5, T6, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], T1, T2, T3, T4, T5, T6, T7, TOut>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  T15,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, T15>,\n  f15: UnaryFunction<T15, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  T15,\n  T16,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, T15>,\n  f15: UnaryFunction<T15, T16>,\n  f16: UnaryFunction<T16, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  T15,\n  T16,\n  T17,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, T15>,\n  f15: UnaryFunction<T15, T16>,\n  f16: UnaryFunction<T16, T17>,\n  f17: UnaryFunction<T17, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  T15,\n  T16,\n  T17,\n  T18,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, T15>,\n  f15: UnaryFunction<T15, T16>,\n  f16: UnaryFunction<T16, T17>,\n  f17: UnaryFunction<T17, T18>,\n  f18: UnaryFunction<T18, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  T15,\n  T16,\n  T17,\n  T18,\n  T19,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, T15>,\n  f15: UnaryFunction<T15, T16>,\n  f16: UnaryFunction<T16, T17>,\n  f17: UnaryFunction<T17, T18>,\n  f18: UnaryFunction<T18, T19>,\n  f19: UnaryFunction<T19, TOut>\n): Func<TIn, TOut>;\nexport function pipe<\n  TIn extends unknown[],\n  T1,\n  T2,\n  T3,\n  T4,\n  T5,\n  T6,\n  T7,\n  T8,\n  T9,\n  T10,\n  T11,\n  T12,\n  T13,\n  T14,\n  T15,\n  T16,\n  T17,\n  T18,\n  T19,\n  T20,\n  TOut\n>(\n  f0: Func<TIn, T1>,\n  f1: UnaryFunction<T1, T2>,\n  f2: UnaryFunction<T2, T3>,\n  f3: UnaryFunction<T3, T4>,\n  f4: UnaryFunction<T4, T5>,\n  f5: UnaryFunction<T5, T6>,\n  f6: UnaryFunction<T6, T7>,\n  f7: UnaryFunction<T7, T8>,\n  f8: UnaryFunction<T8, T9>,\n  f9: UnaryFunction<T9, T10>,\n  f10: UnaryFunction<T10, T11>,\n  f11: UnaryFunction<T11, T12>,\n  f12: UnaryFunction<T12, T13>,\n  f13: UnaryFunction<T13, T14>,\n  f14: UnaryFunction<T14, T15>,\n  f15: UnaryFunction<T15, T16>,\n  f16: UnaryFunction<T16, T17>,\n  f17: UnaryFunction<T17, T18>,\n  f18: UnaryFunction<T18, T19>,\n  f19: UnaryFunction<T19, T20>,\n  f20: UnaryFunction<T20, TOut>\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], TOut>(\n  o1: Func<TIn, any>,\n  ...operations: UnaryFunction<any, any>[]\n): Func<TIn, TOut>;\nexport function pipe<TIn extends unknown[], TOut>(\n  o1: Func<TIn, any>,\n  ...operations: UnaryFunction<any, any>[]\n): Func<TIn, TOut> {\n  return (...argsP: TIn) => operations.reduce((acc, f) => f(acc), o1(...argsP));\n}\n","export function range(end: number): number[];\nexport function range(start: number, end: number, step?: number): number[];\nexport function range(startOrEnd: number, end?: number, step = 1): number[] {\n  if (step <= 0) {\n    return [];\n  }\n\n  const calculatedStart = end == null ? 0 : startOrEnd;\n  const calculatedEnd = end == null ? startOrEnd : end;\n\n  const result = [];\n\n  for (let index = calculatedStart; index < calculatedEnd; index += step) {\n    result.push(index);\n  }\n\n  return result;\n}\n","import { Maybe } from '../../types';\n\nexport function sum(array: Maybe<readonly number[]>): number;\nexport function sum<T>(\n  array: Maybe<readonly T[]>,\n  mapper: ArrayIterator<T>\n): number;\nexport function sum<T>(\n  array: Maybe<readonly T[]>,\n  mapper?: ArrayIterator<T>\n): number {\n  if (array == null) {\n    return 0;\n  }\n\n  const numbers = array.map<number>((value, index, array_) => {\n    const result =\n      mapper?.(value, index, array_) ??\n      // if there's no iteratee, we're in the overload of `sum` that only takes an array of numbers\n      (value as number);\n    return result;\n  });\n\n  return numbers.reduce((draft, value) => draft + value, 0);\n}\n\ntype ArrayIterator<T> = (\n  value: T,\n  index: number,\n  array: readonly T[]\n) => number;\n","import { Maybe } from '../../types';\n\nexport function take<T>(array: Maybe<readonly T[]>, count: number): T[] {\n  if (count <= 0) {\n    return [];\n  }\n\n  return array?.slice(0, count) ?? [];\n}\n","import { objectFromEntries } from '../objectFromEntries';\n\n/**\n * Converts an array of strings to an object with the same values as keys and values.\n * @example\n * ```ts\n * toObject(['a', 'b']) // { a: 'a', b: 'b' }\n * ```\n */\nexport function toObject<T extends string>(array: readonly T[]) {\n  return objectFromEntries(array.map((value) => [value, value]));\n}\n","import { Maybe } from '../../types';\n\nexport function unique<T>(\n  iterable: Maybe<Iterable<T>>,\n  comparator: Comparator<T> = defaultComparator\n): T[] {\n  if (comparator === defaultComparator) {\n    // we can get a performance boost for the default case, which is probably the most common.\n    return [...new Set(iterable)];\n  }\n\n  const result: T[] = [];\n\n  for (const value of iterable ?? []) {\n    if (!result.some((other) => comparator(value, other))) {\n      result.push(value);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Checks if two values are equal.\n */\ntype Comparator<T> = (a: T, b: T) => boolean;\n\nconst defaultComparator: Comparator<unknown> = Object.is;\n","/**\n * Generates a unique identifier.\n *\n * If a `prefix` is provided, the resulting identifier will start with the prefix.\n *\n * @param prefix - An optional prefix for the identifier.\n * @returns A unique identifier.\n */\nexport function uniqueId<Prefix extends string>(\n  prefix: Prefix\n): `${Prefix}${string}`;\nexport function uniqueId(prefix?: string): string;\nexport function uniqueId(prefix = '') {\n  const suffix = generateUUID();\n  return `${prefix}${suffix}`;\n}\n\nfunction generateUUID() {\n  if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {\n    return crypto.randomUUID();\n  }\n\n  return pseudoRandomUUID();\n}\n\nfunction pseudoRandomUUID(): string {\n  const random = Math.random();\n  return random.toString(36).slice(2, 11);\n}\n","import { createKnownTypeGuard } from '../createKnownTypeGuard';\n\n/**\n * Gets the difference between two arrays.\n */\nexport function without<T, const S extends T>(\n  array: readonly T[],\n  itemsToExclude: Iterable<S>\n): Exclude<T, S>[] {\n  const isItemToExclude = createKnownTypeGuard(itemsToExclude);\n  return array.filter((item): item is Exclude<T, S> => !isItemToExclude(item));\n}\n","export function zip<T, U>(first: readonly T[], second: readonly U[]): [T, U][] {\n  const result: [T, U][] = [];\n\n  for (let index = 0; index < Math.min(first.length, second.length); index++) {\n    result.push([first[index], second[index]]);\n  }\n\n  return result;\n}\n"]}