functionalscript 0.3.3 → 0.3.5

package/fsm/module.f.js

@@ -0,0 +1,59 @@
+import * as list from "../types/list/module.f.js";
+const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list;
+import * as byteSet from "../types/byte_set/module.f.js";
+const { toRangeMap, union: byteSetUnion, one, empty } = byteSet;
+import * as sortedSet from "../types/sorted_set/module.f.js";
+const { intersect, union: sortedSetUnion } = sortedSet;
+import * as rangeMap from "../types/range_map/module.f.js";
+const { merge } = rangeMap;
+import * as cmp from "../types/function/compare/module.f.js";
+const { unsafeCmp } = cmp;
+import * as operator from "../types/function/operator/module.f.js";
+const { strictEqual } = operator;
+import * as j from "../json/module.f.js";
+const { stringify } = j;
+import * as f from "../types/function/module.f.js";
+const { identity } = f;
+import * as utf16 from "../text/utf16/module.f.js";
+const { stringToList } = utf16;
+const stringifyIdentity = stringify(identity);
+export const toRange = s => {
+    const [b, e] = toArray(stringToList(s));
+    return byteSet.range([b, e]);
+};
+const toUnionOp = i => bs => byteSetUnion(bs)(one(i));
+export const toUnion = s => {
+    const codePoints = stringToList(s);
+    return fold(toUnionOp)(empty)(codePoints);
+};
+const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) };
+const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set));
+const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
+    if (hasState(ruleIn)(set)) {
+        return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut));
+    }
+    return rm;
+};
+const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp];
+const scanStringify = scan(stringifyOp);
+const fetchOp = ([item, _]) => [item, fetchOp];
+const scanFetch = scan(fetchOp);
+const addEntry = grammar => set => dfa => {
+    const s = stringifyIdentity(set);
+    if (s in dfa) {
+        return dfa;
+    }
+    const setMap = fold(foldOp(set))(emptyList)(grammar);
+    const stringMap = toArray(scanStringify(setMap));
+    const newDfa = { ...dfa, [s]: stringMap };
+    const newStates = scanFetch(setMap);
+    return fold(addEntry(grammar))(newDfa)(newStates);
+};
+const emptyState = [];
+const emptyStateStringify = stringifyIdentity(emptyState);
+const initialState = [''];
+const initialStateStringify = stringifyIdentity(initialState);
+export const dfa = grammar => addEntry(grammar)(initialState)({});
+const get = rangeMap.get(emptyStateStringify);
+const runOp = dfa => input => s => get(input)(dfa[s]);
+export const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input);

package/fsm/test.f.d.ts

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

package/fsm/test.f.js

@@ -0,0 +1,137 @@
+import * as _ from "./module.f.js";
+import * as byteSet from "../types/byte_set/module.f.js";
+import * as o from "../types/object/module.f.js";
+const { sort, fromEntries } = o;
+import * as json from "../json/module.f.js";
+import * as f from "../types/function/module.f.js";
+const { identity } = f;
+import * as list from "../types/list/module.f.js";
+const { toArray } = list;
+import * as utf16 from "../text/utf16/module.f.js";
+const { stringToList } = utf16;
+const stringifyIdentity = json.stringify(identity);
+const buildDfa = () => {
+    const lowercaseAlpha = _.toRange('az');
+    const uppercaseAlpha = _.toRange('AZ');
+    const alpha = byteSet.union(lowercaseAlpha)(uppercaseAlpha);
+    const idSymbol = _.toUnion('_$');
+    const idBegin = byteSet.union(alpha)(idSymbol);
+    const digit = _.toRange('09');
+    const idNext = byteSet.union(idBegin)(digit);
+    const dot = _.toUnion('.');
+    const grammar = [
+        ['', digit, 'int'],
+        ['int', digit, 'int'],
+        ['', digit, 'floatBegin'],
+        ['floatBegin', digit, 'floatBegin'],
+        ['floatBegin', dot, 'floatDot'],
+        ['floatDot', digit, 'float'],
+        ['float', digit, 'float'],
+        ['', idBegin, 'id'],
+        ['id', idNext, 'id']
+    ];
+    return _.dfa(grammar);
+};
+export default {
+    dfa: () => {
+        const dfa = buildDfa();
+        const entries = Object.entries(dfa);
+        const sortedEntries = sort(entries);
+        const obj = fromEntries(sortedEntries);
+        const result = stringifyIdentity(obj);
+        const expectedObj = {
+            '[""]': [
+                ['[]', 35],
+                ['["id"]', 36],
+                ['[]', 47],
+                ['["floatBegin","int"]', 57],
+                ['[]', 64],
+                ['["id"]', 90],
+                ['[]', 94],
+                ['["id"]', 95],
+                ['[]', 96],
+                ['["id"]', 122]
+            ],
+            '["float"]': [['[]', 47], ['["float"]', 57]],
+            '["floatBegin","int"]': [
+                ['[]', 45],
+                ['["floatDot"]', 46],
+                ['[]', 47],
+                ['["floatBegin","int"]', 57]
+            ],
+            '["floatDot"]': [['[]', 47], ['["float"]', 57]],
+            '["id"]': [
+                ['[]', 35],
+                ['["id"]', 36],
+                ['[]', 47],
+                ['["id"]', 57],
+                ['[]', 64],
+                ['["id"]', 90],
+                ['[]', 94],
+                ['["id"]', 95],
+                ['[]', 96],
+                ['["id"]', 122]
+            ],
+            '[]': []
+        };
+        const expectedResult = stringifyIdentity(expectedObj);
+        if (result !== expectedResult) {
+            throw result;
+        }
+    },
+    run: [
+        () => {
+            const dfa = buildDfa();
+            const input = stringToList('a1');
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const expectedOutput = [
+                '["id"]',
+                '["id"]'
+            ];
+            const expectedResult = stringifyIdentity(expectedOutput);
+            if (result !== expectedResult) {
+                throw result;
+            }
+        },
+        () => {
+            const dfa = buildDfa();
+            const input = stringToList('0.1');
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const expectedOutput = [
+                '["floatBegin","int"]',
+                '["floatDot"]',
+                '["float"]'
+            ];
+            const expectedResult = stringifyIdentity(expectedOutput);
+            if (result !== expectedResult) {
+                throw result;
+            }
+        },
+        () => {
+            const dfa = buildDfa();
+            const input = stringToList('//');
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const expectedOutput = [
+                '[]',
+                '[]'
+            ];
+            const expectedResult = stringifyIdentity(expectedOutput);
+            if (result !== expectedResult) {
+                throw result;
+            }
+        },
+        () => {
+            const dfa = buildDfa();
+            const input = stringToList('::');
+            const result = stringifyIdentity(toArray(_.run(dfa)(input)));
+            const expectedOutput = [
+                '[]',
+                '[]'
+            ];
+            const expectedResult = stringifyIdentity(expectedOutput);
+            if (result !== expectedResult) {
+                throw result;
+            }
+        }
+    ]
+};

package/html/module.f.d.ts

@@ -0,0 +1,13 @@
+import { type List } from '../types/list/module.f.ts';
+type Tag = string;
+type Element1 = readonly [Tag, ...Node[]];
+type Element2 = readonly [Tag, Attributes, ...Node[]];
+export type Element = Element1 | Element2;
+type Attributes = {
+    readonly [k in string]: string;
+};
+type Node = Element | string;
+export declare const element: (element: Element) => List<string>;
+export declare const html: (_: Element) => List<string>;
+export declare const htmlToString: (_: Element) => string;
+export {};

package/html/module.f.js

@@ -0,0 +1,58 @@
+import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
+import { concat as stringConcat } from "../types/string/module.f.js";
+import * as O from "../types/object/module.f.js";
+import { compose } from "../types/function/module.f.js";
+import * as utf16 from "../text/utf16/module.f.js";
+const { stringToList } = utf16;
+const { fromCharCode } = String;
+const { entries } = Object;
+/**
+ * Void Elements
+ *
+ * https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+ */
+const voidTagList = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+];
+const isVoid = tag => voidTagList.includes(tag);
+/**
+ * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
+ */
+const escapeCharCode = code => {
+    switch (code) {
+        case 0x22: return '"';
+        case 0x26: return '&';
+        case 0x3C: return '<';
+        case 0x3E: return '>';
+        default: return fromCharCode(code);
+    }
+};
+const escape = compose(stringToList)(map(escapeCharCode));
+const node = n => typeof n === 'string' ? escape(n) : element(n);
+const nodes = flatMap(node);
+const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']]);
+const attributes = compose(entries)(flatMap(attribute));
+const open = t => a => flat([[`<`, t], attributes(a), [`>`]]);
+const element3 = t => ([a, n]) => {
+    const o = flat([[`<`, t], attributes(a), [`>`]]);
+    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']]);
+};
+export const element = e => {
+    const [t, a, ...n] = e;
+    return element3(t)(a === undefined ? [{}, []] : typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]]);
+};
+export const html = compose(element)(listConcat(['<!DOCTYPE html>']));
+export const htmlToString = compose(html)(stringConcat);

package/html/test.f.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    empty: () => void;
+    empty2: () => void;
+    void: () => void;
+    some: () => void;
+    some2: () => void;
+    someVoid: () => void;
+};
+export default _default;

package/html/test.f.js

@@ -0,0 +1,42 @@
+import * as _ from "./module.f.js";
+export default {
+    empty: () => {
+        const r = _.htmlToString(['html']);
+        if (r !== '<!DOCTYPE html><html></html>') {
+            throw `empty: ${r}`;
+        }
+    },
+    empty2: () => {
+        const r = _.htmlToString(['html']);
+        if (r !== '<!DOCTYPE html><html></html>') {
+            throw r;
+        }
+    },
+    void: () => {
+        const r = _.htmlToString(['area']);
+        if (r !== '<!DOCTYPE html><area>') {
+            throw r;
+        }
+    },
+    some: () => {
+        const x = ['div', {}, '<div>&amp;</div>', ['a', { href: 'hello"' }]];
+        const s = _.htmlToString(x);
+        if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
+            throw s;
+        }
+    },
+    some2: () => {
+        const x = ['div', '<div>&amp;</div>', ['a', { href: 'hello"' }]];
+        const s = _.htmlToString(x);
+        if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
+            throw s;
+        }
+    },
+    someVoid: () => {
+        const x = ['div', ['br', { id: '5' }], '<div>&amp;</div>', ['a', { href: 'hello"' }]];
+        const s = _.htmlToString(x);
+        if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') {
+            throw s;
+        }
+    }
+};

package/issues/test.f.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    literal: () => void;
+    ownProperty: {
+        nullish: () => void;
+        bool: () => void;
+        array: () => void;
+        object: {
+            null: () => void;
+            undefined: () => void;
+        };
+        string: {
+            number: () => void;
+        };
+    };
+};
+export default _default;

package/issues/test.f.js

@@ -0,0 +1,70 @@
+const at = a => i => Object.getOwnPropertyDescriptor(a, i)?.value;
+const utf8 = (...x) => x;
+export default {
+    literal: () => {
+        const x = utf8 `17`;
+        const m = '<html>Hello</html>';
+    },
+    ownProperty: {
+        nullish: () => {
+            /* // panic
+            const v = Object.getOwnPropertyDescriptor(null, 0)
+            if (v !== undefined) {
+                throw v
+            }
+            */
+            /* // panic
+            const v = Object.getOwnPropertyDescriptor(undefined, 0)
+            if (v !== undefined) {
+                throw v
+            }
+            */
+        },
+        bool: () => {
+            const v = at(true)('x');
+            if (v !== undefined) {
+                throw v;
+            }
+        },
+        array: () => {
+            const a = ['42'];
+            {
+                const v = at(a)('0');
+                if (v !== '42') {
+                    throw v;
+                }
+            }
+            {
+                const v = at(a)(0);
+                if (v !== '42') {
+                    throw v;
+                }
+            }
+        },
+        object: {
+            null: () => {
+                const o = { null: 'hello' };
+                const v = at(o)(null);
+                if (v !== 'hello') {
+                    throw v;
+                }
+            },
+            undefined: () => {
+                const o = { undefined: 'hello' };
+                const v = at(o)(undefined);
+                if (v !== 'hello') {
+                    throw v;
+                }
+            }
+        },
+        string: {
+            number: () => {
+                const o = 'hello';
+                const v = at(o)(1);
+                if (v !== 'e') {
+                    throw v;
+                }
+            }
+        }
+    }
+};

package/js/tokenizer/module.f.d.ts

@@ -0,0 +1,86 @@
+import * as list from '../../types/list/module.f.ts';
+import * as bigfloatT from '../../types/bigfloat/module.f.ts';
+export type StringToken = {
+    readonly kind: 'string';
+    readonly value: string;
+};
+export type NumberToken = {
+    readonly kind: 'number';
+    readonly value: string;
+    readonly bf: bigfloatT.BigFloat;
+};
+export type BigIntToken = {
+    readonly kind: 'bigint';
+    readonly value: bigint;
+};
+export type ErrorToken = {
+    readonly kind: 'error';
+    message: ErrorMessage;
+};
+export type WhitespaceToken = {
+    readonly kind: 'ws';
+};
+export type NewLineToken = {
+    readonly kind: 'nl';
+};
+type TrueToken = {
+    readonly kind: 'true';
+};
+type FalseToken = {
+    readonly kind: 'false';
+};
+type NullToken = {
+    readonly kind: 'null';
+};
+type UndefinedToken = {
+    readonly kind: 'undefined';
+};
+type KeywordToken = {
+    readonly kind: 'arguments' | 'await' | 'break' | 'case' | 'catch' | 'class' | 'const' | 'continue';
+} | {
+    readonly kind: 'debugger' | 'default' | 'delete' | 'do' | 'else' | 'enum' | 'eval' | 'export';
+} | {
+    readonly kind: 'extends' | 'finally' | 'for' | 'function' | 'if' | 'implements' | 'import' | 'in';
+} | {
+    readonly kind: 'instanceof' | 'interface' | 'let' | 'new' | 'package' | 'private' | 'protected' | 'public';
+} | {
+    readonly kind: 'return' | 'static' | 'super' | 'switch' | 'this' | 'throw' | 'try' | 'typeof';
+} | {
+    readonly kind: 'var' | 'void' | 'while' | 'with' | 'yield';
+};
+export type IdToken = {
+    readonly kind: 'id';
+    readonly value: string;
+};
+type OperatorToken = {
+    readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
+} | {
+    readonly kind: '.' | '=';
+} | {
+    readonly kind: '(' | ')';
+} | {
+    readonly kind: '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=';
+} | {
+    readonly kind: '+' | '-' | '*' | '/' | '%' | '++' | '--' | '**';
+} | {
+    readonly kind: '+=' | '-=' | '*=' | '/=' | '%=' | '**=';
+} | {
+    readonly kind: '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>';
+} | {
+    readonly kind: '&=' | '|=' | '^=' | '<<=' | '>>=' | '>>>=';
+} | {
+    readonly kind: '&&' | '||' | '!' | '??';
+} | {
+    readonly kind: '&&=' | '||=' | '??=';
+} | {
+    readonly kind: '?' | '?.' | '=>';
+};
+export type CommentToken = {
+    readonly kind: '//' | '/*';
+    readonly value: string;
+};
+export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken;
+type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'eof';
+export declare const isKeywordToken: (token: JsToken) => Boolean;
+export declare const tokenize: (input: list.List<number>) => list.List<JsToken>;
+export {};