functionalscript 0.36.0 → 0.38.0

package/README.md

@@ -60,7 +60,7 @@ The CAS is also exposed as an [MCP](https://modelcontextprotocol.io/) server so
 claude mcp add cas -- npx functionalscript m
 ```
 
-See [`fs/cas/mcp/README.md`](fs/cas/mcp/README.md) for details on the `cas_add`, `cas_get`, and `cas_list` tools.
+See [`fjs/cas/mcp/README.md`](fjs/cas/mcp/README.md) for details on the `cas_add`, `cas_get`, and `cas_list` tools.
 
 ## Vision
 

package/{fs → fjs}/asn.1/module.f.js

@@ -8,7 +8,7 @@ import { bitLength, divUp8 } from "../types/bigint/module.f.js";
 import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { identity } from "../types/function/module.f.js";
 import { max } from "../types/function/compare/module.f.js";
-import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
+import { encode as b128encode, decode as b128decode } from "../basen/base128/module.f.js";
 const { popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
 const classPcMask = 224n;

package/{fs → fjs}/asn.1/proof.f.js

@@ -1,7 +1,7 @@
 import { empty, isVec, length, msb, uint, unpack, vec, vec8 } from "../types/bit_vec/module.f.js";
 import { asBase } from "../types/nominal/module.f.js";
 import { decodeRaw, decodeInteger, encodeRaw, encodeInteger, integer, encode, decode, constructedSequence, octetString, boolean, constructedSet, encodeObjectIdentifier, decodeObjectIdentifier, } from "./module.f.js";
-import { assertEq } from "../asserts/module.f.js";
+import { assert, assertEq } from '../asserts/module.f.js';
 const { concat, popFront: pop, listToVec } = msb;
 const pop8 = pop(8n);
 const check = (tag, v, rest) => {
@@ -23,9 +23,7 @@ const integerValueCheck = (i, v) => {
         throw `encode: ${asBase(v)}, ${asBase(v0)}`;
     }
     const i0 = decodeInteger(v);
-    if (i !== i0) {
-        throw [i, i0];
-    }
+    assertEq(i, i0, [i, i0]);
 };
 const ch0 = (r, v, rest) => {
     const [r0, rest0] = decode(concat(v)(rest));
@@ -51,24 +49,14 @@ export const proof = {
         const v = vec8(0x13n);
         const x = encodeRaw([integer, v]);
         const lx = length(x);
-        if (lx !== 24n) {
-            throw lx;
-        }
+        assertEq(lx, 24n);
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [len, x2] = pop8(x1);
-        if (len !== 1n) {
-            throw len;
-        }
+        assertEq(len, 1n);
         const { length: intLen, uint } = unpack(x2);
-        if (intLen !== 8n) {
-            throw intLen;
-        }
-        if (uint !== 0x13n) {
-            throw uint;
-        }
+        assertEq(intLen, 8n);
+        assertEq(uint, 0x13n);
     },
     encode7F: () => {
         const valueLen = 0x7fn << 3n;
@@ -76,24 +64,14 @@ export const proof = {
         const v = vec(valueLen)(value);
         const x = encodeRaw([integer, v]);
         const lx = length(x);
-        if (lx !== 0x81n << 3n) {
-            throw lx;
-        }
+        assertEq(lx, 0x81n << 3n);
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [len, x2] = pop8(x1);
-        if (len !== 0x7fn) {
-            throw len;
-        }
+        assertEq(len, 0x7fn);
         const { length: intLen, uint } = unpack(x2);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     encode80: () => {
         const valueLen = 0x80n << 3n;
@@ -101,28 +79,16 @@ export const proof = {
         const v = vec(valueLen)(value);
         const x = encodeRaw([integer, v]);
         const lx = length(x);
-        if (lx !== 0x83n << 3n) {
-            throw lx;
-        }
+        assertEq(lx, 0x83n << 3n);
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [lenLen, x2] = pop8(x1);
-        if (lenLen !== 0x81n) {
-            throw lenLen;
-        }
+        assertEq(lenLen, 0x81n);
         const [len, x3] = pop8(x2);
-        if (len !== 0x80n) {
-            throw len;
-        }
+        assertEq(len, 0x80n);
         const { length: intLen, uint } = unpack(x3);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     encodeFF: () => {
         const valueLen = 0xffn << 3n;
@@ -134,24 +100,14 @@ export const proof = {
             throw `lx: ${lx}`;
         }
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [lenLen, x2] = pop8(x1);
-        if (lenLen !== 0x81n) {
-            throw lenLen;
-        }
+        assertEq(lenLen, 0x81n);
         const [len, x3] = pop8(x2);
-        if (len !== 0xffn) {
-            throw len;
-        }
+        assertEq(len, 0xffn);
         const { length: intLen, uint } = unpack(x3);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     encode103: () => {
         const valueLen = 0x103n << 3n;
@@ -163,32 +119,20 @@ export const proof = {
             throw `lx: ${lx}`;
         }
         const [tag, x1] = pop8(x);
-        if (tag !== BigInt(integer)) {
-            throw tag;
-        }
+        assertEq(tag, BigInt(integer));
         const [lenLen, x2] = pop8(x1);
-        if (lenLen !== 0x82n) {
-            throw lenLen;
-        }
+        assertEq(lenLen, 0x82n);
         const [len, x3] = pop(16n)(x2);
-        if (len !== 0x103n) {
-            throw len;
-        }
+        assertEq(len, 0x103n);
         const { length: intLen, uint } = unpack(x3);
-        if (intLen !== valueLen) {
-            throw intLen;
-        }
-        if (uint !== value) {
-            throw uint;
-        }
+        assertEq(intLen, valueLen);
+        assertEq(uint, value);
     },
     ed: [
         () => {
             const tag = integer;
             const v = vec(0x10n)(0x8234n);
-            if (asBase(v) !== 0x8234n) {
-                throw asBase(v).toString(16);
-            }
+            assertEq(asBase(v), 0x8234n, asBase(v).toString(16));
             check(integer, v, empty);
         },
         {
@@ -297,16 +241,10 @@ export const proof = {
         // bitString (0x03) is not in SupportedRecord, exercises the default case in rawToRecord
         const raw = encodeRaw([0x03n, vec8(0x42n)]);
         const [decoded, rest] = decode(raw);
-        if (!isVec(decoded)) {
-            throw 'expected UnsupportedRecord (Vec)';
-        }
-        if (rest !== empty) {
-            throw 'expected empty rest';
-        }
+        assert(isVec(decoded), 'expected UnsupportedRecord (Vec)');
+        assertEq(rest, empty, 'expected empty rest');
         // Re-encoding an UnsupportedRecord returns it unchanged (it is already the TLV bytes)
-        if (encode(decoded) !== raw) {
-            throw 'encode should round-trip UnsupportedRecord';
-        }
+        assertEq(encode(decoded), raw, 'encode should round-trip UnsupportedRecord');
     },
     raw: [
         () => {

package/fjs/asserts/module.f.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Assertion helpers for runtime checks and compile-time type-level tests.
+ *
+ * @module
+ */
+/**
+ * Marks a code path as unimplemented. Always throws.
+ */
+export declare const todo: () => never;
+/**
+ * Throws `msg` (default `'assertion failed'`) if `v` is `false`.
+ *
+ * Narrows `v` to `true` via `asserts v`, so callers can rely on the
+ * condition holding for the rest of the enclosing scope.
+ */
+export declare const assert: (v: boolean, msg?: unknown) => asserts v;
+/**
+ * Asserts that `a` and `b` are `===`, throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ */
+export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
+/**
+ * Compile-time-only check: a type resolves only if it is exactly `true`.
+ * Used to assert type-level properties without any runtime cost, e.g.
+ * `type _ = Assert<Equal<A, B>>`.
+ */
+export type Assert<T extends true> = T;
+/**
+ * Asserts that `a` is neither `null` nor `undefined` and returns it,
+ * narrowed to `T`.
+ *
+ * Use this to chain directly off a call that may return a nullish value,
+ * e.g. `const r = assertNotNullish(f(x))`. For a variable that already
+ * exists, prefer `assert(a !== null && a !== undefined)` instead.
+ */
+export declare const assertNotNullish: <T>(a: T | null | undefined, msg?: unknown) => T;

package/fjs/asserts/module.f.js

@@ -0,0 +1,39 @@
+/**
+ * Assertion helpers for runtime checks and compile-time type-level tests.
+ *
+ * @module
+ */
+/**
+ * Marks a code path as unimplemented. Always throws.
+ */
+export const todo = () => { throw 'not implemented'; };
+/**
+ * Throws `msg` (default `'assertion failed'`) if `v` is `false`.
+ *
+ * Narrows `v` to `true` via `asserts v`, so callers can rely on the
+ * condition holding for the rest of the enclosing scope.
+ */
+export const assert = (v, msg = 'assertion failed') => {
+    if (!v)
+        throw msg;
+};
+/**
+ * Asserts that `a` and `b` are `===`, throwing `x` (the `[a, b]` pair, plus
+ * an optional third element used as an extra message) if they differ.
+ */
+export const assertEq = (...x) => {
+    const [a, b] = x;
+    assert(a === b, x);
+};
+/**
+ * Asserts that `a` is neither `null` nor `undefined` and returns it,
+ * narrowed to `T`.
+ *
+ * Use this to chain directly off a call that may return a nullish value,
+ * e.g. `const r = assertNotNullish(f(x))`. For a variable that already
+ * exists, prefer `assert(a !== null && a !== undefined)` instead.
+ */
+export const assertNotNullish = (a, msg) => {
+    assert(a !== null && a !== undefined, msg);
+    return a;
+};

package/fjs/asserts/proof.f.d.ts

@@ -0,0 +1,11 @@
+export declare const proof: {
+    assertPassesOnTrue: () => void;
+    assertEqPassesOnEqual: () => void;
+    throw: {
+        assertEqThrowsOnUnequal: () => void;
+        assertEqThrowsOnUnequal3: () => void;
+        assertThrowsDefaultMsg: () => void;
+        assertThrowsCustomMsg: () => void;
+        todoThrows: () => never;
+    };
+};

package/fjs/asserts/proof.f.js

@@ -0,0 +1,18 @@
+import { assert, assertEq, todo } from './module.f.js';
+export const proof = {
+    assertPassesOnTrue: () => {
+        assert(true);
+        assert(true, 'with message');
+    },
+    assertEqPassesOnEqual: () => {
+        assertEq(1, 1);
+        assertEq('x', 'x');
+    },
+    throw: {
+        assertEqThrowsOnUnequal: () => assertEq(1, 2),
+        assertEqThrowsOnUnequal3: () => assertEq(1, 2, "message"),
+        assertThrowsDefaultMsg: () => assert(false),
+        assertThrowsCustomMsg: () => assert(false, 'oops'),
+        todoThrows: () => todo(),
+    },
+};

package/{fs → fjs}/base_n/module.f.js

@@ -11,9 +11,9 @@
  *
  * @module
  */
-import { msb, lsb, vec, chunkList, unpack } from "../types/bit_vec/module.f.js";
-import { fold } from "../types/list/module.f.js";
-import { compose } from "../types/function/module.f.js";
+import { msb, lsb, vec, chunkList, unpack } from '../types/bit_vec/module.f.js';
+import { fold } from '../types/list/module.f.js';
+import { compose } from '../types/function/module.f.js';
 const { unpackSplit } = msb;
 const { tryListToVec: reversedListToVec } = lsb;
 // `chunkList(msb)` doesn't depend on `bits` or `v` — shared across every

package/{fs → fjs}/base_n/proof.f.js

@@ -1,6 +1,6 @@
-import { assertEq } from "../asserts/module.f.js";
-import { empty, maxLength, vec, length } from "../types/bit_vec/module.f.js";
-import { baseN } from "./module.f.js";
+import { assertEq } from '../asserts/module.f.js';
+import { empty, maxLength, vec, length } from '../types/bit_vec/module.f.js';
+import { baseN } from './module.f.js';
 const hex = baseN(4n, '0123456789abcdef');
 const cb32 = baseN(5n, '0123456789abcdefghjkmnpqrstvwxyz', c => {
     const lower = c.toLowerCase();
@@ -25,67 +25,43 @@ const bigSampleHex = `f`.repeat(Number(maxLength >> 2n));
 export const proof = {
     encodeEmpty: () => {
         const s = hex.vecToString(empty);
-        if (s !== '') {
-            throw [s];
-        }
+        assertEq(s, '', [s]);
     },
     encodeAligned: () => {
         // Two 4-bit chunks → two hex digits
         const s = hex.vecToString(vec(8n)(0xa5n));
-        if (s !== 'a5') {
-            throw [s];
-        }
+        assertEq(s, 'a5', [s]);
     },
     encodeUnaligned: () => {
         // 6 bits → first 4-bit chunk + a 2-bit tail that popFront pads with
         // trailing zeros (the standard `popFront` behaviour the codec inherits).
         const s = hex.vecToString(vec(6n)(41n));
-        if (s !== 'a4') {
-            throw [s];
-        }
+        assertEq(s, 'a4', [s]);
     },
     decodeEmpty: () => {
         const v = hex.stringToVec('');
-        if (v !== empty) {
-            throw [v];
-        }
+        assertEq(v, empty, [v]);
     },
     decodeRoundTrip: () => {
         const v = hex.stringToVec('ab');
-        if (v !== vec(8n)(0xabn)) {
-            throw [v];
-        }
+        assertEq(v, vec(8n)(0xabn), [v]);
     },
     decodeInvalid: () => {
-        if (hex.stringToVec('z') !== null) {
-            throw 'invalid char should return null';
-        }
-        if (hex.stringToVec('aZ') !== null) {
-            throw 'mixed invalid char should return null';
-        }
+        assertEq(hex.stringToVec('z'), null, 'invalid char should return null');
+        assertEq(hex.stringToVec('aZ'), null, 'mixed invalid char should return null');
     },
     normalizeHit: () => {
         // 'A' lowercases to 'a' — same vector as the lowercase input.
         const a = cb32.stringToVec('A');
         const b = cb32.stringToVec('a');
-        if (a !== b) {
-            throw [a, b];
-        }
+        assertEq(a, b, [a, b]);
         // Crockford folds: i,l → 1 and o → 0.
-        if (cb32.stringToVec('I') !== cb32.stringToVec('1')) {
-            throw 'I→1';
-        }
-        if (cb32.stringToVec('l') !== cb32.stringToVec('1')) {
-            throw 'l→1';
-        }
-        if (cb32.stringToVec('o') !== cb32.stringToVec('0')) {
-            throw 'o→0';
-        }
+        assertEq(cb32.stringToVec('I'), cb32.stringToVec('1'), 'I→1');
+        assertEq(cb32.stringToVec('l'), cb32.stringToVec('1'), 'l→1');
+        assertEq(cb32.stringToVec('o'), cb32.stringToVec('0'), 'o→0');
     },
     normalizeMiss: () => {
-        if (cb32.stringToVec('u') !== null) {
-            throw 'unknown char should return null';
-        }
+        assertEq(cb32.stringToVec('u'), null, 'unknown char should return null');
     },
     // Decodes a 1 Mibit hex string. With the O(n log n) `listToVec` builder this
     // runs in well under a second (was ~13 s node / ~43 s bun under the old

package/{fs → fjs/basen}/base128/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type Vec } from '../types/bit_vec/module.f.ts';
+import { type Vec } from '../../types/bit_vec/module.f.ts';
 /**
  * Encodes a bigint into an MSB Base128 vector.
  *

package/{fs → fjs/basen}/base128/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { vec8, msb, empty } from "../types/bit_vec/module.f.js";
+import { vec8, msb, empty } from '../../types/bit_vec/module.f.js';
 const { concat, popFront } = msb;
 const pop8 = popFront(8n);
 /**

package/{fs → fjs/basen}/base128/proof.f.js

@@ -1,6 +1,6 @@
-import { empty, vec, vec8 } from "../types/bit_vec/module.f.js";
-import { asBase } from "../types/nominal/module.f.js";
-import { encode, decode } from "./module.f.js";
+import { empty, vec, vec8 } from '../../types/bit_vec/module.f.js';
+import { asBase } from '../../types/nominal/module.f.js';
+import { encode, decode } from './module.f.js';
 const test = (a, b) => {
     const encoded = encode(a);
     if (encoded !== b) {

package/{fs → fjs/basen}/base64/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type Vec } from "../types/bit_vec/module.f.ts";
-import type { Nullable } from "../types/nullable/module.f.ts";
+import { type Vec } from "../../types/bit_vec/module.f.ts";
+import type { Nullable } from "../../types/nullable/module.f.ts";
 export declare const encode: (input: Vec) => Nullable<string>;
 export declare const decode: (input: string) => Nullable<Vec>;

package/{fs → fjs/basen}/base64/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { msb, length, vec, empty } from "../types/bit_vec/module.f.js";
-import { baseN } from "../base_n/module.f.js";
+import { msb, length, vec, maxLength } from "../../types/bit_vec/module.f.js";
+import { baseN } from "../../base_n/module.f.js";
 const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 const { popFront } = msb;
 const { vecToString, stringToVec } = baseN(6n, alphabet);
@@ -39,23 +39,33 @@ export const decode = (input) => {
     if ((body.length + padChars) % 4 !== 0) {
         return null;
     }
-    // Decode each character to 6 bits.
-    const result = stringToVec(body);
-    if (result === null) {
-        return null;
+    if (padChars === 0) {
+        return stringToVec(body);
     }
-    // Remove the zero-padding bits introduced during encode.
-    // padChars=1 → 2 padding bits removed, padChars=2 → 4 padding bits removed.
+    // `encode`'s zero-padding bits (added to reach a 6-bit boundary) live
+    // entirely inside the *last* character's chunk — RFC 4648 padding never
+    // spans more than one base64 character. Decode every character but the
+    // last through `stringToVec` as usual, then decode and trim the last
+    // character on its own, so no intermediate `Vec` built here is ever
+    // wider than the final, post-trim result — even for input whose decoded
+    // payload lands exactly at `maxLength`.
     const removeBits = BigInt(padChars * 2);
-    const totalBits = length(result);
-    const targetLen = totalBits - removeBits;
-    if (targetLen === 0n) {
-        return empty;
+    const realBits = 6n - removeBits;
+    const head = stringToVec(body.slice(0, body.length - 1));
+    if (head === null) {
+        return null;
+    }
+    const lastChunk = stringToVec(body.slice(body.length - 1));
+    if (lastChunk === null) {
+        return null;
+    }
+    if (length(head) + realBits > maxLength) {
+        return null;
     }
-    const [kept, padVec] = popFront(targetLen)(result);
+    const [kept, pad] = popFront(realBits)(lastChunk);
     // Padding bits must be zero (RFC 4648 §3.5).
-    if (removeBits > 0n && padVec !== vec(removeBits)(0n)) {
+    if (pad !== vec(removeBits)(0n)) {
         return null;
     }
-    return vec(targetLen)(kept);
+    return msb.concat(head)(vec(realBits)(kept));
 };

package/{fs → fjs/basen}/base64/proof.f.d.ts

@@ -9,6 +9,8 @@ export declare const proof: {
     validPadding: () => void;
     knownVectors: () => void;
     decodeOverflow: () => void;
+    decodePaddedTailRejections: () => void;
     encodeAtMaxLengthSucceeds: () => void;
+    decodeAtMaxLengthSucceeds: () => void;
     encodeLargeVecIsSlow: () => void;
 };

package/{fs → fjs/basen}/base64/proof.f.js

@@ -1,5 +1,5 @@
-import { assertEq } from "../asserts/module.f.js";
-import { empty, vec, repeat, vec8, maxLength } from "../types/bit_vec/module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
+import { empty, vec, repeat, vec8, maxLength } from "../../types/bit_vec/module.f.js";
 import { encode, decode } from "./module.f.js";
 const check = (s, v) => {
     assertEq(encode(v), s);
@@ -83,17 +83,37 @@ export const proof = {
         const oversized = 'A'.repeat(174_764);
         assertEq(decode(oversized), null);
     },
+    decodePaddedTailRejections: () => {
+        // These all take the padded branch of `decode` (`padChars > 0`,
+        // i.e. the `head`/`lastChunk` split), unlike `decodeOverflow` above
+        // which takes the unpadded fast path. An invalid character before
+        // the final char must be rejected via the `head` decode...
+        assertEq(decode('!A=='), null);
+        // ...and an invalid final character (the one holding the padding
+        // bits) must be rejected via the last-character decode.
+        assertEq(decode('A!=='), null);
+        // Same as `decodeOverflow`, but with a padded tail so it's the
+        // padded branch that measures the result against `maxLength` and
+        // rejects it.
+        assertEq(decode('A'.repeat(174_764) + '='), null);
+    },
     encodeAtMaxLengthSucceeds: () => {
         // A `maxLength`-sized vector's trailing partial 6-bit chunk is
         // left-padded by `vecToString` itself (see `baseN`), so `encode`
         // never needs to build an over-`maxLength` intermediate and must not
-        // reject this boundary input. (`decode` of the resulting string
-        // still fails on this exact boundary — a separate, still-open bug;
-        // see `fs/base64/todo/decode-rejects-max-size-input.md`.)
+        // reject this boundary input.
         assertEq(encode(vec(maxLength)(0n)), 'A'.repeat(174_763) + '=');
     },
+    decodeAtMaxLengthSucceeds: () => {
+        // Companion to `encodeAtMaxLengthSucceeds`: the encoded string's raw,
+        // pre-trim bit count (1_048_578) is 2 over `maxLength` even though
+        // the payload it decodes to is exactly `maxLength`. `decode` must
+        // trim the last character's 2 zero-padding bits before — not after —
+        // measuring the result against `maxLength`.
+        check('A'.repeat(174_763) + '=', vec(maxLength)(0n));
+    },
     // Regression guard: `encode` used to be quadratic in the input size, not
-    // linear. `baseN`'s `vecToString` (`fs/base_n/module.f.ts`) popped one
+    // linear. `baseN`'s `vecToString` (`fjs/base_n/module.f.ts`) popped one
     // 6-bit chunk off the front at a time via `popFront`, and each `popFront`
     // re-masked the entire remaining bigint through `vec()`'s `m & ui` —
     // O(remaining length) — so encoding a vector of `n` bits cost O(n²). A

package/{fs → fjs/basen}/cbase32/module.f.d.ts

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { type Vec } from "../types/bit_vec/module.f.ts";
-import type { Nullable } from "../types/nullable/module.f.ts";
+import { type Vec } from "../../types/bit_vec/module.f.ts";
+import type { Nullable } from "../../types/nullable/module.f.ts";
 export declare const vec5xToCBase32: (v: Vec) => string;
 export declare const cBase32ToVec5x: (s: string) => Nullable<Vec>;
 export declare const vecToCBase32: (v: Vec) => string;

package/{fs → fjs/basen}/cbase32/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { msb, lsb, length, vec, empty } from "../types/bit_vec/module.f.js";
-import { baseN } from "../base_n/module.f.js";
+import { msb, lsb, length, vec, empty } from "../../types/bit_vec/module.f.js";
+import { baseN } from "../../base_n/module.f.js";
 //                         0123456789abcdef
 const m = '0123456789abcdefghjkmnpqrstvwxyz';
 const { concat } = msb;