functionalscript 0.1.609 → 0.2.1

package/out/types/sorted_set/test.f.mjs

@@ -0,0 +1,80 @@
+import * as _ from './module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as json from '../../json/module.f.mjs';
+import * as object from '../object/module.f.mjs';
+const { sort } = object;
+import * as list from '../list/module.f.mjs';
+const { toArray, countdown, length } = list;
+import * as Map from '../map/module.f.mjs';
+import * as f from '../function/module.f.mjs';
+const { flip } = f;
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a);
+/** @type {<T>(a: T) => (b: T) => Map.Sign} */
+const reverseCmp = flip(unsafeCmp);
+export default {
+    union: [
+        () => {
+            const result = stringify(toArray(_.union(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            if (result !== '[1,2,3,4,5]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(_.union(unsafeCmp)([1, 2, 3])([])));
+            if (result !== '[1,2,3]') {
+                throw result;
+            }
+        },
+        () => {
+            const n = 10_000;
+            const sortedSet = toArray(countdown(n));
+            const result = _.union(reverseCmp)(sortedSet)(sortedSet);
+            const len = length(result);
+            if (len != n) {
+                throw result;
+            }
+        }
+    ],
+    intersect: [
+        () => {
+            const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            if (result !== '[3]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(_.intersect(unsafeCmp)([1, 2, 3])([])));
+            if (result !== '[]') {
+                throw result;
+            }
+        }
+    ],
+    has: [
+        () => {
+            const result = _.has(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (!result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.has(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (!result) {
+                throw result;
+            }
+        }
+    ]
+};

package/out/types/string/module.f.d.mts

@@ -0,0 +1,9 @@
+export const join: f.Func<string, (input: list.List<string>) => string>;
+export const concat: (input: list.List<string>) => string;
+/** @type {(n: string) => (v: number) => string} */
+export const repeat: (n: string) => (v: number) => string;
+/** @type {(a: string) => (b: string) => compare.Sign} */
+export const cmp: (a: string) => (b: string) => compare.Sign;
+import * as list from '../list/module.f.mjs';
+import * as f from '../function/module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';

package/out/types/string/module.f.mjs

@@ -0,0 +1,17 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../list/module.f.mjs';
+const { reduce: listReduce, repeat: listRepeat } = list;
+import * as f from '../function/module.f.mjs';
+const { compose } = f;
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as op from '../function/operator/module.f.mjs';
+const { join: joinOp, concat: concatOp } = op;
+/** @type {(o: op.Reduce<string>) => (input: list.List<string>) => string} */
+const reduce = o => listReduce(o)('');
+export const join = compose(joinOp)(reduce);
+export const concat = reduce(concatOp);
+/** @type {(n: string) => (v: number) => string} */
+export const repeat = v => compose(listRepeat(v))(concat);
+/** @type {(a: string) => (b: string) => compare.Sign} */
+export const cmp = unsafeCmp;

package/out/types/string/test.f.mjs

@@ -0,0 +1,58 @@
+import * as _ from './module.f.mjs';
+const { join, concat, repeat, cmp } = _;
+import * as list from '../list/module.f.mjs';
+const { repeat: repeatList } = list;
+export default {
+    join: {
+        0: () => {
+            const result = join('/')([]);
+            if (result !== '') {
+                throw result;
+            }
+        },
+        1: () => {
+            const result = join('/')(['']);
+            if (result !== '') {
+                throw result;
+            }
+        },
+        3: () => {
+            const result = join(' ')(['hello', 'world', '!']);
+            if (result !== 'hello world !') {
+                throw result;
+            }
+        }
+    },
+    concat: () => {
+        const result = concat(['hello', 'world']);
+        if (result !== 'helloworld') {
+            throw result;
+        }
+    },
+    repeatList: {
+        0: () => {
+            const s = join('.')(repeatList('x')(0));
+            if (s != '') {
+                throw s;
+            }
+        },
+        5: () => {
+            const s = join('.')(repeatList('x')(5));
+            if (s != 'x.x.x.x.x') {
+                throw s;
+            }
+        }
+    },
+    repeat: () => {
+        const s = repeat('x')(5);
+        if (s != 'xxxxx') {
+            throw s;
+        }
+    },
+    cmp: () => {
+        const result = cmp('3')('4');
+        if (result !== -1) {
+            throw result;
+        }
+    }
+};

package/out/types/string_set/module.f.d.mts

@@ -0,0 +1,13 @@
+export const values: <T>(tree: BtreeTypes.Tree<T>) => list.List<T>;
+export const empty: null;
+/** @typedef {BtreeTypes.Tree<string>} StringSet */
+/** @type {(value: string) => (set: StringSet) => boolean} */
+export const contains: (value: string) => (set: StringSet) => boolean;
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+export const set: (value: string) => (s: StringSet) => StringSet;
+export const fromValues: (input: list.List<string>) => StringSet;
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+export const remove: (value: string) => (s: StringSet) => StringSet;
+export type StringSet = BtreeTypes.Tree<string>;
+import * as BtreeTypes from '../btree/types/module.f.mjs';
+import * as list from '../list/module.f.mjs';

package/out/types/string_set/module.f.mjs

@@ -0,0 +1,29 @@
+// @ts-self-types="./module.f.d.mts"
+import * as BtreeTypes from '../btree/types/module.f.mjs';
+import * as btree from '../btree/module.f.mjs';
+import * as btf from '../btree/find/module.f.mjs';
+const { find, isFound } = btf;
+import * as btr from '../btree/remove/module.f.mjs';
+const { remove: btreeRemove } = btr;
+import * as bts from '../btree/set/module.f.mjs';
+const { set: btreeSet } = bts;
+export const { 
+/** @type {(s: StringSet) => list.List<string>} */
+values, empty, } = btree;
+import * as string from "../string/module.f.mjs";
+const { cmp } = string;
+import * as list from '../list/module.f.mjs';
+const { fold } = list;
+import * as f from '../function/module.f.mjs';
+const { compose } = f;
+/** @typedef {BtreeTypes.Tree<string>} StringSet */
+/** @type {(value: string) => (set: StringSet) => boolean} */
+export const contains = value => {
+    const f = find(cmp(value));
+    return s => s !== null && isFound(f(s).first);
+};
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+export const set = value => btreeSet(cmp(value))(() => value);
+export const fromValues = fold(set)(null);
+/** @type {(value: string) => (s: StringSet) => StringSet} */
+export const remove = compose(cmp)(btreeRemove);

package/out/types/string_set/test.f.mjs

@@ -0,0 +1,65 @@
+import * as _ from './module.f.mjs';
+export default {
+    contains: () => {
+        const r = _.set('hello')(null);
+        if (!_.contains('hello')(r)) {
+            throw r;
+        }
+        if (_.contains('hello1')(r)) {
+            throw r;
+        }
+    },
+    remove: () => {
+        let r = _.set('hello')(null);
+        r = _.set('world')(r);
+        r = _.set('HELLO')(r);
+        r = _.set('WORLD!')(r);
+        if (!_.contains('hello')(r)) {
+            throw r;
+        }
+        if (_.contains('hello1')(r)) {
+            throw r;
+        }
+        if (!_.contains('HELLO')(r)) {
+            throw r;
+        }
+        if (_.contains('WORLD')(r)) {
+            throw r;
+        }
+        if (!_.contains('world')(r)) {
+            throw r;
+        }
+        if (_.contains('world!')(r)) {
+            throw r;
+        }
+        if (!_.contains('WORLD!')(r)) {
+            throw r;
+        }
+        //
+        r = _.remove('hello')(r);
+        if (_.contains('hello')(r)) {
+            throw r;
+        }
+        if (!_.contains('world')(r)) {
+            throw r;
+        }
+        r = _.remove('world')(r);
+        if (_.contains('world')(r)) {
+            throw r;
+        }
+        if (!_.contains('HELLO')(r)) {
+            throw r;
+        }
+        r = _.remove('HELLO')(r);
+        if (_.contains('HELLO')(r)) {
+            throw r;
+        }
+        if (!_.contains('WORLD!')(r)) {
+            throw r;
+        }
+        r = _.remove('WORLD!')(r);
+        if (r !== null) {
+            throw r;
+        }
+    }
+};

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "functionalscript",
-  "version": "0.1.609",
+  "version": "0.2.1",
   "type": "module",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
-    "tscp": "tsc --declaration --emitDeclarationOnly --noEmit false",
+    "tscp": "rm -rf out/ && tsc --NoEmit false",
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "index": "node ./dev/index.mjs",
     "version": "node ./nodejs/version/main.mjs",
     "test-only": "node --trace-uncaught ./dev/test.mjs",
-    "comtest": "node ./com/test/build.mjs"
+    "comtest": "node ./com/test/build.mjs",
+    "doc": "rm -rf docs/ && npm run tscp && deno doc --html out/**/module.f.mjs"
   },
   "repository": {
     "type": "git",
@@ -32,7 +33,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.10.1",
+    "@types/node": "^22.10.2",
     "typescript": "^5.7.2"
   }
 }

package/prime_field/module.f.mjs

@@ -1,6 +1,6 @@
 // @ts-self-types="./module.f.d.mts"
 import * as Operator from '../types/function/operator/module.f.mjs'
-import bi from '../types/bigint/module.f.mjs'
+import * as bi from '../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 
 /** @typedef {Operator.Reduce<bigint>} Reduce */
@@ -26,7 +26,7 @@ const { scalar_mul } = bi
  */
 
 /** @type {(p: bigint) => PrimeField} */
-const prime_field = p => {
+export const prime_field = p => {
     /** @type {Reduce} */
     const sub = a => b => {
         const r = a - b
@@ -77,15 +77,12 @@ const prime_field = p => {
     }
 }
 
-export default {
-    prime_field,
-    /** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
-    sqrt: ({p, mul, pow }) => {
-        if ((p & 3n) !== 3n) { throw 'sqrt' }
-        const sqrt_k = (p + 1n) >> 2n
-        return a => {
-            const result = pow(a)(sqrt_k)
-            return mul(result)(result) === a ? result : null
-        }
+/** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
+export const sqrt = ({p, mul, pow }) => {
+    if ((p & 3n) !== 3n) { throw 'sqrt' }
+    const sqrt_k = (p + 1n) >> 2n
+    return a => {
+        const result = pow(a)(sqrt_k)
+        return mul(result)(result) === a ? result : null
     }
 }

package/prime_field/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { prime_field, sqrt } = _
 
 export default {

package/secp/module.f.mjs

@@ -1,7 +1,7 @@
 // @ts-self-types="./module.f.d.mts"
 import * as Operator from '../types/function/operator/module.f.mjs'
-import pf, * as Pf from '../prime_field/module.f.mjs'
-import bi from '../types/bigint/module.f.mjs'
+import * as pf from '../prime_field/module.f.mjs'
+import * as bi from '../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 const { prime_field, sqrt } = pf
 
@@ -20,8 +20,8 @@ const { prime_field, sqrt } = pf
 
 /**
  * @typedef {{
- *  readonly pf: Pf.PrimeField
- *  readonly nf: Pf.PrimeField
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
@@ -31,7 +31,7 @@ const { prime_field, sqrt } = pf
  */
 
 /** @type {(i: Init) => Curve} */
-const curve = ({ p, a: [a0, a1], n }) => {
+export const curve = ({ p, a: [a0, a1], n }) => {
     const pf = prime_field(p)
     const { pow2, pow3, sub, add, mul, neg, div } = pf
     const mul3 = mul(3n)
@@ -85,38 +85,37 @@ const curve = ({ p, a: [a0, a1], n }) => {
     }
 }
 
-export default {
-    curve,
-    /** @type {(a: Point) => (b: Point) => boolean} */
-    eq: a => b => {
-        if (a === null || b === null) {
-            return a === b
-        }
-        const [ax, ay] = a
-        const [bx, by] = b
-        return ax === bx && ay === by
-    },
-    /** @type {Init} */
-    secp256k1: {
-        p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
-        a: [7n, 0n],
-        g: [
-            0x79be667e_f9dcbbac_55a06295_ce870b07_029bfcdb_2dce28d9_59f2815b_16f81798n,
-            0x483ada77_26a3c465_5da4fbfc_0e1108a8_fd17b448_a6855419_9c47d08f_fb10d4b8n
-        ],
-        n: 0xffffffff_ffffffff_ffffffff_fffffffe_baaedce6_af48a03b_bfd25e8c_d0364141n,
-    },
-    /** @type {Init} */
-    secp192r1: {
-        p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
-        a: [
-            0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
-            0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_fffffffcn
-        ],
-        g: [
-            0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012n,
-            0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811n
-        ],
-        n: 0xffffffff_ffffffff_ffffffff_99def836_146bc9b1_b4d22831n,
-    },
+/** @type {(a: Point) => (b: Point) => boolean} */
+export const eq = a => b => {
+    if (a === null || b === null) {
+        return a === b
+    }
+    const [ax, ay] = a
+    const [bx, by] = b
+    return ax === bx && ay === by
+}
+
+/** @type {Init} */
+export const secp256k1 = {
+    p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
+    a: [7n, 0n],
+    g: [
+        0x79be667e_f9dcbbac_55a06295_ce870b07_029bfcdb_2dce28d9_59f2815b_16f81798n,
+        0x483ada77_26a3c465_5da4fbfc_0e1108a8_fd17b448_a6855419_9c47d08f_fb10d4b8n
+    ],
+    n: 0xffffffff_ffffffff_ffffffff_fffffffe_baaedce6_af48a03b_bfd25e8c_d0364141n,
+}
+
+/** @type {Init} */
+export const secp192r1 = {
+    p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
+    a: [
+        0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
+        0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_fffffffcn
+    ],
+    g: [
+        0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012n,
+        0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811n
+    ],
+    n: 0xffffffff_ffffffff_ffffffff_99def836_146bc9b1_b4d22831n,
 }

package/secp/test.f.mjs

@@ -1,13 +1,13 @@
-import _, * as T from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { curve, secp256k1, secp192r1, eq } = _
 
 export default {
     test: () => {
-        /** @type {(c: T.Init) => void} */
+        /** @type {(c: _.Init) => void} */
         const test_curve = c => {
             const { g } = c
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
-            /** @type {(p: T.Point) => void} */
+            /** @type {(p: _.Point) => void} */
             const point_check = p => {
                 if (p === null) { throw 'null' }
                 const [x, y] = p
@@ -17,7 +17,7 @@ export default {
             }
             point_check(g)
             point_check(neg(g))
-            /** @type {(p: T.Point) => void} */
+            /** @type {(p: _.Point) => void} */
             const test_mul = p => {
                 if (mul(p)(0n) !== null) { throw 'O' }
                 if (mul(p)(1n) !== p) { throw 'p' }

package/sha2/module.f.mjs

@@ -19,7 +19,7 @@ const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos)
 const mod = a => b => (a % b + b) % b
 
 /** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-const padding = input => bitsCount => {
+export const padding = input => bitsCount => {
     const appendBlockIndex = (bitsCount / 32) | 0
     const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32
     /** @type {(i: number) => number} */
@@ -183,27 +183,14 @@ const compute = init => input => bitsCount => {
 const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
 
 /** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha256 = compute(init256)
+export const computeSha256 = compute(init256)
 
 /** @type {Hash8} */
 const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
 
 /** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha224 = compute(init224)
-
-const compress256 = compress(init256)
-
-const compress224 = compress(init224)
-
-export default {
-    /** @readonly */
-    padding,
-    /** @readonly */
-    computeSha256,
-    /** @readonly */
-    computeSha224,
-     /** @readonly */
-    compress256,
-    /** @readonly */
-    compress224
-}
+export const computeSha224 = compute(init224)
+
+export const compress256 = compress(init256)
+
+export const compress224 = compress(init224)

package/sha2/test.f.mjs

@@ -1,6 +1,6 @@
-import _ from './module.f.mjs'
-import json, * as jsonT from '../json/module.f.mjs'
-import o from '../types/object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as json from '../json/module.f.mjs'
+import * as o from '../types/object/module.f.mjs'
 const { sort } = o
 
 /** @type {(a: number) => number} */
@@ -9,7 +9,7 @@ const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000
 /** @type {(a: number) => string} */
 const toHexString = x => toU32(x).toString(16).padStart(8, '0')
 
-/** @type {(a: readonly jsonT.Unknown[]) => string} */
+/** @type {(a: readonly json.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
 // {

package/text/ascii/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import _range, * as Range from '../../types/range/module.f.mjs'
+import * as _range from '../../types/range/module.f.mjs'
 
 /** @type {(s: string) => (i: number) => number} */
 const at = s => i => {
@@ -9,22 +9,17 @@ const at = s => i => {
 }
 
 /** @type {(s: string) => number} */
-const one = s => at(s)(0)
+export const one = s => at(s)(0)
 
-/** @type {(s: string) => Range.Range} */
-const range = s => {
+/** @type {(s: string) => _range.Range} */
+export const range = s => {
     const f = at(s)
     const f0 = f(0)
     if (s.length === 1) { return [f0, f0] }
     return [f0, f(1)]
 }
 
-export default {
-    /** @readonly */
-    one,
-    /** @readonly */
-    range,
-
+export const ascii = {
     // 0x00..
 
     /** @readonly 0x08 */

package/text/ascii/test.f.mjs

@@ -1,7 +1,7 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { range } = _
-import json from '../../json/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
 
 const stringify = json.stringify(sort)

package/text/module.f.mjs

@@ -1,21 +1,21 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.mjs'
 const { flatMap } = list
 
 /** @typedef {ItemThunk|ItemArray} Block */
 
 /** @typedef {readonly Item[]} ItemArray */
 
-/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {() => list.List<Item>} ItemThunk */
 
 /** @typedef {string|ItemArray|ItemThunk} Item */
 
-/** @type {(indent: string) => (text: Block) => List.List<string>} */
-const flat = indent => {
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat = indent => {
 
-    /** @type {(prefix: string) => (text: Block) => List.List<string>} */
+    /** @type {(prefix: string) => (text: Block) => list.List<string>} */
     const f = prefix => {
-        /** @type {(item: Item) => List.List<string>} */
+        /** @type {(item: Item) => list.List<string>} */
         const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
         return flatMap(g)
     }
@@ -24,11 +24,4 @@ const flat = indent => {
 }
 
 /** @type {(type: string) => (name: string) => (body: Block) => Block} */
-const curly = type => name => body => [`${type} ${name}`, '{', body, '}']
-
-export default {
-    /** @readonly */
-    flat,
-    /** @readonly */
-    curly,
-}
+export const curly = type => name => body => [`${type} ${name}`, '{', body, '}']

package/text/sgr/module.f.mjs

@@ -5,11 +5,9 @@
  *
  * @type {(c: number) => string}
  */
-const sgr = c => `\x1b[${c.toString()}m`
+export const sgr = c => `\x1b[${c.toString()}m`
 
-export default {
-    /** @readonly */
-    sgr,
+export const codes = {
     /** @readonly */
     reset: sgr(0),
     /** @readonly */

package/text/test.f.mjs

@@ -1,9 +1,9 @@
-import _, * as T from './module.f.mjs'
-import string from '../types/string/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as string from '../types/string/module.f.mjs'
 const { join } = string
 
 export default () => {
-    /** @type {T.Block} */
+    /** @type {_.Block} */
     const text = [
         'a',
         'b',