ctx-core 2.1.0 → 2.2.1

package/all/bad_request/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_request__default__message = 'Bad Request'
+/**
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @returns {BadRequestError}
+ * @private
+ */
+export function bad_request_error_(
+	message,
+	error_o
+) {
+	return assign(
+		new BadRequestError(
+			message ?? bad_request__default__message),
+		error_o)
+}
+/**
+ * Throws a bad_request error (HTTP 400)
+ * @param {string}[message]
+ * @param {argument__error_o_T}[error_o]
+ * @example
+ * bad_request__throw(ctx) // Bad Request
+ */
+export function bad_request__throw(
+	message,
+	error_o
+) {
+	throw bad_request_error_(message, error_o)
+}
+/** @type {import('./index.d.ts').BadRequestError} */
+export class BadRequestError extends HttpError {
+	/**
+	 * @param {string}[message]
+	 */
+	constructor(message) {
+		super(message)
+		this.name = 'BadRequestError'
+		this.http__status = 400
+		this.http__message = bad_request__default__message
+		if (!this.message) this.message = this.http__message
+	}
+}

package/all/base16_random/index.d.ts

@@ -0,0 +1,2 @@
+export declare function base16_random(length?:number):string
+export { base16_random as random__base16 }

package/all/base16_random/index.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number}[length]
+ * @returns {string}
+ */
+export function base16_random(length = 5) {
+	const value_a = []
+	const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+	const length__possible = possible.length
+	for (let i = 0; i < length; i++) {
+		value_a.push(possible.charAt(Math.floor(Math.random() * length__possible)))
+	}
+	return value_a.join('')
+}
+export { base16_random as random__base16 }

package/all/base64__buffer/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare function base64__buffer_(base64:string):Uint8Array|Buffer
+export {
+	base64__buffer_ as base64_buffer_,
+	base64__buffer_ as _base64_buffer,
+}

package/all/base64__buffer/index.js

@@ -0,0 +1,15 @@
+/**
+ * @param {string}base64
+ * @return {Uint8Array}
+ */
+export function base64__buffer_(base64) {
+	if (globalThis['window']) {
+		return Uint8Array.from(window.atob(base64, (c)=>c.charCodeAt(0)))
+	} else {
+		return Buffer.from(base64, 'base64')
+	}
+}
+export {
+	base64__buffer_ as base64_buffer_,
+	base64__buffer_ as _base64_buffer,
+}

package/all/batch_queue/index.d.ts

@@ -0,0 +1,5 @@
+export declare function batch_queue_(queue_size?:number, batch_size?:number):batch_queue_T
+export interface batch_queue_T {
+	add<Out>(queue_fn:()=>Promise<Out>):Promise<[()=>Promise<Out>, Promise<Out>]>
+	close():Promise<unknown>
+}

package/all/batch_queue/index.js

@@ -0,0 +1,44 @@
+import { queue_ } from '../queue/index.js'
+const default_queue_size = 4
+export function batch_queue_(queue_size = default_queue_size, batch_queue_size = queue_size) {
+	if (!queue_size) queue_size = default_queue_size
+	if (!batch_queue_size) batch_queue_size = queue_size
+	const queue = queue_(queue_size)
+	const pending_set = new Set()
+	const waiting_fifo = []
+	return {
+		add(fn) {
+			if (pending_set.size < batch_queue_size) {
+				return Promise.resolve([fn, pending_promise_(fn)])
+			} else {
+				return new Promise(resolve=>{
+					waiting_fifo.push(()=>{
+						resolve([fn, pending_promise_(fn)])
+					})
+				})
+			}
+		},
+		close() {
+			return queue.close()
+		}
+	}
+	function pending_promise_(fn) {
+		const pending_promise = queue.add(fn).then(v=>{
+			try {
+				return v
+			} finally {
+				next(pending_promise)
+			}
+		}).catch(()=>{
+			next(pending_promise)
+		})
+		pending_set.add(pending_promise)
+		return pending_promise
+	}
+	function next(pending_promise) {
+		pending_set.delete(pending_promise)
+		if (waiting_fifo.length) {
+			waiting_fifo.shift()()
+		}
+	}
+}

package/all/batch_queue/index.test.ts

@@ -0,0 +1,149 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import { batch_queue_ } from '../batch_queue/index.js'
+import { promise_o_ } from '../promise_o/index.js'
+test('batch_queue_(1).add|enqueue 1 at a time & run 1 at a time', async ()=>{
+	const batch_queue = batch_queue_(1)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	const fn_a = [()=>promise_o_a[0].promise, ()=>promise_o_a[1].promise, ()=>promise_o_a[2].promise]
+	const ret0_a:any[] = [null, null, null]
+	const ret1_a:any[] = [null, null, null]
+	batch_queue.add(fn_a[0])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[0] = ret0
+		ret1_p.then(ret0=>ret1_a[0] = ret0)
+	})
+	batch_queue.add(fn_a[1])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[1] = ret0
+		ret1_p.then(ret1=>ret1_a[1] = ret1)
+	})
+	batch_queue.add(fn_a[2])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[2] = ret0
+		ret1_p.then(ret1=>ret1_a[2] = ret1)
+	})
+	equal(ret0_a, [null, null, null])
+	equal(ret1_a, [null, null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], null, null])
+	equal(ret1_a, [null, null, null])
+	promise_o_a[1].resolve('val1')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], null, null])
+	equal(ret1_a, [null, null, null])
+	promise_o_a[0].resolve('val0')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], null, null])
+	equal(ret1_a, [null, null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], null])
+	equal(ret1_a, ['val0', null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', null])
+	promise_o_a[2].resolve('val2')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', 'val2'])
+})
+test('batch_queue_(1, 2).add|enqueue 2 at a time & run 1 at a time', async ()=>{
+	const batch_queue = batch_queue_(1, 2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	const fn_a = [()=>promise_o_a[0].promise, ()=>promise_o_a[1].promise, ()=>promise_o_a[2].promise]
+	const ret0_a:any[] = [null, null, null]
+	const ret1_a:any[] = [null, null, null]
+	batch_queue.add(fn_a[0])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[0] = ret0
+		ret1_p.then(ret0=>ret1_a[0] = ret0)
+	})
+	batch_queue.add(fn_a[1])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[1] = ret0
+		ret1_p.then(ret1=>ret1_a[1] = ret1)
+	})
+	batch_queue.add(fn_a[2])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[2] = ret0
+		ret1_p.then(ret1=>ret1_a[2] = ret1)
+	})
+	equal(ret0_a, [null, null, null])
+	equal(ret1_a, [null, null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], null])
+	equal(ret1_a, [null, null, null])
+	promise_o_a[1].resolve('val1')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], null])
+	equal(ret1_a, [null, null, null])
+	promise_o_a[0].resolve('val0')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], null])
+	equal(ret1_a, [null, null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', null])
+	promise_o_a[2].resolve('val2')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', 'val2'])
+})
+test('batch_queue_(2).add|enqueue 2 at a time & run 2 at a time', async ()=>{
+	const batch_queue = batch_queue_(2)
+	const promise_o_a = [promise_o_(), promise_o_(), promise_o_()]
+	const fn_a = [()=>promise_o_a[0].promise, ()=>promise_o_a[1].promise, ()=>promise_o_a[2].promise]
+	const ret0_a:any[] = [null, null, null]
+	const ret1_a:any[] = [null, null, null]
+	batch_queue.add(fn_a[0])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[0] = ret0
+		ret1_p.then(ret0=>ret1_a[0] = ret0)
+	})
+	batch_queue.add(fn_a[1])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[1] = ret0
+		ret1_p.then(ret1=>ret1_a[1] = ret1)
+	})
+	batch_queue.add(fn_a[2])
+	.then(([ret0, ret1_p])=>{
+		ret0_a[2] = ret0
+		ret1_p.then(ret1=>ret1_a[2] = ret1)
+	})
+	equal(ret0_a, [null, null, null])
+	equal(ret1_a, [null, null, null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], null])
+	equal(ret1_a, [null, null, null])
+	promise_o_a[1].resolve('val1')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], null])
+	equal(ret1_a, [null, null, null])
+	promise_o_a[0].resolve('val0')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, [null, 'val1', null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', null])
+	promise_o_a[2].resolve('val2')
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', null])
+	await new Promise(res=>queueMicrotask(()=>res(null)))
+	equal(ret0_a, [fn_a[0], fn_a[1], fn_a[2]])
+	equal(ret1_a, ['val0', 'val1', 'val2'])
+})
+test.run()

package/all/be/index.d.ts

@@ -0,0 +1,5 @@
+import type { be__val__T, Ctx } from '../be_/index.js'
+export declare function be<
+	Out extends NonNullable<unknown>
+>(ctx:Ctx, key:string, val_:be__val__T<Out>):Out
+export { be as b, }

package/all/be/index.js

@@ -0,0 +1,11 @@
+import { be_ } from '../be_/index.js'
+/**
+ * @param {import('../be_/index.js').Ctx}ctx
+ * @param {string}key
+ * @param {import('../be_/index.js').be__val__T}val_
+ * @returns {NonNullable<unknown>}
+ */
+export function be(ctx, key, val_) {
+	return be_(key, val_)(ctx)
+}
+export { be as b, }

package/all/be_/index.d.ts

@@ -0,0 +1,124 @@
+export declare const pending_symbol:unique symbol
+export declare function globalThis__be_<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	val_:be__val__T<Val, ctx_T>,
+	be__params?:be__params_T
+):Be<Val, ctx_T>
+export declare function globalThis__be_<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	id:string,
+	val_:be__val__T<Val, ctx_T>,
+	be__params?:be__params_T
+):Be<Val, ctx_T>
+/**
+ * Auto-memoization function for the Ctx.
+ *
+ * Returns a function to ensure that a member id is defined on a ctx object,
+ * otherwise it creates the value using the val_ factory function.
+ */
+export declare function be_<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	val_:be__val__T<Val, ctx_T>,
+	be__params?:be__params_T
+):Be<Val, ctx_T>
+export declare function be_<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	id:string,
+	val_:be__val__T<Val, ctx_T>,
+	be__params?:be__params_T
+):Be<Val, ctx_T>
+export {
+	be_ as _be,
+	be_ as b_,
+	be_ as _b,
+}
+export declare function be__is_source_<
+	ctx_T extends Ctx = Ctx
+>(be:Be<unknown>):(map_ctx:MapCtx, ctx:ctx_T)=>boolean
+export declare function source__map_ctx_<
+	ctx_T extends Ctx = Ctx
+>(ctx:Ctx, is_source_:is_source__T):MapCtx
+export declare function be__set<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	be:Be<Val>,
+	ctx:ctx_T,
+	val:Val
+):void
+export declare function ctx__set<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	ctx:ctx_T,
+	be_OR_id:Be<Val>|string|symbol,
+	val:Val,
+	is_source_?:is_source__T
+):void
+export declare function be__delete<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	be:Be<Val>,
+	ctx:ctx_T
+):void
+export declare function ctx__delete<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(
+	ctx:ctx_T,
+	be_OR_id:Be<Val>|string|symbol,
+	is_source_?:is_source__T
+):void
+export declare function be__has_<
+	ctx_T extends Ctx = Ctx
+>(be_OR_id:Be<unknown>|string, ctx:ctx_T):boolean
+export declare function be__has__ctx_<
+	ctx_T extends Ctx = Ctx
+>(be_OR_id:Be<unknown>|string, ctx:ctx_T):MapCtx
+export declare function be__val_<
+	Val,
+	ctx_T extends Ctx = Ctx
+>(be_OR_id:Be<Val>|string, ctx:ctx_T):Val|unknown|null
+export declare type MapCtx = Map<Be<unknown>|string|symbol, unknown>
+export interface NestedMapCtx extends Array<NestedMapCtx|MapCtx> {
+}
+export type Ctx = MapCtx|NestedMapCtx
+export declare type Be<
+	Val,
+	ctx_T extends Ctx = Ctx
+> = ((ctx:ctx_T, params?:be_params_T)=>Val)&{
+	id?:string
+}
+export declare type be__return_T<
+	Val,
+	ctx_T extends Ctx = Ctx
+> = Be<Val, ctx_T>
+export declare type be_T<
+	Val,
+	ctx_T extends Ctx = Ctx
+> = Be<Val, ctx_T>
+export declare type be__val__T<
+	Val,
+	ctx_T extends Ctx = Ctx
+> = (ctx:ctx_T, be:Be<Val, ctx_T>, params?:be_params_T)=>Val
+export interface be__params_T {
+	is_source_?:is_source__T
+	expired_?:expired__T
+	be_?:typeof be_
+}
+export type be__opts_T = be__params_T
+export interface be_params_T {
+	force?:boolean
+}
+export type be_opts_T = be_params_T
+export type is_source__T = (map_ctx:MapCtx, ctx:Ctx)=>boolean
+export type expired__T = (ctx:Ctx)=>boolean

package/all/be_/index.js

@@ -0,0 +1,272 @@
+import { globalThis__prop__ensure } from '../globalThis__prop__ensure/index.js'
+import { isArray } from '../isArray/index.js'
+let proto_ = Object.getPrototypeOf
+let string_proto = proto_('')
+let _null = null
+let pending_sym = Symbol.for('pending')
+let be_M_is_source_ = globalThis__prop__ensure(
+	Symbol.for('be_M_is_source_'),
+	()=>new WeakMap())
+/** @typedef {import('./index.d.ts').Be}Be */
+/** @typedef {import('./index.d.ts').Ctx}Ctx */
+/** @typedef {import('./index.d.ts').MapCtx}MapCtx */
+/** @typedef {import('./index.d.ts').be__params_T}be__params_T */
+/** @typedef {import('./index.d.ts').be__val__T}be__val__T */
+/** @typedef {import('./index.d.ts').is_source__T}is_source__T */
+/**
+ * Auto-memoization function for the Ctx.
+ * Memoized on globalThis to allow packages being loaded multiple times, which can happen during bundling.
+ *
+ * Returns a function to ensure that a member id_OR_val_ is defined on a ctx object,
+ * otherwise it creates the value using the val__OR_be__params factory function.
+ * @param {string|be__val__T}id_OR_val_
+ * @param {be__val__T|be__params_T}[val__OR_be__params]
+ * @param {be__params_T}[be__params]
+ * @returns {Be}
+ * @private
+ */
+export function globalThis__be_(
+	id_OR_val_,
+	val__OR_be__params,
+	be__params
+) {
+	return globalThis__prop__ensure(
+		Symbol.for(id_OR_val_),
+		()=>be_(
+			id_OR_val_,
+			val__OR_be__params,
+			be__params))
+}
+/**
+ * Auto-memoization function for the Ctx.
+ *
+ * Returns a function to ensure that a member id is defined on a Ctx,
+ * otherwise it creates the value using the val_ factory function.
+ * @param {string|be__val__T}id_OR_val__new
+ * @param {be__val__T|be__params_T}[val__new_OR_be__params]
+ * @param {be__params_T}[be__params]
+ * @returns {Be}
+ * @private
+ */
+export function be_(
+	id_OR_val__new,
+	val__new_OR_be__params,
+	be__params = {}
+) {
+	/** @type {string} */
+	let id =
+		proto_(id_OR_val__new) === string_proto
+			? id_OR_val__new
+			: _null
+	/** @type {be__val__T} */
+	let val__new =
+		proto_(id_OR_val__new) === string_proto
+			? val__new_OR_be__params || (()=>null)
+			: id_OR_val__new
+	be__params =
+		proto_(id_OR_val__new) === string_proto
+			? be__params
+			: val__new_OR_be__params
+	let is_source_ =
+		be__params
+			? be__params.is_source_
+			: _null
+	let expired_ =
+		be__params
+			? be__params.expired_
+			: ()=>0
+	let be = (argv__ctx, params = {})=>{
+		if (!argv__ctx) {
+			throw new Error(`be must have a Ctx passed as an argument`)
+		}
+		let saved__val = be__val_(be, argv__ctx)
+		if (
+			be__has_(be, argv__ctx)
+			&& !params.force
+			&& (!expired_ || !expired_(argv__ctx))
+		) {
+			return saved__val
+		}
+		let ctx = source__map_ctx_(argv__ctx, is_source_)
+		if (!ctx) {
+			throw new Error(
+				`be: ${
+					String(id)
+				}: is_source_ must be true for at least one Ctx`)
+		}
+		let pending = ctx.get(pending_sym)
+		if (!pending) {
+			pending = new Map()
+			ctx.set(pending_sym, pending)
+		}
+		if (pending.get(be)) {
+			let pending_value_a = []
+			for (let value of pending.values()) {
+				pending_value_a.push(value)
+			}
+			throw new Error(
+				`be_: ${
+					String(id)
+				}: circular dependency:\n${pending_value_a.map(pending_value=>
+					typeof pending_value === 'function'
+						? 'Function'
+						: pending_value).join('\n')}`)
+		}
+		pending.set(be, id || be)
+		let val = val__new(argv__ctx, be, params)
+		ctx.set(be, val)
+		if (id) {
+			ctx.set(id, val)
+		}
+		pending.delete(be)
+		return val
+	}
+	be_M_is_source_.set(be, is_source_)
+	be.id = id
+	return be
+}
+export {
+	be_ as _be,
+	be_ as b_,
+	be_ as _b,
+}
+/**
+ * @param {Be}be
+ * @returns {is_source__T}
+ * @private
+ */
+export function be__is_source__(be) {
+	return be_M_is_source_.get(be)
+}
+/**
+ * @param {Be}be
+ * @param {Ctx}ctx
+ * @param {unknown}val
+ * @returns {unknown}
+ * @private
+ */
+export function be__set(be, ctx, val) {
+	ctx__set(ctx, be, val, be__is_source__(be))
+}
+/**
+ * @param {Ctx}ctx
+ * @param {Be|string|symbol}be_OR_id
+ * @param {unknown}val
+ * @param {is_source__T}[is_source_]
+ * @returns {unknown}
+ * @private
+ */
+export function ctx__set(
+	ctx,
+	be_OR_id,
+	val,
+	is_source_
+) {
+	if (!is_source_) is_source_ = ()=>true
+	let source__map_ctx = source__map_ctx_(ctx, is_source_)
+	if (source__map_ctx) {
+		source__map_ctx.set(be_OR_id, val)
+		let { id } = be_OR_id
+		if (id) {
+			source__map_ctx.set(id, val)
+		}
+	}
+}
+/**
+ * @param {Be}be
+ * @param {Ctx}ctx
+ * @private
+ */
+export function be__delete(be, ctx) {
+	ctx__delete(ctx, be)
+}
+/**
+ * @param {Ctx}ctx
+ * @param {Be|string|symbol}be_OR_id
+ * @param {is_source__T}[is_source_]
+ */
+export function ctx__delete(
+	ctx,
+	be_OR_id,
+) {
+	const is_source_ =
+		be__is_source__(be_OR_id)
+		|| (()=>true)
+	if (isArray(ctx)) {
+		for (let i = 0; i < ctx.length; i++) {
+			if (is_source_(ctx[i], ctx)) {
+				ctx__delete(ctx[i], be_OR_id)
+			}
+		}
+	} else {
+		/** @type {MapCtx} */
+		let map_ctx = /** @type {any} */ctx
+		if (is_source_(map_ctx, ctx)) {
+			let { id } = be_OR_id
+			if (id) {
+				map_ctx.delete(id)
+			}
+			map_ctx.delete(be_OR_id)
+		}
+	}
+}
+/**
+ * @param {Be|string}be_or_id
+ * @param {Ctx}argv__ctx
+ * @returns {boolean}
+ * @private
+ */
+export function be__has_(be_or_id, argv__ctx) {
+	return !!be__has__ctx_(be_or_id, argv__ctx)
+}
+/**
+ * @param {Be|string}be_or_id
+ * @param {Ctx}argv__ctx
+ * @returns {MapCtx}
+ * @private
+ */
+export function be__has__ctx_(be_or_id, argv__ctx) {
+	if (isArray(argv__ctx)) {
+		for (let i = 0; i < argv__ctx.length; i++) {
+			const be__has__ctx = be__has__ctx_(be_or_id, argv__ctx[i])
+			if (be__has__ctx) return be__has__ctx
+		}
+		return null
+	} else {
+		return argv__ctx.has(be_or_id) ? argv__ctx : null
+	}
+}
+/**
+ * @param {Be|string}be_or_id
+ * @param {Ctx}argv__ctx
+ * @returns {unknown}
+ * @private
+ */
+export function be__val_(be_or_id, argv__ctx) {
+	if (isArray(argv__ctx)) {
+		for (let i = 0; i < argv__ctx.length; i++) {
+			let ctx = argv__ctx[i]
+			const be__has__ctx = be__has__ctx_(be_or_id, ctx)
+			if (be__has__ctx) return be__has__ctx.get(be_or_id)
+		}
+	} else {
+		return argv__ctx.get(be_or_id)
+	}
+}
+/**
+ * @param {Ctx}ctx
+ * @param {is_source__T}is_source_
+ * @returns {unknown}
+ * @private
+ */
+export function source__map_ctx_(ctx, is_source_) {
+	if (isArray(ctx)) {
+		for (let i = 0; i < ctx.length; i++) {
+			let i_ctx = ctx[i]
+			let source__map_ctx = source__map_ctx_(i_ctx, is_source_)
+			if (source__map_ctx) return source__map_ctx
+		}
+	} else if (!is_source_ || is_source_(/** @type {MapCtx} */ctx, ctx)) {
+		return ctx
+	}
+}