ctx-core 2.2.0 → 2.2.1

package/all/slice_arg_spread_a/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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,
+>(
+	fn:slice_arg_spread_a__arg__T<In, Out>,
+	begin_idx?:number,
+	end_idx?:number
+):slice_arg_spread_a___ret_T<In, Out>
+export {
+	slice_arg_spread_a_ as slice_arg_spread_a,
+	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
+> = (
+	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> = (
+	...arg_a:In
+)=>Out
+export declare type slice_arg_spread_a__ret_T = slice_arg_spread_a__arg__T

package/all/slice_arg_spread_a/index.js

@@ -0,0 +1,15 @@
+/**
+ * Returns a function that calls fn passing the arguments sliced by slice_arg_a.
+ * @param {import('../slice_arg_spread_a/index.js').slice_arg_spread_a__arg__T}fn
+ * @param {number}[begin_idx]
+ * @param {number}[end_idx]
+ * @returns {import('../slice_arg_spread_a/index.js').slice_arg_spread_a___ret_T}
+ */
+export function slice_arg_spread_a_(fn, begin_idx, end_idx) {
+	return (...arg_a)=>fn(arg_a.slice(begin_idx, end_idx))
+}
+export {
+	slice_arg_spread_a_ as slice_arg_spread_a,
+	slice_arg_spread_a_ as slice_arg_a1,
+	slice_arg_spread_a_ as slice__a1__arg,
+}

package/all/sort/index.d.ts

@@ -0,0 +1,37 @@
+import type { compare_T } from '../array_types/index.js'
+/**
+ * Sort items in `a` by the `compare` function
+ */
+export declare function sort<
+	I extends unknown = unknown, O extends unknown = readonly I[]
+>(
+	a:readonly I[], compare?:compare_T<I>
+):O
+export declare function maybe_sort<
+	I extends unknown = unknown,
+	O extends unknown = readonly I[],
+	Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	compare?:compare_T<I>,
+	or?:Or
+):O|Or
+/**
+ * Returns a Function that calls [sort](#sort) with the given `compare` function.
+ */
+export declare function sort_<
+	I extends unknown = unknown
+>(
+	compare?:compare_T<I>
+):(a:readonly I[])=>I[]
+export declare function maybe_sort_<
+	I extends unknown = unknown, Or = null
+>(
+	compare?:compare_T<I>,
+	or?:Or
+):(maybe_a:readonly I[]|undefined)=>I[]|Or
+export {
+	sort_ as _sort,
+	sort_ as _fn__sort,
+	maybe_sort_ as _maybe_sort,
+}

package/all/sort/index.js

@@ -0,0 +1,41 @@
+/** @typedef {import('../array_types/index.d.ts').compare_T}compare_T */
+/**
+ * Sort items in `a` by the `compare` function
+ * @param {unknown[]}a
+ * @param {compare_T}compare
+ * @returns {unknown[]}
+ */
+export function sort(a, compare) {
+	return a.sort(compare)
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {compare_T}compare
+ * @param {unknown[]|null|unknown}or
+ * @returns {unknown[]|null|unknown}
+ */
+export function maybe_sort(maybe_a, compare, or = null) {
+	return maybe_a ? sort(maybe_a, compare) : or
+}
+/**
+ * Returns a Function that calls [sort](#sort) with the given `compare` function.
+ * @param {compare_T}compare
+ * @returns {(a:unknown[])=>unknown[]}
+ * @private
+ */
+export function sort_(compare) {
+	return a=>sort(a, compare)
+}
+/**
+ * @param {compare_T}compare
+ * @param {unknown[]|null|undefined}or
+ * @returns {(maybe_a:unknown[]|undefined)=>unknown[]|null|undefined}
+ */
+export function maybe_sort_(compare, or = null) {
+	return maybe_a=>maybe_sort(maybe_a, compare, or)
+}
+export {
+	sort_ as _sort,
+	sort_ as _fn__sort,
+	maybe_sort_ as _maybe_sort,
+}

package/all/sort_a/index.d.ts

@@ -0,0 +1,24 @@
+import type { compare_T } from '../array_types/index.js'
+/**
+ * Sorts a copy of `a` by the `compare` function.
+ */
+export declare function sort_a_<
+	I extends unknown = unknown
+>(
+	a:readonly I[],
+	compare?:compare_T<I>
+):I[]
+export declare function maybe_sort_a_<
+	I extends unknown = unknown, Or = null
+>(
+	maybe_a:readonly I[]|undefined,
+	compare?:compare_T<I>,
+	or?:Or
+):I[]|Or
+export {
+	sort_a_ as sort_a1_,
+	sort_a_ as _sort_a1,
+	sort_a_ as _a1__sort,
+	maybe_sort_a_ as maybe_sort_a1_,
+	maybe_sort_a_ as _maybe_sort_a1,
+}

package/all/sort_a/index.js

@@ -0,0 +1,28 @@
+import { maybe_slice, slice } from '../slice/index.js'
+import { maybe_sort, sort } from '../sort/index.js'
+/** @typedef {import('../array_types/index.d.ts').compare_T} */
+/**
+ * Sorts a copy of `a` by the `compare` function.
+ * @param {unknown[]}a
+ * @param {compare_T}[compare]
+ * @returns {unknown[]}
+ */
+export function sort_a_(a, compare) {
+	return sort(slice(a, 0), compare)
+}
+/**
+ * @param {unknown[]|undefined}maybe_a
+ * @param {compare_T}[compare]
+ * @param {unknown[]|null|undefined}[or]
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_sort_a_(maybe_a, compare, or = null) {
+	return maybe_sort(maybe_slice(maybe_a, 0), compare, or)
+}
+export {
+	sort_a_ as sort_a1_,
+	sort_a_ as _sort_a1,
+	sort_a_ as _a1__sort,
+	maybe_sort_a_ as maybe_sort_a1_,
+	maybe_sort_a_ as _maybe_sort_a1,
+}

package/all/sort_idx_a/index.d.ts

@@ -0,0 +1,21 @@
+import type { sort_idx_o_T } from '../array_types/index.js'
+/**
+ * Returns an Array of sorted indices from [sort_idx_o_T](#sort_idx_o_T).sort_idx_a
+ */
+export declare function sort_idx_a_<
+	I extends unknown = unknown
+>(
+	in_sort_idx_o:sort_idx_o_T<I>
+):number[]
+export declare function maybe_sort_idx_a_<
+	I extends unknown = unknown, Or = null
+>(
+	in_sort_idx_ctx:sort_idx_o_T<I>|undefined,
+	or?:Or
+):number[]|Or
+export {
+	sort_idx_a_ as sort_idx_a1_fn,
+	sort_idx_a_ as _sort_idx_a1,
+	maybe_sort_idx_a_ as maybe_sort_idx_a1_fn,
+	maybe_sort_idx_a_ as _maybe_sort_idx_a1,
+}

package/all/sort_idx_a/index.js

@@ -0,0 +1,25 @@
+/** @typedef {import('../array_types/index.d.ts').sort_idx_o_T}sort_idx_o_T */
+/**
+ * Returns an Array of sorted indices from [sort_idx_o_T](#sort_idx_o_T).sort_idx_a
+ * @param {sort_idx_o_T}in_sort_idx_o
+ * @returns {number[]}
+ */
+export function sort_idx_a_(in_sort_idx_o) {
+	return in_sort_idx_o.sort_idx_a
+}
+/**
+ * @param {sort_idx_o_T|undefined}in_sort_idx_o
+ * @param {number[]|null|undefined}or
+ * @returns {number[]|null|undefined}
+ */
+export function maybe_sort_idx_a_(
+	in_sort_idx_o, or = null
+) {
+	return in_sort_idx_o ? sort_idx_a_(in_sort_idx_o) : or
+}
+export {
+	sort_idx_a_ as sort_idx_a1_fn,
+	sort_idx_a_ as _sort_idx_a1,
+	maybe_sort_idx_a_ as maybe_sort_idx_a1_fn,
+	maybe_sort_idx_a_ as _maybe_sort_idx_a1,
+}

package/all/sort_idx_o/index.d.ts

@@ -0,0 +1,29 @@
+import type { compare_T, sort_idx_ctx__T, sort_idx_o_T } from '../array_types/index.js'
+/**
+ * Returns a [sort_idx_o_T](#sort_idx_o_T).
+ */
+export declare function sort_idx_o_<
+	I extends unknown = unknown
+>(
+	maybe_a:readonly I[]|undefined,
+	compare?:compare_T<I>
+):sort_idx_o_T<I>
+export {
+	sort_idx_o_ as sort_idx_ctx_,
+	sort_idx_o_ as _sort_idx_ctx,
+	sort_idx_o_ as _ctx__idx__sort,
+	sort_idx_o_ as _fn__sort_idx_ctx,
+}
+/**
+ * Returns function that returns [_sort_idx_ctx](#_sort_idx_ctx).
+ */
+export declare function sort_idx_o__<
+	I extends unknown = unknown
+>(
+	compare?:compare_T<I>
+):sort_idx_ctx__T<I>
+export {
+	sort_idx_o__ as sort_idx_ctx__,
+	sort_idx_o__ as sort_idx_ctx_2,
+	sort_idx_o__ as _sort_idx_ctx_fn,
+}

package/all/sort_idx_o/index.js

@@ -0,0 +1,53 @@
+import { compare_ } from '../compare/index.js'
+import { sort } from '../sort/index.js'
+/**
+ * Returns a [sort_idx_o_T](#sort_idx_o_T).
+ * @param {unknown[]|undefined}maybe_a
+ * @param {import('../array_types/index.js').compare_T}[compare]
+ * @returns {import('../array_types/index.js').sort_idx_o_T}
+ */
+export function sort_idx_o_(
+	maybe_a,
+	compare = compare_()
+) {
+	const sort_a = []
+	const sort_val_a = []
+	const sort_idx_a = []
+	if (maybe_a) {
+		const a = maybe_a
+		for (let i = 0; i < a.length; i++) {
+			sort_a.push([
+				a[i],
+				i
+			])
+		}
+		sort(sort_a, (l, r)=>compare(l[0], r[0]))
+		for (let i1 = 0; i1 < a.length; i1++) {
+			sort_idx_a.push(sort_a[i1][1])
+			sort_val_a[i1] = sort_a[i1][0]
+		}
+	}
+	return {
+		sort_idx_a,
+		sort_val_a
+	}
+}
+export {
+	sort_idx_o_ as sort_idx_ctx_,
+	sort_idx_o_ as _sort_idx_ctx,
+	sort_idx_o_ as _ctx__idx__sort,
+}
+/**
+ * Returns function that returns [_sort_idx_ctx](#_sort_idx_ctx).
+ * @param {import('../array_types/index.js').compare_T}compare
+ * @returns {import('../array_types/index.js').sort_idx_ctx__T}
+ */
+export function sort_idx_o__(compare) {
+	return a=>sort_idx_o_(a, compare)
+}
+export {
+	sort_idx_o__ as sort_idx_ctx__,
+	sort_idx_o__ as sort_idx_ctx_2,
+	sort_idx_o__ as _sort_idx_ctx_fn,
+	sort_idx_o_ as _fn__sort_idx_ctx,
+}

package/all/sort_idx_o/index.test.ts

@@ -0,0 +1,12 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import type { sort_idx_o_T } from '../array_types/index.js'
+import { sort_idx_o_ } from '../sort_idx_o/index.js'
+test('sort_idx_o_|inference', ()=>{
+	const sort_idx_ctx:sort_idx_o_T<number> = sort_idx_o_([1, 2, 0])
+	equal(sort_idx_ctx, {
+		sort_idx_a: [2, 0, 1],
+		sort_val_a: [0, 1, 2],
+	})
+})
+test.run()

package/all/sort_val_a/index.d.ts

@@ -0,0 +1,21 @@
+import type { sort_idx_o_T } from '../array_types/index.js'
+/**
+ * Returns an Array of sorted values from [sort_idx_o_T](#sort_idx_o_T).sort_val_a
+ */
+export declare function sort_val_a_<
+	I extends unknown = unknown
+>(
+	in_sort_idx_o:sort_idx_o_T<I>
+):I[]
+export declare function maybe_sort_val_a_<
+	I extends unknown = unknown, Or = null
+>(
+	maybe_sort_idx_ctx:sort_idx_o_T<I>|undefined,
+	or?:Or
+):I[]|Or
+export {
+	maybe_sort_val_a_ as maybe_sort_val_a1_fn,
+	maybe_sort_val_a_ as _maybe_sort_val_a1,
+	sort_val_a_ as sort_val_a1_fn,
+	sort_val_a_ as _sort_val_a1,
+}

package/all/sort_val_a/index.js

@@ -0,0 +1,23 @@
+/** @typedef {import('../array_types/index.d.ts').sort_idx_o_T}sort_idx_o_T */
+/**
+ * Returns an Array of sorted values from [sort_idx_o_T](#sort_idx_o_T).sort_val_a
+ * @param {sort_idx_o_T}in_sort_idx_o
+ * @returns {unknown[]}
+ */
+export function sort_val_a_(in_sort_idx_o) {
+	return in_sort_idx_o.sort_val_a
+}
+/**
+ * @param {sort_idx_o_T|undefined}maybe_sort_idx_ctx
+ * @param {unknown[]|null|undefined}or
+ * @returns {unknown[]|null|undefined}
+ */
+export function maybe_sort_val_a_(maybe_sort_idx_ctx, or = null) {
+	return maybe_sort_idx_ctx ? sort_val_a_(maybe_sort_idx_ctx) : or
+}
+export {
+	maybe_sort_val_a_ as maybe_sort_val_a1_fn,
+	maybe_sort_val_a_ as _maybe_sort_val_a1,
+	sort_val_a_ as sort_val_a1_fn,
+	sort_val_a_ as _sort_val_a1,
+}

package/all/sort_val_a__transition_idx_a/index.d.ts

@@ -0,0 +1,61 @@
+import type { sort_val_a__transition_a_frame_fn_T, sort_val_a__transition_a_frame_T } from '../array_types/index.js'
+import type { eq_T } from '../eq/index.js'
+/**
+ * Returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T) of presumably sorted items in `val_a` at each index of the new item for each changed item.
+ */
+export declare function sort_val_a__enter_a_frame_<
+	I extends unknown = unknown
+>(
+	sort_val_a:readonly I[]|undefined
+):sort_val_a__transition_a_frame_T<I>
+export {
+	sort_val_a__enter_a_frame_ as sort_val_a$enter_a_frame_,
+	sort_val_a__enter_a_frame_ as entry_thold_a_compact_ctx_,
+	sort_val_a__enter_a_frame_ as entry_thold_a1_compact_ctx_fn,
+	sort_val_a__enter_a_frame_ as _entry_thold_a1_compact_ctx,
+	sort_val_a__enter_a_frame_ as _ctx__compact__a1__thold__entry,
+}
+/**
+ * Returns a function that returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T)
+ */
+export declare function sort_val_a__enter_a_frame_fn_<
+	I extends unknown = unknown
+>(
+	eq_?:eq_T<readonly I[]>
+):sort_val_a__transition_a_frame_fn_T<I>
+export {
+	sort_val_a__enter_a_frame_fn_ as sort_val_a$enter_a_frame_fn_,
+	sort_val_a__enter_a_frame_fn_ as entry_thold_a_compact_ctx_2,
+	sort_val_a__enter_a_frame_fn_ as entry_thold_a1_compact_ctx_fn2,
+	sort_val_a__enter_a_frame_fn_ as _entry_thold_a1_compact_ctx_fn,
+	sort_val_a__enter_a_frame_fn_ as _fn__ctx__compact__a1__thold__entry,
+}
+/**
+ * Returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T) of presumably sorted items in `val_a` at each index of the old item for each changed item.
+ */
+export declare function sort_val_a__exit_a_frame_<
+	I extends unknown = unknown
+>(
+	sort_val_a?:readonly I[]
+):sort_val_a__transition_a_frame_T<I>
+export {
+	sort_val_a__exit_a_frame_ as sort_val_a$exit_a_frame_,
+	sort_val_a__enter_a_frame_ as exit_thold_a_compact_ctx_,
+	sort_val_a__exit_a_frame_ as exit_thold_a1_compact_ctx_fn,
+	sort_val_a__exit_a_frame_ as _exit_thold_a1_compact_ctx,
+	sort_val_a__exit_a_frame_ as _ctx__compact__a1__thold__exit
+}
+/**
+ * Returns a function that returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T)
+ */
+export declare function sort_val_a__exit_a_frame_fn_<
+	I extends unknown = unknown
+>(
+	eq_?:eq_T<readonly I[]>
+):sort_val_a__transition_a_frame_fn_T<I>
+export {
+	sort_val_a__exit_a_frame_fn_ as sort_val_a$exit_a_frame_fn_,
+	sort_val_a__exit_a_frame_fn_ as exit_thold_a1_compact_ctx_fn2,
+	sort_val_a__exit_a_frame_fn_ as _exit_thold_a1_compact_ctx_fn,
+	sort_val_a__exit_a_frame_fn_ as _fn__ctx__compact__a1__thold__exit,
+}

package/all/sort_val_a__transition_idx_a/index.js

@@ -0,0 +1,108 @@
+import { eq } from '../eq/index.js'
+/** @typedef {import('../eq/index.d.ts').eq_T}eq_T */
+/** @typedef {import('../array_types/index.d.ts').sort_val_a__transition_a_frame_fn_T}sort_val_a__transition_a_frame_fn_T */
+/** @typedef {import('../array_types/index.d.ts').sort_val_a__transition_a_frame_T}sort_val_a__transition_a_frame_T */
+/**
+ * Returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T) of presumably sorted items in `val_a` at each index of the new item for each changed item.
+ * @param {unknown[]|undefined}sort_val_a
+ * @returns {sort_val_a__transition_a_frame_T}
+ */
+export function sort_val_a__enter_a_frame_(sort_val_a) {
+	return sort_val_a__enter_a_frame_fn_()(sort_val_a)
+}
+export {
+	sort_val_a__enter_a_frame_ as sort_val_a$enter_a_frame_,
+	sort_val_a__enter_a_frame_ as entry_thold_a_compact_ctx_,
+	sort_val_a__enter_a_frame_ as entry_thold_a1_compact_ctx_fn,
+	sort_val_a__enter_a_frame_ as _entry_thold_a1_compact_ctx,
+	sort_val_a__enter_a_frame_ as _ctx__compact__a1__thold__entry,
+}
+/**
+ * Returns a function that returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T)
+ * @param {eq_T}[eq_]
+ * @returns {sort_val_a__transition_a_frame_fn_T}
+ */
+export function sort_val_a__enter_a_frame_fn_(eq_ = eq) {
+	return sort_val_a=>{
+		const idx_a = []
+		const val_a = []
+		if (sort_val_a) {
+			for (let i = 0; i < sort_val_a.length; i++) {
+				const sort_val = sort_val_a[i]
+				const prev_sort_val = sort_val_a[i - 1]
+				if (!i || (
+					eq_ ? !eq_([sort_val, prev_sort_val])
+						: sort_val !== prev_sort_val)
+				) {
+					idx_a.push(i)
+					val_a.push(sort_val)
+				}
+			}
+		}
+		return {
+			idx_a,
+			val_a
+		}
+	}
+}
+export {
+	sort_val_a__enter_a_frame_fn_ as sort_val_a$enter_a_frame_fn_,
+	sort_val_a__enter_a_frame_fn_ as entry_thold_a_compact_ctx_2,
+	sort_val_a__enter_a_frame_fn_ as entry_thold_a1_compact_ctx_fn2,
+	sort_val_a__enter_a_frame_fn_ as _entry_thold_a1_compact_ctx_fn,
+	sort_val_a__enter_a_frame_fn_ as _fn__ctx__compact__a1__thold__entry,
+}
+/**
+ * Returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T) of presumably sorted items in `val_a` at each index of the old item for each changed item.
+ * @param {unknown[]}[sort_val_a]
+ * @returns {sort_val_a__transition_a_frame_T}
+ */
+export function sort_val_a__exit_a_frame_(sort_val_a) {
+	return sort_val_a__exit_a_frame_fn_()(sort_val_a)
+}
+export {
+	sort_val_a__exit_a_frame_ as sort_val_a$exit_a_frame_,
+	sort_val_a__exit_a_frame_ as exit_thold_a_compact_ctx_,
+	sort_val_a__exit_a_frame_ as exit_thold_a1_compact_ctx_fn,
+	sort_val_a__exit_a_frame_ as _exit_thold_a1_compact_ctx,
+	sort_val_a__exit_a_frame_ as _ctx__compact__a1__thold__exit,
+}
+/**
+ * Returns a function that returns a [sort_val_a__transition_a_frame_T](#sort_val_a__transition_a_frame_T)
+ * @param {eq_T}[eq_]
+ * @returns {sort_val_a__transition_a_frame_fn_T}
+ */
+export function sort_val_a__exit_a_frame_fn_(eq_ = eq) {
+	/**
+	 * @param sort_val_a{unknown[]}
+	 */
+	return sort_val_a=>{
+		/** @type {number[]} */
+		const idx_a = []
+		/** @type {unknown[]} */
+		const val_a = []
+		if (sort_val_a) {
+			const sort_val_a_length = sort_val_a.length
+			for (let idx = 0; idx < sort_val_a.length; idx++) {
+				const sort_val = sort_val_a[idx]
+				const next_idx = idx + 1
+				const next_sort_val = sort_val_a[next_idx]
+				if (next_idx === sort_val_a_length || (
+					eq_ ? !eq_([sort_val, next_sort_val])
+						: sort_val !== next_sort_val)
+				) {
+					idx_a.push(idx)
+					val_a.push(sort_val)
+				}
+			}
+		}
+		return { idx_a, val_a, }
+	}
+}
+export {
+	sort_val_a__exit_a_frame_fn_ as sort_val_a$exit_a_frame_fn_,
+	sort_val_a__exit_a_frame_fn_ as exit_thold_a_compact_ctx_2,
+	sort_val_a__exit_a_frame_fn_ as exit_thold_a1_compact_ctx_fn2,
+	sort_val_a__exit_a_frame_fn_ as _exit_thold_a1_compact_ctx_fn,
+	sort_val_a__exit_a_frame_fn_ as _fn__ctx__compact__a1__thold__exit,
+}

package/all/sort_val_a__transition_idx_a/index.test.ts

@@ -0,0 +1,99 @@
+import { test } from 'uvu'
+import { equal } from 'uvu/assert'
+import {
+	sort_val_a__enter_a_frame_,
+	sort_val_a__enter_a_frame_fn_,
+	sort_val_a__exit_a_frame_,
+	sort_val_a__exit_a_frame_fn_
+} from '../sort_val_a__transition_idx_a/index.js'
+test('sort_val_a__enter_a_frame_', ()=>{
+	equal({
+		idx_a: [0, 3, 5],
+		val_a: ['a', 'b', 'c']
+	}, sort_val_a__enter_a_frame_(['a', 'a', 'a', 'b', 'b', 'c']))
+})
+test('sort_val_a__enter_a_frame_fn_', ()=>{
+	equal({
+		idx_a: [0, 3, 5],
+		val_a: ['a', 'b', 'c']
+	}, sort_val_a__enter_a_frame_fn_()(['a', 'a', 'a', 'b', 'b', 'c']))
+	{
+		const iter_a_eq_arg_aa:(readonly string[])[] = []
+		equal({
+			idx_a: [0],
+			val_a: ['a']
+		}, sort_val_a__enter_a_frame_fn_<string>(arg_a=>{
+			iter_a_eq_arg_aa.push(arg_a)
+			return true
+		})(['a', 'a', 'a', 'b', 'b', 'c']))
+		equal([
+			['a', 'a'],
+			['a', 'a'],
+			['b', 'a'],
+			['b', 'b'],
+			['c', 'b'],
+		], iter_a_eq_arg_aa)
+	}
+	{
+		const iter_a_eq_arg_aa:(readonly string[])[] = []
+		equal({
+			idx_a: [0, 1, 2, 3, 4, 5],
+			val_a: ['a', 'a', 'a', 'b', 'b', 'c']
+		}, sort_val_a__enter_a_frame_fn_<string>(arg_a=>{
+			iter_a_eq_arg_aa.push(arg_a)
+			return false
+		})(['a', 'a', 'a', 'b', 'b', 'c']))
+		equal([
+			['a', 'a'],
+			['a', 'a'],
+			['b', 'a'],
+			['b', 'b'],
+			['c', 'b'],
+		], iter_a_eq_arg_aa)
+	}
+})
+test('sort_val_a__exit_a_frame_', ()=>{
+	equal(sort_val_a__exit_a_frame_(['a', 'a', 'a', 'b', 'b', 'c']), {
+		idx_a: [2, 4, 5],
+		val_a: ['a', 'b', 'c']
+	})
+})
+test('sort_val_a__exit_a_frame_fn_', ()=>{
+	equal(sort_val_a__exit_a_frame_fn_()(['a', 'a', 'a', 'b', 'b', 'c']), {
+		idx_a: [2, 4, 5],
+		val_a: ['a', 'b', 'c']
+	})
+	{
+		const iter_a_eq_arg_aaa:(readonly string[])[][] = []
+		equal(
+			sort_val_a__exit_a_frame_fn_<string>((...arg_a)=>{
+				iter_a_eq_arg_aaa.push(arg_a)
+				return true
+			})(['a', 'a', 'a', 'b', 'b', 'c']),
+			{ idx_a: [5], val_a: ['c'] })
+		equal(iter_a_eq_arg_aaa, [
+			[['a', 'a']],
+			[['a', 'a']],
+			[['a', 'b']],
+			[['b', 'b']],
+			[['b', 'c']],
+		])
+	}
+	{
+		const iter_a_eq_arg_aaa:(readonly string[])[][] = []
+		equal(
+			sort_val_a__exit_a_frame_fn_<string>((...arg_aa)=>{
+				iter_a_eq_arg_aaa.push(arg_aa)
+				return false
+			})(['a', 'a', 'a', 'b', 'b', 'c']),
+			{ idx_a: [0, 1, 2, 3, 4, 5], val_a: ['a', 'a', 'a', 'b', 'b', 'c'] })
+		equal(iter_a_eq_arg_aaa, [
+			[['a', 'a']],
+			[['a', 'a']],
+			[['a', 'b']],
+			[['b', 'b']],
+			[['b', 'c']],
+		])
+	}
+})
+test.run()

package/all/sparse_a/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns a sparsely populated Array with `idx_a` indices & `val_a` values
+ */
+export declare function sparse_a_<
+	I extends unknown = unknown
+>(
+	idx_a:readonly number[],
+	val_a:readonly I[]
+):I[]
+export {
+	sparse_a_ as sparse_a1_fn,
+	sparse_a_ as _sparse_a1,
+	sparse_a_ as _a1__sparse,
+}

package/all/sparse_a/index.js

@@ -0,0 +1,19 @@
+/**
+ * Returns a sparsely populated Array with `idx_a` indices & `val_a` values
+ * @param {number[]}idx_a
+ * @param {unknown[]}val_a
+ * @returns {unknown[]}
+ */
+export function sparse_a_(idx_a, val_a) {
+	const sparse_a = []
+	for (let i = 0; i < idx_a.length; i++) {
+		const idx = idx_a[i]
+		sparse_a[idx] = val_a[i]
+	}
+	return sparse_a
+}
+export {
+	sparse_a_ as sparse_a1_fn,
+	sparse_a_ as _sparse_a1,
+	sparse_a_ as _a1__sparse,
+}