functionalscript 0.43.0 → 0.44.0

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

@@ -1,173 +0,0 @@
-import { fold } from '../../types/list/module.f.js';
-import { concat } from '../../types/string/module.f.js';
-import { flat, flatMap, map, concat as listConcat } from '../../types/list/module.f.js';
-const { entries } = Object;
-import { compose, fn } from '../../types/function/module.f.js';
-import { serialize as bigintSerialize } from '../../types/bigint/module.f.js';
-import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from '../../media/json/serializer/module.f.js';
-const colon = [':'];
-export const undefinedSerialize = ['undefined'];
-/**
- * Returns the value's `RefCounter` only if it is *shared* (referenced more
- * than once) — otherwise `undefined`. Names the single predicate that drives
- * const hoisting in both `getConstants` (decide which values become consts)
- * and `serializeWithConst` (emit a `c<N>` reference to one).
- */
-const sharedRef = (refs) => (v) => {
-    const rc = refs.get(v);
-    return rc !== undefined && rc[1] > 1 ? rc : undefined;
-};
-const getConstants = refs => {
-    const shared = sharedRef(refs);
-    const checkSelf = djs => state => {
-        if (shared(djs) !== undefined && !state.added.has(djs)) {
-            return {
-                added: new Set([...state.added, djs]),
-                consts: { head: state.consts, tail: [djs] }
-            };
-        }
-        return state;
-    };
-    const op = djs => state => {
-        switch (typeof djs) {
-            case 'boolean': {
-                return state;
-            }
-            case 'number':
-            case 'string':
-            case 'bigint': {
-                return checkSelf(djs)(state);
-            }
-            default: {
-                if (djs === null) {
-                    return state;
-                }
-                if (djs === undefined) {
-                    return state;
-                }
-                if (djs instanceof Array) {
-                    return checkSelf(djs)(fold(op)(state)(djs));
-                }
-                return checkSelf(djs)(fold(op)(state)(map(entryValue)(entries(djs))));
-            }
-        }
-    };
-    const init = { added: new Set(), consts: [] };
-    return djs => op(djs)(init).consts;
-};
-const entryValue = kv => kv[1];
-const noRef = () => null;
-const buildSerialize = refLookup => 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 => {
-        const ref = refLookup(value);
-        if (ref !== null) {
-            return ref;
-        }
-        switch (typeof value) {
-            case 'boolean': {
-                return boolSerialize(value);
-            }
-            case 'number': {
-                return numberSerialize(value);
-            }
-            case 'string': {
-                return stringSerialize(value);
-            }
-            case 'bigint': {
-                return [bigintSerialize(value)];
-            }
-            default: {
-                if (value === null) {
-                    return nullSerialize;
-                }
-                if (value === undefined) {
-                    return undefinedSerialize;
-                }
-                if (value instanceof Array) {
-                    return arraySerialize(value);
-                }
-                return objectSerialize(value);
-            }
-        }
-    };
-    const arraySerialize = compose(map(f))(arrayWrap);
-    return f;
-};
-export const serializeWithoutConst = buildSerialize(noRef);
-const serializeWithConst = sort => refs => {
-    const shared = sharedRef(refs);
-    return root => buildSerialize(value => {
-        if (value === root) {
-            return null;
-        }
-        const rc = shared(value);
-        if (rc !== undefined) {
-            return [`c${rc[0]}`];
-        }
-        return null;
-    })(sort);
-};
-const countRefsOp = djs => refs => {
-    switch (typeof djs) {
-        case 'boolean':
-        case 'number': {
-            return refs;
-        }
-        case 'string':
-        case 'bigint': {
-            return addRef(djs)(refs);
-        }
-        default: {
-            switch (djs) {
-                case null:
-                case undefined: {
-                    return refs;
-                }
-            }
-            if (djs instanceof Array) {
-                if (refs.has(djs))
-                    return addRef(djs)(refs);
-                return addRef(djs)(fold(countRefsOp)(refs)(djs));
-            }
-            if (refs.has(djs))
-                return addRef(djs)(refs);
-            return addRef(djs)(fold(countRefsOp)(refs)(map(entryValue)(entries(djs))));
-        }
-    }
-};
-const addRef = djs => refs => {
-    const refCounter = refs.get(djs);
-    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(refs)(djs);
-    const constSerialize = entry => {
-        const refCounter = refs.get(entry);
-        if (refCounter === undefined) {
-            throw 'unexpected behavior';
-        }
-        return flat([['const c'], numberSerialize(refCounter[0]), [' = '], serializeWithConst(sort)(refs)(entry)(entry), ['\n']]);
-    };
-    const constStrings = flatMap(constSerialize)(consts);
-    const rootStrings = listConcat(['export default '])(serializeWithConst(sort)(refs)(djs)(djs));
-    return concat(listConcat(constStrings)(rootStrings));
-};
-export const stringifyAsTree = sort => compose(serializeWithoutConst(sort))(concat);
-export const countRefs = djs => {
-    return countRefsOp(djs)(new Map());
-};

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

@@ -1,133 +0,0 @@
-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 '../../media/json/module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    stringify: [
-        {
-            testPrimitives: () => {
-                const djs = [1, 2, 2, 2, true, false, undefined, null, 3n, "str"];
-                const refs = countRefs(djs);
-                assertEq(refs.size, 3);
-                const refsBigInt = stringifyAsTree(sort)(refs.get(3n));
-                assertEq(refsBigInt, '[0,1]');
-                const refsString = stringifyAsTree(sort)(refs.get("str"));
-                assertEq(refsString, '[1,1]');
-                const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                assertEq(refsRoot, '[2,1]');
-                assertEq(refs.get(null), undefined);
-            },
-            testArray: () => {
-                const array = [null];
-                const djs = [array, array, array];
-                const refs = countRefs(djs);
-                assertEq(refs.size, 2);
-                const refsArray = stringifyAsTree(sort)(refs.get(array));
-                assertEq(refsArray, '[0,3]');
-                const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                assertEq(refsRoot, '[1,1]');
-            },
-            testObj: () => {
-                const obj = { "a": 1, "b": 2 };
-                const djs = [obj, obj, 1];
-                const refs = countRefs(djs);
-                assertEq(refs.size, 2);
-                const refsObj = stringifyAsTree(sort)(refs.get(obj));
-                assertEq(refsObj, '[0,2]');
-                const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                assertEq(refsRoot, '[1,1]');
-            },
-        },
-        {
-            testSort: () => {
-                const obj = { "a": 1, "c": 2n, "b": [undefined, null, true, false] };
-                const djs = [obj, obj, 1];
-                const res = stringify(sort)(djs);
-                if (res !== 'const c2 = {"a":1,"b":[undefined,null,true,false],"c":2n}\nexport default [c2,c2,1]') {
-                    throw res;
-                }
-            },
-            testIdentity: () => {
-                const obj = { "a": 1, "c": 2n, "b": [undefined, null, true, false] };
-                const djs = [obj, obj, 1];
-                const res = stringify(identity)(djs);
-                if (res !== 'const c2 = {"a":1,"c":2n,"b":[undefined,null,true,false]}\nexport default [c2,c2,1]') {
-                    throw res;
-                }
-            },
-        }
-    ],
-    stringifyAsTree: [
-        {
-            sort: () => {
-                const r = setProperty("Hello")(['a'])({});
-                const x = stringifyAsTree(sort)(r);
-                if (x !== '{"a":"Hello"}') {
-                    throw x;
-                }
-            },
-            identity: () => {
-                const x = stringifyAsTree(identity)(setProperty("Hello")(['a'])({}));
-                if (x !== '{"a":"Hello"}') {
-                    throw x;
-                }
-            },
-        },
-        {
-            sort: () => {
-                const x = stringifyAsTree(sort)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
-                if (x !== '{"a":"Hello","b":12,"c":[]}') {
-                    throw x;
-                }
-            },
-            identity: () => {
-                const x = stringifyAsTree(identity)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
-                if (x !== '{"c":[],"b":12,"a":"Hello"}') {
-                    throw x;
-                }
-            },
-        },
-        {
-            sort: () => {
-                const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = stringifyAsTree(sort)(_1);
-                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
-                    throw _2;
-                }
-            },
-            identity: () => {
-                const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = stringifyAsTree(identity)(_1);
-                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
-                    throw _2;
-                }
-            }
-        },
-        {
-            stringify: () => {
-                const bi = 1234567890n;
-                const result = stringifyAsTree(sort)(bi);
-                assertEq(result, '1234567890n');
-            }
-        },
-        {
-            stringify: () => {
-                const arr = [0n, 1, 2n];
-                const result = stringifyAsTree(sort)(arr);
-                assertEq(result, '[0n,1,2n]');
-            }
-        },
-        {
-            stringify: () => {
-                const obj = { "a": 0n, "b": 1, "c": 2n };
-                const result = stringifyAsTree(sort)(obj);
-                if (result !== '{"a":0n,"b":1,"c":2n}') {
-                    throw result;
-                }
-            }
-        }
-    ]
-};

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

@@ -1,24 +0,0 @@
-/**
- * Experimental DJS parser implementation.
- *
- * @module
- */
-import { type DescentMatch, type DescentMatchResult } from "../../bnf/descent/module.f.ts";
-import { type Rule } from "../../bnf/module.f.ts";
-import { type BigIntToken, type CommentToken, type EofToken, type ErrorToken, type IdToken, type JsTokenWithMetadata, type NewLineToken, type NumberToken, type StringToken, type TokenMetadata, type WhitespaceToken } from "../../js/tokenizer/module.f.ts";
-import { type CodePoint } from "../../text/utf16/module.f.ts";
-import { type List } from "../../types/list/module.f.ts";
-export declare const jsGrammar: () => Rule;
-export declare const descentParserCpOnly: (m: DescentMatch<unknown>, name: string, cp: readonly CodePoint[]) => DescentMatchResult<unknown>;
-export declare const tokenizeString: (s: string) => string;
-export declare const tokenizeJs: (input: List<number>) => (path: string) => List<JsTokenWithMetadata>;
-export type DjsToken = {
-    readonly kind: 'true' | 'false' | 'null' | 'undefined';
-} | {
-    readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=';
-} | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | WhitespaceToken | NewLineToken | CommentToken | EofToken;
-export type DjsTokenWithMetadata = {
-    readonly token: DjsToken;
-    readonly metadata: TokenMetadata;
-};
-export declare const tokenize: (input: List<number>) => (path: string) => List<DjsTokenWithMetadata>;