functionalscript 0.2.0 → 0.2.1

package/out/fsc/test.f.mjs

@@ -0,0 +1,19 @@
+import * as _ from './module.f.mjs';
+import * as ascii from '../text/ascii/module.f.mjs';
+const { one } = ascii;
+import * as j from '../json/module.f.mjs';
+const { stringify } = j;
+const s = stringify(i => i);
+/** @type {(v: string) => string} */
+const f = v => {
+    const n = one(v);
+    return s(_.init(n)[0]);
+};
+export default {
+    a: () => {
+        const x = f('1');
+        if (x != '["1"]') {
+            throw x;
+        }
+    }
+};

package/out/fsm/module.f.mjs

@@ -0,0 +1,80 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list;
+import * as byteSet from '../types/byte_set/module.f.mjs';
+const { toRangeMap, union: byteSetUnion, one, empty } = byteSet;
+import * as sortedSet from '../types/sorted_set/module.f.mjs';
+const { intersect, union: sortedSetUnion } = sortedSet;
+import * as rangeMap from '../types/range_map/module.f.mjs';
+const { merge } = rangeMap;
+import * as cmp from '../types/function/compare/module.f.mjs';
+const { unsafeCmp } = cmp;
+import * as operator from '../types/function/operator/module.f.mjs';
+const { strictEqual } = operator;
+import * as j from '../json/module.f.mjs';
+const { stringify } = j;
+import * as f from '../types/function/module.f.mjs';
+const { identity } = f;
+import * as utf16 from '../text/utf16/module.f.mjs';
+const { stringToList } = utf16;
+/** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
+/** @typedef {list.List<Rule>} Grammar */
+/**
+ * @typedef {{
+ *  readonly[state in string]: rangeMap.RangeMapArray<string>
+ * }} Dfa
+ */
+const stringifyIdentity = stringify(identity);
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toRange = s => {
+    const [b, e] = toArray(stringToList(s));
+    return byteSet.range([b, e]);
+};
+/** @type {operator.Fold<number, byteSet.ByteSet>} */
+const toUnionOp = i => bs => byteSetUnion(bs)(one(i));
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toUnion = s => {
+    const codePoints = stringToList(s);
+    return fold(toUnionOp)(empty)(codePoints);
+};
+/** @type {rangeMap.Operators<sortedSet.SortedSet<string>>} */
+const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) };
+/** @type {(s: string) => (set: sortedSet.SortedSet<string>) => boolean} */
+const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set));
+/** @type {(set: sortedSet.SortedSet<string>) => operator.Fold<Rule, rangeMap.RangeMap<sortedSet.SortedSet<string>>>} */
+const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
+    if (hasState(ruleIn)(set)) {
+        return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut));
+    }
+    return rm;
+};
+/** @type {operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, rangeMap.Entry<string>>} */
+const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp];
+const scanStringify = scan(stringifyOp);
+/** @type {operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, sortedSet.SortedSet<string>>} */
+const fetchOp = ([item, _]) => [item, fetchOp];
+const scanFetch = scan(fetchOp);
+/** @type {(grammar: Grammar) => operator.Fold<sortedSet.SortedSet<string>, Dfa>} */
+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);
+};
+/** @type {string[]} */
+const emptyState = [];
+const emptyStateStringify = stringifyIdentity(emptyState);
+const initialState = [''];
+const initialStateStringify = stringifyIdentity(initialState);
+/** @type {(grammar: Grammar) => Dfa} */
+export const dfa = grammar => addEntry(grammar)(initialState)({});
+const get = rangeMap.get(emptyStateStringify);
+/** @type {(dfa: Dfa) => operator.Fold<number, string>} */
+const runOp = dfa => input => s => get(input)(dfa[s]);
+/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
+export const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input);

package/out/fsm/test.f.mjs

@@ -0,0 +1,138 @@
+import * as _ from './module.f.mjs';
+import * as byteSet from '../types/byte_set/module.f.mjs';
+import * as o from '../types/object/module.f.mjs';
+const { sort, fromEntries } = o;
+import * as json from '../json/module.f.mjs';
+import * as f from '../types/function/module.f.mjs';
+const { identity } = f;
+import * as list from '../types/list/module.f.mjs';
+const { toArray } = list;
+import * as utf16 from '../text/utf16/module.f.mjs';
+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('.');
+    /** @type {_.Grammar} */
+    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/out/html/module.f.mjs

@@ -0,0 +1,94 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { map, flatMap, flat, concat: listConcat } = list;
+import * as s from '../types/string/module.f.mjs';
+const { concat: stringConcat } = s;
+import * as O from '../types/object/module.f.mjs';
+import * as f from '../types/function/module.f.mjs';
+const { compose } = f;
+import * as utf16 from '../text/utf16/module.f.mjs';
+const { stringToList } = utf16;
+const { fromCharCode } = String;
+const { entries } = Object;
+/** @typedef {string} Tag */
+// 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',
+];
+/** @type {(tag: string) => boolean} */
+const isVoid = tag => voidTagList.includes(tag);
+/** @typedef {readonly[Tag]} Element1*/
+/** @typedef {readonly[Tag, Attributes]} Element2A */
+/** @typedef {readonly[Tag, readonly Node[]]} Element2N */
+/** @typedef {readonly[Tag, Attributes, Nodes]} Element3*/
+/** @typedef {Element1 | Element2A | Element2N | Element3} Element */
+/**
+ * @typedef {{
+ *  readonly[k in string]: string
+ * }} Attributes
+ */
+/** @typedef {list.List<Node>} Nodes */
+/** @typedef {Element | string} Node */
+/**
+ * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
+ *
+ * @type {(code: number) => string}
+ */
+const escapeCharCode = code => {
+    switch (code) {
+        case 0x22: return '&quot;';
+        case 0x26: return '&amp;';
+        case 0x3C: return '&lt;';
+        case 0x3E: return '&gt;';
+        default: return fromCharCode(code);
+    }
+};
+const escape = compose(stringToList)(map(escapeCharCode));
+/** @type {(n: Node) => list.List<string>} */
+const node = n => typeof n === 'string' ? escape(n) : element(n);
+const nodes = flatMap(node);
+/** @type {(a: O.Entry<string>) => list.List<string>} */
+const attribute = ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']]);
+/** @type {(a: Attributes) => list.List<string>} */
+const attributes = compose(entries)(flatMap(attribute));
+const open = (/** @type {Element2A} */ [tag, a]) => flat([[`<`, tag], attributes(a), [`>`]]);
+const close = (/** @type {string}*/ tag) => ['</', tag, '>'];
+/** @type {(_: Element3) => list.List<string>} */
+const element3 = ([tag, a, ns]) => flat([open([tag, a]), nodes(ns), close(tag)]);
+/** @type {(_: Element2A) => list.List<string>} */
+const element2a = e => {
+    const [tag] = e;
+    return flat([open(e), isVoid(tag) ? [] : close(tag)]);
+};
+/** @type {(element: Element) => list.List<string>} */
+export const element = e => {
+    switch (e.length) {
+        case 1: {
+            return element2a([e[0], {}]);
+        }
+        case 2: {
+            const [tag, a] = e;
+            return a instanceof Array ?
+                element3([tag, {}, a]) :
+                element2a([tag, a]);
+        }
+        default: {
+            return element3(e);
+        }
+    }
+};
+export const html = compose(element)(listConcat(['<!DOCTYPE html>']));
+export const htmlToString = compose(html)(stringConcat);

package/out/html/test.f.mjs

@@ -0,0 +1,45 @@
+import * as _ from './module.f.mjs';
+export default {
+    empty: () => {
+        const r = _.htmlToString(['html', []]);
+        if (r !== '<!DOCTYPE html><html></html>') {
+            throw 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: () => {
+        /** @type {_.Element} */
+        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: () => {
+        /** @type {_.Element} */
+        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: () => {
+        /** @type {_.Element} */
+        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/out/issues/test.f.mjs

@@ -0,0 +1,66 @@
+/** @type {(a: unknown) => (i: any) =>unknown} */
+const at = a => i => Object.getOwnPropertyDescriptor(a, i)?.value;
+export default {
+    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;
+                }
+            }
+        }
+    }
+};