functionalscript 0.3.6 → 0.3.8

package/types/bit_vec/test.f.js

@@ -1,4 +1,73 @@
-import { empty, vec, length, concatLsb, uintLsb, uintMsb, removeLsb, concatMsb, removeMsb, uint, popUintLsb, popUintMsb } from "./module.f.js";
+import { empty, vec, length, uint, lsb, msb } from "./module.f.js";
+const frontTest = (e) => (r0) => (r1) => () => {
+    const vector = vec(8n)(0xf5n); // 0x1F5n
+    if (vector !== 0x1f5n) {
+        throw vector;
+    }
+    const result = e.front(4n)(vector);
+    if (result !== r0) {
+        throw result;
+    }
+    const result2 = e.front(16n)(vector);
+    if (result2 !== r1) {
+        throw result2;
+    }
+};
+const popFront = (e) => ([r00, r01]) => ([r10, r11]) => () => {
+    const vector = vec(8n)(0xf5n); // 0x1F5n
+    const [result, rest] = e.popFront(4n)(vector);
+    if (result !== r00) {
+        throw result;
+    }
+    if (rest !== r01) {
+        throw rest;
+    }
+    const [result2, rest2] = e.popFront(16n)(vector);
+    if (result2 !== r10) {
+        throw result2;
+    }
+    if (rest2 !== r11) {
+        throw rest2;
+    }
+};
+const removeFront = (e) => (r0) => (r1) => () => {
+    const v = vec(16n)(0x3456n); // 0x13456n
+    if (v !== 0x13456n) {
+        throw v;
+    }
+    const r = e.removeFront(4n)(v);
+    if (r !== r0) {
+        throw r;
+    }
+    const r2 = e.removeFront(24n)(v);
+    if (r2 !== r1) {
+        throw r2;
+    }
+};
+const concat = (e) => (r) => () => {
+    const u8 = vec(8n);
+    const a = u8(0x45n); // 0x145n
+    if (a !== 0x145n) {
+        throw a;
+    }
+    const b = u8(0x89n); // 0x189n
+    if (b !== 0x189n) {
+        throw b;
+    }
+    const ab = e.concat(a)(b); // 0x18945n
+    if (ab !== r) {
+        throw ab;
+    }
+};
+const assertEq = (a, b) => {
+    if (a !== b) {
+        throw [a, b];
+    }
+};
+const assertEq2 = ([a0, a1], [b0, b1]) => {
+    assertEq(a0, b0);
+    assertEq(a1, b1);
+};
 export default {
     examples: {
         vec: () => {
@@ -22,130 +91,54 @@ export default {
                 throw result;
             }
         },
-        uintLsb: () => {
+        front: () => {
             const vector = vec(8n)(0xf5n); // 0x1F5n
-            if (vector !== 0x1f5n) {
-                throw vector;
-            }
-            const result = uintLsb(4n)(vector); // result is 5n
-            if (result !== 5n) {
-                throw result;
-            }
-            const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
-            if (result2 !== 0xf5n) {
-                throw result2;
-            }
+            assertEq(lsb.front(4n)(vector), 5n);
+            assertEq(lsb.front(16n)(vector), 0xf5n);
+            assertEq(msb.front(4n)(vector), 0xfn);
+            assertEq(msb.front(16n)(vector), 0xf500n);
         },
-        uintMsb: () => {
-            const vector = vec(8n)(0xf5n); // 0x1F5n
-            if (vector !== 0x1f5n) {
-                throw vector;
-            }
-            const result = uintMsb(4n)(vector); // result is 0xFn
-            if (result !== 0xfn) {
-                throw result;
-            }
-            const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
-            if (result2 !== 0xf500n) {
-                throw result2;
-            }
-        },
-        popUintLsb: () => {
-            const vector = vec(8n)(0xf5n); // 0x1F5n
-            const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
-            if (result !== 5n) {
-                throw result;
-            }
-            if (rest !== 0x1fn) {
-                throw rest;
-            }
-            const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
-            if (result2 !== 0xf5n) {
-                throw result2;
-            }
-            if (rest2 !== 1n) {
-                throw rest2;
-            }
+        removeFront: () => {
+            const v = vec(16n)(0x3456n); // 0x13456n
+            assertEq(lsb.removeFront(4n)(v), 0x1345n);
+            assertEq(lsb.removeFront(24n)(v), 0x1n);
+            assertEq(msb.removeFront(4n)(v), 0x1456n);
+            assertEq(msb.removeFront(24n)(v), 0x1n);
         },
-        popUintMsb: () => {
+        popFront: () => {
             const vector = vec(8n)(0xf5n); // 0x1F5n
-            const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
-            if (result !== 0xfn) {
-                throw result;
-            }
-            if (rest !== 0x15n) {
-                throw rest;
-            }
-            const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
-            if (result2 !== 0xf500n) {
-                throw result2;
-            }
-            if (rest2 !== 1n) {
-                throw rest2;
-            }
-        },
-        concatLsb: () => {
-            const u8 = vec(8n);
-            const a = u8(0x45n); // 0x145n
-            if (a !== 0x145n) {
-                throw a;
-            }
-            const b = u8(0x89n); // 0x189n
-            if (b !== 0x189n) {
-                throw b;
-            }
-            const ab = concatLsb(a)(b); // 0x18945n
-            if (ab !== 0x18945n) {
-                throw ab;
-            }
+            assertEq2(lsb.popFront(4n)(vector), [5n, 0x1fn]);
+            assertEq2(lsb.popFront(16n)(vector), [0xf5n, 1n]);
+            assertEq2(msb.popFront(4n)(vector), [0xfn, 0x15n]);
+            assertEq2(msb.popFront(16n)(vector), [0xf500n, 1n]);
         },
-        concatMsb: () => {
+        concat: () => {
             const u8 = vec(8n);
             const a = u8(0x45n); // 0x145n
-            if (a !== 0x145n) {
-                throw a;
-            }
             const b = u8(0x89n); // 0x189n
-            if (b !== 0x189n) {
-                throw b;
-            }
-            const ab = concatMsb(a)(b); // 0x14589n
-            if (ab !== 0x14589n) {
-                throw ab;
-            }
-        },
-        removeLsb: () => {
-            const v = vec(16n)(0x3456n); // 0x13456n
-            if (v !== 0x13456n) {
-                throw v;
-            }
-            const r = removeLsb(4n)(v); // 0x1345n
-            if (r !== 0x1345n) {
-                throw r;
-            }
-            const r2 = removeLsb(24n)(v); // 0x1n
-            if (r2 !== 0x1n) {
-                throw r2;
-            }
-        },
-        removeMsb: () => {
-            const v = vec(16n)(0x3456n); // 0x13456n
-            if (v !== 0x13456n) {
-                throw v;
-            }
-            const r = removeMsb(4n)(v); // 0x1456n
-            if (r !== 0x1456n) {
-                throw r;
-            }
-            const r2 = removeMsb(24n)(v); // 0x1n
-            if (r2 !== 0x1n) {
-                throw r2;
-            }
+            assertEq(lsb.concat(a)(b), 0x18945n);
+            assertEq(msb.concat(a)(b), 0x14589n);
         }
     },
+    front: {
+        lsbf: frontTest(lsb)(5n)(0xf5n),
+        msbf: frontTest(msb)(0xfn)(0xf500n),
+    },
+    popFront: {
+        lsbm: popFront(lsb)([5n, 0x1fn])([0xf5n, 1n]),
+        msbm: popFront(msb)([0xfn, 0x15n])([0xf500n, 1n]),
+    },
+    removeFront: {
+        lsbm: removeFront(lsb)(0x1345n)(0x1n),
+        msbm: removeFront(msb)(0x1456n)(0x1n),
+    },
+    concat: {
+        lsbm: concat(lsb)(0x18945n),
+        msbm: concat(msb)(0x14589n),
+    },
     uintLsb: () => {
         const vector = 117n;
-        const extract3Bits = uintLsb(3n);
+        const extract3Bits = lsb.front(3n);
         const result = extract3Bits(vector); // result is 0b101n (5n)
         if (result !== 5n) {
             throw result;
@@ -153,7 +146,7 @@ export default {
     },
     uintSmall: () => {
         const vector = 3n;
-        const extract3Bits = uintLsb(3n)(vector);
+        const extract3Bits = lsb.front(3n)(vector);
         if (extract3Bits !== 1n) {
             throw extract3Bits;
         }
@@ -179,7 +172,7 @@ export default {
         if (length(v) !== 8n) {
             throw 'len';
         }
-        const u = uintLsb(8n)(v);
+        const u = lsb.front(8n)(v);
         if (u !== 0xfen) {
             throw v;
         }
@@ -188,7 +181,7 @@ export default {
         const vec8 = vec(8n);
         const a = vec8(0x345n);
         const b = vec8(0x789n);
-        const ab = concatLsb(a)(b);
+        const ab = lsb.concat(a)(b);
         if (ab !== 0x18945n) {
             throw ab;
         }
@@ -202,7 +195,7 @@ export default {
         if (v !== 0x32345n) {
             throw v.toString(16);
         }
-        const r = removeLsb(9n)(v);
+        const r = lsb.removeFront(9n)(v);
         if (r !== 0x191n) {
             throw r.toString(16);
         }

package/types/btree/find/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
 import * as list from "../../list/module.f.js";
 import * as json from "../../../json/module.f.js";
-import * as o from "../../object/module.f.js";
-const { sort } = o;
-import * as btree from "../types/module.f.js";
+import { sort } from "../../object/module.f.js";
 import * as string from "../../string/module.f.js";
 const { cmp } = string;
 import * as s from "../set/module.f.js";
@@ -13,8 +11,9 @@ const str = r => jsonStr(list.toArray(list.map((x) => x[0])(r)));
 const find = i => m => str(_.find(cmp(i))(m));
 const test = () => {
     let _map = ['1'];
-    for (let i = 2; i <= 10; i++)
+    for (let i = 2; i <= 10; i++) {
         _map = set(_map)((i * i).toString());
+    }
     {
         const s = jsonStr(_map);
         if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {

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

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

package/types/btree/module.f.js

@@ -1,8 +1,5 @@
-import * as list from "../list/module.f.js";
-const { flat } = list;
-import * as n from "../nullable/module.f.js";
-const { map } = n;
-import * as _ from "./types/module.f.js";
+import { flat } from "../list/module.f.js";
+import { map } from "../nullable/module.f.js";
 const nodeValues = node => () => {
     switch (node.length) {
         case 1:

package/types/btree/remove/test.f.js

@@ -1,13 +1,12 @@
 import * as _ from "./module.f.js";
-import * as BTree from "../types/module.f.js";
 import * as s from "../set/module.f.js";
 import * as str from "../../string/module.f.js";
 const { cmp } = str;
 import * as json from "../../../json/module.f.js";
 import * as o from "../../object/module.f.js";
 const { sort } = o;
-const set = node => value => s.set(cmp(value))(() => value)(node);
-const remove = node => value => _.nodeRemove(cmp(value))(node);
+const set = (node) => (value) => s.set(cmp(value))(() => value)(node);
+const remove = (node) => (value) => _.nodeRemove(cmp(value))(node);
 const jsonStr = json.stringify(sort);
 const test = () => {
     let _map = ['1'];

package/types/btree/set/test.f.js

@@ -1,11 +1,8 @@
 import * as _ from "./module.f.js";
-import * as BTree from "../types/module.f.js";
-import * as s from "../../string/module.f.js";
-const { cmp } = s;
+import { cmp } from "../../string/module.f.js";
 import * as json from "../../../json/module.f.js";
-import * as o from "../../object/module.f.js";
-const { sort } = o;
-const set = node => value => _.set(cmp(value))(() => value)(node);
+import { sort } from "../../object/module.f.js";
+const set = (node) => (value) => _.set(cmp(value))(() => value)(node);
 const jsonStr = json.stringify(sort);
 const test = [
     () => {

package/types/btree/test.f.js

@@ -1,4 +1,3 @@
-import * as BTree from "./types/module.f.js";
 import * as _ from "./module.f.js";
 const { values } = _;
 import * as json from "../../json/module.f.js";

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

@@ -1,5 +1,6 @@
-type Array1<T> = readonly [T];
-type Array2<T> = readonly [T, T];
+export type Array1<T> = readonly [T];
+export type Array2<T> = readonly [T, T];
+export type Array3<T> = readonly [T, T, T];
 export type Leaf1<T> = Array1<T>;
 export type Leaf2<T> = Array2<T>;
 export type Branch3<T> = readonly [TNode<T>, T, TNode<T>];
@@ -8,4 +9,3 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
-export {};

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

@@ -1,5 +1,5 @@
-import * as RangeMap from '../range_map/module.f.ts';
-import * as SortedSet from '../sorted_set/module.f.ts';
+import type * as RangeMap from '../range_map/module.f.ts';
+import type * as SortedSet from '../sorted_set/module.f.ts';
 export type ByteSet = bigint;
 type Byte = number;
 export declare const has: (n: Byte) => (s: ByteSet) => boolean;

package/types/byte_set/module.f.js

@@ -1,6 +1,4 @@
 import { compose } from "../function/module.f.js";
-import * as RangeMap from "../range_map/module.f.js";
-import * as SortedSet from "../sorted_set/module.f.js";
 import * as list from "../list/module.f.js";
 const { reverse, countdown, flat, map } = list;
 export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;

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

@@ -1,4 +1,4 @@
-import * as Array from '../../array/module.f.ts';
+import type * as Array from '../../array/module.f.ts';
 export type Index3 = Array.Index3;
 export type Index5 = Array.Index5;
 type Array2<T> = Array.Array2<T>;

package/types/function/compare/module.f.js

@@ -1,4 +1,3 @@
-import * as Array from "../../array/module.f.js";
 export const index3 = cmp => value => (cmp(value) + 1);
 export const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0);

package/types/function/compare/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { unsafeCmp } = _;
+import { unsafeCmp } from "./module.f.js";
 export default () => {
     const result = unsafeCmp(true)(false);
     if (result !== 1) {

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

@@ -24,5 +24,5 @@ type Fn<I, O> = {
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.
  */
-export declare const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
+export declare const fn: <I, O>(result: Func<I, O>) => Fn<I, O>;
 export {};

package/types/function/module.f.js

@@ -13,7 +13,7 @@ export const flip = f => b => a => f(a)(b);
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.
  */
-export const fn = result => ({
+export const fn = (result) => ({
     result,
     then: g => fn(compose(result)(g))
 });

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

@@ -1,4 +1,4 @@
-type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
 export type Fold<I, O> = Binary<I, O, O>;
 export declare const join: (separator: string) => Reduce<string>;
 export declare const concat: Reduce<string>;
@@ -11,10 +11,9 @@ export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
 export declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
 export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
 export type Reduce<T> = Fold<T, T>;
-export declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+export declare const reduceToScan: <T>(op: Reduce<T>) => Scan<T, T>;
 export declare const addition: Reduce<number>;
 export declare const min: Reduce<number>;
 export declare const max: Reduce<number>;
 export declare const increment: (b: number) => number;
 export declare const counter: () => (b: number) => number;
-export {};

package/types/function/operator/module.f.js

@@ -1,16 +1,16 @@
-export const join = separator => value => prior => `${prior}${separator}${value}`;
+export const join = (separator) => value => prior => `${prior}${separator}${value}`;
 export const concat = i => acc => `${acc}${i}`;
 export const logicalNot = v => !v;
-export const strictEqual = a => b => a === b;
-export const stateScanToScan = op => prior => i => {
+export const strictEqual = (a) => (b) => a === b;
+export const stateScanToScan = (op) => (prior) => i => {
     const [o, s] = op(prior)(i);
     return [o, stateScanToScan(op)(s)];
 };
-export const foldToScan = fold => prior => i => {
+export const foldToScan = (fold) => (prior) => i => {
     const result = fold(i)(prior);
     return [result, foldToScan(fold)(result)];
 };
-export const reduceToScan = op => init => [init, foldToScan(op)(init)];
+export const reduceToScan = (op) => init => [init, foldToScan(op)(init)];
 export const addition = a => b => a + b;
 export const min = a => b => a < b ? a : b;
 export const max = a => b => a > b ? a : b;

package/types/function/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { fn } = _;
+import { fn } from "./module.f.js";
 export default () => {
     const f = x => [x];
     const g = ([x]) => [x.length];

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

@@ -13,7 +13,7 @@ type Concat<T> = {
     readonly tail: List<T>;
 };
 export declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
-export declare const next: <T>(list: List<T>) => Result<T>;
+export declare const next: <T>(head: List<T>) => Result<T>;
 export declare const iterable: <T>(list: List<T>) => Iterable<T>;
 export declare const toArray: <T>(list: List<T>) => readonly T[];
 export declare const flat: <T>(list: List<List<T>>) => Thunk<T>;

package/types/list/module.f.js

@@ -1,17 +1,17 @@
 import { identity, fn, compose } from "../function/module.f.js";
 import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from "../function/operator/module.f.js";
-const fromArray = array => {
-    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
+const fromArray = (array) => {
+    const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
     return at(0);
 };
-export const concat = head => tail => tail === null ? head : ({ head, tail });
-const trampoline = list => {
+export const concat = (head) => (tail) => tail === null ? head : ({ head, tail });
+const trampoline = (list) => {
     while (typeof list === 'function') {
         list = list();
     }
     return list;
 };
-export const next = head => {
+export const next = (head) => {
     let tail = null;
     while (true) {
         head = trampoline(head);
@@ -31,7 +31,7 @@ export const next = head => {
         [head, tail] = [tail, null];
     }
 };
-export const iterable = list => ({
+export const iterable = (list) => ({
     *[Symbol.iterator]() {
         let i = list;
         while (true) {
@@ -45,11 +45,11 @@ export const iterable = list => ({
     }
 });
 const { from } = Array;
-export const toArray = list => {
+export const toArray = (list) => {
     const u = trampoline(list);
     return u instanceof Array ? u : from(iterable(u));
 };
-const apply = f => input => () => {
+const apply = (f) => (input) => () => {
     const n = next(input);
     if (n === null) {
         return null;
@@ -58,7 +58,7 @@ const apply = f => input => () => {
 };
 const flatStep = ({ first, tail }) => concat(first)(flat(tail));
 export const flat = apply(flatStep);
-const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) });
+const mapStep = (f) => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) });
 export const map = f => apply(mapStep(f));
 export const flatMap = f => compose(map(f))(flat);
 const filterStep = f => ({ first, tail }) => {

package/types/list/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../object/module.f.js";
-const { sort } = o;
-import * as operator from "../function/operator/module.f.js";
-const { addition, strictEqual, reduceToScan } = operator;
+import { sort } from "../object/module.f.js";
+import { addition, strictEqual, reduceToScan } from "../function/operator/module.f.js";
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence));
 const stringifyTest = () => {
     const s = stringify([1, 2, 3]);

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

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

package/types/map/module.f.js

@@ -1,18 +1,9 @@
-import * as BtreeTypes from "../btree/types/module.f.js";
-import * as btf from "../btree/find/module.f.js";
-const { value, find } = btf;
-import * as bts from "../btree/set/module.f.js";
-const { set } = bts;
-import * as btr from "../btree/remove/module.f.js";
-const { remove: btreeRemove } = btr;
-import * as bt from "../btree/module.f.js";
-const { values } = bt;
-import * as Compare from "../function/compare/module.f.js";
-import * as s from "../string/module.f.js";
-const { cmp } = s;
-import * as list from "../list/module.f.js";
-const { fold } = list;
-import * as Operator from "../function/operator/module.f.js";
+import { value, find } from "../btree/find/module.f.js";
+import { set } from "../btree/set/module.f.js";
+import { remove as btreeRemove } from "../btree/remove/module.f.js";
+import { values } from "../btree/module.f.js";
+import { cmp } from "../string/module.f.js";
+import { fold } from "../list/module.f.js";
 const keyCmp = a => ([b]) => cmp(a)(b);
 export const at = (name) => (map) => {
     if (map === null) {

package/types/map/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { at, setReplace, setReduce, empty, entries, remove } = _;
+import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
 import * as seq from "../list/module.f.js";
 export default {
     main: [