functionalscript 0.43.1 → 0.45.0

package/fjs/types/number/module.f.js

@@ -1,30 +0,0 @@
-/**
- * Numeric list reductions (`sum`, `min`, `max`), comparison via `cmp`, and
- * `countOnes` for 32-bit population count using SWAR.
- *
- * @module
- */
-import { reduce } from '../list/module.f.js';
-import { addition } from '../function/operator/module.f.js';
-import { cmp as uCmp, min as uMin, max as uMax } from '../function/compare/module.f.js';
-import { fold } from '../../common/monoid/module.f.js';
-export const sum = fold({ identity: 0, operation: addition });
-export const min = reduce(uMin)(null);
-export const max = reduce(uMax)(null);
-export const cmp = uCmp;
-const mo = [
-    [0x5555_5555, 1],
-    [0x3333_3333, 2],
-    [0x0F0F_0F0F, 4],
-    [0x00FF_00FF, 8],
-    [0x0000_FFFF, 16],
-];
-/**
- * Count a number of ones in 32 bit number
- */
-export const countOnes = (n) => {
-    for (const [mask, offset] of mo) {
-        n = (n & mask) + ((n >> offset) & mask);
-    }
-    return n;
-};

package/fjs/types/number/proof.f.js

@@ -1,124 +0,0 @@
-import { sum, min, max, cmp, countOnes } from './module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    sum: () => {
-        const result = sum([2, 3, 4, 5]);
-        assertEq(result, 14);
-    },
-    min: {
-        empty: () => {
-            const result = min([]);
-            assertEq(result, null);
-        },
-        multi: () => {
-            const result = min([1, 2, 12, -4, 8]);
-            assertEq(result, -4);
-        }
-    },
-    max: () => {
-        const result = max([1, 2, 12, -4, 8]);
-        assertEq(result, 12);
-    },
-    cmp: () => {
-        const result = cmp(4)(5);
-        assertEq(result, -1);
-    },
-    standard: () => {
-        const check = a => b => {
-            assertEq(BigInt(Number(a)), b, [a, b]);
-        };
-        const eq = v => check(v)(v);
-        // 53, 0x35 bits.
-        //        3                   2                   1                   0
-        //   4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210
-        eq(4503599627370496n);
-        eq(4503599627370497n);
-        eq(4503599627370498n);
-        eq(4503599627370499n);
-        eq(4503599627370500n);
-        //
-        eq(8205552883602248n);
-        eq(6023495077481713n);
-        eq(7655550916643882n);
-        eq(7408615831253283n);
-        eq(5372046171422892n);
-        //
-        eq(9007199254740991n);
-        eq(9007199254740990n);
-        eq(9007199254740989n);
-        eq(9007199254740988n);
-        eq(9007199254740987n);
-        eq(9007199254740986n);
-        eq(9007199254740985n);
-        eq(9007199254740984n);
-        // 54, 0x35+1 bits.
-        //           3                   2                   1                   0
-        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1
-        check(9007199254740992n)(9007199254740992n);
-        check(16585805050637558n)(16585805050637558n);
-        check(18014398509481982n)(18014398509481982n);
-        // round down
-        check(9007199254740993n)(9007199254740992n);
-        check(9007199254740997n)(9007199254740996n);
-        check(11727370849309157n)(11727370849309156n);
-        check(18014398509481981n)(18014398509481980n);
-        // round up
-        check(9007199254740995n)(9007199254740996n);
-        check(15679542343753527n)(15679542343753528n);
-        check(18014398509481983n)(18014398509481984n);
-        // 55, 0x35+2 bits.
-        //           3                   2                   1                   0
-        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_12
-        // 0_xx: down, down, up
-        // 0_00
-        check(18014398509481984n)(18014398509481984n);
-        check(31009640954244032n)(31009640954244032n);
-        check(36028797018963960n)(36028797018963960n);
-        // 0_01 round down
-        check(18014398509481985n)(18014398509481984n);
-        check(35865859090492321n)(35865859090492320n);
-        check(36028797018963961n)(36028797018963960n);
-        // 0_10 round down
-        check(18014398509481986n)(18014398509481984n);
-        check(20537830900813786n)(20537830900813784n);
-        check(36028797018963962n)(36028797018963960n);
-        // 0_11 round up
-        check(18014398509481987n)(18014398509481988n);
-        check(20762549594556867n)(20762549594556868n);
-        check(36028797018963963n)(36028797018963964n);
-        // 1_xx: down, up, up
-        // 1_00
-        check(18014398509481988n)(18014398509481988n);
-        check(27158415062912468n)(27158415062912468n);
-        check(36028797018963963n)(36028797018963964n);
-        // 1_01 round down
-        check(18014398509481989n)(18014398509481988n);
-        check(23136524663958789n)(23136524663958788n);
-        check(36028797018963965n)(36028797018963964n);
-        // 1_10 round up
-        check(18014398509481990n)(18014398509481992n);
-        check(35732739218314830n)(35732739218314832n);
-        check(36028797018963966n)(36028797018963968n);
-        // 1_11 round up
-        check(18014398509481991n)(18014398509481992n);
-        check(35015291789494295n)(35015291789494296n);
-        check(36028797018963967n)(36028797018963968n);
-        // 57, 0x35+4 bits.
-        //           3                   2                   1                   0
-        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1234
-        check(104002482718319358n)(104002482718319360n);
-        check(142693895881191444n)(142693895881191440n);
-    },
-    countOnes: [
-        () => {
-            //                    1121 2231 = 5 + 8 = 13
-            const r = countOnes(0x1234_5678);
-            assertEq(r, 13);
-        },
-        () => {
-            //                    2232 3340 = 9 + 10 = 19
-            const r = countOnes(0x9ABC_DEF0);
-            assertEq(r, 19);
-        }
-    ]
-};

package/fjs/types/object/module.f.d.ts

@@ -1,54 +0,0 @@
-import { type List } from '../list/module.f.ts';
-import { type Nullable } from '../nullable/module.f.ts';
-import { type OrderedMap } from '../ordered_map/module.f.ts';
-/** A record over the keys of `K`, each value possibly missing at runtime. */
-export type OptionalMap<K extends string, T> = {
-    readonly [k in K]?: T;
-};
-/**
- * A record over the keys of `K`, each value required.
- *
- * `K` has to be a finite union of string literals: `RequiredMap<string, T>` is
- * `never`, because no object can carry every string as a key. Use `StringMap<T>`
- * for an open key set — its values are optional, which is what such a key set
- * means at runtime.
- *
- * There is no known way to ask TypeScript whether `K` is finite, so the guard
- * approximates it with `string extends K`, which holds exactly when `K` is
- * `string`. Other infinite key sets are not caught: a template literal such as
- * `x-${string}` yields a template index signature instead of `never`, and its
- * reads are typed `T` while the runtime value is `undefined`. Keep `K` a union
- * of string literals.
- */
-export type RequiredMap<K extends string, T> = string extends K ? never : {
-    readonly [k in K]: T;
-};
-/** A record with an open key set. Every value can be missing at runtime. */
-export type StringMap<T> = OptionalMap<string, T>;
-export type Entry<T> = readonly [string, T];
-export declare const at: (name: string) => <T>(object: StringMap<T>) => Nullable<Exclude<T, undefined>>;
-export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
-export declare const fromEntries: <T>(e: List<Entry<T>>) => StringMap<T>;
-export declare const fromMap: <T>(m: OrderedMap<T>) => StringMap<T>;
-/**
- * A set of objects with a single key.
- *
- * See also
- * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
- */
-export type OneKey<K extends string, V> = {
-    [P in K]: (RequiredMap<P, V> & OptionalMap<Exclude<K, P>, never>) extends infer O ? {
-        [Q in keyof O]: O[Q];
-    } : never;
-}[K];
-/**
- * https://stackoverflow.com/questions/61112584/typing-a-single-record-entry
- */
-export type NotUnion<T, U = T> = T extends unknown ? [
-    U
-] extends [T] ? T : never : never;
-export type SingleProperty<T extends StringMap<never>> = keyof T extends NotUnion<keyof T> ? T : never;
-export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
-/** Returns only the defined (non-undefined) values of a partial record. */
-export declare const definedValues: <T>(map: StringMap<Exclude<T, undefined>>) => readonly Exclude<T, undefined>[];
-export declare const definedEntries: <T>(cmd: StringMap<Exclude<T, undefined>>) => readonly (readonly [string, Exclude<T, undefined>])[];

package/fjs/types/object/module.f.js

@@ -1,25 +0,0 @@
-/**
- * Plain-object helpers and types: the `OptionalMap`/`RequiredMap`/`StringMap`
- * record shapes and `Entry<T>`, safe property lookup via `at`, conversions
- * between entries and `OrderedMap`, and the `OneKey`/`SingleProperty`/`NotUnion`
- * utility types.
- *
- * @module
- */
-import { isArray } from '../array/module.f.js';
-import { iterable } from '../list/module.f.js';
-import { fromUndefined } from '../nullable/module.f.js';
-import { entries as mapEntries, fromEntries as mapFromEntries } from '../ordered_map/module.f.js';
-const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
-export const at = name => object => {
-    const d = getOwnPropertyDescriptor(object, name);
-    return d === undefined ? null : fromUndefined(d.value);
-};
-export const sort = e => mapEntries(mapFromEntries(e));
-export const fromEntries = e => objectFromEntries(iterable(e));
-export const fromMap = m => fromEntries(mapEntries(m));
-export const isObject = (value) => typeof value === 'object' && !isArray(value) && value !== null;
-const { values, entries } = Object;
-/** Returns only the defined (non-undefined) values of a partial record. */
-export const definedValues = (map) => values(map).filter(v => v !== undefined);
-export const definedEntries = (cmd) => entries(cmd).flatMap(([a, b]) => b === undefined ? [] : [[a, b]]);

package/fjs/types/object/proof.f.d.ts

@@ -1,4 +0,0 @@
-export declare const proof: {
-    ctor: () => void;
-    property: () => void;
-};

package/fjs/types/object/proof.f.js

@@ -1,14 +0,0 @@
-import { at } from './module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    ctor: () => {
-        const a = {};
-        const value = at('constructor')(a);
-        assertEq(value, null);
-    },
-    property: () => {
-        const a = { constructor: 42 };
-        const value = at('constructor')(a);
-        assertEq(value, 42);
-    }
-};

package/fjs/types/option/module.f.js

@@ -1,6 +0,0 @@
-/**
- * Optional tuple-based value representation.
- *
- * @module
- */
-export {};

package/fjs/types/ordered_map/module.f.d.ts

@@ -1,17 +0,0 @@
-/**
- * Ordered map operations with deterministic key traversal.
- *
- * @module
- */
-import type { Tree } from '../btree/types/module.f.ts';
-import { type List } from '../list/module.f.ts';
-import type { Reduce } from '../function/operator/module.f.ts';
-export type Entry<T> = readonly [string, T];
-export type OrderedMap<T> = Tree<Entry<T>>;
-export declare const at: (name: string) => <T>(map: OrderedMap<T>) => T | null;
-export declare const setReduce: <T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: OrderedMap<T>) => OrderedMap<T>;
-export declare const setReplace: (name: string) => <T>(value: T) => (map: OrderedMap<T>) => OrderedMap<T>;
-export declare const entries: <T>(map: OrderedMap<T>) => List<Entry<T>>;
-export declare const fromEntries: <T>(entries: List<Entry<T>>) => OrderedMap<T>;
-export declare const remove: (name: string) => <T>(map: OrderedMap<T>) => OrderedMap<T>;
-export declare const empty: null;

package/fjs/types/ordered_map/module.f.js

@@ -1,22 +0,0 @@
-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) {
-        return null;
-    }
-    const result = value(find(keyCmp(name))(map).first);
-    return result === null ? null : result[1];
-};
-const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])]);
-export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value]);
-const replace = () => b => b;
-export const setReplace = name => value => setReduceEntry(replace)([name, value]);
-export const entries = values;
-export const fromEntries = fold(setReduceEntry(replace))(null);
-export const remove = name => btreeRemove(keyCmp(name));
-export const empty = null;

package/fjs/types/ordered_map/proof.f.d.ts

@@ -1,5 +0,0 @@
-export declare const proof: {
-    main: (() => void)[];
-    fromEntries: () => void;
-    stress: () => void;
-};

package/fjs/types/ordered_map/proof.f.js

@@ -1,73 +0,0 @@
-import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from './module.f.js';
-import { toArray } from '../list/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    main: [
-        () => {
-            let m = setReplace('a')(1)(null);
-            assertEq(at('a')(m), 1);
-            assertEq(at('b')(m), null);
-            m = setReplace('b')(2)(m);
-            assertEq(at('a')(m), 1);
-            assertEq(at('b')(m), 2);
-            assertEq(at('c')(m), null);
-            m = setReplace('z')(3)(m);
-            assertEq(at('a')(m), 1);
-            assertEq(at('b')(m), 2);
-            assertEq(at('z')(m), 3);
-            assertEq(at('')(m), null);
-            m = setReplace('')(4)(m);
-            assertEq(at('a')(m), 1);
-            assertEq(at('b')(m), 2);
-            assertEq(at('z')(m), 3);
-            assertEq(at('')(m), 4);
-            assertEq(at('Hello world!')(m), null);
-            m = setReplace('Hello world!')(42)(m);
-            assertEq(at('a')(m), 1);
-            assertEq(at('b')(m), 2);
-            assertEq(at('z')(m), 3);
-            assertEq(at('')(m), 4);
-            assertEq(at('Hello world!')(m), 42);
-            assertEq(at('x')(m), null);
-            // console.log(Array.from(m.entries()))
-            m = remove('Hello world!')(m);
-            assertEq(at('Hello world!')(m), null);
-            m = setReduce((a) => (b) => a + b)('a')(43)(m);
-            assertEq(at('a')(m), 44);
-        },
-        () => {
-            let m = setReplace('x')(12)(null);
-            m = setReplace('y')(44)(m);
-            assertEq(at('x')(m), 12);
-            assertEq(at('y')(m), 44);
-            assertEq(at('a')(m), null);
-            const e = toArray(entries(m));
-            assertEq(e.length, 2);
-        },
-    ],
-    fromEntries: () => {
-        const list = [['a', 1], ['b', 2], ['c', 3]];
-        const m = fromEntries(list);
-        assertEq(at('a')(m), 1);
-        assertEq(at('b')(m), 2);
-        assertEq(at('c')(m), 3);
-        assertEq(at('d')(m), null);
-        // duplicate key: last one wins
-        const m2 = fromEntries([['x', 10], ['x', 20]]);
-        assertEq(at('x')(m2), 20);
-    },
-    stress: () => {
-        let m = empty;
-        for (let i = 0; i < 100_000; ++i) {
-            m = setReplace((i * i).toString())(i)(m);
-            /*
-            console.log()
-            console.log(`# ${i}`)
-            console.log()
-            for (const e of m.struct()) {
-                console.log(e)
-            }
-            */
-        }
-    }
-};

package/fjs/types/patricia_trie/module.f.d.ts

@@ -1,25 +0,0 @@
-/**
- * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
- *
- * @module
- */
-/** Merges two child identities into a parent. Values first, storage last in both params and return. */
-export type Create<S, T> = (a: T, b: T, storage: S) => readonly [T, S];
-/** A leaf entry: `[sortKey, identity]`. The sort key is used only for XOR comparisons. */
-export type Candidate<T> = readonly [bigint, T];
-export type InternalState<T> = readonly Candidate<T>[];
-/** Streaming state: `[storage, right-spine stack]`. */
-export type State<S, T> = readonly [S, InternalState<T>];
-export type PatriciaTrie<S, T> = {
-    /** Add one leaf. Merges any tightly-coupled stack candidates before pushing. */
-    readonly push: (c: Candidate<T>, state: State<S, T>) => State<S, T>;
-    /**
-     * Drain the stack right-to-left, returning the root identity and final storage.
-     * Returns `undefined` as the root if no leaves were pushed.
-     */
-    readonly end: (state: State<S, T>) => readonly [T | undefined, S];
-};
-/** Creates a Patricia trie whose node merging is delegated to `create`. */
-export declare const patriciaTrie: <S, T>(create: Create<S, T>) => PatriciaTrie<S, T>;
-/** Constructs the initial state from a storage value. */
-export declare const emptyState: <S>(storage: S) => readonly [S, readonly []];

package/fjs/types/patricia_trie/module.f.js

@@ -1,35 +0,0 @@
-/**
- * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
- *
- * @module
- */
-/** Creates a Patricia trie whose node merging is delegated to `create`. */
-export const patriciaTrie = (create) => ({
-    push: (c, [storage, stack]) => {
-        const [u] = c;
-        while (stack.length >= 2) {
-            const [rLeaf, rHash] = stack[stack.length - 1];
-            const [lLeaf, lHash] = stack[stack.length - 2];
-            if ((lLeaf ^ rLeaf) >= (rLeaf ^ u)) {
-                break;
-            }
-            const [h, newS] = create(lHash, rHash, storage);
-            storage = newS;
-            stack = [...stack.slice(0, -2), [rLeaf, h]];
-        }
-        return [storage, [...stack, c]];
-    },
-    end: ([storage, stack]) => {
-        if (stack.length === 0) {
-            return [undefined, storage];
-        }
-        let h = stack[stack.length - 1][1];
-        for (let i = stack.length - 2; i >= 0; i--) {
-            const lHash = stack[i][1];
-            [h, storage] = create(lHash, h, storage);
-        }
-        return [h, storage];
-    }
-});
-/** Constructs the initial state from a storage value. */
-export const emptyState = (storage) => [storage, []];

package/fjs/types/patricia_trie/proof.f.d.ts

@@ -1,13 +0,0 @@
-declare const empty: () => void;
-declare const singleLeaf: () => void;
-declare const twoLeaves: () => void;
-declare const descending: () => void;
-declare const ascending: () => void;
-export declare const proof: {
-    empty: typeof empty;
-    singleLeaf: typeof singleLeaf;
-    twoLeaves: typeof twoLeaves;
-    descending: typeof descending;
-    ascending: typeof ascending;
-};
-export {};

package/fjs/types/patricia_trie/proof.f.js

@@ -1,121 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { emptyState, patriciaTrie } from './module.f.js';
-const combine = (a, b) => a * 1000n + b;
-const create = (a, b, s) => {
-    const h = combine(a, b);
-    return [h, [...s, [a, b, h]]];
-};
-const { push, end } = patriciaTrie(create);
-const leaves = ([, candidates]) => candidates.map(([leaf]) => leaf);
-const runExample = (inputs, expectedLeaves, expectedNodeCounts) => {
-    let state = emptyState([]);
-    for (let i = 0; i < inputs.length; i++) {
-        const x = inputs[i];
-        const prevCount = state[0].length;
-        state = push([x, x], state);
-        const actual = leaves(state);
-        assertEq(actual.length, expectedLeaves[i].length);
-        for (let j = 0; j < actual.length; j++) {
-            assertEq(actual[j], expectedLeaves[i][j]);
-        }
-        const newNodes = state[0].slice(prevCount);
-        assertEq(newNodes.length, expectedNodeCounts[i]);
-        for (const [l, r, h] of newNodes) {
-            assertEq(h, combine(l, r));
-        }
-    }
-    const prevCount = state[0].length;
-    const [root, finalStorage] = end(state);
-    const finalNodes = finalStorage.slice(prevCount);
-    assertEq(finalNodes.length, expectedLeaves[expectedLeaves.length - 1].length - 1);
-    assert(root !== undefined);
-    for (const [l, r, h] of finalNodes) {
-        assertEq(h, combine(l, r));
-    }
-};
-const empty = () => {
-    const [root, storage] = end(emptyState([]));
-    assertEq(storage.length, 0);
-    assertEq(root, undefined);
-};
-const singleLeaf = () => {
-    const state = push([42n, 42n], emptyState([]));
-    assertEq(state[0].length, 0);
-    assertEq(leaves(state).length, 1);
-    assertEq(leaves(state)[0], 42n);
-    const [root, finalStorage] = end(state);
-    assertEq(finalStorage.length, 0);
-    assertEq(root, 42n);
-};
-const twoLeaves = () => {
-    const s1 = push([7n, 7n], emptyState([]));
-    const prevCount = s1[0].length;
-    const s2 = push([3n, 3n], s1);
-    assertEq(s2[0].slice(prevCount).length, 0);
-    assertEq(leaves(s2).length, 2);
-    const prevCount2 = s2[0].length;
-    const [root, finalStorage] = end(s2);
-    const finalNodes = finalStorage.slice(prevCount2);
-    assertEq(finalNodes.length, 1);
-    assertEq(finalNodes[0][0], 7n);
-    assertEq(finalNodes[0][1], 3n);
-    assertEq(finalNodes[0][2], combine(7n, 3n));
-    assertEq(root, combine(7n, 3n));
-};
-// example.md — descending
-// merges happen at: step 2 (1), 3 (1), 4 (1), 7 (2), 8 (2), A (1), C (2), F (1)
-const descending = () => runExample([
-    249n, 242n, 227n, 200n,
-    179n, 166n, 163n, 159n,
-    119n, 110n, 89n, 73n,
-    39n, 23n, 16n, 14n,
-], [
-    [249n],
-    [249n, 242n],
-    [242n, 227n],
-    [227n, 200n],
-    [200n, 179n],
-    [200n, 179n, 166n],
-    [200n, 179n, 166n, 163n],
-    [200n, 163n, 159n],
-    [159n, 119n],
-    [159n, 119n, 110n],
-    [159n, 110n, 89n],
-    [159n, 110n, 89n, 73n],
-    [159n, 73n, 39n],
-    [159n, 73n, 39n, 23n],
-    [159n, 73n, 39n, 23n, 16n],
-    [159n, 73n, 39n, 16n, 14n],
-], [0, 0, 1, 1, 1, 0, 0, 2, 2, 0, 1, 0, 2, 0, 0, 1]);
-// example.md — ascending (same values, reversed)
-// merges happen at: step 3 (2), 4 (1), 6 (1), 8 (3), B (1), C (2)
-const ascending = () => runExample([
-    14n, 16n, 23n, 39n,
-    73n, 89n, 110n, 119n,
-    159n, 163n, 166n, 179n,
-    200n, 227n, 242n, 249n,
-], [
-    [14n],
-    [14n, 16n],
-    [14n, 16n, 23n],
-    [23n, 39n],
-    [39n, 73n],
-    [39n, 73n, 89n],
-    [39n, 89n, 110n],
-    [39n, 89n, 110n, 119n],
-    [119n, 159n],
-    [119n, 159n, 163n],
-    [119n, 159n, 163n, 166n],
-    [119n, 159n, 166n, 179n],
-    [119n, 179n, 200n],
-    [119n, 179n, 200n, 227n],
-    [119n, 179n, 200n, 227n, 242n],
-    [119n, 179n, 200n, 227n, 242n, 249n],
-], [0, 0, 0, 2, 1, 0, 1, 0, 3, 0, 0, 1, 2, 0, 0, 0]);
-export const proof = {
-    empty,
-    singleLeaf,
-    twoLeaves,
-    descending,
-    ascending
-};

package/fjs/types/phantom/module.f.js

@@ -1,11 +0,0 @@
-/**
- * Phantom type — attaches a compile-time type annotation `T` to `S` with zero
- * runtime representation, analogous to Rust's `PhantomData<T>`.
- *
- * The phantom field uses a unique symbol key so it is excluded from string index
- * signatures (`{ readonly [K in string]: ... }`), making `Phantom<S, T>` valid
- * for any `S` regardless of its index signature constraints.
- *
- * @module
- */
-export {};

package/fjs/types/prime_field/module.f.d.ts

@@ -1,62 +0,0 @@
-/**
- * Prime field arithmetic over `bigint`: `prime_field(p)` builds a `PrimeField`
- * with negation, addition, subtraction, multiplication, division via modular
- * inverse, and exponentiation; `sqrt` returns a square-root function when
- * `p % 4 === 3`.
- *
- * @module
- */
-import type { Unary, Reduce } from '../bigint/module.f.ts';
-/**
- * A type representing a prime field and its associated operations.
- */
-export type PrimeField = {
-    readonly p: bigint;
-    readonly middle: bigint;
-    readonly max: bigint;
-    readonly neg: Unary;
-    readonly sub: Reduce;
-    readonly add: Reduce;
-    readonly abs: Unary;
-    readonly mul: Reduce;
-    readonly reciprocal: Unary;
-    readonly div: Reduce;
-    readonly pow: Reduce;
-    readonly pow2: Unary;
-    readonly pow3: Unary;
-    /** Reduces an arbitrary `bigint` into `[0, p)`. */
-    readonly reduce: Unary;
-    /**
-     * `true` when `x` is a square modulo `p`, including `0`.
-     *
-     * Nonzero values are tested with Euler's criterion:
-     * `x^((p - 1) / 2) === 1 (mod p)`.
-     * For `p === 2n`, both field elements are squares.
-     */
-    readonly quadRes: (x: bigint) => boolean;
-};
-/**
- * Creates a prime field with the specified prime modulus and associated operations.
- *
- * @param p - A prime number to define the field.
- * @returns The prime field object.
- */
-export declare const prime_field: (p: bigint) => PrimeField;
-/**
- * Computes the square root of a number in a prime field.
- *
- * @throws If the prime modulus `p` does not satisfy `p % 4 == 3`.
- *
- * @example
- *
- * ```js
- * const field = prime_field(7n);
- * const root = sqrt(field)(4n);
- * if (root !== 2n) { throw root }
- * ```
- */
-export declare const sqrt: ({ p, pow, pow2 }: PrimeField) => (a: bigint) => bigint | null;
-/**
- * Modular square root mod `p` (`p ≡ 3 (mod 4)`); uses {@link PrimeField.neg} when `x` is not a residue.
- */
-export declare const modSqrt: (field: PrimeField) => Unary;