functionalscript 0.32.4 → 0.34.0

package/fs/text/code_point/module.f.js

@@ -1,12 +1,15 @@
 /**
  * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
- * error-tag mask used to flag invalid sequences, and a streaming `decoder`
+ * error-tag mask used to flag invalid sequences, the streaming `decoder`
  * factory that wraps a per-unit step and an end-of-input step into a single
- * `List`-to-`List` conversion.
+ * `List`-to-`List` conversion, and the code-point classification predicates
+ * (BMP / surrogate / supplementary-plane / overall validity) that both codecs
+ * share.
  *
  * @module
  */
 import { flat, stateScan } from "../../types/list/module.f.js";
+import { contains } from "../../types/range/module.f.js";
 /**
  * Error mask used to tag invalid code points or encoding errors. A decoded
  * value with this bit set represents a malformed unit rather than a valid
@@ -29,3 +32,72 @@ export const decoder = (byteOp, eofOp) => {
     const run = stateScan(op)(null);
     return input => flat(run(flat([input, [null]])));
 };
+/**
+ * Unicode code-point classification boundaries. The surrogate block
+ * (`0xD800`–`0xDFFF`) splits into a high half (`0xD800`–`0xDBFF`) and a low half
+ * (`0xDC00`–`0xDFFF`); the BMP ends at `0xFFFF` and `maxCodePoint` (`0x10FFFF`)
+ * is the largest assignable code point. Every predicate below is derived from
+ * these constants so the surrogate bounds and the maximum appear exactly once.
+ */
+const surrogateMin = 0xd800;
+const lowSurrogateMin = 0xdc00;
+const surrogateMax = 0xdfff;
+const bmpMax = 0xffff;
+const maxCodePoint = 0x10_ffff;
+/**
+ * Checks whether the 16-bit word (U16) is a high surrogate.
+ * Range: 0xD800 - 0xDBFF.
+ */
+export const isHighSurrogate = contains([surrogateMin, lowSurrogateMin - 1]);
+/**
+ * Checks whether the 16-bit word (U16) is a low surrogate.
+ * Range: 0xDC00 - 0xDFFF.
+ */
+export const isLowSurrogate = contains([lowSurrogateMin, surrogateMax]);
+/**
+ * Ranges of code points for the lower (Low) and higher (High) parts of the BMP
+ * (Basic Multilingual Plane), i.e. the BMP with the surrogate block removed.
+ */
+const lowBmp = contains([0x0000, surrogateMin - 1]);
+const highBmp = contains([surrogateMax + 1, bmpMax]);
+/**
+ * Checks whether the code point is in the BMP range.
+ * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
+ * for the range of surrogates.
+ */
+export const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
+/**
+ * Checks whether the code point belongs to a supplementary (additional) Unicode
+ * plane. Supplementary planes cover code points from 0x010000 to 0x10FFFF.
+ */
+export const isSupplementaryPlane = contains([bmpMax + 1, maxCodePoint]);
+/**
+ * The full assignable code-point range and the surrogate block, used to gate
+ * overall validity below.
+ */
+const validRange = contains([0, maxCodePoint]);
+const isSurrogate = contains([surrogateMin, surrogateMax]);
+/**
+ * Checks whether the code point is a valid scalar value: within the assignable
+ * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
+ */
+export const isValidCodePoint = (c) => validRange(c) && !isSurrogate(c);
+/**
+ * The control-character blocks and the whitespace exception used to separate
+ * *text* code points from binary control bytes. C0 controls span 0x0000 -
+ * 0x001F; 0x007F (DEL) and the C1 controls (0x0080 - 0x009F) form one
+ * contiguous run; the whitespace block 0x0009 - 0x000D (TAB, LF, VT, FF, CR) is
+ * the only control range legitimate in text.
+ */
+const c0Control = contains([0x00, 0x1f]);
+const delAndC1Control = contains([0x7f, 0x9f]);
+const textWhitespace = contains([0x09, 0x0d]);
+/**
+ * Checks whether the code point is a *text* code point — distinct from
+ * {@link isValidCodePoint}, which gates well-formedness for decoding. A code
+ * point is text unless it is a control character: the controls are 0x0000 -
+ * 0x001F, 0x007F (DEL), and 0x0080 - 0x009F (C1), minus the whitespace block
+ * 0x0009 - 0x000D (TAB, LF, VT, FF, CR), which is legitimate in text. Every
+ * code point at or above 0x0020 that is not DEL or a C1 control is text.
+ */
+export const isTextCodePoint = (c) => textWhitespace(c) || !(c0Control(c) || delAndC1Control(c));

package/fs/text/code_point/proof.f.d.ts

@@ -0,0 +1,8 @@
+export declare const proof: {
+    isHighSurrogate: (() => void)[];
+    isLowSurrogate: (() => void)[];
+    isBmpCodePoint: (() => void)[];
+    isSupplementaryPlane: (() => void)[];
+    isValidCodePoint: (() => void)[];
+    isTextCodePoint: (() => void)[];
+};

package/fs/text/code_point/proof.f.js

@@ -0,0 +1,72 @@
+import { isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, isTextCodePoint, isValidCodePoint, } from "./module.f.js";
+const check = (actual, expected) => {
+    if (actual !== expected) {
+        throw `${actual} !== ${expected}`;
+    }
+};
+export const proof = {
+    isHighSurrogate: [
+        () => check(isHighSurrogate(0xd800), true),
+        () => check(isHighSurrogate(0xdbff), true),
+        () => check(isHighSurrogate(0xd7ff), false),
+        () => check(isHighSurrogate(0xdc00), false),
+    ],
+    isLowSurrogate: [
+        () => check(isLowSurrogate(0xdc00), true),
+        () => check(isLowSurrogate(0xdfff), true),
+        () => check(isLowSurrogate(0xdbff), false),
+        () => check(isLowSurrogate(0xe000), false),
+    ],
+    isBmpCodePoint: [
+        // lowBmp branch true
+        () => check(isBmpCodePoint(0x0000), true),
+        () => check(isBmpCodePoint(0xd7ff), true),
+        // lowBmp false, highBmp true
+        () => check(isBmpCodePoint(0xe000), true),
+        () => check(isBmpCodePoint(0xffff), true),
+        // both false: surrogate and supplementary
+        () => check(isBmpCodePoint(0xd800), false),
+        () => check(isBmpCodePoint(0x10000), false),
+    ],
+    isSupplementaryPlane: [
+        () => check(isSupplementaryPlane(0x10000), true),
+        () => check(isSupplementaryPlane(0x10ffff), true),
+        () => check(isSupplementaryPlane(0xffff), false),
+        () => check(isSupplementaryPlane(0x110000), false),
+    ],
+    isValidCodePoint: [
+        // in range, not surrogate
+        () => check(isValidCodePoint(0x0000), true),
+        () => check(isValidCodePoint(0x10ffff), true),
+        // in range, surrogate -> invalid
+        () => check(isValidCodePoint(0xd800), false),
+        () => check(isValidCodePoint(0xdfff), false),
+        // out of range -> validRange short-circuits false
+        () => check(isValidCodePoint(-1), false),
+        () => check(isValidCodePoint(0x110000), false),
+    ],
+    isTextCodePoint: [
+        // C0 controls are binary...
+        () => check(isTextCodePoint(0x00), false), // NUL
+        () => check(isTextCodePoint(0x08), false), // BS
+        () => check(isTextCodePoint(0x1b), false), // ESC
+        () => check(isTextCodePoint(0x1f), false), // US
+        // ...except the whitespace block 0x09 - 0x0D
+        () => check(isTextCodePoint(0x09), true), // TAB
+        () => check(isTextCodePoint(0x0a), true), // LF
+        () => check(isTextCodePoint(0x0b), true), // VT
+        () => check(isTextCodePoint(0x0c), true), // FF
+        () => check(isTextCodePoint(0x0d), true), // CR
+        // printable ASCII is text
+        () => check(isTextCodePoint(0x20), true), // space
+        () => check(isTextCodePoint(0x41), true), // 'A'
+        () => check(isTextCodePoint(0x7e), true), // '~'
+        // DEL and the C1 controls are binary
+        () => check(isTextCodePoint(0x7f), false), // DEL
+        () => check(isTextCodePoint(0x80), false), // C1 start
+        () => check(isTextCodePoint(0x9f), false), // C1 end
+        // above C1 is text again
+        () => check(isTextCodePoint(0xa0), true), // NBSP
+        () => check(isTextCodePoint(0x10ffff), true),
+    ],
+};

package/fs/text/sgr/proof.f.js

@@ -1,15 +1,6 @@
 import { fgRed, reset, createConsoleText, backspace, csiWrite } from "./module.f.js";
-import { virtual, emptyState } from "../../effects/node/virtual/module.f.js";
-const makeOptions = (isTTY) => ({
-    args: [],
-    env: {},
-    home: '.',
-    std: { stdout: { isTTY }, stderr: { isTTY } },
-    testContext: { test: async () => { } },
-    bunTestContext: { test: async () => { } },
-    playwrightTestContext: { test: async () => { } },
-    engine: 'node',
-});
+import { virtual, emptyState, defaultNodeProgramOptions } from "../../effects/node/virtual/module.f.js";
+const makeOptions = (isTTY) => ({ ...defaultNodeProgramOptions, std: { stdout: { isTTY }, stderr: { isTTY } } });
 export const proof = [
     () => {
         if (fgRed !== '\x1b[31m') {

package/fs/text/utf16/module.f.js

@@ -9,33 +9,11 @@ import { map, reduce, flatMap, empty, } from "../../types/list/module.f.js";
 import { concat } from "../../types/function/operator/module.f.js";
 import { contains } from "../../types/range/module.f.js";
 import { fn } from "../../types/function/module.f.js";
-import { decoder, errorMask } from "../code_point/module.f.js";
-/**
- * Ranges of code points for the lower (Low) and higher (High) parts of the BMP (Basic Multilingual Plane) plane.
- */
-const lowBmp = contains([0x0000, 0xd7ff]);
-const highBmp = contains([0xe000, 0xffff]);
-/**
- * Checks whether the code point is in the BMP range.
- * BMP is the main multi-plane Unicode plane that covers code points 0x0000 - 0xFFFF, except for the range of surrogates.
- */
-const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
-/**
- * Checks whether the 16-bit word (U16) is a surrogate of the high part.
- * Range: 0xD800 - 0xDBFF.
- */
-const isHighSurrogate = contains([0xd800, 0xdbff]);
-/**
- * Checks whether the 16-bit word (U16) is a substitute for the low part.
- * Range: 0xDC00 – 0xDFFF.
- */
-const isLowSurrogate = contains([0xdc00, 0xdfff]);
-/**
- * Checks whether the code point belongs to the additional (Supplementary) plane of Unicode.
- * Additional planes include code points from 0x010000 to 0x10FFFF.
- */
-const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
+import { decoder, errorMask, isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, } from "../code_point/module.f.js";
 /**
+ * The BMP / surrogate / supplementary-plane predicates used below live in
+ * `code_point`, the shared Unicode contract; see that module for their ranges.
+ *
  * Converts a Unicode code point to its corresponding UTF-16 representation.
  *
  * This function handles:

package/fs/text/utf8/module.f.d.ts

@@ -4,6 +4,7 @@
  * @module
  */
 import { type List, type Thunk } from '../../types/list/module.f.ts';
+import type { StateScan } from '../../types/function/operator/module.f.ts';
 import type { Array1, Array2, Array3 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 /**
@@ -35,6 +36,32 @@ export type Utf8State = null | Utf8NonEmptyState;
  * @returns A thunk that lazily produces a sequence of UTF-8 bytes.
  */
 export declare const fromCodePointList: (input: List<number>) => Thunk<U8>;
+/**
+ * Converts a non-empty UTF-8 decoding state to an error code.
+ *
+ * @param state - A non-empty UTF-8 decoding state.
+ * @returns An I32 error code derived from the invalid UTF-8 state.
+ */
+export declare const utf8StateToError: (state: Utf8NonEmptyState) => I32;
+/**
+ * Decodes a byte into a Unicode code point, using a given UTF-8 state.
+ *
+ * @param state - The current UTF-8 decoding state.
+ * @param byte - A single byte to decode.
+ * @returns A tuple containing:
+ *   - A list of decoded Unicode code points or error codes.
+ *   - The updated UTF-8 state.
+ */
+export declare const utf8ByteToCodePointOp: StateScan<number, Utf8State, readonly I32[]>;
+/**
+ * Handles the end-of-file (EOF) case for UTF-8 decoding.
+ *
+ * @param state - The current UTF-8 decoding state.
+ * @returns A tuple containing:
+ *   - A list of decoded Unicode code points or error codes.
+ *   - The reset UTF-8 state (`null`).
+ */
+export declare const utf8EofToCodePointOp: (state: Utf8State) => readonly [List<I32>, Utf8State];
 /**
  * Converts a list of UTF-8 bytes into a list of Unicode code points.
  *

package/fs/text/utf8/module.f.js

@@ -4,7 +4,7 @@
  * @module
  */
 import { flatMap, toArray } from "../../types/list/module.f.js";
-import { decoder, errorMask } from "../code_point/module.f.js";
+import { decoder, errorMask, isValidCodePoint } from "../code_point/module.f.js";
 import { msb, u8List, length } from "../../types/bit_vec/module.f.js";
 import { codePointListToString } from "../utf16/module.f.js";
 /**
@@ -106,7 +106,7 @@ export const fromCodePointList = flatMap(codePointToUtf8);
  * @param state - A non-empty UTF-8 decoding state.
  * @returns An I32 error code derived from the invalid UTF-8 state.
  */
-const utf8StateToError = (state) => {
+export const utf8StateToError = (state) => {
     let x;
     switch (state.length) {
         case 1: {
@@ -127,8 +127,8 @@ const utf8StateToError = (state) => {
                 contPayload(s2) + 0b1000_0000_0000_0000;
             break;
         }
-        default:
-            throw 'invalid state';
+        //default:
+        //    throw 'invalid state'
     }
     return x | errorMask;
 };
@@ -141,7 +141,7 @@ const utf8StateToError = (state) => {
  *   - A list of decoded Unicode code points or error codes.
  *   - The updated UTF-8 state.
  */
-const utf8ByteToCodePointOp = (byte, state) => {
+export const utf8ByteToCodePointOp = (byte, state) => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state];
     }
@@ -199,7 +199,7 @@ const utf8ByteToCodePointOp = (byte, state) => {
  *   - A list of decoded Unicode code points or error codes.
  *   - The reset UTF-8 state (`null`).
  */
-const utf8EofToCodePointOp = (state) => [
+export const utf8EofToCodePointOp = (state) => [
     state === null ? null : [utf8StateToError(state)],
     null,
 ];
@@ -216,18 +216,12 @@ export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePoint
  * code points.
  */
 export const fromVec = (v) => {
-    if (length(v) % 8n !== 0n) {
+    if ((length(v) & 7n) !== 0n) {
         return null;
     }
     const arr = toArray(toCodePointList(u8List(msb)(v)));
     for (const cp of arr) {
-        if (cp < 0) {
-            return null;
-        }
-        if (cp > 0x10FFFF) {
-            return null;
-        }
-        if (cp >= 0xD800 && cp <= 0xDFFF) {
+        if (!isValidCodePoint(cp)) {
             return null;
         }
     }

package/fs/types/bigint/module.f.d.ts

@@ -156,24 +156,17 @@ export declare const xor: Reduce;
 export declare const divUp: (b: bigint) => Unary;
 export declare const roundUp: (b: bigint) => Unary;
 /**
- * Divides a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ * Converts a bit count to a byte count, rounding up — divides by `8`.
  *
- * @param e - The exponent (divisor = 2^e).
- * @returns A function that rounds a value up by the given power of two.
- */
-export declare const divUpE2: (e: bigint) => Unary;
-/**
- * Rounds a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
- *
- * @param e - The exponent (multiple = 2^e).
- * @returns A function that rounds a value up to the nearest multiple of the given power of two.
- */
-export declare const roundUpE2: (e: bigint) => Unary;
-/**
- * Converts a bit count to a byte count, rounding up — divides by `8` (`2^3` bits per byte).
+ * Domain: non-negative inputs (bit/byte counts). On negative inputs `divUp`
+ * truncates toward zero rather than flooring toward −∞, so the rounding
+ * direction is only meaningful for `v >= 0n`.
  */
 export declare const divUp8: Unary;
 /**
- * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8` (`2^3` bits per byte).
+ * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8`.
+ *
+ * Domain: non-negative inputs (bit/byte counts). See `divUp8` for the
+ * truncate-vs-floor caveat on negative values.
  */
 export declare const roundUp8: Unary;

package/fs/types/bigint/module.f.js

@@ -234,30 +234,17 @@ export const roundUp = (b) => {
     return v => d(v) * b;
 };
 /**
- * Divides a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ * Converts a bit count to a byte count, rounding up — divides by `8`.
  *
- * @param e - The exponent (divisor = 2^e).
- * @returns A function that rounds a value up by the given power of two.
+ * Domain: non-negative inputs (bit/byte counts). On negative inputs `divUp`
+ * truncates toward zero rather than flooring toward −∞, so the rounding
+ * direction is only meaningful for `v >= 0n`.
  */
-export const divUpE2 = (e) => {
-    const m = mask(e);
-    return v => (v + m) >> e;
-};
+export const divUp8 = divUp(8n);
 /**
- * Rounds a bigint value up to the nearest multiple of 2^e (shift-based, power-of-two only).
+ * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8`.
  *
- * @param e - The exponent (multiple = 2^e).
- * @returns A function that rounds a value up to the nearest multiple of the given power of two.
- */
-export const roundUpE2 = (e) => {
-    const d = divUpE2(e);
-    return v => d(v) << e;
-};
-/**
- * Converts a bit count to a byte count, rounding up — divides by `8` (`2^3` bits per byte).
- */
-export const divUp8 = divUpE2(3n);
-/**
- * Rounds a bit count up to the nearest whole byte — the nearest multiple of `8` (`2^3` bits per byte).
+ * Domain: non-negative inputs (bit/byte counts). See `divUp8` for the
+ * truncate-vs-floor caveat on negative values.
  */
-export const roundUp8 = roundUpE2(3n);
+export const roundUp8 = roundUp(8n);

package/fs/types/bigint/proof.f.d.ts

@@ -29,8 +29,6 @@ export declare const proof: {
     combination3: () => void;
     divUp: () => void;
     roundUp: () => void;
-    divUpE2: () => void;
-    roundUpE2: () => void;
     divUp8: () => void;
     roundUp8: () => void;
     xor: () => void;

package/fs/types/bigint/proof.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUpE2, roundUpE2, divUp8, roundUp8 } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUp8, roundUp8 } from "./module.f.js";
 import { assertEq } from "../../asserts/module.f.js";
 import { min } from "../function/compare/module.f.js";
 const oldLog2 = (v) => {
@@ -463,32 +463,22 @@ export const proof = {
         assertEq(roundUp(8n)(15n), 16n);
         assertEq(roundUp(8n)(3n), 8n);
     },
-    divUpE2: () => {
-        assertEq(divUpE2(3n)(8n), 1n);
-        assertEq(divUpE2(3n)(15n), 2n);
-        assertEq(divUpE2(3n)(0n), 0n);
-        assertEq(divUpE2(3n)(8n), 1n);
-        assertEq(divUpE2(3n)(9n), 2n);
-    },
-    roundUpE2: () => {
-        assertEq(roundUpE2(3n)(8n), 8n);
-        assertEq(roundUpE2(3n)(15n), 16n);
-        assertEq(roundUpE2(3n)(3n), 8n);
-        assertEq(roundUpE2(3n)(0n), 0n);
-        assertEq(roundUpE2(3n)(8n), 8n);
-        assertEq(roundUpE2(3n)(9n), 16n);
-    },
     divUp8: () => {
         assertEq(divUp8(0n), 0n);
         assertEq(divUp8(1n), 1n);
         assertEq(divUp8(8n), 1n);
+        assertEq(divUp8(8n), 1n);
         assertEq(divUp8(9n), 2n);
+        assertEq(divUp8(15n), 2n);
     },
     roundUp8: () => {
         assertEq(roundUp8(0n), 0n);
         assertEq(roundUp8(1n), 8n);
+        assertEq(roundUp8(3n), 8n);
+        assertEq(roundUp8(8n), 8n);
         assertEq(roundUp8(8n), 8n);
         assertEq(roundUp8(9n), 16n);
+        assertEq(roundUp8(15n), 16n);
     },
     xor: () => {
         assertEq(xor(5n)(3n), 6n);

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

@@ -12,6 +12,32 @@ export declare const logicalNot: Unary<boolean, boolean>;
 export type Equal<T> = Binary<T, T, boolean>;
 export declare const strictEqual: <T>(a: T) => (b: T) => boolean;
 export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
+/**
+ * One step of a stream transducer: given an `input` symbol and the `prior`
+ * state, produce an `output` and the next state. It both maps an input stream
+ * to an output stream and threads state, so it models tokenizers, decoders, and
+ * other stream-to-stream stages.
+ *
+ * This is the *shape* of a [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine)
+ * — a [finite-state transducer](https://en.wikipedia.org/wiki/Finite-state_transducer)
+ * — but only its signature. The state `S` (and `I`, `O`) is an arbitrary type,
+ * not a finite set, so a `StateScan` is strictly more expressive than a Mealy
+ * machine — its power is the power of `S`:
+ * - a finite `S`/`I`/`O` recovers the classical finite-state machine (e.g. the
+ *   DFA states in `../../../fsm/module.f.ts`);
+ * - an `S` that is a stack makes it a
+ *   [pushdown / stack machine](https://en.wikipedia.org/wiki/Pushdown_automaton)
+ *   (context-free power — balanced brackets, nested structure, the AST tier);
+ * - an unbounded `S` like `bigint` can count, which no finite automaton can.
+ *
+ * And `O` may be a list (0+ symbols per input), not the single symbol strict
+ * Mealy emits. (Functional/coalgebraic usage still calls this `(input, state)
+ * => [output, state]` shape a "Mealy machine", finiteness aside.)
+ *
+ * A {@link Fold} is the output-less special case (state only); driving a
+ * `StateScan` over a `List` is `stateScan` in `../../list/module.f.ts`, and
+ * {@link stateScanToScan} hides the state to recover a {@link Scan}.
+ */
 export type StateScan<I, S, O> = (input: I, prior: S) => 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>;

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

@@ -4,6 +4,9 @@ type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
 type Empty = null;
 export type Result<T> = Empty | NonEmpty<T>;
 export type Thunk<T> = () => List<T>;
+/**
+ * See also https://en.wikipedia.org/wiki/Cons#Lists
+ */
 export type NonEmpty<T> = {
     readonly first: T;
     readonly tail: List<T>;

package/fs/types/result/module.d.ts

@@ -1,5 +1,3 @@
 import { type Result } from './module.f.ts';
-declare const _default: {
-    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
-};
-export default _default;
+export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
+export declare const asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;

package/fs/types/result/module.js

@@ -1,5 +1,5 @@
 import { ok, error } from "./module.f.js";
-const tryCatch = f => {
+export const tryCatch = f => {
     // Side effect: `try catch` is not allowed in FunctionalScript.
     try {
         return ok(f());
@@ -8,6 +8,12 @@ const tryCatch = f => {
         return error(e);
     }
 };
-export default {
-    tryCatch,
+export const asyncTryCatch = async (f) => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.32.4",
+  "version": "0.34.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -43,8 +43,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@playwright/test": "1.61.0",
-    "@types/node": "26.0.0",
+    "@playwright/test": "1.61.1",
+    "@types/node": "26.0.1",
     "typescript": "6.0.3"
   }
 }

package/issues/demo/data/data.f.js

@@ -1,12 +0,0 @@
-import shared from "./shared.f.js"
-
-// comment
-const s = "Hello, world!"
-
-export default {
-  "a": shared,
-  "b": shared,
-  "s": s,
-  d: -24n,
-  x: undefined,
-}

package/issues/demo/data/shared.f.js

@@ -1,3 +0,0 @@
-export default {
-    "name": "shared object"
-}

package/issues/demo/fs/app.js

@@ -1,4 +0,0 @@
-import math from "./math.f.js"
-
-const add2 = math.add(2)
-console.log("5 ===", add2(3))

package/issues/demo/fs/math.f.js

@@ -1,4 +0,0 @@
-export default {
-  add: a => b => a + b,
-  mul: a => b => a * b,
-}

package/issues/demo/sample/proof.f.js

@@ -1,13 +0,0 @@
-const arrayOfTests = [
-  () => {
-    if (2 + 2 !== 4) throw "It's the end of the world as we know it!"
-  },
-  () => {
-    if (2n + 2n !== 4n) throw "It's the end of the world as we know it!"
-  }
-]
-
-export const proof = {
-  arrayOfTests,
-  generatingTests: () => arrayOfTests,
-}