functionalscript 0.3.4 → 0.3.6

package/types/bigint/test.f.js

@@ -0,0 +1,199 @@
+import * as _ from "./module.f.js";
+const { sum, abs, serialize, log2, bitLength } = _;
+export default {
+    sum: () => {
+        const result = sum([2n, 3n, 4n, 5n]);
+        if (result !== 14n) {
+            throw result;
+        }
+    },
+    abs: [
+        () => {
+            const result = abs(10n);
+            if (result !== 10n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = abs(-10n);
+            if (result !== 10n) {
+                throw result;
+            }
+        }
+    ],
+    serialize: [
+        () => {
+            const result = serialize(0n);
+            if (result !== '0n') {
+                throw result;
+            }
+        },
+        () => {
+            const result = serialize(123456789012345678901234567890n);
+            if (result !== '123456789012345678901234567890n') {
+                throw result;
+            }
+        },
+        () => {
+            const result = serialize(-55555n);
+            if (result !== '-55555n') {
+                throw result;
+            }
+        },
+    ],
+    log2: [
+        () => {
+            const result = log2(-3n);
+            if (result !== -1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(0n);
+            if (result !== -1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(1n);
+            if (result !== 0n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(2n);
+            if (result !== 1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(3n);
+            if (result !== 1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(4n);
+            if (result !== 2n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(7n);
+            if (result !== 2n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(8n);
+            if (result !== 3n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(15n);
+            if (result !== 3n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(16n);
+            if (result !== 4n) {
+                throw result;
+            }
+        },
+        () => {
+            // max for Bun (131_072 Bytes)
+            const v = 1048575n;
+            const result = log2(1n << v);
+            if (result !== v) {
+                throw result;
+            }
+        },
+        () => {
+            const v = 0x18945n;
+            const result = log2(v);
+            if (result !== 16n) {
+                throw result;
+            }
+        }
+    ],
+    toString2: () => {
+        // max for Bun (131_072 Bytes)
+        const v = 1048575n;
+        const result = (1n << v).toString(2).length - 1;
+        if (result !== 1_048_575) {
+            throw result;
+        }
+    },
+    minus: () => {
+        let i = 0n;
+        while (i < 1048575n) {
+            const s = -i;
+            if (i !== -s) {
+                throw [i, s];
+            }
+            i += 1n;
+        }
+    },
+    not: () => {
+        let i = 0n;
+        while (i < 1048575n) {
+            const s = ~i;
+            if (i !== ~s) {
+                throw [i, s];
+            }
+            i += 1n;
+        }
+    },
+    bitLen: {
+        0: () => {
+            const s = bitLength(0n);
+            if (s !== 0n) {
+                throw s;
+            }
+        },
+        m: () => {
+            let i = 0n;
+            while (i < 10000n) {
+                const s = bitLength(1n << i);
+                if (s !== i + 1n) {
+                    throw [s, i];
+                }
+                i += 1n;
+            }
+        },
+        big: () => {
+            const s = bitLength(1n << 1000000n);
+            if (s !== 1000001n) {
+                throw s;
+            }
+        },
+        neg: [
+            () => {
+                const s = bitLength(-1n);
+                if (s !== 1n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-2n);
+                if (s !== 2n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-3n);
+                if (s !== 2n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-4n);
+                if (s !== 3n) {
+                    throw s;
+                }
+            },
+        ]
+    }
+};

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

@@ -0,0 +1,134 @@
+/**
+ * A vector of bits represented as a `bigint`.
+ */
+type Vec = bigint;
+/**
+ * An empty vector of bits.
+ */
+export declare const empty = 1n;
+/**
+ * Calculates the length of the given vector of bits.
+ */
+export declare const length: (v: bigint) => bigint;
+/**
+ * Creates a vector of bits of the given `len` and the given unsigned integer.
+ *
+ * @example
+ *
+ * ```js
+ * const vec4 = vec(4n)
+ * const v0 = vec4(5n)     // 0x15n
+ * const v1 = vec4(0x5FEn) // 0x1En
+ * ```
+ */
+export declare const vec: (len: bigint) => (ui: bigint) => Vec;
+/**
+ * Returns the unsigned integer of the given vector by removing a stop bit.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0x5n) // 0x105n
+ * const result = uint(vector); // result is 0x5n
+ * ```
+ */
+export declare const uint: (v: Vec) => bigint;
+/**
+ * Extract the least significant unsigned integer from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const result = uintLsb(4n)(vector); // result is 5n
+ * const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
+ * ```
+ */
+export declare const uintLsb: (len: bigint) => (v: Vec) => bigint;
+/**
+ * Removes the first `len` least significant bits from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const v = vec(16n)(0x3456n) // 0x13456n
+ * const r = removeLsb(4n)(v) // 0x1345n
+ * const r2 = removeLsb(24n)(v) // 0x1n
+ * ```
+ */
+export declare const removeLsb: (len: bigint) => (v: Vec) => Vec;
+/**
+ * Extracts the least significant unsigned integer and removes it from the vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
+ * const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
+ * ```
+ */
+export declare const popUintLsb: (len: bigint) => (v: Vec) => readonly [bigint, Vec];
+/**
+ * Extract the most significant unsigned integer of the given `len` from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const result = uintMsb(4n)(vector); // result is 0xFn
+ * const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
+ * ```
+ */
+export declare const uintMsb: (len: bigint) => (v: Vec) => bigint;
+/**
+ * Removes the first `len` most significant bits from the given vector.
+ *
+ * @example
+ *
+ * ```js
+ * const v = vec(16n)(0x3456n) // 0x13456n
+ * const r = removeMsb(4n)(v) // 0x1456n
+ * const r2 = removeMsb(24n)(v) // 0x1n
+ * ```
+ */
+export declare const removeMsb: (len: bigint) => (v: Vec) => Vec;
+/**
+ * Extracts the most significant unsigned integer and removes it from the vector.
+ *
+ * @example
+ *
+ * ```js
+ * const vector = vec(8n)(0xF5n) // 0x1F5n
+ * const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
+ * const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
+ * ```
+ */
+export declare const popUintMsb: (len: bigint) => (v: Vec) => readonly [bigint, Vec];
+/**
+ * Concat the given vectors of bits. The first vector is the least significant.
+ *
+ * @example
+ *
+ * ```js
+ * const u8 = vec(8n)
+ * const a = u8(0x45n) // 0x145n
+ * const b = u8(0x89n) // 0x189n
+ * const ab = concatLsb(a)(b) // 0x18945n
+ * ```
+ */
+export declare const concatLsb: (a: Vec) => (b: Vec) => Vec;
+/**
+ * Concat the given vectors of bits. The first vector is the most significant.
+ *
+ * @example
+ *
+ * ```js
+ * const u8 = vec(8n)
+ * const a = u8(0x45n) // 0x145n
+ * const b = u8(0x89n) // 0x189n
+ * const ab = concatMsb(a)(b) // 0x14589n
+ * ```
+ */
+export declare const concatMsb: (b: Vec) => (a: Vec) => Vec;
+export {};

package/types/bit_vec/{module.f.ts → module.f.js}

@@ -1,21 +1,13 @@
-import { log2 } from '../bigint/module.f.ts'
-import { flip } from '../function/module.f.ts'
-
-/**
- * A vector of bits represented as a `bigint`.
- */
-type Vec = bigint
-
+import { log2 } from "../bigint/module.f.js";
+import { flip } from "../function/module.f.js";
 /**
  * An empty vector of bits.
  */
-export const empty = 1n
-
+export const empty = 1n;
 /**
  * Calculates the length of the given vector of bits.
  */
-export const length = log2
-
+export const length = log2;
 /**
  * Creates a vector of bits of the given `len` and the given unsigned integer.
  *
@@ -27,15 +19,15 @@ export const length = log2
  * const v1 = vec4(0x5FEn) // 0x1En
  * ```
  */
-export const vec = (len: bigint): (ui: bigint) => Vec => {
-    if (len <= 0n) { return () => empty }
-    const stop = 1n << len
-    const mask = stop - 1n
-    return data => stop | (data & mask)
-}
-
-const mask = (len: bigint) => (1n << len) - 1n
-
+export const vec = (len) => {
+    if (len <= 0n) {
+        return () => empty;
+    }
+    const stop = 1n << len;
+    const mask = stop - 1n;
+    return data => stop | (data & mask);
+};
+const mask = (len) => (1n << len) - 1n;
 /**
  * Returns the unsigned integer of the given vector by removing a stop bit.
  *
@@ -46,8 +38,7 @@ const mask = (len: bigint) => (1n << len) - 1n
  * const result = uint(vector); // result is 0x5n
  * ```
  */
-export const uint = (v: Vec): bigint => v ^ (1n << length(v))
-
+export const uint = (v) => v ^ (1n << length(v));
 /**
  * Extract the least significant unsigned integer from the given vector.
  *
@@ -59,14 +50,13 @@ export const uint = (v: Vec): bigint => v ^ (1n << length(v))
  * const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
  * ```
  */
-export const uintLsb = (len: bigint): (v: Vec) => bigint => {
-    const m = mask(len)
+export const uintLsb = (len) => {
+    const m = mask(len);
     return v => {
-        const result = v & m
-        return result === v ? uint(v) : result
-    }
-}
-
+        const result = v & m;
+        return result === v ? uint(v) : result;
+    };
+};
 /**
  * Removes the first `len` least significant bits from the given vector.
  *
@@ -78,11 +68,10 @@ export const uintLsb = (len: bigint): (v: Vec) => bigint => {
  * const r2 = removeLsb(24n)(v) // 0x1n
  * ```
  */
-export const removeLsb = (len: bigint) => (v: Vec): Vec => {
-    const r = v >> len
-    return r === 0n ? empty : r
-}
-
+export const removeLsb = (len) => (v) => {
+    const r = v >> len;
+    return r === 0n ? empty : r;
+};
 /**
  * Extracts the least significant unsigned integer and removes it from the vector.
  *
@@ -94,14 +83,13 @@ export const removeLsb = (len: bigint) => (v: Vec): Vec => {
  * const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
  * ```
  */
-export const popUintLsb = (len: bigint): (v: Vec) => readonly[bigint, Vec] => {
-    const m = mask(len)
+export const popUintLsb = (len) => {
+    const m = mask(len);
     return v => {
-        const result = v & m
-        return result === v ? [uint(v), empty] : [result, v >> len]
-    }
-}
-
+        const result = v & m;
+        return result === v ? [uint(v), empty] : [result, v >> len];
+    };
+};
 /**
  * Extract the most significant unsigned integer of the given `len` from the given vector.
  *
@@ -113,11 +101,10 @@ export const popUintLsb = (len: bigint): (v: Vec) => readonly[bigint, Vec] => {
  * const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
  * ```
  */
-export const uintMsb = (len: bigint): (v: Vec) => bigint => {
-    const m = mask(len)
-    return v => (v >> (length(v) - len)) & m
-}
-
+export const uintMsb = (len) => {
+    const m = mask(len);
+    return v => (v >> (length(v) - len)) & m;
+};
 /**
  * Removes the first `len` most significant bits from the given vector.
  *
@@ -129,8 +116,7 @@ export const uintMsb = (len: bigint): (v: Vec) => bigint => {
  * const r2 = removeMsb(24n)(v) // 0x1n
  * ```
  */
-export const removeMsb = (len: bigint) => (v: Vec): Vec => vec(length(v) - len)(v)
-
+export const removeMsb = (len) => (v) => vec(length(v) - len)(v);
 /**
  * Extracts the most significant unsigned integer and removes it from the vector.
  *
@@ -142,14 +128,13 @@ export const removeMsb = (len: bigint) => (v: Vec): Vec => vec(length(v) - len)(
  * const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
  * ```
  */
-export const popUintMsb = (len: bigint): (v: Vec) => readonly[bigint, Vec] => {
-    const m = mask(len)
+export const popUintMsb = (len) => {
+    const m = mask(len);
     return v => {
-        const d = length(v) - len
-        return [(v >> d) & m, vec(d)(v)]
-    }
-}
-
+        const d = length(v) - len;
+        return [(v >> d) & m, vec(d)(v)];
+    };
+};
 /**
  * Concat the given vectors of bits. The first vector is the least significant.
  *
@@ -162,12 +147,11 @@ export const popUintMsb = (len: bigint): (v: Vec) => readonly[bigint, Vec] => {
  * const ab = concatLsb(a)(b) // 0x18945n
  * ```
  */
-export const concatLsb = (a: Vec): (b: Vec) => Vec => {
-    const aLen = length(a)
-    const m = mask(aLen)
-    return b => (b << aLen) | (a & m)
-}
-
+export const concatLsb = (a) => {
+    const aLen = length(a);
+    const m = mask(aLen);
+    return b => (b << aLen) | (a & m);
+};
 /**
  * Concat the given vectors of bits. The first vector is the most significant.
  *
@@ -180,6 +164,4 @@ export const concatLsb = (a: Vec): (b: Vec) => Vec => {
  * const ab = concatMsb(a)(b) // 0x14589n
  * ```
  */
-export const concatMsb
-    : (b: Vec) => (a: Vec) => Vec
-    = flip(concatLsb)
+export const concatMsb = flip(concatLsb);

package/types/bit_vec/test.f.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    examples: {
+        vec: () => void;
+        uint: () => void;
+        uintLsb: () => void;
+        uintMsb: () => void;
+        popUintLsb: () => void;
+        popUintMsb: () => void;
+        concatLsb: () => void;
+        concatMsb: () => void;
+        removeLsb: () => void;
+        removeMsb: () => void;
+    };
+    uintLsb: () => void;
+    uintSmall: () => void;
+    vecExample: () => void;
+    length: () => void;
+    bitset: () => void;
+    appendBack: () => void;
+    removeBack: () => void;
+};
+export default _default;