@kdtlabs/utils 0.0.3 → 0.0.5

package/src/serializer/serializers/primitive.ts

@@ -0,0 +1,32 @@
+import type { Jsonable } from '../../core'
+import type { SerializeContext } from '../types'
+import { isBigInt, isJsonablePrimitive, isNumber, isSymbol } from '../../core'
+import { serializeNumber } from './number'
+
+export function serializePrimitive(value: unknown, ctx: SerializeContext): Jsonable | undefined {
+    if (value === null) {
+        return null
+    }
+
+    if (value === undefined) {
+        return ctx.replacer({ type: 'undefined', value: null })
+    }
+
+    if (isNumber(value)) {
+        return serializeNumber(value, ctx)
+    }
+
+    if (isJsonablePrimitive(value)) {
+        return value
+    }
+
+    if (isBigInt(value)) {
+        return ctx.replacer({ type: 'bigint', value: value.toString() })
+    }
+
+    if (isSymbol(value)) {
+        return ctx.replacer({ type: 'symbol', value: ctx.symbolRegistry(value) })
+    }
+
+    return undefined
+}

package/src/serializer/symbol-registry.ts

@@ -0,0 +1,28 @@
+export function createSymbolKeySerializer() {
+    const cache = new Map<symbol, string>()
+    const usedKeys = new Set<string>()
+
+    let counter = 0
+
+    return (symbol: symbol): string => {
+        const cached = cache.get(symbol)
+
+        if (cached !== undefined) {
+            return cached
+        }
+
+        const desc = symbol.description
+        const base = desc?.length ? desc : `@@${++counter}`
+
+        let key = `[Symbol(${base})]`
+
+        while (usedKeys.has(key)) {
+            key = `[Symbol(${base}@@${++counter})]`
+        }
+
+        usedKeys.add(key)
+        cache.set(symbol, key)
+
+        return key
+    }
+}

package/src/serializer/types.ts

@@ -0,0 +1,42 @@
+import type { Jsonable } from '../core'
+import type { OMIT_SENTINEL } from './constants'
+
+export interface SerializedValue {
+    __serialized__: true
+    metadata?: Record<string, Jsonable>
+    type: string
+    value: Jsonable
+}
+
+export type SerializeReplacer = (value: Omit<SerializedValue, '__serialized__'>) => Jsonable
+
+export type SerializeErrorStrategy = 'omit' | 'placeholder' | 'throw'
+
+export interface SerializeErrorHandlers {
+    circularRef?: SerializeErrorStrategy
+    maxDepth?: SerializeErrorStrategy
+    propertyAccess?: SerializeErrorStrategy
+}
+
+export interface SerializeOptions {
+    maxDepth?: number
+    onError?: SerializeErrorHandlers | SerializeErrorStrategy
+    onUnserializable?: ((value: unknown) => Jsonable) | false
+    replacer?: SerializeReplacer
+}
+
+export interface SerializeContext {
+    depth: number
+    readonly maxDepth: number
+    readonly onCircularRef: SerializeErrorStrategy
+    readonly onMaxDepth: SerializeErrorStrategy
+    readonly onPropertyAccess: SerializeErrorStrategy
+    readonly onUnserializable: ((value: unknown) => Jsonable) | false
+    readonly replacer: SerializeReplacer
+    readonly symbolRegistry: (symbol: symbol) => string
+    readonly visited: Set<object>
+}
+
+export type SerializeValueFn = (value: unknown, ctx: SerializeContext) => Jsonable | typeof OMIT_SENTINEL
+
+export type ErrorPropertyValue = Jsonable | typeof OMIT_SENTINEL | undefined

package/src/serializer/utils.ts

@@ -0,0 +1,15 @@
+import type { Jsonable } from '../core'
+import type { SerializeContext, SerializeErrorStrategy } from './types'
+import { OMIT_SENTINEL } from './constants'
+
+export function handleError(strategy: SerializeErrorStrategy, type: string, placeholder: string, ctx: SerializeContext): Jsonable | typeof OMIT_SENTINEL {
+    if (strategy === 'throw') {
+        throw new Error(placeholder)
+    }
+
+    if (strategy === 'omit') {
+        return OMIT_SENTINEL
+    }
+
+    return ctx.replacer({ type, value: placeholder })
+}

package/src/strings/constants.ts

@@ -0,0 +1 @@
+export const WHITESPACE_CHARACTERS = new Set([' ', '\n', '\r', '\t', '\v', '\f'])

package/src/strings/factories.ts

@@ -0,0 +1,9 @@
+export function randomStr(length = 16, characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
+    let result = ''
+
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length))
+    }
+
+    return result
+}

package/src/strings/guards.ts

@@ -0,0 +1,51 @@
+import type { Nullish } from '../core'
+import type { HexString, UrlLike } from './types'
+import { wrap } from '../arrays'
+import { transform, tryCatch } from '../functions'
+
+export const isEmptyString = (value: string) => value.length === 0
+
+export function isValidProtocol({ protocol }: URL, protocols?: Nullish<string[]>) {
+    if (!protocols?.length) {
+        return true
+    }
+
+    return protocols.some((x) => `${x.toLowerCase()}:` === protocol)
+}
+
+export function isValidUrl(url: UrlLike, protocols?: Nullish<string[]>) {
+    if (url instanceof URL) {
+        return isValidProtocol(url, protocols)
+    }
+
+    return tryCatch(() => isValidProtocol(new URL(url), protocols), false)
+}
+
+export const isWebSocketUrl = (url: UrlLike, wsProtocols = ['ws', 'wss']) => isValidUrl(url, wsProtocols)
+
+export const isHttpUrl = (url: UrlLike, httpProtocols = ['http', 'https']) => isValidUrl(url, httpProtocols)
+
+export const isStringEquals = (str: string, ...others: string[]) => others.length > 0 && others.every((other) => str === other)
+
+export const isStringEqualsIgnoreCase = (str: string, ...others: string[]) => (
+    others.length > 0 && transform(str.toLowerCase(), (x) => others.every((other) => x === other.toLowerCase()))
+)
+
+export const isIncludesAll = (str: string, search: string[]) => search.every((s) => str.includes(s))
+
+export const isIncludesAny = (str: string, search: string[]) => search.some((s) => str.includes(s))
+
+export const isIncludes = (str: string, search: string[] | string, type: 'all' | 'any' = 'all') => (
+    type === 'all' ? isIncludesAll(str, wrap(search)) : isIncludesAny(str, wrap(search))
+)
+
+export function isHexString(value: string, length?: number) {
+    const len = length ? `{${length * 2}}` : '+'
+    const regex = new RegExp(`^(?:0x)?[0-9a-f]${len}$`, 'iu')
+
+    return regex.test(value)
+}
+
+export const isStrictHexString = (value: string, length?: number): value is HexString => (
+    value.startsWith('0x') && isHexString(value, length)
+)

package/src/strings/index.ts

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

package/src/strings/manipulations.ts

@@ -0,0 +1,99 @@
+import type { Numberish } from '../numbers'
+import { WHITESPACE_CHARACTERS } from './constants'
+
+export const ensurePrefix = (str: string, prefix: string) => (str.startsWith(prefix) ? str : prefix + str)
+
+export const ensureSuffix = (str: string, suffix: string) => (str.endsWith(suffix) ? str : str + suffix)
+
+export const stripPrefix = (str: string, prefix: string) => (str.startsWith(prefix) ? str.slice(prefix.length) : str)
+
+export const stripSuffix = (str: string, suffix: string) => (suffix.length > 0 && str.endsWith(suffix) ? str.slice(0, -suffix.length) : str)
+
+export const capitalize = (str: string) => str.charAt(0).toUpperCase() + str.slice(1)
+
+export const escapeRegExp = (input: string) => (
+    input.replaceAll(/[$()*+.?[\\\]^{|}]/gu, String.raw`\$&`).replaceAll('-', String.raw`\x2d`)
+)
+
+export function * chunkStr(str: string, size: number) {
+    if (size <= 0) {
+        throw new RangeError(`chunk size must be a positive number, got ${size}`)
+    }
+
+    const len = str.length
+
+    for (let i = 0; i < len; i += size) {
+        yield str.slice(i, i + size)
+    }
+}
+
+export const padStart = (str: string, targetLength: number, padString = ' ') => (
+    str.padStart(targetLength, padString)
+)
+
+export const padZeroStart = (num: Numberish | string, targetLength: number) => padStart(num.toString(), targetLength, '0')
+
+export function truncate(str: string, maxLength: number, omission = '...') {
+    if (str.length <= maxLength) {
+        return str
+    }
+
+    if (omission.length >= maxLength) {
+        return omission.slice(0, maxLength)
+    }
+
+    return str.slice(0, maxLength - omission.length) + omission
+}
+
+export function truncateMiddle(str: string, maxLength: number, omission = '...') {
+    if (str.length <= maxLength) {
+        return str
+    }
+
+    if (omission.length >= maxLength) {
+        return omission.slice(0, maxLength)
+    }
+
+    const left = Math.floor((maxLength - omission.length) / 2)
+    const right = maxLength - omission.length - left
+
+    return str.slice(0, left) + omission + str.slice(-right)
+}
+
+export function ltrim(str: string, characters: Set<string> | string = WHITESPACE_CHARACTERS) {
+    if (typeof characters === 'string') {
+        characters = new Set(characters)
+    }
+
+    const end = str.length
+
+    let start = 0
+
+    while (start < end && characters.has(str[start]!)) {
+        start++
+    }
+
+    return start > 0 ? str.slice(start, end) : str
+}
+
+export function rtrim(str: string, characters: Set<string> | string = WHITESPACE_CHARACTERS) {
+    if (typeof characters === 'string') {
+        characters = new Set(characters)
+    }
+
+    let end = str.length
+
+    while (end > 0 && characters.has(str[end - 1]!)) {
+        end--
+    }
+
+    return end < str.length ? str.slice(0, end) : str
+}
+
+export const trim = (str: string, characters: Set<string> | string = WHITESPACE_CHARACTERS) => (
+    ltrim(rtrim(str, characters), characters)
+)
+
+export const trimRepeated = (input: string, target: string) => (
+    input.replaceAll(new RegExp(`(?:${escapeRegExp(target)}){2,}`, 'g'), target)
+)

package/src/strings/types.ts

@@ -0,0 +1,3 @@
+export type UrlLike = URL | string
+
+export type HexString = `0x${string}`

package/src/system/env.ts

@@ -0,0 +1,32 @@
+import { isUndefined } from '../core'
+
+export const isInMode = (key: string) => process.env.NODE_ENV === key
+
+export const isInDevelopment = () => isInMode('development') || isInMode('dev')
+export const isInDev = isInDevelopment
+
+export const isInProduction = () => isInMode('production') || isInMode('prod')
+export const isInProd = isInProduction
+
+export const isInStaging = () => isInMode('staging') || isInMode('stage')
+export const isInStage = isInStaging
+
+export interface GetEnvOptions {
+    env?: NodeJS.ProcessEnv
+    includeNonePrefix?: boolean
+    prefix?: string
+}
+
+export function getEnv<T extends string>(key: T[], { env = process.env, includeNonePrefix = false, prefix }: GetEnvOptions = {}) {
+    const result: Record<string, string | undefined> = {}
+
+    for (const k of key) {
+        result[k] = env[prefix ? `${prefix}${k}` : k]
+
+        if (includeNonePrefix && isUndefined(result[k])) {
+            result[k] = env[k]
+        }
+    }
+
+    return result as Record<T, string | undefined>
+}

package/src/system/fetch.ts

@@ -0,0 +1,23 @@
+import type { UrlLike } from '../strings'
+import { combineSignals, createAbortController } from '../errors'
+import { resolveOptions } from '../objects'
+import { withRetry, type WithRetryOptions } from '../promises'
+
+export interface FetchOptions extends Omit<RequestInit, 'signal'> {
+    retry?: Omit<WithRetryOptions<Response>, 'signal'> & { enabled?: boolean } | boolean
+    signal?: AbortSignal
+    timeout?: number
+}
+
+export async function fetch(request: RequestInfo | UrlLike, { retry = true, signal, timeout = 10_000, ...options }: FetchOptions = {}) {
+    const retryOptions = { enabled: true, ...(resolveOptions(retry, {}) || { enabled: false }) }
+
+    const execute = async (retrySignal?: AbortSignal) => {
+        const controller = createAbortController(timeout)
+        const fetchSignal = combineSignals(controller.signal, signal, retrySignal)
+
+        return globalThis.fetch(request, { ...options, signal: fetchSignal }).finally(() => controller.abort())
+    }
+
+    return retryOptions.enabled ? await withRetry(execute, { ...retryOptions, signal }) : await execute()
+}

package/src/system/graceful-exit.ts

@@ -0,0 +1,46 @@
+export type ExitHandler = (exitCode?: number) => Promise<void>
+
+const exitTasks = new Map<ExitHandler, number>()
+
+export function addExitHandler(handler: ExitHandler, maxWaitTime = 3000) {
+    exitTasks.set(handler, maxWaitTime)
+
+    return () => {
+        exitTasks.delete(handler)
+    }
+}
+
+let _isExiting = false
+let _exitPromise: Promise<never> | undefined
+
+export const isExiting = () => {
+    return _isExiting
+}
+
+export function gracefulExit(exitCode = 0, maxWaitTime = 3000): Promise<never> {
+    if (_exitPromise) {
+        return _exitPromise
+    }
+
+    _isExiting = true
+
+    if (exitTasks.size === 0) {
+        process.exit(exitCode)
+    }
+
+    const promises: Array<Promise<void>> = []
+
+    for (const [handler, wait] of exitTasks) {
+        promises.push(Promise.resolve().then(() => handler(exitCode)))
+        maxWaitTime = Math.max(maxWaitTime, wait)
+    }
+
+    const timer = setTimeout(() => process.exit(exitCode), maxWaitTime)
+
+    function finish(): never {
+        clearTimeout(timer)
+        process.exit(exitCode)
+    }
+
+    return _exitPromise = Promise.allSettled(promises).then(finish)
+}

package/src/system/index.ts

@@ -0,0 +1,6 @@
+export * from './env'
+export * from './fetch'
+export * from './graceful-exit'
+export * from './path'
+
+export type * from './types'

package/src/system/path.ts

@@ -0,0 +1,12 @@
+import type { PathLike } from './types'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { bufferToString, isBufferLike } from '../buffers'
+
+export const pathToString = (path: PathLike) => (
+    isBufferLike(path) ? bufferToString(path) : path.toString()
+)
+
+export const pwd = (importMeta: ImportMeta, ...path: PathLike[]) => (
+    join(dirname(fileURLToPath(importMeta.url)), ...path.map(pathToString))
+)

package/src/system/types.ts

@@ -0,0 +1,3 @@
+import type { BufferLike } from '../buffers'
+
+export type PathLike = BufferLike | URL | string

package/src/times/constants.ts

@@ -0,0 +1,6 @@
+export const MS_PER_SECOND = 1000
+export const MS_PER_MINUTE = 60_000
+export const MS_PER_HOUR = 3_600_000
+export const MS_PER_DAY = 86_400_000
+export const MS_PER_MONTH = MS_PER_DAY * 30
+export const MS_PER_YEAR = MS_PER_DAY * 365

package/src/times/conversions.ts

@@ -0,0 +1,85 @@
+import { isString } from '../core'
+import { BigIntMath, isSpecialNumberString, type Numberish } from '../numbers'
+import { padZeroStart } from '../strings'
+
+export const toUnixTimestamp = (date: Date) => Math.floor(date.getTime() / 1000)
+
+export const fromUnixTimestamp = (timestamp: number) => new Date(timestamp * 1000)
+
+const FORMAT_TOKEN_REGEX = /y{4}|S{3}|MM|dd|HH|mm|ss/gu
+const pad2 = (n: number) => padZeroStart(n, 2)
+
+export function formatDate(date: Date, format = 'HH:mm:ss.SSS dd/MM/yyyy') {
+    if (Number.isNaN(date.getTime())) {
+        throw new TypeError('Invalid Date')
+    }
+
+    const tokens: Record<string, () => string> = {
+        dd: () => pad2(date.getDate()),
+        HH: () => pad2(date.getHours()),
+        MM: () => pad2(date.getMonth() + 1),
+        mm: () => pad2(date.getMinutes()),
+        ss: () => pad2(date.getSeconds()),
+        SSS: () => padZeroStart(date.getMilliseconds(), 3),
+        yyyy: () => padZeroStart(date.getFullYear(), 4),
+    }
+
+    return format.replaceAll(FORMAT_TOKEN_REGEX, (match) => tokens[match]!())
+}
+
+const NANOSECOND_UNITS: Array<[label: string, value: bigint]> = [
+    ['h', 3_600_000_000_000n],
+    ['m', 60_000_000_000n],
+    ['s', 1_000_000_000n],
+    ['ms', 1_000_000n],
+    ['\u03BCs', 1000n],
+    ['ns', 1n],
+]
+
+export function humanizeNanoseconds(ns: Numberish) {
+    if (isString(ns) && isSpecialNumberString(ns)) {
+        return ns
+    }
+
+    let remaining: bigint
+
+    try {
+        remaining = BigInt(ns)
+    } catch {
+        return ns.toString()
+    }
+
+    if (remaining === 0n) {
+        return '0ns'
+    }
+
+    const sign = remaining < 0n ? '-' : ''
+    const parts: string[] = []
+
+    remaining = BigIntMath.abs(remaining)
+
+    for (const [label, value] of NANOSECOND_UNITS) {
+        if (remaining >= value) {
+            parts.push(`${remaining / value}${label}`)
+            remaining %= value
+        }
+    }
+
+    return sign + parts.join(' ')
+}
+
+export function humanizeWithMultiplier(value: Numberish, multiplier: bigint) {
+    if (isString(value) && isSpecialNumberString(value)) {
+        return value
+    }
+
+    try {
+        return humanizeNanoseconds(BigInt(value) * multiplier)
+    } catch {
+        return value.toString()
+    }
+}
+
+export const humanizeMilliseconds = (ms: Numberish) => humanizeWithMultiplier(ms, 1_000_000n)
+
+export const humanizeSeconds = (s: Numberish) => humanizeWithMultiplier(s, 1_000_000_000n)

package/src/times/factories.ts

@@ -0,0 +1,3 @@
+import { toUnixTimestamp } from './conversions'
+
+export const timestamp = () => toUnixTimestamp(new Date())

package/src/times/guards.ts

@@ -0,0 +1,3 @@
+export const isValidDate = (value: unknown): value is Date => (
+    value instanceof Date && !Number.isNaN(value.getTime())
+)

package/src/times/index.ts

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

package/src/times/operations.ts

@@ -0,0 +1,9 @@
+import { tap } from '../functions'
+
+export const startOfDay = (date: Date) => tap(new Date(date), (r) => {
+    r.setHours(0, 0, 0, 0)
+})
+
+export const endOfDay = (date: Date) => tap(new Date(date), (r) => {
+    r.setHours(23, 59, 59, 999)
+})

package/CHANGELOG.md

@@ -1,39 +0,0 @@
-# Changelog
-
-
-## v0.0.3
-
-[compare changes](https://github.com/kdtlabs/utils/compare/v0.0.2...v0.0.3)
-
-## v0.0.2
-
-[compare changes](https://github.com/kdtlabs/utils/compare/v0.0.1...v0.0.2)
-
-### 🩹 Fixes
-
-- **release:** Build after changelog gen to prevent package.json version error ([459f06c](https://github.com/kdtlabs/utils/commit/459f06c))
-
-### ❤️ Contributors
-
-- Diep Dang <kdt310722@gmail.com>
-
-## v0.0.1
-
-
-### 🚀 Enhancements
-
-- Add SKILL.md for AI tool discovery of available utils ([e1dde1a](https://github.com/kdtlabs/utils/commit/e1dde1a))
-
-### 🩹 Fixes
-
-- **release:** Fix release script and add CHANGELOG.md to eslint ignore ([a72208c](https://github.com/kdtlabs/utils/commit/a72208c))
-
-### 🏡 Chore
-
-- Initial commit ([058e414](https://github.com/kdtlabs/utils/commit/058e414))
-- Add gitnexus to ignore files ([88c2d38](https://github.com/kdtlabs/utils/commit/88c2d38))
-
-### ❤️ Contributors
-
-- Diep Dang <kdt310722@gmail.com>
-

package/arrays/index.js

@@ -1,4 +0,0 @@
-import{$b as w,Fb as a,Gb as b,Hb as c,Ib as d,Jb as e,Kb as f,Lb as g,Mb as h,Nb as i,Ob as j,Pb as k,Qb as l,Rb as m,Sb as n,Tb as o,Ub as p,Vb as q,Wb as r,Xb as s,Yb as t,Zb as u,_b as v,ac as x,bc as y}from"../chunk-c0p3wm8m.js";import"../chunk-qn6n0ff5.js";import"../chunk-c9mm50vv.js";export{g as wrap,v as uniqueBy,u as unique,h as toArray,y as symmetricDiff,s as sortBy,o as shuffle,l as sample,k as range,t as partition,a as nth,m as merge,c as last,q as keyBy,f as isNonEmptyArray,e as isEmptyArray,d as isArray,w as intersection,p as groupBy,n as flatten,b as first,x as diff,j as createArray,i as compact,r as chunk};
-
-//# debugId=7FF7885B231E2BF464756E2164756E21
-//# sourceMappingURL=index.js.map

package/arrays/index.js.map

@@ -1,9 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [
-  ],
-  "mappings": "",
-  "debugId": "7FF7885B231E2BF464756E2164756E21",
-  "names": []
-}

package/buffers/index.js

@@ -1,4 +0,0 @@
-import{gb as a,hb as b,ib as c,jb as d,kb as e,lb as f,mb as g,nb as h,ob as i}from"../chunk-xp18wdk6.js";export{g as toUint8Array,c as isSharedArrayBuffer,e as isBufferLike,a as isBuffer,d as isArrayBufferView,b as isArrayBuffer,h as concatBuffers,f as bufferToString,i as bufferEquals};
-
-//# debugId=58E6E050C983599364756E2164756E21
-//# sourceMappingURL=index.js.map

package/buffers/index.js.map

@@ -1,9 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [
-  ],
-  "mappings": "",
-  "debugId": "58E6E050C983599364756E2164756E21",
-  "names": []
-}

package/chunk-4w1emwv7.js

@@ -1,6 +0,0 @@
-import{pd as f,td as b}from"./chunk-m4svr349.js";import{Kd as c,Pd as u}from"./chunk-c9mm50vv.js";class p extends Error{constructor(r,{code:e,details:t,exitCode:n,name:o,retryable:i,timestamp:s,...a}={}){super(r,a);Object.setPrototypeOf(this,new.target.prototype),this.defineValue("name",o??this.constructor.name),this.defineValue("timestamp",s??new Date),this.defineValue("cause",a.cause),this.defineValue("code",e),this.defineValue("details",t),this.defineValue("exitCode",n),this.defineValue("retryable",i)}withValue(r,e){if(Object.hasOwn(this,r))throw TypeError(`Cannot redefine property '${r}' on ${this.name}`);return this.defineValue(r,e)}defineValue(r,e){return Object.defineProperty(this,r,{configurable:!1,enumerable:!0,value:e,writable:!1}),this}}var v=(r)=>r instanceof Error,P=(r)=>r instanceof p,R=(r)=>r instanceof DOMException&&r.name==="AbortError",x=(r)=>f(r)&&b(r,"name")&&u(r.name);var O=(r="This operation was aborted",e="AbortError")=>new DOMException(r,e),C=(r="The operation was aborted due to a timeout",e="TimeoutError")=>O(r,e);function B(r,e){let t=new AbortController;if(c(r)&&r>0&&r<=Number.MAX_SAFE_INTEGER){let n,o=()=>{clearTimeout(n),t.signal.removeEventListener("abort",o)};t.signal.addEventListener("abort",o),n=setTimeout(()=>t.abort(d(e??C())),r)}return t}function d(r,e){if(typeof r==="string")return e?new e(r):Error(r);if(typeof r==="function")return d(r(),e);return r}function k({cause:r,message:e,name:t,stack:n,...o},i){let a=new(i??Error)(e,{cause:r});Object.defineProperty(a,"name",{configurable:!0,enumerable:!1,value:t,writable:!0}),Object.defineProperty(a,"stack",{configurable:!0,enumerable:!1,value:n,writable:!0});for(let[l,m]of Object.entries(o))Object.defineProperty(a,l,Object.getOwnPropertyDescriptor(o,l)??{configurable:!0,enumerable:!0,value:m,writable:!0});return a}function y(r,{defaultMessage:e="Unknown error",errorConstructor:t}={}){let n=t??Error;if(r instanceof n)return r;if(u(r))return d(r,t);if(x(r))return k(r,t);return new n(e,{cause:r})}function K(...r){let e=r.filter(c);if(e.length===0)return new AbortController().signal;if(e.length===1)return e[0];return AbortSignal.any(e)}var N={code:(r)=>`[${r}]`,message:(r)=>r,name:(r)=>`${r}:`};function A(r,e,t,n){let o=t+" ".repeat(n.causeIndent),i=[];if(r instanceof AggregateError&&r.errors.length>0)for(let s of r.errors)i.push(g(s,e-1,o,n.causePrefix,n));if(f(r.cause)||u(r.cause))i.push(g(r.cause,e-1,o,n.causePrefix,n));return i}function h(r,e,t,n,o,i){if(!i.includeCause||n<=0||e!==t&&e.cause===t)return;let s=A(e,n,o,i);if(s.length>0)r.push(`
-${s.join(`
-`)}`)}function M(r,e){let t=[];if(e.includeCode&&"code"in r&&c(r.code))t.push(e.formatters.code(String(r.code)));if(e.includeName)t.push(e.formatters.name(r.name));return t.push(e.formatters.message(r.message||e.defaultMessage)),t}function g(r,e,t,n,o){if(o.visited.has(r))return`${t}${n}${o.circularReferenceMessage}`;if(r instanceof Error)o.visited.add(r);if(r instanceof Error&&r.toString!==Error.prototype.toString){let a=[r.toString()];return h(a,r,r,e,t,o),t+n+a.join(" ")}let i=y(r,{...o.normalizeOptions,defaultMessage:o.defaultMessage});o.visited.add(i);let s=M(i,o);return h(s,i,r,e,t,o),t+n+s.join(" ")}function J(r,e={}){let{causeIndent:t=2,causePrefix:n="-> ",circularReferenceMessage:o="[Circular Reference]",defaultMessage:i="Unknown error",formatters:s={},includeCause:a=!0,includeCode:l=!0,includeName:m=!0,maxCauseDepth:E=Number.POSITIVE_INFINITY,...w}=e,S={causeIndent:t,causePrefix:n,circularReferenceMessage:o,defaultMessage:i,formatters:{...N,...s},includeCause:a,includeCode:l,includeName:m,maxCauseDepth:E,normalizeOptions:w,visited:new Set};return g(r,E,"","",S)}export{p as Zc,v as _c,P as $c,R as ad,x as bd,O as cd,C as dd,B as ed,d as fd,k as gd,y as hd,K as id,N as jd,A as kd,h as ld,M as md,g as nd,J as od};
-
-//# debugId=89966F1E1B5C279064756E2164756E21
-//# sourceMappingURL=chunk-4w1emwv7.js.map