ctx-core 2.2.0 → 2.2.2

package/all/andand/index.js

@@ -0,0 +1,19 @@
+/**
+ * Applies `&&` to a chain of properties from `obj`.
+ * @param {unknown}obj
+ * @param {import('./index.d.ts').andand_key_T}name_a
+ * @returns {unknown}
+ */
+export function andand(obj, ...name_a) {
+	let out_value = obj
+	for (let i = 0; i < name_a.length; i++) {
+		const segment = name_a[i]
+		return (
+			out_value
+				? typeof segment === 'function'
+					? out_value[segment(out_value)]
+					: out_value[segment]
+				: null)
+	}
+	return out_value
+}

package/all/andand_or/index.d.ts

@@ -0,0 +1,13 @@
+import type { andand_key_T } from '../andand/index.js'
+/**
+ * Returns `andand(obj, name_a) || or_fn(obj, val)`
+ */
+export declare function andand_or<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+>(obj:Val, name_a:andand_key_T<Val>[], or_:andand_or_T<Val, Out>):Out
+export declare type andand_or_T<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+> = (val:Out|null, obj:Val)=>Out
+export { andand_or as andand__or }

package/all/andand_or/index.js

@@ -0,0 +1,14 @@
+import { andand } from '../andand/index.js'
+/** @typedef {import('../andand/index.js').andand_key_T}andand_key_T */
+/**
+ * Returns `andand(obj, name_a) || or_fn(obj, val)`
+ * @param {unknown|null}obj
+ * @param {andand_key_T[]}name_a
+ * @param {import('./index.d.ts').andand_or_T}or_
+ * @returns {unknown}
+ */
+export function andand_or(obj, name_a, or_fn) {
+	const val = andand(obj, ...name_a)
+	return val || or_fn(val, obj)
+}
+export { andand_or as andand__or }

package/all/andandfn/index.d.ts

@@ -0,0 +1,26 @@
+import type { andand_key_T } from '../andand/index.js'
+/**
+ * Applies `&&` to a chain of property name or function with return value from `obj`.
+ */
+export declare function andandfn<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+>(obj:Val, ...name_a:andand_key_T<Val>[]):Out
+export declare type andandfn_T<
+	Val extends unknown = unknown,
+	Out extends unknown = unknown
+> = (obj:Val)=>Out
+export { andandfn as andand__fn, }
+/**
+ * Returns a function that calls `andand_(obj, ...name_a)`
+ */
+export declare function andandfn_<
+	In extends unknown = unknown,
+	Out extends unknown = unknown
+>(
+	...name_a:andand_key_T<In>[]
+):andandfn_T<In, Out>
+export {
+	andandfn_ as _andand_,
+	andandfn_ as _fn__andand__fn,
+}

package/all/andandfn/index.js

@@ -0,0 +1,39 @@
+/** @typedef {import('../andand/index.js').andand_key_T}andand_key_T */
+/**
+ * Applies `&&` to a chain of property name or function with return value from `obj`.
+ * @param {unknown}obj
+ * @param {andand_key_T}name_a
+ * @returns {unknown}
+ */
+export function andandfn(obj, ...name_a) {
+	let out_value = obj
+	for (let i = 0; i < name_a.length; i++) {
+		if (!out_value) break
+		const segment = name_a[i]
+		let in_value =
+			out_value
+				? out_value[segment]
+				: typeof segment === 'function'
+					? segment(out_value)
+					: undefined
+		out_value =
+			in_value && typeof in_value === 'function'
+				? in_value.call(out_value)
+				: in_value
+	}
+	return out_value
+}
+export { andandfn as andand__fn, }
+/** @typedef {import('../andand/index.d.ts').andand_key_T}andand_key_T */
+/**
+ * Returns a function that calls `andand_(obj, ...name_a)`
+ * @param {andand_key_T}name_a
+ * @returns {import('../andandfn').andandfn_T}
+ */
+export function andandfn_(...name_a) {
+	return (obj)=>andandfn(obj, ...name_a)
+}
+export {
+	andandfn_ as _andand_,
+	andandfn_ as _fn__andand__fn,
+}

package/all/apply/index.d.ts

@@ -0,0 +1,14 @@
+import type { bind_call_T } from '../bind_call/index.js'
+import type { call_fn_T } from '../call/index.js'
+/**
+ * Returns function that applies in_arg_a with ...fn_arg_a
+ */
+export declare function apply_<
+	A1 extends unknown[] = unknown[],
+	O1 extends unknown = unknown,
+	A2 extends unknown[] = unknown[],
+	O2 extends unknown = unknown
+>(
+	fn:call_fn_T<A2, O2>, in_arg_a?:unknown[]
+):bind_call_T<A1, O1>
+export { apply_ as _apply, }

package/all/apply/index.js

@@ -0,0 +1,14 @@
+/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/**
+ * Returns function that applies in_arg_a with ...fn_arg_a
+ * @param {call_fn_T}fn
+ * @param {unknown[]}[in_arg_a]
+ * @returns {import('../bind_call').bind_call_T}
+ */
+export function apply_(fn, in_arg_a = []) {
+	return (...fn_arg_a)=>fn(...[
+		...in_arg_a,
+		...fn_arg_a
+	])
+}
+export { apply_ as _apply, }

package/all/arg_i0_a/index.d.ts

@@ -0,0 +1,11 @@
+import type { slice_arg_spread_a___ret_T, slice_arg_spread_a__arg__T } from '../slice_arg_spread_a/index.js'
+/**
+ * Returns a function that calls fn passing only the first argument.
+ */
+export declare function arg_i0_a<
+	In extends unknown[] = unknown[],
+	Out extends unknown = unknown
+>(
+	fn:slice_arg_spread_a__arg__T<In, Out>
+):slice_arg_spread_a___ret_T<In, Out>
+export { arg_i0_a as arg__0__ }

package/all/arg_i0_a/index.js

@@ -0,0 +1,11 @@
+import { slice_arg_spread_a_ } from '../slice_arg_spread_a/index.js'
+/** @typedef {import('../slice_arg_spread_a_/index.js').slice_arg_spread_a__arg__T}slice_arg_spread_a__arg__T */
+/**
+ * Returns a function that calls fn passing only the first argument.
+ * @param {slice_arg_spread_a__arg__T}fn
+ * @returns {import('../slice_arg_spread_a_').slice_arg_spread_a___ret_T}
+ */
+export function arg_i0_a(fn) {
+	return slice_arg_spread_a_(fn, 0, 1)
+}
+export { arg_i0_a as arg__0__ }

package/all/array_types/index.d.ts

@@ -0,0 +1,134 @@
+export declare type l1a_T<Val> = [Val]
+export declare type rl1a_T<Val> = readonly [Val]
+export declare type l2a_T<Val> = [...l1a_T<Val>, Val]
+export declare type rl2a_T<Val> = readonly [...l1a_T<Val>, Val]
+export declare type l3a_T<Val> = [...l2a_T<Val>, Val]
+export declare type rl3a_T<Val> = readonly [...l2a_T<Val>, Val]
+export declare type l4a_T<Val> = [...l3a_T<Val>, Val]
+export declare type rl4a_T<Val> = readonly [...l3a_T<Val>, Val]
+export declare type l5a_T<Val> = [...l4a_T<Val>, Val]
+export declare type rl5a_T<Val> = readonly [...l4a_T<Val>, Val]
+export declare type l6a_T<Val> = [...l5a_T<Val>, Val]
+export declare type rl6a_T<Val> = readonly [...l5a_T<Val>, Val]
+export declare type l7a_T<Val> = [...l6a_T<Val>, Val]
+export declare type rl7a_T<Val> = readonly [...l6a_T<Val>, Val]
+export declare type l8a_T<Val> = [...l7a_T<Val>, Val]
+export declare type rl8a_T<Val> = readonly [...l7a_T<Val>, Val]
+export declare type l9a_T<Val> = [...l8a_T<Val>, Val]
+export declare type rl9a_T<Val> = readonly [...l8a_T<Val>, Val]
+export declare type l10a_T<Val> = [...l9a_T<Val>, Val]
+export declare type rl10a_T<Val> = readonly [...l9a_T<Val>, Val]
+export declare type l20a_T<Val> = [...l10a_T<Val>, ...l10a_T<Val>]
+export declare type rl20a_T<Val> = readonly [...l10a_T<Val>, ...l10a_T<Val>]
+export declare type l30a_T<Val> = [...l20a_T<Val>, ...l10a_T<Val>]
+export declare type rl30a_T<Val> = readonly [...l20a_T<Val>, ...l10a_T<Val>]
+export declare type l40a_T<Val> = [...l30a_T<Val>, ...l10a_T<Val>]
+export declare type rl40a_T<Val> = readonly [...l30a_T<Val>, ...l10a_T<Val>]
+export declare type l50a_T<Val> = [...l40a_T<Val>, ...l10a_T<Val>]
+export declare type rl50a_T<Val> = readonly [...l40a_T<Val>, ...l10a_T<Val>]
+export declare type l100a_T<Val> = [...l50a_T<Val>, ...l50a_T<Val>]
+export declare type rl100a_T<Val> = readonly [...l50a_T<Val>, ...l50a_T<Val>]
+export declare type l200a_T<Val> = [...l100a_T<Val>, ...l100a_T<Val>]
+export declare type rl200a_T<Val> = readonly [...l100a_T<Val>, ...l100a_T<Val>]
+export declare type l300a_T<Val> = [...l200a_T<Val>, ...l100a_T<Val>]
+export declare type rl300a_T<Val> = readonly [...l200a_T<Val>, ...l100a_T<Val>]
+export declare type l400a_T<Val> = [...l300a_T<Val>, ...l100a_T<Val>]
+export declare type rl400a_T<Val> = readonly [...l300a_T<Val>, ...l100a_T<Val>]
+export declare type l500a_T<Val> = [...l400a_T<Val>, ...l100a_T<Val>]
+export declare type rl500a_T<Val> = readonly [...l400a_T<Val>, ...l100a_T<Val>]
+export declare type l1000a_T<Val> = [...l500a_T<Val>, ...l500a_T<Val>]
+export declare type rl1000a_T<Val> = readonly [...l500a_T<Val>, ...l500a_T<Val>]
+export declare type a1_T<A extends any[]> = A
+export declare type ra1_T<A extends readonly any[]> = A
+export declare type a2_T<A extends any[]> = a1_T<A>
+export declare type ra2_T<A extends readonly any[]> = ra1_T<A>
+export declare type a3_T<A extends any[]> = a2_T<A>
+export declare type ra3_T<A extends readonly any[]> = ra2_T<A>
+export declare type a4_T<A extends any[]> = a3_T<A>
+export declare type ra4_T<A extends readonly any[]> = ra3_T<A>
+export declare type a5_T<A extends any[]> = a4_T<A>
+export declare type ra5_T<A extends readonly any[]> = ra4_T<A>
+export declare type a6_T<A extends any[]> = a5_T<A>
+export declare type ra6_T<A extends readonly any[]> = ra5_T<A>
+export declare type a7_T<A extends any[]> = a6_T<A>
+export declare type ra7_T<A extends readonly any[]> = ra6_T<A>
+export declare type a8_T<A extends any[]> = a7_T<A>
+export declare type ra8_T<A extends readonly any[]> = ra7_T<A>
+export declare type a9_T<A extends any[]> = a8_T<A>
+export declare type ra9_T<A extends readonly any[]> = ra8_T<A>
+export declare type a10_T<A extends any[]> = a9_T<A>
+export declare type ra10_T<A extends readonly any[]> = ra9_T<A>
+export declare type a20_T<A extends any[]> = a10_T<a10_T<A>>
+export declare type ra20_T<A extends readonly any[]> = ra10_T<ra10_T<A>>
+export declare type a30_T<A extends any[]> = a20_T<a10_T<A>>
+export declare type ra30_T<A extends readonly any[]> = ra20_T<ra10_T<A>>
+export declare type a40_T<A extends any[]> = a30_T<a10_T<A>>
+export declare type ra40_T<A extends readonly any[]> = ra30_T<ra10_T<A>>
+export declare type a50_T<A extends any[]> = a40_T<a10_T<A>>
+export declare type ra50_T<A extends readonly any[]> = ra40_T<ra10_T<A>>
+export declare type a100_T<A extends any[]> = a50_T<a50_T<A>>
+export declare type ra100_T<A extends readonly any[]> = ra50_T<ra50_T<A>>
+export declare type a200_T<A extends any[]> = a100_T<a100_T<A>>
+export declare type ra200_T<A extends readonly any[]> = ra100_T<ra100_T<A>>
+export declare type a300_T<A extends any[]> = a200_T<a100_T<A>>
+export declare type ra300_T<A extends readonly any[]> = ra200_T<ra100_T<A>>
+export declare type a400_T<A extends any[]> = a300_T<a100_T<A>>
+export declare type ra400_T<A extends readonly any[]> = ra300_T<ra100_T<A>>
+export declare type a500_T<A extends any[]> = a400_T<a100_T<A>>
+export declare type ra500_T<A extends readonly any[]> = ra400_T<ra100_T<A>>
+export declare type a1000_T<A extends any[]> = a500_T<a500_T<A>>
+export declare type ra1000_T<A extends readonly any[]> = ra500_T<ra500_T<A>>
+/**
+ * `ctx` of values & indices.
+ */
+export interface sort_val_a__transition_a_frame_T<I> {
+	idx_a:number[]
+	val_a:I[]
+}
+export declare type sort_val_a$transition_a_frame_T<I> = sort_val_a__transition_a_frame_T<I>
+export declare type compact_a_ctx_I<I> = sort_val_a__transition_a_frame_T<I>
+export declare type compact_a1_ctx_I<I> = sort_val_a__transition_a_frame_T<I>
+export declare type compare_1_T<
+	Val extends unknown = unknown
+> = (val:Val, idx?:number)=>number
+export declare type compare_T<
+	I extends unknown = unknown
+> = (a:I, b:I)=>number
+export declare type is_match__T<
+	Val extends unknown = unknown
+> = (in_value:Val, idx:number)=>boolean
+export declare type is_match_fn_T<Val extends unknown = unknown> = is_match__T<Val>
+export declare type _is_match_T<Val extends unknown = unknown> = is_match__T<Val>
+export declare type _is_match_type<Val extends unknown = unknown> = is_match__T<Val>
+export declare type item_key_idx_val_fn_T<
+	Val extends unknown = unknown,
+	Obj extends Record<string, Val> = Record<string, Val>
+> = (val:Val, item:Obj, key:string|number, idx:number)=>string
+export declare type _item_key_idx_val_T<
+	Val extends unknown = unknown,
+	Obj extends Record<string, Val> = Record<string, Val>
+> = item_key_idx_val_fn_T<Val, Obj>
+export declare type _item_key_idx_val_type<
+	Val extends unknown = unknown,
+	Obj extends Record<string, Val> = Record<string, Val>
+> = item_key_idx_val_fn_T<Val, Obj>
+export declare type sort_idx_ctx__T<I extends unknown = unknown> = (
+	a:readonly I[])=>sort_idx_o_T<I>
+export declare type sort_idx_ctx_2_T<I extends unknown = unknown> = sort_idx_ctx__T<I>
+export declare type sort_idx_ctx_a1_fn_type<I extends unknown = unknown> = sort_idx_ctx__T<I>
+export declare type fn__a1__ctx__idx__sort<I extends unknown = unknown> = sort_idx_ctx__T<I>
+export interface sort_idx_o_T<I extends unknown = unknown> {
+	sort_idx_a:readonly number[]
+	sort_val_a:I[]
+}
+export declare type sort_idx_ctx_T<I extends unknown = unknown> = sort_idx_o_T<I>
+export declare type ctx__idx__sort<I extends unknown = unknown> = sort_idx_o_T<I>
+export declare type sort_val_a__transition_a_frame_fn_T<
+	I extends unknown = unknown
+> = (in_val_a:readonly I[]|undefined)=>sort_val_a__transition_a_frame_T<I>
+export declare type sort_val_a$transition_a_frame_fn_T<I extends unknown = unknown> =
+	sort_val_a__transition_a_frame_T<I>
+export declare type thold_a_compact_ctx__T<I extends unknown = unknown> =
+	sort_val_a__transition_a_frame_fn_T<I>
+export declare type thold_a1_compact_ctx_fn_type<I extends unknown = unknown> =
+	sort_val_a__transition_a_frame_fn_T<I>

package/all/array_types/index.js

@@ -0,0 +1 @@
+export {}

package/all/assign/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Object.assign
+ */
+export declare const assign:typeof Object.assign

package/all/assign/index.js

@@ -0,0 +1,5 @@
+/**
+ * Object.assign
+ */
+export const assign =
+	Object.assign

package/all/assign_fn_key_a/index.d.ts

@@ -0,0 +1,15 @@
+import type { assign_fn_T } from '../call_assign/index.js'
+/**
+ * Assigns to obj array of keys the return value of function in key_a_fn_aa.
+ */
+export declare function assign_fn_key_a<
+	I extends unknown = unknown
+>(
+	obj:Record<string, I>,
+	...key_a_fn_aa:fn_key_a_tuple_T<I>[]
+):Record<string, I>
+export declare type fn_key_a_tuple_T<I> = [string[], assign_fn_T<I>]
+export {
+	assign_fn_key_a as assign_fn_key_a1,
+	assign_fn_key_a as assign__key_a1__fn,
+}

package/all/assign_fn_key_a/index.js

@@ -0,0 +1,24 @@
+/** @typedef {import('../assign_fn_key_a/index.js').fn_key_a_tuple_T} */
+/**
+ * Assigns to an obj array of keys the return value of function in key_a_fn_aa.
+ * @param {object}obj
+ * @param {fn_key_a_tuple_T}key_a_fn_aa
+ * @returns {object}
+ */
+export function assign_fn_key_a(
+	obj,
+	...key_a_fn_aa
+) {
+	for (let i = 0; i < key_a_fn_aa.length; i++) {
+		const [key_a, fn] = key_a_fn_aa[i]
+		for (let j = 0; j < key_a.length; j += 1) {
+			const key = key_a[j]
+			obj[key] = fn(obj[key], obj, key)
+		}
+	}
+	return obj
+}
+export {
+	assign_fn_key_a as assign_fn_key_a1,
+	assign_fn_key_a as assign__key_a1__fn,
+}

package/all/assign_unless_null/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Assign only if obj is not null
+ */
+export declare function assign_unless_null<
+	O extends object = object
+>(obj:O, ...arg_a:Partial<O>[]):O|undefined
+export { assign_unless_null as assign__unless__null }

package/all/assign_unless_null/index.js

@@ -0,0 +1,11 @@
+import { assign } from '../assign/index.js'
+/**
+ * Assign only if obj is not null
+ * @param {object}obj
+ * @param {unknown}arg_a
+ * @returns {object|undefined}
+ */
+export function assign_unless_null(obj, ...arg_a) {
+	return obj == undefined ? undefined : assign(obj, ...arg_a)
+}
+export { assign_unless_null as assign__unless__null }

package/all/async_gen_a/index.d.ts

@@ -0,0 +1,3 @@
+export declare function async_gen_a_<T>(
+	async_iter:AsyncGenerator<T>
+):Promise<T[]>

package/all/async_gen_a/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {AsyncGenerator<unknown>}async_iter
+ * @returns {Promise<unknown[]>}
+ */
+export async function async_gen_a_(async_iter) {
+	const async_gen_a = []
+	for await (const $ of async_iter) async_gen_a.push($)
+	return async_gen_a
+}

package/all/async_gen_a/index.test.ts

@@ -0,0 +1,12 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { async_gen_a_ } from '../async_gen_a/index.js'
+test('async_gen_a_', async ()=>{
+	equal(await async_gen_a_(async_gen_([2, 1, 3, 0])), [2, 1, 3, 0])
+})
+async function* async_gen_(a:number[]):AsyncGenerator<number> {
+	for (const $ of a) {
+		yield $
+	}
+}
+test.run()

package/all/at_date/index.d.ts

@@ -0,0 +1 @@
+export declare function at_date(time:number):Date

package/all/at_date/index.js

@@ -0,0 +1,9 @@
+/**
+ * @param {number}time
+ * @returns {Date}
+ */
+export function at_date(time) {
+	const date = new Date()
+	date.setTime(time)
+	return date
+}

package/all/atob/index.d.ts

@@ -0,0 +1,3 @@
+export declare function atob(str:string):string
+export declare function atob_():(encoded_data:string)=>string
+export { atob_ as _atob, }

package/all/atob/index.js

@@ -0,0 +1,16 @@
+/**
+ * @param {string}str
+ * @returns {string}
+ */
+export function atob(str) {
+	return (
+		globalThis['window']
+			? window.atob(str)
+			: Buffer.from(str, 'base64').toString('binary')
+	)
+}
+/** @type {typeof import('./index.d.ts').atob_} */
+export const atob_ = ()=>{
+	return atob
+}
+export { atob_ as _atob, }

package/all/atob_Uint32Array/index.d.ts

@@ -0,0 +1,5 @@
+export declare function atob_Uint32Array_(b64:string):Uint32Array
+export {
+	atob_Uint32Array_ as _atob_Uint32Array,
+	atob_Uint32Array_ as _Uint32Array__atob,
+}

package/all/atob_Uint32Array/index.js

@@ -0,0 +1,16 @@
+import { atob } from '../atob/index.js'
+/** @type {typeof import('./index.d.ts').atob_Uint32Array_} */
+export const atob_Uint32Array_ = (b64)=>{
+	const str = atob(b64)
+	const { length } = str
+	/** @type {Uint32Array} */
+	let atob_Uint32Array = new Uint32Array(length)
+	for (let i = 0; i < length; i++) {
+		atob_Uint32Array[i] = str.charCodeAt(i)
+	}
+	return atob_Uint32Array
+}
+export {
+	atob_Uint32Array_ as _atob_Uint32Array,
+	atob_Uint32Array_ as _Uint32Array__atob,
+}

package/all/bad_credentials/index.d.ts

@@ -0,0 +1,30 @@
+import type { argument__error_o_T, error_o_error_T, error_o_T } from '../error_o/index.js'
+import type { HttpError } from '../http_error/index.js'
+export declare const bad_credentials__default__message:string
+export declare function bad_credentials_error_(
+	message?:string,
+	bad_credentials_error_o?:argument__bad_credentials_error_o_T
+):BadCredentialsError
+/**
+ * Throws a Bad Credentials error (HTTP 401)
+ * @example
+ * bad_credentials__throw(ctx) // Unauthorized
+ */
+export declare function bad_credentials__throw(
+	message?:string,
+	bad_credentials_error_o?:argument__bad_credentials_error_o_T
+):void
+export declare class BadCredentialsError
+	extends HttpError
+	implements bad_credentials_error_o_error_T {
+	jwt_token?:string
+}
+export interface bad_credentials_error_o_T extends error_o_T {
+	jwt_token?:string
+}
+export interface argument__bad_credentials_error_o_T
+	extends bad_credentials_error_o_T, argument__error_o_T {
+}
+export interface bad_credentials_error_o_error_T
+	extends error_o_error_T, bad_credentials_error_o_T {
+}

package/all/bad_credentials/index.js

@@ -0,0 +1,44 @@
+import { assign } from '../assign/index.js'
+import { HttpError } from '../http_error/index.js'
+/** @typedef {import('./index.d.ts').argument__bad_credentials_error_o_T}argument__bad_credentials_error_o_T */
+export const bad_credentials__default__message = 'Unauthorized'
+/**
+ * @param {string}[message]
+ * @param {argument__bad_credentials_error_o_T}[bad_credentials_error_o]
+ * @private
+ */
+export function bad_credentials_error_(
+	message,
+	bad_credentials_error_o
+) {
+	return assign(
+		new /** @type {any} */BadCredentialsError(
+			message ?? bad_credentials__default__message),
+		bad_credentials_error_o)
+}
+/**
+ * Throws a Bad Credentials error (HTTP 401)
+ * @param {string}[message]
+ * @param {argument__bad_credentials_error_o_T}[bad_credentials_error_o]
+ * @example
+ * bad_credentials__throw(ctx) // Unauthorized
+ */
+export function bad_credentials__throw(
+	message,
+	bad_credentials_error_o
+) {
+	throw bad_credentials_error_(message, bad_credentials_error_o)
+}
+/** @type {typeof import('./index.d.ts').BadCredentialsError} */
+export class BadCredentialsError extends HttpError {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'BadCredentialsError'
+		this.http__message = bad_credentials__default__message
+		this.http__status = 401
+		if (!this.message) this.message = this.http__message
+	}
+}

package/all/bad_gateway/index.d.ts

@@ -0,0 +1,20 @@
+import type { argument__error_o_T, error_o_error_T } from '../error_o/index.js'
+import type { HttpError } from '../http_error/index.js'
+export declare const bad_gateway__default__message:string
+export declare function bad_gateway_error_(
+	message?:string,
+	error_o?:argument__error_o_T
+):BadGatewayError
+/**
+ * Throws a bad_gateway error (HTTP 502)
+ * @example
+ * bad_gateway__throw('Unauthorized') // Bad Gateway
+ */
+export declare function bad_gateway__throw(
+	message?:string,
+	error_o?:argument__error_o_T
+):void
+export declare class BadGatewayError
+	extends HttpError
+	implements error_o_error_T {
+}

package/all/bad_gateway/index.js

@@ -0,0 +1,45 @@
+import { assign } from '../assign/index.js'
+import { HttpError } from '../http_error/index.js'
+/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
+export const bad_gateway__default__message = 'Bad Gateway'
+/**
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @returns {BadGatewayError}
+ * @private
+ */
+export function bad_gateway_error_(
+	message,
+	error_o
+) {
+	return assign(
+		new /** @type {any} */BadGatewayError(
+			message ?? bad_gateway__default__message),
+		error_o)
+}
+/**
+ * Throws a bad_gateway error (HTTP 502)
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @example
+ * bad_gateway__throw(ctx) // Bad Gateway
+ */
+export function bad_gateway__throw(
+	message,
+	error_o
+) {
+	throw bad_gateway_error_(message, error_o)
+}
+/** @type {import('./index.d.ts').BadGatewayError} */
+export class BadGatewayError extends HttpError {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'BadGatewayError'
+		this.http__status = 502
+		this.http__message = bad_gateway__default__message
+		if (!this.message) this.message = this.http__message
+	}
+}

package/all/bad_request/index.d.ts

@@ -0,0 +1,20 @@
+import type { argument__error_o_T, error_o_error_T } from '../error_o/index.js'
+import type { HttpError } from '../http_error/index.js'
+export declare const bad_request__default__message:string
+export declare function bad_request_error_(
+	message?:string,
+	error_o?:argument__error_o_T
+):BadRequestError
+/**
+ * Throws a bad_request error (HTTP 400)
+ * @example
+ * bad_request__throw('Bad Request') // Bad Request
+ */
+export declare function bad_request__throw(
+	message?:string,
+	error_o?:argument__error_o_T
+):void
+export declare class BadRequestError
+	extends HttpError
+	implements error_o_error_T {
+}