imagic-utils 1.0.0 → 2.1.0

package/README.md

@@ -1 +1,262 @@
-# utils
+# imagic-utils
+
+> Collection of general-purpose utility functions for arrays, numbers, strings, random values, IDs, hashing, and async helpers.
+
+## Install
+
+```bash
+npm install imagic-utils
+```
+
+## Quick Start
+
+```js
+import { getRandInteger, getRandString, generateId, wait } from 'imagic-utils'
+
+const id = generateId()            // '3f2a1b4c...' (32 hex chars)
+const n  = getRandInteger(1, 100)  // e.g. 42
+const s  = getRandString(8)        // e.g. 'aX9kPq2Z'
+
+await wait(500)                    // pause for 500 ms
+```
+
+## API
+
+### Arrays
+
+#### `getRandArrayItem(array)` → `any`
+
+Returns a random element from the array. Returns `undefined` if the array is empty.
+
+```ts
+getRandArrayItem(array: any[]): any
+```
+
+- `array` — must be an `Array`; throws `TypeError` if not
+
+Alias: `getRandomArrayItem`
+
+---
+
+#### `chunkArray(array, chunkSize)` → `any[][]`
+
+Splits an array into sub-arrays of the given size. The last chunk may be smaller than `chunkSize`.
+
+```ts
+chunkArray(array: any[], chunkSize: number): any[][]
+```
+
+- `array` — must be an `Array`; throws `TypeError` if not
+- `chunkSize` — must be a positive integer; throws if not
+
+---
+
+#### `shuffle(variable)` → `any[]`
+
+Returns a **new** array with elements in random order (Fisher-Yates algorithm). Does not mutate the original.
+
+```ts
+shuffle(variable: any[]): any[]
+```
+
+- `variable` — must be an `Array`; throws `TypeError` if not
+
+---
+
+### Numbers
+
+#### `getRandInteger(min, max)` → `number`
+
+Returns a random integer in the inclusive range `[min, max]`.
+
+```ts
+getRandInteger(min: number, max: number): number
+```
+
+- `min`, `max` — must be finite numbers; throws `TypeError` if not
+- Throws `RangeError` if there is no integer in `[min, max]`
+
+Alias: `getRandomInteger`
+
+---
+
+#### `getRandFloat(min, max, decimalPoint?)` → `number`
+
+Returns a random floating-point number in `[min, max]`, rounded to `decimalPoint` decimal places.
+
+```ts
+getRandFloat(min: number, max: number, decimalPoint?: number): number
+```
+
+- `min`, `max` — numeric bounds
+- `decimalPoint` — integer `0–15`; default `5`; throws `RangeError` if outside that range
+
+Alias: `getRandomFloat`
+
+---
+
+#### `chance(percent)` → `boolean`
+
+Returns `true` with `percent`% probability.
+
+```ts
+chance(percent: number): boolean
+```
+
+- `0` always returns `false`; `100` always returns `true`
+- Throws `TypeError` if `percent` is not a finite number
+
+---
+
+### Strings
+
+#### `getRandString(length?, charSet?)` → `string`
+
+Returns a random string composed of characters from `charSet`.
+
+```ts
+getRandString(length?: number, charSet?: string): string
+```
+
+- `length` — default `16`
+- `charSet` — default `A-Za-z0-9` (62 characters); throws if an empty string is provided
+
+Alias: `getRandomString`
+
+---
+
+#### `isJSON(json)` → `boolean`
+
+Returns `true` if the argument is a string containing valid JSON; `false` for any other input (including non-strings).
+
+```ts
+isJSON(json: any): boolean
+```
+
+---
+
+### Random Bytes / IDs
+
+#### `getRandomBytes(length)` → `Uint8Array`
+
+Returns cryptographically random bytes. Uses `crypto.getRandomValues` when available (browser / Node.js ≥ 15), otherwise falls back to `node:crypto`.
+
+```ts
+getRandomBytes(length: number): Uint8Array
+```
+
+- `length` — must be a positive integer; throws `TypeError` if not
+
+---
+
+#### `generateId()` → `string`
+
+Returns a 32-character lowercase hex string generated from 16 random bytes.
+
+```ts
+generateId(): string
+```
+
+Alias: `generateHexId`
+
+---
+
+#### `generateBigId()` → `string`
+
+Returns a UUIDv4-formatted string (`xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx`).
+
+```ts
+generateBigId(): string
+```
+
+Alias: `generateUuidV4`
+
+---
+
+#### `md5(data)` → `string`
+
+Returns the 32-character lowercase hex MD5 hash of the input.
+
+```ts
+md5(data: string | Buffer | Uint8Array): string
+```
+
+---
+
+### Promises
+
+#### `wait(milliseconds)` → `Promise<void>`
+
+Resolves after the given number of milliseconds.
+
+```ts
+wait(milliseconds: number): Promise<void>
+```
+
+- `milliseconds` — must be a non-negative number; throws `TypeError` if not
+
+---
+
+### Node.js-only
+
+The following exports are available in `src/index.js` but **not** in `src/browser.js`. Calling the browser stubs throws an explicit error.
+
+#### `getLocalAddress()` → `string`
+
+Returns the first non-loopback IPv4 address of the current machine.
+
+#### `getLocalAddresses()` → `string[]`
+
+Returns all non-loopback IPv4 addresses of the current machine.
+
+#### `getCPUUsage()` → `number`
+
+Returns the current CPU usage as a percentage in the range `0–100`.
+
+---
+
+### Aliases
+
+| Alias | Canonical name |
+|-------|---------------|
+| `getRandomArrayItem` | `getRandArrayItem` |
+| `getRandomFloat` | `getRandFloat` |
+| `getRandomInteger` | `getRandInteger` |
+| `getRandomString` | `getRandString` |
+| `generateUuidV4` | `generateBigId` |
+| `generateHexId` | `generateId` |
+
+---
+
+## Error Handling
+
+| Function | Error type | Condition |
+|----------|-----------|-----------|
+| `getRandArrayItem` | `TypeError` | argument is not an Array |
+| `chunkArray` | `TypeError` | `array` is not an Array |
+| `chunkArray` | `TypeError` / `RangeError` | `chunkSize` is not a positive integer |
+| `shuffle` | `TypeError` | argument is not an Array |
+| `getRandInteger` | `TypeError` | `min` or `max` is not a finite number |
+| `getRandInteger` | `RangeError` | no integer exists in `[min, max]` |
+| `getRandFloat` | `RangeError` | `decimalPoint` is outside `0–15` |
+| `chance` | `TypeError` | `percent` is not a finite number |
+| `getRandString` | `Error` | `charSet` is an empty string |
+| `getRandomBytes` | `TypeError` | `length` is not a positive integer |
+| `wait` | `TypeError` | `milliseconds` is not a non-negative number |
+| Node-only in browser | `Error` | called in a browser environment |
+
+---
+
+## Examples
+
+See the [`examples/`](./examples/) directory for runnable scripts:
+
+```bash
+node examples/basic.js
+```
+
+---
+
+## License
+
+MIT © iMagicKey

package/package.json

@@ -1,20 +1,31 @@
 {
     "name": "imagic-utils",
-    "version": "1.0.0",
-    "description": "Utils package",
-    "main": "src/index.js",
+    "version": "2.1.0",
+    "description": "Utility helpers for Node.js and browsers",
+    "exports": {
+        ".": {
+            "browser": "./src/browser.js",
+            "default": "./src/index.js"
+        },
+        "./browser": "./src/browser.js",
+        "./node": "./src/index.js",
+        "./package.json": "./package.json"
+    },
+    "sideEffects": false,
+    "files": ["src", "README.md", "LICENSE"],
     "type": "module",
     "scripts": {
-        "test": "node ./tests/index.js"
+        "test": "node --test ./tests/**/*.test.js",
+        "lint": "eslint src",
+        "lint:fix": "eslint src --fix",
+        "deps:check": "npm outdated",
+        "deps:update": "npm update"
     },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/iMagicKey/utils.git"
     },
-    "keywords": [
-        "utils",
-        "util"
-    ],
+    "keywords": ["utils", "util"],
     "author": "iMagicKey",
     "license": "MIT",
     "bugs": {
@@ -22,6 +33,18 @@
     },
     "homepage": "https://github.com/iMagicKey/utils#readme",
     "engines": {
-        "node": ">=18"
+        "node": ">=24"
+    },
+    "devDependencies": {
+        "@eslint/js": "latest",
+        "chai": "latest",
+        "eslint": "latest",
+        "eslint-config-prettier": "latest",
+        "eslint-plugin-import": "latest",
+        "eslint-plugin-n": "latest",
+        "eslint-plugin-prettier": "latest",
+        "eslint-plugin-promise": "latest",
+        "globals": "latest",
+        "prettier": "latest"
     }
 }

package/src/browser.js

@@ -0,0 +1,28 @@
+import sharedUtils from './shared.js'
+
+export * from './shared.js'
+
+function createUnsupportedFunction(name) {
+    return function unsupportedInBrowser() {
+        throw new Error(`${name} is available only in Node.js environments`)
+    }
+}
+
+const getLocalAddress = createUnsupportedFunction('getLocalAddress')
+const getLocalAddresses = createUnsupportedFunction('getLocalAddresses')
+const getCPUUsage = createUnsupportedFunction('getCPUUsage')
+const getLocalIPv4Address = getLocalAddress
+const getLocalIPv4Addresses = getLocalAddresses
+
+const browserUtils = {
+    ...sharedUtils,
+    getLocalAddress,
+    getLocalAddresses,
+    getCPUUsage,
+    getLocalIPv4Address,
+    getLocalIPv4Addresses,
+}
+
+export { getLocalAddress, getLocalAddresses, getCPUUsage, getLocalIPv4Address, getLocalIPv4Addresses }
+
+export default browserUtils

package/src/index.js

@@ -1,31 +1,22 @@
-import getRandArrayItem from './utils/array/getRandArrayItem.js'
-import getRandFloat from './utils/float/getRandFloat.js'
-import chance from './utils/general/chance.js'
-import generateBigId from './utils/general/generateBigId.js'
-import generateId from './utils/general/generateId.js'
-import isJSON from './utils/general/isJSON.js'
-import shuffle from './utils/general/shuffle.js'
-import wait from './utils/general/wait.js'
-import md5 from './utils/general/md5.js'
-import getRandInteger from './utils/integer/getRandInteger.js'
+import sharedUtils from './shared.js'
 import getLocalAddress from './utils/os/getLocalAddress.js'
 import getLocalAddresses from './utils/os/getLocalAddresses.js'
 import getCPUUsage from './utils/os/getCPUUsage.js'
-import getRandString from './utils/string/getRandString.js'
 
-export default {
-    getRandArrayItem,
-    getRandFloat,
-    chance,
-    generateBigId,
-    generateId,
-    isJSON,
-    shuffle,
-    wait,
-    md5,
-    getRandInteger,
+export * from './shared.js'
+
+const getLocalIPv4Address = getLocalAddress
+const getLocalIPv4Addresses = getLocalAddresses
+
+const nodeUtils = {
+    ...sharedUtils,
     getLocalAddress,
     getLocalAddresses,
     getCPUUsage,
-    getRandString,
+    getLocalIPv4Address,
+    getLocalIPv4Addresses,
 }
+
+export { getLocalAddress, getLocalAddresses, getCPUUsage, getLocalIPv4Address, getLocalIPv4Addresses }
+
+export default nodeUtils

package/src/shared.js

@@ -0,0 +1,66 @@
+import getRandArrayItem from './utils/array/getRandArrayItem.js'
+import chunkArray from './utils/array/chunkArray.js'
+import getRandFloat from './utils/float/getRandFloat.js'
+import chance from './utils/general/chance.js'
+import generateBigId from './utils/general/generateBigId.js'
+import generateId from './utils/general/generateId.js'
+import getRandomBytes from './utils/general/getRandomBytes.js'
+import isJSON from './utils/general/isJSON.js'
+import shuffle from './utils/general/shuffle.js'
+import wait from './utils/general/wait.js'
+import md5 from './utils/general/md5.js'
+import getRandInteger from './utils/integer/getRandInteger.js'
+import getRandString from './utils/string/getRandString.js'
+
+const getRandomArrayItem = getRandArrayItem
+const getRandomFloat = getRandFloat
+const getRandomInteger = getRandInteger
+const getRandomString = getRandString
+const generateUuidV4 = generateBigId
+const generateHexId = generateId
+
+const sharedUtils = {
+    getRandArrayItem,
+    chunkArray,
+    getRandFloat,
+    chance,
+    generateBigId,
+    generateId,
+    getRandomBytes,
+    isJSON,
+    shuffle,
+    wait,
+    md5,
+    getRandInteger,
+    getRandString,
+    getRandomArrayItem,
+    getRandomFloat,
+    getRandomInteger,
+    getRandomString,
+    generateUuidV4,
+    generateHexId,
+}
+
+export {
+    getRandArrayItem,
+    chunkArray,
+    getRandFloat,
+    chance,
+    generateBigId,
+    generateId,
+    getRandomBytes,
+    isJSON,
+    shuffle,
+    wait,
+    md5,
+    getRandInteger,
+    getRandString,
+    getRandomArrayItem,
+    getRandomFloat,
+    getRandomInteger,
+    getRandomString,
+    generateUuidV4,
+    generateHexId,
+}
+
+export default sharedUtils

package/src/utils/array/chunkArray.js

@@ -0,0 +1,17 @@
+export default function chunkArray(array, chunkSize) {
+    if (!Array.isArray(array)) {
+        throw new TypeError('array must be an array')
+    }
+
+    if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+        throw new TypeError('chunkSize must be a positive integer')
+    }
+
+    const result = []
+
+    for (let i = 0; i < array.length; i += chunkSize) {
+        result.push(array.slice(i, i + chunkSize))
+    }
+
+    return result
+}

package/src/utils/array/getRandArrayItem.js

@@ -1,3 +1,11 @@
-export default function (array) {
+export default function getRandArrayItem(array) {
+    if (!Array.isArray(array)) {
+        throw new TypeError('array must be an array')
+    }
+
+    if (array.length === 0) {
+        return undefined
+    }
+
     return array[Math.floor(Math.random() * array.length)]
 }

package/src/utils/float/getRandFloat.js

@@ -1,8 +1,16 @@
-export default function (min, max, decimalPoint = 5) {
-    let nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
-    let numString = ''
-    for (let i = 0; i < decimalPoint; i++) {
-        numString += Math.floor(Math.random() * nums.length)
+export default function getRandFloat(min, max, decimalPoint = 5) {
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        throw new TypeError('min and max must be finite numbers')
     }
-    return parseFloat(`${this.getRandInteger(min, max)}.${numString})}`)
+
+    if (!Number.isInteger(decimalPoint) || decimalPoint < 0 || decimalPoint > 15) {
+        throw new RangeError('decimalPoint must be an integer from 0 to 15')
+    }
+
+    const lowerBound = Math.min(min, max)
+    const upperBound = Math.max(min, max)
+    const factor = 10 ** decimalPoint
+    const value = Math.random() * (upperBound - lowerBound) + lowerBound
+
+    return Math.round(value * factor) / factor
 }

package/src/utils/general/chance.js

@@ -1,7 +1,15 @@
-export default function (percent) {
-    if (Math.ceil(Math.random() * 100) <= percent) {
+export default function chance(percent) {
+    if (!Number.isFinite(percent)) {
+        throw new TypeError('percent must be a finite number')
+    }
+
+    if (percent <= 0) {
+        return false
+    }
+
+    if (percent >= 100) {
         return true
     }
 
-    return false
+    return Math.random() * 100 < percent
 }

package/src/utils/general/generateBigId.js

@@ -1,6 +1,11 @@
-export default function () {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (e) {
-        var t = (16 * Math.random()) | 0
-        return ('x' === e ? t : (3 & t) | 8).toString(16)
-    })
+import getRandomBytes from './getRandomBytes.js'
+
+export default function generateBigId() {
+    const bytes = getRandomBytes(16)
+
+    bytes[6] = (bytes[6] & 0x0f) | 0x40
+    bytes[8] = (bytes[8] & 0x3f) | 0x80
+
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
 }

package/src/utils/general/generateId.js

@@ -1,6 +1,5 @@
-export default function () {
-    return 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'.replace(/[xy]/g, function (e) {
-        let t = (16 * Math.random()) | 0
-        return ('x' === e ? t : (3 & t) | 8).toString(16)
-    })
+import getRandomBytes from './getRandomBytes.js'
+
+export default function generateId() {
+    return Array.from(getRandomBytes(16), (byte) => byte.toString(16).padStart(2, '0')).join('')
 }

package/src/utils/general/getRandomBytes.js

@@ -0,0 +1,16 @@
+export default function getRandomBytes(length) {
+    if (!Number.isInteger(length) || length <= 0) {
+        throw new TypeError('length must be a positive integer')
+    }
+
+    if (globalThis.crypto && typeof globalThis.crypto.getRandomValues === 'function') {
+        return globalThis.crypto.getRandomValues(new Uint8Array(length))
+    }
+
+    const bytes = new Uint8Array(length)
+    for (let index = 0; index < bytes.length; index += 1) {
+        bytes[index] = Math.floor(Math.random() * 256)
+    }
+
+    return bytes
+}

package/src/utils/general/isJSON.js

@@ -1,7 +1,12 @@
-export default function (json) {
+export default function isJSON(json) {
+    if (typeof json !== 'string') {
+        return false
+    }
+
     try {
-        if (JSON.parse(json)) return true
-    } catch (e) {
+        JSON.parse(json)
+        return true
+    } catch {
         return false
     }
 }

package/src/utils/general/md5.js

@@ -1,5 +1,200 @@
-import crypto from 'crypto'
+function rotateLeft(value, shift) {
+    return (value << shift) | (value >>> (32 - shift))
+}
+
+function addUnsigned(left, right) {
+    const leftHigh = left & 0x80000000
+    const rightHigh = right & 0x80000000
+    const leftMid = left & 0x40000000
+    const rightMid = right & 0x40000000
+    const result = (left & 0x3fffffff) + (right & 0x3fffffff)
+
+    if (leftMid & rightMid) {
+        return result ^ 0x80000000 ^ leftHigh ^ rightHigh
+    }
+
+    if (leftMid | rightMid) {
+        if (result & 0x40000000) {
+            return result ^ 0xc0000000 ^ leftHigh ^ rightHigh
+        }
+
+        return result ^ 0x40000000 ^ leftHigh ^ rightHigh
+    }
+
+    return result ^ leftHigh ^ rightHigh
+}
+
+function f(x, y, z) {
+    return (x & y) | (~x & z)
+}
+
+function g(x, y, z) {
+    return (x & z) | (y & ~z)
+}
+
+function h(x, y, z) {
+    return x ^ y ^ z
+}
+
+function i(x, y, z) {
+    return y ^ (x | ~z)
+}
+
+function ff(a, b, c, d, x, s, ac) {
+    return addUnsigned(rotateLeft(addUnsigned(addUnsigned(a, f(b, c, d)), addUnsigned(x, ac)), s), b)
+}
+
+function gg(a, b, c, d, x, s, ac) {
+    return addUnsigned(rotateLeft(addUnsigned(addUnsigned(a, g(b, c, d)), addUnsigned(x, ac)), s), b)
+}
+
+function hh(a, b, c, d, x, s, ac) {
+    return addUnsigned(rotateLeft(addUnsigned(addUnsigned(a, h(b, c, d)), addUnsigned(x, ac)), s), b)
+}
+
+function ii(a, b, c, d, x, s, ac) {
+    return addUnsigned(rotateLeft(addUnsigned(addUnsigned(a, i(b, c, d)), addUnsigned(x, ac)), s), b)
+}
+
+function toWordArray(value) {
+    const messageLength = value.length
+    const numberOfWordsTemp1 = messageLength + 8
+    const numberOfWordsTemp2 = (numberOfWordsTemp1 - (numberOfWordsTemp1 % 64)) / 64
+    const numberOfWords = (numberOfWordsTemp2 + 1) * 16
+    const wordArray = Array(numberOfWords - 1)
+    let byteIndex = 0
+    let wordIndex
+
+    while (byteIndex < messageLength) {
+        wordIndex = (byteIndex - (byteIndex % 4)) / 4
+        wordArray[wordIndex] = wordArray[wordIndex] || 0
+        wordArray[wordIndex] |= value.charCodeAt(byteIndex) << ((byteIndex % 4) * 8)
+        byteIndex += 1
+    }
+
+    wordIndex = (byteIndex - (byteIndex % 4)) / 4
+    wordArray[wordIndex] = wordArray[wordIndex] || 0
+    wordArray[wordIndex] |= 0x80 << ((byteIndex % 4) * 8)
+    wordArray[numberOfWords - 2] = messageLength << 3
+    wordArray[numberOfWords - 1] = messageLength >>> 29
+
+    return wordArray
+}
+
+function toHex(value) {
+    let word = ''
+
+    for (let index = 0; index <= 3; index += 1) {
+        const byte = (value >>> (index * 8)) & 255
+        word += `0${byte.toString(16)}`.slice(-2)
+    }
+
+    return word
+}
+
+function toUtf8(value) {
+    const bytes = new TextEncoder().encode(value)
+    let result = ''
+
+    for (let index = 0; index < bytes.length; index += 1) {
+        result += String.fromCharCode(bytes[index])
+    }
+
+    return result
+}
+
+export default function md5(data) {
+    let str
+    if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+        str = Array.from(data, (b) => String.fromCharCode(b)).join('')
+    } else {
+        str = toUtf8(String(data))
+    }
+    const x = toWordArray(str)
+    let a = 0x67452301
+    let b = 0xefcdab89
+    let c = 0x98badcfe
+    let d = 0x10325476
+
+    for (let index = 0; index < x.length; index += 16) {
+        const aOld = a
+        const bOld = b
+        const cOld = c
+        const dOld = d
+
+        a = ff(a, b, c, d, x[index + 0], 7, 0xd76aa478)
+        d = ff(d, a, b, c, x[index + 1], 12, 0xe8c7b756)
+        c = ff(c, d, a, b, x[index + 2], 17, 0x242070db)
+        b = ff(b, c, d, a, x[index + 3], 22, 0xc1bdceee)
+        a = ff(a, b, c, d, x[index + 4], 7, 0xf57c0faf)
+        d = ff(d, a, b, c, x[index + 5], 12, 0x4787c62a)
+        c = ff(c, d, a, b, x[index + 6], 17, 0xa8304613)
+        b = ff(b, c, d, a, x[index + 7], 22, 0xfd469501)
+        a = ff(a, b, c, d, x[index + 8], 7, 0x698098d8)
+        d = ff(d, a, b, c, x[index + 9], 12, 0x8b44f7af)
+        c = ff(c, d, a, b, x[index + 10], 17, 0xffff5bb1)
+        b = ff(b, c, d, a, x[index + 11], 22, 0x895cd7be)
+        a = ff(a, b, c, d, x[index + 12], 7, 0x6b901122)
+        d = ff(d, a, b, c, x[index + 13], 12, 0xfd987193)
+        c = ff(c, d, a, b, x[index + 14], 17, 0xa679438e)
+        b = ff(b, c, d, a, x[index + 15], 22, 0x49b40821)
+
+        a = gg(a, b, c, d, x[index + 1], 5, 0xf61e2562)
+        d = gg(d, a, b, c, x[index + 6], 9, 0xc040b340)
+        c = gg(c, d, a, b, x[index + 11], 14, 0x265e5a51)
+        b = gg(b, c, d, a, x[index + 0], 20, 0xe9b6c7aa)
+        a = gg(a, b, c, d, x[index + 5], 5, 0xd62f105d)
+        d = gg(d, a, b, c, x[index + 10], 9, 0x02441453)
+        c = gg(c, d, a, b, x[index + 15], 14, 0xd8a1e681)
+        b = gg(b, c, d, a, x[index + 4], 20, 0xe7d3fbc8)
+        a = gg(a, b, c, d, x[index + 9], 5, 0x21e1cde6)
+        d = gg(d, a, b, c, x[index + 14], 9, 0xc33707d6)
+        c = gg(c, d, a, b, x[index + 3], 14, 0xf4d50d87)
+        b = gg(b, c, d, a, x[index + 8], 20, 0x455a14ed)
+        a = gg(a, b, c, d, x[index + 13], 5, 0xa9e3e905)
+        d = gg(d, a, b, c, x[index + 2], 9, 0xfcefa3f8)
+        c = gg(c, d, a, b, x[index + 7], 14, 0x676f02d9)
+        b = gg(b, c, d, a, x[index + 12], 20, 0x8d2a4c8a)
+
+        a = hh(a, b, c, d, x[index + 5], 4, 0xfffa3942)
+        d = hh(d, a, b, c, x[index + 8], 11, 0x8771f681)
+        c = hh(c, d, a, b, x[index + 11], 16, 0x6d9d6122)
+        b = hh(b, c, d, a, x[index + 14], 23, 0xfde5380c)
+        a = hh(a, b, c, d, x[index + 1], 4, 0xa4beea44)
+        d = hh(d, a, b, c, x[index + 4], 11, 0x4bdecfa9)
+        c = hh(c, d, a, b, x[index + 7], 16, 0xf6bb4b60)
+        b = hh(b, c, d, a, x[index + 10], 23, 0xbebfbc70)
+        a = hh(a, b, c, d, x[index + 13], 4, 0x289b7ec6)
+        d = hh(d, a, b, c, x[index + 0], 11, 0xeaa127fa)
+        c = hh(c, d, a, b, x[index + 3], 16, 0xd4ef3085)
+        b = hh(b, c, d, a, x[index + 6], 23, 0x04881d05)
+        a = hh(a, b, c, d, x[index + 9], 4, 0xd9d4d039)
+        d = hh(d, a, b, c, x[index + 12], 11, 0xe6db99e5)
+        c = hh(c, d, a, b, x[index + 15], 16, 0x1fa27cf8)
+        b = hh(b, c, d, a, x[index + 2], 23, 0xc4ac5665)
+
+        a = ii(a, b, c, d, x[index + 0], 6, 0xf4292244)
+        d = ii(d, a, b, c, x[index + 7], 10, 0x432aff97)
+        c = ii(c, d, a, b, x[index + 14], 15, 0xab9423a7)
+        b = ii(b, c, d, a, x[index + 5], 21, 0xfc93a039)
+        a = ii(a, b, c, d, x[index + 12], 6, 0x655b59c3)
+        d = ii(d, a, b, c, x[index + 3], 10, 0x8f0ccc92)
+        c = ii(c, d, a, b, x[index + 10], 15, 0xffeff47d)
+        b = ii(b, c, d, a, x[index + 1], 21, 0x85845dd1)
+        a = ii(a, b, c, d, x[index + 8], 6, 0x6fa87e4f)
+        d = ii(d, a, b, c, x[index + 15], 10, 0xfe2ce6e0)
+        c = ii(c, d, a, b, x[index + 6], 15, 0xa3014314)
+        b = ii(b, c, d, a, x[index + 13], 21, 0x4e0811a1)
+        a = ii(a, b, c, d, x[index + 4], 6, 0xf7537e82)
+        d = ii(d, a, b, c, x[index + 11], 10, 0xbd3af235)
+        c = ii(c, d, a, b, x[index + 2], 15, 0x2ad7d2bb)
+        b = ii(b, c, d, a, x[index + 9], 21, 0xeb86d391)
+
+        a = addUnsigned(a, aOld)
+        b = addUnsigned(b, bOld)
+        c = addUnsigned(c, cOld)
+        d = addUnsigned(d, dOld)
+    }
 
-export default function (data) {
-    return crypto.createHash('md5').update(data).digest('hex')
+    return `${toHex(a)}${toHex(b)}${toHex(c)}${toHex(d)}`.toLowerCase()
 }

package/src/utils/general/shuffle.js

@@ -1,7 +1,14 @@
-export default function (variable) {
-    return Array(variable.length)
-        .fill(null)
-        .map((_, i) => [Math.random(), i])
-        .sort(([a], [b]) => a - b)
-        .map(([, i]) => variable[i])
+export default function shuffle(variable) {
+    if (!Array.isArray(variable)) {
+        throw new TypeError('variable must be an array')
+    }
+
+    const result = [...variable]
+
+    for (let index = result.length - 1; index > 0; index -= 1) {
+        const randomIndex = Math.floor(Math.random() * (index + 1))
+        ;[result[index], result[randomIndex]] = [result[randomIndex], result[index]]
+    }
+
+    return result
 }

package/src/utils/general/wait.js

@@ -1,7 +1,9 @@
-export default function (miliseconds) {
+export default function wait(milliseconds) {
+    if (!Number.isFinite(milliseconds) || milliseconds < 0) {
+        throw new TypeError('milliseconds must be a non-negative number')
+    }
+
     return new Promise((resolve) => {
-        setTimeout(() => {
-            resolve()
-        }, miliseconds)
+        setTimeout(resolve, milliseconds)
     })
 }

package/src/utils/integer/getRandInteger.js

@@ -1,3 +1,14 @@
-export default function (min, max) {
-    return Math.floor(Math.random() * (Math.floor(max) - Math.ceil(min) + 1)) + Math.ceil(min)
+export default function getRandInteger(min, max) {
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        throw new TypeError('min and max must be finite numbers')
+    }
+
+    const lowerBound = Math.ceil(Math.min(min, max))
+    const upperBound = Math.floor(Math.max(min, max))
+
+    if (lowerBound > upperBound) {
+        throw new RangeError('min and max do not contain an integer range')
+    }
+
+    return Math.floor(Math.random() * (upperBound - lowerBound + 1)) + lowerBound
 }

package/src/utils/os/getCPUUsage.js

@@ -1,31 +1,38 @@
-import os from 'os'
+import os from 'node:os'
 
-export default function (ms = 1000, free = false) {
-    function getCPUInfo() {
-        let stats = os.cpus().map((cpu) => {
-            return {
-                total: cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq,
-                idle: cpu.times.idle,
-            }
-        })
+function sampleCPUInfo() {
+    const stats = os.cpus().map((cpu) => {
+        return {
+            total: cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq,
+            idle: cpu.times.idle,
+        }
+    })
 
-        return stats.reduce((a, b) => {
+    return stats.reduce(
+        (accumulator, current) => {
             return {
-                total: a.total + b.total,
-                idle: a.idle + b.idle,
+                total: accumulator.total + current.total,
+                idle: accumulator.idle + current.idle,
             }
-        })
+        },
+        { total: 0, idle: 0 }
+    )
+}
+
+export default function getCPUUsage(ms = 1000, free = false) {
+    if (!Number.isFinite(ms) || ms < 0) {
+        throw new TypeError('ms must be a non-negative number')
     }
 
     return new Promise((resolve) => {
-        const startStats = getCPUInfo()
+        const startStats = sampleCPUInfo()
+
         setTimeout(() => {
-            const endStats = getCPUInfo()
-            if (free) {
-                resolve((endStats.idle - startStats.idle) / (endStats.total - startStats.total))
-            } else {
-                resolve(1 - (endStats.idle - startStats.idle) / (endStats.total - startStats.total))
-            }
+            const endStats = sampleCPUInfo()
+            const totalDelta = endStats.total - startStats.total
+            const idleDelta = endStats.idle - startStats.idle
+            const idleRatio = totalDelta === 0 ? 0 : idleDelta / totalDelta
+            resolve(free ? idleRatio : 1 - idleRatio)
         }, ms)
     })
 }

package/src/utils/os/getLocalAddress.js

@@ -1,20 +1,24 @@
-import os from 'os'
+import os from 'node:os'
 
-export default function () {
-    let networkInterfaces = os.networkInterfaces()
+function isIPv4Interface(networkInterface) {
+    return (networkInterface.family === 'IPv4' || networkInterface.family === 4) && !networkInterface.internal
+}
+
+export default function getLocalAddress() {
+    const networkInterfaces = os.networkInterfaces()
+    const addresses = []
 
-    let localAddresses = []
-    for (let index in networkInterfaces) {
-        let interIPv4 = networkInterfaces[index]
-            .filter((inter) => {
-                return inter.family == 'IPv4' && inter.address != '127.0.0.1'
-            })
-            .map((inter) => {
-                return inter.address
-            })
+    for (const interfaces of Object.values(networkInterfaces)) {
+        if (!Array.isArray(interfaces)) {
+            continue
+        }
 
-        localAddresses = localAddresses.concat(interIPv4)
+        for (const networkInterface of interfaces) {
+            if (isIPv4Interface(networkInterface)) {
+                addresses.push(networkInterface.address)
+            }
+        }
     }
 
-    return localAddresses[0]
+    return addresses[0]
 }

package/src/utils/os/getLocalAddresses.js

@@ -1,20 +1,24 @@
-import os from 'os'
+import os from 'node:os'
 
-export default function () {
-    let networkInterfaces = os.networkInterfaces()
+function isIPv4Interface(networkInterface) {
+    return (networkInterface.family === 'IPv4' || networkInterface.family === 4) && !networkInterface.internal
+}
+
+export default function getLocalAddresses() {
+    const networkInterfaces = os.networkInterfaces()
+    const addresses = []
 
-    let localAddresses = []
-    for (let index in networkInterfaces) {
-        let interIPv4 = networkInterfaces[index]
-            .filter((inter) => {
-                return inter.family == 'IPv4' && inter.address != '127.0.0.1'
-            })
-            .map((inter) => {
-                return inter.address
-            })
+    for (const interfaces of Object.values(networkInterfaces)) {
+        if (!Array.isArray(interfaces)) {
+            continue
+        }
 
-        localAddresses = localAddresses.concat(interIPv4)
+        for (const networkInterface of interfaces) {
+            if (isIPv4Interface(networkInterface)) {
+                addresses.push(networkInterface.address)
+            }
+        }
     }
 
-    return localAddresses
+    return addresses
 }

package/src/utils/string/getRandString.js

@@ -1,9 +1,16 @@
-export default function (length = 16, charSet) {
-    var result = []
-    charSet = charSet || 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+export default function getRandString(length = 16, charSet) {
+    if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError('length must be a non-negative integer')
+    }
+
+    const normalizedCharSet = charSet === undefined ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' : charSet
+    if (typeof normalizedCharSet !== 'string' || normalizedCharSet.length === 0) {
+        throw new TypeError('charSet must be a non-empty string')
+    }
 
-    while (length--) {
-        result.push(charSet[Math.floor(Math.random() * charSet.length)])
+    const result = []
+    for (let index = 0; index < length; index += 1) {
+        result.push(normalizedCharSet[Math.floor(Math.random() * normalizedCharSet.length)])
     }
 
     return result.join('')

package/.eslintrc

@@ -1,21 +0,0 @@
-{
-    "extends": ["airbnb", "eslint-config-airbnb-base", "prettier"],
-    "rules": {
-        "indent": ["error", 4],
-        "semi": "off",
-        "prettier/prettier": ["error"],
-        "no-unused-vars": "warn",
-        "max-len": ["error", { "code": 150 }],
-        "no-console": "off",
-        "import/extensions": "off"
-    },
-    "parserOptions": {
-        "ecmaVersion": 2022,
-        "sourceType": "module"
-    },
-    "env": {
-        "es6": true,
-        "node": true
-    },
-    "plugins": ["import", "prettier", "node"]
-}

package/.prettierrc

@@ -1,11 +0,0 @@
-{
-  "singleQuote": true,
-  "semi": false,
-  "tabWidth": 4,
-  "printWidth": 150,
-  "arrowParens": "always",
-  "bracketSpacing": true,
-  "arrayBracketSpacing": true,
-  "jsxBracketSameLine": false,
-  "trailingComma": "es5"
-}

package/tests/index.js

@@ -1,25 +0,0 @@
-import utils from '../src/index.js'
-
-// ARRAY
-console.log(utils.getRandArrayItem([1, 2, 3, 4, 5, 6, 7, 8, 9]))
-
-// FLOAT
-console.log(utils.getRandFloat(0, 1, 3))
-
-// GENERAL
-console.log(utils.chance(20))
-console.log(utils.generateBigId())
-console.log(utils.generateId())
-console.log(utils.isJSON('{}'))
-console.log(utils.shuffle([1, 2, 3, 4, 5, 6, 7, 8]))
-console.log(utils.wait(1000))
-
-// INTEGER
-console.log(utils.getRandInteger(1, 2000))
-
-// OS
-console.log(utils.getLocalAddress())
-console.log(utils.getLocalAddresses())
-
-// STRING
-console.log(utils.getRandString(2))