functionalscript 0.19.0 → 0.20.0

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

@@ -7,88 +7,47 @@ import { serialize as bigintSerialize } from "../../types/bigint/module.f.js";
 import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "../../json/serializer/module.f.js";
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
-const getConstantsOp = djs => state => {
-    switch (typeof djs) {
-        case 'boolean': {
-            return state;
-        }
-        case 'number':
-        case 'string':
-        case 'bigint': {
-            return getConstantSelf(djs)(state);
-        }
-        default: {
-            if (djs === null) {
-                return state;
-            }
-            if (djs === undefined) {
-                return state;
-            }
-            if (djs instanceof Array) {
-                return getConstantSelf(djs)(fold(getConstantsOp)(state)(djs));
-            }
-            return getConstantSelf(djs)(fold(getConstantsOp)(state)(map(entryValue)(entries(djs))));
+const getConstants = refs => {
+    const checkSelf = djs => state => {
+        const refCounter = refs.get(djs);
+        if (refCounter !== undefined && refCounter[1] > 1 && !state.added.has(djs)) {
+            return {
+                added: new Set([...state.added, djs]),
+                consts: { head: state.consts, tail: [djs] }
+            };
         }
-    }
-};
-const getConstantSelf = djs => state => {
-    const refs = state.refs;
-    const refCounter = refs.get(djs);
-    if (refCounter !== undefined && refCounter[1] > 1 && !refCounter[2]) {
-        refCounter[2] = true;
-        refs.set(djs, refCounter);
-        return { refs, consts: { head: state.consts, tail: [djs] } };
-    }
-    return state;
-};
-const getConstants = djs => refs => {
-    return getConstantsOp(djs)(refs);
-};
-const entryValue = kv => kv[1];
-export const serializeWithoutConst = sort => {
-    const propertySerialize = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ]);
-    const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn(entries)
-        .map(sort)
-        .map(mapPropertySerialize)
-        .map(objectWrap)
-        .result;
-    const f = value => {
-        switch (typeof value) {
+        return state;
+    };
+    const op = djs => state => {
+        switch (typeof djs) {
             case 'boolean': {
-                return boolSerialize(value);
-            }
-            case 'number': {
-                return numberSerialize(value);
-            }
-            case 'string': {
-                return stringSerialize(value);
+                return state;
             }
+            case 'number':
+            case 'string':
             case 'bigint': {
-                return [bigintSerialize(value)];
+                return checkSelf(djs)(state);
             }
             default: {
-                if (value === null) {
-                    return nullSerialize;
+                if (djs === null) {
+                    return state;
                 }
-                if (value === undefined) {
-                    return undefinedSerialize;
+                if (djs === undefined) {
+                    return state;
                 }
-                if (value instanceof Array) {
-                    return arraySerialize(value);
+                if (djs instanceof Array) {
+                    return checkSelf(djs)(fold(op)(state)(djs));
                 }
-                return objectSerialize(value);
+                return checkSelf(djs)(fold(op)(state)(map(entryValue)(entries(djs))));
             }
         }
     };
-    const arraySerialize = compose(map(f))(arrayWrap);
-    return f;
+    const init = { added: new Set(), consts: [] };
+    return djs => op(djs)(init).consts;
 };
-const serializeWithConst = sort => refs => root => {
+const entryValue = kv => kv[1];
+const noRef = () => null;
+const buildSerialize = refLookup => sort => {
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
@@ -101,11 +60,9 @@ const serializeWithConst = sort => refs => root => {
         .map(objectWrap)
         .result;
     const f = value => {
-        if (value !== root) {
-            const refCounter = refs.get(value);
-            if (refCounter !== undefined && refCounter[1] > 1) {
-                return [`c${refCounter[0]}`];
-            }
+        const ref = refLookup(value);
+        if (ref !== null) {
+            return ref;
         }
         switch (typeof value) {
             case 'boolean': {
@@ -137,6 +94,17 @@ const serializeWithConst = sort => refs => root => {
     const arraySerialize = compose(map(f))(arrayWrap);
     return f;
 };
+export const serializeWithoutConst = buildSerialize(noRef);
+const serializeWithConst = sort => refs => root => buildSerialize(value => {
+    if (value === root) {
+        return null;
+    }
+    const refCounter = refs.get(value);
+    if (refCounter !== undefined && refCounter[1] > 1) {
+        return [`c${refCounter[0]}`];
+    }
+    return null;
+})(sort);
 const countRefsOp = djs => refs => {
     switch (typeof djs) {
         case 'boolean':
@@ -167,14 +135,14 @@ const countRefsOp = djs => refs => {
 };
 const addRef = djs => refs => {
     const refCounter = refs.get(djs);
-    if (refCounter === undefined) {
-        return refs.set(djs, [refs.size, 1, false]);
-    }
-    return refs.set(djs, [refCounter[0], refCounter[1] + 1, false]);
+    const newCounter = refCounter === undefined
+        ? [refs.size, 1]
+        : [refCounter[0], refCounter[1] + 1];
+    return new Map([...refs, [djs, newCounter]]);
 };
 export const stringify = sort => djs => {
     const refs = countRefs(djs);
-    const consts = getConstants(djs)({ refs, consts: [] }).consts;
+    const consts = getConstants(refs)(djs);
     const constSerialize = entry => {
         const refCounter = refs.get(entry);
         if (refCounter === undefined) {

package/fs/djs/serializer/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     stringify: ({
         testPrimitives: () => void;
         testArray: () => void;
@@ -22,4 +22,3 @@ declare const _default: {
         stringify: () => void;
     })[];
 };
-export default _default;

package/fs/djs/serializer/{test.f.js → proof.f.js}

@@ -2,7 +2,7 @@ import { countRefs, stringify, stringifyAsTree } from "./module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { identity } from "../../types/function/module.f.js";
 import { setProperty } from "../../json/module.f.js";
-export default {
+export const proof = {
     stringify: [
         {
             testPrimitives: () => {
@@ -12,15 +12,15 @@ export default {
                     throw refs.size;
                 }
                 const refsBigInt = stringifyAsTree(sort)(refs.get(3n));
-                if (refsBigInt !== '[0,1,false]') {
+                if (refsBigInt !== '[0,1]') {
                     throw refsBigInt;
                 }
                 const refsString = stringifyAsTree(sort)(refs.get("str"));
-                if (refsString !== '[1,1,false]') {
+                if (refsString !== '[1,1]') {
                     throw refsString;
                 }
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[2,1,false]') {
+                if (refsRoot !== '[2,1]') {
                     throw refsRoot;
                 }
                 if (refs.get(null) !== undefined) {
@@ -35,11 +35,11 @@ export default {
                     throw refs.size;
                 }
                 const refsArray = stringifyAsTree(sort)(refs.get(array));
-                if (refsArray !== '[0,3,false]') {
+                if (refsArray !== '[0,3]') {
                     throw refsArray;
                 }
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[1,1,false]') {
+                if (refsRoot !== '[1,1]') {
                     throw refsRoot;
                 }
             },
@@ -51,11 +51,11 @@ export default {
                     throw refs.size;
                 }
                 const refsObj = stringifyAsTree(sort)(refs.get(obj));
-                if (refsObj !== '[0,2,false]') {
+                if (refsObj !== '[0,2]') {
                     throw refsObj;
                 }
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[1,1,false]') {
+                if (refsRoot !== '[1,1]') {
                     throw refsRoot;
                 }
             },

package/fs/djs/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     djs: (() => void)[];
     id: (() => void)[];
     keywords: (() => void)[];
     comments: (() => void)[];
     metadata: (() => void)[];
 };
-export default _default;

package/fs/djs/tokenizer/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))
 const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
 const stringify = stringifyAsTree(sort);
 const withoutMetada = tokenWithMetada => { return tokenWithMetada.token; };
-export default {
+export const proof = {
     djs: [
         () => {
             const result = stringify(tokenizeString(''));

package/fs/djs/tokenizer-new/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     isValid: (() => void)[];
     tokenizer: (() => void)[];
     djs: (() => void)[];
 };
-export default _default;

package/fs/djs/tokenizer-new/{test.f.js → proof.f.js}

@@ -108,7 +108,7 @@ const getTokensFromAstRule = ast => {
         return [token];
     return { first: token, tail: getTokensFromAstSequence(ast.sequence) };
 };
-export default {
+export const proof = {
     isValid: [() => {
             const m = descentParser(jsGrammar());
             const expect = (s, expected) => {

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

@@ -10,12 +10,27 @@ 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';
+/**
+ * State threaded through the recursive transpilation of a DJS module graph.
+ *
+ * - `complete`: modules that have been fully parsed and evaluated, keyed by path.
+ * - `stack`: import chain currently being resolved (used to detect circular dependencies).
+ * - `error`: the first parse error encountered, or `null` while everything is clean.
+ */
 export type ParseContext = {
     readonly complete: OrderedMap<djsResult>;
     readonly stack: List<string>;
     readonly error: ParseError | null;
 };
+/** The evaluated DJS value produced for one successfully transpiled module. */
 export type djsResult = {
     djs: Unknown;
 };
+/**
+ * Transpiles a DJS module graph rooted at `path` into a single `Unknown` value.
+ *
+ * Reads each file via the `ReadFile` effect, resolves imports recursively, and
+ * evaluates the AST. Returns `['ok', value]` on success, or `['error', ParseError]`
+ * on a parse failure or circular dependency.
+ */
 export declare const transpile: (path: string) => Effect<ReadFile, Result<Unknown, ParseError>>;

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

@@ -12,7 +12,7 @@ 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 { pure } from "../../types/effects/module.f.js";
+import { foldStep, pure } from "../../types/effects/module.f.js";
 import { readFile } from "../../types/effects/node/module.f.js";
 import { utf8ToString } from "../../text/module.f.js";
 const mapDjs = context => path => {
@@ -35,7 +35,8 @@ const transpileWithImports = path => parseModuleResult => context => {
         const pathsCombine = listMap(pathConcat(dir))(parseModuleResult[1][0]);
         const pathsArray = toArray(pathsCombine);
         const contextWithStack = { ...context, stack: { first: path, tail: context.stack } };
-        return pathsArray.reduce((acc, p) => acc.step(ctx => foldNextModuleOp(p)(ctx)), pure(contextWithStack)).step(contextWithImports => {
+        return foldStep(foldNextModuleOp)(contextWithStack)(pathsArray)
+            .step(contextWithImports => {
             if (contextWithImports.error !== null) {
                 return pure(contextWithImports);
             }
@@ -62,6 +63,13 @@ const foldNextModuleOp = path => context => {
     }
     return parseModule(path).step(parseModuleResult => transpileWithImports(path)(parseModuleResult)(context));
 };
+/**
+ * Transpiles a DJS module graph rooted at `path` into a single `Unknown` value.
+ *
+ * Reads each file via the `ReadFile` effect, resolves imports recursively, and
+ * evaluates the AST. Returns `['ok', value]` on success, or `['error', ParseError]`
+ * on a parse failure or circular dependency.
+ */
 export const transpile = path => foldNextModuleOp(path)({ stack: null, complete: null, error: null }).step((context) => {
     if (context.error !== null) {
         return pure(error(context.error));

package/fs/djs/transpiler/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     parse: () => void;
     parseWithSubModule: () => void;
     parseWithSubModules: () => void;
     parseWithFileNotFoundError: () => void;
     parseWithCycleError: () => void;
 };
-export default _default;

package/fs/djs/transpiler/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));
     return result;
 };
-export default {
+export const proof = {
     parse: () => {
         const result = run({ a: utf8('export default 1') })('a');
         if (result[0] === 'error') {

package/fs/fsc/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     a: () => void;
     fn: () => void;
     f1: () => void;
@@ -6,4 +6,3 @@ declare const _default: {
     f3: () => void;
     f4: () => void;
 };
-export default _default;

package/fs/fsc/{test.f.js → proof.f.js}

@@ -11,7 +11,7 @@ const fn = (f, name) => ({ [name]: f }[name]);
 const withName = (name) => 
 // translated into one command: define a `function [name]() { return undefined }`
 Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
-export default {
+export const proof = {
     a: () => {
         const x = f('1');
         if (x !== '["1"]') {

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

@@ -0,0 +1,4 @@
+export declare const proof: {
+    dfa: () => void;
+    run: (() => void)[];
+};

package/fs/fsm/{test.f.js → proof.f.js}

@@ -28,7 +28,7 @@ const buildDfa = () => {
     ];
     return dfa(grammar);
 };
-export default {
+export const proof = {
     dfa: () => {
         const dfa = buildDfa();
         const entries = Object.entries(dfa);

package/fs/html/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     empty: () => void;
     empty2: () => void;
     void: () => void;
@@ -13,4 +13,3 @@ declare const _default: {
         noRaw: () => void;
     };
 };
-export default _default;

package/fs/html/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { htmlToString } from "./module.f.js";
-export default {
+export const proof = {
     empty: () => {
         const r = htmlToString(['html']);
         if (r !== '<!DOCTYPE html><html></html>') {

package/fs/io/module.d.ts

@@ -4,6 +4,6 @@ import { type Result } from '../types/result/module.f.ts';
 export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
 export declare const io: Io;
-export type NodeRun = (p: NodeProgram) => Promise<number>;
+export type NodeRun = (p: NodeProgram) => Promise<never>;
 declare const effectRun: NodeRun;
 export default effectRun;

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

@@ -74,7 +74,7 @@ export type Process = {
     readonly stderr: Writable;
 };
 export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
-export type Sandbox = <T>(f: () => T) => SandboxResult<T>;
+export type Sandbox = <T>(f: () => T) => Promise<SandboxResult<T>>;
 export type Server = {
     readonly listen: (port: number) => void;
 };
@@ -120,6 +120,7 @@ export type Io = {
     readonly bunTestContext: TestContext;
     readonly playwrightTestContext: TestContext;
     readonly engine: Engine;
+    readonly await: (p: unknown) => Promise<readonly [unknown]>;
 };
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;
@@ -129,5 +130,5 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, write: ioWrite, }: Io) => EffectToPromise;
+export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }: Io) => EffectToPromise;
 export declare const runProgram: (io: Io) => (args: readonly string[]) => (program: NodeProgram) => Promise<number>;

package/fs/io/module.f.js

@@ -45,7 +45,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, write: ioWrite, }) => {
+export 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 () => {
@@ -95,8 +95,9 @@ export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile,
         },
         forever: () => new Promise(() => { }),
         now: async () => ioNow(),
-        sandbox: async (f) => ioSandbox(f),
-        write: ioWrite,
+        sandbox,
+        await: awaitPromise,
+        write,
         test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
     });
     return result;

package/fs/io/module.js

@@ -12,7 +12,7 @@ import fs from 'node:fs';
 import process from 'node:process';
 import { concat } from "../path/module.f.js";
 import { once } from 'node:events';
-import { fromIo, runProgram } from "./module.f.js";
+import { runProgram } from "./module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec } from "../types/uint8array/module.f.js";
 import * as testContext from 'node:test';
@@ -35,12 +35,11 @@ const inlineTest = async (name, { expectFailure }, fn) => {
     }
 };
 const inlineContext = { test: inlineTest };
-const bunTestContext = {
-    test: (name, opts, fn) => testContext.test(name, () => inlineTest(name, opts, fn))
-};
-const playwrightTestContext = {
-    test: (name, opts, fn) => pwTest(name, () => inlineTest(name, opts, fn))
-};
+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. */
@@ -76,6 +75,7 @@ export const tryCatch = f => {
         return error(e);
     }
 };
+const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
 export const io = {
     console,
     fs,
@@ -99,14 +99,18 @@ export const io = {
     http,
     childProcess,
     now,
-    sandbox: (f) => {
+    sandbox: async (f) => {
         let result;
         let after;
         const before = performance.now();
         try {
-            const value = f();
+            let p = f();
             after = performance.now();
-            result = ok(value);
+            if (p instanceof Promise) {
+                p = await p;
+                after = performance.now();
+            }
+            result = ok(p);
         }
         catch (e) {
             after = performance.now();
@@ -115,10 +119,14 @@ export const io = {
         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',
 };
-const effectRun = runProgram(io)(io.process.argv.slice(2));
+const effectRun = async (p) => {
+    const code = await runProgram(io)(io.process.argv.slice(2))(p);
+    return process.exit(code);
+};
 export default effectRun;

package/fs/js/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     djs: (() => void)[];
     operators: (() => void)[];
     ws: (() => void)[];
@@ -7,4 +7,3 @@ declare const _default: {
     comments: (() => void)[];
     metadata: (() => void)[];
 };
-export default _default;

package/fs/js/tokenizer/{test.f.js → proof.f.js}

@@ -7,7 +7,7 @@ const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))
 const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
 const stringify = stringifyAsTree(sort);
 const withoutMetada = tokenWithMetada => tokenWithMetada.token;
-export default {
+export const proof = {
     djs: [
         () => {
             const result = stringify(tokenizeString(''));

package/fs/json/parser/{test.f.d.ts → proof.f.d.ts}

@@ -1,5 +1,4 @@
-declare const _default: {
+export declare const proof: {
     valid: (() => void)[];
     invalid: (() => void)[];
 };
-export default _default;

package/fs/json/parser/{test.f.js → proof.f.js}

@@ -6,7 +6,7 @@ import { sort } from "../../types/object/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s)));
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     valid: [
         () => {
             const tokenList = tokenizeString('null');

package/fs/json/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     setProperty: () => void;
     stringify: {
         sort: () => void;
         identity: () => void;
     }[];
 };
-export default _default;

package/fs/json/{test.f.js → proof.f.js}

@@ -1,7 +1,7 @@
 import { setProperty, stringify } from "./module.f.js";
 import { sort } from "../types/object/module.f.js";
 import { identity } from "../types/function/module.f.js";
-export default {
+export const proof = {
     setProperty: () => {
         if (setProperty("Hello")([])({}) !== "Hello") {
             throw 'error';

package/fs/json/serializer/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     arrayWrap: (() => void)[];
     objectWrap: (() => void)[];
     stringSerialize: (() => void)[];
     numberSerialize: (() => void)[];
     boolSerialize: (() => void)[];
 };
-export default _default;

package/fs/json/serializer/{test.f.js → proof.f.js}

@@ -1,7 +1,7 @@
 import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from "./module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { toArray } = list;
-export default {
+export const proof = {
     arrayWrap: [
         () => {
             const result = JSON.stringify(toArray(arrayWrap(null)));

package/fs/json/tokenizer/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     json: (() => void)[];
     id: (() => void)[];
     keywords: (() => void)[];
 };
-export default _default;

package/fs/json/tokenizer/{test.f.js → proof.f.js}

@@ -5,7 +5,7 @@ import { sort } from "../../types/object/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenize(stringToList(s)));
 const stringify = stringifyAsTree(sort);
-export default {
+export const proof = {
     json: [
         () => {
             const result = stringify(tokenizeString(''));