{"version":3,"file":"index.cjs","sources":["../../src/common/constants.ts","../../src/common/is.ts","../../src/common/error.ts","../../src/common/validate-options.ts","../../src/format/constants.ts","../../src/common/transform-items.ts","../../src/common/find-table.ts","../../src/common/exp-items.ts","../../src/common/no-duplicates.ts","../../src/format/user-items.ts","../../src/format/default-items.ts","../../src/format/find-unit.ts","../../src/format/output.ts","../../src/format/round.ts","../../src/format/create-formatter.ts","../../src/format/format.ts","../../src/parse/constants.ts","../../src/parse/extract-pre.ts","../../src/parse/user-items.ts","../../src/parse/default-items.ts","../../src/parse/find-multiplier.ts","../../src/parse/match.ts","../../src/parse/create-parser.ts","../../src/parse/parse.ts"],"sourcesContent":["export const MICRO = '\\xb5'\n","import type { NullishReturn, TypeCheckFunction } from './private-types'\n\nexport function isNullish(value: unknown): value is NullishReturn {\n  return value == null\n}\n\ninterface TypeOfMap {\n  number: number\n  object: object | null\n  function: CallableFunction\n}\n\nfunction isType<T extends keyof TypeOfMap>(type: T): TypeCheckFunction<TypeOfMap[T]> {\n  return (value: unknown): value is TypeOfMap[T] => {\n    return typeof value === type\n  }\n}\n\nexport const isNumber = isType('number')\nexport const isObject = isType('object')\nexport const isFunction = isType('function')\n\ntype UnknownArray = unknown[] | readonly unknown[]\nexport const isArray = Array.isArray as TypeCheckFunction<UnknownArray>\n\nexport const isFiniteNumber = Number.isFinite as {\n  (value: number): boolean\n  (value: unknown): value is number\n}\n","export function error(message: string): TypeError {\n  return new TypeError(message)\n}\n\nexport function rangeError(message: string): RangeError {\n  return new RangeError(message)\n}\n\nexport function errorInvalidOption(optionName: string): TypeError {\n  return error(`Invalid \"${optionName}\" option`)\n}\n","import { error } from './error'\n\nexport function validateOptions<O extends Record<string, unknown>, K extends keyof O>(options: O, valid: K[], removed: Record<string, string>): Pick<O, K>\nexport function validateOptions<O extends Record<string, unknown>>(options: O, valid: string[], removed: Record<string, string>): O\nexport function validateOptions<O extends Record<string, unknown>>(options: O, valid: string[], removed: Record<string, string>): O {\n\n  // key input options\n  const optionsNames = Object.keys(options)\n  const removedOptionNames = Object.keys(removed)\n\n  // throw if removed option present\n  const removedOptionName = optionsNames.find((optionName) => removedOptionNames.includes(optionName))\n  if (removedOptionName) throw error(`Option \"${removedOptionName}\" has been removed. Use \"${removed[removedOptionName]}\" option instead.`)\n\n  // throw if unknown option present\n  const unknownOptionName = optionsNames.find((optionName) => !valid.includes(optionName))\n  if (unknownOptionName) throw error(`Unknown option \"${unknownOptionName}\".`)\n\n  // return options as valid\n  return options\n\n}\n","import type { CreateFormatterOptions } from './types'\n\ntype CreateFormatterValidOptionName = keyof CreateFormatterOptions\ntype CreateFormatterRemovedOptionName = 'table' | 'dec' | 'fixed'\n\nexport const validFormatterOptions: CreateFormatterValidOptionName[] = ['unit', 'find', 'round', 'output']\n\nexport const removedFormatterOptions: Record<CreateFormatterRemovedOptionName, CreateFormatterValidOptionName> = {\n  table: 'find',\n  dec: 'round',\n  fixed: 'round',\n}\n","import { rangeError } from './error'\nimport { isFiniteNumber } from './is'\nimport type { ExponentFindItems, MultiplierFindItems } from './types'\n\nexport function transformFindItems(items: ExponentFindItems, base: number): MultiplierFindItems {\n  return items.map(({ pre, exp }) => {\n\n    // compute multiplier\n    const mul = base ** exp\n\n    // throw if multiplier is invalid\n    if (!isFiniteNumber(mul) || mul <= 0) throw rangeError(`${base} to the power of ${exp} is not a valid multiplier`)\n\n    // return multiplier item\n    return { pre, mul }\n\n  })\n}\n","import type { DeprecatedFindUnitAdvancedOptions } from '../deprecated-types'\nimport { errorInvalidOption } from './error'\nimport { isArray, isNullish, isNumber, isObject } from './is'\nimport type { AllowNullish } from './private-types'\nimport { transformFindItems } from './transform-items'\nimport type { DeclarativeFindUnit, ExponentFindItems, FindUnitAdvancedOptions, MultiplierFindItems } from './types'\n\n/** @deprecated */\n// eslint-disable-next-line @typescript-eslint/no-deprecated\nfunction deprecated_transformAdvancedOptions(find: FindUnitAdvancedOptions): Omit<FindUnitAdvancedOptions, keyof DeprecatedFindUnitAdvancedOptions> {\n\n  // return option if it's a modern option\n  if ('items' in find || !('find' in find)) return find\n\n  // handle deprecated option\n  // use deprecated 'find' member as modern 'items' member\n  // return modern option based on deprecated option\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const { find: items, base } = find\n  return { items, base }\n\n}\n\nexport function createFindTable(find: AllowNullish<DeclarativeFindUnit>, defaultItems: ExponentFindItems, validateItems: (items: ExponentFindItems) => ExponentFindItems): MultiplierFindItems {\n\n  // return default table if \"find\" option is null or undefined\n  if (isNullish(find)) return transformFindItems(defaultItems, 1000)\n\n  // use find option as base if it's a number\n  if (isNumber(find)) return transformFindItems(defaultItems, find)\n\n  // use find option as items if it's an array\n  if (isArray(find)) return transformFindItems(validateItems(find), 1000)\n\n  // throw if find option is not an object at this point\n  if (!isObject(find)) throw errorInvalidOption('find')\n\n  // get items and base from find option\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const { items, base } = deprecated_transformAdvancedOptions(find)\n\n  // normalize base\n  const normalizedBase = base ?? 1000\n\n  // return default items with given base if no items provided\n  if (isNullish(items)) return transformFindItems(defaultItems, normalizedBase)\n\n  // TODO: Throw more descriptive error\n  // throw if items is not an array at this point\n  if (!isArray(items)) throw errorInvalidOption('find')\n\n  // return items based on option\n  return transformFindItems(validateItems(items), normalizedBase)\n\n}\n","import { MICRO } from './constants'\nimport type { ExponentFindItem } from './types'\n\nexport const exa: ExponentFindItem = { pre: 'E', exp: 6 }\nexport const peta: ExponentFindItem = { pre: 'P', exp: 5 }\nexport const tera: ExponentFindItem = { pre: 'T', exp: 4 }\nexport const giga: ExponentFindItem = { pre: 'G', exp: 3 }\nexport const mega: ExponentFindItem = { pre: 'M', exp: 2 }\nexport const kilo: ExponentFindItem = { pre: 'k', exp: 1 }\nexport const milli: ExponentFindItem = { pre: 'm', exp: -1 }\nexport const micro: ExponentFindItem = { pre: MICRO, exp: -2 }\nexport const nano: ExponentFindItem = { pre: 'n', exp: -3 }\nexport const pico: ExponentFindItem = { pre: 'p', exp: -4 }\nexport const femto: ExponentFindItem = { pre: 'f', exp: -5 }\nexport const atto: ExponentFindItem = { pre: 'a', exp: -6 }\n","import { error } from './error'\nimport type { ExponentFindItem, ExponentFindItems } from './types'\n\nexport function noDuplicates(items: ExponentFindItems, key: keyof ExponentFindItem, str: string): ExponentFindItems {\n\n  const { length } = items\n\n  for (let i1 = 0; i1 < length - 1; i1++) {\n    const iut = items[i1][key]\n    for (let i2 = i1 + 1; i2 < length; i2++) {\n      if (items[i2][key] === iut) throw error(`Duplicated ${str} (${iut})`)\n    }\n  }\n\n  return items\n\n}\n","import { noDuplicates } from '../common/no-duplicates'\nimport type { ExponentFindItems } from '../common/types'\n\nexport function validateFormatItems(items: ExponentFindItems): ExponentFindItems {\n\n  // validate items\n  // will throw on duplicated exponent\n  const validated = noDuplicates(\n    items,\n    'exp',\n    'exponent',\n  )\n\n  // return sorted items\n  return validated.sort((a, b) => b.exp - a.exp)\n\n}\n","import { atto, exa, femto, giga, kilo, mega, micro, milli, nano, peta, pico, tera } from '../common/exp-items'\nimport type { MultiplierFindItem } from '../common/types'\nimport { validateFormatItems } from './user-items'\n\nexport const unity: MultiplierFindItem = { pre: '', mul: 1 }\n\nexport const defaultBase1000FormatExpItems = validateFormatItems([\n  exa,\n  peta,\n  tera,\n  giga,\n  mega,\n  kilo,\n  { exp: 0, pre: '' },\n  milli,\n  micro,\n  nano,\n  pico,\n  femto,\n  atto,\n])\n","import { error, rangeError } from '../common/error'\nimport { createFindTable } from '../common/find-table'\nimport { isFiniteNumber, isFunction, isNullish, isNumber, isObject } from '../common/is'\nimport type { MultiplierFindItem } from '../common/types'\nimport type { DivisorFindItem } from '../deprecated-types'\nimport { defaultBase1000FormatExpItems } from './default-items'\nimport type { FormatFindUnitFunction, FormatFindUnitOption } from './types'\nimport { validateFormatItems } from './user-items'\n\n/** @deprecated */\n// eslint-disable-next-line @typescript-eslint/no-deprecated\nfunction deprecated_handleResult(item: MultiplierFindItem | DivisorFindItem): MultiplierFindItem {\n\n  // return item if it's modern item\n  if ('mul' in item) return item\n\n  // use deprecated 'div' member as modern 'mul' member\n  // return modern item based on deprecated item\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const { pre, div: mul } = item\n  return { pre, mul }\n\n}\n\nexport function createUnitFinder(find: FormatFindUnitOption): FormatFindUnitFunction {\n\n  // return wrapped user function if option it's a function\n  // wrap function to test for result validity\n  if (isFunction(find)) return (value) => {\n\n    // call user function\n    const result = find(value)\n\n    // return undefined if user function returns nullish\n    if (isNullish(result)) return\n\n    // throw if user function return non-object\n    if (!isObject(result)) throw error(`${result} is not a valid return value for \"find\" option`)\n\n    // normalize result for deprecated result\n    // get prefix and multiplier\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    const { pre, mul } = deprecated_handleResult(result)\n\n    // throw if multiplier is invalid\n    if (!isNumber(mul) || !isFiniteNumber(mul) || mul <= 0) throw rangeError(`${mul} is not a valid multiplier`)\n\n    // return prefix and multiplier\n    return { pre, mul }\n\n  }\n\n  // create find table\n  const findTable = createFindTable(\n    find,\n    defaultBase1000FormatExpItems,\n    validateFormatItems,\n  )\n\n  // get table array length\n  const { length: itemsLength } = findTable\n\n  // always return null if no table items\n  if (itemsLength === 0) return () => null\n\n  return (value) => {\n\n    // return undefined if value equals zero\n    if (value === 0) return\n\n    // get absolute value\n    const absolute = Math.abs(value)\n\n    // iterate through table skipping last item (smallest unit)\n    const lastIndex = itemsLength - 1\n    for (let i = 0; i < lastIndex; i++) {\n      const item = findTable[i]\n      if (absolute >= item.mul) return item\n    }\n\n    // return smallest unit if it couldn't be found\n    return findTable[lastIndex]\n\n  }\n\n}\n","import { errorInvalidOption, rangeError } from '../common/error'\nimport { isFiniteNumber, isFunction, isNullish, isNumber, isObject } from '../common/is'\nimport type { FormatOutputFunction, FormatOutputOption } from './types'\n\nfunction createFormatterFromOptions(space: string): FormatOutputFunction {\n  return (value, pre, unit) => {\n    const wholeUnit = `${pre}${unit}`\n    const spacedUnit = wholeUnit ? `${space}${wholeUnit}` : ''\n    return `${value}${spacedUnit}`\n  }\n}\n\nconst oneSpace = ' '\n\nexport function createOutputFormatter(output: FormatOutputOption): FormatOutputFunction {\n\n  // return default formatter\n  if (isNullish(output)) return createFormatterFromOptions(oneSpace)\n\n  // return wrapped function if it's a function to ensure it returns a string\n  if (isFunction(output)) {\n    return (value, pre, unit) => {\n\n      // call user function\n      const formatted = output(value, pre, unit)\n\n      // return user function result as string\n      return `${formatted as never}`\n\n    }\n  }\n\n  // throw if option is not an object at this point\n  if (!isObject(output)) throw errorInvalidOption('output')\n\n  // get option members\n  const { space } = output\n\n  // if space member is a number\n  if (isNumber(space)) {\n\n    // throw if it's invalid number of spaces\n    if (!isFiniteNumber(space) || space < 0) throw rangeError(`Can't format output with ${space} spaces`)\n\n    // return formatter with given number of spaces\n    const spaceString = oneSpace.repeat(space)\n    return createFormatterFromOptions(spaceString)\n\n  }\n\n  // normalize space\n  const normalizedSpace = space ?? oneSpace\n\n  // return formatter base on advanced options\n  return createFormatterFromOptions(normalizedSpace)\n\n}\n","import { errorInvalidOption, rangeError } from '../common/error'\nimport { isFiniteNumber, isFunction, isNullish, isNumber, isObject } from '../common/is'\nimport type { AllowNullish } from '../common/private-types'\nimport type { FormatRoundOption, RoundFunction } from './types'\n\nfunction validateNumberOfDecimals(dec: number): number {\n\n  // throw if number of decimals is invalid\n  if (!isFiniteNumber(dec) || dec < 0) throw rangeError(`Can't create round function with ${dec} decimal.`)\n\n  // return valid number of decimals\n  return dec\n\n}\n\nexport function createRounderFromOptions(dec: number, fixed?: AllowNullish<boolean>): RoundFunction {\n\n  // return fixed rounder function if fixed member set\n  if (fixed) return (num: number): string => {\n    return num.toFixed(dec)\n  }\n\n  // compute round multiplier\n  const roundMultiplier = 10 ** dec\n\n  // return regular rounder function\n  return (num: number): number => {\n    return Math.round(num * roundMultiplier) / roundMultiplier\n  }\n\n}\n\nexport function createRounder(round: FormatRoundOption): RoundFunction {\n\n  // return default rounder if round option is nullish\n  if (isNullish(round) || round === true) return createRounderFromOptions(2)\n\n  // return user option if it's a function\n  if (isFunction(round)) return round\n\n  // return rounder with round option as number of decimals if it's a number\n  if (isNumber(round)) return createRounderFromOptions(\n    validateNumberOfDecimals(round),\n  )\n\n  if (round === false) return (n) => n\n\n  // throw if round option is not an object at this point\n  if (!isObject(round)) throw errorInvalidOption('round')\n\n  // get members from advanced round option\n  const { dec, fixed } = round\n\n  if (isNullish(dec)) return createRounderFromOptions(2, fixed)\n\n  // TODO: throw more descriptive error\n  // throw if dec member is not a number\n  if (!isNumber(dec)) throw errorInvalidOption('round')\n\n  // return rounder based on advanced options\n  return createRounderFromOptions(\n    validateNumberOfDecimals(dec),\n    fixed,\n  )\n\n}\n","import { isFiniteNumber, isFunction, isNullish } from '../common/is'\nimport { validateOptions } from '../common/validate-options'\nimport type { DeprecatedFormatGetUnitFunction } from '../deprecated-types'\nimport { removedFormatterOptions, validFormatterOptions } from './constants'\nimport { createUnitFinder } from './find-unit'\nimport { createOutputFormatter } from './output'\nimport { createRounder } from './round'\nimport type { CreateFormatterOptions, CreateFormatterOptionsWithoutUnit, CreateFormatterOptionsWithUnit, Formatter, FormatUnitOption } from './types'\n\n/** @deprecated */\n// eslint-disable-next-line @typescript-eslint/no-deprecated\nfunction deprecated_createGetUnit(unit: FormatUnitOption | DeprecatedFormatGetUnitFunction): DeprecatedFormatGetUnitFunction {\n\n  // return unit option if it's a function (deprecated)\n  if (isFunction(unit)) return unit\n\n  // return a function returning normalized unit\n  const normalizedUnit = unit ?? ''\n  return () => normalizedUnit\n\n}\n\n/**\n * Create a formatter function\n *\n * @param options create formatter options\n */\nexport function createFormatter(options: CreateFormatterOptionsWithoutUnit): Formatter\nexport function createFormatter<U extends FormatUnitOption>(options: CreateFormatterOptionsWithUnit<U>): Formatter\nexport function createFormatter(options?: CreateFormatterOptions): Formatter\nexport function createFormatter(options: CreateFormatterOptions = {}): Formatter {\n\n  const validOptions = validateOptions(\n    options,\n    validFormatterOptions,\n    removedFormatterOptions,\n  )\n\n  const { unit, find, round, output } = validOptions\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const getUnit = deprecated_createGetUnit(unit)\n  const findUnit = createUnitFinder(find)\n  const roundNum = createRounder(round)\n  const formatOutput = createOutputFormatter(output)\n\n  const formatWithPre = (value: number, pre: string) => {\n    const rounded = roundNum(value)\n    const computedUnit = getUnit(value, rounded, pre)\n    return formatOutput(\n      rounded,\n      pre,\n      computedUnit,\n    )\n  }\n\n  return (value: number): string => {\n\n    // return value as string if it's not finite\n    if (!isFiniteNumber(value)) return `${value}`\n\n    // find unit\n    const item = findUnit(value)\n\n    // return formatted value * 1 if can't find prefix and multiplier\n    if (isNullish(item)) return formatWithPre(value, '')\n\n    // get prefix and multiplier\n    const { pre, mul: divisor } = item\n\n    // return formatted value\n    return formatWithPre(value / divisor, pre)\n\n  }\n\n}\n","import { createFormatter } from './create-formatter'\nimport type { CreateFormatterOptions, CreateFormatterOptionsWithoutUnit, CreateFormatterOptionsWithUnit, FormatUnitOption } from './types'\n\nexport function format(value: number, options: CreateFormatterOptionsWithoutUnit): string\nexport function format<U extends FormatUnitOption>(value: number, options?: CreateFormatterOptionsWithUnit<U>): string\nexport function format(value: number, options?: CreateFormatterOptions): string\nexport function format(value: number, options?: CreateFormatterOptions): string {\n  const formatter = createFormatter(options)\n  return formatter(value)\n}\n","import type { CreateParserOptions } from './types'\n\ntype CreateParserValidOptionName = keyof CreateParserOptions\ntype CreateParserRemovedOptionName = 'table'\n\nexport const validParserOptions: CreateParserValidOptionName[] = ['unit', 'match', 'find']\n\nexport const removedParserOptions: Record<CreateParserRemovedOptionName, CreateParserValidOptionName> = {\n  table: 'find',\n}\n","import type { ParseUnitOption } from './types'\n\ntype ExtractPrefixFunction = (wholeUnit: string) => string\n\nexport function createExtractPre(unit: ParseUnitOption): ExtractPrefixFunction {\n\n  if (unit) return (wholeUnit) => {\n\n    // return prefix if whole unit ends with unit\n    if (wholeUnit.endsWith(unit)) {\n      const { length: unitLength } = unit\n      return wholeUnit.slice(0, -unitLength)\n    }\n\n    // return whole unit as prefix\n    return wholeUnit\n\n  }\n\n  // return whole unit as prefix\n  return (wholeUnit) => wholeUnit\n\n}\n","import { noDuplicates } from '../common/no-duplicates'\nimport { ExponentFindItems } from '../common/types'\n\nexport function validateParseItems(items: ExponentFindItems): ExponentFindItems {\n\n  // validate items\n  // will throw on duplicated prefix\n  return noDuplicates(\n    items,\n    'pre',\n    'prefix',\n  )\n\n}\n","import { atto, exa, femto, giga, kilo, mega, micro, milli, nano, peta, pico, tera } from '../common/exp-items'\nimport { validateParseItems } from './user-items'\n\nexport const defaultBase1000ParseExpItems = validateParseItems([\n  exa,\n  peta,\n  tera,\n  giga,\n  { pre: 'meg', exp: 2 },\n  mega,\n  { pre: 'K', exp: 1 },\n  kilo,\n  milli,\n  { pre: 'u', exp: -2 },\n  micro,\n  nano,\n  pico,\n  femto,\n  atto,\n])\n","import { error, rangeError } from '../common/error'\nimport { createFindTable } from '../common/find-table'\nimport { isFiniteNumber, isFunction, isNullish, isNumber, isObject } from '../common/is'\nimport { defaultBase1000ParseExpItems } from './default-items'\nimport type { ParseFindMultiplierFunction, ParseFindMultiplierOption } from './types'\nimport { validateParseItems } from './user-items'\n\nexport function createMulFinder(find: ParseFindMultiplierOption): ParseFindMultiplierFunction {\n\n  // return wrapped function if find option is a function\n  // wrap function test for result validity\n  if (isFunction(find)) return (prefix, unit) => {\n\n    // find multiplier\n    const result = find(prefix, unit)\n\n    // return undefined if no multiplier found (null | undefined)\n    if (isNullish(result)) return\n\n    // TODO: remove if future version\n    // this feature was removed in version 0.1.0\n    // throw error for removed feature\n    if (isObject(result)) throw error('Function returning object is no longer supported, return a non-zero positive number, null or undefined.')\n\n    // throw if multiplier is not valid\n    if (!isNumber(result) || !isFiniteNumber(result) || result <= 0) throw rangeError(`${result} is not a valid multiplier`)\n\n    // return multiplier\n    return result\n\n  }\n\n  // create find table\n  const findTable = createFindTable(\n    find,\n    defaultBase1000ParseExpItems,\n    validateParseItems,\n  )\n\n  // return function returning null if there are no items to search\n  if (findTable.length === 0) return () => null\n\n  // return multiplier finder function\n  return (prefix: string) => {\n\n    // return 1 as multiplier if captured prefix is empty\n    if (!prefix) return 1\n\n    const item = findTable.find(({ pre }) => pre === prefix)\n\n    // return undefined if not multiplier found\n    if (!item) return\n\n    // return multiplier\n    return item.mul\n\n  }\n\n}\n","import { error } from '../common/error'\nimport { isArray, isFunction, isNullish } from '../common/is'\nimport type { InputMatchResults, MatchFunction, ParseMatchOption } from './types'\n\nexport function createMatcher(match: ParseMatchOption): MatchFunction {\n\n  // return wrapped function if match option is a function\n  // wrap function to test for result validity\n  if (isFunction(match)) return (input) => {\n\n    // call user function\n    const captured = match(input)\n\n    // return undefined if nullish return by user function\n    if (isNullish(captured)) {\n      return\n    }\n\n    // throw if it's not an array\n    if (!isArray(captured)) {\n      throw error('Match function should return an array of strings')\n    }\n\n    // return array\n    // array validation will happen later\n    return captured\n\n  }\n\n  // create regular expression based on option\n  const re = isNullish(match)\n    ? /^\\s*(-?\\d*\\.?\\d*(?:e[+-]?\\d+)?)\\s*([a-z\\xb5]*)\\s*$/i\n    : new RegExp(match)\n\n  // return input match function\n  return (input) => {\n\n    // execute RegExp against input\n    const result = re.exec(input)\n\n    // return undefined if it doesn't match\n    if (!result) return\n\n    // get a slice of the result array containing the captured groups only\n    const resultAsArray = result.slice(1)\n\n    // return array\n    // array validation will happen later\n    return resultAsArray as InputMatchResults\n\n  }\n\n}\n","import { error } from '../common/error'\nimport { isFiniteNumber, isNullish, isNumber } from '../common/is'\nimport { validateOptions } from '../common/validate-options'\nimport { removedParserOptions, validParserOptions } from './constants'\nimport { createExtractPre } from './extract-pre'\nimport { createMulFinder } from './find-multiplier'\nimport { createMatcher } from './match'\nimport type { CreateParserOptions, CreateParserOptionsWithoutUnit, CreateParserOptionsWithUnit, ParseInput, Parser, ParseUnitOption } from './types'\n\n/**\n * Create a parser function\n *\n * @param options create parser options\n */\nexport function createParser(options: CreateParserOptionsWithoutUnit): Parser\nexport function createParser<U extends ParseUnitOption>(options: CreateParserOptionsWithUnit<U>): Parser\nexport function createParser(options?: CreateParserOptionsWithUnit<ParseUnitOption> | CreateParserOptionsWithoutUnit): Parser\nexport function createParser(options: CreateParserOptionsWithUnit<ParseUnitOption> | CreateParserOptionsWithoutUnit = {}): Parser {\n\n  // validate options\n  const validOptions = validateOptions(\n    options as CreateParserOptions,\n    validParserOptions,\n    removedParserOptions,\n  )\n\n  const { unit, match, find } = validOptions\n\n  const extractPre = createExtractPre(unit)\n  const findMultiplier = createMulFinder(find)\n  const matchInput = createMatcher(match)\n\n  // return parser function\n  return (input: ParseInput): number => {\n\n    // if input is of type number (number, NaN or Infinity)\n    if (isNumber(input)) {\n\n      // return the number if it's finite (number)\n      if (isFiniteNumber(input)) return input\n\n      // return NaN otherwise (NaN or Infinity)\n      return NaN\n\n    }\n\n    // return NaN if input is falsy (false, '', null or undefined) or true\n    if (!input || input === true) return NaN\n\n    // convert input (probably non-empty string or object) to string\n    const inputAsString = `${input as never}`\n\n    // return NaN if input as string is empty ('')\n    if (!inputAsString) return NaN\n\n    // convert string to number\n    const inputAsNumber = +inputAsString\n\n    // return number if string as number is finite (not NaN or Infinity)\n    if (isFiniteNumber(inputAsNumber)) return inputAsNumber\n\n    // capture value and unit from string\n    const captured = matchInput(inputAsString)\n\n    // return NaN if can't capture value and unit\n    if (!captured) return NaN\n\n    // get captured array length\n    const { length } = captured as string[]\n\n    // throw if captured array has less that 2 items\n    if (length < 2) throw error(`Match result array should have 2 items, got ${length}`)\n\n    // get value and unit from captured array\n    const [capturedValueAsString, wholeUnit] = captured\n\n    // return NaN if captured value is empty string ('')\n    if (!capturedValueAsString) return NaN\n\n    // convert captured value to number\n    const capturedValueAsNumber = +capturedValueAsString\n\n    // return NaN if captured value as number is not finite\n    if (!isFiniteNumber(capturedValueAsNumber)) return NaN\n\n    // extract prefix from whole unit\n    const pre = extractPre(wholeUnit)\n\n    // try to find find multiplier\n    const multiplier = findMultiplier(pre, unit)\n\n    // return NaN if can't find multiplier\n    if (isNullish(multiplier)) return NaN\n\n    // return parsed value\n    return capturedValueAsNumber * multiplier\n\n  }\n\n}\n","import { createParser } from './create-parser'\nimport type { CreateParserOptionsWithoutUnit, CreateParserOptionsWithUnit, ParseInput, ParseUnitOption } from './types'\n\n/**\n * Parse value in one step\n *\n * @param input input to parse\n * @param options parser options\n * @returns parsed value or NaN if it can't be parsed\n */\nexport function parse(input: ParseInput, options: CreateParserOptionsWithoutUnit): number\nexport function parse<U extends ParseUnitOption>(input: ParseInput, options: CreateParserOptionsWithUnit<U>): number\nexport function parse(input: ParseInput, options?: CreateParserOptionsWithUnit<ParseUnitOption> | CreateParserOptionsWithoutUnit): number\nexport function parse(input: ParseInput, options?: CreateParserOptionsWithUnit<ParseUnitOption> | CreateParserOptionsWithoutUnit): number {\n  const parser = createParser(options)\n  return parser(input)\n}\n"],"names":["MICRO","isNullish","value","isType","type","isNumber","isObject","isFunction","isArray","Array","isFiniteNumber","Number","isFinite","error","message","TypeError","rangeError","RangeError","errorInvalidOption","optionName","validateOptions","options","valid","removed","optionsNames","Object","keys","removedOptionNames","removedOptionName","find","includes","unknownOptionName","validFormatterOptions","removedFormatterOptions","table","dec","fixed","transformFindItems","items","base","map","_ref","pre","exp","mul","deprecated_transformAdvancedOptions","createFindTable","defaultItems","validateItems","normalizedBase","exa","peta","tera","giga","mega","kilo","milli","micro","nano","pico","femto","atto","noDuplicates","key","str","length","i1","iut","i2","validateFormatItems","validated","sort","a","b","defaultBase1000FormatExpItems","deprecated_handleResult","item","div","createUnitFinder","result","findTable","itemsLength","absolute","Math","abs","lastIndex","i","createFormatterFromOptions","space","unit","wholeUnit","spacedUnit","oneSpace","createOutputFormatter","output","formatted","spaceString","repeat","normalizedSpace","validateNumberOfDecimals","createRounderFromOptions","num","toFixed","roundMultiplier","round","createRounder","n","deprecated_createGetUnit","normalizedUnit","createFormatter","validOptions","getUnit","findUnit","roundNum","formatOutput","formatWithPre","rounded","computedUnit","divisor","format","formatter","validParserOptions","removedParserOptions","createExtractPre","endsWith","unitLength","slice","validateParseItems","defaultBase1000ParseExpItems","createMulFinder","prefix","createMatcher","match","input","captured","re","RegExp","exec","resultAsArray","createParser","extractPre","findMultiplier","matchInput","NaN","inputAsString","inputAsNumber","capturedValueAsString","capturedValueAsNumber","multiplier","parse","parser"],"mappings":"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"}