functionalscript 0.43.1 → 0.44.0

package/fjs/emergent_testing/proof.f.js

@@ -1,416 +0,0 @@
-import { log } from '../effects/node/module.f.js';
-import { defaultNodeProgramOptions, emptyState } from '../effects/node/virtual/module.f.js';
-import { virtual } from '../effects/node/virtual/module.f.js';
-import { assert, assertEq } from '../asserts/module.f.js';
-import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, parseTestSet, defaultTest, } from './module.f.js';
-import { run as mockRun } from '../effects/mock/module.f.js';
-import { shouldLoad } from '../dev/module.f.js';
-import { parse as parseJson } from '../media/json/module.f.js';
-import { array, number as rttiNumber, or, string as rttiString } from '../types/rtti/module.f.js';
-import { parse as rttiParse } from '../types/rtti/parse/module.f.js';
-import { unwrap } from '../types/result/module.f.js';
-/**
- * The mock reporter's stdout lines. A schema rather than a hand-written type:
- * the events round-trip through JSON, and this is what turns a line back into
- * a typed value without an `as` cast — a shape change fails at the parse
- * instead of silently at an assertion.
- *
- * `Reporter.result` also receives the test's `SandboxResult`, which is not
- * written: no assertion here reads it, and its `undefined` payloads have no
- * JSON representation to round-trip through anyway.
- */
-const event = or(['result', rttiString, array(or(rttiString, null))], ['summary', rttiNumber, rttiNumber, rttiNumber]);
-const parseEvent = rttiParse(event);
-const writeEvent = (e) => log(JSON.stringify(e));
-const parseEvents = (stdout) => stdout === '' ? [] : stdout.trimEnd().split('\n')
-    .map(line => unwrap(parseEvent(unwrap(parseJson(line)))));
-const makeReporter = () => ({
-    result: (file, path, _r, _throws) => writeEvent(['result', file, [...path]]),
-    summary: (pass, fail, time) => writeEvent(['summary', pass, fail, time]),
-    test: defaultTest,
-});
-const options = (initCwd, github = false) => ({
-    ...defaultNodeProgramOptions,
-    env: { INIT_CWD: initCwd, ...(github ? { GITHUB_ACTIONS: 'true' } : {}) },
-});
-const ok0 = () => ({ result: ['ok', undefined], duration: 0 });
-const fail0 = () => ({ result: ['error', 'oops'], duration: 0 });
-const ok1 = () => ({ result: ['ok', undefined], duration: 1 });
-const run = (dir, initCwd = '.') => {
-    const reporter = makeReporter();
-    const state = { ...emptyState, root: dir };
-    const [finalState, exitCode] = virtual(state)(testAll(reporter)(options(initCwd)));
-    return [parseEvents(finalState.stdout), exitCode];
-};
-// Runs the real `defaultReporter` and returns its captured stdout/stderr so the
-// terminal and GitHub output formats can be asserted directly.
-const runMain = (dir, github = false) => {
-    const state = { ...emptyState, root: dir };
-    const opts = options('.', github);
-    const [finalState, exitCode] = virtual(state)(testAll(defaultReporter(opts))(opts));
-    return [finalState.stdout, finalState.stderr, exitCode];
-};
-// flat object: two passing tests
-export const flat = () => {
-    const [events, exit] = run({
-        'a.proof.f.ts': () => ({ proof: { a: ok0, b: ok1 } }),
-    });
-    assertEq(exit, 0);
-    const [e0, e1, e2] = events;
-    assert(e0[0] === 'result' && e0[2][0] === 'a');
-    assert(e1[0] === 'result' && e1[2][0] === 'b');
-    assert(e2[0] === 'summary');
-    const [, pass, fail] = e2;
-    assertEq(pass, 2);
-    assertEq(fail, 0);
-};
-// nested object: leaf tests carry the full path including the sub-tree key
-export const nested = () => {
-    const [events, exit] = run({
-        'n.proof.f.ts': () => ({ proof: { math: { add: ok0, sub: ok0 } } }),
-    });
-    assertEq(exit, 0);
-    const [e0, e1, e2] = events;
-    assert(e0[0] === 'result' && e0[2][1] === 'add');
-    assert(e1[0] === 'result' && e1[2][1] === 'sub');
-    assert(e2[0] === 'summary');
-    const [, pass, fail] = e2;
-    assertEq(pass, 2);
-    assertEq(fail, 0);
-};
-// throw key: tests inside 'throw' pass on error result
-export const throwKey = () => {
-    const [events, exit] = run({
-        't.proof.f.ts': () => ({ proof: { throw: { a: fail0 } } }),
-    });
-    assertEq(exit, 0);
-    const [e0, e1] = events;
-    assert(e0[0] === 'result' && e0[2][0] === 'throw' && e0[2][1] === 'a');
-    assert(e1[0] === 'summary');
-    const [, pass, fail] = e1;
-    assertEq(pass, 1);
-    assertEq(fail, 0);
-};
-// throw key fails when test does not throw (returns ok in throw context)
-export const throwKeyFail = () => {
-    const [events, exit] = run({
-        't.proof.f.ts': () => ({ proof: { throw: { a: ok0 } } }),
-    });
-    assertEq(exit, 1);
-    const [e0, e1] = events;
-    assert(e0[0] === 'result');
-    const [, pass, fail] = e1;
-    assertEq(pass, 0);
-    assertEq(fail, 1);
-};
-// mixed pass/fail updates summary counts
-export const mixedPassFail = () => {
-    const [events, exit] = run({
-        'm.proof.f.ts': () => ({ proof: { good: ok0, bad: fail0 } }),
-    });
-    assertEq(exit, 1);
-    const summary = events[events.length - 1];
-    assert(summary[0] === 'summary');
-    const [, pass, fail] = summary;
-    assertEq(pass, 1);
-    assertEq(fail, 1);
-};
-// return-value sub-tree: passing test's return value is walked
-export const returnValueSubTree = () => {
-    const inner = () => ({ result: ['ok', undefined], duration: 0 });
-    const [events, exit] = run({
-        'r.proof.f.ts': () => ({
-            proof: {
-                outer: () => ({
-                    result: ['ok', { inner }],
-                    duration: 0,
-                }),
-            }
-        }),
-    });
-    // outer passes, then inner (from return value) also passes
-    assertEq(exit, 0);
-    const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 2);
-    const [p0, p1] = passEvents;
-    assertEq(p0[2][0], 'outer');
-    assertEq(p1[2][2], 'inner');
-};
-// integer-indexed array keys appear as numeric path segments
-export const arrayKeys = () => {
-    const [events, exit] = run({
-        'a.proof.f.ts': () => ({ proof: { arr: [ok0, ok0] } }),
-    });
-    assertEq(exit, 0);
-    const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 2);
-    assertEq(passEvents[0][2][1], '0');
-    assertEq(passEvents[1][2][1], '1');
-};
-// non-proof files are skipped: plain `.ts` is not loaded; `.f.ts` without
-// a `proof` export is loaded but produces no events
-export const nonTestFilesSkipped = () => {
-    const [events, exit] = run({
-        'helper.ts': () => ({ a: ok0 }), // not loaded (plain .ts)
-        'module.f.ts': () => ({ someExport: ok0 }), // loaded, no proof → skipped
-        'b.proof.f.ts': () => ({ proof: { x: ok0 } }), // loaded, has proof → runs
-    });
-    assertEq(exit, 0);
-    const results = events.filter(e => e[0] === 'result');
-    assertEq(results.length, 1);
-    assertEq(results[0][1], './b.proof.f.ts');
-};
-// multiple test files each produce result events
-export const multipleFiles = () => {
-    const [events, exit] = run({
-        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
-        'b.proof.f.ts': () => ({ proof: { y: ok0 } }),
-    });
-    assertEq(exit, 0);
-    const results = events.filter(e => e[0] === 'result');
-    assertEq(results.length, 2);
-    const [, pass, fail] = events[events.length - 1];
-    assertEq(pass, 2);
-    assertEq(fail, 0);
-};
-// a function literally named `throw` is a throwing test even when its key is not `throw`
-export const throwByFunctionName = () => {
-    // // `bun` calls the function `named` instead of `throw`
-    // const named = ({ throw: () => fail0() }).throw
-    const x = { throw: () => fail0() };
-    const [events, exit] = run({
-        't.proof.f.ts': () => ({ proof: { here: x.throw } }),
-    });
-    assertEq(exit, 0);
-    const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 1);
-    assertEq(passEvents[0][2][0], 'here');
-};
-// only the `proof` export is used; other module properties are ignored
-export const namedExports = () => {
-    const [events, exit] = run({
-        'e.proof.f.ts': () => ({ proof: { a: ok0, b: ok0 }, other: ok0 }),
-    });
-    assertEq(exit, 0);
-    const passEvents = events.filter(e => e[0] === 'result');
-    assertEq(passEvents.length, 2); // `other` is ignored
-    assertEq(passEvents[0][2][0], 'a');
-    assertEq(passEvents[1][2][0], 'b');
-};
-// the default (non-GitHub) reporter formats module/pass/summary lines on stdout
-export const defaultReporterOutput = () => {
-    const [stdout, stderr, exit] = runMain({
-        'a.proof.f.ts': () => ({ proof: { x: ok0 } }),
-    });
-    assertEq(exit, 0);
-    assertEq(stderr, '');
-    assertEq(stdout, 'import("./a.proof.f.ts").proof.x(): ok, 0.0000 ms\n'
-        + 'Number of tests: pass: 1, fail: 0, total: 1\n'
-        + 'Time: 0.0000 ms\n');
-};
-// timeFormat with duration >= 1ms covers the `yl <= 0` branch (no leading zeros needed)
-export const defaultReporterOutputLargeDuration = () => {
-    const [stdout, , exit] = runMain({
-        'a.proof.f.ts': () => ({ proof: { x: ok1 } }),
-    });
-    assertEq(exit, 0);
-    assertEq(stdout, 'import("./a.proof.f.ts").proof.x(): ok, 1.0000 ms\n'
-        + 'Number of tests: pass: 1, fail: 0, total: 1\n'
-        + 'Time: 1.0000 ms\n');
-};
-// a failure on the non-GitHub reporter writes the error to stderr, not stdout
-export const defaultReporterFailOutput = () => {
-    const [, stderr, exit] = runMain({
-        'a.proof.f.ts': () => ({ proof: { bad: fail0 } }),
-    });
-    assertEq(exit, 1);
-    assertEq(stderr, 'import("./a.proof.f.ts").proof.bad(): error, 0.0000 ms\noops\n');
-};
-// the GitHub reporter emits an `::error` annotation with a percent-encoded
-// title (the JSON path) and message
-export const githubReporterOutput = () => {
-    const [, stderr, exit] = runMain({
-        's.proof.f.ts': () => ({ proof: { 'a:b,c%d': fail0 } }),
-    }, true);
-    assertEq(exit, 1);
-    assertEq(stderr, '::error file=./s.proof.f.ts,line=1,title=import("./s.proof.f.ts").proof["a%3Ab%2Cc%25d"]()::oops\n');
-};
-const registerNoopCtx = { test: (_n, _o, _f) => Promise.resolve() };
-/**
- * Builds a synchronous mock runner for `registerModule`'s `Test`/`All`/`Await`
- * effect operations. Only the `test` op varies between call sites (whether it
- * invokes the registered callback), so `all`/`await` are shared here.
- */
-const makeRegisterRunner = (testOp) => {
-    let runner;
-    runner = mockRun({
-        test: (ctx, name, xf, fn) => testOp(runner, ctx, name, xf, fn),
-        all: (...effects) => (s) => effects.reduce(([st, rs], e) => {
-            const [ns, r] = runner(st)(e);
-            return [ns, [...rs, r]];
-        }, [s, []]),
-        await: (p) => (s) => [s, [p]],
-    });
-    return runner;
-};
-// registerModule appends ' ...' for inline runners (Bun).
-// This mock never invokes the registered callback; it only records names.
-export const registerSuffixes = () => {
-    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => (s) => [[...s, name], undefined]);
-    const proof = {
-        ok: () => { },
-        throw: { a: () => { throw 'expected'; } },
-    };
-    // Node (star = ''): no suffixes
-    const [nodeNames] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ''));
-    assertEq(nodeNames.length, 2);
-    assert(nodeNames[0] === 'import("./a.f.ts").proof.ok()');
-    assertEq(nodeNames[1], 'import("./a.f.ts").proof.throw.a()');
-    // Bun (star = ' ...'): ... on normal tests, path shows throw for throw-tests
-    const [inlineNames] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ' ...'));
-    assertEq(inlineNames.length, 2);
-    assert(inlineNames[0] === 'import("./a.f.ts").proof.ok() ...');
-    assertEq(inlineNames[1], 'import("./a.f.ts").proof.throw.a()');
-};
-// A `throw`-tagged test whose function completes without throwing (the
-// external framework, not this module, is responsible for turning that into
-// a failure via `expectFailure`). registerModule's own callback must still
-// short-circuit before walking the returned value for sub-tests: it invokes
-// the callback and returns without recursing, rather than treating the
-// returned object as a sub-tree.
-export const registerThrowsWithoutThrowing = () => {
-    // Unlike registerSuffixes' mock, this one actually invokes the registered
-    // callback so registerOne's inner `.step` body runs, and asserts the
-    // callback is registered with `expectFailure: true`.
-    const runner = makeRegisterRunner((runner, ctx, name, xf, fn) => (s) => {
-        assert(xf);
-        const [ns] = runner(s)(fn(ctx));
-        return [[...ns, name], undefined];
-    });
-    // Returns a sub-tree that would register more tests if it were walked.
-    const proof = { throw: { a: () => ({ sub: () => { } }) } };
-    const [names] = runner([])(registerModule(registerNoopCtx, './a.f.ts', proof, ''));
-    // Only the throw-test itself is registered; `sub` is never reached.
-    assertEq(names.length, 1);
-    assertEq(names[0], 'import("./a.f.ts").proof.throw.a()');
-};
-// registerModule with an empty proof object registers zero tests and
-// returns without invoking the mock's `test` op at all.
-export const registerEmptyProof = () => {
-    const runner = makeRegisterRunner((_runner, _ctx, name, _xf, _fn) => (s) => [[...s, name], undefined]);
-    const [names] = runner([])(registerModule(registerNoopCtx, './a.f.ts', {}, ''));
-    assertEq(names.length, 0);
-};
-// direct unit tests for the pure path-format helpers
-export const helpers = {
-    isInteger: () => {
-        assert(isInteger('0'));
-        assert(isInteger('123'));
-        assert(!isInteger(''));
-        assert(!isInteger('01'));
-        assert(!isInteger('1a'));
-        assert(!isInteger('-1'));
-    },
-    isIdentifier: () => {
-        assert(isIdentifier('abc'));
-        assert(isIdentifier('_x'));
-        assert(isIdentifier('$y'));
-        assert(isIdentifier('a1'));
-        assert(!isIdentifier(''));
-        assert(!isIdentifier('1a'));
-        assert(!isIdentifier('a-b'));
-    },
-    shouldLoad: () => {
-        // all .f.ts / .f.js — FS modules are safe to bulk-load
-        assert(shouldLoad('module.f.ts'));
-        assert(shouldLoad('module.f.js'));
-        assert(shouldLoad('a.proof.f.ts'));
-        assert(shouldLoad('dir/module.f.ts'));
-        // vanilla opt-in by filename
-        assert(shouldLoad('proof.ts'));
-        assert(shouldLoad('proof.js'));
-        assert(shouldLoad('proof.mts'));
-        assert(shouldLoad('proof.mjs'));
-        assert(shouldLoad('math.proof.ts'));
-        assert(shouldLoad('math.proof.js'));
-        assert(shouldLoad('math.proof.mts'));
-        assert(shouldLoad('dir/math.proof.ts'));
-        // non-FS, non-proof vanilla files are not loaded
-        assert(!shouldLoad('helper.ts'));
-        assert(!shouldLoad('module.ts'));
-        assert(!shouldLoad('proof.tsx'));
-    },
-    fmtImport: () => {
-        assertEq(fmtImport('./a.proof.f.ts', []), 'import("./a.proof.f.ts").proof()');
-        assertEq(fmtImport('./a.proof.f.ts', ['math', 'add']), 'import("./a.proof.f.ts").proof.math.add()');
-        assertEq(fmtImport('./a.proof.f.ts', ['users', '3']), 'import("./a.proof.f.ts").proof.users[3]()');
-        assertEq(fmtImport('./a.proof.f.ts', ['x', 'hello world']), 'import("./a.proof.f.ts").proof.x["hello world"]()');
-        assertEq(fmtImport('./a.proof.f.ts', ['outer', null, 'inner']), 'import("./a.proof.f.ts").proof.outer().inner()');
-    },
-    fmtPath: () => {
-        assertEq(fmtPath([]), '');
-        assertEq(fmtPath(['math', 'add']), '.math.add');
-        assertEq(fmtPath(['users', '3', 'name']), '.users[3].name');
-        assertEq(fmtPath(['x', 'hello world']), '.x["hello world"]');
-        assertEq(fmtPath(['outer', null, 'inner']), '.outer().inner');
-    },
-    fmtTerm: () => {
-        assertEq(fmtTerm([]), '()');
-        assertEq(fmtTerm(['math', 'add']), '| | add');
-        assertEq(fmtTerm(['a', '0']), '| | 0');
-        assertEq(fmtTerm(['x', 'hello world']), '| | "hello world"');
-        // null marks a function-call boundary; fmtTerm filters it out
-        assertEq(fmtTerm(['outer', null, 'inner']), '| | inner');
-    },
-    ghEscape: () => {
-        assertEq(ghEscape('a%b'), 'a%25b');
-        assertEq(ghEscape('a:b'), 'a%3Ab');
-        assertEq(ghEscape('a,b'), 'a%2Cb');
-        assertEq(ghEscape('a\r\nb'), 'a%0D%0Ab');
-        assertEq(ghEscape('a%b:c,d'), 'a%25b%3Ac%2Cd');
-    },
-    parseTestSet: {
-        nullReturnsEmpty: () => {
-            const result = parseTestSet(false, null);
-            assertEq(Array.isArray(result), true);
-            assertEq(result.length, 0);
-        },
-        functionWithParamsReturnsEmpty: () => {
-            const result = parseTestSet(false, (_x) => _x);
-            assertEq(Array.isArray(result), true);
-            assertEq(result.length, 0);
-        },
-    },
-};
-// a passing throw-test emits '# EXPECTED TO THROW' in its output line
-const defaultReporterExpectedToThrow = () => {
-    // fail0 returns a SandboxResult indicating an error; in a throw context
-    // defaultTest inverts it to ok, so defaultReporter.result sees s==='ok' and throws===true
-    const [stdout, , exit] = runMain({
-        'a.proof.f.ts': () => ({ proof: { throw: { x: fail0 } } }),
-    });
-    assertEq(exit, 0);
-    assert(stdout.includes('# EXPECTED TO THROW'), stdout);
-};
-export const proof = {
-    flat,
-    nested,
-    throwKey,
-    throwKeyFail,
-    mixedPassFail,
-    returnValueSubTree,
-    arrayKeys,
-    nonTestFilesSkipped,
-    multipleFiles,
-    throwByFunctionName,
-    namedExports,
-    defaultReporterOutput,
-    defaultReporterOutputLargeDuration,
-    defaultReporterFailOutput,
-    githubReporterOutput,
-    registerSuffixes,
-    registerThrowsWithoutThrowing,
-    registerEmptyProof,
-    defaultReporterExpectedToThrow,
-    helpers
-};

package/fjs/fsc/bnf.f.d.ts

@@ -1,2 +0,0 @@
-import { type Rule } from '../bnf/module.f.ts';
-export declare const wsModule: Rule;

package/fjs/fsc/bnf.f.js

@@ -1,42 +0,0 @@
-import { range, remove, set, option } from '../bnf/module.f.js';
-import { digit, json, unicode, ws0, ws1, wsNoNewLine0 } from './json.f.js';
-export const wsModule = () => [ws0, module];
-const module = () => ({
-    json: [json, ws0],
-    fjs,
-});
-const fjs = () => option({
-    const: ['const', ws1, id, ws0, '=', ws0, json, wsNoNewLine0, fjsTail],
-    export: ['export', ws1, 'default', ws1, json],
-});
-const fjsTail = option(['\n', ws0, fjs]);
-// line comment
-const lineItem = remove(unicode, set('\n'));
-const line = () => option([lineItem, line]);
-const lineComment = () => ['/', commentTail, '\n'];
-const multiLineSkip = remove(unicode, set('/'));
-const multiLineItem = remove(unicode, set('*'));
-const multiLine = () => ({
-    '*': ['*', multiLineTail],
-    '_': [multiLineItem, multiLine]
-});
-const multiLineTail = {
-    '/': '/',
-    '_': [multiLineSkip, multiLine]
-};
-const commentTail = {
-    '/': ['/', lineComment],
-    '*': ['*', multiLine],
-};
-// id
-const id = () => [alpha, idTail0];
-const alpha = {
-    upper: range('AZ'),
-    lower: range('az'),
-    _: set('_$'),
-};
-const idTail0 = () => option([alphaDigit, idTail0]);
-const alphaDigit = {
-    alpha,
-    digit,
-};

package/fjs/fsc/json.f.d.ts

@@ -1,7 +0,0 @@
-import { type Rule, type TerminalRange } from '../bnf/module.f.ts';
-export declare const wsNoNewLine0: Rule;
-export declare const ws0: Rule;
-export declare const ws1: Rule;
-export declare const json: Rule;
-export declare const unicode: TerminalRange;
-export declare const digit: Rule;

package/fjs/fsc/json.f.js

@@ -1,64 +0,0 @@
-import { join0Plus, rangeEncode, range, remove, repeat0Plus, set, option } from '../bnf/module.f.js';
-// space
-const wsNoNewLineItem = set(' \t\r');
-export const wsNoNewLine0 = repeat0Plus(wsNoNewLineItem);
-const wsItem = {
-    wsNoNewLineItem,
-    n: '\n',
-};
-export const ws0 = () => option(ws1);
-export const ws1 = [wsItem, ws0];
-//
-export const json = () => ({
-    object,
-    array,
-    number,
-    string,
-    true: 'true',
-    false: 'false',
-    null: 'null',
-});
-//
-const separator = [',', ws0];
-// object
-const member = () => [string, ws0, ':', ws0, json, ws0];
-const object = ['{', ws0, join0Plus(member, separator), '}'];
-// array
-const element = [json, ws0];
-const array = ['[', ws0, join0Plus(element, separator), ']'];
-// string
-const character = () => ({
-    ...remove(unicode, set('"\\')),
-    '\\': ['\\', escape],
-});
-const string = ['"', repeat0Plus(character), '"'];
-export const unicode = rangeEncode(0x20, 0x10FFFF);
-const escape = () => ({
-    ...set('"\\/bfnrt'),
-    'u': ['u', hex, hex, hex, hex] // 117
-});
-const hex = () => ({
-    digit,
-    upper: range('AF'),
-    lower: range('af'),
-});
-// number
-const number = () => ({
-    uNumber,
-    minus: ['-', uNumber],
-});
-const uNumber = () => [uint, fraction0, exponent0];
-const uint = () => ({
-    '0': '0',
-    '19': [range('19'), digits0]
-});
-export const digit = range('09');
-const digits0 = repeat0Plus(digit);
-const digits1 = [digit, digits0];
-const fraction0 = option(['.', digits1]);
-const exponent0 = () => option([e, sign, digits1]);
-const e = set('eE');
-const sign = option({
-    '+': '+',
-    '-': '-',
-});

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

@@ -1,11 +0,0 @@
-type Result = readonly [readonly string[], ToResult];
-type ToResult = (codePoint: number) => Result;
-export declare const terminal = -1;
-export declare const init: ToResult;
-export declare const proof: {
-    throw: {
-        unionConflict: () => void;
-    };
-    defHandler: () => void;
-};
-export {};

package/fjs/fsc/module.f.js

@@ -1,73 +0,0 @@
-/**
- * FunctionalScript command utilities for compile workflows.
- *
- * @module
- */
-import { strictEqual } from '../types/function/operator/module.f.js';
-import { merge as rangeMapMerge, fromRange, get, } from '../types/range_map/module.f.js';
-import { reduce as listReduce, toArray, map } from '../types/list/module.f.js';
-import { range as asciiRange } from '../text/ascii/module.f.js';
-import { flip, fn } from '../types/function/module.f.js';
-import { one } from '../types/range/module.f.js';
-import { assertEq } from '../asserts/module.f.js';
-const fromCharCode = String.fromCharCode;
-const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol];
-const def = () => unexpectedSymbol;
-const union = (a) => (b) => {
-    if (a === def || a === b) {
-        return b;
-    }
-    if (b === def) {
-        return a;
-    }
-    throw [a, b];
-};
-const empty = [];
-const reduce = (a) => {
-    const merge = rangeMapMerge({
-        union,
-        equal: strictEqual,
-        def,
-    });
-    return toArray(listReduce(merge)(empty)(a));
-};
-const codePointRange = flip(fromRange(def));
-const range = fn(asciiRange).map(codePointRange).result;
-const rangeSet = (l) => (f) => {
-    const codePointRange = flip(fromRange(def));
-    const g = r => codePointRange(asciiRange(r))(f);
-    return reduce(map(g)(l));
-};
-const create = (a) => {
-    const i = reduce(a);
-    const x = get(def);
-    return v => c => x(i)(c)(v)(c);
-};
-export const terminal = -1;
-const toInit = () => () => [[], init];
-const single = (c) => range(c)(() => () => [[c], unexpectedSymbol]);
-const punctuation = "!\"%&'()*+,-./:;<=>?[]^`{|}~";
-export const init = create([
-    codePointRange(one(terminal))(toInit),
-    rangeSet(['\t', ' ', '\n', '\r'])(toInit),
-    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unexpectedSymbol]),
-    range('09')(() => a => [[fromCharCode(a)], unexpectedSymbol]),
-    ...[...punctuation].map(single),
-])(undefined);
-export const proof = {
-    // union throws when two distinct non-def handlers are merged for the same range;
-    // this path is unreachable through the public API (init has no overlapping ranges),
-    // so we exercise it here where the private union function is in scope.
-    throw: {
-        unionConflict: () => {
-            const a = _s => unexpectedSymbol;
-            const b = _s => unexpectedSymbol;
-            a(undefined);
-            b(undefined);
-            union(a)(b);
-        }
-    },
-    // `def` is the range-map's default handler; the public API never calls it directly
-    // (`init` covers every code point), so exercise it here where it's in scope.
-    defHandler: () => assertEq(def(undefined), unexpectedSymbol)
-};