typedash/dist/index.cjs.map

modern, type-safe collection of utility functions

{"version":3,"sources":["../src/functions/compact/compact.ts","../src/functions/assert/assert.ts","../src/functions/assertNever/assertNever.ts","../src/functions/capitalize/capitalize.ts","../src/functions/camelCase/camelCase.ts","../src/functions/isArray/isArray.ts","../src/functions/castArrayIfDefined/castArrayIfDefined.ts","../src/functions/castArray/castArray.ts","../src/functions/chunk/chunk.ts","../src/functions/clamp/clamp.ts","../src/functions/constantCase/constantCase.ts","../src/functions/_internal/filterIterable/filterIterable.ts","../src/functions/count/count.ts","../src/functions/createTypeGuard/createTypeGuard.ts","../src/functions/debounce/debounce.ts","../src/functions/negate/negate.ts","../src/functions/difference/difference.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/inRange/inRange.ts","../src/functions/intersection/intersection.ts","../src/functions/invert/invert.ts","../src/functions/isEmpty/isEmpty.ts","../src/functions/zip/zip.ts","../src/functions/isEqual/_internal/array/areArraysEqual.ts","../src/functions/isEqual/_internal/createIsCircularTypeEqualityComparator.ts","../src/functions/isEqual/_internal/date/areDatesEqual.ts","../src/functions/isEqual/_internal/date/dateTag.ts","../src/functions/isEqual/_internal/map/areMapsEqual.ts","../src/functions/isEqual/_internal/react/reactOwnerPropertyName.ts","../src/functions/isEqual/_internal/object/getObjectProperties.ts","../src/functions/isEqual/_internal/object/areObjectsEqual.ts","../src/functions/isEqual/_internal/primitiveWrappers/arePrimitiveWrappersEqual.ts","../src/functions/isEqual/_internal/regExp/areRegExpsEqual.ts","../src/functions/isEqual/_internal/regExp/regExpTag.ts","../src/functions/isEqual/_internal/set/areSetsEqual.ts","../src/functions/isEqual/_internal/set/setTag.ts","../src/functions/isEqual/_internal/typedArray/areTypedArraysEqual.ts","../src/functions/isEqual/_internal/typedArray/isTypedArray.ts","../src/functions/isEqual/_internal/comparator.ts","../src/functions/isEqual/_internal/createEqualityComparator.ts","../src/functions/isEqual/isEqual.ts","../src/functions/isNonNullable/isNonNullable.ts","../src/functions/join/join.ts","../src/functions/kebabCase/kebabCase.ts","../src/functions/keyBy/keyBy.ts","../src/functions/objectEntries/objectEntries.ts","../src/functions/objectFromEntries/objectFromEntries.ts","../src/functions/mapKeys/mapKeys.ts","../src/functions/mapValues/mapValues.ts","../src/functions/max/max.ts","../src/functions/memoize/memoize.ts","../src/functions/min/min.ts","../src/functions/noop/noop.ts","../src/functions/objectKeys/objectKeys.ts","../src/functions/_internal/filterObject/createObjectPredicate.ts","../src/functions/_internal/filterObject/filterObject.ts","../src/functions/omit/omit.ts","../src/functions/once/once.ts","../src/functions/orderBy/orderBy.ts","../src/functions/partition/partition.ts","../src/functions/pick/pick.ts","../src/functions/pipe/pipe.ts","../src/functions/range/range.ts","../src/functions/sample/sample.ts","../src/functions/_internal/isMaliciousObjectPath.ts","../src/functions/set/set.ts","../src/functions/single/single.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"],"names":["range","min","max","isEqual","areArraysEqual","areDatesEqual","areMapsEqual","areObjectsEqual","arePrimitiveWrappersEqual","areRegExpsEqual","areSetsEqual","areTypedArraysEqual","count"],"mappings":"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","sourcesContent":["import { Falsey, 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 * @example\n * ```ts\n * compact([0, 1, false, 2, '', 3, null, 4, undefined]) // [1, 2, 3, 4]\n * ```\n */\nexport function compact<T>(array: Maybe<ReadonlyArray<T | Falsey>>): T[] {\n  return (array?.filter(Boolean) as T[] | undefined) ?? [];\n}\n","import { compact } from '../compact';\n\n/**\n * Asserts that a condition is true, throwing an Error if it is not.\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 * @throws An `AssertionError` if the condition is falsy\n * @example\n * ```ts\n * function doWork(value: number | undefined) {\n *   assert(value !== undefined, 'value should be defined');\n *   // value is now narrowed to number\n *\n *   return value + 1;\n * }\n * ```\n * @example\n * ```ts\n * assert(1 === 1); // OK\n * assert(1 === 2); // throws AssertionError\n * assert(1 === 2, '1 should equal 2'); // throws AssertionError: 1 should equal 2\n * ```\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\n/**\n * An error that is thrown when an assertion is not satisfied.\n * Thrown by {@link assert}.\n */\nexport class AssertionError extends Error {\n  constructor(message?: string) {\n    super(\n      compact([\n        `Assertion not satisfied`,\n        message ? `: \"${message}\"` : '',\n      ]).join('')\n    );\n  }\n}\n","/**\n * Throws an error if a value is of type `never`.\n * Used for exhaustive checks.\n * @param inclusive The value to check.\n * @param noThrow If `true`, returns `undefined` instead of throwing an error.\n * @returns This function never returns a value, but throws an error if `inclusive` is of type `never`.\n * @example\n * ```typescript\n * assertNever('foo' as never); // throws an error\n * assertNever('foo' as never, true); // returns undefined\n * ```\n */\nexport function assertNever(inclusive: never, noThrow = false): never {\n  if (noThrow) {\n    return undefined as never;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- this is unexpected to happen, but if it does, it's better to have the value.\n  throw new Error(`Unexpected inclusive value: ${inclusive}`);\n}\n","/**\n * Returns a new string with the first character capitalized.\n * @param string The input string to capitalize.\n * @returns A new string with the first character capitalized.\n * @example\n * ```ts\n * capitalize('foo'); // 'Foo'\n * capitalize(''); // ''\n * ```\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 type { CamelCase as CamelCaseImplementation } from 'type-fest';\n\nimport { capitalize } from '../capitalize';\n\n/**\n * Changes the casing of a string to kebab case.\n * @param string The input string to change the casing of.\n * @returns A new string with the casing changed to kebab case.\n * @example\n * ```ts\n * camelCase('fooBar') // 'fooFar'\n * camelCase('foo bar') // 'fooBar'\n * camelCase('foo-bar') // 'fooBar'\n * camelCase('fooBar42') // 'fooBar42'\n * ```\n */\nexport function camelCase<S extends string>(string: S): CamelCase<S> {\n  if (!/[a-z]+/i.test(string)) {\n    return string as CamelCase<S>;\n  }\n\n  const words = string.trim().split(wordsRegex);\n  return words\n    .map((word, index) => (index === 0 ? word.toLowerCase() : capitalize(word)))\n    .join('') as CamelCase<S>;\n}\n\n/**\n * Changes the casing of a string to camel case.\n * @see {@link camelCase}.\n */\nexport type CamelCase<S extends string> = CamelCaseImplementation<S>;\n\nconst wordsRegex = /[\\s_-]+|(?<=[a-z])(?=[A-Z])/;\n","import { Many, Maybe } from '../../types';\n\n// eslint-disable-next-line prefer-destructuring\nexport const isArray: IsArray = Array.isArray;\n\ninterface IsArray {\n  /**\n   * The same as `Array.isArray` but with a better type guard.\n   * @param value The value to check.\n   * @returns `true` if the value is an array, `false` otherwise.\n   * @example\n   * ```ts\n   * isArray([1, 2, 3]) // true\n   * isArray('foo') // false\n   * ```\n   */\n  <T>(value: Maybe<Array<ArrayElement<T>>>): value is NonNullable<typeof value>;\n  /**\n   * The same as `Array.isArray` but with a better type guard.\n   * @param value The value to check.\n   * @returns `true` if the value is an array, `false` otherwise.\n   * @example\n   * ```ts\n   * isArray([1, 2, 3]) // true\n   * isArray('foo') // false\n   * ```\n   */\n  <T>(\n    value: Maybe<ReadonlyArray<ArrayElement<T>>>\n  ): value is NonNullable<typeof value>;\n\n  /**\n   * The same as `Array.isArray` but with a better type guard.\n   * @param value The value to check.\n   * @returns `true` if the value is an array, `false` otherwise.\n   * @example\n   * ```ts\n   * isArray([1, 2, 3]) // true\n   * isArray('foo') // false\n   * ```\n   */\n  <T>(value: Maybe<Many<T>>): value is NonNullable<readonly T[]>;\n  /**\n   * The same as `Array.isArray` but with a better type guard.\n   * @param value The value to check.\n   * @returns `true` if the value is an array, `false` otherwise.\n   * @example\n   * ```ts\n   * isArray([1, 2, 3]) // true\n   * isArray('foo') // false\n   * ```\n   */\n  <T>(value: unknown): value is readonly T[];\n}\n\ntype ArrayElement<T> = T extends ReadonlyArray<infer U> ? U : never;\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 * @param value The value to convert to an array if it's not already one.\n * @returns An array containing the input value, or the input value itself if it is already an array, or `null` or `undefined` if the input value is `null` or `undefined`.\n * @example\n * ```ts\n * castArrayIfDefined(null) // null\n * ```\n */\nexport function castArrayIfDefined(value: null): null;\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 * @param value The value to convert to an array if it's not already one.\n * @example\n * ```ts\n * castArrayIfDefined(undefined) // undefined\n * ```\n */\nexport function castArrayIfDefined(value: undefined): undefined;\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 * @param value The value to convert to an array if it's not already one.\n * @returns An array containing the input value, or the input value itself if it is already an array, or `null` or `undefined` if the input value is `null` or `undefined`.\n * @example\n * ```ts\n * castArrayIfDefined([1, 2, 3]) // [1, 2, 3]\n * ```\n */\nexport function castArrayIfDefined<T>(value: readonly T[]): readonly T[];\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 * @param value The value to convert to an array if it's not already one.\n * @returns An array containing the input value, or the input value itself if it is already an array, or `null` or `undefined` if the input value is `null` or `undefined`.\n * @example\n * ```ts\n * castArrayIfDefined([1, 2, 3]) // [1, 2, 3]\n * ```\n */\nexport function castArrayIfDefined<T>(value: T[]): T[];\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 * @param value The value to convert to an array if it's not already one.\n * @returns An array containing the input value, or the input value itself if it is already an array, or `null` or `undefined` if the input value is `null` or `undefined`.\n * @example\n * ```ts\n * castArrayIfDefined([1, 2, 3]) // [1, 2, 3]\n * castArrayIfDefined(42) // [42]\n * ```\n */\nexport function castArrayIfDefined<T>(value: NonNullable<T>): T[];\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 * @param value The value to convert to an array if it's not already one.\n * @returns An array containing the input value, or the input value itself if it is already an array, or `null` or `undefined` if the input value is `null` or `undefined`.\n * @example\n * ```ts\n * castArrayIfDefined([1, 2, 3]) // [1, 2, 3]\n * castArrayIfDefined(42) // [42]\n * ```\n */\nexport function castArrayIfDefined<T>(\n  value: Maybe<\n    Many<NonNullable<T>, 'mutable'> | Many<NonNullable<T>, 'immutable'>\n  >\n): Maybe<T[]>;\n/**\n * Implementation for all overloads.\n * @param value The value to convert to an array if it's not already one.\n * @returns An array containing the input value, or the input value itself if it is already an array, or `null` or `undefined` if the input value is `null` or `undefined`.\n */\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';\nimport { castArrayIfDefined } from '../castArrayIfDefined';\n\n// NOTE: all JSDocs here are duplicated of one another since there's no way to inherit them at this time.\n// see https://github.com/microsoft/TypeScript/issues/407 for more info.\n\n/**\n * Casts the input value to an array if it is not already an array.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\nexport function castArray<T>(value: null): T[];\n/**\n * Casts the input value to an array if it is not already an array.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\nexport function castArray<T>(value: undefined): T[];\n/**\n * Casts the input value to an array if it is not already an array.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\nexport function castArray<T>(value: readonly T[]): readonly T[];\n/**\n * Casts the input value to an array if it is not already an array.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\nexport function castArray<T>(value: T[]): T[];\n/**\n * Casts the input value to an array if it is not already an array.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\nexport function castArray<T>(\n  value: Maybe<\n    Many<NonNullable<T>, 'mutable'> | Many<NonNullable<T>, 'immutable'>\n  >\n): T[];\n/**\n * Casts the input value to an array if it is not already an array.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\nexport function castArray<T>(value: NonNullable<T>): T[];\n/**\n * Implementation for all overloads.\n * @param value The input value to cast to an array.\n * @returns An array containing the input value, or the input value itself if it is already an array.\n * @example\n * ```ts\n * castArray('foo'); // ['foo']\n * castArray(['foo']); // ['foo']\n * castArray(null); // []\n * castArray(undefined); // []\n * ```\n */\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 * @param array The array to split.\n * @param size The maximum size of each chunk.\n * @returns An array of arrays where each sub-array has at most `size` elements.\n * @example\n * ```ts\n * chunk([1, 2, 3, 4, 5], 2) // [[1, 2], [3, 4], [5]]\n * ```\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 { CastToString } from '../../types';\n\ninterface ClampOptions {\n  /**\n   * Whether the clamping should be inclusive of the range.\n   * @default true\n   */\n  inclusive?: boolean | 'min' | 'max';\n}\n\n/**\n * Clamps a number to a specified range.\n * @param value The number to clamp.\n * @param range The range to clamp to, as a tuple of min and max values.\n * @param options Optional parameters.\n * @param options.inclusive Whether the clamping should be inclusive of the min and/or max value.\n * - If `true`, the clamping is inclusive of both min and max.\n * - If `false`, the clamping is exclusive of both min and max.\n * - If `'min'`, the clamping is inclusive of the min value but exclusive of the max value.\n * - If `'max'`, the clamping is exclusive of the min value but inclusive of the max value.\n * @returns The clamped number.\n * @example\n * ```typescript\n * clamp(3, [1, 5]); // 3\n * clamp(5, [1, 5]); // 5\n * clamp(5, [1, 5], { inclusive: false }); // 4\n * clamp(1, [1, 5], { inclusive: 'max' }); // 5\n * ```\n */\n// eslint-disable-next-line consistent-return -- we have an exhaustive check, so we never get to the end of the function\nexport function clamp(\n  value: number,\n  range: readonly [min: number, max: number],\n  options?: ClampOptions\n): number {\n  const [min, max] = range;\n  if (min > max) {\n    throw new RangeError(`Invalid range: [${min},${max}]`);\n  }\n\n  const { inclusive = true } = options ?? {};\n\n  return {\n    true: () => Math.max(min, Math.min(max, value)),\n    false: () => Math.max(min + 1, Math.min(max - 1, value)),\n    min: () => Math.max(min, Math.min(max - 1, value)),\n    max: () => Math.max(min + 1, Math.min(max, value)),\n  }[inclusive as CastToString<typeof inclusive>]();\n}\n","/**\n * Changes the casing of a string to constant case.\n * @param string The input string to change the casing of.\n * @returns A new string with the casing changed to constant case.\n * @example\n * ```ts\n * constantCase('fooBar') // 'FOO_BAR'\n * constantCase('foo bar') // 'FOO_BAR'\n * constantCase('foo-bar') // 'FOO_BAR'\n * constantCase('fooBar42') // 'FOO_BAR42'\n * ```\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\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s-]+/g, '_')\n    .toUpperCase() as ConstantCase<S>;\n}\n\n/**\n * Changes the casing of a string to constant case.\n * @see {@link constantCase}.\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","import { Maybe } from '../../../types';\n\nexport function filter<T>(source: Maybe<Iterable<T>>): T[] | undefined;\nexport function filter<T>(\n  source: Maybe<Iterable<T>>,\n  predicate?: (value: T, index: number) => boolean\n): T[] | undefined;\nexport function filter<T, S>(\n  source: Maybe<Iterable<T>>,\n  predicate?: (value: S, index: number) => value is S\n): S[] | undefined;\nexport function filter<T>(\n  source: Maybe<Iterable<T>>,\n  predicate?: (value: T, index: number) => boolean\n): T[] | undefined {\n  if (source == null) {\n    return undefined;\n  }\n\n  const relevantItems =\n    predicate == null\n      ? [...source]\n      : // eslint-disable-next-line unicorn/no-array-callback-reference -- this is fine, we want to use the same predicate\n        [...source].filter(predicate);\n\n  return relevantItems;\n}\n","import { Maybe } from '../../types';\nimport { filter } from '../_internal/filterIterable';\n\n/**\n * Returns the number of elements in an iterable.\n * @param source The iterable to count.\n * @returns The number of elements.\n * @example\n * ```ts\n * count([1, 2, 3]); // 3\n * count([]); // 0\n * count(null); // 0\n * ```\n */\nexport function count<T>(source: Maybe<Iterable<T>>): number;\n/**\n * Returns the number of elements in an iterable that satisfy a predicate.\n * @param source The iterable to count.\n * @param predicate The predicate function used to determine if an element is a match.\n * @returns The number of matching elements.\n * @example\n * ```ts\n * count([1, 2, 3], x => x % 2 === 0); // 1\n * count([1, 2, 3], x => x >= 2); // 2\n * count([], x => x >= 1); // 0\n * count(null, x => x >= 1); // 0\n * ```\n */\nexport function count<T>(\n  source: Maybe<Iterable<T>>,\n  predicate?: (value: T, index: number) => boolean\n): number;\n/**\n * Implementation for all overloads.\n * @param source The iterable to count.\n * @param predicate The predicate function used to determine if an element is a match.\n * @returns The number of matching elements.\n */\nexport function count<T>(\n  source: Maybe<Iterable<T>>,\n  predicate?: (value: T, index: number) => boolean\n): number {\n  const relevantItems = filter(source, predicate);\n  return relevantItems?.length ?? 0;\n}\n","/**\n * Creates a type guard that checks if the given type is assignable to the given type.\n * @param values The values to check against.\n * @template {TInput} 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 * @example\n * ```ts\n * const isValidValue = createTypeGuard(['foo', 'bar']);\n *\n * const value: unknown = '...';\n * if (isValidValue(value)) {\n *   // ✅ value is of type `'foo' | 'bar'`\n * }\n * ```\n */\nexport function createTypeGuard<\n  const TKnownValue,\n  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents -- without this we can't have a default type of `unknown`\n  TInput extends TKnownValue | unknown = unknown,\n>(values: Iterable<TKnownValue>): (v: TInput) => v is TInput & TKnownValue {\n  const setValues = new Set<unknown>(values);\n  return function predicate(v: unknown): v is TInput & TKnownValue {\n    return setValues.has(v);\n  };\n}\n","import { AnyFunction } from '../../types/_internal';\n\n/**\n * Creates a debounced function that delays invoking `func` until after `delay` milliseconds have elapsed since the last time the debounced function was invoked.\n * @param func The function to debounce.\n * @param delay The number of milliseconds to delay.\n * @param options Optional configuration options.\n * @param options.leading Whether to call the function on the leading edge of the timeout.\n * @returns A debounced function that can be called multiple times, but only invokes `func` once per `delay` milliseconds.\n */\nexport function debounce<TFunction extends AnyFunction<void | undefined>>(\n  func: TFunction,\n  delay: number,\n  options: {\n    /**\n     * Whether to call the function on the leading edge of the timeout.\n     * @default false\n     */\n    leading?: boolean;\n  } = {}\n): DebouncedFunction<TFunction> {\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n  let isCalled = false;\n  let latestArguments: Parameters<TFunction>;\n\n  function debouncedFunction(...args: Parameters<TFunction>): void {\n    latestArguments = args;\n\n    if (options.leading && !isCalled) {\n      func(...args);\n      isCalled = true;\n    }\n\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    timeoutId = setTimeout(() => {\n      if (!options.leading) {\n        func(...args);\n      }\n      isCalled = false;\n    }, delay);\n  }\n\n  debouncedFunction.flush = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    func(...latestArguments);\n  };\n\n  debouncedFunction.clear = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n  };\n\n  return debouncedFunction;\n}\n\ninterface DebouncedFunction<TFunction extends AnyFunction<void | undefined>> {\n  (...args: Parameters<TFunction>): void;\n  clear(): void;\n  flush(): void;\n}\n","import { AnyFunction } from '../../types/_internal';\n\n/**\n * Returns a new function that negates the result of the input function.\n * @param func The input function to negate.\n * @returns A new function that negates the result of the input function.\n * @example\n * ```ts\n * const isEven = (num: number) => num % 2 === 0;\n * const isOdd = negate(isEven);\n * isOdd(1); // true\n * isOdd(2); // false\n * ```\n */\nexport function negate<Func extends AnyFunction<boolean>>(\n  func: Func\n): (...args: Parameters<Func>) => boolean {\n  return (...args: Parameters<Func>) => {\n    const result = func(...args);\n    return !result;\n  };\n}\n","import type { IsLiteral } from 'type-fest';\n\nimport { createTypeGuard } from '../createTypeGuard';\nimport { negate } from '../negate';\n\n/**\n * Gets the difference between two arrays.\n * @param array1 The first array.\n * @param array2 The second array.\n * @param comparator A function that determines whether two items are equal.\n * @returns An array with the difference between the two arrays - items that are in the first array but not in the second.\n * @example\n * ```ts\n * difference([1, 2, 3], [2, 3, 4]) // [2, 3]\n * ```\n */\nexport function difference<const T, const S extends T>(\n  array1: readonly T[],\n  array2: readonly S[],\n  comparator?: Comparator<T, S>\n): Array<IsLiteral<T> | IsLiteral<S> extends true ? Exclude<T, S> : T>;\n/**\n * Gets the difference between two arrays.\n * @param array1 The first array.\n * @param array2 The second array.\n * @param comparator A function that determines whether two items are equal.\n * @returns An array with the difference between the two arrays - items that are in the first array but not in the second.\n * @example\n * ```ts\n * difference([1, 2, 3], [2, 3, 4]) // [2, 3]\n * ```\n */\nexport function difference<T, S extends T>(\n  array1: readonly T[],\n  array2: readonly S[],\n  comparator?: Comparator<T, S>\n): Array<IsLiteral<T> | IsLiteral<S> extends true ? Exclude<T, S> : T>;\n// eslint-disable-next-line jsdoc/require-jsdoc -- implementation of the overload signatures\nexport function difference<T, S extends T>(\n  array1: readonly T[],\n  array2: readonly S[],\n  comparator?: Comparator<T, S>\n): Array<IsLiteral<T> | IsLiteral<S> extends true ? Exclude<T, S> : T> {\n  // no comparator provided - we can do a quicker check using `Object.is` via a Set.\n  if (!comparator) {\n    const isArray2Item = createTypeGuard(array2);\n    return array1.filter(negate(isArray2Item)) as Array<Exclude<T, S>>;\n  }\n\n  return array1.filter(\n    (a1): a1 is Exclude<T, S> => !array2.some((a2) => comparator(a1, a2))\n  );\n}\n\ntype Comparator<T, S extends T> =\n  | ((a: T, b: S) => a is Exclude<T, S>)\n  | ((a: T, b: S) => boolean);\n","/**\n * Ensures that the string starts with the given prefix.\n * @param string The string to ensure the prefix of.\n * @param prefix The prefix to ensure.\n * @returns The string with the given prefix.\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 * @param string The string to ensure the suffix of.\n * @param suffix The suffix to ensure.\n * @returns The string with the given suffix.\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\n/**\n * Returns whether the input value has the specified key.\n * @param value The value to check.\n * @param key The key to check for.\n * @returns Whether the input value has the specified key.\n * @example\n * ```ts\n * hasKey({ a: 1 }, 'a') // true\n * hasKey({ a: 1 }, 'b') // false\n * ```\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, ObjectPath } from '../../types';\nimport { hasKey } from '../hasKey';\nimport { isArray } from '../isArray';\n\n/**\n * Gets the value at path of object.\n * Allows accessing properties in unions of objects and getting undefined if the property is not present.\n * @param object The object to query.\n * @param path The path of the property to get.\n * @returns The value at path of object.\n * @example\n * ```ts\n * get({ a: 1, b: 2, c: 3 }, 'b') // 2\n * get({\n *   name: \"John Doe\",\n *   address: {\n *     street: \"123 Main St\",\n *     city: \"Anytown\",\n *   }\n * }, 'address.city') // \"Anytown\"\n * ```\n */\nexport function get<T, Path extends ObjectPath<T>>(\n  object: T,\n  path: Path\n): Get<T, Path>;\n/**\n * Gets the value at path of object.\n * Allows accessing properties in unions of objects and getting undefined if the property is not present.\n * @param object The object to query.\n * @param path The path of the property to get.\n * @returns The value at path of object.\n * @example\n * ```ts\n * get({\n *   name: \"John Doe\",\n *   address: {\n *     street: \"123 Main St\",\n *     city: \"Anytown\",\n *   }\n * }, ['address', 'city']) // \"Anytown\"\n * ```\n */\nexport function get<T, Path extends Many<string>>(\n  object: T,\n  path: Path\n): Get<T, Path>;\n/**\n * Implementation of all overloads.\n * @param object The object to query.\n * @param path The path of the property to get.\n * @returns The value at path of object.\n */\nexport function get<T, Path extends ObjectPath<T> | 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 mapped to the items of the array.\n * @param array The