functionalscript 0.1.609 → 0.2.1

package/commonjs/package/module.f.d.mts

@@ -1,27 +0,0 @@
-declare namespace _default {
-    export { dependencies };
-    export { isPackageJson };
-}
-export default _default;
-export type PackageJson = {
-    readonly name: string;
-    readonly version: string;
-    readonly dependencies?: Dependencies.DependenciesJson;
-};
-export type Package = {
-    readonly dependency: (localPackageId: string) => string | null;
-    readonly file: (localFileId: string) => string | null;
-};
-export type Get = (packageId: string) => Package | null;
-import dependencies from './dependencies/module.f.mjs';
-/**
- * @typedef {{
- *  readonly name: string
- *  readonly version: string
- *  readonly dependencies?: Dependencies.DependenciesJson
- * }} PackageJson
- */
-/** @type {(j: Json.Unknown) => j is PackageJson} */
-declare const isPackageJson: (j: Json.Unknown) => j is PackageJson;
-import * as Dependencies from './dependencies/module.f.mjs';
-import * as Json from '../../json/module.f.mjs';

package/dev/module.f.d.mts

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

package/djs/tokenizer/module.f.d.mts

@@ -1,17 +0,0 @@
-declare namespace _default {
-    export { tokenize };
-}
-export default _default;
-export type DjsToken = {
-    readonly kind: "true" | "false" | "null";
-} | {
-    readonly kind: "{" | "}" | ":" | "," | "[" | "]" | "." | "=";
-} | jsTokenizerT.StringToken | jsTokenizerT.NumberToken | jsTokenizerT.ErrorToken | jsTokenizerT.IdToken | jsTokenizerT.BigIntToken | jsTokenizerT.WhitespaceToken | jsTokenizerT.NewLineToken;
-export type ScanState = {
-    readonly kind: "def" | "-";
-};
-export type ScanInput = jsTokenizerT.JsToken | null;
-/** @type {(input: List.List<number>) => List.List<DjsToken>} */
-declare const tokenize: (input: List.List<number>) => List.List<DjsToken>;
-import * as jsTokenizerT from '../../js/tokenizer/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

package/fsc/module.f.d.mts

@@ -1,12 +0,0 @@
-declare namespace _default {
-    export { terminal };
-    export { init };
-}
-export default _default;
-export type Result = readonly [readonly string[], ToResult];
-export type ToResult = (codePoint: number) => Result;
-export type CreateToResult<T> = (state: T) => ToResult;
-export type State<T> = RM.RangeMapArray<CreateToResult<T>>;
-declare const terminal: -1;
-declare const init: ToResult;
-import * as RM from '../types/range_map/module.f.mjs';

package/fsm/module.f.d.mts

@@ -1,21 +0,0 @@
-declare namespace _default {
-    export { dfa };
-    export { run };
-    export { toRange };
-    export { toUnion };
-}
-export default _default;
-export type Rule = readonly [string, byteSetT.ByteSet, string];
-export type Grammar = List.List<Rule>;
-export type Dfa = { readonly [state in string]: RM.RangeMapArray<string>; };
-/** @type {(grammar: Grammar) => Dfa} */
-declare const dfa: (grammar: Grammar) => Dfa;
-/** @type {(dfa: Dfa) => (input: List.List<number>) => List.List<string>} */
-declare const run: (dfa: Dfa) => (input: List.List<number>) => List.List<string>;
-/** @type {(s: string) => byteSetT.ByteSet} */
-declare const toRange: (s: string) => byteSetT.ByteSet;
-/** @type {(s: string) => byteSetT.ByteSet} */
-declare const toUnion: (s: string) => byteSetT.ByteSet;
-import * as byteSetT from '../types/byte_set/module.f.mjs';
-import * as List from '../types/list/module.f.mjs';
-import * as RM from '../types/range_map/module.f.mjs';

package/html/module.f.d.mts

@@ -1,20 +0,0 @@
-declare namespace _default {
-    export { element };
-    export { html };
-    export { htmlToString };
-}
-export default _default;
-export type Tag = string;
-export type Element1 = readonly [Tag];
-export type Element2A = readonly [Tag, Attributes];
-export type Element2N = readonly [Tag, readonly Node[]];
-export type Element3 = readonly [Tag, Attributes, Nodes];
-export type Element = Element1 | Element2A | Element2N | Element3;
-export type Attributes = { readonly [k in string]: string; };
-export type Nodes = List.List<Node>;
-export type Node = Element | string;
-/** @type {(element: Element) => List.List<string>} */
-declare const element: (element: Element) => List.List<string>;
-declare const html: import("../types/function/module.f.mjs").Func<Element, List.List<string>>;
-declare const htmlToString: import("../types/function/module.f.mjs").Func<Element, string>;
-import * as List from '../types/list/module.f.mjs';

package/json/module.f.d.mts

@@ -1,41 +0,0 @@
-declare namespace _default {
-    export { setProperty };
-    export { stringify };
-    export { serialize };
-    export { parse };
-    export { isObject };
-}
-export default _default;
-export type Object = { readonly [k in string]: Unknown; };
-export type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array;
-export type Entry = O.Entry<Unknown>;
-export type Entries = (List.List<Entry>);
-export type MapEntries = (entries: Entries) => Entries;
-/**
- * @typedef {{
- *  readonly [k in string]: Unknown
- * }} Object
- */
-/** @typedef {readonly Unknown[]} Array */
-/** @typedef {Object|boolean|string|number|null|Array} Unknown */
-/** @type {(value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown} */
-declare const setProperty: (value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown;
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- *
- * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
- */
-declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
-/** @typedef {O.Entry<Unknown>} Entry*/
-/** @typedef {(List.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
-declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List.List<string>;
-/** @type {(value: string) => Unknown} */
-declare const parse: (value: string) => Unknown;
-/** @type {(value: Unknown) => value is Object} */
-declare const isObject: (value: Unknown) => value is Object;
-import * as O from '../types/object/module.f.mjs';
-import * as List from '../types/list/module.f.mjs';

package/json/serializer/module.f.d.mts

@@ -1,45 +0,0 @@
-declare namespace _default {
-    export { objectWrap };
-    export { arrayWrap };
-    export { stringSerialize };
-    export { numberSerialize };
-    export { nullSerialize };
-    export { boolSerialize };
-}
-export default _default;
-/**
- * <T>
- */
-export type Obj<T> = { readonly [k in string]: Unknown<T>; };
-/**
- * <T>
- */
-export type Arr<T> = readonly Unknown<T>[];
-export type Primitive = boolean | string | number | null;
-/**
- * <T>
- */
-export type Unknown<T> = Arr<T> | Obj<T> | null | T;
-/**
- * <T>
- */
-export type Entry<T> = O.Entry<Unknown<T>>;
-/**
- * <T>
- */
-export type Entries<T> = (List.List<Entry<T>>);
-/**
- * <T>
- */
-export type MapEntries<T> = (entries: Entries<T>) => Entries<T>;
-declare const objectWrap: (input: List.List<List.List<string>>) => List.List<string>;
-declare const arrayWrap: (input: List.List<List.List<string>>) => List.List<string>;
-/** @type {(_: string) => List.List<string>} */
-declare const stringSerialize: (_: string) => List.List<string>;
-/** @type {(_: number) => List.List<string>} */
-declare const numberSerialize: (_: number) => List.List<string>;
-declare const nullSerialize: string[];
-/** @type {(_: boolean) => List.List<string>} */
-declare const boolSerialize: (_: boolean) => List.List<string>;
-import * as O from '../../types/object/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

package/json/tokenizer/module.f.d.mts

@@ -1,17 +0,0 @@
-declare namespace _default {
-    export { tokenize };
-}
-export default _default;
-export type JsonToken = {
-    readonly kind: "true" | "false" | "null";
-} | {
-    readonly kind: "{" | "}" | ":" | "," | "[" | "]";
-} | JsTokenizer.StringToken | JsTokenizer.NumberToken | JsTokenizer.ErrorToken;
-export type ScanState = {
-    readonly kind: "def" | "-";
-};
-export type ScanInput = JsTokenizer.JsToken | null;
-/** @type {(input: List.List<number>) => List.List<JsonToken>} */
-declare const tokenize: (input: List.List<number>) => List.List<JsonToken>;
-import * as JsTokenizer from '../../js/tokenizer/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

package/sha2/module.f.d.mts

@@ -1,23 +0,0 @@
-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/text/ascii/module.f.d.mts

@@ -1,73 +0,0 @@
-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/module.f.d.mts

@@ -1,18 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/utf16/module.f.d.mts

@@ -1,19 +0,0 @@
-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/utf8/module.f.d.mts

@@ -1,15 +0,0 @@
-declare namespace _default {
-    export { fromCodePointList };
-    export { toCodePointList };
-}
-export default _default;
-export type ByteOrEof = u8 | null;
-export type Utf8NonEmptyState = Array.Array1<number> | Array.Array2<number> | Array.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 Array from '../../types/array/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

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

@@ -1,11 +0,0 @@
-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/btree/module.f.d.mts

@@ -1,9 +0,0 @@
-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/byte_set/module.f.d.mts

@@ -1,38 +0,0 @@
-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/list/module.f.d.mts

@@ -1,117 +0,0 @@
-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/map/module.f.d.mts

@@ -1,30 +0,0 @@
-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/nibble_set/module.f.d.mts

@@ -1,26 +0,0 @@
-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/nullable/module.f.d.mts

@@ -1,14 +0,0 @@
-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/number/module.f.d.mts

@@ -1,13 +0,0 @@
-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';