fix: Throw correct type of error

* throw RangeError on range errors

__test__/format/find-option.test.ts

@@ -354,7 +354,7 @@ describe('format "find" option', () => {
 
     });
 
-    test('Should throw on invalid find function result multiplier', () => {
+    test('Should throw on invalid find function resulting multiplier', () => {
 
       const values = [
         { pre: '', mul: 0 },
@@ -370,6 +370,7 @@ describe('format "find" option', () => {
           find: () => value,
         });
 
+        expect(() => format(10)).toThrow(RangeError);
         expect(() => format(10)).toThrow('is not a valid multiplier');
 
       });

__test__/format/output-option.test.ts

@@ -70,6 +70,7 @@ describe('format "output" option', () => {
 
       invalidSpaces.forEach((space) => {
         const create = () => createFormatter({ output: { space } });
+        expect(create).toThrow(RangeError);
         expect(create).toThrow('Can\'t format output with');
       });
 

__test__/format/round-option.test.ts

@@ -34,6 +34,7 @@ describe('format "round" option', () => {
       const create = () => createFormatter({
         round: invalid,
       });
+      expect(create).toThrow(RangeError);
       expect(create).toThrow('Can\'t create round function with');
     });
 
@@ -109,6 +110,7 @@ describe('format "round" option', () => {
             dec: invalid,
           },
         });
+        expect(create).toThrow(RangeError);
         expect(create).toThrow('Can\'t create round function with');
       });
 

__test__/parse/find-option.test.ts

@@ -125,7 +125,7 @@ describe('parse "find" option', () => {
             items: invalid as never,
           },
         });
-        expect(create).toThrow();
+        expect(create).toThrow('Invalid "find" option');
       });
 
     });
@@ -374,12 +374,11 @@ describe('parse "find" option', () => {
       ];
 
       invalidMultipliers.forEach((invalid) => {
-
         const parse = createParser({
           find: () => invalid as never,
         });
+        expect(() => parse('10 k')).toThrow(RangeError);
         expect(() => parse('10 k')).toThrow('is not a valid multiplier');
-
       });
 
     });
@@ -417,7 +416,9 @@ describe('parse "find" option', () => {
     ];
 
     invalidFindOptions.forEach((options) => {
-      expect(() => createParser({ find: options })).toThrow('is not a valid multiplier');
+      const create = () => createParser({ find: options });
+      expect(create).toThrow(RangeError);
+      expect(create).toThrow('is not a valid multiplier');
     });
 
   });

src/common/error.ts

@@ -2,6 +2,10 @@ export function error(message: string) {
   return new TypeError(message);
 }
 
+export function rangeError(message: string) {
+  return new RangeError(message);
+}
+
 export function errorInvalidOption(option: string) {
   return error(`Invalid "${option}" option`);
 }

src/common/transform-items.ts

@@ -1,12 +1,12 @@
 import { isFiniteNumber } from '../tools/is';
-import { error } from './error';
+import { rangeError } from './error';
 import type { ExponentFindItems, MultiplierFindItems } from './types';
 
 export function transformFindItems(items: ExponentFindItems, base: number): MultiplierFindItems {
   return items.map(({ pre, exp }) => {
     const mul = base ** exp;
     if (!isFiniteNumber(mul) || mul <= 0) {
-      throw error(`${base} to the power of ${exp} is not a valid multiplier`);
+      throw rangeError(`${base} to the power of ${exp} is not a valid multiplier`);
     }
     return { pre, mul };
   });

src/format/find-unit.ts

@@ -1,4 +1,4 @@
-import { error } from '../common/error';
+import { error, rangeError } from '../common/error';
 import { createFindTable } from '../common/find-table';
 import { MultiplierFindItem } from '../common/types';
 import { isFiniteNumber, isFunction, isNumber, isObject } from '../tools/is';
@@ -31,7 +31,7 @@ export function createUnitFinder(find: FormatFindUnitOption): FormatFindUnitFunc
       const { pre, mul } = deprecated_handleResult(result);
 
       if (!isNumber(mul) || !isFiniteNumber(mul) || mul <= 0) {
-        throw error(`${mul} is not a valid multiplier`);
+        throw rangeError(`${mul} is not a valid multiplier`);
       }
 
       return { pre, mul };

src/format/output.ts

@@ -1,4 +1,4 @@
-import { error, errorInvalidOption } from '../common/error';
+import { errorInvalidOption, rangeError } from '../common/error';
 import { isFiniteNumber, isFunction, isNumber, isObject } from '../tools/is';
 import type { FormatOutputFunction, FormatOutputOption } from './types';
 
@@ -34,7 +34,7 @@ export function createFormatOutput(output: FormatOutputOption): FormatOutputFunc
 
   if (isNumber(space)) {
     if (!isFiniteNumber(space) || space < 0) {
-      throw error(`Can't format output with ${space} spaces`);
+      throw rangeError(`Can't format output with ${space} spaces`);
     }
     return createOutputFormatter(oneSpace.repeat(space));
   }

src/format/round.ts

@@ -1,11 +1,11 @@
-import { error, errorInvalidOption } from '../common/error';
+import { errorInvalidOption, rangeError } from '../common/error';
 import type { AllowNullish } from '../tools/helper-types';
 import { isFiniteNumber, isFunction, isNumber, isObject } from '../tools/is';
 import type { FormatRoundOption, RoundFunction } from './types';
 
 function validateNumberOfDecimals(dec: number): number {
   if (!isFiniteNumber(dec) || dec < 0) {
-    throw error(`Can't create round function with ${dec} decimal.`);
+    throw rangeError(`Can't create round function with ${dec} decimal.`);
   }
   return dec;
 }

src/parse/find-multiplier.ts

@@ -1,4 +1,4 @@
-import { error } from '../common/error';
+import { error, rangeError } from '../common/error';
 import { createFindTable } from '../common/find-table';
 import { isFiniteNumber, isFunction, isNumber, isObject } from '../tools/is';
 import { defaultBase1000ParseExpItems } from './default-items';
@@ -31,7 +31,7 @@ export function createMulFinder(find: ParseFindMultiplierOption): ParseFindMulti
       }
 
       if (!isNumber(result) || !isFiniteNumber(result) || result <= 0) {
-        throw error(`${result} is not a valid multiplier`);
+        throw rangeError(`${result} is not a valid multiplier`);
       }
 
       return result;