functionalscript 0.22.0 → 0.24.0

package/fs/dev/version/proof.f.js

@@ -1,7 +1,7 @@
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { isVec } from "../../types/bit_vec/module.f.js";
-import { all, writeFile } from "../../types/effects/node/module.f.js";
-import { emptyState, virtual } from "../../types/effects/node/virtual/module.f.js";
+import { all, writeFile } from "../../effects/node/module.f.js";
+import { emptyState, virtual } from "../../effects/node/virtual/module.f.js";
 import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
 const x = {

package/fs/djs/module.f.d.ts

@@ -4,8 +4,8 @@
  * @module
  */
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
-import { type Effect } from '../types/effects/module.f.ts';
-import { type WriteFile, type ReadFile, type Write } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type WriteFile, type ReadFile, type Write } from '../effects/node/module.f.ts';
 export type Object = {
     readonly [k in string]: Unknown;
 };

package/fs/djs/module.f.js

@@ -1,8 +1,8 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-import { pure } from "../types/effects/module.f.js";
-import { writeFile, error, } from "../types/effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { writeFile, error, } from "../effects/node/module.f.js";
 import { utf8 } from "../text/module.f.js";
 export const compile = args => {
     if (args.length < 2) {

package/fs/djs/parser/module.f.d.ts

@@ -7,11 +7,9 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-import type { Fs } from '../../io/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
 import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
 export type ParseContext = {
-    readonly fs: Fs;
     readonly complete: OrderedMap<Result<AstModule, string>>;
     readonly stack: List<string>;
 };

package/fs/djs/proof.f.js

@@ -1,5 +1,5 @@
 import { compile } from "./module.f.js";
-import { virtual, emptyState } from "../types/effects/node/virtual/module.f.js";
+import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 const readOutput = (root, path) => {

package/fs/djs/transpiler/module.f.d.ts

@@ -8,8 +8,8 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import { type ParseError } from '../parser/module.f.ts';
-import { type Effect } from '../../types/effects/module.f.ts';
-import { type ReadFile } from '../../types/effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
+import { type ReadFile } from '../../effects/node/module.f.ts';
 /**
  * State threaded through the recursive transpilation of a DJS module graph.
  *

package/fs/djs/transpiler/module.f.js

@@ -12,8 +12,8 @@ import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";
 import { run } from "../ast/module.f.js";
-import { foldStep, pure } from "../../types/effects/module.f.js";
-import { readFile } from "../../types/effects/node/module.f.js";
+import { foldStep, pure } from "../../effects/module.f.js";
+import { readFile } from "../../effects/node/module.f.js";
 import { utf8ToString } from "../../text/module.f.js";
 const mapDjs = context => path => {
     const res = at(path)(context.complete);

package/fs/djs/transpiler/proof.f.js

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-import { virtual, emptyState } from "../../types/effects/node/virtual/module.f.js";
+import { virtual, emptyState } from "../../effects/node/virtual/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));

package/fs/{types/effects → effects}/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type List } from '../list/module.f.ts';
+import { type List } from '../types/list/module.f.ts';
 export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;

package/fs/{types/effects → effects}/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { fold } from "../list/module.f.js";
+import { fold } from "../types/list/module.f.js";
 export const pure = (v) => ({
     value: [v],
     step: f => f(v)

package/fs/effects/node/module.d.ts

@@ -0,0 +1,20 @@
+import { type NodeProgram } from './module.f.ts';
+/**
+ * Runs a `NodeProgram` against the real Node `io` and process arguments,
+ * resolving to its exit code **without** terminating the process.
+ *
+ * Use this when the caller must stay alive afterwards — e.g. when proofs are
+ * registered under an external test runner (Node `--test`, Bun, Playwright)
+ * that owns the process lifecycle. For a standalone CLI entry point that should
+ * exit with the program's code, use {@link run} instead.
+ */
+export declare const runEffect: (p: NodeProgram) => Promise<number>;
+/**
+ * CLI entry point: runs a `NodeProgram` via {@link runEffect}, then calls
+ * `process.exit` with its exit code. The `Promise<never>` return type reflects
+ * that control never returns to the caller — the process terminates.
+ *
+ * A `bin` script can simply
+ * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
+ */
+export declare const run: (p: NodeProgram) => Promise<never>;

package/fs/{types/effects → effects}/node/module.f.d.ts

@@ -1,6 +1,6 @@
-import type { Vec } from '../../bit_vec/module.f.ts';
-import type { Nominal } from '../../nominal/module.f.ts';
-import type { Result } from '../../result/module.f.ts';
+import type { Vec } from '../../types/bit_vec/module.f.ts';
+import type { Nominal } from '../../types/nominal/module.f.ts';
+import type { Result } from '../../types/result/module.f.ts';
 import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
 export type All = ['all', <T>(...effects: Effect<never, T>[]) => readonly T[]];

package/fs/{types/effects → effects}/node/module.f.js

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import { utf8 } from "../../../text/module.f.js";
+import { utf8 } from "../../text/module.f.js";
 import { begin, do_, pure } from "../module.f.js";
 const doAll = do_('all');
 /**

package/fs/effects/node/module.js

@@ -0,0 +1,231 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import http from 'node:http';
+import childProcess from 'node:child_process';
+import fs from 'node:fs';
+import process from 'node:process';
+import { once } from 'node:events';
+import * as testContext from 'node:test';
+import { concat } from "../../path/module.f.js";
+import { normalize } from "../../path/module.f.js";
+import {} from "../module.f.js";
+import { asyncRun } from "../module.js";
+import {} from "./module.f.js";
+import { asBase, asNominal } from "../../types/nominal/module.f.js";
+import { error, ok } from "../../types/result/module.f.js";
+import { fromVec, listToVec, toVec } from "../../types/uint8array/module.f.js";
+const tc = async (f) => {
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+const collect = async (v) => {
+    let result = [];
+    for await (const a of v) {
+        result = [...result, a];
+    }
+    return result;
+};
+const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }) => {
+    const result = asyncRun({
+        all: async (...effects) => await Promise.all(effects.map(result)),
+        fetch: async (url) => tc(async () => {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
+            }
+            return toVec(new Uint8Array(await response.arrayBuffer()));
+        }),
+        mkdir: (...p) => tc(async () => { await mkdir(...p); }),
+        readFile: path => tc(async () => toVec(await readFile(path))),
+        readdir: (path, r) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+            .map(v => ({
+            name: v.name,
+            parentPath: normalize(v.parentPath),
+            isFile: v.isFile()
+        }))),
+        writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
+        rm: path => tc(() => rm(path)),
+        access: path => tc(() => access(path)),
+        import: path => tc(() => asyncImport(path)),
+        exec: (command, stdin) => new Promise(resolve => {
+            const child = childProcess.exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
+            child.stdin?.end(stdin);
+        }),
+        createServer: async (requestListener) => {
+            const erl = requestListener;
+            const nodeRl = async (req, res) => {
+                const reqBody = await collect(req);
+                const { method, url, headers } = req;
+                const { status, headers: outHeaders, body: outBody } = await result(erl({
+                    method,
+                    url,
+                    headers,
+                    body: listToVec(reqBody)
+                }));
+                res
+                    .writeHead(status, outHeaders)
+                    .end(fromVec(outBody));
+            };
+            const server = asNominal(createServer(nodeRl));
+            return server;
+        },
+        listen: async (server, port) => {
+            const s = asBase(server);
+            s.listen(port);
+        },
+        forever: () => new Promise(() => { }),
+        now: async () => ioNow(),
+        sandbox,
+        await: awaitPromise,
+        write,
+        test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
+    });
+    return result;
+};
+const runProgram = (io) => {
+    const { process: { env, stdout, stderr }, testContext, bunTestContext, playwrightTestContext, engine } = io;
+    const std = { stdout, stderr };
+    const f = fromIo(io);
+    return args => {
+        const options = { args, env, std, testContext, bunTestContext, playwrightTestContext, engine };
+        return program => f(program(options));
+    };
+};
+const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
+const pwTest = isPlaywright
+    ? (await import('@playwright/test')).test
+    : undefined;
+const inlineTest = async (name, { expectFailure }, fn) => {
+    if (expectFailure) {
+        try {
+            await fn(inlineContext);
+        }
+        catch {
+            return;
+        }
+        throw new Error(`expected to throw: ${name}`);
+    }
+    else {
+        await fn(inlineContext);
+    }
+};
+const inlineContext = { test: inlineTest };
+const wrapInlineTest = (register) => ({
+    test: (name, opts, fn) => register(name, () => inlineTest(name, opts, fn))
+});
+const bunTestContext = wrapInlineTest(testContext.test);
+const playwrightTestContext = wrapInlineTest(pwTest);
+const prefix = 'file:///';
+const { now } = Date;
+/** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
+const streams = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+};
+/**
+ * Writes `data` to `stream` respecting Node.js backpressure.
+ *
+ * `stream.write()` returns `false` when the internal buffer is full; the data
+ * is already buffered at that point (no retry needed) but the caller must not
+ * issue more writes until the `'drain'` event fires. Waiting here throttles the
+ * producer to the speed of the OS consumer, preventing unbounded memory growth
+ * when many large messages arrive faster than they can be flushed.
+ *
+ * When the buffer is not full `write()` returns `true` and we return
+ * immediately, so large computations with occasional prints never stall.
+ *
+ * @see {@link https://nodejs.org/api/stream.html#writablewritechunk}
+ */
+const writeAll = async (stream, data) => {
+    if (!stream.write(data)) {
+        await once(stream, 'drain');
+    }
+};
+const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
+const tryCatch = f => {
+    try {
+        return ok(f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
+const io = {
+    console,
+    fs,
+    process,
+    asyncImport: (v) => {
+        const s0 = v.includes(':') || v.startsWith('/') ? v : concat(process.cwd())(v);
+        const s1 = s0.startsWith(prefix) ? s0 : `${prefix}${s0}`;
+        return asyncImport(s1);
+    },
+    performance,
+    fetch,
+    tryCatch,
+    asyncTryCatch: async (f) => {
+        try {
+            return ok(await f());
+        }
+        catch (e) {
+            return error(e);
+        }
+    },
+    http,
+    childProcess,
+    now,
+    sandbox: async (f) => {
+        let result;
+        let after;
+        const before = performance.now();
+        try {
+            let p = f();
+            after = performance.now();
+            if (p instanceof Promise) {
+                p = await p;
+                after = performance.now();
+            }
+            result = ok(p);
+        }
+        catch (e) {
+            after = performance.now();
+            result = error(e);
+        }
+        return { result, duration: after - before };
+    },
+    write: (stream, data) => writeAll(streams[stream], fromVec(data)),
+    await: awaitPromise,
+    testContext,
+    bunTestContext,
+    playwrightTestContext,
+    engine: isPlaywright ? 'playwright' : 'Bun' in globalThis ? 'bun' : 'node',
+};
+/**
+ * Runs a `NodeProgram` against the real Node `io` and process arguments,
+ * resolving to its exit code **without** terminating the process.
+ *
+ * Use this when the caller must stay alive afterwards — e.g. when proofs are
+ * registered under an external test runner (Node `--test`, Bun, Playwright)
+ * that owns the process lifecycle. For a standalone CLI entry point that should
+ * exit with the program's code, use {@link run} instead.
+ */
+export const runEffect = runProgram(io)(io.process.argv.slice(2));
+/**
+ * CLI entry point: runs a `NodeProgram` via {@link runEffect}, then calls
+ * `process.exit` with its exit code. The `Promise<never>` return type reflects
+ * that control never returns to the caller — the process terminates.
+ *
+ * A `bin` script can simply
+ * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
+ */
+export const run = async (p) => process.exit(await runEffect(p));

package/fs/{types/effects → effects}/node/proof.f.js

@@ -1,4 +1,4 @@
-import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
+import { empty, isVec, uint, vec8 } from "../../types/bit_vec/module.f.js";
 import { pure } from "../module.f.js";
 import { fetch, mkdir, now, readdir, readFile, rm, sandbox, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";

package/fs/{types/effects → effects}/node/virtual/module.f.d.ts

@@ -1,4 +1,4 @@
-import { type Vec } from '../../../bit_vec/module.f.ts';
+import { type Vec } from '../../../types/bit_vec/module.f.ts';
 import { type RunInstance } from '../../mock/module.f.ts';
 import type { Module, NodeOp } from '../module.f.ts';
 /**

package/fs/{types/effects → effects}/node/virtual/module.f.js

@@ -3,11 +3,11 @@
  *
  * @module
  */
-import { assert, todo } from "../../../../asserts/module.f.js";
-import { parse } from "../../../../path/module.f.js";
-import { utf8ToString } from "../../../../text/module.f.js";
-import { isVec } from "../../../bit_vec/module.f.js";
-import { error, ok } from "../../../result/module.f.js";
+import { todo } from "../../../asserts/module.f.js";
+import { parse } from "../../../path/module.f.js";
+import { utf8ToString } from "../../../text/module.f.js";
+import { isVec } from "../../../types/bit_vec/module.f.js";
+import { error, ok } from "../../../types/result/module.f.js";
 import { run } from "../../mock/module.f.js";
 export const emptyState = {
     stdout: '',

package/fs/emergent_testing/all.test.js

@@ -1,3 +1,4 @@
-import { run } from "./module.js";
+import { runEffect } from "../effects/node/module.js";
+import { register } from "./module.f.js";
 // we need `await` for Playwright.
-await run();
+await runEffect(register);

package/fs/emergent_testing/example.f.d.ts

@@ -0,0 +1,13 @@
+export declare const add: (a: number, b: number) => number;
+export declare const mul: (a: number, b: number) => number;
+export declare const sqr: (a: number) => number;
+export declare const todo: () => never;
+export declare const proof: {
+    addTest: () => void;
+    mulTest: (() => void)[];
+    throw: {
+        todo: () => never;
+        divByZero: () => bigint;
+    };
+    generateSqrTests: () => (() => void)[];
+};

package/fs/emergent_testing/example.f.js

@@ -0,0 +1,31 @@
+export const add = (a, b) => a + b;
+export const mul = (a, b) => a * b;
+export const sqr = (a) => mul(a, a);
+export const todo = () => { throw "not implemented"; };
+const checkMul = (a, b, r) => {
+    if (mul(a, b) !== r) {
+        throw `mul(${a}, ${b}) !== ${r}`;
+    }
+};
+export const proof = {
+    addTest: () => {
+        if (add(2, 2) !== 4) {
+            throw "something wrong with the math";
+        }
+    },
+    mulTest: [
+        () => checkMul(2, 3, 6),
+        () => checkMul(22, 34, 748),
+        () => checkMul(-2, 3, -6),
+        () => checkMul(-2, -3, 6),
+    ],
+    throw: {
+        todo,
+        divByZero: () => 5n / 0n,
+    },
+    generateSqrTests: () => [1, 2, 3, 5].map(a => () => {
+        if (sqr(a) !== a * a) {
+            throw `sqr(${a})`;
+        }
+    })
+};

package/fs/emergent_testing/module.f.d.ts

@@ -1,5 +1,5 @@
-import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../types/effects/node/module.f.ts';
-import { type Effect, type Operation } from '../types/effects/module.f.ts';
+import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../effects/node/module.f.ts';
+import { type Effect, type Operation } from '../effects/module.f.ts';
 import { type LoadModuleOperations, type ModuleMap } from '../dev/module.f.ts';
 /** A zero-argument test function whose return value may contain sub-tests. */
 export type TestFn = () => unknown;

package/fs/emergent_testing/module.f.js

@@ -11,8 +11,8 @@
  * @module
  */
 import { reset, fgGreen, fgRed, bold, csiWrite } from "../text/sgr/module.f.js";
-import { all, awaitIfPromise, sandbox, test } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { all, awaitIfPromise, sandbox, test } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
 import { loadModuleMap, shouldLoad } from "../dev/module.f.js";
 import { invert } from "../types/result/module.f.js";
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });

package/fs/emergent_testing/proof.f.js

@@ -1,9 +1,9 @@
-import { pure } from "../types/effects/module.f.js";
-import { emptyState } from "../types/effects/node/virtual/module.f.js";
-import { virtual } from "../types/effects/node/virtual/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { emptyState } from "../effects/node/virtual/module.f.js";
+import { virtual } from "../effects/node/virtual/module.f.js";
 import { assert, assertEq, todo } from "../asserts/module.f.js";
 import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, defaultTest, } from "./module.f.js";
-import { run as mockRun } from "../types/effects/mock/module.f.js";
+import { run as mockRun } from "../effects/mock/module.f.js";
 import { shouldLoad } from "../dev/module.f.js";
 const makeReporter = () => {
     const events = [];

package/fs/emergent_testing/scenarios/all.d.ts

@@ -1 +1 @@
-export {};
+import '../all.test.ts';

package/fs/emergent_testing/scenarios/all.js

@@ -1,3 +1 @@
-import { run } from "../module.js";
-// we need `await` for Playwright.
-await run();
+import "../all.test.js";

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

@@ -1,2 +1,2 @@
-import { type NodeProgram } from '../types/effects/node/module.f.ts';
+import { type NodeProgram } from '../effects/node/module.f.ts';
 export declare const main: NodeProgram;

package/fs/fjs/module.f.js

@@ -6,7 +6,7 @@
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../emergent_testing/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
-import { import_, errorExit } from "../types/effects/node/module.f.js";
+import { import_, errorExit } from "../effects/node/module.f.js";
 export const main = options => {
     const [command, ...rest] = options.args;
     switch (command) {

package/fs/fjs/module.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 import { main } from "./module.f.js";
-import effectRun from "../io/module.js";
-effectRun(main);
+import { run } from "../effects/node/module.js";
+await run(main);

package/fs/path/module.f.d.ts

@@ -4,6 +4,10 @@
  * @module
  */
 import type { Reduce, Unary } from '../types/function/operator/module.f.ts';
+/**
+ * Converts Windows separators (`\`) to POSIX separators (`/`).
+ */
+export declare const toPosix: (path: string) => string;
 /**
  * Splits a path into normalized segments.
  *

package/fs/path/module.f.js

@@ -21,6 +21,10 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
+/**
+ * Converts Windows separators (`\`) to POSIX separators (`/`).
+ */
+export const toPosix = (path) => path.replaceAll('\\', '/');
 /**
  * Splits a path into normalized segments.
  *
@@ -29,7 +33,7 @@ const foldNormalizeOp = input => state => {
  * separators are converted to POSIX separators.
  */
 export const parse = (path) => {
-    const split = path.replaceAll('\\', '/').split('/');
+    const split = toPosix(path).split('/');
     return toArray(fold(foldNormalizeOp)([])(split));
 };
 /**

package/fs/path/proof.f.d.ts

@@ -2,4 +2,5 @@ export declare const proof: {
     normalizeTest: (() => void)[];
     concatTest: (() => void)[];
     relativizeTest: (() => void)[];
+    toPosixTest: (() => void)[];
 };

package/fs/path/proof.f.js

@@ -1,4 +1,4 @@
-import { concat, normalize, relativize } from "./module.f.js";
+import { concat, normalize, relativize, toPosix } from "./module.f.js";
 const normalizeTest = [
     () => {
         const norm = normalize("dir/file.json");
@@ -65,4 +65,30 @@ const relativizeTest = [
         }
     },
 ];
-export const proof = { normalizeTest, concatTest, relativizeTest };
+const toPosixTest = [
+    () => {
+        const p = toPosix('a\\b\\c');
+        if (p !== 'a/b/c') {
+            throw p;
+        }
+    },
+    () => {
+        const p = toPosix('a/b/c');
+        if (p !== 'a/b/c') {
+            throw p;
+        }
+    },
+    () => {
+        const p = toPosix('C:\\Users\\x');
+        if (p !== 'C:/Users/x') {
+            throw p;
+        }
+    },
+    () => {
+        const p = toPosix('');
+        if (p !== '') {
+            throw p;
+        }
+    },
+];
+export const proof = { normalizeTest, concatTest, relativizeTest, toPosixTest };