functionalscript 0.1.594 → 0.1.596

package/sha2/module.f.d.mts

@@ -0,0 +1,23 @@
+declare namespace _default {
+    export { padding };
+    export { computeSha256 };
+    export { computeSha224 };
+    export { compress256 };
+    export { compress224 };
+}
+export default _default;
+export type HashInput = {
+    readonly f: (i: number) => number;
+    readonly length: number;
+};
+export type Hash8 = arrayT.Array8<number>;
+export type Array16 = arrayT.Array16<number>;
+/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
+declare const padding: (input: readonly number[]) => (bits: number) => HashInput;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+declare const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+declare const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
+declare const compress256: (data: Array16) => Hash8;
+declare const compress224: (data: Array16) => Hash8;
+import * as arrayT from '../types/array/module.f.mjs';

package/sha2/test.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    export namespace empty {
+        function sha256(): void;
+        function sha224(): void;
+    }
+    export let sha224compress: (() => void)[];
+    let sha256_1: (() => void)[];
+    export { sha256_1 as sha256 };
+}
+export default _default;

package/text/ascii/module.f.d.mts

@@ -0,0 +1,73 @@
+declare namespace _default {
+    export { one };
+    export { range };
+    export let backspace: number;
+    export let ht: number;
+    export let lf: number;
+    export let ff: number;
+    export let cr: number;
+    export let space: number;
+    export let exclamationMark: number;
+    export let quotationMark: number;
+    export let numberSign: number;
+    export let dollarSign: number;
+    export let percentSign: number;
+    export let ampersand: number;
+    export let apostrophe: number;
+    export let leftParenthesis: number;
+    export let rightParenthesis: number;
+    export let asterisk: number;
+    export let plusSign: number;
+    export let comma: number;
+    export let hyphenMinus: number;
+    export let fullStop: number;
+    export let solidus: number;
+    export let digitRange: Range.Range;
+    export let digit0: number;
+    export let digit1: number;
+    export let digit2: number;
+    export let digit3: number;
+    export let digit4: number;
+    export let digit5: number;
+    export let digit6: number;
+    export let digit7: number;
+    export let digit8: number;
+    export let digit9: number;
+    export let colon: number;
+    export let semicolon: number;
+    export let lessThanSign: number;
+    export let equalsSign: number;
+    export let greaterThanSign: number;
+    export let questionMark: number;
+    export let commercialAt: number;
+    export let latinCapitalLetterRange: Range.Range;
+    export let latinCapitalLetterA: number;
+    export let latinCapitalLetterE: number;
+    export let latinCapitalLetterF: number;
+    export let leftSquareBracket: number;
+    export let reverseSolidus: number;
+    export let rightSquareBracket: number;
+    export let circumflexAccent: number;
+    export let lowLine: number;
+    export let graveAccent: number;
+    export let latinSmallLetterRange: Range.Range;
+    export let latinSmallLetterA: number;
+    export let latinSmallLetterB: number;
+    export let latinSmallLetterE: number;
+    export let latinSmallLetterF: number;
+    export let latinSmallLetterN: number;
+    export let latinSmallLetterR: number;
+    export let latinSmallLetterT: number;
+    export let latinSmallLetterU: number;
+    export let latinSmallLetterZ: number;
+    export let leftCurlyBracket: number;
+    export let verticalLine: number;
+    export let rightCurlyBracket: number;
+    export let tilde: number;
+}
+export default _default;
+/** @type {(s: string) => number} */
+declare const one: (s: string) => number;
+/** @type {(s: string) => Range.Range} */
+declare const range: (s: string) => Range.Range;
+import * as Range from '../../types/range/module.f.mjs';

package/text/ascii/test.f.d.mts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function range(): void;
+}
+export default _default;

package/text/module.f.d.mts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    export { flat };
+    export { curly };
+}
+export default _default;
+export type Block = ItemThunk | ItemArray;
+export type ItemArray = readonly Item[];
+export type ItemThunk = () => List.List<Item>;
+export type Item = string | ItemArray | ItemThunk;
+/** @typedef {ItemThunk|ItemArray} Block */
+/** @typedef {readonly Item[]} ItemArray */
+/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {string|ItemArray|ItemThunk} Item */
+/** @type {(indent: string) => (text: Block) => List.List<string>} */
+declare const flat: (indent: string) => (text: Block) => List.List<string>;
+/** @type {(type: string) => (name: string) => (body: Block) => Block} */
+declare const curly: (type: string) => (name: string) => (body: Block) => Block;
+import * as List from '../types/list/module.f.mjs';

package/text/sgr/module.f.d.mts

@@ -0,0 +1,14 @@
+declare namespace _default {
+    export { sgr };
+    export let reset: string;
+    export let bold: string;
+    export let fgRed: string;
+    export let fgGreen: string;
+}
+export default _default;
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+declare const sgr: (c: number) => string;

package/text/test.f.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): void;
+export default _default;

package/text/utf16/module.f.d.mts

@@ -0,0 +1,19 @@
+declare namespace _default {
+    export { fromCodePointList };
+    export { toCodePointList };
+    export { stringToList };
+    export { listToString };
+}
+export default _default;
+export type WordOrEof = u16 | null;
+export type Utf16State = number | null;
+export type u16 = number;
+export type i32 = number;
+declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
+/** @type {(input: List.List<u16>) => List.List<i32>} */
+declare const toCodePointList: (input: List.List<u16>) => List.List<i32>;
+/** @type {(s: string) => List.List<u16>} */
+declare const stringToList: (s: string) => List.List<u16>;
+/** @type {(input: List.List<u16>) => string} */
+declare const listToString: (input: List.List<u16>) => string;
+import * as List from '../../types/list/module.f.mjs';

package/text/utf16/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let toCodePointList: (() => void)[];
+    let fromCodePointList: (() => void)[];
+    let string: (() => void)[];
+}
+export default _default;

package/text/utf8/module.f.d.mts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { fromCodePointList };
+    export { toCodePointList };
+}
+export default _default;
+export type ByteOrEof = u8 | null;
+export type Utf8NonEmptyState = arrayT.Array1<number> | arrayT.Array2<number> | arrayT.Array3<number>;
+export type Utf8State = null | Utf8NonEmptyState;
+export type u8 = number;
+export type i32 = number;
+declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
+/** @type {(input: List.List<u8>) => List.List<i32>} */
+declare const toCodePointList: (input: List.List<u8>) => List.List<i32>;
+import * as arrayT from '../../types/array/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/text/utf8/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let toCodePoint: (() => void)[];
+    let fromCodePointList: (() => void)[];
+    let toFrom: (() => void)[];
+}
+export default _default;

package/types/array/module.f.d.mts

@@ -0,0 +1,41 @@
+declare namespace _default {
+    export { at };
+    export { first };
+    export { last };
+    export { head };
+    export { tail };
+    export { splitFirst };
+    export { splitLast };
+}
+export default _default;
+export type Array1<T> = readonly [T];
+export type Index1 = 0;
+export type Array2<T> = readonly [T, T];
+export type Tuple2<T0, T1> = readonly [T0, T1];
+export type Index2 = 0 | 1;
+export type Array3<T> = readonly [T, T, T];
+export type Tuple3<T0, T1, T2> = readonly [T0, T1, T2];
+export type Index3 = 0 | 1 | 2;
+export type Array4<T> = readonly [T, T, T, T];
+export type Index4 = 0 | 1 | 2 | 3;
+export type Array5<T> = readonly [T, T, T, T, T];
+export type Array8<T> = readonly [T, T, T, T, T, T, T, T];
+export type Array16<T> = readonly [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T];
+export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
+export type Index5 = 0 | 1 | 2 | 3 | 4;
+export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+declare const first: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+declare const last: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+declare const head: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+declare const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;

package/types/array/test.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    function stringify(): void;
+    let at: (() => void)[];
+    let first: (() => void)[];
+    let last: (() => void)[];
+    let head: (() => void)[];
+    let tail: (() => void)[];
+    let splitFirst: (() => void)[];
+}
+export default _default;

package/types/bigfloat/module.f.d.mts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { decToBin };
+    export { multiply };
+}
+export default _default;
+export type BigFloat = readonly [bigint, number];
+export type BigFloatWithRemainder = readonly [BigFloat, bigint];
+/** @type {(dec: BigFloat) => BigFloat} */
+declare const decToBin: (dec: BigFloat) => BigFloat;
+/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
+declare const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;

package/types/bigfloat/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let decToBin: (() => void)[];
+    let roundingPositive: (() => void)[];
+    let roundingNegative: (() => void)[];
+}
+export default _default;

package/types/bigint/module.f.d.mts

@@ -0,0 +1,77 @@
+declare namespace _default {
+    export { addition };
+    export { sum };
+    export { abs };
+    export { sign };
+    export { serialize };
+    export { scalar_mul };
+    export { log2 };
+    export { bitLength };
+}
+export default _default;
+export type Unary = Op.Unary<bigint, bigint>;
+export type Additive<T> = {
+    readonly 0: T;
+    readonly add: Op.Reduce<T>;
+};
+/** @typedef {Op.Unary<bigint, bigint>} Unary*/
+/** @type {(a: bigint) => (b: bigint) => bigint} */
+declare const addition: (a: bigint) => (b: bigint) => bigint;
+declare const sum: (input: import("../list/module.f.mjs").List<bigint>) => bigint;
+/** @type {(a: bigint) => bigint} */
+declare const abs: (a: bigint) => bigint;
+/** @type {(a: bigint) => compareT.Sign} */
+declare const sign: (a: bigint) => compareT.Sign;
+/** @type {(a: bigint) => string} */
+declare const serialize: (a: bigint) => string;
+/**
+ * @template T
+ * @typedef {{
+ *  readonly 0: T
+ *  readonly add: Op.Reduce<T>
+ * }} Additive
+ */
+/** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
+declare const scalar_mul: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
+/**
+ * Calculates the base-2 logarithm (floor).
+ *
+ * This function returns the integer part of the logarithm. For example:
+ * - `log2(1n)` returns `0n`,
+ * - `log2(2n)` returns `1n`,
+ * - `log2(15n)` returns `3n`.
+ *
+ * @param {bigint} v - The input BigInt.
+ * @returns {bigint} The base-2 logarithm (floor) of the input BigInt, or `-1n` if the input is less than or equal to 0.
+ *
+ * @remarks
+ * The function operates in two phases:
+ * 1. **Fast Doubling Phase:** Uses exponential steps to quickly narrow down the range
+ *    of the most significant bit.
+ * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
+ *    determining the exact value of the logarithm.
+ */
+declare function log2(v: bigint): bigint;
+/**
+ * Calculates the bit length of a given BigInt.
+ *
+ * The bit length of a number is the number of bits required to represent its absolute value in binary,
+ * excluding leading zeros. For example:
+ * - `0n` has a bit length of 0 (it has no bits).
+ * - `1n` (binary `1`) has a bit length of 1.
+ * - `255n` (binary `11111111`) has a bit length of 8.
+ * - `-255n` (absolute value `255`, binary `11111111`) also has a bit length of 8.
+ *
+ * The function handles both positive and negative numbers. For negative inputs, the bit length is calculated
+ * based on the absolute value of the number. Zero has a bit length of 0.
+ *
+ * @param {bigint} v - The input BigInt.
+ * @returns {bigint} The bit length of the input BigInt.
+ *
+ * @remark
+ * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
+ * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
+ */
+declare function bitLength(v: bigint): bigint;
+import * as Op from '../function/operator/module.f.mjs';
+import * as compareT from '../function/compare/module.f.mjs';

package/types/bigint/test.f.d.mts

@@ -0,0 +1,16 @@
+declare namespace _default {
+    function sum(): void;
+    let abs: (() => void)[];
+    let serialize: (() => void)[];
+    let log2: (() => void)[];
+    function toString2(): void;
+    function minus(): void;
+    function not(): void;
+    let bitLen: {
+        0: () => void;
+        m: () => void;
+        big: () => void;
+        neg: (() => void)[];
+    };
+}
+export default _default;

package/types/btree/find/module.f.d.mts

@@ -0,0 +1,42 @@
+declare namespace _default {
+    export { find };
+    export { value };
+    export { isFound };
+}
+export default _default;
+export type FirstLeaf1<T> = readonly [cmpT.Index3, _.Leaf1<T>];
+export type FirstBranch3<T> = readonly [1, _.Branch3<T>];
+export type FirstLeaf2<T> = readonly [cmpT.Index5, _.Leaf2<T>];
+export type FirstBranch5<T> = readonly [1 | 3, _.Branch5<T>];
+export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
+export type PathItem3<T> = readonly [0 | 2, _.Branch3<T>];
+export type PathItem5<T> = readonly [0 | 2 | 4, _.Branch5<T>];
+export type PathItem<T> = PathItem3<T> | PathItem5<T>;
+export type Path<T> = List.List<PathItem<T>>;
+/**
+ * <T>
+ */
+export type Result<T> = {
+    readonly first: First<T>;
+    readonly tail: Path<T>;
+};
+/**
+ * @template T
+ * @typedef {List.List<PathItem<T>>} Path
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+declare const find: <T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>;
+/** @type {<T>(first: First<T>) => T | null} */
+declare const value: <T>(first: First<T>) => T | null;
+/** @type {<T>(first: First<T>) => boolean} */
+declare const isFound: <T>(first: First<T>) => boolean;
+import * as cmpT from '../../function/compare/module.f.mjs';
+import * as _ from '../types/module.f.mjs';
+import * as List from '../../list/module.f.mjs';

package/types/btree/find/test.f.d.mts

@@ -0,0 +1,2 @@
+export default test;
+declare function test(): void;

package/types/btree/module.f.d.mts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export let empty: null;
+    export { values };
+}
+export default _default;
+/** @type {<T>(tree: _.Tree<T>) => List.List<T>} */
+declare const values: <T>(tree: _.Tree<T>) => List.List<T>;
+import * as _ from './types/module.f.mjs';
+import * as List from '../list/module.f.mjs';

package/types/btree/remove/module.f.d.mts

@@ -0,0 +1,19 @@
+declare namespace _default {
+    export { nodeRemove };
+    export { remove };
+}
+export default _default;
+export type Leaf01<T> = null | _.Leaf1<T>;
+export type RemovePath<T> = {
+    readonly first: Leaf01<T>;
+    readonly tail: findT.Path<T>;
+};
+export type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>;
+export type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>;
+/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+declare const nodeRemove: <T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
+/** @type {<T>(c: cmpT.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+declare const remove: <T>(c: cmpT.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
+import * as _ from '../types/module.f.mjs';
+import * as findT from '../find/module.f.mjs';
+import * as cmpT from '../../function/compare/module.f.mjs';

package/types/btree/remove/test.f.d.mts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export { test };
+    export { test2 };
+}
+export default _default;
+declare function test(): void;
+declare function test2(): void;

package/types/btree/set/module.f.d.mts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export { set };
+}
+export default _default;
+export type Branch1To3<T> = _.Branch1<T> | _.Branch3<T>;
+/** @type {<T>(c: cmpT.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
+declare const set: <T>(c: cmpT.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.Node<T>;
+import * as _ from '../types/module.f.mjs';
+import * as cmpT from '../../function/compare/module.f.mjs';

package/types/btree/set/test.f.d.mts

@@ -0,0 +1,2 @@
+export default test;
+declare const test: (() => void)[];

package/types/btree/test.f.d.mts

@@ -0,0 +1,13 @@
+declare namespace _default {
+    export { valueTest1 };
+    export { valuesTest2 };
+    export { findTrue };
+    export { find };
+    export { test };
+}
+export default _default;
+declare function valueTest1(): void;
+declare function valuesTest2(): void;
+declare function findTrue(): void;
+declare function find(): void;
+declare function test(): void;

package/types/btree/types/module.f.d.mts

@@ -0,0 +1,16 @@
+declare const _default: {};
+export default _default;
+export type Array1<T> = readonly [T];
+export type Array2<T> = readonly [T, T];
+export type Array3<T> = readonly [T, T, T];
+export type Index2 = 0 | 1;
+export type Index3 = 0 | 1 | 2;
+export type Index5 = 0 | 1 | 2 | 3 | 4;
+export type Leaf1<T> = Array1<T>;
+export type Leaf2<T> = Array2<T>;
+export type Branch3<T> = readonly [Node<T>, T, Node<T>];
+export type Branch5<T> = readonly [Node<T>, T, Node<T>, T, Node<T>];
+export type Node<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
+export type Tree<T> = Node<T> | null;
+export type Branch1<T> = readonly [Node<T>];
+export type Branch7<T> = readonly [...Branch5<T>, T, Node<T>];

package/types/byte_set/module.f.d.mts

@@ -0,0 +1,38 @@
+declare namespace _default {
+    export { empty };
+    export { universe };
+    export { has };
+    export { set };
+    export { unset };
+    export { one };
+    export { union };
+    export { setRange };
+    export { range };
+    export { complement };
+    export { toRangeMap };
+}
+export default _default;
+export type ByteSet = bigint;
+export type Byte = number;
+declare const empty: 0n;
+declare const universe: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+/** @typedef {bigint} ByteSet */
+/** @typedef {number} Byte */
+/** @type {(n: Byte) => (s: ByteSet) => boolean} */
+declare const has: (n: Byte) => (s: ByteSet) => boolean;
+declare const set: import("../function/module.f.mjs").Func<number, (b: ByteSet) => ByteSet>;
+/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
+declare const unset: (n: Byte) => (s: ByteSet) => ByteSet;
+/** @type {(n: Byte) => ByteSet} */
+declare const one: (n: Byte) => ByteSet;
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+declare const union: (a: ByteSet) => (b: ByteSet) => ByteSet;
+declare const setRange: import("../function/module.f.mjs").Func<readonly [number, number], (b: ByteSet) => ByteSet>;
+/** @type {(r: readonly[Byte, Byte]) => ByteSet} */
+declare const range: (r: readonly [Byte, Byte]) => ByteSet;
+/** @type {(n: ByteSet) => ByteSet} */
+declare const complement: (n: ByteSet) => ByteSet;
+/** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
+declare const toRangeMap: (n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>;
+import * as RangeMap from '../range_map/module.f.mjs';
+import * as SortedSet from '../sorted_set/module.f.mjs';

package/types/byte_set/test.f.d.mts

@@ -0,0 +1,13 @@
+declare namespace _default {
+    let has: (() => void)[];
+    function setRange(): void;
+    let unset: (() => void)[];
+    function universe(): void;
+    namespace compliment {
+        export function empty(): void;
+        export function universe_1(): void;
+        export { universe_1 as universe };
+    }
+    let toRangeMap: (() => void)[];
+}
+export default _default;

package/types/function/compare/module.f.d.mts

@@ -0,0 +1,29 @@
+declare namespace _default {
+    export { unsafeCmp };
+    export { index3 };
+    export { index5 };
+}
+export default _default;
+export type Index3 = array.Index3;
+export type Index5 = array.Index5;
+export type Array2<T> = array.Array2<T>;
+export type Sign = -1 | 0 | 1;
+export type Compare<T> = (_: T) => Sign;
+/** @type {<T>(a: T) => (b: T) => Sign} */
+declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
+/** @typedef {array.Index3} Index3 */
+/** @typedef {array.Index5} Index5 */
+/**
+ * @template T
+ * @typedef {array.Array2<T>} Array2
+ */
+/** @typedef {-1|0|1} Sign */
+/**
+ * @template T
+ * @typedef {(_: T) => Sign} Compare
+ */
+/** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
+declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
+/** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
+declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
+import * as array from '../../array/module.f.mjs';

package/types/function/compare/test.f.d.mts

@@ -0,0 +1,2 @@
+declare function _default(): void;
+export default _default;

package/types/function/module.f.d.mts

@@ -0,0 +1,36 @@
+declare namespace _default {
+    export { identity };
+    export { compose };
+    export { flip };
+    export { fn };
+}
+export default _default;
+export type Func<I, O> = (_: I) => O;
+export type Fn<I, O> = {
+    readonly result: Func<I, O>;
+    readonly then: <T>(g: Func<O, T>) => Fn<I, T>;
+};
+/** @type {<T>(value: T) => T} */
+declare const identity: <T>(value: T) => T;
+/**
+ * @template I
+ * @template O
+ * @typedef {(_: I) => O} Func
+ */
+/**
+ * A postfix compose function.
+ *
+ * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
+ */
+declare const compose: <I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>;
+/** @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C} */
+declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
+/**
+ * @template I,O
+ * @typedef {{
+ *  readonly result: Func<I, O>
+ *  readonly then: <T>(g: Func<O, T>) => Fn<I, T>
+ * }} Fn
+ */
+/** @type {<I, O>(f: (i: I) => O) => Fn<I, O>} */
+declare const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;