@kdtlabs/utils 0.0.4 → 0.0.6

package/src/functions/executions.ts

@@ -0,0 +1,12 @@
+import type { Nullish } from '../core'
+import type { Fn } from './types'
+
+export const noop = () => void 0
+
+export const invoke = <T>(fn: () => T) => fn()
+
+export function invokes(functions: Array<Nullish<Fn>>) {
+    for (const fn of functions) {
+        fn?.()
+    }
+}

package/src/functions/guards.ts

@@ -0,0 +1,5 @@
+import type { Fn } from './types'
+
+export const isFunction = <T extends Fn>(value: unknown): value is T => (
+    typeof value === 'function'
+)

package/src/functions/index.ts

@@ -0,0 +1,11 @@
+export * from './compositions'
+export * from './debounce'
+export * from './executions'
+export * from './guards'
+export * from './memoize'
+export * from './once'
+export * from './pipe'
+export * from './throttle'
+export * from './timer-state'
+
+export type * from './types'

package/src/functions/memoize.ts

@@ -0,0 +1,33 @@
+import type { Args, Fn } from './types'
+
+export interface MemoizeCache<V = unknown> {
+    delete(key: unknown): boolean
+    get(key: unknown): V | undefined
+    has(key: unknown): boolean
+    set(key: unknown, value: V): void
+}
+
+export interface MemoizeOptions<T extends Fn> {
+    cache?: MemoizeCache<ReturnType<T>>
+    resolver?: (...args: Args<T>) => unknown
+}
+
+export function memoize<T extends Fn>(fn: T, { cache = new Map(), resolver }: MemoizeOptions<T> = {}) {
+    const memoized = function (this: unknown, ...args: Args<T>) {
+        const key = resolver ? resolver(...args) : args[0]
+
+        if (cache.has(key)) {
+            return cache.get(key)
+        }
+
+        const result = fn.apply(this, args)
+
+        cache.set(key, result)
+
+        return result
+    } as T & { cache: MemoizeCache<ReturnType<T>> }
+
+    memoized.cache = cache
+
+    return memoized
+}

package/src/functions/once.ts

@@ -0,0 +1,33 @@
+import type { Args, Fn } from './types'
+import { normalizeError } from '../errors'
+
+export function once<T extends Fn>(fn: T) {
+    let called = false
+    let result: ReturnType<T>
+    let error: unknown
+
+    const cb = (...args: Args<T>): ReturnType<T> => {
+        if (called) {
+            if (error) {
+                throw normalizeError(error)
+            }
+
+            return result
+        }
+
+        called = true
+
+        try {
+            return (result = fn(...args))
+        } catch (error_) {
+            throw error = normalizeError(error_)
+        }
+    }
+
+    cb.reset = () => {
+        called = false
+        error = undefined
+    }
+
+    return cb
+}

package/src/functions/pipe.ts

@@ -0,0 +1,39 @@
+import type { Fn } from './types'
+import { isNonEmptyArray } from '../arrays'
+
+export function pipe(): void
+export function pipe<T>(fn: () => T): T
+export function pipe<T1, T2>(fn1: () => T1, fn2: (arg: T1) => T2): T2
+export function pipe<T1, T2, T3>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3): T3
+export function pipe<T1, T2, T3, T4>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4): T4
+export function pipe<T1, T2, T3, T4, T5>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5): T5
+export function pipe<T1, T2, T3, T4, T5, T6>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6): T6
+export function pipe<T1, T2, T3, T4, T5, T6, T7>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7): T7
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8): T8
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9): T9
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10): T10
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11): T11
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12): T12
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13): T13
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14): T14
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14, fn15: (arg: T14) => T15): T15
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14, fn15: (arg: T14) => T15, fn16: (arg: T15) => T16): T16
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14, fn15: (arg: T14) => T15, fn16: (arg: T15) => T16, fn17: (arg: T16) => T17): T17
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14, fn15: (arg: T14) => T15, fn16: (arg: T15) => T16, fn17: (arg: T16) => T17, fn18: (arg: T17) => T18): T18
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14, fn15: (arg: T14) => T15, fn16: (arg: T15) => T16, fn17: (arg: T16) => T17, fn18: (arg: T17) => T18, fn19: (arg: T18) => T19): T19
+export function pipe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>(fn1: () => T1, fn2: (arg: T1) => T2, fn3: (arg: T2) => T3, fn4: (arg: T3) => T4, fn5: (arg: T4) => T5, fn6: (arg: T5) => T6, fn7: (arg: T6) => T7, fn8: (arg: T7) => T8, fn9: (arg: T8) => T9, fn10: (arg: T9) => T10, fn11: (arg: T10) => T11, fn12: (arg: T11) => T12, fn13: (arg: T12) => T13, fn14: (arg: T13) => T14, fn15: (arg: T14) => T15, fn16: (arg: T15) => T16, fn17: (arg: T16) => T17, fn18: (arg: T17) => T18, fn19: (arg: T18) => T19, fn20: (arg: T19) => T20): T20
+export function pipe(...fns: Fn[]): unknown
+
+export function pipe(...fns: Fn[]) {
+    if (!isNonEmptyArray(fns)) {
+        return
+    }
+
+    let result = fns[0]()
+
+    for (let i = 1; i < fns.length; i++) {
+        result = fns[i]!(result)
+    }
+
+    return result
+}

package/src/functions/throttle.ts

@@ -0,0 +1,59 @@
+import type { Args, Fn, TimingControlled } from './types'
+import { createTimerState, flushTimer, invokeTimer } from './timer-state'
+
+export type Throttled<T extends Fn> = TimingControlled<T>
+
+export function throttle<T extends Fn>(fn: T, wait: number): Throttled<T> {
+    const state = createTimerState<T>()
+
+    let lastCallTime: number | undefined
+
+    const invoke = () => {
+        lastCallTime = Date.now()
+        invokeTimer(state, fn)
+    }
+
+    const throttled: Throttled<T> = function (this: unknown, ...args: Args<T>) {
+        const now = Date.now()
+
+        state.lastArgs = args
+        state.lastThis = this
+
+        if (lastCallTime === undefined) {
+            lastCallTime = now
+            state.lastResult = fn.apply(this, args)
+
+            return
+        }
+
+        const remaining = wait - (now - lastCallTime)
+
+        if (remaining <= 0) {
+            if (state.timeoutId !== undefined) {
+                clearTimeout(state.timeoutId)
+                state.timeoutId = undefined
+            }
+
+            lastCallTime = now
+            state.lastResult = fn.apply(this, args)
+        } else {
+            state.timeoutId ??= setTimeout(invoke, remaining)
+        }
+    }
+
+    throttled.cancel = () => {
+        if (state.timeoutId !== undefined) {
+            clearTimeout(state.timeoutId)
+            state.timeoutId = undefined
+        }
+
+        state.lastArgs = undefined
+        lastCallTime = undefined
+    }
+
+    throttled.flush = () => {
+        return flushTimer(state, invoke)
+    }
+
+    return throttled
+}

package/src/functions/timer-state.ts

@@ -0,0 +1,33 @@
+import type { Args, Fn } from './types'
+
+export interface TimerState<T extends Fn> {
+    lastArgs: Args<T> | undefined
+    lastResult: ReturnType<T> | undefined
+    lastThis: unknown
+    timeoutId: ReturnType<typeof setTimeout> | undefined
+}
+
+export const createTimerState = <T extends Fn>(): TimerState<T> => ({
+    lastArgs: undefined,
+    lastResult: undefined,
+    lastThis: undefined,
+    timeoutId: undefined,
+})
+
+export function invokeTimer<T extends Fn>(state: TimerState<T>, fn: T) {
+    const args = state.lastArgs!
+    const thisArg = state.lastThis
+
+    state.timeoutId = undefined
+    state.lastArgs = undefined
+    state.lastResult = fn.apply(thisArg, args)
+}
+
+export function flushTimer<T extends Fn>(state: TimerState<T>, invoke: () => void) {
+    if (state.timeoutId !== undefined) {
+        clearTimeout(state.timeoutId)
+        invoke()
+    }
+
+    return state.lastResult
+}

package/src/functions/types.ts

@@ -0,0 +1,8 @@
+export type Fn = (...args: any[]) => any
+
+export type Args<F extends Fn> = F extends (...args: infer A) => any ? A : never
+
+export type TimingControlled<T extends Fn> = ((...args: Args<T>) => void) & {
+    cancel: () => void
+    flush: () => ReturnType<T> | undefined
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export * from './arrays'
+export * from './buffers'
+export * from './collections'
+export * from './common'
+export * from './core'
+export * from './errors'
+export * from './events'
+export * from './functions'
+export * from './json-rpc'
+export * from './numbers'
+export * from './objects'
+export * from './promises'
+export * from './serializer'
+export * from './strings'
+export * from './system'
+export * from './times'

package/src/json-rpc/constants.ts

@@ -0,0 +1,15 @@
+export enum JsonRpcErrorCode {
+    ParseError = -32_700,
+    InternalError = -32_603,
+    InvalidParams = -32_602,
+    MethodNotFound = -32_601,
+    InvalidRequest = -32_600,
+}
+
+export const JSON_RPC_ERROR_MESSAGES: Record<JsonRpcErrorCode, string> = {
+    [JsonRpcErrorCode.InternalError]: 'Internal error',
+    [JsonRpcErrorCode.InvalidParams]: 'Invalid params',
+    [JsonRpcErrorCode.InvalidRequest]: 'Invalid request',
+    [JsonRpcErrorCode.MethodNotFound]: 'Method not found',
+    [JsonRpcErrorCode.ParseError]: 'Parse error',
+}

package/src/json-rpc/factories.ts

@@ -0,0 +1,22 @@
+import type { JsonRpcErrorObject, JsonRpcErrorResponseMessage, JsonRpcNotifyMessage, JsonRpcRequestMessage, JsonRpcResponseId, JsonRpcSuccessResponseMessage } from './types'
+import { notUndefined } from '../core'
+
+export const createJsonRpcNotifyMessage = <TParams>(method: string, params?: TParams): JsonRpcNotifyMessage<TParams> => ({
+    jsonrpc: '2.0', method, ...(notUndefined(params) ? { params } : {}),
+})
+
+export const createJsonRpcRequestMessage = <TParams>(id: number | string, method: string, params?: TParams): JsonRpcRequestMessage<TParams> => ({
+    id, jsonrpc: '2.0', method, ...(notUndefined(params) ? { params } : {}),
+})
+
+export const createJsonRpcSuccessResponseMessage = <TResult = any>(id: JsonRpcResponseId, result: TResult): JsonRpcSuccessResponseMessage<TResult> => ({
+    id, jsonrpc: '2.0', result,
+})
+
+export const createJsonRpcErrorObject = <TData>(code: number, message: string, data?: TData): JsonRpcErrorObject<TData> => ({
+    code, message, ...(notUndefined(data) ? { data } : {}),
+})
+
+export const createJsonRpcErrorResponseMessage = <TData>(id: JsonRpcResponseId, error: JsonRpcErrorObject<TData>): JsonRpcErrorResponseMessage<TData> => ({
+    error, id, jsonrpc: '2.0',
+})

package/src/json-rpc/guards.ts

@@ -0,0 +1,58 @@
+import type { JsonRpcBatchRequest, JsonRpcBatchResponse, JsonRpcErrorObject, JsonRpcErrorResponseMessage, JsonRpcMessage, JsonRpcNotifyMessage, JsonRpcRequestMessage, JsonRpcResponseId, JsonRpcResponseMessage, JsonRpcResponseMessageWithNonNullId, JsonRpcSuccessResponseMessage } from './types'
+import { isArray } from '../arrays'
+import { isNull, isNumber, isString, notNullish } from '../core'
+import { isKeysOf, isObject } from '../objects'
+
+export const isJsonRpcMessage = <TParams = any, TResult = any, TErrorData = any>(message: unknown): message is JsonRpcMessage<TParams, TResult, TErrorData> => (
+    isObject(message) && message.jsonrpc === '2.0'
+)
+
+export const isValidJsonRpcId = (id: unknown): id is JsonRpcResponseId => isString(id) || isNumber(id) || isNull(id)
+
+export const isJsonRpcRequestMessage = <TParams = any>(message: JsonRpcMessage): message is JsonRpcRequestMessage<TParams> => (
+    isKeysOf(message, 'id', 'method') && isValidJsonRpcId(message.id) && isString(message.method)
+)
+
+export const isJsonRpcNotifyMessage = <TParams = any>(message: JsonRpcMessage): message is JsonRpcNotifyMessage<TParams> => (
+    isKeysOf(message, 'method') && isString(message.method) && !isKeysOf(message, 'id')
+)
+
+export const isJsonRpcResponseMessage = <TResult = any, TErrorData = any>(message: JsonRpcMessage): message is JsonRpcResponseMessage<TResult, TErrorData> => (
+    isKeysOf(message, 'id') && isValidJsonRpcId(message.id) && !isKeysOf(message, 'method')
+)
+
+export const isJsonRpcError = <TData = any>(message: unknown): message is JsonRpcErrorObject<TData> => (
+    isObject(message) && isKeysOf(message, 'code', 'message')
+)
+
+export const isJsonRpcErrorResponseMessage = <TData = any>(message: JsonRpcMessage): message is JsonRpcErrorResponseMessage<TData> => (
+    isKeysOf(message, 'error') && isJsonRpcError(message.error)
+)
+
+export const isJsonRpcSuccessResponseMessage = <TResult = any>(message: JsonRpcMessage): message is JsonRpcSuccessResponseMessage<TResult> => (
+    isKeysOf(message, 'result') && !isKeysOf(message, 'error')
+)
+
+export const isJsonRpcResponseHasNonNullableId = <TResult = any, TErrorData = any>(response: JsonRpcResponseMessage): response is JsonRpcResponseMessageWithNonNullId<TResult, TErrorData> => (
+    notNullish(response.id)
+)
+
+export const isJsonRpcBatchRequest = <TParams = any>(value: unknown): value is JsonRpcBatchRequest<TParams> => (
+    isArray(value) && value.length > 0 && value.every((item) => {
+        if (!isJsonRpcMessage(item)) {
+            return false
+        }
+
+        return isJsonRpcRequestMessage(item) || isJsonRpcNotifyMessage(item)
+    })
+)
+
+export const isJsonRpcBatchResponse = <TResult = any, TErrorData = any>(value: unknown): value is JsonRpcBatchResponse<TResult, TErrorData> => (
+    isArray(value) && value.length > 0 && value.every((item) => {
+        if (!isJsonRpcMessage(item)) {
+            return false
+        }
+
+        return isJsonRpcResponseMessage(item)
+    })
+)

package/src/json-rpc/index.ts

@@ -0,0 +1,5 @@
+export * from './constants'
+export * from './factories'
+export * from './guards'
+
+export type * from './types'

package/src/json-rpc/types.ts

@@ -0,0 +1,48 @@
+export interface BaseJsonRpcMessage {
+    jsonrpc: '2.0'
+}
+
+export interface JsonRpcRequestMessage<TParams = any> extends BaseJsonRpcMessage {
+    id: number | string
+    method: string
+    params?: TParams
+}
+
+export interface JsonRpcNotifyMessage<TParams = any> extends BaseJsonRpcMessage {
+    method: string
+    params?: TParams
+}
+
+export interface JsonRpcErrorObject<TData = any> {
+    code: number
+    data?: TData
+    message: string
+}
+
+export type JsonRpcResponseId = number | string | null
+
+export interface BaseJsonRpcResponseMessage extends BaseJsonRpcMessage {
+    id: JsonRpcResponseId
+}
+
+export interface JsonRpcSuccessResponseMessage<TResult = any> extends BaseJsonRpcResponseMessage {
+    result: TResult
+}
+
+export interface JsonRpcErrorResponseMessage<TData = any> extends BaseJsonRpcResponseMessage {
+    error: JsonRpcErrorObject<TData>
+}
+
+export type JsonRpcResponseMessage<TResult = any, TErrorData = any> = JsonRpcErrorResponseMessage<TErrorData> | JsonRpcSuccessResponseMessage<TResult>
+
+export type JsonRpcResponseBodyWithoutId<TResult = any, TErrorData = any> = Omit<JsonRpcErrorResponseMessage<TErrorData>, 'id'> | Omit<JsonRpcSuccessResponseMessage<TResult>, 'id'>
+
+export type JsonRpcResponseMessageWithNonNullId<TResult = any, TErrorData = any> = JsonRpcResponseBodyWithoutId<TResult, TErrorData> & {
+    id: NonNullable<JsonRpcResponseId>
+}
+
+export type JsonRpcMessage<TParams = any, TResult = any, TErrorData = any> = JsonRpcNotifyMessage<TParams> | JsonRpcRequestMessage<TParams> | JsonRpcResponseMessage<TResult, TErrorData>
+
+export type JsonRpcBatchRequest<TParams = any> = Array<JsonRpcNotifyMessage<TParams> | JsonRpcRequestMessage<TParams>>
+
+export type JsonRpcBatchResponse<TResult = any, TErrorData = any> = Array<JsonRpcResponseMessage<TResult, TErrorData>>

package/src/numbers/bigint-math.ts

@@ -0,0 +1,163 @@
+export const BigIntMath = {
+    isEven(a: bigint) {
+        return a % 2n === 0n
+    },
+
+    isOdd(a: bigint) {
+        return a % 2n !== 0n
+    },
+
+    divMod(a: bigint, b: bigint): [quotient: bigint, remainder: bigint] {
+        if (b === 0n) {
+            throw new RangeError('Division by zero')
+        }
+
+        return [a / b, a % b]
+    },
+
+    abs(a: bigint) {
+        return a < 0n ? -a : a
+    },
+
+    max(a: bigint, b: bigint) {
+        return a > b ? a : b
+    },
+
+    min(a: bigint, b: bigint) {
+        return a < b ? a : b
+    },
+
+    pow(a: bigint, b: bigint) {
+        return a ** b
+    },
+
+    sign(a: bigint) {
+        return a === 0n ? 0n : (a < 0n ? -1n : 1n)
+    },
+
+    mod(a: bigint, b: bigint) {
+        return ((a % b) + b) % b
+    },
+
+    modPow(base: bigint, exponent: bigint, modulus: bigint) {
+        if (exponent < 0n) {
+            throw new RangeError('Exponent must be non-negative')
+        }
+
+        if (modulus === 1n) {
+            return 0n
+        }
+
+        let result = 1n
+
+        base = BigIntMath.mod(base, modulus)
+
+        while (exponent > 0n) {
+            if (exponent % 2n === 1n) {
+                result = BigIntMath.mod(result * base, modulus)
+            }
+
+            exponent >>= 1n
+            base = BigIntMath.mod(base * base, modulus)
+        }
+
+        return result
+    },
+
+    gcd(a: bigint, b: bigint) {
+        a = BigIntMath.abs(a)
+        b = BigIntMath.abs(b)
+
+        while (b !== 0n) {
+            [a, b] = [b, a % b]
+        }
+
+        return a
+    },
+
+    lcm(a: bigint, b: bigint) {
+        return (a / BigIntMath.gcd(a, b)) * b
+    },
+
+    clamp(value: bigint, min: bigint, max: bigint) {
+        return BigIntMath.min(BigIntMath.max(value, min), max)
+    },
+
+    sqrt(n: bigint) {
+        if (n < 0n) {
+            throw new RangeError('Square root of negative bigint is undefined')
+        }
+
+        if (n < 2n) {
+            return n
+        }
+
+        let x = n
+        let y = (x + 1n) / 2n
+
+        while (y < x) {
+            x = y
+            y = (x + n / x) / 2n
+        }
+
+        return x
+    },
+
+    factorial(n: bigint) {
+        if (n < 0n) {
+            throw new RangeError('Factorial of negative bigint is undefined')
+        }
+
+        if (n === 0n) {
+            return 1n
+        }
+
+        let result = 1n
+
+        for (let i = 1n; i <= n; i++) {
+            result *= i
+        }
+
+        return result
+    },
+
+    sum(array: bigint[]) {
+        return array.reduce((a, b) => a + b, 0n)
+    },
+
+    avg(array: bigint[]) {
+        if (array.length === 0) {
+            return 0n
+        }
+
+        return BigIntMath.sum(array) / BigInt(array.length)
+    },
+
+    isPrime(n: bigint) {
+        if (n < 2n) {
+            return false
+        }
+
+        if (n < 4n) {
+            return true
+        }
+
+        if (n % 2n === 0n || n % 3n === 0n) {
+            return false
+        }
+
+        const limit = BigIntMath.sqrt(n)
+
+        for (let i = 5n; i <= limit; i += 6n) {
+            if (n % i === 0n || n % (i + 2n) === 0n) {
+                return false
+            }
+        }
+
+        return true
+    },
+
+    compare(a: bigint, b: bigint) {
+        return a === b ? 0 : (a < b ? -1 : 1)
+    },
+}

package/src/numbers/constants.ts

@@ -0,0 +1,14 @@
+export const SPECIAL_NUMBER_STRINGS = new Set(['+Infinity', '-Infinity', 'Infinity', 'NaN'])
+
+export const SUBSCRIPT_CHARS: Record<string, string> = {
+    0: '\u2080',
+    1: '\u2081',
+    2: '\u2082',
+    3: '\u2083',
+    4: '\u2084',
+    5: '\u2085',
+    6: '\u2086',
+    7: '\u2087',
+    8: '\u2088',
+    9: '\u2089',
+}