functionalscript 0.1.594 → 0.1.597

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/module.f.mjs

@@ -1,7 +1,7 @@
 import f from '../function/module.f.mjs'
-const { fn, compose } = f
+const { compose } = f
 import * as RangeMap from '../range_map/module.f.mjs'
-import sortedSet, * as SortedSet from '../sorted_set/module.f.mjs'
+import * as SortedSet from '../sorted_set/module.f.mjs'
 import list from '../list/module.f.mjs'
 const { reverse, countdown, flat, map } = list
 

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/byte_set/test.f.mjs

@@ -1,12 +1,12 @@
 import _ from './module.f.mjs'
 import list from '../list/module.f.mjs'
 const { every, countdown, map, toArray } = list
-import json, * as jsonT from '../../json/module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
 import o from '../object/module.f.mjs'
 const { sort } = o
 
-/** @type {(a: readonly jsonT.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+/** @type {(a: readonly Json.Unknown[]) => string} */
+const stringify = json.stringify(sort)
 
 export default {
     has: [

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/module.f.mjs

@@ -1,11 +1,11 @@
-import * as array from '../../array/module.f.mjs'
+import * as Array from '../../array/module.f.mjs'
 
-/** @typedef {array.Index3} Index3 */
-/** @typedef {array.Index5} Index5 */
+/** @typedef {Array.Index3} Index3 */
+/** @typedef {Array.Index5} Index5 */
 
 /**
  * @template T
- * @typedef {array.Array2<T>} Array2
+ * @typedef {Array.Array2<T>} Array2
  */
 
 /** @typedef {-1|0|1} Sign */

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>;

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

@@ -0,0 +1,75 @@
+declare namespace _default {
+    export { join };
+    export { addition };
+    export { increment };
+    export { strictEqual };
+    export { logicalNot };
+    export { min };
+    export { max };
+    export { stateScanToScan };
+    export { foldToScan };
+    export { reduceToScan };
+    export { counter };
+    export { concat };
+}
+export default _default;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Fold<I, O> = Binary<I, O, O>;
+export type Unary<T, R> = (value: T) => R;
+export type Equal<T> = Binary<T, T, boolean>;
+export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
+export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
+export type Reduce<T> = Fold<T, T>;
+/**
+ * @template A
+ * @template B
+ * @template R
+ * @typedef {(a: A) => (b: B) => R} Binary
+ */
+/**
+ * @template I,O
+ * @typedef {Binary<I, O, O>} Fold
+ */
+/** @type {(separator: string) => Reduce<string>} */
+declare const join: (separator: string) => Reduce<string>;
+/** @type {Reduce<number>} */
+declare const addition: Reduce<number>;
+declare const increment: (b: number) => number;
+/**
+ * @template T
+ * @typedef {Binary<T, T, boolean>} Equal
+ */
+/** @type {<T>(a: T) => (b: T) => boolean} */
+declare const strictEqual: <T>(a: T) => (b: T) => boolean;
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => R} Unary
+ */
+/** @type {Unary<boolean, boolean>} */
+declare const logicalNot: Unary<boolean, boolean>;
+/** @type {Reduce<number>} */
+declare const min: Reduce<number>;
+/** @type {Reduce<number>} */
+declare const max: Reduce<number>;
+/**
+ * @template I,O
+ * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
+ */
+/**
+ * @template I,S,O
+ * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
+ */
+/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
+declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
+/** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
+declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
+/**
+ * @template T
+ * @typedef {Fold<T, T>} Reduce
+ */
+/** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
+declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+declare function counter(): (b: number) => number;
+/** @type {Reduce<string>} */
+declare const concat: Reduce<string>;

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

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

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

@@ -0,0 +1,117 @@
+declare namespace _default {
+    export let empty: null;
+    export { concat };
+    export { next };
+    export { iterable };
+    export { toArray };
+    export { flat };
+    export { map };
+    export { flatMap };
+    export { filter };
+    export { filterMap };
+    export { takeWhile };
+    export { take };
+    export { dropWhile };
+    export { drop };
+    export { first };
+    export { last };
+    export { find };
+    export { some };
+    export { every };
+    export { isEmpty };
+    export { includes };
+    export { countdown };
+    export { repeat };
+    export { cycle };
+    export { scan };
+    export { stateScan };
+    export { foldScan };
+    export { fold };
+    export { reduce };
+    export { length };
+    export { entries };
+    export { reverse };
+    export { zip };
+    export { equal };
+}
+export default _default;
+export type List<T> = NotLazy<T> | Thunk<T>;
+export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
+export type Empty = null;
+export type Result<T> = Empty | NonEmpty<T>;
+export type Thunk<T> = () => List<T>;
+export type NonEmpty<T> = {
+    readonly first: T;
+    readonly tail: List<T>;
+};
+export type Concat<T> = {
+    readonly head: List<T>;
+    readonly tail: List<T>;
+};
+export type Entry<T> = readonly [number, T];
+/** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
+declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
+/** @type {<T>(list: List<T>) => Result<T>} */
+declare const next: <T>(list: List<T>) => Result<T>;
+/** @type {<T>(list: List<T>) => Iterable<T>} */
+declare const iterable: <T>(list: List<T>) => Iterable<T>;
+/** @type {<T>(list: List<T>) => readonly T[]} */
+declare const toArray: <T>(list: List<T>) => readonly T[];
+/** @type {<T>(list: List<List<T>>) => Thunk<T>} */
+declare const flat: <T>(list: List<List<T>>) => Thunk<T>;
+/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
+declare const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
+/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
+declare const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+declare const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+/** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
+declare const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+declare const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
+declare const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+declare const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
+declare const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
+/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
+declare const first: <D>(def: D) => <T>(input: List<T>) => D | T;
+/** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
+declare const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
+/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
+declare const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
+/** @type {(input: List<boolean>) => boolean} */
+declare const some: (input: List<boolean>) => boolean;
+declare const every: import("../function/module.f.mjs").Func<List<boolean>, boolean>;
+/** @type {<T>(input: List<T>) => boolean} */
+declare const isEmpty: <T>(input: List<T>) => boolean;
+/** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
+declare const includes: <T>(value: T) => (sequence: List<T>) => boolean;
+/** @type {(count: number) => Thunk<number>} */
+declare const countdown: (count: number) => Thunk<number>;
+/** @type {<T>(v: T) => (c: number) => Thunk<T>} */
+declare const repeat: <T>(v: T) => (c: number) => Thunk<T>;
+/** @type {<T>(list: List<T>) => List<T>} */
+declare const cycle: <T>(list: List<T>) => List<T>;
+/** @type {<I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
+declare const scan: <I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
+/** @type {<I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+declare const stateScan: <I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+declare const foldScan: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+declare const fold: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
+/** @type {<T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+declare const reduce: <T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
+/** @type {<T>(input: List<T>) => number} */
+declare const length: <T>(input: List<T>) => number;
+/** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
+declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
+/** @type {<T>(input: List<T>) => List<T>} */
+declare const reverse: <T>(input: List<T>) => List<T>;
+/** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
+declare const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
+/** @type {<T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+declare const equal: <T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
+import * as Operator from '../function/operator/module.f.mjs';

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

@@ -0,0 +1,38 @@
+declare namespace _default {
+    export { stringifyTest };
+    export { cycle };
+    export { countdown };
+    export { flat };
+    export { concat };
+    export { flatMap };
+    export { take };
+    export { find };
+    export { takeWhile };
+    export { dropWhile };
+    export { drop };
+    export { additionTests };
+    export { entries };
+    export { reverse };
+    export { zip };
+    export { logic };
+    export let strictEqual: (() => void)[];
+    export let isEmpty: (() => void)[];
+    export function length(): void;
+}
+export default _default;
+declare function stringifyTest(): void;
+declare function cycle(): void;
+declare function countdown(): void;
+declare function flat(): void;
+declare function concat(): void;
+declare function flatMap(): void;
+declare const take: (() => void)[];
+declare const find: (() => void)[];
+declare const takeWhile: (() => void)[];
+declare function dropWhile(): void;
+declare const drop: (() => void)[];
+declare const additionTests: (() => void)[];
+declare const entries: (() => void)[];
+declare const reverse: (() => void)[];
+declare const zip: (() => void)[];
+declare function logic(): (() => void)[];

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

@@ -0,0 +1,30 @@
+declare namespace _default {
+    export let empty: null;
+    export { at };
+    export { setReduce };
+    export { setReplace };
+    export { entries };
+    export { fromEntries };
+    export { remove };
+}
+export default _default;
+export type Sign = Compare.Sign;
+export type Cmp<T> = Compare.Compare<T>;
+export type Entry<T> = readonly [string, T];
+export type Map<T> = BtreeTypes.Tree<Entry<T>>;
+/** @type {(name: string) => <T>(map: Map<T>) => T|null} */
+declare const at: (name: string) => <T>(map: Map<T>) => T | null;
+/** @type {<T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
+declare const setReduce: <T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
+/** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
+declare const setReplace: (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>;
+/** @type {<T>(map: Map<T>) => List.List<Entry<T>>} */
+declare const entries: <T>(map: Map<T>) => List.List<Entry<T>>;
+/** @type {<T>(entries: List.List<Entry<T>>) => Map<T>} */
+declare const fromEntries: <T>(entries: List.List<Entry<T>>) => Map<T>;
+/** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
+declare const remove: (name: string) => <T>(map: Map<T>) => Map<T>;
+import * as Compare from '../function/compare/module.f.mjs';
+import * as BtreeTypes from '../btree/types/module.f.mjs';
+import * as Operator from '../function/operator/module.f.mjs';
+import * as List from '../list/module.f.mjs';

package/types/map/module.f.mjs

@@ -1,4 +1,4 @@
-import * as btreeTypes from '../btree/types/module.f.mjs'
+import * as BtreeTypes from '../btree/types/module.f.mjs'
 import btf from '../btree/find/module.f.mjs'
 const { value, find } = btf
 import bts from '../btree/set/module.f.mjs'
@@ -7,12 +7,12 @@ import btr from '../btree/remove/module.f.mjs'
 const { remove: btreeRemove } = btr
 import bt from '../btree/module.f.mjs'
 const { values } = bt
-import compare, * as Compare from '../function/compare/module.f.mjs'
+import * as Compare from '../function/compare/module.f.mjs'
 import s from '../string/module.f.mjs'
 const { cmp } = s
 import list, * as List from '../list/module.f.mjs'
 const { fold } = list
-import operator, * as Operator from '../function/operator/module.f.mjs'
+import * as Operator from '../function/operator/module.f.mjs'
 
 /** @typedef {Compare.Sign} Sign */
 
@@ -28,7 +28,7 @@ import operator, * as Operator from '../function/operator/module.f.mjs'
 
 /**
  * @template T
- * @typedef {btreeTypes.Tree<Entry<T>>} Map
+ * @typedef {BtreeTypes.Tree<Entry<T>>} Map
  */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */

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

@@ -0,0 +1,5 @@
+declare namespace _default {
+    let main: (() => void)[];
+    function stress(): void;
+}
+export default _default;

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

@@ -0,0 +1,26 @@
+declare namespace _default {
+    export { empty };
+    export { universe };
+    export { has };
+    export { complement };
+    export { set };
+    export { unset };
+    export { setRange };
+}
+export default _default;
+export type NibbleSet = number;
+export type Nibble = number;
+/** @typedef {number} NibbleSet */
+/** @typedef {number} Nibble */
+declare const empty: 0;
+declare const universe: 65535;
+/** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
+declare const has: (n: Nibble) => (s: NibbleSet) => boolean;
+/** @type {(n: NibbleSet) => NibbleSet} */
+declare const complement: (n: NibbleSet) => NibbleSet;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+declare const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+declare const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
+declare const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;

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

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

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

@@ -0,0 +1,14 @@
+declare namespace _default {
+    export { map };
+    export { match };
+}
+export default _default;
+export type Nullable<T> = T | null;
+/**
+ * @template T
+ * @typedef {T|null} Nullable
+ */
+/** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
+declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
+/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
+declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;

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

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

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

@@ -0,0 +1,13 @@
+declare namespace _default {
+    export { sum };
+    export { min };
+    export { max };
+    export { cmp };
+}
+export default _default;
+declare const sum: (input: import("../list/module.f.mjs").List<number>) => number;
+declare const min: (input: import("../list/module.f.mjs").List<number>) => number | null;
+declare const max: (input: import("../list/module.f.mjs").List<number>) => number | null;
+/** @type {(a: number) => (b: number) => Compare.Sign} */
+declare const cmp: (a: number) => (b: number) => Compare.Sign;
+import * as Compare from '../function/compare/module.f.mjs';

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

@@ -0,0 +1,11 @@
+declare namespace _default {
+    function sum(): void;
+    namespace min {
+        function empty(): void;
+        function multi(): void;
+    }
+    function max(): void;
+    function cmp(): void;
+    function standard(): void;
+}
+export default _default;

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

@@ -0,0 +1,29 @@
+declare namespace _default {
+    export { at };
+    export { sort };
+    export { fromEntries };
+    export { fromMap };
+}
+export default _default;
+export type Map<T> = { readonly [k in string]: T; };
+export type Entry<T> = readonly [string, T];
+/**
+ * @template T
+ * @typedef {{
+ *  readonly [k in string]: T
+ * }} Map
+ */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+/** @type {(name: string) => <T>(object: Map<T>) => T|null} */
+declare const at: (name: string) => <T>(object: Map<T>) => T | null;
+/** @type {<T>(e: List.List<Entry<T>>) => List.List<Entry<T>>} */
+declare const sort: <T>(e: List.List<Entry<T>>) => List.List<Entry<T>>;
+/** @type {<T>(e: List.List<Entry<T>>) => Map<T>} */
+declare const fromEntries: <T>(e: List.List<Entry<T>>) => Map<T>;
+/** @type {<T>(m: Map.Map<T>) => Map<T>} */
+declare const fromMap: <T>(m: Map.Map<T>) => Map<T>;
+import * as List from '../list/module.f.mjs';
+import * as Map from '../map/module.f.mjs';

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

@@ -0,0 +1,5 @@
+declare namespace _default {
+    function ctor(): void;
+    function property(): void;
+}
+export default _default;

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

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { contains };
+    export { one };
+}
+export default _default;
+export type Range = readonly [number, number];
+/** @typedef {readonly[number,number]} Range */
+/** @type {(range: Range) => (i: number) => boolean} */
+declare const contains: (range: Range) => (i: number) => boolean;
+/** @type {(i: number) => Range} */
+declare const one: (i: number) => Range;

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

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

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

@@ -0,0 +1,25 @@
+declare namespace _default {
+    export { merge };
+    export { get };
+    export { fromRange };
+}
+export default _default;
+export type Entry<T> = [T, number];
+export type RangeMap<T> = SortedList.SortedList<Entry<T>>;
+export type RangeMapArray<T> = readonly Entry<T>[];
+export type Operators<T> = {
+    readonly union: O.Reduce<T>;
+    readonly equal: O.Equal<T>;
+};
+export type RangeState<T> = Option.Nullable<Entry<T>>;
+export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
+/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
+/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
+declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
+/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
+declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
+import * as SortedList from '../sorted_list/module.f.mjs';
+import * as O from '../function/operator/module.f.mjs';
+import * as Option from '../nullable/module.f.mjs';
+import * as Range from '../range/module.f.mjs';