functionalscript 0.6.10 → 0.7.0

package/bnf/data/module.f.d.ts

@@ -1,4 +1,6 @@
-import type { Rule as FRule } from '../module.f.ts';
+import { type CodePoint } from '../../text/utf16/module.f.ts';
+import { type RangeMapArray } from '../../types/range_map/module.f.ts';
+import { type Rule as FRule } from '../module.f.ts';
 export type TerminalRange = number;
 export type Sequence = readonly string[];
 /** A variant of rule names. */
@@ -8,7 +10,44 @@ export type Variant = {
 export type Rule = Variant | Sequence | TerminalRange;
 /** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
+type EmptyTag = string | true | undefined;
+type DispatchRule = {
+    readonly emptyTag: EmptyTag;
+    readonly rangeMap: Dispatch;
+};
+type Dispatch = RangeMapArray<DispatchResult>;
+type DispatchResult = DispatchRuleCollection | null;
+type DispatchRuleCollection = {
+    readonly tag: string | undefined;
+    readonly rules: DispatchRule[];
+};
+type DispatchMap = {
+    readonly [id in string]: DispatchRule;
+};
+/**
+ * Represents a parsed Abstract Syntax Tree (AST) sequence.
+ */
+export type AstSequence = readonly (AstRule | CodePoint)[];
+/**
+ * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
+ */
+export type AstRule = readonly [string, AstSequence];
+/**
+ * Represents the remaining input after a match attempt, or `null` if no match is possible.
+ */
+export type Remainder = readonly CodePoint[] | null;
+/**
+ * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
+ */
+export type MatchResult = readonly [AstRule, Remainder];
+/**
+ * Represents an LL(1) parser function for matching input against grammar rules.
+ */
+export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
+export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
+export declare const parser: (fr: FRule) => Match;
+export {};
 /**
  * Either `{ variantItem: id }` or `id`.
  */

package/bnf/data/module.f.js

@@ -1,5 +1,9 @@
+import { todo } from "../../dev/module.f.js";
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
+import { strictEqual } from "../../types/function/operator/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { rangeMap } from "../../types/range_map/module.f.js";
+import { oneEncode, rangeDecode, } from "../module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {
@@ -40,10 +44,11 @@ const variant = (fr) => map => {
     }
     return [map, set, rule];
 };
+const mapOneEncode = map(oneEncode);
 const data = (dr) => {
     switch (typeof dr) {
         case 'string': {
-            return sequence(toArray(stringToCodePointList(dr)));
+            return sequence(toArray(mapOneEncode(stringToCodePointList(dr))));
         }
         case 'number':
             return m => [m, {}, dr];
@@ -72,7 +77,87 @@ export const toData = (fr) => {
     const [, ruleSet, id] = toDataAdd({})(fr);
     return [ruleSet, id];
 };
-// type Dispatch = RangeMapArray<string>;
+const dispatchOp = rangeMap({
+    union: a => b => {
+        if (a === null) {
+            return b;
+        }
+        if (b === null) {
+            return a;
+        }
+        throw ['can not merge [', a, '][', b, ']'];
+    },
+    equal: strictEqual,
+    def: null,
+});
+export const dispatchMap = (ruleSet) => {
+    const addRuleToDispatch = (dr, rule) => {
+        if (dr === null)
+            return null;
+        return { tag: dr.tag, rules: [...dr.rules, rule] };
+    };
+    const addTagToDispatch = (dr, tag) => {
+        if (dr === null)
+            return null;
+        return { tag, rules: dr.rules };
+    };
+    const dispatchRule = (dm, name) => {
+        if (name in dm) {
+            return dm;
+        }
+        const rule = ruleSet[name];
+        if (typeof rule === 'number') {
+            const range = rangeDecode(rule);
+            const dispatch = dispatchOp.fromRange(range)({ tag: undefined, rules: [] });
+            const dr = { emptyTag: undefined, rangeMap: dispatch };
+            return { ...dm, [name]: dr };
+        }
+        else if (rule instanceof Array) {
+            let emptyTag = true;
+            let result = [];
+            for (const item of rule) {
+                dm = dispatchRule(dm, item);
+                const dr = dm[item];
+                if (emptyTag === true) {
+                    result = toArray(dispatchOp.merge(result)(dr.rangeMap));
+                    emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                }
+                else {
+                    result = result.map(x => [addRuleToDispatch(x[0], dr), x[1]]);
+                }
+            }
+            const dr = { emptyTag, rangeMap: result };
+            return { ...dm, [name]: dr };
+        }
+        else {
+            const entries = Object.entries(rule);
+            let result = [];
+            let emptyTag = undefined;
+            for (const [tag, item] of entries) {
+                dm = dispatchRule(dm, item);
+                const dr = dm[item];
+                if (dr.emptyTag !== undefined) {
+                    emptyTag = tag;
+                }
+                else {
+                    const d = dr.rangeMap.map(x => [addTagToDispatch(x[0], tag), x[1]]);
+                    result = toArray(dispatchOp.merge(result)(d));
+                }
+            }
+            const dr = { emptyTag, rangeMap: result };
+            return { ...dm, [name]: dr };
+        }
+    };
+    let result = {};
+    for (const k in ruleSet) {
+        result = dispatchRule(result, k);
+    }
+    return result;
+};
+export const parser = (fr) => {
+    const data = toData(fr);
+    return todo();
+};
 /**
  * Either `{ variantItem: id }` or `id`.
  */

package/bnf/data/test.f.d.ts

@@ -1,5 +1,7 @@
 declare const _default: {
-    toData: () => void;
+    toData: (() => void)[];
+    variantTest: () => void;
+    dispatch: (() => void)[];
     example: () => void;
 };
 export default _default;

package/bnf/data/test.f.js

@@ -1,10 +1,115 @@
+import { stringify } from "../../json/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { range } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
-import { toData } from "./module.f.js";
+import { dispatchMap, toData } from "./module.f.js";
 export default {
-    toData: () => {
-        const c = toData(classic());
-        const d = toData(deterministic());
+    toData: [
+        () => {
+            const c = toData(classic());
+            const d = toData(deterministic());
+        },
+        () => {
+            const stringRule = 'true';
+            const result = stringify(sort)(toData(stringRule));
+            if (result != '[{"":["0","1","2","3"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917},""]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const result = stringify(sort)(toData(terminalRangeRule));
+            if (result != '[{"":1090519110},""]') {
+                throw result;
+            } //1090519110 = 65 * 2^24 + 70
+        },
+        () => {
+            const sequenceRangeRule = [range('AF'), range('af')];
+            const result = stringify(sort)(toData(sequenceRangeRule));
+            if (result != '[{"":["0","1"],"0":1090519110,"1":1627390054},""]') {
+                throw result;
+            }
+        },
+        () => {
+            const lazyRule = () => 'true';
+            const result = stringify(sort)(toData(lazyRule));
+            if (result != '[{"":1946157172,"0":1912602738,"1":1962934389,"2":1694498917,"lazyRule":["","0","1","2"]},"lazyRule"]') {
+                throw result;
+            }
+        },
+        () => {
+            const varintRule = { true: 'true', false: 'false' };
+            const result = stringify(sort)(toData(varintRule));
+            const expected = '[{"":{"false":"5","true":"0"},"0":["1","2","3","4"],"1":1946157172,"2":1912602738,"3":1962934389,"4":1694498917,"5":["6","7","8","9","4"],"6":1711276134,"7":1627390049,"8":1811939436,"9":1929379955},""]';
+            if (result != expected) {
+                throw [result, expected];
+            }
+        },
+        () => {
+            const lazyRule = () => 'true';
+            const lazyRule0 = () => 'false';
+            const result = stringify(sort)(toData([lazyRule, lazyRule0]));
+            const expected = '[{"":["lazyRule","lazyRule0"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917,"4":1711276134,"5":1627390049,"6":1811939436,"7":1929379955,"lazyRule":["0","1","2","3"],"lazyRule0":["4","5","6","7","3"]},""]';
+            if (result != expected) {
+                throw [result, expected];
+            }
+        },
+    ],
+    variantTest: () => {
+        const varintRule = { a: 'a', b: 'b' };
+        const result = stringify(sort)(toData(varintRule));
+        if (result != '[{"":{"a":"0","b":"2"},"0":["1"],"1":1627390049,"2":["3"],"3":1644167266},""]') {
+            throw result;
+        }
     },
+    dispatch: [
+        () => {
+            const terminalRangeRule = range('AF');
+            const data = toData(terminalRangeRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result != '{"":{"rangeMap":[[null,64],[{"rules":[]},70]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const data = toData(stringRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result != '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"rules":[{"rangeMap":[[null,65],[{"rules":[]},66]]}]},65]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const data = toData(emptyRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result != '{"":{"emptyTag":true,"rangeMap":[]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const data = toData(variantRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result != '{"0":{"rangeMap":[[null,64],[{"rules":[]},65]]},"1":{"rangeMap":[[null,65],[{"rules":[]},66]]},"":{"rangeMap":[[null,64],[{"tag":"a","rules":[]},65],[{"tag":"b","rules":[]},66]]}}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const data = toData(variantRule);
+            const dm = dispatchMap(data[0]);
+            const result = JSON.stringify(dm);
+            if (result != '{"0":{"emptyTag":true,"rangeMap":[]},"1":{"rangeMap":[[null,64],[{"rules":[]},65]]},"":{"emptyTag":"e","rangeMap":[[null,64],[{"tag":"a","rules":[]},65]]}}') {
+                throw result;
+            }
+        },
+    ],
     example: () => {
         const grammar = {
             space: 0x000020_000020,

package/crypto/hmac/module.f.js

@@ -48,13 +48,18 @@ export const hmac = (sha2) => {
     const op = p(oPad);
     const c = computeSync(sha2);
     const vbl = vec(blockLength);
+    // a and b should have the same size
     const xor = (a) => (b) => vbl(a ^ b);
-    return k => m => {
+    return k => {
         const k1 = length(k) > blockLength ? c([k]) : k;
         const k2 = concat(k1)(vec(blockLength - length(k1))(0n));
         const xk2 = xor(k2);
-        const f = (p, msg) => c([xk2(p), msg]);
-        const m1 = f(ip, m);
-        return f(op, m1);
+        const f = (p) => {
+            const x = xk2(p);
+            return (msg) => c([x, msg]);
+        };
+        const fip = f(ip);
+        const fop = f(op);
+        return m => fop(fip(m));
     };
 };

package/crypto/sha2/module.f.d.ts

@@ -37,7 +37,7 @@ export type Base = {
  * const s = msbUtf8("The quick brown fox jumps over the lazy dog.")
  * let state = sha224.init
  * state = sha224.append(state)(s)
- * const h = sha224.end(state) // 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn
+ * const h = sha224.end(state) // 0x1_619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn
  * ```
  */
 export type Sha2 = {

package/crypto/sign/module.f.d.ts

@@ -0,0 +1,5 @@
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type Init } from '../secp/module.f.ts';
+import type { Sha2 } from '../sha2/module.f.ts';
+export declare const newPrivateKey: (i: Init) => (random: Vec) => Vec;
+export declare const sign: (sha2: Sha2) => (curveInit: Init) => (privateKey: Vec) => (messageHash: Vec) => readonly [bigint, bigint];

package/crypto/sign/module.f.js

@@ -0,0 +1,53 @@
+import { listToVec, msb, uint, vec, vec8, length } from "../../types/bit_vec/module.f.js";
+import { hmac } from "../hmac/module.f.js";
+import { curve } from "../secp/module.f.js";
+const concat = listToVec(msb);
+const v00 = vec8(0x00n);
+const v01 = vec8(0x01n);
+/**
+ * The size of the result equals the size of the hash.
+ *
+ * @param sha2 SHA2 hash function
+ * @returns A function that accepts a private key, a message hash and returns `k`.
+ */
+const createK = (sha2) => {
+    const h = hmac(sha2);
+    let vs = vec(sha2.hashLength);
+    let k0 = vs(0x00n);
+    let v0 = vs(0x01n);
+    return (privateKey) => (messageHash) => {
+        const pm = concat([privateKey, messageHash]);
+        let k = k0;
+        let v = v0;
+        k = h(k)(concat([v, v00, pm]));
+        v = h(k)(v);
+        k = h(k)(concat([v, v01, pm]));
+        v = h(k)(v);
+        return uint(h(k)(v));
+    };
+};
+export const newPrivateKey = (i) => (random) => {
+    const { nf } = curve(i);
+    if (length(nf.max) < length(random)) {
+        throw "need more random bits";
+    }
+    return uint(random) % nf.p;
+};
+export const sign = (sha2) => (curveInit) => (privateKey) => (messageHash) => {
+    const { mul, pf } = curve(curveInit);
+    // const curveVec = vec(length(pf.max))
+    //`k` is a unique for each `z` and secret.
+    const k = createK(sha2)(privateKey)(messageHash) % pf.p;
+    // `R = G * k`.
+    const rp = mul(curveInit.g)(k);
+    // `r = R.x`
+    const r = rp === null ? 0n : rp[0];
+    // `s = ((z + r * d) / k)`.
+    const d = uint(privateKey);
+    const z = uint(messageHash);
+    const rd = pf.mul(r)(d);
+    const zrd = pf.add(z)(rd);
+    const kn1 = pf.reciprocal(k);
+    const s = pf.mul(zrd)(kn1);
+    return [r, s];
+};

package/crypto/sign/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/crypto/sign/test.f.js

@@ -0,0 +1 @@
+export default {};

package/dev/test.f.js

@@ -18,7 +18,7 @@ export default {
     ctorUndefined: () => {
         /** @type {any} */
         const o = {
-            constructor: void 0
+            constructor: undefined
         };
         const c = o['constructor'];
         //console.log(c)

package/dev/tf/all.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dev/tf/all.test.js

@@ -0,0 +1,43 @@
+import { io } from "../../io/module.js";
+import { loadModuleMap } from "../module.f.js";
+import { isTest, parseTestSet } from "./module.f.js";
+import * as nodeTest from 'node:test';
+const isBun = typeof Bun !== 'undefined';
+const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
+const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
+const framework = isBun ? createBunFramework(nodeTest) : createFramework(nodeTest);
+const parse = parseTestSet(io.tryCatch);
+const scanModule = (x) => async (subTestRunner) => {
+    let subTests = [x];
+    while (true) {
+        const [first, ...rest] = subTests;
+        if (first === undefined) {
+            break;
+        }
+        subTests = rest;
+        //
+        const [name, value] = first;
+        const set = parse(value);
+        if (typeof set === 'function') {
+            await subTestRunner(name, () => {
+                const r = set();
+                subTests = [...subTests, [`${name}()`, r]];
+            });
+        }
+        else {
+            for (const [j, y] of set) {
+                const pr = `${name}/${j}`;
+                subTests = [...subTests, [pr, y]];
+            }
+        }
+    }
+};
+const run = async () => {
+    const x = await loadModuleMap(io);
+    for (const [i, v] of Object.entries(x)) {
+        if (isTest(i)) {
+            framework(i, scanModule(['', v.default]));
+        }
+    }
+};
+await run();

package/dev/{test → tf}/module.f.d.ts

@@ -1,7 +1,8 @@
+import { type CsiConsole } from '../../text/sgr/module.f.ts';
 import type * as Result from '../../types/result/module.f.ts';
-import type { Io, Performance } from '../../io/module.f.ts';
+import type { Io, Performance, TryCatch } from '../../io/module.f.ts';
 import { type ModuleMap } from '../module.f.ts';
-type Log<T> = (v: string) => (state: T) => T;
+type Log<T> = CsiConsole;
 type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
 type Input<T> = {
     readonly moduleMap: ModuleMap;
@@ -12,6 +13,10 @@ type Input<T> = {
     readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
     readonly env: (n: string) => string | undefined;
 };
+export declare const isTest: (s: string) => boolean;
+export type Test = () => unknown;
+export type TestSet = Test | readonly (readonly [string, unknown])[];
+export declare const parseTestSet: (t: TryCatch) => (x: unknown) => TestSet;
 export declare const test: <T>(input: Input<T>) => readonly [number, T];
 export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
 export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];

package/dev/tf/module.f.js

@@ -0,0 +1,117 @@
+import { entries, fold } from "../../types/list/module.f.js";
+import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
+import { env, loadModuleMap } from "../module.f.js";
+export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
+const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
+const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
+const timeFormat = (a) => {
+    const y = Math.round(a * 10_000).toString();
+    const yl = 5 - y.length;
+    const x = '0'.repeat(yl > 0 ? yl : 0) + y;
+    const s = x.length - 4;
+    const b = x.substring(0, s);
+    const e = x.substring(s);
+    return `${b}.${e} ms`;
+};
+export const parseTestSet = (t) => (x) => {
+    switch (typeof x) {
+        case 'function': {
+            if (x.length === 0) {
+                const xt = x;
+                if (xt.name !== 'throw') {
+                    return xt;
+                }
+                // Usual tests throw on error, but if the function name is 'throw',
+                // then the test passes if it throws.
+                return () => {
+                    const [tag, value] = t(xt);
+                    if (tag === 'ok') {
+                        throw value;
+                    }
+                    return value;
+                };
+            }
+            break;
+        }
+        case 'object': {
+            if (x !== null) {
+                return Object.entries(x);
+            }
+            break;
+        }
+    }
+    return [];
+};
+export const test = (input) => {
+    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
+    const isGitHub = env('GITHUB_ACTION') !== undefined;
+    const parse = parseTestSet(tryCatch);
+    const f = ([k, v]) => {
+        const test = i => v => ([ts, state]) => {
+            const next = test(`${i}| `);
+            const set = parse(v);
+            if (typeof set === 'function') {
+                const [[s, r], delta, state0] = measure(() => tryCatch(set))(state);
+                state = state0;
+                if (s !== 'ok') {
+                    ts = addFail(delta)(ts);
+                    if (isGitHub) {
+                        // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+                        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+                        error(`::error file=${k},line=1,title=[3]['a']()::${r}`);
+                    }
+                    else {
+                        error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
+                        error(`${fgRed}${r}${reset}`);
+                    }
+                }
+                else {
+                    ts = addPass(delta)(ts);
+                    log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
+                    [ts, state] = next(r)([ts, state]);
+                }
+            }
+            else {
+                const f = ([k, v]) => ([time, state]) => {
+                    log(`${i}${k}:`);
+                    [time, state] = next(v)([time, state]);
+                    return [time, state];
+                };
+                [ts, state] = fold(f)([ts, state])(set);
+            }
+            return [ts, state];
+        };
+        return ([ts, state]) => {
+            if (isTest(k)) {
+                log(`testing ${k}`);
+                [ts, state] = test('| ')(v.default)([ts, state]);
+            }
+            return [ts, state];
+        };
+    };
+    let ts = { time: 0, pass: 0, fail: 0 };
+    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
+    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
+    log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`);
+    log(`${bold}Time: ${timeFormat(ts.time)}${reset}`);
+    return [ts.fail !== 0 ? 1 : 0, state];
+};
+export const anyLog = (f) => (s) => (state) => {
+    f(s);
+    return state;
+};
+export const measure = (p) => (f) => (state) => {
+    const b = p.now();
+    const r = f();
+    const e = p.now();
+    return [r, e - b, state];
+};
+export const main = async (io) => test({
+    moduleMap: await loadModuleMap(io),
+    log: stdio(io), // anyLog(io.console.log),
+    error: stderr(io), // anyLog(io.console.error),
+    measure: measure(io.performance),
+    tryCatch: io.tryCatch,
+    env: env(io),
+    state: undefined,
+})[0];

package/dev/tf/test.f.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    throw: () => never;
+};
+export default _default;

package/dev/tf/test.f.js

@@ -0,0 +1,5 @@
+export default {
+    throw: () => {
+        throw [() => { }, () => { }];
+    }
+};

package/io/module.f.d.ts

@@ -25,6 +25,7 @@ export type MakeDirectoryOptions = {
  * @see https://nodejs.org/api/fs.html
  */
 export type Fs = {
+    readonly writeSync: (fd: number, s: string) => void;
     readonly writeFileSync: (file: string, data: string) => void;
     readonly readFileSync: (path: string, options: BufferEncoding) => string | null;
     readonly existsSync: (path: string) => boolean;
@@ -60,6 +61,10 @@ export type Module = {
 export type Performance = {
     readonly now: () => number;
 };
+export type Writable = {
+    readonly fd: number;
+    readonly isTTY: boolean;
+};
 /**
  * Node.js Process interface
  * @see https://nodejs.org/api/process.html
@@ -69,7 +74,10 @@ export type Process = {
     readonly env: Env;
     readonly exit: (code: number) => never;
     readonly cwd: () => string;
+    readonly stdout: Writable;
+    readonly stderr: Writable;
 };
+export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
 /**
  * Core IO operations interface providing access to system resources
  */
@@ -80,7 +88,7 @@ export type Io = {
     readonly asyncImport: (s: string) => Promise<Module>;
     readonly performance: Performance;
     readonly fetch: (url: string) => Promise<Response>;
-    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
+    readonly tryCatch: TryCatch;
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
 };
 /**

package/io/virtual/module.f.js

@@ -5,6 +5,7 @@ export const createVirtualIo = (files) => ({
         error: (..._d) => { }
     },
     fs: {
+        writeSync: (fd, s) => { },
         writeFileSync: (_file, _data) => { },
         readFileSync: (path, _options) => { return at(path)(files); },
         existsSync: (path) => { return at(path)(files) !== null; },
@@ -22,6 +23,8 @@ export const createVirtualIo = (files) => ({
         env: {},
         exit: n => { throw n; },
         cwd: () => '',
+        stdout: { fd: 1, isTTY: false },
+        stderr: { fd: 2, isTTY: false },
     },
     asyncImport: () => Promise.reject(),
     performance: {

package/issues/test.f.d.ts

@@ -1,7 +1,12 @@
 declare const _default: {
     literal: () => void;
     ownProperty: {
-        nullish: () => void;
+        null: {
+            throw: () => PropertyDescriptor | undefined;
+        };
+        undefined: {
+            throw: () => PropertyDescriptor | undefined;
+        };
         bool: () => void;
         array: () => void;
         object: {

package/issues/test.f.js

@@ -6,19 +6,11 @@ export default {
         const m = '<html>Hello</html>';
     },
     ownProperty: {
-        nullish: () => {
-            /* // panic
-            const v = Object.getOwnPropertyDescriptor(null, 0)
-            if (v !== undefined) {
-                throw v
-            }
-            */
-            /* // panic
-            const v = Object.getOwnPropertyDescriptor(undefined, 0)
-            if (v !== undefined) {
-                throw v
-            }
-            */
+        null: {
+            throw: () => Object.getOwnPropertyDescriptor(null, 0),
+        },
+        undefined: {
+            throw: () => Object.getOwnPropertyDescriptor(undefined, 0),
         },
         bool: () => {
             const v = at(true)('x');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.6.10",
+  "version": "0.7.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -10,11 +10,12 @@
   "scripts": {
     "prepack": "tsc --NoEmit false",
     "git-clean": "git clean -xf",
-    "test20": "npm run prepack && node ./dev/test/module.js",
-    "test22": "tsc && node --experimental-strip-types ./dev/test/module.ts",
-    "test": "tsc && node ./dev/test/module.ts",
+    "test20": "npm run prepack && node --test",
+    "test22": "tsc && node --test --experimental-strip-types",
+    "test": "tsc && node --test",
     "index": "node ./dev/index/module.ts",
     "fsc": "node ./fsc/module.ts",
+    "fst": "node ./dev/tf/module.ts",
     "update": "npm run index && npm install"
   },
   "engines": {
@@ -22,7 +23,7 @@
   },
   "bin": {
     "fsc": "fsc/module.js",
-    "fst": "dev/test/module.js"
+    "fst": "dev/tf/module.js"
   },
   "repository": {
     "type": "git",
@@ -44,7 +45,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.15.30",
-    "typescript": "^5.8.3"
+    "@types/node": "^24.2.0",
+    "@typescript/native-preview": "^7.0.0-dev.20250805.1",
+    "typescript": "^5.9.2"
   }
 }

package/text/module.f.d.ts

@@ -5,7 +5,6 @@ type ItemArray = readonly Item[];
 type ItemThunk = () => List<Item>;
 export type Item = string | ItemArray | ItemThunk;
 export declare const flat: (indent: string) => (text: Block) => List<string>;
-export declare const curly: (type: string) => (name: string) => (body: Block) => Block;
 /**
  * Converts a string to an UTF-8, represented as an MSB first bit vector.
  *

package/text/module.f.js

@@ -1,6 +1,6 @@
 import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
 import { flatMap } from "../types/list/module.f.js";
-import * as utf8 from "./utf8/module.f.js";
+import { fromCodePointList, toCodePointList } from "./utf8/module.f.js";
 import { stringToCodePointList, codePointListToString } from "./utf16/module.f.js";
 export const flat = (indent) => {
     const f = (prefix) => {
@@ -9,18 +9,18 @@ export const flat = (indent) => {
     };
     return f('');
 };
-export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body, '}'];
+const u8ListToVecMsb = u8ListToVec(msb);
 /**
  * Converts a string to an UTF-8, represented as an MSB first bit vector.
  *
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(stringToCodePointList(s)));
+export const msbUtf8 = (s) => u8ListToVecMsb(fromCodePointList(stringToCodePointList(s)));
 /**
  * Converts a UTF-8 bit vector with MSB first encoding to a string.
  *
  * @param msbV - The UTF-8 bit vector with MSB first encoding.
  * @returns The resulting string.
  */
-export const msbUtf8ToString = (msbV) => codePointListToString(utf8.toCodePointList(u8List(msb)(msbV)));
+export const msbUtf8ToString = (msbV) => codePointListToString(toCodePointList(u8List(msb)(msbV)));

package/text/sgr/module.f.d.ts

@@ -1,3 +1,4 @@
+import type { Io, Writable } from "../../io/module.f.ts";
 export declare const backspace: string;
 type End = 'm';
 type Csi = (code: number | string) => string;
@@ -23,4 +24,8 @@ export type Stdout = {
 };
 export type WriteText = (text: string) => WriteText;
 export declare const createConsoleText: (stdout: Stdout) => WriteText;
+export type CsiConsole = (s: string) => void;
+export declare const console: ({ fs: { writeSync } }: Io) => (w: Writable) => CsiConsole;
+export declare const stdio: (io: Io) => CsiConsole;
+export declare const stderr: (io: Io) => CsiConsole;
 export {};

package/text/sgr/module.f.js

@@ -1,6 +1,7 @@
 // Co control codes
 // https://en.wikipedia.org/wiki/ANSI_escape_code#C0_control_codes
 export const backspace = '\x08';
+const begin = '\x1b[';
 /**
  * Control Sequence Introducer (CSI) escape sequence.
  * https://en.wikipedia.org/wiki/ANSI_escape_code#Control_Sequence_Introducer_commands
@@ -8,7 +9,7 @@ export const backspace = '\x08';
  * @param end - The final character that indicates the type of sequence.
  * @returns A function that takes a code (number or string) and returns the complete ANSI escape sequence.
  */
-export const csi = (end) => code => `\x1b[${code.toString()}${end}`;
+export const csi = (end) => code => `${begin}${code.toString()}${end}`;
 /**
  * Specialization of CSI for Select Graphic Rendition (SGR) sequences.
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
@@ -31,3 +32,11 @@ export const createConsoleText = (stdout) => {
     };
     return f('');
 };
+export const console = ({ fs: { writeSync } }) => (w) => {
+    const { isTTY } = w;
+    return isTTY
+        ? (s) => writeSync(w.fd, s + '\n')
+        : (s) => writeSync(w.fd, s.replace(/\x1b\[[0-9;]*m/g, '') + '\n');
+};
+export const stdio = (io) => console(io)(io.process.stdout);
+export const stderr = (io) => console(io)(io.process.stderr);

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

@@ -152,3 +152,4 @@ export declare const u8ListToVec: (bo: BitOrder) => (list: List<number>) => Vec;
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export declare const u8List: ({ popFront }: BitOrder) => (v: Vec) => Thunk<number>;
+export declare const listToVec: (bo: BitOrder) => (list: List<Vec>) => Vec;

package/types/bit_vec/module.f.js

@@ -136,3 +136,4 @@ export const u8List = ({ popFront }) => {
     };
     return f;
 };
+export const listToVec = (bo) => fold(bo.concat)(empty);

package/dev/test/module.f.js

@@ -1,95 +0,0 @@
-import { entries, fold } from "../../types/list/module.f.js";
-import { reset, fgGreen, fgRed, bold } from "../../text/sgr/module.f.js";
-import { env, loadModuleMap } from "../module.f.js";
-const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
-const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
-const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
-const timeFormat = (a) => {
-    const y = Math.round(a * 10_000).toString();
-    const yl = 5 - y.length;
-    const x = '0'.repeat(yl > 0 ? yl : 0) + y;
-    const s = x.length - 4;
-    const b = x.substring(0, s);
-    const e = x.substring(s);
-    return `${b}.${e} ms`;
-};
-export const test = (input) => {
-    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
-    const isGitHub = env('GITHUB_ACTION') !== undefined;
-    const f = ([k, v]) => {
-        const test = i => v => ([ts, state]) => {
-            const next = test(`${i}| `);
-            switch (typeof v) {
-                case 'function': {
-                    if (v.length === 0) {
-                        const [[s, r], delta, state0] = measure(() => tryCatch(v))(state);
-                        state = state0;
-                        // Usual tests throw on error, but if the function name is 'throw', then the test passes if it throws.
-                        if ((s === 'error') === (v.name !== 'throw')) {
-                            ts = addFail(delta)(ts);
-                            if (isGitHub) {
-                                // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                                // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                                state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state);
-                            }
-                            else {
-                                state = error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`)(state);
-                                state = error(`${fgRed}${r}${reset}`)(state);
-                            }
-                        }
-                        else {
-                            ts = addPass(delta)(ts);
-                            state = log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`)(state);
-                        }
-                        [ts, state] = next(r)([ts, state]);
-                    }
-                    break;
-                }
-                case 'object': {
-                    if (v !== null) {
-                        const f = ([k, v]) => ([time, state]) => {
-                            state = log(`${i}${k}:`)(state);
-                            [time, state] = next(v)([time, state]);
-                            return [time, state];
-                        };
-                        [ts, state] = fold(f)([ts, state])(v instanceof Array ? entries(v) : Object.entries(v));
-                    }
-                    break;
-                }
-            }
-            return [ts, state];
-        };
-        return ([ts, state]) => {
-            if (isTest(k)) {
-                state = log(`testing ${k}`)(state);
-                [ts, state] = test('| ')(v.default)([ts, state]);
-            }
-            return [ts, state];
-        };
-    };
-    let ts = { time: 0, pass: 0, fail: 0 };
-    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
-    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
-    state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state);
-    state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
-    return [ts.fail !== 0 ? 1 : 0, state];
-};
-export const anyLog = (f) => (s) => (state) => {
-    f(s);
-    return state;
-};
-export const measure = (p) => (f) => (state) => {
-    const b = p.now();
-    const r = f();
-    const e = p.now();
-    return [r, e - b, state];
-};
-export const main = async (io) => test({
-    moduleMap: await loadModuleMap(io),
-    log: anyLog(io.console.log),
-    error: anyLog(io.console.error),
-    measure: measure(io.performance),
-    tryCatch: io.tryCatch,
-    env: env(io),
-    state: undefined,
-})[0];