ctx-core 5.11.0 → 5.14.0

package/all/be/index.d.ts

@@ -1,11 +1,11 @@
 import type { be__val__new_T, be_config_T, Ctx, Ctx_wide_T } from '../be_/index.js'
 export declare function be<
-	Out extends NonNullable<unknown>,
+	val_T extends NonNullable<unknown>,
 	ns_T extends string = '',
 	ctx_T extends Ctx = Ctx_wide_T<ns_T>
 >(
 	ctx:ctx_T,
-	val_:be__val__new_T<Out, ns_T, ctx_T>,
+	val_:be__val__new_T<val_T, ns_T, ctx_T>,
 	config:be_config_T<ns_T>
-):Out
+):val_T
 export { be as b, }

package/all/be/index.test.ts

@@ -0,0 +1,21 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { be_ } from '../be_/index.js'
+import { ctx__new } from '../ctx/index.js'
+import { be } from './index.js'
+test('be|s|BeMap', ()=>{
+	const ctx = ctx__new()
+	let incrementer_num = 0
+	const incrementer = ()=>++incrementer_num
+	const root_ = be_(()=>
+		incrementer(),
+	{ id: 'root_' })
+	const child = be(ctx, ctx=>
+		root_(ctx) + incrementer(),
+	{ id: 'child_' })
+	equal(root_(ctx), 1)
+	equal(ctx.s[''].get('root_')![0], 1)
+	equal(child, 3)
+	equal(ctx.s[''].get('child_')![0], 3)
+})
+test.run()

package/all/be_/index.js

@@ -132,6 +132,12 @@ export function be_map__find(be_or_id, ctx, ns = be_or_id.ns ?? '') {
 export function be__val_(be_or_id, ctx, ns) {
 	return be_map__find(be_or_id, ctx, ns)?.get?.(be_or_id.id ?? be_or_id)?.[0]
 }
+/**
+ * @param {be__val__new_T}val__new
+ * @param {be_config_T}config
+ * @returns {Be}
+ * @private
+ */
 export function ondelete_be_(val__new, config) {
 	let be = be_(val__new, config)
 	let ondelete_cb_a = []
@@ -140,6 +146,7 @@ export function ondelete_be_(val__new, config) {
 		for (let ondelete_cb of ondelete_cb_a) {
 			ondelete_cb(...state)
 		}
+		ondelete_cb_a = []
 	}
 	return be
 }

package/all/be_/index.test.ts

@@ -22,9 +22,9 @@ import {
 	globalThis__be_,
 	ondelete_be_
 } from '../be_/index.js'
-import { ctx_, ctx__new, ns_ctx__new } from '../ctx/index.js'
+import { ctx__new, ns_ctx__new } from '../ctx/index.js'
 import { tempfile_path_ } from '../tempfile_path/index.js'
-import { Equal, Expect } from '../test/index.js'
+import type { Equal, Expect } from '../test/index.js'
 test.after(()=>{
 	delete (globalThis as { root_be?:Be<unknown> }).root_be
 })
@@ -165,7 +165,7 @@ test('be_|Ctx generic type', ()=>{
 	{ id: 'val_', ns: 'test_ns' })
 	val_(valid_ctx)
 	// @ts-expect-error TS2322
-	throws(()=>val_(ctx_()))
+	throws(()=>val_(ctx__new()))
 })
 test('be_|Ctx|ns', ()=>{
 	const ctx0 = ctx__new()
@@ -425,6 +425,12 @@ test('ondelete_be_', ()=>{
 	ctx__delete(ctx, be)
 	equal(ondelete0_arg_aa, [[1, ctx, be]])
 	equal(ondelete1_arg_aa, [[1, ctx, be]])
+	equal(be(ctx), 1)
+	equal(ondelete0_arg_aa, [[1, ctx, be]])
+	equal(ondelete1_arg_aa, [[1, ctx, be]])
+	ctx__delete(ctx, be)
+	equal(ondelete0_arg_aa, [[1, ctx, be], [1, ctx, be]])
+	equal(ondelete1_arg_aa, [[1, ctx, be], [1, ctx, be]])
 })
 test('ctx__clear', ()=>{
 	const ondelete0_arg_aa:[val:number, ctx:Ctx, be:Be<number, ''|'test_ns'>][] = []

package/all/bind_apply/index.d.ts

@@ -4,14 +4,34 @@ import type { call_fn_T } from '../call/index.js'
  */
 export declare function bind_apply_<
 	Self,
-	A_outer = unknown,
-	A_inner extends unknown[] = unknown[],
-	Out = unknown
+	A extends unknown[] = unknown[],
+	in_A extends unknown[] = unknown[],
+	O = unknown
 >(
-	fn:call_fn_T<A_inner, Out>, self:Self, in_arg_a?:A_outer
-):ReturnType<call_fn_T<A_inner, Out>>
+	fn:call_fn_T<A, O>,
+	self:Self,
+	in_arg_a?:bind_apply__in_arg_a_T<A, in_A>
+):(...arg_a:bind_apply__out_arg_a_T<A, in_A>)=>O
 export {
 	bind_apply_ as _bind_apply,
 	bind_apply_ as _apply__bind,
 }
-
+export type bind_apply__in_arg_a_T<
+	A extends unknown[],
+	in_A extends unknown[]
+> =
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	A extends [...in_A, ...infer out_a]
+		? in_A
+		: never
+export type bind_apply__out_arg_a_T<
+	A extends unknown[],
+	in_A extends unknown[]
+> =
+	A extends [...in_A, ...infer out_A]
+		? [...in_A, ...out_A] extends A
+			? out_A
+			: in_A extends unknown[]
+			? A
+			: never
+		: never

package/all/bind_apply/index.js

@@ -2,14 +2,14 @@
 /**
  * Returns function bound to self that applies arg_a with ...arg_a_
  * @param {call_fn_T}fn
- * @param {unknown}self
+ * @param {unknown}_this
  * @param {unknown}[in_arg_a]
  * @returns {(fn:call_fn_T, unknown, in_arg_a?:unknown[])=>ReturnType<call_fn_T>}
  */
-export function bind_apply_(fn, _self, _in_arg_a) {
-	return (find, self, in_arg_a)=>fn.apply(self ?? _self, [
-		...in_arg_a,
-		...(fn_arg_a ?? _in_arg_a)
+export function bind_apply_(fn, _this, in_arg_a) {
+	return (..._in_arg_a)=>fn.apply(_this, [
+		...in_arg_a ?? [],
+		..._in_arg_a
 	])
 }
 export {

package/all/bind_apply/index.test.ts

@@ -0,0 +1,19 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { tup } from '../tup/index.js'
+import { bind_apply_ } from './index.js'
+test('bind_apply_', ()=>{
+	function fn(this:unknown, a:number, b:number, c:number, d:number) {
+	  return [this, a, b, c, d]
+	}
+	const _this = { foo: 'bar' }
+	equal(bind_apply_(fn, _this)(0, 1, 2, 3), [_this, 0, 1, 2, 3])
+	equal(bind_apply_(fn, _this, tup(0, 1))(2, 3), [_this, 0, 1, 2, 3])
+	// @ts-expect-error TS2345
+	equal(bind_apply_(fn, _this)(0, 1, 2, 3, 4), [_this, 0, 1, 2, 3])
+	// @ts-expect-error TS2345
+	equal(bind_apply_(fn, _this, tup(0, 1))(2, 3, 4), [_this, 0, 1, 2, 3])
+	// @ts-expect-error TS2345
+	equal(bind_apply_(fn, _this, tup(0, 1, 2, 3, 4))(), [_this, 0, 1, 2, 3])
+})
+test.run()

package/all/bind_call/index.d.ts

@@ -7,14 +7,32 @@ export {
  * Returns function bound to self that calls ...in_arg_a concat with ...fn_arg_a passed to function
  */
 export declare function bind_call_<
+	Self,
 	A extends unknown[] = unknown[],
-	O = unknown,
-	S = unknown
+	in_A extends unknown[] = unknown[],
+	Out = unknown
 >(
-	fn:call_fn_T<A, O>, self:S, ...in_arg_a:A[]
-):ReturnType<call_fn_T<A, O>>
+	fn:call_fn_T<A, Out>,
+	self:Self,
+	...in_arg_a:bind_call__in_arg_a_T<A, in_A>
+):(...arg_a:[...bind_call__out_arg_a_T<A, in_A>])=>Out
 export declare type bind_call_T<
 	A extends readonly unknown[] = readonly unknown[],
 	O = unknown
 > = (...fn_arg_a:A)=>O
 export declare type bind_call_type = bind_call_T
+export type bind_call__in_arg_a_T<
+	A extends unknown[],
+	in_A extends unknown[]
+> =
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	A extends [...in_A, ...infer Right]
+		? in_A
+		: never
+export type bind_call__out_arg_a_T<
+	A extends unknown[],
+	in_A extends unknown[]
+> =
+	A extends [...in_A, ...infer out_A]
+		? out_A
+		: never

package/all/bind_call/index.js

@@ -7,7 +7,7 @@
  * @returns {(fn:call_fn_T, self:unknown, ...in_arg_a:unknown[])=>ReturnType<call_fn_T>}
  */
 export function bind_call_(fn, self, ...in_arg_a) {
-	return (...fn_arg_a)=>fn.call(self, ...[
+	return (...fn_arg_a)=>fn.apply(self, [
 		...in_arg_a,
 		...fn_arg_a
 	])

package/all/bind_call/index.test.ts

@@ -0,0 +1,18 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { bind_call_ } from './index.js'
+test('bind_call_', ()=>{
+	function fn(this:unknown, a:number, b:number, c:number, d:number) {
+		return [this, a, b, c, d]
+	}
+	const _this = { foo: 'bar' }
+	equal(bind_call_(fn, _this)(0, 1, 2, 3), [_this, 0, 1, 2, 3])
+	equal(bind_call_(fn, _this, 0, 1)(2, 3), [_this, 0, 1, 2, 3])
+	// @ts-expect-error TS2345
+	equal(bind_call_(fn, _this)(0, 1, 2, 3, 4), [_this, 0, 1, 2, 3])
+	// @ts-expect-error TS2345
+	equal(bind_call_(fn, _this, 0, 1)(2, 3, 4), [_this, 0, 1, 2, 3])
+	// @ts-expect-error TS2345
+	equal(bind_call_(fn, _this, 0, 1, 2, 3, 4)(), [_this, 0, 1, 2, 3])
+})
+test.run()

package/all/call/index.d.ts

@@ -18,5 +18,5 @@ export { call_ as _call, }
 export declare type call_fn_T<
 	A extends readonly unknown[] = readonly unknown[],
 	O = unknown
-> = (...args:A)=>O
+> = (...arg_a:A)=>O
 export declare type call_fn_type = call_fn_T

package/all/ctx/index.d.ts

@@ -1,5 +1,5 @@
 import type { Ctx } from '../be_/index.js'
-import { TupleToUnion } from '../tup/index.js'
+import type { TupleToUnion } from '../tuple/index.js'
 export declare function ctx__new():Ctx<''>
 export { ctx__new as ctx_ }
 export declare function ns_ctx__new<ns0_T extends string|Ctx, ns_a_T extends (string|Ctx)[]>(

package/all/index.d.ts

@@ -14,7 +14,6 @@ export * from './NumericUnit/index.js'
 export * from './PHI/index.js'
 export * from './Request/index.js'
 export * from './Response/index.js'
-export * from './Timeout/index.js'
 export * from './VERSION/index.js'
 export * from './a/index.js'
 export * from './a_assign/index.js'
@@ -341,7 +340,6 @@ export * from './prev_idx/index.js'
 export * from './primitive/index.js'
 export * from './promise/index.js'
 export * from './promise_o/index.js'
-export * from './promise_timeout/index.js'
 export * from './prototype/index.js'
 export * from './prototype_mixin/index.js'
 export * from './push/index.js'
@@ -406,6 +404,7 @@ export * from './throttle/index.js'
 export * from './tick/index.js'
 export * from './timedout/index.js'
 export * from './timedout/index.js'
+export * from './timeout/index.js'
 export * from './timeout_promise/index.js'
 export * from './times/index.js'
 export * from './timestamp_ms/index.js'
@@ -413,6 +412,7 @@ export * from './timestamp_ms/index.js'
 export * from './toLocalDateString/index.js'
 export * from './toString/index.js'
 export * from './tup/index.js'
+export * from './tuple/index.js'
 export * from './tuple__o/index.js'
 export * from './tuple__union/index.js'
 export * from './tuple_a_o/index.js'
@@ -442,7 +442,6 @@ export * from './valueof/index.js'
 export * from './values/index.js'
 export * from './waitfor/index.js'
 export * from './waitfor_fibonacci_backoff/index.js'
-export * from './waitfor_val/index.js'
 export * from './weak_r/index.js'
 export * from './week/index.js'
 export * from './wrap_a/index.js'

package/all/index.js

@@ -14,7 +14,6 @@ export * from './NumericUnit/index.js'
 export * from './PHI/index.js'
 export * from './Request/index.js'
 export * from './Response/index.js'
-export * from './Timeout/index.js'
 export * from './VERSION/index.js'
 export * from './a/index.js'
 export * from './a_assign/index.js'
@@ -341,7 +340,6 @@ export * from './prev_idx/index.js'
 export * from './primitive/index.js'
 export * from './promise/index.js'
 export * from './promise_o/index.js'
-export * from './promise_timeout/index.js'
 export * from './prototype/index.js'
 export * from './prototype_mixin/index.js'
 export * from './push/index.js'
@@ -406,6 +404,7 @@ export * from './throttle/index.js'
 export * from './tick/index.js'
 export * from './timedout/index.js'
 export * from './timedout/index.js'
+export * from './timeout/index.js'
 export * from './timeout_promise/index.js'
 export * from './times/index.js'
 export * from './timestamp_ms/index.js'
@@ -413,6 +412,7 @@ export * from './timestamp_ms/index.js'
 export * from './toLocalDateString/index.js'
 export * from './toString/index.js'
 export * from './tup/index.js'
+export * from './tuple/index.js'
 export * from './tuple__o/index.js'
 export * from './tuple__union/index.js'
 export * from './tuple_a_o/index.js'
@@ -442,7 +442,6 @@ export * from './valueof/index.js'
 export * from './values/index.js'
 export * from './waitfor/index.js'
 export * from './waitfor_fibonacci_backoff/index.js'
-export * from './waitfor_val/index.js'
 export * from './weak_r/index.js'
 export * from './week/index.js'
 export * from './wrap_a/index.js'

package/all/nullish__guard__async/index.js

@@ -10,7 +10,7 @@ export async function nullish__guard__async(
 		const rv = await fn()
 		if (rv != null) return rv
 	}
-	throw new Error(`${label} cannot be nullish`)
+	throw Error(`${label} cannot be nullish`)
 }
 export {
 	nullish__guard__async as nullish_async_guard,

package/all/nullish__none/index.d.ts

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

package/all/rmemo__wait/index.js

@@ -1,6 +1,6 @@
 /// <reference types="../rmemo/index.d.ts" />
 /// <reference types="./index.d.ts" />
-import { promise_timeout } from '../promise_timeout/index.js'
+import { timeout_promise } from '../timeout_promise/index.js'
 import { memo_ } from '../rmemo/index.js'
 /**
  * @param {rmemo_T}rmemo
@@ -26,7 +26,7 @@ export function rmemo__wait(
 	})
 	/** @type {cancel_Promise&{ m:memo_T<unknown> }} */
 	let promise =
-		promise_timeout(
+		timeout_promise(
 			_subscribe_wait,
 			timeout ?? Infinity,
 			error)

package/all/run/index.d.ts

@@ -6,4 +6,3 @@ export declare function run<O, A extends unknown[] = unknown[]>(
 	arg_a:A,
 	fn:(...arg_a:A)=>O
 ):O
-export { run as _ }

package/all/run/index.js

@@ -10,4 +10,3 @@ export function run(...arg_a) {
 			: arg_a[1](...arg_a[0])
 	)
 }
-export { run as _ }

package/all/tap/index.d.ts

@@ -1,20 +1,18 @@
 /**
- * Invokes interceptor with the obj, and then returns the object.
+ * Invokes interceptor with the val, and then returns the object.
  * The primary purpose of this method is to "tap into" a method chain,
  * to perform operations on intermediate results within the chain.
  * @see {@link https://underscorejs.org/#tap}
  */
-export declare function tap<Obj>(
-	obj:Obj, interceptor:tap__interceptor_T<Obj>
-):Obj
-export declare type tap__interceptor_T<T = unknown> = (obj:T)=>void
-export declare type tap_interceptor_T<T = unknown> = tap__interceptor_T<T>
+export declare function tap<V>(
+	val:V, interceptor:tap__interceptor_T<V>
+):V
+export declare type tap__interceptor_T<V = unknown> = (Val:V)=>void
+export declare type tap_interceptor_T<V = unknown> = tap__interceptor_T<V>
 /**
  * Returns function that calls tap with obj.
  */
-export declare function tap_<
-	Val = unknown
->(
-	fn:tap__interceptor_T<Val>
-):(val:Val)=>Val
+export declare function tap_<V = unknown>(
+	fn:tap__interceptor_T<V>
+):(val:V)=>V
 export { tap_ as _tap, }

package/all/tap/index.test.ts

@@ -0,0 +1,10 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { tap } from './index.js'
+test('tap', ()=>{
+	const o = {} as { foo?:string }
+	equal(tap(o, _o=>{
+		_o.foo = 'bar'
+	}), { foo: 'bar' })
+})
+test.run()

package/all/timeout/index.d.ts

@@ -0,0 +1,3 @@
+export declare class Timeout extends Error {
+	constructor(ms_OR_message:number|string)
+}

package/all/timeout/index.js

@@ -0,0 +1,8 @@
+export class Timeout extends Error {
+	constructor(ms_OR_message) {
+		super(
+			typeof ms_OR_message === 'number'
+				? 'Timeout ' + ms_OR_message + 'ms'
+				: ms_OR_message)
+	}
+}

package/all/timeout/index.test.ts

@@ -0,0 +1,8 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { Timeout } from './index.js'
+test('Timeout', ()=>{
+	equal(new Timeout(10).message, 'Timeout 10ms')
+	equal(new Timeout('custom message').message, 'custom message')
+})
+test.run()

package/all/timeout_promise/index.d.ts

@@ -1,6 +1,7 @@
-/**
- * @see {@link https://italonascimento.github.io/applying-a-timeout-to-your-promises/}
- * @see {@link http://disq.us/p/1k8w63m}
- */
-export declare function timeout_promise<O>(ms:number, promise:Promise<O>):Promise<O>
-export { timeout_promise as _timeout_promise }
+import type { cancel_Promise } from '../promise/index.js'
+export declare function timeout_promise<O>(
+	promise:(()=>Promise<O>)|Promise<O>,
+	ms:number,
+	error?:Error
+):cancel_Promise<O, (val?:O)=>Promise<O>>
+export { timeout_promise as promise_timeout }

package/all/timeout_promise/index.js

@@ -1,12 +1,32 @@
-import { promise_timeout } from '../promise_timeout/index.js'
+import { Timeout } from '../timeout/index.js'
 /**
+ * @param {(()=>Promise<unknown>)|Promise<unknown>}promise
  * @param {number}ms
- * @param {Promise<unknown>}promise
- * @returns {Promise<unknown>}
- * @see {@link https://italonascimento.github.io/applying-a-timeout-to-your-promises/}
- * @see {@link http://disq.us/p/1k8w63m}
+ * @param {Error}[error]
+ * @returns {cancel_Promise}
  */
-export async function timeout_promise(ms, promise) {
-	return await promise_timeout(promise, ms)
+export function timeout_promise(
+	promise,
+	ms,
+	error
+) {
+	error ??= new Timeout(ms)
+	let id
+	let timeout = new Promise((_resolve, reject)=>{
+		id = setTimeout(()=>reject(error), ms)
+	})
+	let cancel_promise__resolve
+	let cancel_promise = new Promise(resolve=>cancel_promise__resolve = resolve)
+	/** @type {cancel_Promise} */
+	let ret_promise = Promise.race([
+		typeof promise === 'function' ? promise() : promise,
+		timeout,
+		cancel_promise,
+	]).then(result=>{
+		clearTimeout(id)
+		return result
+	})
+	ret_promise.cancel = cancel_promise__resolve
+	return ret_promise
 }
-export { timeout_promise as _timeout_promise }
+export { timeout_promise as promise_timeout }

package/all/{promise_timeout → timeout_promise}/index.test.ts

@@ -2,10 +2,11 @@ import { test } from 'uvu'
 import { equal } from 'uvu/assert'
 import { run } from '../run/index.js'
 import { sleep } from '../sleep/index.js'
-import { promise_timeout } from './index.js'
-test('promise_timeout|success', async ()=>{
+import { Timeout } from '../timeout/index.js'
+import { timeout_promise } from './index.js'
+test('timeout_promise|success', async ()=>{
 	let count = 0
-	const promise = promise_timeout(run(async ()=>{
+	const promise = timeout_promise(run(async ()=>{
 		count++
 		await sleep(10)
 		return true
@@ -14,11 +15,11 @@ test('promise_timeout|success', async ()=>{
 	equal(await promise, true)
 	equal(count, 1)
 })
-test('promise_timeout|timeout', async ()=>{
+test('timeout_promise|timeout', async ()=>{
 	let count = 0
 	let err:Error|undefined = undefined
 	try {
-		await promise_timeout(run(async ()=>{
+		await timeout_promise(run(async ()=>{
 			count++
 			await sleep(10)
 			return false
@@ -27,10 +28,11 @@ test('promise_timeout|timeout', async ()=>{
 		err = _err as Error
 	}
 	equal(count, 1)
+	equal(err instanceof Timeout, true)
 	equal(err?.message, 'Timeout 1ms')
 })
-test('promise_timeout|cancel|arg', async ()=>{
-	const promise = promise_timeout(
+test('timeout_promise|cancel|arg', async ()=>{
+	const promise = timeout_promise(
 		new Promise<number>(()=>{}),
 		1000)
 	promise.cancel(5)

package/all/tup/index.d.ts

@@ -11,31 +11,3 @@ export {
 	tup as _tup,
 	tup as tup_fn,
 }
-export type TupleRest<T extends unknown[]> =
-	T['length'] extends 0
-		? undefined
-		: (((...b:T)=>void) extends (a:unknown, ...b:infer I)=>void ? I : [])
-export type TupleFirst<T extends unknown[]> =
-	T['length'] extends 0 ? undefined : T[0]
-export type TupleExclude<T extends unknown[], E> =
-	T extends []
-		? [Exclude<T, E>]
-		: T extends [infer Head, ...infer Tail]
-			? [Exclude<Head, E>, ...TupleExclude<Tail, E>]
-			: Exclude<T[number], E>[]
-export type TupleMemberExtends<T extends Readonly<unknown[]>, E> =
-	T extends Readonly<[infer Head, ...infer Tail]>
-		? Head extends E
-			? true
-			: Tail extends unknown[]
-				? TupleMemberExtends<Tail, E>
-				: { ERROR:'Tail is not an array' }
-		: { ERROR:'Head does not extend E' }
-export type TupleValues<T extends Readonly<unknown[]>> =
-	T extends Readonly<[infer Head, ...infer Tail]>
-		? [Head, ...Tail]
-		: { ERROR:'Unable to infer Head & Tail from T' }
-export type TupleConcat<T> = T extends [infer A extends Readonly<unknown[]>, ...infer Rest extends Readonly<unknown[]>]
-	? A extends unknown[] ? [...A, ...TupleConcat<Rest>] : A
-	: T
-export type TupleToUnion<T extends unknown[]> = T[number]

package/all/tuple/index.d.ts

@@ -0,0 +1,28 @@
+export type TupleRest<T extends unknown[]> =
+	T['length'] extends 0
+		? undefined
+		: (((...b:T)=>void) extends (a:unknown, ...b:infer I)=>void ? I : [])
+export type TupleFirst<T extends unknown[]> =
+	T['length'] extends 0 ? undefined : T[0]
+export type TupleExclude<T extends unknown[], E> =
+	T extends []
+		? [Exclude<T, E>]
+		: T extends [infer Head, ...infer Tail]
+			? [Exclude<Head, E>, ...TupleExclude<Tail, E>]
+			: Exclude<T[number], E>[]
+export type TupleMemberExtends<T extends Readonly<unknown[]>, E> =
+	T extends Readonly<[infer Head, ...infer Tail]>
+		? Head extends E
+			? true
+			: Tail extends unknown[]
+				? TupleMemberExtends<Tail, E>
+				: { ERROR:'Tail is not an array' }
+		: { ERROR:'Head does not extend E' }
+export type TupleValues<T extends Readonly<unknown[]>> =
+	T extends Readonly<[infer Head, ...infer Tail]>
+		? [Head, ...Tail]
+		: { ERROR:'Unable to infer Head & Tail from T' }
+export type TupleConcat<T> = T extends [infer A extends Readonly<unknown[]>, ...infer Rest extends Readonly<unknown[]>]
+	? A extends unknown[] ? [...A, ...TupleConcat<Rest>] : A
+	: T
+export type TupleToUnion<T extends unknown[]> = T[number]

package/all/tuple/index.js

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

package/all/tuple__o/index.d.ts

@@ -1,7 +1,7 @@
 export type tuple__o_T<
-	T extends readonly any[],
+	T extends readonly unknown[],
 	Key extends keyof T[number],
 	Val extends keyof T[number]
 > = {
-	[P in Exclude<keyof T, keyof readonly any[]> as T[P][Key]&string]:T[P][Val]
+	[P in Exclude<keyof T, keyof readonly unknown[]> as T[P][Key]&string]:T[P][Val]
 }

package/all/tuple__union/index.d.ts

@@ -1 +1 @@
-export type tuple__union_T<T extends any[]> = T[number]
+export type tuple__union_T<T extends unknown[]> = T[number]

package/all/tuple_a_o/index.d.ts

@@ -4,7 +4,7 @@ import type { zip__tuple_a_T } from '../zip__tuple_a/index.js'
  */
 export type tuple_a_o_T<
 	K extends readonly PropertyKey[],
-	V extends readonly any[]
+	V extends readonly unknown[]
 > = {
 	[T in zip__tuple_a_T<K, V>[number] as T[0]]:T[1]
 }

package/all/waitfor/index.d.ts

@@ -4,6 +4,7 @@ export declare function waitfor<V>(
 	timeout:number,
 	period?:number|((promise:waitfor_Promise<V>)=>Promise<number>)
 ):waitfor_Promise<V>
+export { waitfor as waitfor_val, waitfor as waitfor_val_ }
 export declare function cancel__period_<V>(
 	ms:number,
 	should_cancel_:()=>boolean