functionalscript 0.43.1 → 0.45.0

package/fjs/djs/ast/proof.f.js

@@ -1,49 +0,0 @@
-import { sort } from '../../types/object/module.f.js';
-import { run } from './module.f.js';
-import { stringifyAsTree } from '../serializer/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    test: () => {
-        const djs = run([1])([]);
-        const result = stringifyAsTree(sort)(djs);
-        assertEq(result, '1');
-    },
-    testCref: () => {
-        const djs = run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
-        const result = stringifyAsTree(sort)(djs);
-        assertEq(result, '4');
-    },
-    testAref: () => {
-        const djs = run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
-        const result = stringifyAsTree(sort)(djs);
-        assertEq(result, '14');
-    },
-    testArray: () => {
-        const djs = run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
-        const result = stringifyAsTree(sort)(djs);
-        assertEq(result, '[14,4]');
-    },
-    testObj: () => {
-        const djs = run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);
-        const result = stringifyAsTree(sort)(djs);
-        if (result !== '{"key":{"key2":[14,4]}}') {
-            throw result;
-        }
-    },
-    testBool: () => {
-        assertEq(stringifyAsTree(sort)(run([true])([])), 'true');
-        assertEq(stringifyAsTree(sort)(run([false])([])), 'false');
-    },
-    testStr: () => {
-        assertEq(stringifyAsTree(sort)(run(['hello'])([])), '"hello"');
-    },
-    testNull: () => {
-        assertEq(stringifyAsTree(sort)(run([null])([])), 'null');
-    },
-    testBigint: () => {
-        assertEq(stringifyAsTree(sort)(run([42n])([])), '42n');
-    },
-    testUndefined: () => {
-        assertEq(stringifyAsTree(sort)(run([undefined])([])), 'undefined');
-    },
-};

package/fjs/djs/examples/input.f.js

@@ -1,4 +0,0 @@
-import c from "./m.f.js";
-const a = 1;
-const b = 2;
-export default [a, a, b, c, c];

package/fjs/djs/examples/m.f.js

@@ -1 +0,0 @@
-export default "text";

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

@@ -1,17 +0,0 @@
-/**
- * High-level DJS API for parsing, transpiling, and serializing modules.
- *
- * @module
- */
-import type { Primitive as JsonPrimitive } from '../media/json/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;
-};
-export type Array = readonly Unknown[];
-export type Primitive = JsonPrimitive | bigint | undefined;
-export type Unknown = Primitive | Object | Array;
-type CompileOp = ReadFile | WriteFile | Write;
-export declare const compile: (args: readonly string[]) => Effect<CompileOp, number>;
-export {};

package/fjs/djs/module.f.js

@@ -1,22 +0,0 @@
-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, step } from '../effects/module.f.js';
-import { writeUtf8File, error, } from '../effects/node/module.f.js';
-export const compile = args => {
-    if (args.length < 2) {
-        return step(error('Error: Requires 2 or more arguments'), () => pure(1));
-    }
-    const inputFileName = args[0];
-    const outputFileName = args[1];
-    return step(transpile(inputFileName), (result) => {
-        if (result[0] === 'error') {
-            const metadata = result[1].metadata;
-            return step(error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`), () => pure(0));
-        }
-        const content = outputFileName.endsWith('.json')
-            ? stringifyAsTree(sort)(result[1])
-            : stringify(sort)(result[1]);
-        return step(writeUtf8File(outputFileName, content), () => pure(0));
-    });
-};

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

@@ -1,23 +0,0 @@
-/**
- * DJS parser that builds structured trees from DJS tokens.
- *
- * @module
- */
-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 { AstModule } from '../ast/module.f.ts';
-import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
-export type ParseError = {
-    readonly message: string;
-    readonly metadata: TokenMetadata | null;
-};
-export declare const parseFromTokens: (tokenList: List<DjsTokenWithMetadata>) => Result<AstModule, ParseError>;
-export declare const proof: {
-    pushKey: {
-        nonObjectTop: () => void;
-    };
-    endArray: {
-        nonArrayTop: () => void;
-    };
-};

package/fjs/djs/parser/module.f.js

@@ -1,410 +0,0 @@
-/**
- * DJS parser that builds structured trees from DJS tokens.
- *
- * @module
- */
-import { error, ok } from '../../types/result/module.f.js';
-import { fold, next, toArray, length, concat } from '../../types/list/module.f.js';
-import { setReplace, at } from '../../types/ordered_map/module.f.js';
-import { fromMap } from '../../types/object/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-const parseInitialOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            switch (token.value) {
-                case 'import': return { ...state, state: 'import' };
-                case 'const': return { ...state, state: 'const' };
-                case 'export': return { ...state, state: 'export' };
-            }
-        }
-    }
-    return foldOp({ token, metadata })({ ...state, state: 'exportValue', valueState: '', top: null, stack: null });
-};
-const parseNewLineRequiredOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case '//':
-        case '/*': return state;
-        case 'nl': return { ...state, state: '' };
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseExportOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        case 'id': {
-            if (token.value === 'default')
-                return { ...state, state: 'exportValue', valueState: '', top: null, stack: null };
-        }
-    }
-    return { state: 'error', error: { message: 'unexpected token', metadata } };
-};
-const parseResultOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*':
-        case 'eof': return state;
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseConstOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            if (at(token.value)(state.module.refs) !== null)
-                return { state: 'error', error: { message: 'duplicate id', metadata } };
-            const cref = ['cref', length(state.module.consts)];
-            const refs = setReplace(token.value)(cref)(state.module.refs);
-            return { ...state, state: 'const+name', module: { ...state.module, refs: refs } };
-        }
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseConstNameOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case '=': return { ...state, state: 'constValue', valueState: '', top: null, stack: null };
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseImportOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'id': {
-            if (at(token.value)(state.module.refs) !== null) {
-                return { state: 'error', error: { message: 'duplicate id', metadata } };
-            }
-            const aref = ['aref', length(state.module.modules)];
-            const refs = setReplace(token.value)(aref)(state.module.refs);
-            return { ...state, state: 'import+name', module: { ...state.module, refs: refs } };
-        }
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseImportNameOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        case 'id': {
-            if (token.value === 'from')
-                return { ...state, state: 'import+from' };
-        }
-    }
-    return { state: 'error', error: { message: 'unexpected token', metadata } };
-};
-const parseImportFromOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'string': {
-            const modules = concat(state.module.modules)([token.value]);
-            return { ...state, state: 'nl', module: { ...state.module, modules: modules } };
-        }
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const addKeyToObject = obj => key => (['object', obj[1], key]);
-const addValueToObject = obj => value => (['object', setReplace(obj[2])(value)(obj[1]), '']);
-const addToArray = array => value => (['array', concat(array[1])([value])]);
-const pushKey = state => key => metadata => {
-    if (state.top?.[0] === 'object') {
-        return { ...state, valueState: '{k', top: addKeyToObject(state.top)(key), stack: state.stack };
-    }
-    return { state: 'error', error: { message: 'error', metadata } };
-};
-const pushValue = state => value => {
-    if (state.top === null) {
-        const consts = concat(state.module.consts)([value]);
-        switch (state.state) {
-            case 'exportValue': return { ...state, state: 'result', module: { ...state.module, consts: consts } };
-            case 'constValue': return { ...state, state: 'nl', module: { ...state.module, consts: consts } };
-        }
-    }
-    if (state.top?.[0] === 'array') {
-        return { ...state, valueState: '[v', top: addToArray(state.top)(value), stack: state.stack };
-    }
-    return { ...state, valueState: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
-};
-const pushRef = state => name => metadata => {
-    const ref = at(name)(state.module.refs);
-    if (ref === null)
-        return { state: 'error', error: { message: 'const not found', metadata } };
-    return pushValue(state)(ref);
-};
-const startArray = state => {
-    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
-    return { ...state, valueState: '[', top: ['array', null], stack: newStack };
-};
-// Pops the enclosing container off `stack`. `next` is forced here rather than
-// left as a `drop(1)` thunk: the stack is written only by startArray/startObject,
-// always as a literal cons, and a lazy pop leaves one unforced thunk per closed
-// container — a chain that overflows the call stack when it is finally forced.
-const popStack = state => {
-    const ne = next(state.stack);
-    return ne === null
-        ? { ...state, valueState: '', top: null, stack: null }
-        : { ...state, valueState: '', top: ne.first, stack: ne.tail };
-};
-const endArray = state => {
-    const top = state.top;
-    const newState = popStack(state);
-    if (top !== null && top[0] === 'array') {
-        const array = ['array', toArray(top[1])];
-        return pushValue(newState)(array);
-    }
-    return pushValue(newState)(null);
-};
-const startObject = state => {
-    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
-    return { ...state, valueState: '{', top: ['object', null, ''], stack: newStack };
-};
-const endObject = state => {
-    const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
-    const newState = popStack(state);
-    return pushValue(newState)(obj);
-};
-const tokenToValue = token => {
-    switch (token.kind) {
-        case 'null': return null;
-        case 'false': return false;
-        case 'true': return true;
-        case 'number': return parseFloat(token.value);
-        case 'string': return token.value;
-        case 'bigint': return token.value;
-        case 'undefined': return undefined;
-        default: return null;
-    }
-};
-const isValueToken = token => {
-    switch (token.kind) {
-        case 'null':
-        case 'false':
-        case 'true':
-        case 'number':
-        case 'string':
-        case 'bigint':
-        case 'undefined': return true;
-        default: return false;
-    }
-};
-const parseValueOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case ']':
-            if (state.valueState === '[,') {
-                return endArray(state);
-            }
-            return { state: 'error', error: { message: 'unexpected token', metadata } };
-        case 'id': return pushRef(state)(token.value)(metadata);
-        case '[': return startArray(state);
-        case '{': return startObject(state);
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default:
-            if (isValueToken(token)) {
-                return pushValue(state)(tokenToValue(token));
-            }
-            return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseArrayStartOp = ({ token, metadata }) => state => {
-    if (isValueToken(token)) {
-        return pushValue(state)(tokenToValue(token));
-    }
-    switch (token.kind) {
-        case 'id': return pushRef(state)(token.value)(metadata);
-        case '[': return startArray(state);
-        case ']': return endArray(state);
-        case '{': return startObject(state);
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseArrayValueOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case ']': return endArray(state);
-        case ',': return { ...state, valueState: '[,', top: state.top, stack: state.stack };
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-// allow identifier property names (#2410)
-const parseObjectStartOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case 'string':
-        case 'id':
-            return pushKey(state)(String(token.value))(metadata);
-        case '}': return endObject(state);
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseObjectKeyOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case ':': return { ...state, valueState: '{:', top: state.top, stack: state.stack };
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseObjectColonOp = ({ token, metadata }) => state => {
-    if (isValueToken(token)) {
-        return pushValue(state)(tokenToValue(token));
-    }
-    switch (token.kind) {
-        case 'id': return pushRef(state)(token.value)(metadata);
-        case '[': return startArray(state);
-        case '{': return startObject(state);
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseObjectNextOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case '}': return endObject(state);
-        case ',': return { ...state, valueState: '{,', top: state.top, stack: state.stack };
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const parseObjectCommaOp = ({ token, metadata }) => state => {
-    switch (token.kind) {
-        case '}': return endObject(state);
-        case 'string':
-        case 'id':
-            return pushKey(state)(String(token.value))(metadata);
-        case 'ws':
-        case 'nl':
-        case '//':
-        case '/*': return state;
-        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
-        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
-    }
-};
-const foldOp = token => state => {
-    switch (state.state) {
-        case '': return parseInitialOp(token)(state);
-        case 'nl': return parseNewLineRequiredOp(token)(state);
-        case 'import': return parseImportOp(token)(state);
-        case 'import+name': return parseImportNameOp(token)(state);
-        case 'import+from': return parseImportFromOp(token)(state);
-        case 'const': return parseConstOp(token)(state);
-        case 'const+name': return parseConstNameOp(token)(state);
-        case 'export': return parseExportOp(token)(state);
-        case 'result': return parseResultOp(token)(state);
-        case 'error': return { state: 'error', error: state.error };
-        case 'constValue':
-        case 'exportValue':
-            {
-                switch (state.valueState) {
-                    case '': return parseValueOp(token)(state);
-                    case '[': return parseArrayStartOp(token)(state);
-                    case '[v': return parseArrayValueOp(token)(state);
-                    case '[,': return parseValueOp(token)(state);
-                    case '{': return parseObjectStartOp(token)(state);
-                    case '{k': return parseObjectKeyOp(token)(state);
-                    case '{:': return parseObjectColonOp(token)(state);
-                    case '{v': return parseObjectNextOp(token)(state);
-                    case '{,': return parseObjectCommaOp(token)(state);
-                }
-            }
-    }
-};
-export const parseFromTokens = (tokenList) => {
-    const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null } })(tokenList);
-    switch (state.state) {
-        case 'result': return ok([toArray(state.module.modules), toArray(state.module.consts)]);
-        case 'error': return error(state.error);
-        default: return error({ message: 'unexpected end', metadata: null });
-    }
-};
-export const proof = {
-    pushKey: {
-        // `pushKey` is only ever invoked while `state.top` is an object (the
-        // `'{'`/`'{,'` value-states guarantee it), so its non-object guard is
-        // a defensive branch unreachable through `parseFromTokens`. Call it
-        // directly to cover that branch.
-        nonObjectTop: () => {
-            const state = {
-                state: 'exportValue',
-                module: { refs: null, modules: null, consts: null },
-                valueState: '[',
-                top: null,
-                stack: null,
-            };
-            const result = pushKey(state)('key')({ path: 'test', line: 0, column: 0 });
-            assertEq(result.state, 'error');
-        },
-    },
-    endArray: {
-        // `endArray` is only ever invoked while `state.top` is an array (the
-        // `'['`/`'[v'`/`'[,'` value-states guarantee it), so its non-array
-        // guard is a defensive branch unreachable through `parseFromTokens`.
-        // Call it directly to cover that branch.
-        nonArrayTop: () => {
-            const state = {
-                state: 'exportValue',
-                module: { refs: null, modules: null, consts: null },
-                valueState: '[,',
-                top: null,
-                stack: null,
-            };
-            const result = endArray(state);
-            assertEq(result.state, 'result');
-        },
-    },
-};

package/fjs/djs/parser/proof.f.d.ts

@@ -1,14 +0,0 @@
-export declare const proof: {
-    valid: (() => void)[];
-    invalid: (() => void)[];
-    errorMetadata: (() => void)[];
-    validWhiteSpaces: (() => void)[];
-    validJson: (() => void)[];
-    invalidModule: (() => void)[];
-    validWithConst: (() => void)[];
-    invalidWithConst: (() => void)[];
-    validWithArgs: (() => void)[];
-    invalidWithArgs: (() => void)[];
-    comments: (() => void)[];
-    containerStackCost: (() => void)[];
-};