functionalscript 0.2.6 → 0.3.0

package/out/fsc/module.f.mjs

@@ -1,105 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as operator from '../types/function/operator/module.f.mjs';
-import * as rangeMap from '../types/range_map/module.f.mjs';
-const { merge: rangeMapMerge, fromRange, get } = rangeMap;
-import * as list from '../types/list/module.f.mjs';
-const { reduce: listReduce } = list;
-import * as ascii from '../text/ascii/module.f.mjs';
-const { range: asciiRange } = ascii;
-const { fromCharCode } = String;
-import * as f from '../types/function/module.f.mjs';
-const { fn } = f;
-import * as _range from '../types/range/module.f.mjs';
-const { one } = _range;
-const { toArray, map } = list;
-/** @typedef {readonly[readonly string[], ToResult]} Result */
-/** @typedef {(codePoint: number) => Result} ToResult */
-/**
- * @template T
- * @typedef {(state: T) => ToResult} CreateToResult
- */
-/**
- * @template T
- * @typedef {rangeMap.RangeMapArray<CreateToResult<T>>} State
- */
-/** @type {ToResult} */
-const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol];
-/** @type {<T>(state: T) => ToResult} */
-const def = () => unexpectedSymbol;
-/** @type {<T>(a: CreateToResult<T>) => (b: CreateToResult<T>) => CreateToResult<T>} */
-const union = a => b => {
-    if (a === def || a === b) {
-        return b;
-    }
-    if (b === def) {
-        return a;
-    }
-    throw [a, b];
-};
-/** @type {readonly never[]} */
-const empty = [];
-/** @type {<T>(a: list.List<State<T>>) => State<T>} */
-const reduce = a => {
-    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
-    /** @type {rangeMap.RangeMerge<CreateToResult<T>>} */
-    const merge = rangeMapMerge({
-        union,
-        equal: operator.strictEqual,
-    });
-    return toArray(listReduce(merge)(empty)(a));
-};
-const codePointRange = fromRange(def);
-const range = fn(asciiRange).then(codePointRange).result;
-/** @type {(l: readonly string[]) => <T>(f: CreateToResult<T>) => State<T>} */
-const rangeSet = l => f => {
-    /** @typedef {typeof f extends CreateToResult<infer T> ? T : never} T */
-    /** @type {(a: _range.Range) => (f: CreateToResult<T>) => State<T>} */
-    const codePointRange = fromRange(def);
-    /** @type {(r: string) => State<T>} */
-    const g = r => codePointRange(asciiRange(r))(f);
-    return reduce(map(g)(l));
-};
-/** @type {<T>(a: list.List<State<T>>) => CreateToResult<T>} */
-const create = a => {
-    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
-    const i = reduce(a);
-    /** @type {(v: number) => (i: State<T>) => (v: T) => ToResult} */
-    const x = get(def);
-    return v => c => x(c)(i)(v)(c);
-};
-export const terminal = -1;
-/** @type {() => ToResult} */
-const toInit = () => () => [[], init];
-export const init = create([
-    codePointRange(one(terminal))(toInit),
-    rangeSet(['\t', ' ', '\n', '\r'])(toInit),
-    range('!')(() => () => [['!'], unexpectedSymbol]),
-    range('"')(() => () => [['"'], unexpectedSymbol]),
-    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unexpectedSymbol]),
-    range('%')(() => () => [['%'], unexpectedSymbol]),
-    range('&')(() => () => [['&'], unexpectedSymbol]),
-    range("'")(() => () => [["'"], unexpectedSymbol]),
-    range('(')(() => () => [['('], unexpectedSymbol]),
-    range(')')(() => () => [[')'], unexpectedSymbol]),
-    range('*')(() => () => [['*'], unexpectedSymbol]),
-    range('+')(() => () => [['+'], unexpectedSymbol]),
-    range(',')(() => () => [[','], unexpectedSymbol]),
-    range('-')(() => () => [['-'], unexpectedSymbol]),
-    range('.')(() => () => [['.'], unexpectedSymbol]),
-    range('/')(() => () => [['/'], unexpectedSymbol]),
-    range('09')(() => a => [[fromCharCode(a)], unexpectedSymbol]),
-    range(':')(() => () => [[':'], unexpectedSymbol]),
-    range(';')(() => () => [[';'], unexpectedSymbol]),
-    range('<')(() => () => [['<'], unexpectedSymbol]),
-    range('=')(() => () => [['='], unexpectedSymbol]),
-    range('>')(() => () => [['>'], unexpectedSymbol]),
-    range('?')(() => () => [['?'], unexpectedSymbol]),
-    range('[')(() => () => [['['], unexpectedSymbol]),
-    range(']')(() => () => [[']'], unexpectedSymbol]),
-    range('^')(() => () => [['^'], unexpectedSymbol]),
-    range('`')(() => () => [['`'], unexpectedSymbol]),
-    range('{')(() => () => [['{'], unexpectedSymbol]),
-    range('|')(() => () => [['|'], unexpectedSymbol]),
-    range('}')(() => () => [['}'], unexpectedSymbol]),
-    range('~')(() => () => [['~'], unexpectedSymbol]),
-])(undefined);

package/out/fsc/test.f.d.mts

@@ -1,4 +0,0 @@
-declare namespace _default {
-    function a(): void;
-}
-export default _default;

package/out/fsc/test.f.mjs

@@ -1,19 +0,0 @@
-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.d.mts

@@ -1,14 +0,0 @@
-/** @type {(s: string) => byteSet.ByteSet} */
-export const toRange: (s: string) => byteSet.ByteSet;
-/** @type {(s: string) => byteSet.ByteSet} */
-export const toUnion: (s: string) => byteSet.ByteSet;
-/** @type {(grammar: Grammar) => Dfa} */
-export const dfa: (grammar: Grammar) => Dfa;
-/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
-export const run: (dfa: Dfa) => (input: list.List<number>) => list.List<string>;
-export type Rule = readonly [string, byteSet.ByteSet, string];
-export type Grammar = list.List<Rule>;
-export type Dfa = { readonly [state in string]: rangeMap.RangeMapArray<string>; };
-import * as byteSet from '../types/byte_set/module.f.mjs';
-import * as list from '../types/list/module.f.mjs';
-import * as rangeMap from '../types/range_map/module.f.mjs';

package/out/fsm/module.f.mjs

@@ -1,80 +0,0 @@
-// @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.d.mts

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

package/out/fsm/test.f.mjs

@@ -1,138 +0,0 @@
-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.d.mts

@@ -1,17 +0,0 @@
-/** @type {(element: Element) => list.List<string>} */
-export const element: (element: Element) => list.List<string>;
-export const html: f.Func<Element, list.List<string>>;
-export const htmlToString: f.Func<Element, string>;
-export type Tag = string;
-export type VoidTagList = typeof voidTagList;
-export type VoidTag = keyof readonly ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
-export type Element1 = readonly [Tag, ...Node[]];
-export type Element2 = readonly [Tag, Attributes, ...Node[]];
-export type Element = Element1 | Element2;
-export type Attributes = { readonly [k in string]: string; };
-export type Node = Element | string;
-import * as list from '../types/list/module.f.mjs';
-import * as f from '../types/function/module.f.mjs';
-/** @typedef {string} Tag */
-declare const voidTagList: readonly ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"];
-export {};

package/out/html/module.f.mjs

@@ -1,80 +0,0 @@
-// @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 = /** @type {const} */ ([
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-]);
-/** @typedef {typeof voidTagList} VoidTagList */
-/** @typedef {keyof voidTagList} VoidTag */
-/** @type {(tag: string) => boolean} */
-const isVoid = tag => voidTagList.includes(/** @type {any} */ (tag));
-/** @typedef {readonly[Tag, ...Node[]]} Element1*/
-/** @typedef {readonly[Tag, Attributes, ...Node[]]} Element2 */
-/** @typedef {Element1 | Element2 } 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));
-/** @type {(t: string) => (a: Attributes) => list.List<string>} */
-const open = t => a => flat([[`<`, t], attributes(a), [`>`]]);
-/** @type {(t: string) => (an: readonly[Attributes, readonly Node[]]) => list.List<string>} */
-const element3 = t => ([a, n]) => {
-    const o = flat([[`<`, t], attributes(a), [`>`]]);
-    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']]);
-};
-/** @type {(element: Element) => list.List<string>} */
-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/out/html/test.f.d.mts

@@ -1,10 +0,0 @@
-declare namespace _default {
-    export function empty(): void;
-    export function empty2(): void;
-    export function _void(): void;
-    export { _void as void };
-    export function some(): void;
-    export function some2(): void;
-    export function someVoid(): void;
-}
-export default _default;

package/out/html/test.f.mjs

@@ -1,45 +0,0 @@
-import * as _ from './module.f.mjs';
-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: () => {
-        /** @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.d.mts

@@ -1,16 +0,0 @@
-declare namespace _default {
-    namespace ownProperty {
-        function nullish(): void;
-        function bool(): void;
-        function array(): void;
-        namespace object {
-            export function _null(): void;
-            export { _null as null };
-            export function undefined(): void;
-        }
-        namespace string {
-            function number(): void;
-        }
-    }
-}
-export default _default;

package/out/issues/test.f.mjs

@@ -1,66 +0,0 @@
-/** @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;
-                }
-            }
-        }
-    }
-};