ctx-core 4.19.0 → 5.0.1

package/all/many_andand/index.d.ts

@@ -1,11 +1,12 @@
 import type { andand_key__T } from '../andand/index.js'
-export declare function many_andand_<
-	Val extends unknown = unknown
->(...name_a:(keyof Val|andand_key__T<Val>)[]):many_andand_T<Val>
+export declare function many_andand_<Val>(
+	...name_a:(keyof Val|andand_key__T<Val>)[]
+):many_andand_T<Val>
 export {
 	many_andand_ as _many_andand,
 	many_andand_ as _andand__many,
 }
-export declare type many_andand_T<
-	Val extends unknown = unknown
-> = (obj:Val, ...arg_a:(keyof Val|andand_key__T<Val>)[])=>Val|null
+export declare type many_andand_T<Val> = (
+	obj:Val,
+	...arg_a:(keyof Val|andand_key__T<Val>)[]
+)=>Val|null

package/all/many_andand_or/index.d.ts

@@ -1,15 +1,9 @@
 import type { andand_key_T } from '../andand/index.js'
 import type { andand_or_T } from '../andand_or/index.js'
-export declare function many_andand_or_<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
->(
+export declare function many_andand_or_<Val, Out>(
 	name_a:andand_key_T<Val>[], or_:andand_or_T<Val, Out>
 ):many_andand_or_T<Val, Out>
-export declare type many_andand_or_T<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
-> = (obj:Val, ...arg_a:andand_key_T<Val>[])=>Out
+export declare type many_andand_or_T<Val, Out> = (obj:Val, ...arg_a:andand_key_T<Val>[])=>Out
 export {
 	many_andand_or_ as _many_andand_or,
 	many_andand_or_ as _andand_or__many,

package/all/map/index.d.ts

@@ -2,18 +2,11 @@ import { map_fn_T } from '../map_fn/index.js'
 /**
  * Map return value of `fn(a[], i)` into an Array.
  */
-export declare function map<
-	Val extends unknown = unknown,
-	Out extends unknown = unknown
->(
+export declare function map<Val, Out>(
 	a:readonly Val[],
 	fn:map_fn_T<Val, Out>
 ):Out[]
-export declare function maybe_map<
-	Val extends unknown,
-	Out extends unknown,
-	Or = null
->(
+export declare function maybe_map<Val, Out, Or = null>(
 	maybe_a:readonly Val[]|undefined,
 	fn:map_fn_T<Val, Out>,
 	or?:Or
@@ -21,17 +14,10 @@ export declare function maybe_map<
 /**
  * Returns Function returning [map](#map) with `fn`.
  */
-export declare function map_<
-	I extends unknown = unknown,
-	O extends unknown = unknown
->(
+export declare function map_<I, O>(
 	fn:(val:I, idx:number)=>O
 ):(a:readonly I[])=>O[]
-export declare function maybe_map_<
-	I extends unknown = unknown,
-	O extends unknown = unknown,
-	Or = null
->(
+export declare function maybe_map_<I, O, Or = null>(
 	fn:(val:I, idx:number)=>O,
 	or?:Or
 ):(a:readonly I[]|undefined)=>O[]|Or

package/all/map_andand/index.d.ts

@@ -2,15 +2,11 @@ import type { andand_key_T } from '../andand/index.js'
 /**
  * Returns Array of mapped `a` with `_andand(...name_a)`.
  */
-export declare function map_andand<
-	In extends unknown = unknown, Out extends unknown = unknown
->(
+export declare function map_andand<In, Out>(
 	a:readonly In[],
 	...name_a:readonly andand_key_T<In>[]
 ):Out[]
-export declare function maybe_map_andand<
-	Val extends unknown, Out extends unknown
->(
+export declare function maybe_map_andand<Val, Out>(
 	a:readonly Val[]|undefined,
 	...name_a:readonly andand_key_T<Val>[]
 ):Out[]|undefined
@@ -18,9 +14,7 @@ export { map_andand as map__andand, }
 /**
  * Returns function that returns value from [map_andand](#map_andand) with `...attr_a`.
  */
-export declare function map_andand_<
-	In extends unknown, Out extends unknown
->(
+export declare function map_andand_<In, Out>(
 	...attr_a:readonly andand_key_T<In>[]
 ):(a:readonly In[])=>Out[]
 export {

package/all/map_andand_or/index.d.ts

@@ -3,9 +3,7 @@ import type { andand_or_T } from '../andand_or/index.js'
 /**
  * Returns Array of mapped `a` with `_andand(...attr_a)` or the return value of `or_fn`.
  */
-export declare function map_andand_or<
-	In extends unknown = unknown, Out extends unknown = unknown
->(
+export declare function map_andand_or<In, Out>(
 	a:readonly In[],
 	attr_a:readonly andand_key_T<In>[],
 	or_fn:andand_or_T<In, Out>

package/all/map_andandfn/index.d.ts

@@ -2,9 +2,7 @@ import type { andand_key_T } from '../andand/index.js'
 /**
  * Returns Array of mapped `a` with `andandfn_(...attr_a)`
  */
-export declare function map_andandfn<
-	In extends unknown = unknown, Out extends unknown = unknown
->(
+export declare function map_andandfn<In, Out>(
 	a:readonly In[],
 	...attr_a:readonly andand_key_T<In>[]
 ):Out[]
@@ -15,9 +13,7 @@ export {
 /**
  * Returns function that returns value from [map_andand_](#map_andand_) with `...attr_a`.
  */
-export declare function map_andandfn_<
-	Val extends unknown, Out extends unknown
->(
+export declare function map_andandfn_<Val, Out>(
 	...attr_a:readonly andand_key_T<Val>[]
 ):(a:readonly Val[])=>Out[]
 export {

package/all/map_apply/index.d.ts

@@ -2,14 +2,11 @@ import type { map_fn_T } from '../map_fn/index.js'
 /**
  * Returns function that returns map of calls to fn_a applying in_arg_a with ...arg_a_
  */
-export declare function map_apply_<
-	Arg extends unknown = unknown,
-	O extends unknown = unknown,
->(fn_a:map_fn_T[], in_arg_a?:Arg[]):(...fn_arg_a:Arg[])=>O[]
-export declare type map_apply_T<
-	Arg extends unknown = unknown,
-	O extends unknown = unknown,
-> = (...fn_arg_a:Arg[])=>O[]
+export declare function map_apply_<Arg, O>(
+	fn_a:map_fn_T<Arg, O>[],
+	in_arg_a?:Arg[]
+):(...fn_arg_a:Arg[])=>O[]
+export declare type map_apply_T<Arg, O> = (...fn_arg_a:Arg[])=>O[]
 export {
 	map_apply_ as map_fn_apply_fn,
 	map_apply_ as _map_apply,

package/all/map_apply/index.js

@@ -6,7 +6,7 @@ import { concat } from '../concat/index.js'
  * @returns {(...fn_arg_a:unknown[])=>unknown[]}
  */
 export function map_apply_(fn_a, in_arg_a = []) {
-	return (...fn_arg_a)=>fn_a.map((fn)=>fn(...concat(in_arg_a, fn_arg_a)))
+	return (...fn_arg_a)=>fn_a.map(fn=>fn(...concat(in_arg_a, fn_arg_a)))
 }
 export {
 	map_apply_ as map_fn_apply_fn,

package/all/map_call/index.d.ts

@@ -2,18 +2,15 @@ import type { map_fn_T } from '../map_fn/index.js'
 /**
  * Returns the map of calls to fn_a with ...arg_a.
  */
-export declare function map_call<
-	I extends unknown = unknown,
-	O extends unknown = unknown
->(fn_a:map_fn_T<I, O>[], ...arg_a:I[]):O[]
+export declare function map_call<I, O>(fn_a:map_fn_T<I, O>[], ...arg_a:I[]):O[]
 export { map_call as call__map }
 /**
  * Returns function that maps calls to fn_al ...fac_arg_a concat with ...fn_arg_a passed to function
  */
-export declare function map_call_<
-	I extends unknown = unknown,
-	O extends unknown = unknown
->(fn_a:map_fn_T<I, O>[], ...fac_arg_a:I[]):(...fn_arg_a:I[])=>O[]
+export declare function map_call_<I, O>(
+	fn_a:map_fn_T<I, O>[],
+	...fac_arg_a:I[]
+):(...fn_arg_a:I[])=>O[]
 export {
 	map_call_ as map_a_call_fn,
 	map_call_ as map_a1_call_fn,

package/all/map_find/index.d.ts

@@ -2,17 +2,11 @@ import type { wrap_a_T2 } from '../wrap_a/index.js'
 /**
  * Returns first return value of `fn(a[idx], idx)` where `fn(a[idx], idx)` is truthy.
  */
-export declare function map_find<
-	In extends unknown = unknown, Out extends unknown = In
->(
+export declare function map_find<In, Out = In>(
 	a:wrap_a_T2<In>,
 	fn:(val:In, idx:number)=>Out
 ):Out|undefined
-export declare function maybe_map_find<
-	In extends unknown = unknown,
-	Out extends unknown = In,
-	Or = null
->(
+export declare function maybe_map_find<In, Out = In, Or = null>(
 	maybe_a:wrap_a_T2<In>,
 	fn:(val:In, idx:number)=>Out,
 	or?:Or
@@ -21,9 +15,7 @@ export { map_find as find__map, }
 /**
  * Returns function that returns value from [map_find](#map_find) with `fn` argument.
  */
-export declare function map_find_<
-	In extends unknown = unknown, Out extends unknown = In
->(
+export declare function map_find_<In, Out = In>(
 	fn:(val:In, idx:number)=>Out
 ):(a:wrap_a_T2<In>)=>Out|undefined
 export {

package/all/map_fn/index.d.ts

@@ -1,4 +1 @@
-export declare type map_fn_T<
-	I extends unknown = unknown,
-	Ret extends unknown = unknown
-> = (...arg_a:I[])=>Ret
+export declare type map_fn_T<I, Ret> = (...arg_a:I[])=>Ret

package/all/map_obj/index.d.ts

@@ -2,25 +2,16 @@ import type { nullish } from '../nullish/index.js'
 /**
  * Maps values in `in_obj` to `fn`, returning object with values returned by `fn`.
  */
-export declare function map_obj<
-	In extends unknown = unknown,
-	Out = In
->(
+export declare function map_obj<In, Out = In>(
 	in_obj:Record<string, In>,
 	fn:map_obj_fn_T<In, Out>
 ):Record<string, Out|nullish>
-export declare type map_obj_fn_T<
-	Val extends unknown = unknown,
-	Out = Val
-> = (in_obj:Val, key:string)=>Out
+export declare type map_obj_fn_T<Val, Out = Val> = (in_obj:Val, key:string)=>Out
 export { map_obj as map__obj }
 /**
  * Returns function to map `obj` to `fn` returning object with values.
  */
-export declare function map_obj_<
-	In extends unknown = unknown,
-	Out = In
->(
+export declare function map_obj_<In, Out = In>(
 	fn:map_obj_fn_T<In, Out>
 ):(obj:Record<string, In>)=>Record<string, Out|nullish>
 export {

package/all/map_obj_andand/index.d.ts

@@ -3,10 +3,7 @@ import type { nullish } from '../nullish/index.js'
 /**
  * Map `values` `andand` `key_a` in `obj` to `fn`, returning object with values return by `fn`.
  */
-export declare function map_obj_andand<
-	In extends unknown = unknown,
-	Out extends unknown = unknown
->(
+export declare function map_obj_andand<In, Out>(
 	obj:Record<string, In>,
 	...key_a:andand_key_T<In>[]
 ):Record<string, Out|nullish>
@@ -15,10 +12,7 @@ export { map_obj_andand as map__obj__andand }
  * Returns function to
  * map `values` `andand` `key_a` in `obj` to `fn`, returning object with values return by `fn`.
  */
-export declare function map_obj_andand_<
-	In extends unknown = unknown,
-	Out = In
->(
+export declare function map_obj_andand_<In, Out = In>(
 	...key_a:andand_key_T<In>[]
 ):(obj:Record<string, In>)=>Record<string, Out|nullish>
 export {

package/all/merge/index.d.ts

@@ -1,7 +1,4 @@
 /**
  * Performs a deep merge on the target with each source_a
  */
-export declare function merge<
-	I extends unknown = unknown,
-	O = I
->(target:I, ...source_a:O[]):I|undefined
+export declare function merge<I, O = I>(target:I, ...source_a:O[]):I|undefined

package/all/mixin/index.d.ts

@@ -7,7 +7,4 @@
  *        }
  *    })
  */
-export declare function mixin<
-	I extends unknown = unknown,
-	O = I
->(target:I, ...source_a:O[]):I
+export declare function mixin<I, O = I>(target:I, ...source_a:O[]):I

package/all/neq/index.d.ts

@@ -2,13 +2,9 @@ import type { wrap_a_T } from '../wrap_a/index.js'
 /**
  * Returns `!=` operator to all values in `in_value_a`.
  */
-export declare function neq<
-	I extends unknown = unknown
->(in_value_a:wrap_a_T<I>):boolean
+export declare function neq<I>(in_value_a:wrap_a_T<I>):boolean
 /**
  * Return function that Returns `!=` operator to all values in `in_value_a`.
  */
-export declare function neq_<
-	I extends unknown = unknown
->(in_value_a:I|I[]):(val:I)=>boolean
+export declare function neq_<I>(in_value_a:I|I[]):(val:I)=>boolean
 export { neq_ as _neq, }

package/all/neql/index.d.ts

@@ -1,15 +1,11 @@
 /**
  * Returns `!==` operator to all values in `a_unwrap`.
  */
-export declare function neql<
-	I extends unknown = unknown
->(a_unwrap:I):boolean
+export declare function neql<I>(a_unwrap:I):boolean
 /**
  * Returns function that returns `!==` operator to all values in `in_value_a`.
  * @param in_value_a
  * @returns {function(*=): boolean}
  */
-export declare function neql_<
-	Arg extends unknown = unknown
->(in_value_a:Arg[]):(value:Arg)=>boolean
+export declare function neql_<Arg>(in_value_a:Arg[]):(value:Arg)=>boolean
 export { neql_ as _neql, }

package/all/noinit/index.d.ts

@@ -1,9 +1,6 @@
-export declare function noinit_<
-	Arg extends unknown = unknown,
-	Ret extends unknown = unknown
->(fn:(...args:Arg[])=>Ret, times?:number):noinit_T<Arg, Ret>
-export declare type noinit_T<
-	Arg extends unknown = unknown,
-	Ret extends unknown = unknown
-> = (...args:Arg[])=>Ret|undefined
+export declare function noinit_<Arg, Ret>(
+	fn:(...args:Arg[])=>Ret,
+	times?:number
+):noinit_T<Arg, Ret>
+export declare type noinit_T<Arg, Ret> = (...args:Arg[])=>Ret|undefined
 export { noinit_ as _noinit, }

package/all/not/index.d.ts

@@ -2,16 +2,10 @@ import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns not applied to the spread of `in_value_a`
  */
-export declare function not<
-	I extends unknown = unknown
->(in_value_a:a_nowrap_T<I>):boolean
+export declare function not<I>(in_value_a:a_nowrap_T<I>):boolean
 /**
  * Returns function that calls [not](#not) with [wrap_concat](#wrap_concat)  of the arguments.
  */
-export declare function not_<
-	I extends unknown = unknown
->(a_unwrap:a_nowrap_T<I>):not_T<I>
-export declare type not_T<
-	I extends unknown = unknown
-> = (val_a:I[])=>boolean
+export declare function not_<I>(a_unwrap:a_nowrap_T<I>):not_T<I>
+export declare type not_T<I> = (val_a:I[])=>boolean
 export { not_ as _not, }

package/all/notnot/index.d.ts

@@ -5,8 +5,6 @@ export declare function notnot<I>(in_value_a:I|I[]):boolean
 /**
  * Returns function that calls [notnot](#notnot) with [wrap_concat](#wrap_concat) of the arguments.
  */
-export declare function notnot_<
-	Val extends unknown = unknown
->(in_value_a:Val|Val[]):(val:Val)=>boolean
-export declare type notnot_T<Val extends unknown = unknown> = (val:Val)=>boolean
+export declare function notnot_<Val>(in_value_a:Val|Val[]):(val:Val)=>boolean
+export declare type notnot_T<Val> = (val:Val)=>boolean
 export { notnot_ as _notnot, }

package/all/nullish__guard/index.d.ts

@@ -1,8 +1,7 @@
 import type { nullish } from '../nullish/index.js'
-export declare function nullish__guard<
-	Val extends unknown = unknown
->(
-	label:string, ...fn_a:(()=>(nullish|Val))[]
+export declare function nullish__guard<Val>(
+	label:string,
+	...fn_a:(()=>(nullish|Val))[]
 ):Val|nullish
 export {
 	nullish__guard as nullish_guard,

package/all/nullish__guard__async/index.d.ts

@@ -1,8 +1,7 @@
 import type { nullish } from '../nullish/index.js'
-export declare function nullish__guard__async<
-	Val extends unknown = unknown
->(
-	label:string, ...fn_a:(()=>Promise<nullish|Val>)[]
+export declare function nullish__guard__async<Val>(
+	label:string,
+	...fn_a:(()=>Promise<nullish|Val>)[]
 ):Promise<Val>
 export {
 	nullish__guard__async as nullish_async_guard,

package/all/nullish__none/index.d.ts

@@ -1,8 +1,6 @@
 import type { nullish } from '../nullish/index.js'
 import type { TupleExclude } from '../tup/index.js'
-export function nullish__none_<
-	T extends unknown[], U
->(
+export function nullish__none_<T extends unknown[], U>(
 	$:T,
 	_:(...$:TupleExclude<T, nullish>)=>U,
 	onnullish?:(nullish:nullish)=>unknown

package/all/o_a_present/index.d.ts

@@ -4,12 +4,8 @@ import type { filter_o_T } from '../filter_o/index.js'
  * boolean of whether the array has items present
  */
 export declare function o_a_present<
-	Val extends unknown = unknown,
-	Obj extends {
-		[key:string]:Val[];
-	} = {
-		[key:string]:Val[];
-	}
+	Val,
+	Obj extends { [key:string]:Val[] } = { [key:string]:Val[] }
 >(o:Obj):filter_o_T|undefined
 export {
 	o_a_present as r_a_present,

package/all/o_some/index.d.ts

@@ -5,9 +5,7 @@ import type { maybe } from '../maybe/index.js'
  * some({foo: 9, bar: 10}, (value, key) => value === 10) // returns true
  * some({baz: 11, quux: 12}, (value, key) => value === 10) // returns false
  */
-export declare function o_some<
-	I extends unknown = unknown
->(
+export declare function o_some<I>(
 	obj:Record<string, I>,
 	compare_some:(obj:I, key:string)=>unknown
 ):maybe<boolean>

package/all/offset_destructure_aa/index.d.ts

@@ -1,9 +1,7 @@
 /**
  * Returns 2d Array where `source_a` is destructured into subarray of length `offset`.
  */
-export declare function offset_destructure_aa_<
-	I extends unknown = unknown
->(
+export declare function offset_destructure_aa_<I>(
 	source_a:readonly I[], offset?:number
 ):I[][]
 export {

package/all/offset_i_slice/index.d.ts

@@ -1,16 +1,12 @@
 /**
  * Returns an Array from slicing an array from an array's offset from position i
  */
-export declare function offset_i_slice<
-	I extends unknown = unknown
->(
+export declare function offset_i_slice<I>(
 	a:readonly I[],
 	i:number,
 	offset?:number
 ):I[]
-export declare function maybe_offset_i_slice<
-	I extends unknown = unknown, Or = null
->(
+export declare function maybe_offset_i_slice<I, Or = null>(
 	maybe_a:readonly I[]|undefined,
 	i:number,
 	offset?:number,

package/all/one_andand/index.d.ts

@@ -2,9 +2,9 @@ import type { andand_key_T } from '../andand/index.js'
 /**
  * Returns a function that calls `andand(obj, ...name_a)`
  */
-export declare function one_andand_<
-	Val extends unknown = unknown, Out extends unknown = unknown
->(...name_a:andand_key_T<Val>[]):(obj:Val)=>Out|null
+export declare function one_andand_<Val, Out>(
+	...name_a:andand_key_T<Val>[]
+):(obj:Val)=>Out|null
 export {
 	one_andand_ as andand_,
 	one_andand_ as _one_andand,

package/all/one_andand_or/index.d.ts

@@ -3,11 +3,9 @@ import type { andand_or_T } from '../andand_or/index.js'
 /**
  * Returns function that calls `andand_or(obj, name_a, or_fn)`
  */
-export declare function one_andand_or_<
-	In extends unknown = unknown,
-	Out extends unknown = unknown
->(
-	name_a:andand_key_T<In>[], or_:andand_or_T<In, Out>
+export declare function one_andand_or_<In, Out>(
+	name_a:andand_key_T<In>[],
+	or_:andand_or_T<In, Out>
 ):(obj:In)=>Out
 export {
 	one_andand_or_ as andand_or_,

package/all/or/index.d.ts

@@ -3,37 +3,26 @@ import type { wrap_a_T } from '../wrap_a/index.js'
 /**
  * Returns first truthy or last item in `a_unwrap`.
  */
-export declare function or<
-	Val extends unknown = unknown
->(
+export declare function or<Val>(
 	a_unwrap:Val|wrap_a_T<Val>
 ):Val|undefined
 /**
  * Returns first truthy or last item call or value in `a_unwrap`.
  */
-export declare function or_<
-	Val extends unknown,
-	Ret extends unknown
->(a_unwrap:a_nowrap_T<Val>):or_T<Val, Ret>
-export interface or_fn_callable_T<I extends unknown = unknown> {
+export declare function or_<Val, Ret>(a_unwrap:a_nowrap_T<Val>):or_T<Val, Ret>
+export interface or_fn_callable_T<I> {
 	(...args:wrap_a_T<I>):I
 }
-export declare type or_T<Val extends unknown, Ret extends unknown> =
+export declare type or_T<Val, Ret> =
 	(Val extends or_fn_callable_T<Val> ? Ret : Val)
 	|undefined
 /**
  * Returns function that returns first truthy or last item call or value in `a_unwrap`.
  */
-export declare function or_fn_<
-	Val extends unknown,
-	Ret extends unknown
->(
+export declare function or_fn_<Val, Ret>(
 	a_unwrap:a_nowrap_T<Val>
 ):(val:Val)=>or_T<Val, Ret>
-export declare type or_fn_T<
-	Val extends unknown,
-	Ret extends unknown
-> = (val:Val)=>or_T<Val, Ret>
+export declare type or_fn_T<Val, Ret> = (val:Val)=>or_T<Val, Ret>
 export {
 	or_ as on__fn,
 	or_fn_ as _or__fn,

package/all/or_property/index.d.ts

@@ -1,9 +1,5 @@
 /**
  * Returns first obj property that is truthy
  */
-export declare function or_property<
-	I extends unknown = unknown
->(
-	obj:I, name_a:string[]
-):I[keyof I]|undefined
+export declare function or_property<I>(obj:I, name_a:string[]):I[keyof I]|undefined
 export { or_property as or__property }

package/all/promise_timeout/index.d.ts

@@ -1,5 +1,5 @@
-export declare function promise_timeout<
-	O extends unknown = unknown
->(
-	promise:(()=>Promise<O>)|Promise<O>, ms:number, error?:Error
+export declare function promise_timeout<O>(
+	promise:(()=>Promise<O>)|Promise<O>,
+	ms:number,
+	error?:Error
 ):Promise<O>

package/all/prototype_mixin/index.d.ts

@@ -1,7 +1,8 @@
 export declare function prototype_mixin<
-	target_T extends Function&{ prototype:object },
-	source_T extends Function&{ prototype:object },
-	out_T extends Function&{ prototype:object } = target_T&{ prototype:target_T['prototype']&source_T['prototype'] },
+	target_T extends { prototype:object },
+	source_T extends { prototype:object },
+	out_T extends { prototype:object } =
+		target_T&{ prototype:target_T['prototype']&source_T['prototype'] },
 >(
 	target:target_T,
 	source:source_T

package/all/prototype_mixin/index.js

@@ -1,7 +1,7 @@
 /**
- * @param {Function&{ prototype:object }}target
- * @param {Function&{ prototype:object }}source
- * @returns {Function&{ prototype:object }}
+ * @param {{ prototype:object }}target
+ * @param {{ prototype:object }}source
+ * @returns {{ prototype:object }}
  */
 export function prototype_mixin(target, source) {
 	const target_prototype = target.prototype

package/all/push/index.d.ts

@@ -1,15 +1,11 @@
 /**
  * Calls push on an array
  */
-export declare function push<
-	I extends unknown = unknown
->(
+export declare function push<I>(
 	a:readonly I[],
 	...arg_a:readonly I[]
 ):number
-export declare function maybe_push<
-	I extends unknown = unknown
->(
+export declare function maybe_push<I>(
 	maybe_a:readonly I[]|undefined,
 	...arg_a:readonly I[]
 ):number|undefined

package/all/r_val_a/index.d.ts

@@ -1,15 +1,11 @@
 /**
  * Returns Array of `obj[key_a[]]`.
  */
-export declare function r_val_a_<
-	Val extends unknown = unknown
->(
+export declare function r_val_a_<Val>(
 	obj:Record<string, Val>,
 	key_a?:readonly string[]
 ):Val[]
-export declare function maybe_r_val_a_<
-	Val extends unknown = unknown, Or = null
->(
+export declare function maybe_r_val_a_<Val, Or = null>(
 	obj:Record<string, Val>|undefined,
 	key_a?:readonly string[],
 	or?:Or