functionalscript 0.44.0 → 0.45.0

package/fjs/types/function/operator/module.f.mjs

@@ -2,10 +2,10 @@
  * Common higher-order operator type aliases.
  *
  * @module
+ *
+ * @import { Fold, Reduce, Scan, StateScan, Unary } from './types.ts'
  */
 
-/** @import { Fold, Reduce, Scan, StateScan, Unary } from './types.ts' */
-
 /** @type {(separator: string) => Reduce<string>} */
 export const join = separator => value => prior =>
     `${prior}${separator}${value}`

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

@@ -1,8 +1,15 @@
+/**
+ * Immutable list data structure utilities and combinators.
+ *
+ * @module
+ *
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import {Scan, StateScan, Fold, Reduce, Equal} from '../function/operator/types.ts'
+ * @import { Accumulator, Concat, Entry, List, NonEmpty, NotLazy, Result, Thunk } from './types.ts'
+ */
 import type { Nullable } from '../nullable/types.ts';
 import type { Scan, StateScan, Fold, Reduce, Equal } from '../function/operator/types.ts';
 import type { Accumulator, Entry, List, Result, Thunk } from './types.ts';
-/** @import {Scan, StateScan, Fold, Reduce, Equal} from '../function/operator/types.ts' */
-/** @import { Accumulator, Concat, Entry, List, NonEmpty, NotLazy, Result, Thunk } from './types.ts' */
 export declare const fromArrayLike: <T>(
 /**
  * @template T

package/fjs/types/list/module.f.mjs

@@ -2,9 +2,13 @@
  * Immutable list data structure utilities and combinators.
  *
  * @module
+ *
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import {Scan, StateScan, Fold, Reduce, Equal} from '../function/operator/types.ts'
+ * @import { Accumulator, Concat, Entry, List, NonEmpty, NotLazy, Result, Thunk } from './types.ts'
  */
+
 import { identity, fn, compose } from '../function/module.f.mjs'
-/** @import { Nullable } from '../nullable/types.ts' */
 import {
     addition,
     logicalNot,
@@ -13,8 +17,6 @@ import {
     foldToScan,
     reduceToScan,
 } from '../function/operator/module.f.mjs'
-/** @import {Scan, StateScan, Fold, Reduce, Equal} from '../function/operator/types.ts' */
-/** @import { Accumulator, Concat, Entry, List, NonEmpty, NotLazy, Result, Thunk } from './types.ts' */
 
 export const fromArrayLike =
     /**

package/fjs/types/list/proof.f.d.mts

@@ -1,4 +1,7 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { List } from './types.ts'
+ */
 declare const stringifyTest: () => void;
 declare const countdownTest: () => void;
 declare const flatTest: () => void;

package/fjs/types/list/proof.f.mjs

@@ -1,6 +1,8 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ * @import { List } from './types.ts'
+ */
 
-/** @import { List } from './types.ts' */
 import { length, concat, countdown, cycle, drop, dropWhile, entries, every, filter, find, flat, flatMap, map, next, reduce, reverse, scan, some, take, takeWhile, toArray, zip, first, filterMap, isEmpty, equal, tryFold } from './module.f.mjs'
 import { stringify } from '../../media/json/module.f.mjs'
 import { sort } from '../object/module.f.mjs'

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

@@ -13,9 +13,10 @@
  * `ByteSet` is a `bigint`, which `JSON.stringify` cannot serialize.
  *
  * @module
+ *
+ * @import { Nibble, NibbleSet } from './types.ts'
  */
 import type { Nibble, NibbleSet } from './types.ts';
-/** @import { Nibble, NibbleSet } from './types.ts' */
 export declare const empty = 0;
 export declare const universe = 65535;
 /** @type {(n: Nibble) => (s: NibbleSet) => boolean} */

package/fjs/types/nibble_set/module.f.mjs

@@ -13,10 +13,10 @@
  * `ByteSet` is a `bigint`, which `JSON.stringify` cannot serialize.
  *
  * @module
+ *
+ * @import { Nibble, NibbleSet } from './types.ts'
  */
 
-/** @import { Nibble, NibbleSet } from './types.ts' */
-
 export const empty = 0
 
 export const universe = 0xFFFF

package/fjs/types/nominal/module.f.d.mts

@@ -2,8 +2,9 @@
  * Nominal typing helpers for branded TypeScript types.
  *
  * @module
+ *
+ * @import { Nominal } from './types.ts'
  */
 import type { Nominal } from './types.ts';
-/** @import { Nominal } from './types.ts' */
 export declare const asNominal: <N extends string, R extends string, B>(b: B) => Nominal<N, R, B>;
 export declare const asBase: <T extends string, R extends string, B>(n: Nominal<T, R, B>) => B;

package/fjs/types/nominal/module.f.mjs

@@ -2,10 +2,11 @@
  * Nominal typing helpers for branded TypeScript types.
  *
  * @module
+ *
+ * @import { Nominal } from './types.ts'
  */
 
 import { identity } from "../function/module.f.mjs"
-/** @import { Nominal } from './types.ts' */
 
 export const asNominal =
     /** @type {<N extends string, R extends string, B>(b: B) => Nominal<N, R, B>} */

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

@@ -1,7 +1,13 @@
+/**
+ * Utilities for nullable (`null`/`undefined`) value handling.
+ *
+ * @module
+ *
+ * @import { Option } from '../option/types.ts'
+ * @import { Nullable } from './types.ts'
+ */
 import type { Option } from '../option/types.ts';
 import type { Nullable } from './types.ts';
-/** @import { Option } from '../option/types.ts' */
-/** @import { Nullable } from './types.ts' */
 /**
  * @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>}
  */

package/fjs/types/nullable/module.f.mjs

@@ -2,11 +2,13 @@
  * Utilities for nullable (`null`/`undefined`) value handling.
  *
  * @module
+ *
+ * @import { Option } from '../option/types.ts'
+ * @import { Nullable } from './types.ts'
  */
+
 import { assert } from '../../asserts/module.f.mjs'
 import { fn } from '../function/module.f.mjs'
-/** @import { Option } from '../option/types.ts' */
-/** @import { Nullable } from './types.ts' */
 
 /**
  * @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>}

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

@@ -3,6 +3,10 @@
  * `countOnes` for 32-bit population count using SWAR.
  *
  * @module
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Sign } from '../function/compare/types.ts';

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

@@ -3,14 +3,15 @@
  * `countOnes` for 32-bit population count using SWAR.
  *
  * @module
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
  */
 
 import { reduce } from '../list/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { addition } from '../function/operator/module.f.mjs'
-/** @import { Reduce } from '../function/operator/types.ts' */
 import { cmp as uCmp, min as uMin, max as uMax } from '../function/compare/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
 import { fold } from '../../common/monoid/module.f.mjs'
 
 /** @type {(input: List<number>) => number} */

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

@@ -1,15 +1,27 @@
 /**
- * Plain-object helpers: safe property lookup via `at`, and conversions
- * between entries and `OrderedMap`. See `./types.ts` for the
+ * Plain-object helpers: safe property lookup via `at`, structural comparison
+ * via `structurallySame`, and conversions between entries and `OrderedMap`.
+ * See `./types.ts` for the
  * `OptionalMap`/`RequiredMap`/`StringMap`/`Entry`/`OneKey`/`SingleProperty`/
  * `NotUnion` type-level API.
  *
  * @module
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { OrderedMap } from '../ordered_map/types.ts'
+ * @import { StringMap, Entry } from './types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Nullable } from '../nullable/types.ts';
 import type { OrderedMap } from '../ordered_map/types.ts';
 import type { StringMap, Entry } from './types.ts';
+/**
+ * `structurallySame` is implemented in a dependency-free leaf so `fjs/asserts`
+ * can use it without the cycle `asserts -> object -> nullable -> asserts`; see
+ * `./structurally_same/README.md`. This module is its public home.
+ */
+export { structurallySame } from './structurally_same/module.f.mjs';
 /** @type {(name: string) => <T>(object: StringMap<T>) => Nullable<Exclude<T, undefined>>} */
 export declare const at: (name: string) => <T>(object: StringMap<T>) => Nullable<Exclude<T, undefined>>;
 /** @type {<T>(e: List<Entry<T>>) => List<Entry<T>>} */

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

@@ -1,20 +1,29 @@
 /**
- * Plain-object helpers: safe property lookup via `at`, and conversions
- * between entries and `OrderedMap`. See `./types.ts` for the
+ * Plain-object helpers: safe property lookup via `at`, structural comparison
+ * via `structurallySame`, and conversions between entries and `OrderedMap`.
+ * See `./types.ts` for the
  * `OptionalMap`/`RequiredMap`/`StringMap`/`Entry`/`OneKey`/`SingleProperty`/
  * `NotUnion` type-level API.
  *
  * @module
+ *
+ * @import { List } from '../list/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { OrderedMap } from '../ordered_map/types.ts'
+ * @import { StringMap, Entry } from './types.ts'
  */
 
 import { isArray } from '../array/module.f.mjs'
 import { iterable } from '../list/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { fromUndefined } from '../nullable/module.f.mjs'
-/** @import { Nullable } from '../nullable/types.ts' */
 import { entries as mapEntries, fromEntries as mapFromEntries } from '../ordered_map/module.f.mjs'
-/** @import { OrderedMap } from '../ordered_map/types.ts' */
-/** @import { StringMap, Entry } from './types.ts' */
+
+/**
+ * `structurallySame` is implemented in a dependency-free leaf so `fjs/asserts`
+ * can use it without the cycle `asserts -> object -> nullable -> asserts`; see
+ * `./structurally_same/README.md`. This module is its public home.
+ */
+export { structurallySame } from './structurally_same/module.f.mjs'
 
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
 

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

@@ -1,3 +1,8 @@
+/**
+ * @import { OptionalMap, RequiredMap, StringMap } from './types.ts'
+ * @import { Assert } from '../../asserts/types.ts'
+ * @import { Equal } from '../ts/types.ts'
+ */
 import type { OptionalMap, RequiredMap, StringMap } from './types.ts';
 import type { Assert } from '../../asserts/types.ts';
 import type { Equal } from '../ts/types.ts';
@@ -13,8 +18,6 @@ export type _RequiredIsRequired = Assert<Equal<RequiredMap<'a' | 'b', bigint>, {
     readonly b: bigint;
 }>>;
 export type _RequiredOverAnyStringIsNever = Assert<Equal<RequiredMap<string, bigint>, never>>;
-/** @import { Assert } from '../../asserts/types.ts' */
-/** @import { Equal } from '../ts/types.ts' */
 /** @typedef {Assert<Equal<StringMap<bigint>, { readonly [k in string]?: bigint }>>} _StringMapIsOptional */
 /** @typedef {Assert<Equal<OptionalMap<'a'|'b', bigint>, { readonly a?: bigint; readonly b?: bigint }>>} _OptionalIsPartial */
 /** @typedef {Assert<Equal<RequiredMap<'a'|'b', bigint>, { readonly a: bigint; readonly b: bigint }>>} _RequiredIsRequired */

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

@@ -1,8 +1,11 @@
+/**
+ * @import { OptionalMap, RequiredMap, StringMap } from './types.ts'
+ * @import { Assert } from '../../asserts/types.ts'
+ * @import { Equal } from '../ts/types.ts'
+ */
+
 import { at } from './module.f.mjs'
-/** @import { OptionalMap, RequiredMap, StringMap } from './types.ts' */
 import { assertEq } from '../../asserts/module.f.mjs'
-/** @import { Assert } from '../../asserts/types.ts' */
-/** @import { Equal } from '../ts/types.ts' */
 
 /** @typedef {Assert<Equal<StringMap<bigint>, { readonly [k in string]?: bigint }>>} _StringMapIsOptional */
 

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

@@ -0,0 +1,39 @@
+/**
+ * Structural comparison for FunctionalScript data.
+ *
+ * `structurallySame` answers "do these two independently constructed values
+ * have the same shape and the same leaves?" — the question proofs really ask
+ * when they compare a computed value against an expected one. It is scoped to
+ * FunctionalScript data (primitives, arrays, and record-like objects) and
+ * deliberately says nothing about dates, maps, sets, typed arrays, prototypes,
+ * or property descriptors; see the README for what it does *not* promise.
+ *
+ * This module is a dependency-free leaf on purpose. `fjs/asserts` needs the
+ * comparison for `assertStructurallySame`, and the public object module
+ * (`../module.f.mjs`) reaches `fjs/asserts` through `types/nullable`, so
+ * importing anything here would close the cycle
+ * `asserts -> object -> nullable -> asserts`. Keep it importing nothing.
+ *
+ * @module
+ */
+/**
+ * Compares two values structurally.
+ *
+ * - `Object.is` decides first, so `NaN` equals itself, `0` and `-0` differ, and
+ *   an object is trivially the same as itself.
+ * - Anything else that is not a non-null object differs.
+ * - Arrays match arrays of the same length whose elements match pairwise; an
+ *   array never matches a non-array. Arrays are assumed dense — FunctionalScript
+ *   cannot build a sparse one; see the README.
+ * - Other objects match when their own enumerable string properties form the
+ *   same set — order is irrelevant — and every property's value matches. A
+ *   property whose value is `undefined` is a property: `{ a: undefined }` and
+ *   `{}` differ.
+ *
+ * There is no cycle detection: a self-referential value recurses until the
+ * stack runs out. FunctionalScript data is acyclic, and adding a seen-set would
+ * cost every ordinary comparison for a case that cannot arise.
+ *
+ * @type {(a: unknown, b: unknown) => boolean}
+ */
+export declare const structurallySame: (a: unknown, b: unknown) => boolean;

package/fjs/types/object/structurally_same/module.f.mjs

@@ -0,0 +1,59 @@
+/**
+ * Structural comparison for FunctionalScript data.
+ *
+ * `structurallySame` answers "do these two independently constructed values
+ * have the same shape and the same leaves?" — the question proofs really ask
+ * when they compare a computed value against an expected one. It is scoped to
+ * FunctionalScript data (primitives, arrays, and record-like objects) and
+ * deliberately says nothing about dates, maps, sets, typed arrays, prototypes,
+ * or property descriptors; see the README for what it does *not* promise.
+ *
+ * This module is a dependency-free leaf on purpose. `fjs/asserts` needs the
+ * comparison for `assertStructurallySame`, and the public object module
+ * (`../module.f.mjs`) reaches `fjs/asserts` through `types/nullable`, so
+ * importing anything here would close the cycle
+ * `asserts -> object -> nullable -> asserts`. Keep it importing nothing.
+ *
+ * @module
+ */
+
+const { entries, is } = Object
+
+/**
+ * Compares two values structurally.
+ *
+ * - `Object.is` decides first, so `NaN` equals itself, `0` and `-0` differ, and
+ *   an object is trivially the same as itself.
+ * - Anything else that is not a non-null object differs.
+ * - Arrays match arrays of the same length whose elements match pairwise; an
+ *   array never matches a non-array. Arrays are assumed dense — FunctionalScript
+ *   cannot build a sparse one; see the README.
+ * - Other objects match when their own enumerable string properties form the
+ *   same set — order is irrelevant — and every property's value matches. A
+ *   property whose value is `undefined` is a property: `{ a: undefined }` and
+ *   `{}` differ.
+ *
+ * There is no cycle detection: a self-referential value recurses until the
+ * stack runs out. FunctionalScript data is acyclic, and adding a seen-set would
+ * cost every ordinary comparison for a case that cannot arise.
+ *
+ * @type {(a: unknown, b: unknown) => boolean}
+ */
+export const structurallySame = (a, b) => {
+    if (is(a, b)) { return true }
+    if (
+        typeof a !== 'object' || a === null ||
+        typeof b !== 'object' || b === null
+    ) { return false }
+    if (a instanceof Array) {
+        return b instanceof Array
+            && a.length === b.length
+            && a.every((v, i) => structurallySame(v, b[i]))
+    }
+    if (b instanceof Array) { return false }
+    const ae = entries(a)
+    /** @type {ReadonlyMap<string, unknown>} */
+    const bm = new Map(entries(b))
+    return ae.length === bm.size
+        && ae.every(([k, v]) => bm.has(k) && structurallySame(v, bm.get(k)))
+}

package/fjs/types/object/structurally_same/proof.f.d.mts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    primitives: (() => void)[];
+    identity: (() => void)[];
+    arrays: (() => void)[];
+    objects: (() => void)[];
+};

package/fjs/types/object/structurally_same/proof.f.mjs

@@ -0,0 +1,73 @@
+import { assert } from '../../../asserts/module.f.mjs'
+import { structurallySame } from './module.f.mjs'
+
+/** @type {(a: unknown, b: unknown) => void} */
+const same = (a, b) => assert(structurallySame(a, b), ['same', a, b])
+
+/** @type {(a: unknown, b: unknown) => void} */
+const differ = (a, b) => assert(!structurallySame(a, b), ['differ', a, b])
+
+export const proof = {
+    primitives: [
+        // `Object.is` decides, so `NaN` is its own equal...
+        () => same(Number.NaN, Number.NaN),
+        () => same(42, 42),
+        () => same('a', 'a'),
+        () => same(undefined, undefined),
+        () => same(null, null),
+        // ...and the two zeros are not.
+        () => differ(0, -0),
+        () => differ(1, 2),
+        () => differ('a', 'b'),
+        () => differ(null, undefined),
+        // a non-object on either side ends it
+        () => differ(1, {}),
+        () => differ({}, 1),
+        () => differ(null, {}),
+        () => differ({}, null),
+    ],
+    identity: [
+        // the same reference short-circuits before any traversal
+        () => {
+            const a = /** @type {const} */ ({ x: [1, 2] })
+            same(a, a)
+        },
+    ],
+    arrays: [
+        () => same([], []),
+        () => same([1, { a: 2 }], [1, { a: 2 }]),
+        // length first, then elementwise
+        () => differ([1], [1, 2]),
+        () => differ([1, 2], [2, 1]),
+        // an array is never the same as a non-array, in either position.
+        // `differ([], {})` alone does not pin this: it already fails on
+        // `0 === undefined`, so only an array-like with a matching `length`
+        // reaches the `b instanceof Array` check.
+        () => differ([], {}),
+        () => differ({}, []),
+        () => differ([1, 2], { 0: 1, 1: 2, length: 2 }),
+        // an explicitly `undefined` element is an ordinary element, so it
+        // counts towards the length
+        () => same([undefined], [undefined]),
+        () => differ([undefined], [1]),
+        () => differ([undefined], []),
+    ],
+    objects: [
+        () => same({}, {}),
+        // property order is not part of the structure
+        () => same({ a: 1, b: { c: 2 } }, { b: { c: 2 }, a: 1 }),
+        // same count, different names. The first is settled by the values
+        // (`1` vs `undefined`); only the second — disjoint names *and*
+        // `undefined` on both sides — pins the key-set check itself.
+        () => differ({ a: 1 }, { b: 1 }),
+        () => differ({ a: undefined }, { b: undefined }),
+        // same names, different values
+        () => differ({ a: 1 }, { a: 2 }),
+        () => differ({ a: { b: 1 } }, { a: { b: 2 } }),
+        // different counts
+        () => differ({ a: 1 }, { a: 1, b: 2 }),
+        // an `undefined`-valued property is still a property
+        () => differ({ a: undefined }, {}),
+        () => differ({}, { a: undefined }),
+    ],
+}

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

@@ -2,6 +2,11 @@
  * Ordered map operations with deterministic key traversal.
  *
  * @module
+ *
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
+ * @import { Entry, OrderedMap } from './types.ts'
  */
 import type { List } from '../list/types.ts';
 import type { Reduce } from '../function/operator/types.ts';

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

@@ -2,18 +2,19 @@
  * Ordered map operations with deterministic key traversal.
  *
  * @module
+ *
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce } from '../function/operator/types.ts'
+ * @import { Entry, OrderedMap } from './types.ts'
  */
 
 import { value, find } from '../btree/find/module.f.mjs'
 import { set } from '../btree/set/module.f.mjs'
 import { remove as btreeRemove } from '../btree/remove/module.f.mjs'
 import { values } from '../btree/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
 import { cmp } from '../string/module.f.mjs'
-/** @import { List } from '../list/types.ts' */
 import { fold } from '../list/module.f.mjs'
-/** @import { Reduce } from '../function/operator/types.ts' */
-/** @import { Entry, OrderedMap } from './types.ts' */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
 const keyCmp = a => ([b]) => cmp(a)(b)

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

@@ -1,3 +1,6 @@
+/**
+ * @import { OrderedMap } from './types.ts'
+ */
 export declare const proof: {
     main: (() => void)[];
     fromEntries: () => void;

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

@@ -1,5 +1,8 @@
+/**
+ * @import { OrderedMap } from './types.ts'
+ */
+
 import { at, setReplace, setReduce, empty, entries, remove, fromEntries } from './module.f.mjs'
-/** @import { OrderedMap } from './types.ts' */
 import { toArray } from '../list/module.f.mjs'
 import { assertEq } from '../../asserts/module.f.mjs'
 

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

@@ -2,9 +2,10 @@
  * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
  *
  * @module
+ *
+ * @import { Candidate, Create, PatriciaTrie } from './types.ts'
  */
 import type { Create, PatriciaTrie } from './types.ts';
-/** @import { Candidate, Create, PatriciaTrie } from './types.ts' */
 /**
  * Creates a Patricia trie whose node merging is delegated to `create`.
  *

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

@@ -2,10 +2,10 @@
  * Streaming Patricia trie for building content-addressed binary trees from sorted leaf sequences.
  *
  * @module
+ *
+ * @import { Candidate, Create, PatriciaTrie } from './types.ts'
  */
 
-/** @import { Candidate, Create, PatriciaTrie } from './types.ts' */
-
 /**
  * Creates a Patricia trie whose node merging is delegated to `create`.
  *

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

@@ -1,3 +1,6 @@
+/**
+ * @import { State } from './types.ts'
+ */
 export type _NodeList = readonly [bigint, bigint, bigint][];
 declare const empty: () => void;
 declare const singleLeaf: () => void;

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

@@ -1,6 +1,9 @@
+/**
+ * @import { State } from './types.ts'
+ */
+
 import { assert, assertEq } from '../../asserts/module.f.mjs'
 import { emptyState, patriciaTrie } from './module.f.mjs'
-/** @import { State } from './types.ts' */
 
 /** @typedef {readonly [bigint, bigint, bigint][]} _NodeList */
 

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

@@ -5,10 +5,12 @@
  * `p % 4 === 3`.
  *
  * @module
+ *
+ * @import { Reduce, Unary } from '../bigint/types.ts'
+ * @import { PrimeField } from './types.ts'
  */
 import type { Unary } from '../bigint/types.ts';
 import type { PrimeField } from './types.ts';
-/** @import { PrimeField } from './types.ts' */
 /**
  * Creates a prime field with the specified prime modulus and associated operations.
  *

package/fjs/types/prime_field/module.f.mjs

@@ -5,12 +5,13 @@
  * `p % 4 === 3`.
  *
  * @module
+ *
+ * @import { Reduce, Unary } from '../bigint/types.ts'
+ * @import { PrimeField } from './types.ts'
  */
 
-/** @import { Reduce, Unary } from '../bigint/types.ts' */
 import { repeat } from '../../common/monoid/module.f.mjs'
 import { assertNotNullish } from '../../asserts/module.f.mjs'
-/** @import { PrimeField } from './types.ts' */
 
 /**
  * Creates a prime field with the specified prime modulus and associated operations.

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

@@ -2,9 +2,10 @@
  * Range and interval utilities for numeric boundaries.
  *
  * @module
+ *
+ * @import { Range } from './types.ts'
  */
 import type { Range } from './types.ts';
-/** @import { Range } from './types.ts' */
 /** @type {(...range: Range) => (i: number) => boolean} */
 export declare const contains: (...range: Range) => (i: number) => boolean;
 /** @type {(i: number) => Range} */

package/fjs/types/range/module.f.mjs

@@ -2,10 +2,10 @@
  * Range and interval utilities for numeric boundaries.
  *
  * @module
+ *
+ * @import { Range } from './types.ts'
  */
 
-/** @import { Range } from './types.ts' */
-
 /** @type {(...range: Range) => (i: number) => boolean} */
 export const contains = (b, e) => i => b <= i && i <= e