{"version":3,"sources":["../../src/functions/isArray/isArray.ts","../../src/functions/castArray/castArrayIfDefined.ts","../../src/functions/castArray/castArray.ts","../../src/functions/createKnownTypeGuard/createKnownTypeGuard.ts","../../src/functions/objectEntries/objectEntries.ts","../../src/functions/pick/pick.ts"],"names":[],"mappings":";AAMO,IAAM,UAAmB,MAAM;;;ACwB/B,SAAS,mBACd,OAGA;AACA,MAAI,SAAS,MAAM;AACjB,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,KAAK,GAAG;AAClB,WAAO;AAAA,EACT;AAEA,SAAO,CAAC,KAAK;AACf;;;ACnCO,SAAS,UACd,OAGA;AACA,SAAO,mBAAmB,SAAS,CAAC,CAAC;AACvC;;;ACGO,SAAS,qBAGd,QAA0B;AAC1B,QAAM,YAAY,IAAI,IAAa,MAAM;AACzC,SAAO,SAAS,cAAc,GAA+C;AAC3E,WAAO,UAAU,IAAI,CAAC;AAAA,EACxB;AACF;;;AC1BO,IAAM,gBAA8B,OAAO;;;ACa3C,SAAS,KAGd,QAAkB,uBAAqD;AACvE,MAAI,UAAU,MAAM;AAClB,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YACJ,OAAO,0BAA0B,aAC7B,wBACA,0BAA0B,qBAAqB;AAErD,SAAO,OAAO;AAAA,IACZ,cAAc,MAAM,EAAE;AAAA,MAAO,CAAC,CAAC,KAAK,KAAK,MACvC,UAAU,OAAO,KAAK,MAAM;AAAA,IAC9B;AAAA,EACF;AACF;AAEA,SAAS,0BAGP,YAAyC;AACzC,QAAM,kBAAkB,qBAAqB,UAAU,UAAU,CAAC;AAElE,SAAO,CAAC,QAAQ,QAAQ,gBAAgB,GAAG;AAC7C","sourcesContent":["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","/**\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","export const objectEntries: ObjetEntries = Object.entries;\n\ninterface ObjetEntries {\n  <T extends object>(object: T): [keyof T, T[keyof T]][];\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"]}