{"version":3,"file":"index.mjs","sources":["../src/array/arrChunks/arrChunks.ts","../src/array/arrCross/arrCross.ts","../src/array/arrDiff/arrDiff.ts","../src/array/arrEject/arrEject.ts","../src/array/arrProd/arrProd.ts","../src/array/arrSum/arrSum.ts","../src/array/arrUnion/arrUnion.ts","../src/math/clamp/clamp.ts","../src/math/gcd/gcd.ts","../src/math/vecDot/vecDot.ts","../src/math/vecMag/vecMag.ts","../src/number/numAbbr/numAbbr.ts","../src/number/numOrd/numOrd.ts","../src/number/parseNum/parseNum.ts","../src/object/hasKey/hasKey.ts","../src/object/objEqual/objEqual.ts","../src/object/objDiff/objDiff.ts","../src/object/objFlush/objFlush.ts","../src/object/objPick/objPick.ts","../src/string/snakeCase/snakeCase.ts","../src/string/strCap/strCap.ts","../src/string/strTunc/strTrunc.ts","../src/url/paramsToObj/paramsToObj.ts"],"sourcesContent":["/**\n * Splits a parent array into smaller chunks\n *\n * @example\n * arrChunks([1, 2, 3, 4], 2);\n * => [[1, 2], [3, 4]]\n *\n * @param a - An array\n * @param size - Individual chunk size\n */\nexport const arrChunks = <Type extends unknown[]>(\n  a: Type,\n  size: number,\n): Type[] => {\n  const chunks: Type[] = [];\n\n  for (let i = 0; i < a.length; i += size) {\n    chunks.push(a.slice(i, i + size) as Type);\n  }\n\n  return chunks;\n};\n\nexport { arrChunks as arrayToChunks, arrChunks as arrayChunks };\n","/**\n * Returns the common elements from two arrays\n *\n * @example\n * arrCross([1, 2, 3, 4], [2, 3]);\n * => [2, 3]\n *\n * @param a - First array\n * @param b - Second array\n */\nexport const arrCross = <Type extends unknown[]>(\n  a: unknown[],\n  b: unknown[],\n): Type => a.filter((element) => b.indexOf(element) !== -1) as Type;\n\nexport { arrCross as arrayCross, arrCross as arrayIntersect };\n","/**\n * Returns elements from the first array that are not present in the second array\n *\n * @example\n * arrDiff([1, 2, 3, 4], [2, 3]);\n * => [1, 4]\n *\n * @param a - First array\n * @param b - Second array\n */\nexport const arrDiff = <Type extends unknown[]>(\n  a: unknown[],\n  b: unknown[],\n): Type => a.filter((element) => b.indexOf(element) === -1) as Type;\n\nexport {\n  arrDiff as arrayDiff,\n  // Users might actually confuse arrDiff with array diffing\n  arrDiff as arrayDifference,\n};\n","type ArrayElement<ArrayType extends unknown[]> = ArrayType[number];\n\nconst ejectElement = (element: unknown, array: unknown[]): void => {\n  const index = array.indexOf(element);\n\n  if (index > -1) {\n    array.splice(index, 1);\n  }\n};\n\n/**\n * Removes one or more elements from an array\n *\n * @example\n * arrEject([1, 2, 3, 4], 2);\n * => [1, 3, 4]\n *\n * @param a - An array\n * @param elements - A single element or an array of elements to eject\n * @param mutate - Whether to mutate the original array\n */\nexport const arrEject = <Type extends unknown[]>(\n  a: unknown[],\n  elements: ArrayElement<Type> | ArrayElement<Type>[],\n  mutate = true,\n): Type => {\n  const operand = mutate ? a : [...a];\n\n  if (Array.isArray(elements)) {\n    for (const element of elements) {\n      ejectElement(element, operand);\n    }\n  } else {\n    ejectElement(elements, operand);\n  }\n\n  return operand as Type;\n};\n\nexport { arrEject as arrayEject, arrEject as arrayDelete };\n","/**\n * Returns the product of elements of an array\n *\n * @example\n * arrProd([2, 4, 8]);\n * => 64\n *\n * @param a - A numeric array\n */\nexport const arrProd = (a: number[]): number =>\n  a.reduce((previousValue, currentValue) => previousValue * currentValue, 1);\n\nexport { arrProd as arrayProd, arrProd as arrayProduct };\n","/**\n * Returns the sum of elements of an array\n *\n * @example\n * arrSum([1, 2, 3]);\n * => 6\n *\n * @param a - A numeric array\n */\nexport const arrSum = (a: number[]): number =>\n  a.reduce((previousValue, currentValue) => previousValue + currentValue, 0);\n\nexport { arrSum as arraySum };\n","/**\n * Returns a unique union of elements of two arrays\n *\n * @example\n * arrUnion([1, 2, 3, 4, 5], [1, 3, 5, 7]);\n * => [1, 2, 3, 4, 5, 7]\n *\n * @param a - First array\n * @param b - Second array\n */\nexport const arrUnion = <Type extends unknown[]>(\n  a: unknown[],\n  b: unknown[],\n): Type => [...new Set([...a, ...b])] as Type;\n\nexport { arrUnion as arrayUnion, arrUnion as arrayMerge };\n","/**\n * Clamps a number to bounds\n *\n * @example\n * clamp(0, 64, 32);\n * => 32\n *\n * @param min - The lower bound\n * @param value - Un-clamped value\n * @param max - The upper bound\n */\nexport const clamp = (min: number, value: number, max: number): number =>\n  Math.min(Math.max(value, min), max);\n","/**\n * Returns the greatest common divisor of two numbers\n *\n * @example\n * gcd(24, 12);\n * => 12\n *\n * @param a - First number\n * @param b - Second number\n */\nexport const gcd = (a: number, b: number): number =>\n  b === 0 ? a : gcd(b, a % b);\n","import type { Vector } from '../types';\n\n/**\n * Returns the dot product of two vectors\n *\n * @example\n * vecDot([1, 2], [3, 4]);\n * => 11\n *\n * @param a - First vector\n * @param b - Second vector\n */\nexport const vecDot = (a: Vector, b: Vector): number =>\n  a\n    .map((_, index) => (a[index] || 0) * (b[index] || 0))\n    .reduce((previousValue, currentValue) => previousValue + currentValue);\n\nexport { vecDot as vectorDot };\n","import type { Vector } from '../types';\nimport { vecDot } from '../vecDot';\n\n/**\n * Returns the magnitude of a vector\n *\n * @example\n * vecMag([3, 4]);\n * => 5\n *\n * @param a - A vector\n */\nexport const vecMag = (a: Vector): number => Math.sqrt(vecDot(a, a));\n\nexport { vecMag as vectorMag };\n","export const defaultAbbreviations = ['', 'k', 'M', 'B', 'T', 'P', 'E'] as const;\n\n/**\n * Abbreviates a number\n *\n * @example\n * numAbbr(1e3);\n * => \"1k\"\n *\n * @param a - A number\n * @param suppliedAbbreviations - Optional custom abbreviations\n */\nexport const numAbbr = (\n  a: number,\n  suppliedAbbreviations?: string[],\n): string => {\n  const abbreviations = suppliedAbbreviations || defaultAbbreviations;\n  const positive = Math.sign(a) >= 0;\n\n  a = Math.abs(a);\n\n  const level = (Math.log10(a) / 3) | 0;\n\n  if (level == 0) {\n    return `${!positive ? '-' : ''}${a}`;\n  }\n\n  const abbreviation = abbreviations[level];\n\n  if (!abbreviation) {\n    throw new RangeError('Number out of range');\n  }\n\n  const result = String(Number((a / Math.pow(10, level * 3)).toFixed(1)));\n\n  return `${!positive ? '-' : ''}${result}${abbreviation}`;\n};\n\nexport { numAbbr as numAbbreviate, numAbbr as numberAbbreviate };\n","export const defaultOrdinals = ['th', 'st', 'nd', 'rd'] as const;\n\n/**\n * Suffixes an ordinal to a number\n *\n * @example\n * numOrd(10);\n * => \"10th\"\n *\n * @param a - A number\n * @param suppliedOrdinals - Optional custom ordinals\n * @see https://gist.github.com/jlbruno/1535691/db35b4f3af3dcbb42babc01541410f291a8e8fac\n */\nexport const numOrd = (a: number, suppliedOrdinals?: string[]): string => {\n  const ordinals = suppliedOrdinals || defaultOrdinals;\n  const index = a % 100;\n\n  return (\n    a + (ordinals[(index - 20) % 10] || ordinals[index] || ordinals[0] || '')\n  );\n};\n\nexport { numOrd as numOrdinal, numOrd as numberOrd, numOrd as numberOrdinal };\n","/**\n * Converts a string to an integer or a floating value\n *\n * @example\n * parseNum('64');\n * => 64\n *\n * parseNum('2.14');\n * => 2.14\n *\n * @param value - The string to parse\n * @param returnNull - Whether to return null if the input cannot be parsed to a number\n */\nexport const parseNum = <ReturnType extends boolean = false>(\n  value: string | number,\n  returnNull?: ReturnType,\n): ReturnType extends false ? string | number : number | null =>\n  Number.isNaN(Number(value)) || Number.isNaN(Number.parseInt('' + value))\n    ? returnNull\n      ? null\n      : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (value as any)\n    : +('' + value);\n\nexport { parseNum as parseNumber, parseNum as toNumber };\n","/**\n * Checks if a key or an array of keys exists on an object\n *\n * @example\n * const obj = {\n *   \"foo\": true,\n *   \"bar\": false\n * };\n *\n * hasKey(obj, 'foo');\n * => true\n *\n * hasKey(obj, ['foo', 'bar']);\n * => true\n *\n * @param a - An object\n * @param keys - The keys to check\n */\nexport const hasKey = <\n  Type extends Record<string | number | symbol, unknown>,\n  Key extends keyof Type,\n>(\n  a: Type,\n  keys: Key | Key[],\n): boolean => {\n  let hasKeys = true;\n\n  if (Array.isArray(keys)) {\n    let i = keys.length;\n\n    while (i--) {\n      if (!hasKey(a, keys[i] as Key)) {\n        hasKeys = false;\n        break;\n      }\n    }\n  } else {\n    if (!Object.prototype.hasOwnProperty.call(a, keys)) {\n      hasKeys = false;\n    }\n  }\n\n  return hasKeys;\n};\n\nexport { hasKey as objHasKey, hasKey as objectHasKey };\n","// TODO: Implement deep comparison\n\n/**\n * Compares two objects for equality\n *\n * @example\n * objEqual({ foo: 1, bar: 2 }, { foo: 1, bar: 2 });\n * => true\n *\n * objEqual({ foo: 1, bar: 2 }, { foo: 1, bar: false });\n * => false\n *\n * @param a - First object\n * @param b - Second object\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const objEqual = <Type extends Record<string | number | symbol, any>>(\n  a: Type,\n  b: Type,\n): boolean => {\n  if (typeof a == 'object' && a != null && typeof b == 'object' && b != null) {\n    if (Object.keys(a).length - Object.keys(b).length !== 0) {\n      return false;\n    }\n\n    for (const objKey in a) {\n      if (!(objKey in b) || !objEqual(a[objKey], b[objKey])) {\n        return false;\n      }\n    }\n\n    for (const relObjKey in b) {\n      if (!(relObjKey in a) || !objEqual(b[relObjKey], a[relObjKey])) {\n        return false;\n      }\n    }\n\n    return true;\n  } else {\n    return a === b;\n  }\n};\n\nexport { objEqual as objectEqual };\n","import { hasKey } from '../hasKey';\nimport { objEqual } from '../objEqual';\n\n/**\n * Returns an array of identical keys with different values across two objects\n *\n * @example\n * objDiff({ foo: 1, bar: 2 }, { foo: true, bar: 2 });\n * => ['foo']\n *\n * objDiff({ foo: 1, bar: 2 }, { foo: 1, bar: 2 });\n * => false\n *\n * @param a - First object\n * @param b - Second object\n */\nexport const objDiff = <\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Type extends Record<string | number | symbol, any>,\n  Key extends keyof Type,\n>(\n  a: Type,\n  b: Type,\n): Key[] | false => {\n  if (objEqual(a, b)) {\n    return false;\n  }\n\n  const modifiedKeys: Key[] = [];\n  const keys = Object.keys(a);\n  let i = keys.length;\n\n  while (i--) {\n    if (\n      hasKey(b, keys[i] as Key) &&\n      !objEqual(a[keys[i] as Key], b[keys[i] as Key])\n    ) {\n      modifiedKeys.push(keys[i] as Key);\n    }\n  }\n\n  return modifiedKeys.length ? modifiedKeys : false;\n};\n\nexport {\n  objDiff as objDifference,\n  objDiff as objectDiff,\n  // Users might actually confuse objDiff with object diffing\n  objDiff as objectDifference,\n};\n","import { hasKey } from '../hasKey';\n\n/**\n * Deletes a single key or multiple keys from an object\n *\n * @example\n * const obj = {\n *   \"foo\": true,\n *   \"bar\": false,\n *   \"one\": 2\n * };\n *\n * objFlush(obj, 'foo');\n * =>\n * {\n *   \"bar\": false,\n *   \"one\": 2\n * }\n *\n * objFlush(obj, ['foo', 'bar']);\n * => {\n *   \"one\": 2\n * }\n *\n * objFlush(obj);\n * => {}\n *\n * @param a - An object\n * @param keys - The key or an array of keys to remove.\n */\nexport const objFlush = <\n  Type extends Record<string | number | symbol, unknown>,\n  Key extends keyof Type,\n>(\n  a: Type,\n  keys?: Key | Key[],\n): Partial<Type> => {\n  if (!keys) {\n    for (const key in a) {\n      if (hasKey(a, key)) {\n        delete a[key];\n      }\n    }\n  } else if (Array.isArray(keys)) {\n    let i = keys.length;\n\n    while (i--) {\n      if (hasKey(a, keys[i] as Key)) {\n        delete a[keys[i] as Key];\n      }\n    }\n  } else if (hasKey(a, keys)) {\n    delete a[keys];\n  }\n\n  return a;\n};\n\nexport { objFlush as objectFlush };\n","import { hasKey } from '../hasKey';\n\n/**\n * Returns a new object with the specified keys from a source object\n *\n * @example\n * const obj = {\n *   \"one\": true,\n *   \"two\": false,\n *   \"foo\": \"bar\"\n * };\n *\n * const newObj = objPick(obj, ['two', 'foo']);\n * =>\n * {\n *   \"two\": false,\n *   \"foo\": \"bar\"\n * }\n *\n * @param a - An object\n * @param keys - An array of keys to pick\n * @param options - Optional options\n * @param options.upsert - Whether to create new properties for missing keys\n * @param options.defaultValue - Default value to use when upsert-ing\n */\nexport const objPick = <\n  Type extends Record<string | number | symbol, unknown>,\n  Key extends keyof Type,\n>(\n  a: Type,\n  keys: Key[] | string[],\n  options?: {\n    defaultValue?: unknown;\n    upsert?: boolean;\n  },\n): Record<(typeof keys)[number], (typeof a)[keyof typeof a]> => {\n  const { defaultValue, upsert } = options || {};\n  const newObj: Record<string | number | symbol, unknown> = {};\n  let i = keys.length;\n\n  while (i--) {\n    if (hasKey(a, keys[i] as Key)) {\n      newObj[keys[i] as Key] = a[keys[i] as Key];\n    } else if (upsert) {\n      newObj[keys[i] as Key] = defaultValue || null;\n    }\n  }\n\n  return newObj as Record<(typeof keys)[number], (typeof a)[keyof typeof a]>;\n};\n\nexport { objPick as objectPick };\n","/**\n * Converts a string to snake_case\n *\n * @example\n * snakeCase(\"camelCase\");\n * => \"camel_case\"\n *\n * @param a - A string\n * @param separator - An optional separator to use instead of underscore\n */\nexport const snakeCase = (a: string, separator?: string): string => {\n  const matches = a.match(\n    /[A-Z]{2,}(?=[A-Z][a-z]+\\d*|\\b)|[A-Z]?[a-z]+\\d*|[A-Z]|\\d+/g,\n  );\n\n  return matches\n    ? matches.map((chunk) => chunk.toLowerCase()).join(separator || '_')\n    : a;\n};\n\nexport { snakeCase as toSnakeCase };\n","/**\n * Capitalizes the first letter of a phrase\n *\n * @example\n * strCap(\"lower case\");\n * => \"Lower case\"\n *\n * @param a - A string\n */\nexport const strCap = (a: string): string =>\n  a.charAt(0).toUpperCase() + a.slice(1);\n\nexport {\n  strCap as strCapitalize,\n  strCap as stringCap,\n  strCap as stringCapitalize,\n};\n","/**\n * Truncates a long string\n *\n * @example\n * strTrunc(\"A very long string\", 5);\n * => \"A very...\"\n *\n * @param a - A long string\n * @param limit - Limit of characters\n * @param delimiter - Optional delimiter (terminating suffix)\n */\nexport const strTrunc = (a: string, limit: number, delimiter = '...'): string =>\n  a.length > limit ? `${a.substring(0, limit + 1)}${delimiter}` : a;\n\nexport {\n  strTrunc as strTruncate,\n  strTrunc as stringTrunc,\n  strTrunc as stringTruncate,\n};\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { URLSearchParams } from 'url';\nimport { parseNum } from '../../number';\n\n/**\n * Converts url parameters to object\n *\n * @example\n * paramsToObj(new URLSearchParams(\"?foo=bar&bar=doe&foo=5&john=null\"));\n * => {\n *   foo: [\"bar\", \"5\"],\n *   bar: \"doe\",\n *   john: \"null\"\n * }\n *\n * paramsToObj(\n *   new URLSearchParams('?foo=5&bar=null', {\n *     parseNulls: true,\n *     parseNumbers: true,\n *   }),\n * );\n * => {\n *   foo: 5,\n *   bar: null\n * }\n *\n * @param params - Search params\n * @param options - Optional options\n * @param options.parseNumbers - Whether to parse numeric string parameter values\n * @param options.parseNulls - Whether to parse null string parameter values\n */\nexport const paramsToObj = <Type = any>(\n  params: URLSearchParams,\n  options?: {\n    parseNulls?: boolean;\n    parseNumbers?: boolean;\n  },\n): Type => {\n  const iterator = params.entries();\n  const object: any = {};\n\n  for (let itr = iterator.next(); !itr.done; itr = iterator.next()) {\n    const [key, rawValue] = itr.value;\n    const value =\n      options?.parseNulls && rawValue === 'null'\n        ? null\n        : options?.parseNumbers\n        ? parseNum(rawValue)\n        : rawValue;\n\n    if (object[key]) {\n      if (Array.isArray(object[key])) {\n        object[key].push(value);\n      } else {\n        object[key] = [object[key], value];\n      }\n    } else {\n      object[key] = value;\n    }\n  }\n\n  return object as Type;\n};\n\nexport { paramsToObj as paramsToObject };\n"],"names":[],"mappings":"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"}