functionalscript 0.9.1 → 0.9.3

package/README.md

@@ -26,7 +26,7 @@ This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and dist
 Install FunctionalScript via npm:
 
 ```bash
-npm install functionalscript
+npm install -g functionalscript
 ```
 
 The FunctionalScript compiler command (`fjs compile`) currently supports:
@@ -39,9 +39,9 @@ It does **not** yet support functions or complex expressions.
 Example usage with `fjs`:
 
 ```bash
-npx fjs compile example.f.js output.json
+fjs compile example.f.js output.json
 # or
-npx fjs compile example.f.js output.f.js
+fjs compile example.f.js output.f.js
 ```
 
 FunctionalScript code can be compiled directly into either JSON or JavaScript without imports.

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

@@ -1,4 +1,6 @@
 declare const _default: {
+    rangeDecode: () => void;
+    rangeEncode: () => void;
     toData: (() => void)[];
     emptyTags: (() => void)[];
     variantTest: () => void;

package/bnf/data/test.f.js

@@ -3,7 +3,7 @@ import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { join0Plus, option, range, repeat0Plus, set } from "../module.f.js";
+import { join0Plus, oneEncode, option, range, rangeDecode, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
 import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap, descentParser } from "./module.f.js";
 const mapCodePoint = (cp) => [cp, undefined];
@@ -12,6 +12,34 @@ const descentParserCpOnly = (m, name, cp) => {
     return m(name, cpm);
 };
 export default {
+    rangeDecode: () => {
+        const decoded1 = stringify(sort)(rangeDecode(0x000079_000087));
+        if (decoded1 !== '[121,135]') {
+            throw decoded1;
+        }
+        const decoded2 = stringify(sort)(rangeDecode(0x000080_000087));
+        if (decoded2 !== '[128,135]') {
+            throw decoded2;
+        }
+        const decoded3 = stringify(sort)(rangeDecode(0x10FFFF_10FFFF));
+        if (decoded3 !== '[1114111,1114111]') {
+            throw decoded3;
+        }
+    },
+    rangeEncode: () => {
+        const encoded1 = oneEncode(0x79);
+        if (encoded1 !== 0x000079_000079) {
+            throw encoded1;
+        }
+        const encoded2 = oneEncode(0x80);
+        if (encoded2 !== 0x000080_000080) {
+            throw encoded2;
+        }
+        const encoded3 = oneEncode(0x10FFFF);
+        if (encoded3 !== 0x10FFFF_10FFFF) {
+            throw encoded3;
+        }
+    },
     toData: [
         () => {
             const c = toData(classic());
@@ -281,7 +309,16 @@ export default {
             }
         },
         () => {
-            const terminalRangeRule = range('AF');
+            const terminalRangeRule = 0x000079_000087;
+            const m = parser(terminalRangeRule);
+            const mr = m("", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,[64]]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = 0x000080_000087; //broken range
             const m = parser(terminalRangeRule);
             const mr = m("", [64]);
             const result = JSON.stringify(mr);

package/bnf/module.f.d.ts

@@ -7,6 +7,8 @@ import { type Array2 } from '../types/array/module.f.ts';
  * - 0xEEEEEE is the last symbol (24 bits)
  */
 export type TerminalRange = number;
+export declare const fullRange: TerminalRange;
+export declare const unicodeRange: TerminalRange;
 /** A sequence of rules. */
 export type Sequence = readonly Rule[];
 /** A variant */
@@ -19,6 +21,7 @@ export type Rule = DataRule | LazyRule;
 export declare const max: string;
 export declare const rangeEncode: (a: number, b: number) => TerminalRange;
 export declare const oneEncode: (a: number) => TerminalRange;
+export declare const eof: TerminalRange;
 export declare const rangeDecode: (r: number) => Array2<number>;
 export declare const toSequence: (s: string) => readonly TerminalRange[];
 export declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;
@@ -30,8 +33,9 @@ export declare const range: (ab: string) => TerminalRange;
 export type RangeVariant = {
     readonly [k in string]: TerminalRange;
 };
-export declare const rangeToId: (r: TerminalRange) => string;
-export declare const remove: (range: TerminalRange, removeSet: RangeVariant) => RangeVariant;
+export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
+export declare const not: (v: RangeVariant) => RangeVariant;
+export declare const notSet: (s: string) => RangeVariant;
 export type None = readonly [];
 export declare const none: None;
 export type Option<S> = {

package/bnf/module.f.js

@@ -1,6 +1,8 @@
 import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
 import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
+export const fullRange = 0x000000_FFFFFF;
+export const unicodeRange = 0x000000_10FFFF;
 // Internals:
 const { fromEntries, values } = Object;
 const { fromCodePoint } = String;
@@ -15,10 +17,11 @@ export const rangeEncode = (a, b) => {
     if (!isValid(a) || !isValid(b) || a > b) {
         throw `Invalid range ${a} ${b}.`;
     }
-    return (a << offset) | b;
+    return Number((BigInt(a) << BigInt(offset)) | BigInt(b));
 };
 export const oneEncode = (a) => rangeEncode(a, a);
-export const rangeDecode = (r) => [r >> offset, r & mask];
+export const eof = oneEncode(0x110000);
+export const rangeDecode = (r) => [Number(BigInt(r) >> BigInt(offset)), Number(BigInt(r) & BigInt(mask))];
 const mapOneEncode = map(oneEncode);
 export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
 export const str = (s) => {
@@ -34,13 +37,7 @@ export const range = (ab) => {
     }
     return rangeEncode(...a);
 };
-export const rangeToId = (r) => {
-    const ab = rangeDecode(r);
-    const [a, b] = ab;
-    const cp = a === b ? [a] : ab;
-    return fromCodePoint(...cp);
-};
-const rangeToEntry = (r) => [rangeToId(r), r];
+const rangeToEntry = (r) => ['0x' + r.toString(16), r];
 const toVariantRangeSet = (r) => fromEntries(r.map(rangeToEntry));
 const removeOne = (list, ab) => {
     const [a, b] = rangeDecode(ab);
@@ -60,13 +57,15 @@ const removeOne = (list, ab) => {
     }
     return result;
 };
-export const remove = (range, removeSet) => {
+export const remove = (range, v) => {
     let result = [range];
-    for (const r of values(removeSet)) {
+    for (const r of values(v)) {
         result = removeOne(result, r);
     }
     return toVariantRangeSet(result);
 };
+export const not = (v) => remove(fullRange, v);
+export const notSet = (s) => not(set(s));
 export const none = [];
 export const option = (some) => ({
     some,

package/cas/module.f.d.ts

@@ -1,17 +1,18 @@
 import { type Sha2 } from "../crypto/sha2/module.f.ts";
-import type { Io } from "../io/module.f.ts";
-import { type Vec } from "../types/bit_vec/module.f.ts";
-export type KvStore = {
-    readonly read: (key: Vec) => Promise<Vec | undefined>;
-    readonly write: (key: Vec, value: Vec) => Promise<KvStore>;
-    readonly list: () => Promise<Iterable<Vec>>;
+import type { Vec } from "../types/bit_vec/module.f.ts";
+import { type Effect, type Operations } from "../types/effect/module.f.ts";
+import { type Fs, type NodeOperations } from "../types/effect/node/module.f.ts";
+export type KvStore<O extends Operations> = {
+    readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    readonly write: (key: Vec, value: Vec) => Effect<O, void>;
+    readonly list: () => Effect<O, readonly Vec[]>;
 };
 export type Kv = readonly [Vec, Vec];
-export declare const memKvStore: () => KvStore;
-export declare const fileKvStore: (io: Io) => (path: string) => KvStore;
-export type Cas = {
-    readonly read: (key: Vec) => Promise<Vec | undefined>;
-    readonly write: (value: Vec) => Promise<readonly [Cas, Vec]>;
-    readonly list: () => Promise<Iterable<Vec>>;
+export declare const fileKvStore: (path: string) => KvStore<Fs>;
+export type Cas<O extends Operations> = {
+    readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    readonly write: (value: Vec) => Effect<O, Vec>;
+    readonly list: () => Effect<O, readonly Vec[]>;
 };
-export declare const cas: (sha2: Sha2) => (s: KvStore) => Cas;
+export declare const cas: (sha2: Sha2) => <O extends Operations>(_: KvStore<O>) => Cas<O>;
+export declare const main: (args: readonly string[]) => Effect<NodeOperations, number>;

package/cas/module.f.js

@@ -1,77 +1,95 @@
-import { computeSync } from "../crypto/sha2/module.f.js";
-import { todo } from "../dev/module.f.js";
-import {} from "../types/bit_vec/module.f.js";
+import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
+import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../types/cbase32/module.f.js";
-import { compose } from "../types/function/module.f.js";
+import { pure } from "../types/effect/module.f.js";
+import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effect/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
-import { fromVec, toVec } from "../types/uint8array/module.f.js";
-export const memKvStore = () => {
-    const create = (...i) => {
-        const store = new Map(i);
-        return {
-            read: async (key) => store.get(key),
-            write: async (...kv) => create(...store, kv),
-            list: async () => store.keys(),
-        };
-    };
-    return create();
-};
+import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };
 const split = (s) => [s.substring(0, 2), s.substring(2)];
+const prefix = '.cas';
 const toPath = (key) => {
     const s = vecToCBase32(key);
     const [a, bc] = split(s);
     const [b, c] = split(bc);
-    return `${a}/${b}/${c}`;
-};
-export const fileKvStore = (io) => (path) => {
-    const { readdir, readFile, writeFile } = io.fs.promises;
-    const { asyncTryCatch } = io;
-    const result = {
-        read: async (key) => {
-            const p = toPath(key);
-            const [s, v] = await asyncTryCatch(() => readFile(`${path}/${p}`));
-            if (s === 'error') {
-                return undefined;
-            }
-            return toVec(v);
-        },
-        write: async (key, value) => {
-            const p = toPath(key);
-            await writeFile(`${path}/${p}`, fromVec(value));
-            return result;
-        },
-        list: async () => {
-            const f = async (p) => {
-                const dir = await readdir(p, o);
-                let result = [];
-                for (const entry of dir) {
-                    const { name } = entry;
-                    if (entry.isFile()) {
-                        result = [...result, name];
-                        continue;
-                    }
-                    // directory
-                    const sub = await f(`${p}/${name}`);
-                    result = [...result, ...sub.map(x => `${name}${x}`)];
-                }
-                return result;
-            };
-            const all = await f(path);
-            return all.flatMap(compose(cBase32ToVec)(toOption));
-        },
-    };
-    return result;
+    return `${prefix}/${a}/${b}/${c}`;
 };
+export const fileKvStore = (path) => ({
+    read: (key) => readFile(toPath(key))
+        .map(([status, data]) => status === 'error' ? undefined : data),
+    write: (key, value) => {
+        const p = toPath(key);
+        const parts = parse(p);
+        const dir = `${path}/${parts.slice(0, -1).join('/')}`;
+        // TODO: error handling
+        return mkdir(dir, { recursive: true })
+            .pipe(() => writeFile(`${path}/${p}`, value))
+            .map(() => undefined);
+    },
+    list: () => readdir('.cas', { recursive: true })
+        // TODO: remove unwrap
+        .map(r => unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name) : null))),
+});
 export const cas = (sha2) => {
     const compute = computeSync(sha2);
-    const f = ({ read, list, write }) => ({
+    return ({ read, write, list }) => ({
         read,
-        write: async (value) => {
+        write: (value) => {
             const hash = compute([value]);
-            return [f(await write(hash, value)), hash];
+            return write(hash, value)
+                .map(() => hash);
         },
         list,
     });
-    return f;
+};
+const e = (s) => error(s).map(() => 1);
+export const main = (args) => {
+    const c = cas(sha256)(fileKvStore('.'));
+    const [cmd, ...options] = args;
+    switch (cmd) {
+        case 'add': {
+            if (options.length !== 1) {
+                return e("'cas add' expects one parameter");
+            }
+            const [path] = options;
+            return readFile(path)
+                .pipe(v => c.write(unwrap(v)))
+                .pipe(hash => log(vecToCBase32(hash)))
+                .map(() => 0);
+        }
+        case 'get': {
+            if (options.length !== 2) {
+                return e("'cas get' expects two parameters");
+            }
+            const [hashCBase32, path] = options;
+            const hash = cBase32ToVec(hashCBase32);
+            if (hash === null) {
+                return e(`invalid hash format: ${hashCBase32}`);
+            }
+            return c.read(hash)
+                .pipe(v => {
+                const result = v === undefined
+                    ? e(`no such hash: ${hashCBase32}`)
+                    : writeFile(path, v).map(() => 0);
+                return result;
+            });
+        }
+        case 'list': {
+            return c.list()
+                .pipe(v => {
+                // TODO: make it lazy.
+                let i = pure(undefined);
+                for (const j of v) {
+                    i = i.pipe(() => log(vecToCBase32(j)));
+                }
+                return i;
+            })
+                .map(() => 0);
+        }
+        case undefined: {
+            return e('Error: CAS command requires subcommand');
+        }
+        default:
+            return e(`Error: Unknown CAS subcommand "${args[0]}"`);
+    }
 };

package/ci/module.f.d.ts

@@ -1,3 +1,4 @@
-import type { Io } from '../io/module.f.ts';
-declare const _default: (io: Io) => Promise<number>;
+import { type NodeEffect } from '../types/effect/node/module.f.ts';
+export declare const effect: NodeEffect<number>;
+declare const _default: () => NodeEffect<number>;
 export default _default;

package/ci/module.f.js

@@ -1,4 +1,5 @@
-import { encodeUtf8 } from "../types/uint8array/module.f.js";
+import { utf8 } from "../text/module.f.js";
+import { writeFile } from "../types/effect/node/module.f.js";
 const os = ['ubuntu', 'macos', 'windows'];
 const architecture = ['intel', 'arm'];
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
@@ -72,9 +73,7 @@ const toSteps = (m) => {
     return [
         ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
         ...(rust ? [{
-                // wasm32-wasip1-threads doesn't work on Rust 1.91 in the release mode.
-                // See https://github.com/sergey-shandar/wasmtime-crash
-                uses: 'dtolnay/rust-toolchain@1.92.0',
+                uses: 'dtolnay/rust-toolchain@1.93.1',
                 with: {
                     components: 'rustfmt,clippy',
                     targets
@@ -165,7 +164,6 @@ const gha = {
     on: { pull_request: {} },
     jobs,
 };
-export default async (io) => {
-    io.fs.writeFileSync('.github/workflows/ci.yml', encodeUtf8(JSON.stringify(gha, null, '  ')));
-    return 0;
-};
+export const effect = writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
+    .map(() => 0);
+export default () => effect;

package/ci/module.js

@@ -1,3 +1,3 @@
-import node from "../io/module.js";
-import x from "./module.f.js";
-await node(x);
+import { nodeRun } from "../io/module.js";
+import run from "./module.f.js";
+await nodeRun(run);

package/crypto/hmac/test.f.js

@@ -1,5 +1,5 @@
 import { utf8 } from "../../text/module.f.js";
-import { length, uint, vec } from "../../types/bit_vec/module.f.js";
+import { uint, vec } from "../../types/bit_vec/module.f.js";
 import { sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { hmac } from "./module.f.js";
 export default {

package/crypto/sign/test.f.js

@@ -1,7 +1,7 @@
 import { utf8 } from "../../text/module.f.js";
 import { empty, msb, repeat, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
-import { curve, secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
+import { secp192r1, secp256r1, secp384r1, secp521r1 } from "../secp/module.f.js";
 import { computeSync, sha224, sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { all, concat, computeK, fromCurve, sign } from "./module.f.js";
 const sample = utf8("sample");

package/dev/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { Io } from '../io/module.f.ts';
+import { type Io } from '../io/module.f.ts';
 export declare const todo: () => never;
 export type Module = {
     readonly default?: unknown;

package/dev/module.f.js

@@ -1,5 +1,9 @@
+import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
 import { decodeUtf8, encodeUtf8 } from "../types/uint8array/module.f.js";
+import { readFile } from "../types/effect/node/module.f.js";
+import { utf8ToString } from "../text/module.f.js";
+import { unwrap } from "../types/result/module.f.js";
 export const todo = () => { throw 'not implemented'; };
 const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 export const env = ({ process: { env } }) => a => {
@@ -9,7 +13,7 @@ export const env = ({ process: { env } }) => a => {
             r.value;
 };
 export const allFiles = (io) => (s) => {
-    const { fs: { promises: { readdir } }, process: { cwd } } = io;
+    const { fs: { promises: { readdir } } } = io;
     const load = async (p) => {
         let result = [];
         for (const i of await readdir(p, { withFileTypes: true })) {
@@ -47,18 +51,21 @@ export const loadModuleMap = async (io) => {
     }
     return Object.fromEntries(map.toSorted(cmp));
 };
+const denoJson = './deno.json';
+const index2 = updateVersion
+    .pipe(() => readFile(denoJson))
+    .map(v => JSON.parse(utf8ToString(unwrap(v))));
 export const index = async (io) => {
-    updateVersion(io);
-    const jj = './deno.json';
-    const jsr_json = JSON.parse(decodeUtf8(await io.fs.promises.readFile(jj)));
+    const runner = fromIo(io);
+    const jsr_json = await runner(index2);
     const list = (await allFiles(io)('.')).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
-    //console.log(list)
+    // console.log(list)
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
     // console.log(exportsA)
     const exports = Object.fromEntries(exportsA);
     // console.log(exports)
     const json = JSON.stringify({ ...jsr_json, exports }, null, 2);
     // console.log(json)
-    await io.fs.promises.writeFile(jj, encodeUtf8(json));
+    await io.fs.promises.writeFile(denoJson, encodeUtf8(json));
     return 0;
 };

package/dev/tf/all.test.js

@@ -7,11 +7,11 @@ const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
 // Bun doesn't support nested tests yet.
 const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const createPlaywrihtFramework = async () => {
+const createPlaywrightFramework = async () => {
     const pwTest = (await import('@playwright/test')).test;
     return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
 };
-const framework = isPlaywright ? await createPlaywrihtFramework() :
+const framework = isPlaywright ? await createPlaywrightFramework() :
     isBun ? createBunFramework(nodeTest) :
         createFramework(nodeTest);
 const parse = parseTestSet(io.tryCatch);

package/dev/tf/module.f.js

@@ -1,4 +1,4 @@
-import { entries, fold } from "../../types/list/module.f.js";
+import { 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');
@@ -58,7 +58,7 @@ export const test = (input) => {
                     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}`);
+                        error(`::error file=${k},line=1,title=${i}()::${r}`);
                     }
                     else {
                         error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);

package/dev/version/module.f.d.ts

@@ -1,11 +1,2 @@
-export type Buffer = object;
-type Fs<T> = {
-    readonly readFileSync: (name: string) => Uint8Array;
-    readonly writeFileSync: (name: string, content: Uint8Array) => T;
-};
-export type Node<T> = {
-    readonly fs: Fs<T>;
-};
-export declare const getVersion: <T>(fs: Fs<T>) => string;
-export declare const updateVersion: <T>(node: Node<T>) => readonly [T, T];
-export {};
+import { type NodeEffect } from "../../types/effect/node/module.f.ts";
+export declare const updateVersion: NodeEffect<number>;

package/dev/version/module.f.js

@@ -1,17 +1,19 @@
-import { decodeUtf8, encodeUtf8 } from "../../types/uint8array/module.f.js";
+import { utf8, utf8ToString } from "../../text/module.f.js";
+import { all } from "../../types/effect/module.f.js";
+import { readFile, writeFile } from "../../types/effect/node/module.f.js";
+import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
-export const getVersion = fs => readJson(fs)('package').version;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = fs => name => parse(decodeUtf8(fs.readFileSync(jsonFile(name))));
-export const updateVersion = ({ fs }) => {
-    const f = (name) => {
-        return fs.writeFileSync(jsonFile(name), encodeUtf8(stringify({
-            ...readJson(fs)(name),
-            version: getVersion(fs)
-        }, null, 2)));
-    };
-    return [
-        f('package'),
-        f('deno')
-    ];
-};
+const readJson = (name) => readFile(jsonFile(name))
+    .map(v => parse(utf8ToString(unwrap(v))));
+const writeVersion = (version) => (name) => readJson(name)
+    .pipe(json => writeFile(jsonFile(name), utf8(stringify({
+    ...json,
+    version,
+}, null, 2))));
+export const updateVersion = readJson('package')
+    .pipe(p => {
+    const w = writeVersion(p.version);
+    return all([w('package'), w('deno')]);
+})
+    .map(() => 0);

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

@@ -1,2 +1,4 @@
-declare const _default: () => void;
+declare const _default: {
+    new: () => void;
+};
 export default _default;

package/dev/version/test.f.js

@@ -1,5 +1,10 @@
-import { decodeUtf8, encodeUtf8 } from "../../types/uint8array/module.f.js";
-import * as _ from "./module.f.js";
+import { utf8, utf8ToString } from "../../text/module.f.js";
+import { isVec } from "../../types/bit_vec/module.f.js";
+import { run } from "../../types/effect/mock/module.f.js";
+import { all } from "../../types/effect/module.f.js";
+import { writeFile } from "../../types/effect/node/module.f.js";
+import { emptyState, virtual } from "../../types/effect/node/virtual/module.f.js";
+import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
 const x = {
     'package.json': {
@@ -74,15 +79,25 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-export default () => {
-    const node = {
-        fs: {
-            readFileSync: n => encodeUtf8(JSON.stringify(x[n])),
-            writeFileSync: (_, content) => decodeUtf8(content)
+export default {
+    new: () => {
+        const rv = run(virtual);
+        const w = (name) => {
+            const fn = `${name}.json`;
+            return writeFile(fn, utf8(JSON.stringify(x[fn])));
+        };
+        const [state] = rv(emptyState)(all([w('package'), w('deno')]));
+        const [newState, result] = rv(state)(updateVersion);
+        if (result !== 0) {
+            throw result;
+        }
+        const vec = newState.root['package.json'];
+        if (!isVec(vec)) {
+            throw vec;
+        }
+        const n = utf8ToString(vec);
+        if (n !== e) {
+            throw [n, e];
         }
-    };
-    const [n, d] = _.updateVersion(node);
-    if (n !== e) {
-        throw [n, e];
     }
 };

package/djs/parser-new/module.f.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from "../../bnf/module.f.ts";
+export declare const parse: (input: string) => boolean;
+export declare const jsGrammar: () => Rule;