@radham/utils 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+Changelog
+=========
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+[0.1.0] - 2026-02-08
+--------------------
+
+### Added
+
+- Initial release.
+
+[0.1.0]: https://github.com/jbenner-radham/node-utils/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, James Benner
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,152 @@
+@radham/utils
+=============
+
+A small bespoke utility library.
+
+Install
+-------
+
+...
+
+Usage
+-----
+
+### attempt
+
+Executes a function and returns its result, or `undefined` if it throws.
+
+```typescript
+import { attempt } from '@radham/utils';
+
+attempt(() => JSON.parse('{"a":1}')); // { a: 1 }
+attempt(() => JSON.parse('invalid')); // undefined
+```
+
+### capitalize
+
+Capitalizes the first character of a string.
+
+```typescript
+import { capitalize } from '@radham/utils';
+
+capitalize('hello'); // 'Hello'
+```
+
+### compose
+
+Composes multiple functions into a single function that applies them from left to right.
+
+```typescript
+import { compose } from '@radham/utils';
+
+const addOne = (value: number) => value + 1;
+const double = (value: number) => value * 2;
+
+compose(addOne, double)(3); // 8
+```
+
+### isNumber
+
+Checks whether the given value is a number.
+
+```typescript
+import { isNumber } from '@radham/utils';
+
+isNumber(42);                         // true
+isNumber('42');                       // false
+isNumber(NaN);                        // true
+isNumber(NaN, { finite: true });      // false
+isNumber(Infinity, { finite: true }); // false
+```
+
+### isNumberLike
+
+Checks whether the given value is a number or can be coerced to one.
+
+```typescript
+import { isNumberLike } from '@radham/utils';
+
+isNumberLike(42);                           // true
+isNumberLike('42');                         // true
+isNumberLike('3.14');                       // true
+isNumberLike('NaN');                        // true
+isNumberLike('NaN', { finite: true });      // false
+isNumberLike('Infinity', { finite: true }); // false
+isNumberLike('abc');                        // false
+isNumberLike(null);                         // false
+isNumberLike(1n);                           // false
+isNumberLike(1n, { bigint: true });         // true
+isNumberLike('1n', { bigint: true });       // true
+```
+
+### isPlainObject
+
+Checks whether the given value is a plain object.
+
+```typescript
+import { isPlainObject } from '@radham/utils';
+
+isPlainObject({ a: 1 });  // true
+isPlainObject([1, 2, 3]); // false
+isPlainObject(null);      // false
+```
+
+### isString
+
+Checks whether the given value is a string.
+
+```typescript
+import { isString } from '@radham/utils';
+
+isString('hello'); // true
+isString(42);      // false
+```
+
+### omit
+
+Creates a new object with the specified keys omitted.
+
+```typescript
+import { omit } from '@radham/utils';
+
+omit({ a: 1, b: 2, c: 3 }, ['a', 'c']); // { b: 2 }
+omit({ a: 1, b: 2 }, 'a');              // { b: 2 }
+```
+
+### range
+
+Creates an array of numbers from `start` (inclusive) to `end` (exclusive).
+
+```typescript
+import { range } from '@radham/utils';
+
+range(4);    // [0, 1, 2, 3]
+range(2, 5); // [2, 3, 4]
+```
+
+### toString
+
+Converts a value to its string representation.
+
+```typescript
+import { toString } from '@radham/utils';
+
+toString(42);        // '42'
+toString(null);      // 'null'
+toString(undefined); // 'undefined'
+```
+
+### unique
+
+Returns a new array with duplicate values removed.
+
+```typescript
+import { unique } from '@radham/utils';
+
+unique([1, 2, 2, 3, 1]); // [1, 2, 3]
+```
+
+License
+-------
+
+The BSD 3-Clause License. See the [license file](LICENSE) for details.

package/dist/cjs/index.js

@@ -0,0 +1,2 @@
+"use strict";var a=Object.defineProperty;var N=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var w=Object.prototype.hasOwnProperty;var k=(e,t)=>{for(var r in t)a(e,r,{get:t[r],enumerable:!0})},S=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of T(t))!w.call(e,i)&&i!==r&&a(e,i,{get:()=>t[i],enumerable:!(n=N(t,i))||n.enumerable});return e};var O=e=>S(a({},"__esModule",{value:!0}),e);var h={};k(h,{attempt:()=>o,capitalize:()=>s,compose:()=>l,isNumber:()=>u,isNumberLike:()=>p,isPlainObject:()=>m,isString:()=>c,omit:()=>b,range:()=>d,toString:()=>g,unique:()=>y});module.exports=O(h);function o(e){try{return e()}catch{}}function s(e){return e.charAt(0).toUpperCase()+e.slice(1)}function l(...e){return t=>e.reduce((r,n)=>n(r),t)}function u(e,t){return typeof e=="number"&&(!t?.finite||Number.isFinite(e))}function p(e,t){if(typeof e=="bigint")return!!t?.bigint;if(typeof e=="string"&&t?.bigint)return!!(o(()=>BigInt(e))??!1);if(typeof e=="string"&&["-Infinity","Infinity","NaN"].includes(e))return!t?.finite;let n=["",!1,null],i=[!0];if(n.includes(e)||i.includes(e))return!1;let f=Number(e);return typeof e!="number"&&Number.isNaN(f)?!1:u(f,t)}function m(e){if(typeof e!="object"||e===null)return!1;let t=Object.getPrototypeOf(e);return t!==null&&t!==Object.prototype?!1:!Object.hasOwn(e,Symbol.toStringTag)}function c(e){return typeof e=="string"}function b(e,t){let r=Array.isArray(t)?t:[t];return Object.fromEntries(Object.entries(e).filter(([n])=>!r.includes(n)))}function d(e,t){let r=t===void 0?0:e,n=t??e;if(!Number.isInteger(r)||!Number.isInteger(n))throw new TypeError(`Expected integer arguments, received start (${r}), and end (${n}).`);let i=n-r;if(i<0)throw new RangeError(`Invalid range: start (${r}) must not be greater than end (${n}).`);return Array.from({length:i},(f,x)=>r+x)}function g(e){return e?.toString?.()??String(e)}function y(e){return e.filter((t,r)=>e.indexOf(t)===r)}
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts", "../../src/attempt.ts", "../../src/capitalize.ts", "../../src/compose.ts", "../../src/is-number.ts", "../../src/is-number-like.ts", "../../src/is-plain-object.ts", "../../src/is-string.ts", "../../src/omit.ts", "../../src/range.ts", "../../src/to-string.ts", "../../src/unique.ts"],
+  "sourcesContent": ["export { default as attempt } from './attempt.js';\nexport { default as capitalize } from './capitalize.js';\nexport { default as compose } from './compose.js';\nexport { default as isNumber } from './is-number.js';\nexport { default as isNumberLike } from './is-number-like.js';\nexport { default as isPlainObject } from './is-plain-object.js';\nexport { default as isString } from './is-string.js';\nexport { default as omit } from './omit.js';\nexport { default as range } from './range.js';\nexport { default as toString } from './to-string.js';\nexport { default as unique } from './unique.js';\n", "/**\n * Executes a function and returns its result, or `undefined` if it throws.\n *\n * @param callback - The function to execute.\n * @returns The return value of `callback`, or `undefined` if an error is thrown.\n *\n * @example\n * ```typescript\n * attempt(() => JSON.parse('{\"a\":1}')); // { a: 1 }\n * attempt(() => JSON.parse('invalid')); // undefined\n * ```\n */\nexport default function attempt<T>(callback: () => T): T | undefined {\n  try {\n    return callback();\n  } catch { /* Do nothing. */ }\n}\n", "/**\n * Capitalizes the first character of a string.\n *\n * @param value - The string to capitalize.\n * @returns A new string with the first character in uppercase.\n *\n * @example\n * ```typescript\n * capitalize('hello'); // 'Hello'\n * ```\n */\nexport default function capitalize<T extends string>(value: T): Capitalize<T> {\n  return (value.charAt(0).toUpperCase() + value.slice(1)) as Capitalize<T>;\n}\n", "/**\n * Composes multiple functions into a single function that applies them from left to right.\n *\n * @param functions - The functions to compose, each taking and returning the same type.\n * @returns A function that pipes a value through each function in order.\n *\n * @example\n * ```typescript\n * const addOne = (value: number) => value + 1;\n * const double = (value: number) => value * 2;\n *\n * compose(addOne, double)(3); // 8\n * ```\n */\nexport default function compose<T>(...functions: Array<(value: T) => T>): (value: T) => T {\n  return (value: T) => functions.reduce((accumulator, fn) => fn(accumulator), value);\n}\n", "/**\n * Checks whether the given value is a number.\n *\n * @param value - The value to check.\n * @param options - Optional configuration.\n * @param options.finite - When `true`, only finite numbers are considered valid (`NaN` and\n *   `Infinity` return `false`).\n * @returns `true` if `value` is a number, `false` otherwise.\n *\n * @example\n * ```typescript\n * isNumber(42);                         // true\n * isNumber('42');                       // false\n * isNumber(NaN);                        // true\n * isNumber(NaN, { finite: true });      // false\n * isNumber(Infinity, { finite: true }); // false\n * ```\n */\nexport default function isNumber(\n  value: unknown, options?: { finite?: boolean }\n): value is number {\n  return typeof value === 'number' && (!options?.finite || Number.isFinite(value));\n}\n", "import attempt from './attempt.js';\nimport isNumber from './is-number.js';\n\n/**\n * Checks whether the given value is a number or can be coerced to one.\n *\n * @remarks\n * This function only considers actual numbers and strings that represent numbers as\n * number-like. Even though the values `''`, `false`, and `null` convert to `0`, and\n * `true` converts to `1`, none of these are considered number-like by this function.\n *\n * @param value - The value to check.\n * @param options - Optional configuration.\n * @param options.bigint - When `true`, bigints and strings that can be converted to\n *   bigints are considered valid.\n * @param options.finite - When `true`, only finite numbers are considered valid (`NaN`,\n *   `Infinity`, and their string equivalents return `false`).\n * @returns `true` if `value` is number-like, `false` otherwise.\n *\n * @example\n * ```typescript\n * isNumberLike(42);                           // true\n * isNumberLike('42');                         // true\n * isNumberLike('3.14');                       // true\n * isNumberLike('NaN');                        // true\n * isNumberLike('NaN', { finite: true });      // false\n * isNumberLike('Infinity', { finite: true }); // false\n * isNumberLike('abc');                        // false\n * isNumberLike(null);                         // false\n * isNumberLike(1n);                           // false\n * isNumberLike(1n, { bigint: true });         // true\n * isNumberLike('1n', { bigint: true });       // true\n * ```\n */\nexport default function isNumberLike(\n  value: unknown, options?: { bigint?: boolean; finite?: boolean }\n): value is number {\n  // `Number()` will coerce bigints to numbers, so we need to make this check.\n  if (typeof value === 'bigint') {\n    return Boolean(options?.bigint);\n  }\n\n  if (typeof value === 'string' && options?.bigint) {\n    return Boolean(attempt(() => BigInt(value)) ?? false);\n  }\n\n  const infiniteNumberStrings = ['-Infinity', 'Infinity', 'NaN'];\n\n  if (typeof value === 'string' && infiniteNumberStrings.includes(value)) {\n    return !options?.finite;\n  }\n\n  // These values are converted to `0` by `Number()`.\n  const falsyNumberValues = ['', false, null];\n\n  // These values are converted to `1` by `Number()`.\n  const truthyNumberValues = [true];\n\n  if (\n    falsyNumberValues.includes(value as boolean | null | string) ||\n    truthyNumberValues.includes(value as boolean)\n  ) {\n    return false;\n  }\n\n  const numberValue = Number(value);\n\n  if (typeof value !== 'number' && Number.isNaN(numberValue)) {\n    return false;\n  }\n\n  return isNumber(numberValue, options);\n}\n", "/**\n * Checks whether the given value is a plain object.\n *\n * @remarks\n * A plain object is one created by the `Object` constructor, a `null` prototype, or an object\n * literal.\n *\n * @param value - The value to check.\n * @returns `true` if `value` is a plain object, `false` otherwise.\n *\n * @example\n * ```typescript\n * isPlainObject({ a: 1 }); // true\n * isPlainObject([1, 2]);   // false\n * ```\n */\nexport default function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  const prototype = Object.getPrototypeOf(value) as unknown;\n\n  if (prototype !== null && prototype !== Object.prototype) {\n    return false;\n  }\n\n  // This is needed for `Atomics`, `Intl`, `JSON`, `Math`, and `Reflect`.\n  return !Object.hasOwn(value, Symbol.toStringTag);\n}\n", "/**\n * Checks whether the given value is a string.\n *\n * @param value - The value to check.\n * @returns `true` if `value` is a string, `false` otherwise.\n *\n * @example\n * ```typescript\n * isString('hello'); // true\n * isString(42);      // false\n * ```\n */\nexport default function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n", "/**\n * Creates a new object with the specified keys omitted.\n *\n * @param object - The source object to omit keys from.\n * @param omitted - A key or array of keys to exclude from the result.\n * @returns A new object containing all entries from `object` except those with keys in `omitted`.\n *\n * @example\n * ```typescript\n * omit({ a: 1, b: 2, c: 3 }, ['a', 'c']); // { b: 2 }\n * ```\n */\nexport default function omit(\n  object: Record<PropertyKey, unknown>, omitted: PropertyKey | PropertyKey[]\n) {\n  const omittedKeys = Array.isArray(omitted) ? omitted : [omitted];\n\n  return Object.fromEntries(\n    Object.entries(object).filter(([key]) => !omittedKeys.includes(key))\n  );\n}\n", "/**\n * Creates an array of integers from `start` (inclusive) to `end` (exclusive).\n *\n * @remarks\n * When called with a single argument, it generates a range from `0` to that value.\n *\n * @param startOrEnd - The start of the range if `maybeEnd` is provided, otherwise the end.\n * @param maybeEnd - The end of the range (exclusive). Must be greater than or equal to `start`.\n * @returns An array of sequential integers.\n *\n * @throws {@link TypeError} If either argument is not a finite integer.\n * @throws {@link RangeError} If `start` is greater than `end`.\n *\n * @example\n * ```typescript\n * range(4);    // [0, 1, 2, 3]\n * range(2, 5); // [2, 3, 4]\n * ```\n */\nexport default function range(startOrEnd: number, maybeEnd?: number): number[] {\n  const start = maybeEnd === undefined ? 0 : startOrEnd;\n  const end = maybeEnd ?? startOrEnd;\n\n  if (!Number.isInteger(start) || !Number.isInteger(end)) {\n    throw new TypeError(`Expected integer arguments, received start (${start}), and end (${end}).`);\n  }\n\n  const length = end - start;\n\n  if (length < 0) {\n    throw new RangeError(`Invalid range: start (${start}) must not be greater than end (${end}).`);\n  }\n\n  return Array.from({ length }, (_, index) => start + index);\n}\n", "/**\n * Converts a value to its string representation.\n *\n * @param value - The value to convert.\n * @returns The string representation of `value`.\n *\n * @example\n * ```typescript\n * toString(42);   // '42'\n * toString(null); // 'null'\n * ```\n */\nexport default function toString(value: unknown): string {\n  return value?.toString?.() ?? String(value);\n}\n", "/**\n * Returns a new array with duplicate values removed.\n *\n * @param array - The array to deduplicate.\n * @returns A new array containing only the first occurrence of each value.\n *\n * @example\n * ```typescript\n * unique([1, 2, 2, 3, 1]); // [1, 2, 3]\n * ```\n */\nexport default function unique<T>(array: T[]): T[] {\n  // NOTE: This benchmarks significantly better than `return [...new Set(array)]`.\n  return array.filter((item, index) => array.indexOf(item) === index);\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,aAAAE,EAAA,eAAAC,EAAA,YAAAC,EAAA,aAAAC,EAAA,iBAAAC,EAAA,kBAAAC,EAAA,aAAAC,EAAA,SAAAC,EAAA,UAAAC,EAAA,aAAAC,EAAA,WAAAC,IAAA,eAAAC,EAAAb,GCYe,SAARc,EAA4BC,EAAkC,CACnE,GAAI,CACF,OAAOA,EAAS,CAClB,MAAQ,CAAoB,CAC9B,CCLe,SAARC,EAA8CC,EAAyB,CAC5E,OAAQA,EAAM,OAAO,CAAC,EAAE,YAAY,EAAIA,EAAM,MAAM,CAAC,CACvD,CCCe,SAARC,KAA+BC,EAAoD,CACxF,OAAQC,GAAaD,EAAU,OAAO,CAACE,EAAaC,IAAOA,EAAGD,CAAW,EAAGD,CAAK,CACnF,CCEe,SAARG,EACLC,EAAgBC,EACC,CACjB,OAAO,OAAOD,GAAU,WAAa,CAACC,GAAS,QAAU,OAAO,SAASD,CAAK,EAChF,CCYe,SAARE,EACLC,EAAgBC,EACC,CAEjB,GAAI,OAAOD,GAAU,SACnB,MAAO,EAAQC,GAAS,OAG1B,GAAI,OAAOD,GAAU,UAAYC,GAAS,OACxC,MAAO,GAAQC,EAAQ,IAAM,OAAOF,CAAK,CAAC,GAAK,IAKjD,GAAI,OAAOA,GAAU,UAFS,CAAC,YAAa,WAAY,KAAK,EAEN,SAASA,CAAK,EACnE,MAAO,CAACC,GAAS,OAInB,IAAME,EAAoB,CAAC,GAAI,GAAO,IAAI,EAGpCC,EAAqB,CAAC,EAAI,EAEhC,GACED,EAAkB,SAASH,CAAgC,GAC3DI,EAAmB,SAASJ,CAAgB,EAE5C,MAAO,GAGT,IAAMK,EAAc,OAAOL,CAAK,EAEhC,OAAI,OAAOA,GAAU,UAAY,OAAO,MAAMK,CAAW,EAChD,GAGFC,EAASD,EAAaJ,CAAO,CACtC,CCxDe,SAARM,EAA+BC,EAAuD,CAC3F,GAAI,OAAOA,GAAU,UAAYA,IAAU,KACzC,MAAO,GAGT,IAAMC,EAAY,OAAO,eAAeD,CAAK,EAE7C,OAAIC,IAAc,MAAQA,IAAc,OAAO,UACtC,GAIF,CAAC,OAAO,OAAOD,EAAO,OAAO,WAAW,CACjD,CCjBe,SAARE,EAA0BC,EAAiC,CAChE,OAAO,OAAOA,GAAU,QAC1B,CCFe,SAARC,EACLC,EAAsCC,EACtC,CACA,IAAMC,EAAc,MAAM,QAAQD,CAAO,EAAIA,EAAU,CAACA,CAAO,EAE/D,OAAO,OAAO,YACZ,OAAO,QAAQD,CAAM,EAAE,OAAO,CAAC,CAACG,CAAG,IAAM,CAACD,EAAY,SAASC,CAAG,CAAC,CACrE,CACF,CCDe,SAARC,EAAuBC,EAAoBC,EAA6B,CAC7E,IAAMC,EAAQD,IAAa,OAAY,EAAID,EACrCG,EAAMF,GAAYD,EAExB,GAAI,CAAC,OAAO,UAAUE,CAAK,GAAK,CAAC,OAAO,UAAUC,CAAG,EACnD,MAAM,IAAI,UAAU,+CAA+CD,CAAK,eAAeC,CAAG,IAAI,EAGhG,IAAMC,EAASD,EAAMD,EAErB,GAAIE,EAAS,EACX,MAAM,IAAI,WAAW,yBAAyBF,CAAK,mCAAmCC,CAAG,IAAI,EAG/F,OAAO,MAAM,KAAK,CAAE,OAAAC,CAAO,EAAG,CAACC,EAAGC,IAAUJ,EAAQI,CAAK,CAC3D,CCtBe,SAARC,EAA0BC,EAAwB,CACvD,OAAOA,GAAO,WAAW,GAAK,OAAOA,CAAK,CAC5C,CCHe,SAARC,EAA2BC,EAAiB,CAEjD,OAAOA,EAAM,OAAO,CAACC,EAAMC,IAAUF,EAAM,QAAQC,CAAI,IAAMC,CAAK,CACpE",
+  "names": ["index_exports", "__export", "attempt", "capitalize", "compose", "isNumber", "isNumberLike", "isPlainObject", "isString", "omit", "range", "toString", "unique", "__toCommonJS", "attempt", "callback", "capitalize", "value", "compose", "functions", "value", "accumulator", "fn", "isNumber", "value", "options", "isNumberLike", "value", "options", "attempt", "falsyNumberValues", "truthyNumberValues", "numberValue", "isNumber", "isPlainObject", "value", "prototype", "isString", "value", "omit", "object", "omitted", "omittedKeys", "key", "range", "startOrEnd", "maybeEnd", "start", "end", "length", "_", "index", "toString", "value", "unique", "array", "item", "index"]
+}

package/dist/cjs/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@radham/utils",
+  "version": "0.1.0",
+  "description": "A small bespoke utility library.",
+  "keywords": [
+    "lib",
+    "library",
+    "utility",
+    "utilities"
+  ],
+  "homepage": "https://github.com/jbenner-radham/node-utils#readme",
+  "bugs": {
+    "url": "https://github.com/jbenner-radham/node-utils/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jbenner-radham/node-utils.git"
+  },
+  "license": "BSD-3-Clause",
+  "author": "James Benner <hello@jamesbenner.com> (https://www.jamesbenner.com/)",
+  "sideEffects": false,
+  "type": "commonjs",
+  "exports": "./index.js",
+  "types": "../types/index.d.ts",
+  "devDependencies": {
+    "@eslint/compat": "^2.0.2",
+    "@eslint/json": "^1.0.0",
+    "@radham/changelog": "^0.1.1",
+    "@radham/eslint-config": "^13.0.0",
+    "@types/node": "^22.18.8",
+    "@vitest/coverage-v8": "^4.0.18",
+    "cspell": "^9.6.4",
+    "duo-build": "^0.2.1",
+    "eslint": "^9.39.2",
+    "globals": "^17.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "np": "^11.0.2",
+    "rimraf": "^6.1.2",
+    "sort-package-json": "^3.6.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "packageManager": "pnpm@10.29.1",
+  "engines": {
+    "node": ">=22"
+  }
+}

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+function o(e){try{return e()}catch{}}function a(e){return e.charAt(0).toUpperCase()+e.slice(1)}function s(...e){return t=>e.reduce((r,n)=>n(r),t)}function u(e,t){return typeof e=="number"&&(!t?.finite||Number.isFinite(e))}function l(e,t){if(typeof e=="bigint")return!!t?.bigint;if(typeof e=="string"&&t?.bigint)return!!(o(()=>BigInt(e))??!1);if(typeof e=="string"&&["-Infinity","Infinity","NaN"].includes(e))return!t?.finite;let n=["",!1,null],i=[!0];if(n.includes(e)||i.includes(e))return!1;let f=Number(e);return typeof e!="number"&&Number.isNaN(f)?!1:u(f,t)}function p(e){if(typeof e!="object"||e===null)return!1;let t=Object.getPrototypeOf(e);return t!==null&&t!==Object.prototype?!1:!Object.hasOwn(e,Symbol.toStringTag)}function m(e){return typeof e=="string"}function c(e,t){let r=Array.isArray(t)?t:[t];return Object.fromEntries(Object.entries(e).filter(([n])=>!r.includes(n)))}function b(e,t){let r=t===void 0?0:e,n=t??e;if(!Number.isInteger(r)||!Number.isInteger(n))throw new TypeError(`Expected integer arguments, received start (${r}), and end (${n}).`);let i=n-r;if(i<0)throw new RangeError(`Invalid range: start (${r}) must not be greater than end (${n}).`);return Array.from({length:i},(f,y)=>r+y)}function d(e){return e?.toString?.()??String(e)}function g(e){return e.filter((t,r)=>e.indexOf(t)===r)}export{o as attempt,a as capitalize,s as compose,u as isNumber,l as isNumberLike,p as isPlainObject,m as isString,c as omit,b as range,d as toString,g as unique};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/attempt.ts", "../../src/capitalize.ts", "../../src/compose.ts", "../../src/is-number.ts", "../../src/is-number-like.ts", "../../src/is-plain-object.ts", "../../src/is-string.ts", "../../src/omit.ts", "../../src/range.ts", "../../src/to-string.ts", "../../src/unique.ts"],
+  "sourcesContent": ["/**\n * Executes a function and returns its result, or `undefined` if it throws.\n *\n * @param callback - The function to execute.\n * @returns The return value of `callback`, or `undefined` if an error is thrown.\n *\n * @example\n * ```typescript\n * attempt(() => JSON.parse('{\"a\":1}')); // { a: 1 }\n * attempt(() => JSON.parse('invalid')); // undefined\n * ```\n */\nexport default function attempt<T>(callback: () => T): T | undefined {\n  try {\n    return callback();\n  } catch { /* Do nothing. */ }\n}\n", "/**\n * Capitalizes the first character of a string.\n *\n * @param value - The string to capitalize.\n * @returns A new string with the first character in uppercase.\n *\n * @example\n * ```typescript\n * capitalize('hello'); // 'Hello'\n * ```\n */\nexport default function capitalize<T extends string>(value: T): Capitalize<T> {\n  return (value.charAt(0).toUpperCase() + value.slice(1)) as Capitalize<T>;\n}\n", "/**\n * Composes multiple functions into a single function that applies them from left to right.\n *\n * @param functions - The functions to compose, each taking and returning the same type.\n * @returns A function that pipes a value through each function in order.\n *\n * @example\n * ```typescript\n * const addOne = (value: number) => value + 1;\n * const double = (value: number) => value * 2;\n *\n * compose(addOne, double)(3); // 8\n * ```\n */\nexport default function compose<T>(...functions: Array<(value: T) => T>): (value: T) => T {\n  return (value: T) => functions.reduce((accumulator, fn) => fn(accumulator), value);\n}\n", "/**\n * Checks whether the given value is a number.\n *\n * @param value - The value to check.\n * @param options - Optional configuration.\n * @param options.finite - When `true`, only finite numbers are considered valid (`NaN` and\n *   `Infinity` return `false`).\n * @returns `true` if `value` is a number, `false` otherwise.\n *\n * @example\n * ```typescript\n * isNumber(42);                         // true\n * isNumber('42');                       // false\n * isNumber(NaN);                        // true\n * isNumber(NaN, { finite: true });      // false\n * isNumber(Infinity, { finite: true }); // false\n * ```\n */\nexport default function isNumber(\n  value: unknown, options?: { finite?: boolean }\n): value is number {\n  return typeof value === 'number' && (!options?.finite || Number.isFinite(value));\n}\n", "import attempt from './attempt.js';\nimport isNumber from './is-number.js';\n\n/**\n * Checks whether the given value is a number or can be coerced to one.\n *\n * @remarks\n * This function only considers actual numbers and strings that represent numbers as\n * number-like. Even though the values `''`, `false`, and `null` convert to `0`, and\n * `true` converts to `1`, none of these are considered number-like by this function.\n *\n * @param value - The value to check.\n * @param options - Optional configuration.\n * @param options.bigint - When `true`, bigints and strings that can be converted to\n *   bigints are considered valid.\n * @param options.finite - When `true`, only finite numbers are considered valid (`NaN`,\n *   `Infinity`, and their string equivalents return `false`).\n * @returns `true` if `value` is number-like, `false` otherwise.\n *\n * @example\n * ```typescript\n * isNumberLike(42);                           // true\n * isNumberLike('42');                         // true\n * isNumberLike('3.14');                       // true\n * isNumberLike('NaN');                        // true\n * isNumberLike('NaN', { finite: true });      // false\n * isNumberLike('Infinity', { finite: true }); // false\n * isNumberLike('abc');                        // false\n * isNumberLike(null);                         // false\n * isNumberLike(1n);                           // false\n * isNumberLike(1n, { bigint: true });         // true\n * isNumberLike('1n', { bigint: true });       // true\n * ```\n */\nexport default function isNumberLike(\n  value: unknown, options?: { bigint?: boolean; finite?: boolean }\n): value is number {\n  // `Number()` will coerce bigints to numbers, so we need to make this check.\n  if (typeof value === 'bigint') {\n    return Boolean(options?.bigint);\n  }\n\n  if (typeof value === 'string' && options?.bigint) {\n    return Boolean(attempt(() => BigInt(value)) ?? false);\n  }\n\n  const infiniteNumberStrings = ['-Infinity', 'Infinity', 'NaN'];\n\n  if (typeof value === 'string' && infiniteNumberStrings.includes(value)) {\n    return !options?.finite;\n  }\n\n  // These values are converted to `0` by `Number()`.\n  const falsyNumberValues = ['', false, null];\n\n  // These values are converted to `1` by `Number()`.\n  const truthyNumberValues = [true];\n\n  if (\n    falsyNumberValues.includes(value as boolean | null | string) ||\n    truthyNumberValues.includes(value as boolean)\n  ) {\n    return false;\n  }\n\n  const numberValue = Number(value);\n\n  if (typeof value !== 'number' && Number.isNaN(numberValue)) {\n    return false;\n  }\n\n  return isNumber(numberValue, options);\n}\n", "/**\n * Checks whether the given value is a plain object.\n *\n * @remarks\n * A plain object is one created by the `Object` constructor, a `null` prototype, or an object\n * literal.\n *\n * @param value - The value to check.\n * @returns `true` if `value` is a plain object, `false` otherwise.\n *\n * @example\n * ```typescript\n * isPlainObject({ a: 1 }); // true\n * isPlainObject([1, 2]);   // false\n * ```\n */\nexport default function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  const prototype = Object.getPrototypeOf(value) as unknown;\n\n  if (prototype !== null && prototype !== Object.prototype) {\n    return false;\n  }\n\n  // This is needed for `Atomics`, `Intl`, `JSON`, `Math`, and `Reflect`.\n  return !Object.hasOwn(value, Symbol.toStringTag);\n}\n", "/**\n * Checks whether the given value is a string.\n *\n * @param value - The value to check.\n * @returns `true` if `value` is a string, `false` otherwise.\n *\n * @example\n * ```typescript\n * isString('hello'); // true\n * isString(42);      // false\n * ```\n */\nexport default function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n", "/**\n * Creates a new object with the specified keys omitted.\n *\n * @param object - The source object to omit keys from.\n * @param omitted - A key or array of keys to exclude from the result.\n * @returns A new object containing all entries from `object` except those with keys in `omitted`.\n *\n * @example\n * ```typescript\n * omit({ a: 1, b: 2, c: 3 }, ['a', 'c']); // { b: 2 }\n * ```\n */\nexport default function omit(\n  object: Record<PropertyKey, unknown>, omitted: PropertyKey | PropertyKey[]\n) {\n  const omittedKeys = Array.isArray(omitted) ? omitted : [omitted];\n\n  return Object.fromEntries(\n    Object.entries(object).filter(([key]) => !omittedKeys.includes(key))\n  );\n}\n", "/**\n * Creates an array of integers from `start` (inclusive) to `end` (exclusive).\n *\n * @remarks\n * When called with a single argument, it generates a range from `0` to that value.\n *\n * @param startOrEnd - The start of the range if `maybeEnd` is provided, otherwise the end.\n * @param maybeEnd - The end of the range (exclusive). Must be greater than or equal to `start`.\n * @returns An array of sequential integers.\n *\n * @throws {@link TypeError} If either argument is not a finite integer.\n * @throws {@link RangeError} If `start` is greater than `end`.\n *\n * @example\n * ```typescript\n * range(4);    // [0, 1, 2, 3]\n * range(2, 5); // [2, 3, 4]\n * ```\n */\nexport default function range(startOrEnd: number, maybeEnd?: number): number[] {\n  const start = maybeEnd === undefined ? 0 : startOrEnd;\n  const end = maybeEnd ?? startOrEnd;\n\n  if (!Number.isInteger(start) || !Number.isInteger(end)) {\n    throw new TypeError(`Expected integer arguments, received start (${start}), and end (${end}).`);\n  }\n\n  const length = end - start;\n\n  if (length < 0) {\n    throw new RangeError(`Invalid range: start (${start}) must not be greater than end (${end}).`);\n  }\n\n  return Array.from({ length }, (_, index) => start + index);\n}\n", "/**\n * Converts a value to its string representation.\n *\n * @param value - The value to convert.\n * @returns The string representation of `value`.\n *\n * @example\n * ```typescript\n * toString(42);   // '42'\n * toString(null); // 'null'\n * ```\n */\nexport default function toString(value: unknown): string {\n  return value?.toString?.() ?? String(value);\n}\n", "/**\n * Returns a new array with duplicate values removed.\n *\n * @param array - The array to deduplicate.\n * @returns A new array containing only the first occurrence of each value.\n *\n * @example\n * ```typescript\n * unique([1, 2, 2, 3, 1]); // [1, 2, 3]\n * ```\n */\nexport default function unique<T>(array: T[]): T[] {\n  // NOTE: This benchmarks significantly better than `return [...new Set(array)]`.\n  return array.filter((item, index) => array.indexOf(item) === index);\n}\n"],
+  "mappings": "AAYe,SAARA,EAA4BC,EAAkC,CACnE,GAAI,CACF,OAAOA,EAAS,CAClB,MAAQ,CAAoB,CAC9B,CCLe,SAARC,EAA8CC,EAAyB,CAC5E,OAAQA,EAAM,OAAO,CAAC,EAAE,YAAY,EAAIA,EAAM,MAAM,CAAC,CACvD,CCCe,SAARC,KAA+BC,EAAoD,CACxF,OAAQC,GAAaD,EAAU,OAAO,CAACE,EAAaC,IAAOA,EAAGD,CAAW,EAAGD,CAAK,CACnF,CCEe,SAARG,EACLC,EAAgBC,EACC,CACjB,OAAO,OAAOD,GAAU,WAAa,CAACC,GAAS,QAAU,OAAO,SAASD,CAAK,EAChF,CCYe,SAARE,EACLC,EAAgBC,EACC,CAEjB,GAAI,OAAOD,GAAU,SACnB,MAAO,EAAQC,GAAS,OAG1B,GAAI,OAAOD,GAAU,UAAYC,GAAS,OACxC,MAAO,GAAQC,EAAQ,IAAM,OAAOF,CAAK,CAAC,GAAK,IAKjD,GAAI,OAAOA,GAAU,UAFS,CAAC,YAAa,WAAY,KAAK,EAEN,SAASA,CAAK,EACnE,MAAO,CAACC,GAAS,OAInB,IAAME,EAAoB,CAAC,GAAI,GAAO,IAAI,EAGpCC,EAAqB,CAAC,EAAI,EAEhC,GACED,EAAkB,SAASH,CAAgC,GAC3DI,EAAmB,SAASJ,CAAgB,EAE5C,MAAO,GAGT,IAAMK,EAAc,OAAOL,CAAK,EAEhC,OAAI,OAAOA,GAAU,UAAY,OAAO,MAAMK,CAAW,EAChD,GAGFC,EAASD,EAAaJ,CAAO,CACtC,CCxDe,SAARM,EAA+BC,EAAuD,CAC3F,GAAI,OAAOA,GAAU,UAAYA,IAAU,KACzC,MAAO,GAGT,IAAMC,EAAY,OAAO,eAAeD,CAAK,EAE7C,OAAIC,IAAc,MAAQA,IAAc,OAAO,UACtC,GAIF,CAAC,OAAO,OAAOD,EAAO,OAAO,WAAW,CACjD,CCjBe,SAARE,EAA0BC,EAAiC,CAChE,OAAO,OAAOA,GAAU,QAC1B,CCFe,SAARC,EACLC,EAAsCC,EACtC,CACA,IAAMC,EAAc,MAAM,QAAQD,CAAO,EAAIA,EAAU,CAACA,CAAO,EAE/D,OAAO,OAAO,YACZ,OAAO,QAAQD,CAAM,EAAE,OAAO,CAAC,CAACG,CAAG,IAAM,CAACD,EAAY,SAASC,CAAG,CAAC,CACrE,CACF,CCDe,SAARC,EAAuBC,EAAoBC,EAA6B,CAC7E,IAAMC,EAAQD,IAAa,OAAY,EAAID,EACrCG,EAAMF,GAAYD,EAExB,GAAI,CAAC,OAAO,UAAUE,CAAK,GAAK,CAAC,OAAO,UAAUC,CAAG,EACnD,MAAM,IAAI,UAAU,+CAA+CD,CAAK,eAAeC,CAAG,IAAI,EAGhG,IAAMC,EAASD,EAAMD,EAErB,GAAIE,EAAS,EACX,MAAM,IAAI,WAAW,yBAAyBF,CAAK,mCAAmCC,CAAG,IAAI,EAG/F,OAAO,MAAM,KAAK,CAAE,OAAAC,CAAO,EAAG,CAACC,EAAGC,IAAUJ,EAAQI,CAAK,CAC3D,CCtBe,SAARC,EAA0BC,EAAwB,CACvD,OAAOA,GAAO,WAAW,GAAK,OAAOA,CAAK,CAC5C,CCHe,SAARC,EAA2BC,EAAiB,CAEjD,OAAOA,EAAM,OAAO,CAACC,EAAMC,IAAUF,EAAM,QAAQC,CAAI,IAAMC,CAAK,CACpE",
+  "names": ["attempt", "callback", "capitalize", "value", "compose", "functions", "value", "accumulator", "fn", "isNumber", "value", "options", "isNumberLike", "value", "options", "attempt", "falsyNumberValues", "truthyNumberValues", "numberValue", "isNumber", "isPlainObject", "value", "prototype", "isString", "value", "omit", "object", "omitted", "omittedKeys", "key", "range", "startOrEnd", "maybeEnd", "start", "end", "length", "_", "index", "toString", "value", "unique", "array", "item", "index"]
+}

package/dist/esm/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@radham/utils",
+  "version": "0.1.0",
+  "description": "A small bespoke utility library.",
+  "keywords": [
+    "lib",
+    "library",
+    "utility",
+    "utilities"
+  ],
+  "homepage": "https://github.com/jbenner-radham/node-utils#readme",
+  "bugs": {
+    "url": "https://github.com/jbenner-radham/node-utils/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jbenner-radham/node-utils.git"
+  },
+  "license": "BSD-3-Clause",
+  "author": "James Benner <hello@jamesbenner.com> (https://www.jamesbenner.com/)",
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./index.js",
+  "types": "../types/index.d.ts",
+  "devDependencies": {
+    "@eslint/compat": "^2.0.2",
+    "@eslint/json": "^1.0.0",
+    "@radham/changelog": "^0.1.1",
+    "@radham/eslint-config": "^13.0.0",
+    "@types/node": "^22.18.8",
+    "@vitest/coverage-v8": "^4.0.18",
+    "cspell": "^9.6.4",
+    "duo-build": "^0.2.1",
+    "eslint": "^9.39.2",
+    "globals": "^17.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "np": "^11.0.2",
+    "rimraf": "^6.1.2",
+    "sort-package-json": "^3.6.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "packageManager": "pnpm@10.29.1",
+  "engines": {
+    "node": ">=22"
+  }
+}

package/dist/types/attempt.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Executes a function and returns its result, or `undefined` if it throws.
+ *
+ * @param callback - The function to execute.
+ * @returns The return value of `callback`, or `undefined` if an error is thrown.
+ *
+ * @example
+ * ```typescript
+ * attempt(() => JSON.parse('{"a":1}')); // { a: 1 }
+ * attempt(() => JSON.parse('invalid')); // undefined
+ * ```
+ */
+export default function attempt<T>(callback: () => T): T | undefined;
+//# sourceMappingURL=attempt.d.ts.map

package/dist/types/attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/attempt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAInE"}

package/dist/types/capitalize.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Capitalizes the first character of a string.
+ *
+ * @param value - The string to capitalize.
+ * @returns A new string with the first character in uppercase.
+ *
+ * @example
+ * ```typescript
+ * capitalize('hello'); // 'Hello'
+ * ```
+ */
+export default function capitalize<T extends string>(value: T): Capitalize<T>;
+//# sourceMappingURL=capitalize.d.ts.map

package/dist/types/capitalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capitalize.d.ts","sourceRoot":"","sources":["../../src/capitalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAE5E"}

package/dist/types/compose.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composes multiple functions into a single function that applies them from left to right.
+ *
+ * @param functions - The functions to compose, each taking and returning the same type.
+ * @returns A function that pipes a value through each function in order.
+ *
+ * @example
+ * ```typescript
+ * const addOne = (value: number) => value + 1;
+ * const double = (value: number) => value * 2;
+ *
+ * compose(addOne, double)(3); // 8
+ * ```
+ */
+export default function compose<T>(...functions: Array<(value: T) => T>): (value: T) => T;
+//# sourceMappingURL=compose.d.ts.map

package/dist/types/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/compose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,CAAC,EAAE,GAAG,SAAS,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAExF"}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export { default as attempt } from './attempt.js';
+export { default as capitalize } from './capitalize.js';
+export { default as compose } from './compose.js';
+export { default as isNumber } from './is-number.js';
+export { default as isNumberLike } from './is-number-like.js';
+export { default as isPlainObject } from './is-plain-object.js';
+export { default as isString } from './is-string.js';
+export { default as omit } from './omit.js';
+export { default as range } from './range.js';
+export { default as toString } from './to-string.js';
+export { default as unique } from './unique.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/types/is-number-like.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Checks whether the given value is a number or can be coerced to one.
+ *
+ * @remarks
+ * This function only considers actual numbers and strings that represent numbers as
+ * number-like. Even though the values `''`, `false`, and `null` convert to `0`, and
+ * `true` converts to `1`, none of these are considered number-like by this function.
+ *
+ * @param value - The value to check.
+ * @param options - Optional configuration.
+ * @param options.bigint - When `true`, bigints and strings that can be converted to
+ *   bigints are considered valid.
+ * @param options.finite - When `true`, only finite numbers are considered valid (`NaN`,
+ *   `Infinity`, and their string equivalents return `false`).
+ * @returns `true` if `value` is number-like, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isNumberLike(42);                           // true
+ * isNumberLike('42');                         // true
+ * isNumberLike('3.14');                       // true
+ * isNumberLike('NaN');                        // true
+ * isNumberLike('NaN', { finite: true });      // false
+ * isNumberLike('Infinity', { finite: true }); // false
+ * isNumberLike('abc');                        // false
+ * isNumberLike(null);                         // false
+ * isNumberLike(1n);                           // false
+ * isNumberLike(1n, { bigint: true });         // true
+ * isNumberLike('1n', { bigint: true });       // true
+ * ```
+ */
+export default function isNumberLike(value: unknown, options?: {
+    bigint?: boolean;
+    finite?: boolean;
+}): value is number;
+//# sourceMappingURL=is-number-like.d.ts.map

package/dist/types/is-number-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-number-like.d.ts","sourceRoot":"","sources":["../../src/is-number-like.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/D,KAAK,IAAI,MAAM,CAoCjB"}

package/dist/types/is-number.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Checks whether the given value is a number.
+ *
+ * @param value - The value to check.
+ * @param options - Optional configuration.
+ * @param options.finite - When `true`, only finite numbers are considered valid (`NaN` and
+ *   `Infinity` return `false`).
+ * @returns `true` if `value` is a number, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isNumber(42);                         // true
+ * isNumber('42');                       // false
+ * isNumber(NaN);                        // true
+ * isNumber(NaN, { finite: true });      // false
+ * isNumber(Infinity, { finite: true }); // false
+ * ```
+ */
+export default function isNumber(value: unknown, options?: {
+    finite?: boolean;
+}): value is number;
+//# sourceMappingURL=is-number.d.ts.map

package/dist/types/is-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-number.d.ts","sourceRoot":"","sources":["../../src/is-number.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC7C,KAAK,IAAI,MAAM,CAEjB"}

package/dist/types/is-plain-object.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks whether the given value is a plain object.
+ *
+ * @remarks
+ * A plain object is one created by the `Object` constructor, a `null` prototype, or an object
+ * literal.
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is a plain object, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isPlainObject({ a: 1 }); // true
+ * isPlainObject([1, 2]);   // false
+ * ```
+ */
+export default function isPlainObject(value: unknown): value is Record<PropertyKey, unknown>;
+//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/types/is-plain-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.d.ts","sourceRoot":"","sources":["../../src/is-plain-object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAa3F"}

package/dist/types/is-string.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks whether the given value is a string.
+ *
+ * @param value - The value to check.
+ * @returns `true` if `value` is a string, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isString('hello'); // true
+ * isString(42);      // false
+ * ```
+ */
+export default function isString(value: unknown): value is string;
+//# sourceMappingURL=is-string.d.ts.map

package/dist/types/is-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-string.d.ts","sourceRoot":"","sources":["../../src/is-string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAEhE"}

package/dist/types/omit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a new object with the specified keys omitted.
+ *
+ * @param object - The source object to omit keys from.
+ * @param omitted - A key or array of keys to exclude from the result.
+ * @returns A new object containing all entries from `object` except those with keys in `omitted`.
+ *
+ * @example
+ * ```typescript
+ * omit({ a: 1, b: 2, c: 3 }, ['a', 'c']); // { b: 2 }
+ * ```
+ */
+export default function omit(object: Record<PropertyKey, unknown>, omitted: PropertyKey | PropertyKey[]): {
+    [k: string]: unknown;
+};
+//# sourceMappingURL=omit.d.ts.map

package/dist/types/omit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omit.d.ts","sourceRoot":"","sources":["../../src/omit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,WAAW,GAAG,WAAW,EAAE;;EAO3E"}

package/dist/types/range.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Creates an array of integers from `start` (inclusive) to `end` (exclusive).
+ *
+ * @remarks
+ * When called with a single argument, it generates a range from `0` to that value.
+ *
+ * @param startOrEnd - The start of the range if `maybeEnd` is provided, otherwise the end.
+ * @param maybeEnd - The end of the range (exclusive). Must be greater than or equal to `start`.
+ * @returns An array of sequential integers.
+ *
+ * @throws {@link TypeError} If either argument is not a finite integer.
+ * @throws {@link RangeError} If `start` is greater than `end`.
+ *
+ * @example
+ * ```typescript
+ * range(4);    // [0, 1, 2, 3]
+ * range(2, 5); // [2, 3, 4]
+ * ```
+ */
+export default function range(startOrEnd: number, maybeEnd?: number): number[];
+//# sourceMappingURL=range.d.ts.map

package/dist/types/range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAe7E"}

package/dist/types/to-string.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a value to its string representation.
+ *
+ * @param value - The value to convert.
+ * @returns The string representation of `value`.
+ *
+ * @example
+ * ```typescript
+ * toString(42);   // '42'
+ * toString(null); // 'null'
+ * ```
+ */
+export default function toString(value: unknown): string;
+//# sourceMappingURL=to-string.d.ts.map

package/dist/types/to-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-string.d.ts","sourceRoot":"","sources":["../../src/to-string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEvD"}

package/dist/types/unique.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns a new array with duplicate values removed.
+ *
+ * @param array - The array to deduplicate.
+ * @returns A new array containing only the first occurrence of each value.
+ *
+ * @example
+ * ```typescript
+ * unique([1, 2, 2, 3, 1]); // [1, 2, 3]
+ * ```
+ */
+export default function unique<T>(array: T[]): T[];
+//# sourceMappingURL=unique.d.ts.map

package/dist/types/unique.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unique.d.ts","sourceRoot":"","sources":["../../src/unique.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAGjD"}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@radham/utils",
+  "version": "0.1.0",
+  "description": "A small bespoke utility library.",
+  "keywords": [
+    "lib",
+    "library",
+    "utility",
+    "utilities"
+  ],
+  "homepage": "https://github.com/jbenner-radham/node-utils#readme",
+  "bugs": {
+    "url": "https://github.com/jbenner-radham/node-utils/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jbenner-radham/node-utils.git"
+  },
+  "license": "BSD-3-Clause",
+  "author": "James Benner <hello@jamesbenner.com> (https://www.jamesbenner.com/)",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "import": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "require": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "prebuild": "rimraf ./dist",
+    "build": "duo-build",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "prepare": "husky",
+    "prepublishOnly": "pnpm run build",
+    "spellcheck": "cspell --dot --gitignore .",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.0.2",
+    "@eslint/json": "^1.0.0",
+    "@radham/changelog": "^0.1.1",
+    "@radham/eslint-config": "^13.0.0",
+    "@types/node": "^22.18.8",
+    "@vitest/coverage-v8": "^4.0.18",
+    "cspell": "^9.6.4",
+    "duo-build": "^0.2.1",
+    "eslint": "^9.39.2",
+    "globals": "^17.3.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "np": "^11.0.2",
+    "rimraf": "^6.1.2",
+    "sort-package-json": "^3.6.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "packageManager": "pnpm@10.29.1",
+  "engines": {
+    "node": ">=22"
+  }
+}