ctx-core 5.1.0 → 5.2.0

package/all/call/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../call/index.d.ts').call_fn_T} */
+/// <reference types="../call/index.d.ts" />
+/** @typedef {call_fn_T} */
 /**
  * Calls the fn with ...arg_a.
  * @param {call_fn_T}fn

package/all/call_assign/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../call_assign/index.d.ts').assign_fn_T} */
+/// <reference types="../call_assign/index.d.ts" />
+/** @typedef {assign_fn_T} */
 /**
  * Assigns function calls into obj
  * @param {object}obj

package/all/chain/index.js

@@ -1,7 +1,8 @@
+/// <reference types="../chain/index.d.ts" />
 import { isArray } from '../isArray/index.js'
 /**
- * @param {import('../chain/index.js').chain__o_T}chain__o
- * @param {import('../chain/index.js').chain_key__T[]}key_a
+ * @param {chain__o_T}chain__o
+ * @param {chain_key__T[]}key_a
  * @returns {*}
  */
 export function chain_(chain__o, ...key_a) {

package/all/clone_assign_fn_key_a/index.js

@@ -1,9 +1,10 @@
+/// <reference types="../assign_fn_key_a/index.d.ts" />
 import { assign_fn_key_a } from '../assign_fn_key_a/index.js'
 import { clone } from '../clone/index.js'
 /**
  * Assigns to a cloned obj array of keys the return value of function in key_a_fn_aa.
  * @param {Record<string, object>}obj
- * @param {import('../assign_fn_key_a/index.js').fn_key_a_tuple_T}key_a_fn_aa
+ * @param {fn_key_a_tuple_T}key_a_fn_aa
  * @returns {Record<string, object>}
  */
 export function clone_assign_fn_key_a(

package/all/color_hsv_phi_rgb_a/index.js

@@ -1,11 +1,12 @@
+/// <reference types="../color_rgb_a__color_hsv_a/index.d.ts" />
 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[]}
+ * @param {hsv_phi_rgb_color_a__params_T}params
+ * @returns {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_(

package/all/color_invert_rgb_a/index.js

@@ -1,7 +1,8 @@
+/// <reference types="../color_invert_rgb_a/index.d.ts" />
 /**
  * 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}
+ * @param {color_hsv_a_T}rgb_color_a
+ * @return {color_hsv_a_T}
  */
 export function color_invert_rgb_a_(
 	rgb_color_a

package/all/compact_a_ctx/index.js

@@ -1,7 +1,8 @@
+/// <reference types="../array_types/index.d.ts" />
 /**
  * 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}
+ * @returns {sort_val_a__transition_a_frame_T}
  */
 export function compact_a_ctx_(sparse_a) {
 	const idx_a = []

package/all/compare/index.js

@@ -1,7 +1,8 @@
+/// <reference types="../array_types/index.d.ts" />
 /**
  * Returns a basic ascending or descending `compare` function to be used for sorting.
  * @param {boolean}[asc]
- * @returns {import('../array_types/index.js').compare_T}
+ * @returns {compare_T}
  */
 export function compare_(asc = true) {
 	return (a, b)=>{

package/all/compose/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../compose/index.d.ts').compose_fn_T} */
+/// <reference types="../compose/index.d.ts" />
 /**
  * Composes fn_a into a single function
  *
@@ -9,9 +9,9 @@
 export function compose(...fn_a) {
 	return (
 		fn_a.reduceRight((prev_fn, next_fn)=>
-				(...arg_a)=>
-					next_fn(
-						prev_fn(...arg_a)),
-			$=>$)
+			(...arg_a)=>
+				next_fn(
+					prev_fn(...arg_a)),
+		$=>$)
 	)
 }

package/all/concat_truthy_a/index.js

@@ -1,9 +1,11 @@
+/// <reference types="../a_nowrap/index.d.ts" />
+/// <reference types="../wrap_a/index.d.ts" />
 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 {a_nowrap_T}a_nowrap
  * @param {unknown}rest_a
- * @returns {import('../wrap_a/index.js').wrap_a_T<unknown>}
+ * @returns {wrap_a_T<unknown>}
  */
 export function concat_truthy_a(a_nowrap, ...rest_a) {
 	let out_a = a_nowrap ? wrap_a_(a_nowrap) : []

package/all/console__error/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../error_o/index.d.ts').error_o_error_T} */
+/// <reference types="../error_o/index.d.ts" />
+/** @typedef {error_o_error_T} */
 /**
  * Logs the given error_o_error to stderr
  * @param {error_o_error_T}error_o_error

package/all/crypto__sign/index.js

@@ -1,6 +1,7 @@
+/// <reference types="../crypto__sign/index.d.ts" />
 import { crypto_ } from '../crypto/index.js'
 /**
- * @param {import('../crypto__sign/index.js').crypto__sign__algorithm_T}algorithm
+ * @param {crypto__sign__algorithm_T}algorithm
  * @param {CryptoKey}key
  * @param {BufferSource}data
  * @returns {Promise<ArrayBuffer>}

package/all/currency_str/index.js

@@ -1,3 +1,4 @@
+/// <reference types="../currency_str/index.d.ts" />
 import { currency_symbol_ } from '../currency_symbol/index.js'
 import { money_str_ } from '../money_str/index.js'
 /**
@@ -25,7 +26,7 @@ export {
 	currency_str_ as format__currency,
 }
 /**
- * @param {import('../currency_str').currency_str__default_params_T|string}params
+ * @param {currency_str__default_params_T|string}params
  * @returns {(amount:number)=>string}
  */
 export function currency_str__(params) {

package/all/currency_symbol/index.js

@@ -1,7 +1,8 @@
+/// <reference types="../currency_code/index.d.ts" />
 import { currencies } from '../currencies/index.js'
 /**
  * Returns the symbol for the given `currency_code_.currency`. Defaults to `$`
- * @param {import('../currency_code').currency_code_o_T|string}currency_code_
+ * @param {currency_code_o_T|string}currency_code_
  * @returns {string} * @see {@link https://github.com/bengourley/currency-symbol-map}
  * @see {@link https://raw.githubusercontent.com/bengourley/currency-symbol-map/master/map.js}
  */

package/all/curry/index.js

@@ -1,8 +1,8 @@
 /// <reference types="../resolver_curry/index.d.ts" />
 /// <reference types="./index.d.ts" />
 /**
- * @param append{import('../resolver_curry/index.js').append_current_T}
- * @returns {import('../resolver_curry/index.js').resolver_curry_T}
+ * @param append{append_current_T}
+ * @returns {resolver_curry_T}
  */
 export function curry(append) {
 	return curry_((local, arg_a)=>

package/all/date/index.js

@@ -1,4 +1,4 @@
-/** @type {typeof import('../date/index.d.ts').date_} */
+/// <reference types="../date/index.d.ts" />
 export const date_ =
 	(...arg_a)=>
 		new Date(/** @type {any} */...arg_a)

package/all/default_arg_a/index.d.ts

@@ -0,0 +1,11 @@
+import type { param_dfn_T } from '../param_dfn/index.js'
+export declare function default_arg_a_(
+	arg_a:string[],
+	value_r_param_dfn?:Record<string, param_dfn_T>,
+	cancel_a?:string[]
+):string[]
+export {
+	default_arg_a_ as default_arg_a1_fn,
+	default_arg_a_ as _default_arg_a1,
+	default_arg_a_ as _a1__arg__default,
+}

package/all/default_arg_a/index.js

@@ -0,0 +1,41 @@
+import { a_some } from '../a_some/index.js'
+import { every } from '../every/index.js'
+import { flag_a_ } from '../flag_a/index.js'
+import { flag_r_ } from '../flag_r/index.js'
+import { keys } from '../keys/index.js'
+/**
+ * @param {string[]}arg_a
+ * @param {Record<string, param_dfn_T>}value_R_param_dfn
+ * @param {string[]}cancel_a
+ * @returns {string[]}
+ */
+export function default_arg_a_(
+	arg_a,
+	value_R_param_dfn = {},
+	cancel_a = []
+) {
+	const default_arg_a = arg_a.slice(0)
+	const flag_h = flag_r_(default_arg_a)
+	if (
+		a_some(keys(flag_h), flag=>cancel_a.indexOf(flag) > -1
+		)) {
+		return default_arg_a
+	}
+	for (let param_dfn in value_R_param_dfn) {
+		const flag_a = flag_a_(param_dfn)
+		if (every(flag_a, (flag)=>!(flag in flag_h)
+		)) {
+			const value = value_R_param_dfn[param_dfn]
+			const $value = typeof value === 'function' ? value() : value
+			const flag1 = find(flag_a, (flag)=>/^--/.test(flag)
+			) || flag_a[0]
+			default_arg_a.push(flag1, $value)
+		}
+	}
+	return default_arg_a
+}
+export {
+	default_arg_a_ as default_arg_a1_fn,
+	default_arg_a_ as _default_arg_a1,
+	default_arg_a_ as _a1__arg__default,
+}

package/all/dfn_flag_r/index.d.ts

@@ -0,0 +1,8 @@
+import type { param_dfn_T } from '../param_dfn/index.js'
+export declare function dfn_flag_r_(
+	param_dfn_a:param_dfn_T[]
+):Record<string, string[]>
+export {
+	dfn_flag_r_ as dfn_flag_h_,
+	dfn_flag_r_ as _dfn_flag_h,
+}

package/all/dfn_flag_r/index.js

@@ -0,0 +1,24 @@
+/// <reference types="../types/index.d.ts" />
+import { each } from '../each/index.js'
+import { flag_a_ } from '../flag_a/index.js'
+/**
+ * @param {param_dfn_T[]}param_dfn_a
+ * @returns {Record<string, string[]>}
+ */
+export function dfn_flag_r_(param_dfn_a) {
+	const dfn_flag_R = {}
+	each(param_dfn_a, (param_dfn)=>{
+		const flag_a = flag_a_(
+			typeof param_dfn === 'function'
+				? param_dfn()
+				: param_dfn)
+		each(flag_a, (flag)=>{
+			dfn_flag_R[flag] = flag_a
+		})
+	})
+	return dfn_flag_R
+}
+export {
+	dfn_flag_r_ as dfn_flag_h_,
+	dfn_flag_r_ as _dfn_flag_h,
+}

package/all/difference_a/index.js

@@ -1,9 +1,11 @@
+/// <reference types="../a_nowrap/index.d.ts" />
+/// <reference types="../wrap_aa/index.d.ts" />
 import { difference_set_ } from '../difference_set/index.js'
 import { wrap_aa_ } from '../wrap_aa/index.js'
 /**
  * Returns the difference of n arrays
- * @param {import('../a_nowrap/index.js').a_nowrap_T}aa_nowrap
- * @returns {import('../wrap_aa/index.js').wrap_aa_T[]}
+ * @param {a_nowrap_T}aa_nowrap
+ * @returns {wrap_aa_T[]}
  * @see {@link http://www.2ality.com/2015/01/es6-set-operations.html}
  */
 export function difference_a_(aa_nowrap) {

package/all/each/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../each/index.d.ts').each_fn_T} */
+/// <reference types="../each/index.d.ts" />
+/** @typedef {each_fn_T} */
 /**
  * Iterate over each item in `a` with `fn(a[i], i)`.
  * @param {unknown[]}a

package/all/ensure__refresh/index.js

@@ -1,8 +1,9 @@
+/// <reference types="../ensure__refresh/index.d.ts" />
 import { clone } from '../clone/index.js'
 /**
  * `ensure` `obj[key]` is present or call `ensure(obj)`. Then call `refresh(obj, obj[key])`.
- * @param {import('../ensure__refresh/index.js').ensure_refresh__o_T}obj
- * @param {import('../ensure__refresh/index.js').ensure__refresh_opts_T}ensure__refresh_opts_a
+ * @param {ensure_refresh__o_T}obj
+ * @param {ensure__refresh_opts_T}ensure__refresh_opts_a
  * @returns {unknown}
  */
 export function ensure__refresh(

package/all/eq/index.js

@@ -1,8 +1,10 @@
+/// <reference types="../a_nowrap/index.d.ts" />
+/// <reference types="../eq/index.d.ts" />
 import { wrap_a_ } from '../wrap_a/index.js'
 import { wrap_concat } from '../wrap_concat/index.js'
 /**
  * Returns `==` operator to all values in `a_nowrap`.
- * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
+ * @param {a_nowrap_T}a_nowrap
  * @returns {boolean}
  */
 export function eq(a_nowrap) {
@@ -16,8 +18,8 @@ export function eq(a_nowrap) {
 }
 /**
  * Returns function that returns `==` operator to all values in `in_value_aS`.
- * @param {import('../a_nowrap/index.js').a_nowrap_T}a_nowrap
- * @returns {import('../eq/index.js').eq_fn_T}
+ * @param {a_nowrap_T}a_nowrap
+ * @returns {eq_fn_T}
  */
 export function eq_(a_nowrap) {
 	return (value)=>eq(wrap_concat(a_nowrap, value))

package/all/eql_fn_a/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../a_item/index.d.ts').a_item_T} */
+/// <reference types="../a_item/index.d.ts" />
 /**
  * Is i0_a `===` to i1_a based on `fn(a, b, i)`? Checks first level equality.
  * @param i0_a{unknown[]}

package/all/error__print/index.js

@@ -1,8 +1,10 @@
-/** @typedef {import('../error_o/index.d.ts').argument__error_o_T} */
+/// <reference types="../error_o/index.d.ts" />
+/// <reference types="../error__print/index.d.ts" />
+/** @typedef {argument__error_o_T} */
 /**
  * Prints the given `error_o_error` to stderr
  * @param {error_o_error_T}error_o_error
- * @type {typeof import('../error__print/index.js').error__print}
+ * @type {typeof error__print}
  */
 export function error__print(error_o_error) {
 	const {

package/all/error_o/index.js

@@ -1,6 +1,8 @@
+/// <reference types="../error_o/index.d.ts" />
+/// <reference types="./index.d.ts" />
 import { assign } from '../assign/index.js'
-/** @typedef {import('./index.d.ts').argument__error_o_T} */
-/** @typedef {import('../error_o/index.d.ts').error_o_error_T} */
+/** @typedef {argument__error_o_T} */
+/** @typedef {error_o_error_T} */
 /**
  * argument__error_o_T factory function
  * @param {string}[message]

package/all/falsy__none/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../falsy/index.d.ts').falsy} */
+/// <reference types="../falsy/index.d.ts" />
+/** @typedef {falsy} */
 /**
  * @param {unknown[]}a
  * @param {(...$:unknown[])=>unknown}_

package/all/fetch/index.js

@@ -1,2 +1,3 @@
-/** @type {import('../fetch/index.d.ts').fetch} */
+/// <reference types="../fetch/index.d.ts" />
+/** @type {fetch} */
 export const { fetch } = globalThis

package/all/fetch__template_pair/index.js

@@ -1,5 +1,6 @@
+/// <reference types="../fetch__template_pair/index.d.ts" />
 import { response_pair__new } from '../response_pair/index.js'
-/** @typedef {import('../fetch__template_pair/index.d.ts').fetch__template_pair_T} */
+/** @typedef {fetch__template_pair_T} */
 /**
  * @param {(...arg_a:any[])=>Promise<Response>}fetch_fn
  * @param {(val:unknown)=>unknown}[hydrate]

package/all/fetch_method/index.js

@@ -1,5 +1,6 @@
+/// <reference types="../fetch_method/index.d.ts" />
 /**
- * @param {import('../fetch_method/index.js').fetch_method___params_T}fetch_method___params
+ * @param {fetch_method___params_T}fetch_method___params
  * @returns {string}
  * @private
  */

package/all/fetch_response_pair/index.js

@@ -1,8 +1,10 @@
+/// <reference types="../fetch/index.d.ts" />
+/// <reference types="../fetch__template_pair/index.d.ts" />
 import { response_pair__new } from '../response_pair/index.js'
-/** @typedef {import('../fetch/index.d.ts').fetch_T} */
+/** @typedef {fetch_T} */
 /**
  * @param {fetch_T}fetch
- * @returns {typeof import('../fetch__template_pair/index.js').fetch_response_pair__new}
+ * @returns {typeof fetch_response_pair__new}
  */
 export function fetch_response_pair__new2(fetch) {
 	return async (input, init)=>{

package/all/filter/index.js

@@ -1,4 +1,5 @@
-/** @typedef {import('../array_types/index.d.ts').is_match__T} */
+/// <reference types="../fetch__template_pair/index.d.ts" />
+/** @typedef {is_match__T} */
 /**
  * Returns Array where items in `a` are filtered by `fn`.
  * @param {unknown[]}a

package/all/filter_o/index.js

@@ -1,9 +1,10 @@
+/// <reference types="../filter_o/index.d.ts" />
 import { I__ } from '../combinators/index.js'
 /**
  * Returns a filter_h1 with the values filtered by `fn`.
  * @param {object}o
  * @param {(val:any, key:string, h1:object)=>any}fn
- * @returns {import('../filter_o').filter_o_T|undefined}
+ * @returns {filter_o_T|undefined}
  */
 export function filter_o_(
 	o,
@@ -27,7 +28,7 @@ export {
  * Returns a filter_h where the value is a
  * boolean of whether the array has items present
  * @param {(val:any, key:string, l0_r:object)=>any}fn
- * @returns {(l1_r:object|undefined)=>(import('../filter_o').filter_o_T|undefined)}
+ * @returns {(l1_r:object|undefined)=>(filter_o_T|undefined)}
  */
 export function filter_o__(fn = I__) {
 	return (l1_r)=>filter_o_(l1_r, fn)

package/all/find/index.js

@@ -1,4 +1,4 @@
-/** @typedef {import('../wrap_a/index.d.ts').wrap_a_T2} */
+/// <reference types="../wrap_a/index.d.ts" />
 /**
  * Returns first item in `a` where `fn(a[idx], idx)` is truthy.
  * @param {wrap_a_T2}a

package/all/flag_a/index.d.ts

@@ -0,0 +1,6 @@
+export declare function flag_a_(param_dfn:string):string[]
+export {
+	flag_a_ as flag_a1_fn,
+	flag_a_ as _flag_a1,
+	flag_a_ as _a1__flag,
+}

package/all/flag_a/index.js

@@ -0,0 +1,13 @@
+import { param_dfn_split_regex } from '../param_dfn_split_regex/index.js'
+/**
+ * @param {string}param_dfn
+ * @returns {string[]}
+ */
+export function flag_a_(param_dfn) {
+	return param_dfn.split(param_dfn_split_regex)
+}
+export {
+	flag_a_ as flag_a1_fn,
+	flag_a_ as _flag_a1,
+	flag_a_ as _a1__flag,
+}

package/all/flag_r/index.d.ts

@@ -0,0 +1,8 @@
+export declare function flag_r_(
+	arg_a:string[]
+):Record<string, string>
+export {
+	flag_r_ as flag_h_,
+	flag_r_ as _flag_h,
+	flag_r_ as _h__flag,
+}

package/all/flag_r/index.js

@@ -0,0 +1,34 @@
+import { flag_regex } from '../flag_regex/index.js'
+/**
+ * @param {string[]}arg_a
+ * @returns {Record<string, string>}
+ * @private
+ */
+export function flag_r_(arg_a) {
+	const flag_R = {}
+	let i = 0
+	while (i < arg_a.length) {
+		const flag = arg_a[i]
+		const match = flag_regex.test(flag)
+		let j = i + 1
+		if (match) {
+			while (j < arg_a.length && !flag_regex.test(arg_a[j])) {
+				const value = arg_a[j]
+				if (flag_R[flag]) {
+					flag_R[flag] += ` ${value}`
+				} else {
+					flag_R[flag] = value
+				}
+				j += 1
+			}
+		}
+		if (!(flag in flag_R)) delete flag_R[flag]
+		i = j
+	}
+	return flag_R
+}
+export {
+	flag_r_ as flag_h_,
+	flag_r_ as _flag_h,
+	flag_r_ as _h__flag,
+}

package/all/flag_r__pick/index.d.ts

@@ -0,0 +1,11 @@
+import type { param_dfn_T } from '../param_dfn/index.js'
+export declare function flag_r__pick(
+	arg_a:string[],
+	...param_dfn_a:param_dfn_T[]
+):Record<string, string>
+export {
+	flag_r__pick as flag_R__pick,
+	flag_r__pick as pick_flag_r_,
+	flag_r__pick as pick_flag_h_,
+	flag_r__pick as _pick_flag_h,
+}

package/all/flag_r__pick/index.js

@@ -0,0 +1,31 @@
+/// <reference types="../types/index.d.ts" />
+import { dfn_flag_r_ } from '../dfn_flag_r/index.js'
+import { each } from '../each/index.js'
+import { flag_r_ } from '../flag_r/index.js'
+import { keys } from '../keys/index.js'
+/**
+ * @param {string[]}arg_a
+ * @param {param_dfn_T}param_dfn_a
+ * @returns {Record<string, string>}
+ * @private
+ */
+export function flag_r__pick(
+	arg_a,
+	...param_dfn_a
+) {
+	const dfn_flag_h = dfn_flag_r_(param_dfn_a)
+	const flag_h = flag_r_(arg_a)
+	const pick_flag_a = []
+	each(keys(flag_h), (flag)=>{
+		if (flag in dfn_flag_h) {
+			pick_flag_a.push(flag)
+		}
+	})
+	return pick(flag_h, ...pick_flag_a)
+}
+export {
+	flag_r__pick as flag_R__pick,
+	flag_r__pick as pick_flag_r_,
+	flag_r__pick as pick_flag_h_,
+	flag_r__pick as _pick_flag_h,
+}

package/all/flag_r_arg_a/index.d.ts

@@ -0,0 +1,9 @@
+export declare function flag_r_arg_a_<O>(
+	flag_r:Record<string, O>,
+	arg_a:string[]
+):(string|O)[]
+export {
+	flag_r_arg_a_ as flag_R_arg_a_,
+	flag_r_arg_a_ as flag_h_arg_a_,
+	flag_r_arg_a_ as _flag_h_arg_a1,
+}

package/all/flag_r_arg_a/index.js

@@ -0,0 +1,27 @@
+import { keys } from '../keys/index.js'
+import { reduce } from '../reduce/index.js'
+/**
+ * @param {Record<string, unknown>}flag_R
+ * @param {string[]}arg_a
+ * @returns {string|unknown}
+ * @private
+ */
+export function flag_r_arg_a_(
+	flag_R,
+	arg_a
+) {
+	return reduce(keys(flag_R), (memo, flag)=>{
+		memo.push(flag)
+		const _value = flag_R[flag]
+		const value = typeof _value === 'function' ? _value(arg_a) : _value
+		if (value != null) {
+			memo.push(...[].concat(value))
+		}
+		return memo
+	}, [])
+}
+export {
+	flag_r_arg_a_ as flag_R_arg_a_,
+	flag_r_arg_a_ as flag_h_arg_a_,
+	flag_r_arg_a_ as _flag_h_arg_a1,
+}

package/all/flag_r_param_name/index.d.ts

@@ -0,0 +1,9 @@
+export declare function flag_r_param_name_(
+	param_dfn_r_param_name?:param_name_r_param_dfn_T
+):Record<string, string>
+export {
+	flag_r_param_name_ as flag_R_param_name_,
+	flag_r_param_name_ as flag_h_param_name_,
+	flag_r_param_name_ as _flag_h_param_name,
+}
+export type param_name_r_param_dfn_T = Record<string, string>

package/all/flag_r_param_name/index.js

@@ -0,0 +1,24 @@
+/// <reference types="../types/index.d.ts" />
+import { each } from '../each/index.js'
+import { flag_a_ } from '../flag_a/index.js'
+/**
+ * @param {param_name_r_param_dfn_T}param_dfn_r_param_name
+ * @returns {Record<string, string>}
+ */
+export function flag_r_param_name_(
+	param_dfn_r_param_name
+) {
+	const flag_R_param_name = {}
+	for (let param_name in param_dfn_r_param_name) {
+		const param_dfn = param_dfn_r_param_name[param_name]
+		const flag_a = flag_a_(param_dfn)
+		each(flag_a, flag=>
+			flag_R_param_name[flag] = param_name)
+	}
+	return flag_R_param_name
+}
+export {
+	flag_r_param_name_ as flag_R_param_name_,
+	flag_r_param_name_ as flag_h_param_name_,
+	flag_r_param_name_ as _flag_h_param_name,
+}