ctx-core 2.2.0 → 2.2.2

package/all/color_hsv/index.js

@@ -0,0 +1,36 @@
+const { floor } = Math
+/**
+ * Returns a rgb array value from the given `(h,s,v)` (Hue, Saturation, Value)
+ * @param {import('./color_hsv_a_T.d.ts').color_hsv_a_T}hsv_color_a
+ * @see {@link http://en.wikipedia.org/wiki/HSL_and_HSV#Converting_to_RGB}
+ */
+export function color_rgb_a__color_hsv_a_(
+	hsv_color_a
+) {
+	const [h, s, v] = hsv_color_a
+	const h_i = floor(h * 6)
+	const f = h * 6 - h_i
+	const p = v * (1 - s)
+	const q = v * (1 - f * s)
+	const t = v * (1 - (1 - f) * s)
+	let r = 0, g = 0, b = 0
+	if (h_i === 0) {
+		[r, g, b] = [v, t, p]
+	} else if (h_i === 1) {
+		[r, g, b] = [q, v, p]
+	} else if (h_i === 2) {
+		[r, g, b] = [p, v, t]
+	} else if (h_i === 3) {
+		[r, g, b] = [p, q, v]
+	} else if (h_i === 4) {
+		[r, g, b] = [t, p, v]
+	} else if (h_i === 5) {
+		[r, g, b] = [v, p, q]
+	}
+	return [floor(r * 256), floor(g * 256), floor(b * 256)]
+}
+export {
+	color_rgb_a__color_hsv_a_ as hsv_color_a1_from_rgb_color_a1_,
+	color_rgb_a__color_hsv_a_ as _hsv_color_a1_from_rgb_color_a1,
+	color_rgb_a__color_hsv_a_ as _a1__color__rgb__from__a1__color__hsv,
+}

package/all/color_hsv_phi_rgb_a/index.d.ts

@@ -0,0 +1,19 @@
+import type { color_hsv_a_T } from '../color_hsv/index.js'
+import type { color_rgb_a_T } from '../color_rgb/index.js'
+/**
+ * Returns an array of colors with a given sv (`[saturation, value]`)
+ * with h (hue) seperated by `1/PHI`
+ * @see {@link https://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/}
+ */
+export declare function color_hsv_phi_rgb_a_(
+	params:hsv_phi_rgb_color_a__params_T
+):color_rgb_a_T[]
+export interface hsv_phi_rgb_color_a__params_T {
+	length:number
+	hsv:color_hsv_a_T
+}
+export {
+	color_hsv_phi_rgb_a_ as hsv_phi_rgb_color_a_,
+	color_hsv_phi_rgb_a_ as _hsv_phi_rgb_color_a1,
+	color_hsv_phi_rgb_a_ as _a1__color__rgb__phi__hsv,
+}

package/all/color_hsv_phi_rgb_a/index.js

@@ -0,0 +1,32 @@
+import { color_rgb_a__color_hsv_a_ } from '../color_hsv/index.js'
+import { PHI } from '../PHI/index.js'
+const { floor } = Math
+/**
+ * Returns an array of colors with a given sv (`[saturation, value]`)
+ * with h (hue) seperated by `1/PHI`
+ * @param {import('../color_rgb_a__color_hsv_a/index.js').hsv_phi_rgb_color_a__params_T}params
+ * @returns {import('../color_rgb_a__color_hsv_a/index.js').color_rgb_a_T[]}
+ * @see {@link https://martin.ankerl.com/2009/12/09/how-to-create-random-colors-programmatically/}
+ */
+export function color_hsv_phi_rgb_a_(
+	params
+) {
+	const { length, hsv, } = params
+	const [s, v] = hsv.slice(1)
+	const colors = []
+	const PHI_inverse = 1 / PHI
+	let n = length
+	const h_float = parseFloat(hsv[0].toString())
+	let h = isNaN(h_float) ? Math.random() : h_float
+	while (n) {
+		h += PHI_inverse
+		h = h - floor(h)
+		colors.push(color_rgb_a__color_hsv_a_([h, s, v]))
+		n--
+	}
+	return colors
+}
+export {
+	color_hsv_phi_rgb_a_ as _hsv_phi_rgb_color_a1,
+	color_hsv_phi_rgb_a_ as _a1__color__rgb__phi__hsv,
+}

package/all/color_invert_rgb_a/index.d.ts

@@ -0,0 +1,12 @@
+import type { color_hsv_a_T } from '../color_hsv/index.js'
+/**
+ * Inverted color for rgb_color_a as rgb_color_a
+ */
+export declare function color_invert_rgb_a_(
+	rgb_color_a:color_hsv_a_T
+):color_hsv_a_T
+export {
+	color_invert_rgb_a_ as invert_rgb_color_a_,
+	color_invert_rgb_a_ as invert_rgb_color_a1,
+	color_invert_rgb_a_ as invert__a1__color__rgb,
+}

package/all/color_invert_rgb_a/index.js

@@ -0,0 +1,18 @@
+/**
+ * Inverted color for rgb_color_a as rgb_color_a
+ * @param {import('../color_invert_rgb_a/index.js').color_hsv_a_T}rgb_color_a
+ * @return {import('../color_invert_rgb_a/index.js').color_hsv_a_T}
+ */
+export function color_invert_rgb_a_(
+	rgb_color_a
+) {
+	const invert_rgb_color_a = rgb_color_a.slice()
+	invert_rgb_color_a[0] = 255 - rgb_color_a[0]
+	invert_rgb_color_a[1] = 255 - rgb_color_a[1]
+	invert_rgb_color_a[2] = 255 - rgb_color_a[2]
+	return invert_rgb_color_a
+}
+export {
+	color_invert_rgb_a_ as invert_rgb_color_a1,
+	color_invert_rgb_a_ as invert__a1__color__rgb,
+}

package/all/color_rgb/index.d.ts

@@ -0,0 +1,7 @@
+export declare function color_rgb_hex_a_(hex:string):color_rgb_a_T
+export {
+	color_rgb_hex_a_ as hex_rgb_a_,
+}
+export declare type color_rgb_a_T = [number, number, number]
+export declare type rgb_color_a_T = color_rgb_a_T
+export declare type rgb_color_a1_T = color_rgb_a_T

package/all/color_rgb/index.js

@@ -0,0 +1,22 @@
+import { hex_int_ } from '../hex_int/index.js'
+/**
+ * @param {string}hex
+ * @return {[number, number, number]}
+ */
+export function color_rgb_hex_a_(hex) {
+	if (hex.at(0) === '#') {
+		hex = hex.replace(/^#/, '')
+	}
+	if (hex.length === 3) {
+		hex = hex.replace(/(.)/g, (_$0, $1)=>$1 + $1)
+	}
+	const hex_a = hex.match(/.{1,2}/g)
+	const hex_rgb_a = []
+	for (let i = 0; i < hex_a.length; i++) {
+		hex_rgb_a.push(hex_int_(hex_a[i]))
+	}
+	return hex_rgb_a
+}
+export {
+	color_rgb_hex_a_ as hex_rgb_a_,
+}

package/all/color_rgb/index.test.ts

@@ -0,0 +1,12 @@
+import { deepEqual } from 'assert'
+import { test } from 'uvu'
+import { color_rgb_hex_a_ } from '../color_rgb/index.js'
+test('color_rgb_hex_a_', ()=>{
+	deepEqual(
+		color_rgb_hex_a_('AABBCC'),
+		[170, 187, 204])
+	deepEqual(
+		color_rgb_hex_a_('#AABBCC'),
+		[170, 187, 204])
+})
+test.run()

package/all/columns_nansum_matrix/index.d.ts

@@ -0,0 +1,4 @@
+export declare function columns_nansum_matrix_(
+	matrix:number[], columns_length:number
+):number[]
+export { columns_nansum_matrix_ as _matrix__nansum__columns }

package/all/columns_nansum_matrix/index.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]}matrix
+ * @param {number}}columns_length
+ * @returns {number[]}
+ */
+export function columns_nansum_matrix_(matrix, columns_length) {
+	const columns_nansum_matrix = []
+	for (let j = 0; j < columns_length; j++) {
+		let column_sum = 0.0
+		for (let i = j; i < matrix.length; i += columns_length) {
+			column_sum += matrix[i] || 0
+		}
+		columns_nansum_matrix.push(column_sum)
+	}
+	return columns_nansum_matrix
+}
+export { columns_nansum_matrix_ as _matrix__nansum__columns }

package/all/combinators/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @see {@link https://gist.github.com/Avaq/1f0636ec5c8d6aed2e45}
+ */
+export declare function I<
+	X extends unknown = unknown
+>(x:X):X
+export declare function K<
+	X extends unknown = unknown
+>(x:X):(_:any)=>X
+export declare function A<
+	X extends unknown = unknown,
+	O extends unknown = unknown
+>(f:(x:X)=>O):(x:X)=>O
+export declare function T<
+	X extends unknown = unknown,
+	O extends unknown = unknown
+>(x:X):(f:(x:X)=>O)=>O
+export declare function W<
+	X extends unknown = unknown,
+	O extends unknown = unknown
+>(f:(x:X)=>(x:X)=>O):(x:X)=>O
+export declare function C<
+	X extends unknown = unknown,
+	Y extends unknown = unknown,
+	O extends unknown = unknown
+>(f:(x:X)=>(y:Y)=>O):(y:Y)=>(x:X)=>O
+export declare function B<
+	X extends unknown = unknown,
+	Og extends unknown = unknown,
+	O extends unknown = unknown
+>(f:(og:Og)=>O):(g:(x:X)=>Og)=>(x:X)=>O
+export declare function S<
+	X extends unknown = unknown,
+	Og extends unknown = unknown,
+	O extends unknown = unknown
+>(f:(x:X)=>(og:Og)=>O):(g:(x:X)=>Og)=>(x:X)=>O
+export declare function P<
+	X extends unknown = unknown,
+	Y extends unknown = unknown,
+	Ogx extends unknown = unknown,
+	Ogy extends unknown = unknown,
+	O extends unknown = unknown
+>(f:(ogx:Ogx)=>(ogy:Ogy)=>O):(g:(a:(X|Y))=>(Ogx|Ogy))=>(x:X)=>(y:Y)=>O
+export declare function Y<
+	X extends unknown = unknown,
+	Of extends unknown = unknown,
+	Off extends unknown = unknown
+>(f:(ff:(x:X)=>Of)=>Off):Off
+export declare function I__<
+	O extends unknown = unknown,
+	R extends unknown = unknown
+>(x:O, ..._:R[]):O

package/all/combinators/index.js

@@ -0,0 +1,48 @@
+/**
+ * @see {@link https://gist.github.com/Avaq/1f0636ec5c8d6aed2e45}
+ */ // export const I = x=>x
+export function I(x) {
+	return x
+}
+// export const K = x=>_=>x
+export function K(x) {
+	return (_)=>x
+}
+// export const A = f=>x=>f(x)
+export function A(f) {
+	return (x)=>f(x)
+}
+// export const T = x=>f=>f(x)
+export function T(x) {
+	return (f)=>f(x)
+}
+// export const W = f=>x=>f(x)(x)
+export function W(f) {
+	return (x)=>f(x)(x)
+}
+// export const C = f=>y=>x=>f(x)(y)
+export function C(f) {
+	return (y)=>(x)=>f(x)(y)
+}
+// export const B = f=>g=>x=>f(g(x))
+export function B(f) {
+	return (g)=>(x)=>f(g(x))
+}
+// export const S = f=>g=>x=>f(x)(g(x))
+export function S(f) {
+	return (g)=>(x)=>f(x)(g(x))
+}
+// export const P = f=>g=>x=>y=>f(g(x))(g(y))
+export function P(f) {
+	return (g)=>(x)=>(y)=>f(g(x))(g(y))
+}
+// export const Y = (f)=>(g=>g(g))(g=>f(x=>g(g)(x)))
+export function Y(f) {
+	return ((g)=>g(g)
+	)((g)=>f((x)=>g(g)(x)
+		)
+	)
+}
+export function I__(x, ..._) {
+	return x
+}

package/all/combinators/index.test.ts

@@ -0,0 +1,8 @@
+import { test } from 'uvu'
+import { is } from 'uvu/assert'
+import { I } from '../combinators/index.js'
+test('I', ()=>{
+	const obj = {}
+	is(obj, I(obj))
+})
+test.run()

package/all/comma_number_str/index.d.ts

@@ -0,0 +1,2 @@
+export declare function comma_number_str_(number:number|string):string|null
+export { comma_number_str_ as _comma_number_str, comma_number_str_ as format__commas, }

package/all/comma_number_str/index.js

@@ -0,0 +1,8 @@
+export function comma_number_str_(number) {
+	return (
+		number == null
+			? null
+			: number.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,')
+	)
+}
+export { comma_number_str_ as _comma_number_str, comma_number_str_ as format__commas, }

package/all/compact/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Removes null values from the array
+ */
+export declare function compact<
+	I extends unknown = unknown
+>(a:readonly I[]):I[]
+export declare function maybe_compact<
+	I extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly I[]|undefined, or?:Or
+):I[]|Or
+export {
+	compact as compact_a1,
+	compact as compact__a1,
+}

package/all/compact/index.js

@@ -0,0 +1,27 @@
+/**
+ * Removes null values from the array
+ * @param {unknown[]}a
+ * @returns {unknown[]}
+ */
+export function compact(a) {
+	const out_a = []
+	for (const val of a) {
+		if (val) {
+			out_a.push(val)
+		}
+	}
+	return out_a
+}
+/**
+ * @param {unknown[]}maybe_a
+ * @param {unknown[]|null|undefined}[or]
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_compact(maybe_a, or = null) {
+	if (!maybe_a) return or
+	return compact(maybe_a)
+}
+export {
+	compact as compact_a1,
+	compact as compact__a1,
+}

package/all/compact_a_ctx/index.d.ts

@@ -0,0 +1,11 @@
+import type { sort_val_a__transition_a_frame_T } from '../array_types/index.js'
+/**
+ * Returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T)
+ */
+export declare function compact_a_ctx_<
+	I extends unknown = unknown
+>(sparse_a:readonly I[]):sort_val_a__transition_a_frame_T<I>
+export {
+	compact_a_ctx_ as compact_a1_ctx_fn,
+	compact_a_ctx_ as _compact_a1_ctx,
+}

package/all/compact_a_ctx/index.js

@@ -0,0 +1,21 @@
+/**
+ * Returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T)
+ * @param {unknown[]}sparse_a
+ * @returns {import('../array_types/index.js').sort_val_a__transition_a_frame_T}
+ */
+export function compact_a_ctx_(sparse_a) {
+	const idx_a = []
+	const val_a = []
+	for (let i = 0; i < sparse_a.length; i++) {
+		const val = sparse_a[i]
+		if (val != undefined) {
+			idx_a.push(i)
+			val_a.push(val)
+		}
+	}
+	return { idx_a, val_a }
+}
+export {
+	compact_a_ctx_ as compact_a1_ctx_fn,
+	compact_a_ctx_ as _compact_a1_ctx,
+}

package/all/compare/index.d.ts

@@ -0,0 +1,23 @@
+import type { compare_T } from '../array_types/index.js'
+/**
+ * Returns a basic ascending or descending `compare` function to be used for sorting.
+ */
+export declare function compare_<
+	I extends unknown = unknown
+>(asc?:boolean):compare_T<I>
+/**
+ * Compare function to sort by ascending order.
+ */
+export declare const asc_compare:compare_T<unknown>
+/**
+ * Compare function to sort by descending order.
+ */
+export declare const desc_compare:compare_T<unknown>
+export {
+	compare_ as _compare,
+	compare_ as _fn__compare,
+	asc_compare as compare__asc,
+	asc_compare as fn__compare__asc,
+	desc_compare as compare__desc,
+	desc_compare as fn__compare__desc,
+}

package/all/compare/index.js

@@ -0,0 +1,32 @@
+/**
+ * Returns a basic ascending or descending `compare` function to be used for sorting.
+ * @param {boolean}[asc]
+ * @returns {import('../array_types/index.js').compare_T}
+ */
+export function compare_(asc = true) {
+	return (a, b)=>{
+		if (a < b) return asc ? -1 : 1
+		if (a > b) return asc ? 1 : -1
+		return 0
+	}
+}
+export {
+	compare_ as _compare,
+	compare_ as _fn__compare,
+}
+/**
+ * Compare function to sort by ascending order.
+ */
+export const asc_compare = compare_(true)
+export {
+	asc_compare as compare__asc,
+	asc_compare as fn__compare__asc,
+}
+/**
+ * Compare function to sort by descending order.
+ */
+export const desc_compare = compare_(false)
+export {
+	desc_compare as compare__desc,
+	desc_compare as fn__compare__desc,
+}

package/all/compose/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Composes fn_a into a single function
+ * @see {@link https://gist.github.com/JamieMason/172460a36a0eaef24233e6edb2706f83}
+ */
+export declare function compose<O extends unknown = unknown>(
+	...fn_a:compose_fn_T<O>[]
+):compose_fn_T<O>
+export declare type compose_fn_T<O extends unknown = unknown> =
+	(...fn_a:any[])=>O

package/all/compose/index.js

@@ -0,0 +1,17 @@
+/** @typedef {import('../compose/index.d.ts').compose_fn_T}compose_fn_T */
+/**
+ * Composes fn_a into a single function
+ *
+ * @param {compose_fn_T}fn_a
+ * @returns {compose_fn_T}
+ * @see {@link https://gist.github.com/JamieMason/172460a36a0eaef24233e6edb2706f83}
+ */
+export function compose(...fn_a) {
+	return (
+		fn_a.reduceRight((prev_fn, next_fn)=>
+				(...arg_a)=>
+					next_fn(
+						prev_fn(...arg_a)),
+			$=>$)
+	)
+}

package/all/concat/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Array#`concat`
+ */
+export declare function concat<
+	I extends unknown = unknown
+>(a?:I[], ...rest_a:I[]|I[][]):I[]
+export declare function maybe_concat<
+	I extends unknown = unknown
+>(a?:I[], ...rest_a:I[]|I[][]):I[]

package/all/concat/index.js

@@ -0,0 +1,17 @@
+/**
+ * Array#`concat`
+ * @param {unknown[]}[a]
+ * @param {unknown}rest_a
+ * @returns {unknown[]}
+ */
+export function concat(a, ...rest_a) {
+	return (a || []).concat(...rest_a)
+}
+/**
+ * @param {unknown[]}[a]
+ * @param {unknown}rest_a
+ * @returns {unknown[]}
+ */
+export function maybe_concat(a, ...rest_a) {
+	return (a || []).concat(...rest_a)
+}

package/all/concat_truthy_a/index.d.ts

@@ -0,0 +1,15 @@
+import type { a_nowrap_T } from '../a_nowrap/index.js'
+import type { wrap_a_T } from '../wrap_a/index.js'
+/**
+ * Array#`concat`, setting falsy values to an empty Array (`[]`).
+ */
+export declare function concat_truthy_a<
+	I extends unknown = unknown
+>(
+	a_nowrap:a_nowrap_T<I>, ...rest_a:readonly unknown[]
+):wrap_a_T<I>
+export {
+	concat_truthy_a as concat_truthy_a1,
+	concat_truthy_a as concat__default__a1,
+	concat_truthy_a as concat__truthy,
+}

package/all/concat_truthy_a/index.js

@@ -0,0 +1,19 @@
+import { wrap_a_ } from '../wrap_a/index.js'
+/**
+ * Array#`concat`, setting falsy values to an empty Array (`[]`).
+ * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @param {unknown}rest_a
+ * @returns {import('../wrap_a/index.js').wrap_a_T<unknown>}
+ */
+export function concat_truthy_a(a_nowrap, ...rest_a) {
+	let out_a = a_nowrap ? wrap_a_(a_nowrap) : []
+	for (let i = 0; i < rest_a.length; i++) {
+		out_a = out_a.concat(rest_a[i] || [])
+	}
+	return out_a
+}
+export {
+	concat_truthy_a as concat_truthy_a1,
+	concat_truthy_a as concat__default__a1,
+	concat_truthy_a as concat__truthy,
+}

package/all/console__error/index.d.ts

@@ -0,0 +1,7 @@
+import type { error_o_error_T } from '../error_o/index.js'
+/**
+ * Logs the given error_o to stderr
+ */
+export declare function console__error(
+	error_o_error:error_o_error_T
+):void

package/all/console__error/index.js

@@ -0,0 +1,18 @@
+/** @typedef {import('../error_o/index.d.ts').error_o_error_T} */
+/**
+ * Logs the given error_o_error to stderr
+ * @param {error_o_error_T}error_o_error
+ */
+export function console__error(error_o_error) {
+	const message =
+		error_o_error.message
+		|| error_o_error && error_o_error.toString()
+		|| 'console__error|Unknown Error'
+	const stack = error_o_error && error_o_error.stack
+	console.error(`
+console__error
+${stack}
+${message}
+${JSON.stringify(error_o_error)}
+	`.trim())
+}

package/all/crypto/index.d.ts

@@ -0,0 +1 @@
+export const crypto:Crypto

package/all/crypto/index.js

@@ -0,0 +1,11 @@
+/**
+ * @type {Crypto}
+ * @see {@link https://stackoverflow.com/a/70981544/142571}
+ */
+export const crypto = globalThis.crypto
+export async function crypto_() {
+	return (
+		crypto
+		|| import('node:crypto').then($=>
+			$.webcrypto))
+}

package/all/crypto__sign/index.d.ts

@@ -0,0 +1,13 @@
+export declare function crypto__sign(
+	algorithm:crypto__sign__algorithm_T,
+	key:CryptoKey,
+	data:BufferSource|string
+):Promise<ArrayBuffer>
+export type crypto__sign__algorithm_T =
+	'RSASSA-PKCS1-v1_5'
+	|'RSA-PSS'
+	|'ECDSA'
+	|'HMAC'
+	|Algorithm
+	|RsaPssParams
+	|EcdsaParams

package/all/crypto__sign/index.js

@@ -0,0 +1,18 @@
+import { crypto_ } from '../crypto/index.js'
+/**
+ * @param {import('../crypto__sign/index.js').crypto__sign__algorithm_T}algorithm
+ * @param {CryptoKey}key
+ * @param {BufferSource}data
+ * @returns {Promise<ArrayBuffer>}
+ */
+export async function crypto__sign(
+	algorithm,
+	key,
+	data
+) {
+	if (typeof data === 'string') {
+		data = new TextEncoder().encode(/** @type {string} */data)
+	}
+	const crypto = await crypto_()
+	return crypto.subtle.sign(algorithm, key, data)
+}

package/all/ctx/index.d.ts

@@ -0,0 +1,4 @@
+import type { MapCtx } from '../be_/index.js'
+export declare function ctx__new():MapCtx
+export { ctx__new as ctx_ }
+export declare function is_ctx_(val:unknown):boolean

package/all/ctx/index.js

@@ -0,0 +1,25 @@
+import { flatten } from '../flatten/index.js'
+import { isArray } from '../isArray/index.js'
+const ctx_sym = Symbol.for('ctx')
+/**
+ * @returns {import('../be_/index.js').MapCtx}
+ * @private
+ */
+export function ctx__new() {
+	return new Map([[ctx_sym, true]])
+}
+export { ctx__new as ctx_ }
+/**
+ * @param {unknown}val
+ * @returns {boolean}
+ * @private
+ */
+export function is_ctx_(val) {
+	if (!isArray(val)) return !!(val instanceof Map && val.get(ctx_sym))
+	if (!val.length) return false
+	const flat__val = flatten(val)
+	for (let i = 0; i < flat__val.length; i++) {
+		if (!is_ctx_(flat__val[i])) return false
+	}
+	return true
+}