ctx-core 4.18.0 → 5.0.0

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

package/all/rank/index.d.ts

@@ -2,9 +2,8 @@ import type { compare_1_T } from '../array_types/index.js'
 /**
  * Returns the rank of the items where the compare function === 0
  */
-export declare function rank<
-	I extends unknown = unknown
->(
-	a:readonly I[], compare_1:compare_1_T
+export declare function rank<I>(
+	a:readonly I[],
+	compare_1:compare_1_T
 ):number
 export { rank as rank__a1, }

package/all/reduce/index.d.ts

@@ -1,23 +1,18 @@
 /**
  * Returns reduced `memo` iterating over `a` with `fn(memo, a[], i, a)`.
  */
-export declare function reduce<
-	I extends unknown = unknown, O extends unknown = unknown
->(
+export declare function reduce<I, O>(
 	a:readonly I[],
 	fn:reduce_fn_T<I, O>,
 	memo:O
 ):O
-export declare type reduce_fn_T<
-	I extends unknown = unknown, O extends unknown = unknown
-> = (
-	memo:O, item:I, idx:number, a:readonly I[]
+export declare type reduce_fn_T<I, O> = (
+	memo:O,
+	item:I,
+	idx:number,
+	a:readonly I[]
 )=>O
-export declare function maybe_reduce<
-	I extends unknown = unknown,
-	O extends unknown = unknown,
-	Or = null
->(
+export declare function maybe_reduce<I, O, Or = null>(
 	maybe_a:readonly I[]|undefined,
 	fn:reduce_fn_T<I, O>,
 	memo:O,
@@ -26,20 +21,12 @@ export declare function maybe_reduce<
 /**
  * Return Function that returns from `reduce` with `fn` and factory `memo_(a)`.
  */
-export declare function reduce_<
-	I extends unknown = unknown, O extends unknown = unknown
->(
+export declare function reduce_<I, O>(
 	fn:reduce_fn_T<I, O>, memo_:memo_fn_T<I, O>
 ):(a:readonly I[], memo:O)=>O
-export declare type memo_fn_T<
-	I extends unknown = unknown, O extends unknown = unknown
-> =
+export declare type memo_fn_T<I, O> =
 	(a:readonly I[])=>O
-export declare function maybe_reduce_<
-	I extends unknown = unknown,
-	O extends unknown = unknown,
-	Or = null
->(
+export declare function maybe_reduce_<I, O, Or = null>(
 	fn:reduce_fn_T<I, O|undefined>,
 	memo_fn:memo_fn_T<I, O>|undefined,
 	or?:Or

package/all/reject/index.d.ts

@@ -2,14 +2,13 @@ import type { is_match__T } from '../array_types/index.js'
 /**
  * Returns Array of items not rejected by `fn`.
  */
-export declare function reject<
-	Val extends unknown = unknown, Out extends unknown = readonly Val[]
->(
-	a:readonly Val[], is_match_:is_match__T<Val>
+export declare function reject<Val, Out = readonly Val[]>(
+	a:readonly Val[],
+	is_match_:is_match__T<Val>
 ):Out
 export declare function maybe_reject<
-	Val extends unknown = unknown,
-	Out extends unknown = readonly Val[],
+	Val,
+	Out = readonly Val[],
 	Or = null
 >(
 	maybe_a:readonly Val[]|undefined,
@@ -19,16 +18,10 @@ export declare function maybe_reject<
 /**
  * Returns function that returns value from [reject](#reject) with `fn` argument.
  */
-export declare function reject_<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
+export declare function reject_<I, O = readonly I[]>(
 	is_match_:is_match__T<I>
 ):(a:readonly I[])=>O
-export declare function maybe_reject_<
-	I extends unknown = unknown,
-	O extends unknown = readonly I[],
-	Or = null
->(
+export declare function maybe_reject_<I, O = readonly I[], Or = null>(
 	is_match_:is_match__T<I>,
 	or?:Or
 ):(a:readonly I[]|undefined)=>O|Or

package/all/remove/index.d.ts

@@ -1,15 +1,11 @@
 /**
  * Remove each `...item_a` from `a`.
  */
-export declare function remove<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
+export declare function remove<I, O = readonly I[]>(
 	a:readonly I[],
 	...item_a:readonly I[]
 ):O
-export declare function maybe_remove<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
+export declare function maybe_remove<I, O = readonly I[]>(
 	maybe_a:readonly I[]|undefined,
 	...item_a:readonly I[]
 ):O|undefined

package/all/remove_idx/index.d.ts

@@ -1,10 +1,10 @@
 /**
  * Remove `count = 1` items from `a` at position `idx`.
  */
-export declare function remove_idx<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
-	a:readonly I[], idx:number, count?:number
+export declare function remove_idx<I, O = readonly I[]>(
+	a:readonly I[],
+	idx:number,
+	count?:number
 ):O
 export {
 	remove_idx as remove__idx,

package/all/resolver_curry/index.d.ts

@@ -1,6 +1,6 @@
-export type resolver_curry_T<ResolverArg extends unknown = unknown> = (
+export type resolver_curry_T<ResolverArg> = (
 	...resolver_arg_a:ResolverArg[]
 )=>resolver_curry_T<ResolverArg>
-export type append_current_T<ResolverArg extends unknown = unknown> = (
+export type append_current_T<ResolverArg> = (
 	local:ResolverArg[], arg_a:ResolverArg[]
 )=>any

package/all/reverse/index.d.ts

@@ -1,16 +1,8 @@
 /**
  * Reverses the order of items in `in_a` by mutating `in_a`.
  */
-export declare function reverse<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
-	in_a:readonly I[]
-):O
-export declare function maybe_reverse<
-	I extends unknown = unknown,
-	O extends unknown = readonly I[],
-	Or = null
->(
+export declare function reverse<I, O = readonly I[]>(in_a:readonly I[]):O
+export declare function maybe_reverse<I, O = readonly I[], Or = null>(
 	maybe_a:readonly I[]|undefined,
 	or?:Or
 ):O|Or

package/all/right_and/index.d.ts

@@ -3,9 +3,7 @@ import type { falsy } from '../falsy/index.js'
 /**
  * Returns function that returns the first falsy from `value` or `a_unwrap` or the last value of `a_unwrap`.
  */
-export declare function right_and_<
-	Val extends unknown = unknown
->(
+export declare function right_and_<Val>(
 	a_unwrap:a_nowrap_T<Val>
 ):(val:Val)=>Val|falsy
 export {

package/all/right_or/index.d.ts

@@ -2,9 +2,7 @@ import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns function that returns first truthy or last item in `a_unwrap`.
  */
-export declare function right_or_<
-	Val extends unknown = unknown
->(
+export declare function right_or_<Val>(
 	a_unwrap:a_nowrap_T<Val>
 ):(fn_a_unwrap:Val)=>Val|undefined
 export {

package/all/rmemo/index.js

@@ -15,12 +15,12 @@ export function memo_(memo_def, ...subscriber_a) {
 			memo.f()
 		}
 		if (cur_memo) {
-			if (!~memo.memor.indexOf(cur_memo.r ||= new WeakRef(cur_memo.f))) memo.memor.push(cur_memo.r)
+			if (!memo.memor.includes(cur_memo.r ||= new WeakRef(cur_memo.f))) memo.memor.push(cur_memo.r)
 			if (cur_memo.f.l < memo.f.l + 1) cur_memo.f.l = memo.f.l + 1
 			// conditional in r calls this r_memo
 			cur_memo.f.s.push(memo)
 			// prevent this rmemo from GC while cur_memo is still active
-			if (!~cur_memo.f.S.indexOf(memo)) cur_memo.f.S.push(memo)
+			if (!cur_memo.f.S.includes(memo)) cur_memo.f.S.push(memo)
 		}
 		return memo.val
 	}
@@ -32,7 +32,7 @@ export function memo_(memo_def, ...subscriber_a) {
 				run_queue = !queue.size
 				memo.memor = memo.memor.filter(r=>{
 					r = r.deref()
-					if (r && ~r.s.indexOf(memo)) { // if conditional r refresh calls this r_memo, add to queue
+					if (r && r.s.includes(memo)) { // if conditional r refresh calls this r_memo, add to queue
 						queue.add(r)
 					}
 					return r

package/all/rmemo__wait/index.test.ts

@@ -17,7 +17,7 @@ test('rmemo__wait', async ()=>{
 		subject$._ = 1
 		equal(subject, -1)
 		equal(subject$(), 1)
-	}).catch($=>console.trace($))
+	})
 	equal(subject, 1)
 })
 test.run()

package/all/run/index.d.ts

@@ -1,7 +1,4 @@
-export declare function run<
-	O extends unknown = unknown,
-	A extends any[] = any[]
->(
+export declare function run<O, A extends unknown[] = unknown[]>(
 	fn:(...arg_a:A)=>O,
 	...arg_a:A
 ):O

package/all/selector_splice/index.d.ts

@@ -1,9 +1,7 @@
 /**
  * splice out any `array` elements matching `selector`
  */
-export declare function selector_splice<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
+export declare function selector_splice<I, O extends unknown[] = readonly I[]>(
 	a:readonly I[],
 	selector:(v:I, i:number, a:readonly I[])=>I
 ):O

package/all/slice/index.d.ts

@@ -1,18 +1,12 @@
 /**
  * Calls slice on a
  */
-export declare function slice<
-	I extends unknown = unknown, O extends unknown = readonly I[]
->(
-	a:readonly  I[],
+export declare function slice<I, O extends unknown[] = readonly I[]>(
+	a:readonly I[],
 	begin_idx?:number,
 	end_idx?:number
 ):O
-export declare function maybe_slice<
-	I extends unknown = unknown,
-	O extends unknown = readonly I[],
-	Or = null
->(
+export declare function maybe_slice<I, O extends unknown[] = readonly I[], Or = null>(
 	maybe_a:readonly I[]|undefined,
 	begin_idx?:number,
 	end_idx?:number,
@@ -21,14 +15,10 @@ export declare function maybe_slice<
 /**
  * Returns a `slice` function with the given `...arg_a` that takes a Array `a` as it's argument.
  */
-export declare function slice_<
-	I extends unknown = unknown
->(
+export declare function slice_<I>(
 	begin_idx?:number, end_idx?:number
 ):(a:readonly I[])=>I[]
-export declare function maybe_slice_<
-	I extends unknown = unknown, Or = null
->(
+export declare function maybe_slice_<I, Or = null>(
 	begin_idx?:number, end_idx?:number, or?:Or
 ):(maybe_a:readonly I[]|undefined)=>I[]|Or
 export {

package/all/slice_arg_a/index.d.ts

@@ -2,22 +2,13 @@ import type { a_nowrap_T } from '../a_nowrap/index.js'
 /**
  * Returns a function where the arguments to the wrapped function are sliced with begin_idx & end_idx.
  */
-export declare function slice_arg_a_<
-	In extends unknown = unknown,
-	Out extends unknown[] = unknown[]
->(
+export declare function slice_arg_a_<In, Out extends unknown[] = unknown[]>(
 	fn:slice_arg_a_fn_T<In, Out>, begin_idx?:number, end_idx?:number
 ):slice_arg_a_T<In, Out>
-export declare type slice_arg_a_fn_T<
-	In extends unknown = unknown,
-	Out extends unknown[] = unknown[]
-> = (
+export declare type slice_arg_a_fn_T<In, Out extends unknown[] = unknown[]> = (
 	arg_a:a_nowrap_T<In>
 )=>Out
-export declare type slice_arg_a_T<
-	In extends unknown = unknown,
-	Out extends unknown[] = unknown[]
-> = (
+export declare type slice_arg_a_T<In, Out extends unknown[] = unknown[]> = (
 	arg_a:a_nowrap_T<In>
 )=>Out
 export {

package/all/slice_arg_spread_a/index.d.ts

@@ -1,10 +1,7 @@
 /**
  * Returns a function that calls fn passing the arguments sliced by slice_arg_a.
  */
-export declare function slice_arg_spread_a_<
-	In extends unknown[] = unknown[],
-	Out extends unknown = unknown,
->(
+export declare function slice_arg_spread_a_<In extends unknown[] = unknown[], Out = unknown>(
 	fn:slice_arg_spread_a__arg__T<In, Out>,
 	begin_idx?:number,
 	end_idx?:number
@@ -14,16 +11,11 @@ export {
 	slice_arg_spread_a_ as slice_arg_a1,
 	slice_arg_spread_a_ as slice__a1__arg,
 }
-export declare type slice_arg_spread_a__arg__T<
-	In extends unknown[] = unknown[],
-	Out extends unknown = unknown
-> = (
+export declare type slice_arg_spread_a__arg__T<In extends unknown[] = unknown[], Out = unknown> = (
 	arg_a:In[number][]
 )=>Out
 export declare type slice_arg_spread_a__arg_fn_T = slice_arg_spread_a__arg__T
-export declare type slice_arg_spread_a___ret_T<
-	In extends unknown[] = unknown[],
-	Out extends unknown = unknown> = (
+export declare type slice_arg_spread_a___ret_T<In extends unknown[] = unknown[], Out = unknown> = (
 	...arg_a:In
 )=>Out
 export declare type slice_arg_spread_a__ret_T = slice_arg_spread_a__arg__T