functionalscript 0.8.2 → 0.9.2

package/types/bit_vec/module.f.d.ts

@@ -185,3 +185,4 @@ export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => V
  * Repeats a vector to create a padded block of the desired length.
  */
 export declare const repeat: Fold<bigint, Vec>;
+export declare const isVec: <T>(v: Vec | T) => v is Vec;

package/types/bit_vec/module.f.js

@@ -202,3 +202,4 @@ export const listToVec = ({ concat }) => fold(flip(concat))(empty);
  * Repeats a vector to create a padded block of the desired length.
  */
 export const repeat = mRepeat({ identity: empty, operation: lsb.concat });
+export const isVec = (v) => typeof v === 'bigint';

package/types/btree/find/module.f.d.ts

@@ -2,13 +2,13 @@ import type { Leaf1, Leaf2, Branch3, Branch5, TNode } from '../types/module.f.ts
 import type { List } from '../../list/module.f.ts';
 import { type Compare } from '../../function/compare/module.f.ts';
 import type { Index3, Index5 } from "../../array/module.f.ts";
-type FirstLeaf1<T> = readonly [Index3, Leaf1<T>];
-type FirstBranch3<T> = readonly [1, Branch3<T>];
-type FirstLeaf2<T> = readonly [Index5, Leaf2<T>];
-type FirstBranch5<T> = readonly [1 | 3, Branch5<T>];
-type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
-type PathItem3<T> = readonly [0 | 2, Branch3<T>];
-type PathItem5<T> = readonly [0 | 2 | 4, Branch5<T>];
+export type FirstLeaf1<T> = readonly [Index3, Leaf1<T>];
+export type FirstBranch3<T> = readonly [1, Branch3<T>];
+export type FirstLeaf2<T> = readonly [Index5, Leaf2<T>];
+export type FirstBranch5<T> = readonly [1 | 3, Branch5<T>];
+export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
+export type PathItem3<T> = readonly [0 | 2, Branch3<T>];
+export type PathItem5<T> = readonly [0 | 2 | 4, Branch5<T>];
 export type PathItem<T> = PathItem3<T> | PathItem5<T>;
 export type Path<T> = List<PathItem<T>>;
 export type Result<T> = {
@@ -18,4 +18,3 @@ export type Result<T> = {
 export declare const find: <T>(c: Compare<T>) => (node: TNode<T>) => Result<T>;
 export declare const isFound: <T>([i]: First<T>) => boolean;
 export declare const value: <T>([i, r]: First<T>) => T | null;
-export {};

package/types/btree/set/module.f.js

@@ -30,7 +30,20 @@ const reduceOp = ([i, x]) => a => {
 };
 const reduceBranch = fold(reduceOp);
 const nodeSet = (c) => (g) => (node) => {
+    // export type Result<T> = {
+    //    readonly first: First<T>,
+    //    readonly tail: Path<T>
+    //}
     const { first, tail } = find(c)(node);
+    // export type Index2 = 0 | 1
+    // export type Index3 = Index2 | 2 // 0 | 1 | 2
+    // export type Index4 = Index3 | 3 // 0 | 1 | 2 | 3
+    // export type Index5 = Index4 | 4 // 0 | 1 | 2 | 3 | 4
+    // type FirstLeaf1<T> = readonly[Index3, Leaf1<T>]
+    // type FirstBranch3<T> = readonly[1, Branch3<T>]
+    // type FirstLeaf2<T> = readonly[Index5, Leaf2<T>]
+    // type FirstBranch5<T> = readonly[1|3, Branch5<T>]
+    // export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>
     const [i, x] = first;
     const f = () => {
         switch (i) {
@@ -66,6 +79,8 @@ const nodeSet = (c) => (g) => (node) => {
             case 2: {
                 // insert
                 const value = g(null);
+                // TODO: remove after TSGO fix the regression.
+                const _xl = x.length;
                 switch (x.length) {
                     case 1: {
                         return [[x[0], value]];
@@ -74,9 +89,13 @@ const nodeSet = (c) => (g) => (node) => {
                         return [[x[0]], value, [x[1]]];
                     }
                 }
+                // TODO: remove after TSGO fix the regression.
+                throw 'unreachable';
             }
             case 3: {
                 // replace
+                // TODO: remove after TSGO fix the regression.
+                const _xl = x.length;
                 switch (x.length) {
                     case 2: {
                         return [[x[0], g(x[1])]];
@@ -85,6 +104,8 @@ const nodeSet = (c) => (g) => (node) => {
                         return [[x[0], x[1], x[2], g(x[3]), x[4]]];
                     }
                 }
+                // TODO: remove after TSGO fix the regression.
+                throw 'unreachable';
             }
             case 4: {
                 // insert

package/types/cbase32/module.f.d.ts

@@ -0,0 +1,6 @@
+import { type Vec } from "../bit_vec/module.f.ts";
+import type { Nullable } from "../nullable/module.f.ts";
+export declare const vec5xToCBase32: (v: Vec) => string;
+export declare const vecToCBase32: (v: Vec) => string;
+export declare const cBase32ToVec5x: (s: string) => Nullable<Vec>;
+export declare const cBase32ToVec: (s: string) => Nullable<Vec>;

package/types/cbase32/module.f.js

@@ -0,0 +1,71 @@
+import { msb, lsb, length, vec, empty } from "../bit_vec/module.f.js";
+//                         0123456789abcdef
+const m = '0123456789abcdefghjkmnpqrstvwxyz';
+const { popFront, concat } = msb;
+const popBack1 = lsb.popFront(1n);
+const popFront5 = popFront(5n);
+export const vec5xToCBase32 = (v) => {
+    let result = '';
+    while (true) {
+        const len = length(v);
+        if (len === 0n) {
+            break;
+        }
+        const [r, rest] = popFront5(v);
+        result += m[Number(r)];
+        v = rest;
+    }
+    return result;
+};
+export const vecToCBase32 = (v) => {
+    const len = length(v);
+    const extraLen = 5n - len % 5n;
+    const last = 1n << (extraLen - 1n);
+    const padded = concat(v)(vec(extraLen)(last));
+    return vec5xToCBase32(padded);
+};
+const vec5 = vec(5n);
+const normalizeChar = (c) => {
+    const lower = c.toLowerCase();
+    switch (lower) {
+        case 'i': {
+            return '1';
+        }
+        case 'l': {
+            return '1';
+        }
+        case 'o': {
+            return '0';
+        }
+        default: {
+            return lower;
+        }
+    }
+};
+const toCrockfordIndex = (c) => m.indexOf(normalizeChar(c));
+export const cBase32ToVec5x = (s) => {
+    let result = empty;
+    for (const c of s) {
+        const index = toCrockfordIndex(c);
+        if (index < 0) {
+            return null;
+        }
+        const v = vec5(BigInt(index));
+        result = concat(result)(v);
+    }
+    return result;
+};
+export const cBase32ToVec = (s) => {
+    let v = cBase32ToVec5x(s);
+    if (v === null || v === empty) {
+        return null;
+    }
+    // TODO: replace with a function that computes trailing zeros.
+    while (true) {
+        const [last, v0] = popBack1(v);
+        v = v0;
+        if (last === 1n) {
+            return v;
+        }
+    }
+};

package/types/cbase32/test.f.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    roundtrip5x: () => void;
+    roundtrip: () => void;
+    unalignedBits: () => void;
+    caseInsensitive: () => void;
+};
+export default _default;

package/types/cbase32/test.f.js

@@ -0,0 +1,74 @@
+import { empty, vec } from "../bit_vec/module.f.js";
+import { cBase32ToVec, cBase32ToVec5x, vec5xToCBase32, vecToCBase32 } from "./module.f.js";
+const check5x = (s, v) => {
+    const sr = vec5xToCBase32(v);
+    if (sr !== s) {
+        throw [sr, s];
+    }
+    const vr = cBase32ToVec5x(s);
+    if (vr !== v) {
+        throw [vr, v];
+    }
+    //
+    check(`${s}g`, v);
+};
+const check = (s, v) => {
+    const sr = vecToCBase32(v);
+    if (sr !== s) {
+        throw [sr, s];
+    }
+    const vr = cBase32ToVec(s);
+    if (vr !== v) {
+        throw [vr, v];
+    }
+};
+export default {
+    roundtrip5x: () => {
+        check5x("", empty);
+        check5x("0", vec(5n)(0n));
+        check5x("1", vec(5n)(1n));
+        check5x("7", vec(5n)(7n));
+        check5x("a", vec(5n)(10n));
+        check5x("b", vec(5n)(11n));
+        check5x("f", vec(5n)(15n));
+        check5x("gh", vec(10n)(529n));
+        check5x("jk", vec(10n)(595n));
+        check5x("mnpq", vec(20n)(677591n));
+        check5x("rstvwxyz", vec(40n)(852378941407n));
+    },
+    roundtrip: () => {
+        check("g", empty);
+        check("8", vec(1n)(0n));
+        check("r", vec(1n)(1n));
+        check("4", vec(2n)(0n));
+        check("c", vec(2n)(1n));
+        check("2", vec(3n)(0n));
+        check("1", vec(4n)(0n));
+        check("2g", vec(5n)(2n));
+        check("01", vec(9n)(0n));
+    },
+    unalignedBits: () => {
+        const v = vec(1n)(1n);
+        const cr = vec5xToCBase32(v);
+        if (cr !== "g") {
+            throw ['g', cr];
+        }
+    },
+    caseInsensitive: () => {
+        if (cBase32ToVec5x("A") !== cBase32ToVec5x("a")) {
+            throw 'case-insensitive expected';
+        }
+        if (cBase32ToVec5x("I") !== cBase32ToVec5x("1")) {
+            throw 'i maps to 1';
+        }
+        if (cBase32ToVec5x("l") !== cBase32ToVec5x("1")) {
+            throw 'l maps to 1';
+        }
+        if (cBase32ToVec5x("o") !== cBase32ToVec5x("0")) {
+            throw 'o maps to 0';
+        }
+        if (cBase32ToVec5x("u") !== null) {
+            throw 'should error on invalid character';
+        }
+    }
+};

package/types/effect/mock/module.f.d.ts

@@ -0,0 +1,5 @@
+import type { Effect, Operations } from "../module.f.ts";
+export type MemOperationMap<O extends Operations, S> = {
+    readonly [K in keyof O]: (state: S, payload: O[K][0]) => readonly [S, O[K][1]];
+};
+export declare const run: <O extends Operations, S>(o: MemOperationMap<O, S>) => (state: S) => <O1 extends O, T>(effect: Effect<O1, T>) => readonly [S, T];

package/types/effect/mock/module.f.js

@@ -0,0 +1,14 @@
+export const run = (o) => (state) => (effect) => {
+    let s = state;
+    let e = effect;
+    while (true) {
+        if ('pure' in e) {
+            return [s, e.pure];
+        }
+        const [cmd, payload, cont] = e.do;
+        const operation = o[cmd];
+        const [ns, m] = operation(s, payload);
+        s = ns;
+        e = cont(m);
+    }
+};

package/types/effect/module.d.ts

@@ -0,0 +1,2 @@
+import type { Effect, Operations, ToAsyncOperationMap } from "./module.f.ts";
+export declare const asyncRun: <O extends Operations>(map: ToAsyncOperationMap<O>) => <T, E extends Effect<O, T>>(effect: Effect<O, T>) => Promise<T>;

package/types/effect/module.f.d.ts

@@ -0,0 +1,23 @@
+export type Operations = {
+    readonly [command in string]: readonly [input: unknown, output: unknown];
+};
+export type Effect<O extends Operations, T> = Pure<O, T> | Do<O, T>;
+export type Map<O extends Operations, T> = {
+    readonly pipe: <O1 extends Operations, R>(f: (_: T) => Effect<O1, R>) => Effect<O | O1, R>;
+    readonly map: <O1 extends Operations, R>(f: (_: T) => R) => Effect<O | O1, R>;
+};
+export type Pure<O extends Operations, T> = {
+    readonly pure: T;
+} & Map<O, T>;
+export declare const pure: <O extends Operations, T>(value: T) => Pure<O, T>;
+export type One<O extends Operations, T, K extends keyof O & string> = readonly [K, O[K][0], (input: O[K][1]) => Effect<O, T>];
+export type Do<O extends Operations, T> = {
+    readonly do: {
+        readonly [K in keyof O & string]: One<O, T, K>;
+    }[keyof O & string];
+} & Map<O, T>;
+export declare const do_: <O extends Operations, K extends keyof O & string>(cmd: K, payload: O[K][0]) => Do<O, O[K][1]>;
+export type ToAsyncOperationMap<O extends Operations> = {
+    readonly [K in keyof O]: (payload: O[K][0]) => Promise<O[K][1]>;
+};
+export declare const all: <O extends Operations, T>(set: readonly Effect<O, T>[]) => Effect<O, readonly T[]>;

package/types/effect/module.f.js

@@ -0,0 +1,14 @@
+export const pure = (value) => ({
+    pure: value,
+    pipe: e => e(value),
+    map: f => pure(f(value))
+});
+const doFull = (cmd, payload, cont) => ({
+    do: [cmd, payload, cont],
+    pipe: e => doFull(cmd, payload, x => cont(x).pipe(e)),
+    map: f => doFull(cmd, payload, x => cont(x).map(f))
+});
+export const do_ = (cmd, payload) => doFull(cmd, payload, pure);
+const empty = pure([]);
+// TODO: replace with either a `Do` operation or as an addition to `Pure` and `Do`.
+export const all = (set) => set.reduce((previous, current) => previous.pipe(previousResult => current.map(currentResult => [...previousResult, currentResult])), empty);

package/types/effect/module.js

@@ -0,0 +1,11 @@
+export const asyncRun = (map) => async (effect) => {
+    while (true) {
+        if ('pure' in effect) {
+            return effect.pure;
+        }
+        const [command, payload, continuation] = effect.do;
+        const operation = map[command];
+        const result = await operation(payload);
+        effect = continuation(result);
+    }
+};

package/types/effect/node/module.f.d.ts

@@ -0,0 +1,52 @@
+import type { Vec } from '../../bit_vec/module.f.ts';
+import type { Result } from '../../result/module.f.ts';
+import { type Do, type Effect, type ToAsyncOperationMap } from '../module.f.ts';
+export type IoResult<T> = Result<T, unknown>;
+export type MakeDirectoryOptions = {
+    readonly recursive: true;
+};
+export type MkdirParam = readonly [string, MakeDirectoryOptions?];
+export type Mkdir = {
+    readonly mkdir: readonly [MkdirParam, IoResult<void>];
+};
+export declare const mkdir: (...p: MkdirParam) => Do<Mkdir, IoResult<void>>;
+export type ReadFile = {
+    readonly readFile: readonly [string, IoResult<Vec>];
+};
+export declare const readFile: (path: string) => Do<ReadFile, IoResult<Vec>>;
+/**
+ * Represents a directory entry (file or directory) in the filesystem
+ * @see https://nodejs.org/api/fs.html#class-fsdirent
+ */
+export type Dirent = {
+    readonly name: string;
+    readonly parentPath: string;
+    readonly isFile: boolean;
+};
+export type ReaddirOptions = {
+    readonly recursive?: true;
+};
+export type ReaddirParam = readonly [string, ReaddirOptions];
+export type Readdir = {
+    readonly readdir: readonly [ReaddirParam, IoResult<readonly Dirent[]>];
+};
+export declare const readdir: (...p: ReaddirParam) => Do<Readdir, IoResult<readonly Dirent[]>>;
+export type WriteFileParam = readonly [string, Vec];
+export type WriteFile = {
+    readonly writeFile: readonly [WriteFileParam, IoResult<void>];
+};
+export declare const writeFile: (...p: WriteFileParam) => Do<WriteFile, IoResult<void>>;
+export type Fs = Mkdir & ReadFile & Readdir & WriteFile;
+export type Error = {
+    readonly error: readonly [string, void];
+};
+export declare const error: (msg: string) => Do<Error, void>;
+export type Log = {
+    readonly log: readonly [string, void];
+};
+export declare const log: (msg: string) => Do<Log, void>;
+export type Console = Log & Error;
+export type NodeOperations = Console & Fs;
+export type NodeEffect<T> = Effect<NodeOperations, T>;
+export type NodeOperationMap = ToAsyncOperationMap<NodeOperations>;
+export type NodeProgram = (argv: readonly string[]) => NodeEffect<number>;

package/types/effect/node/module.f.js

@@ -0,0 +1,7 @@
+import { do_ } from "../module.f.js";
+export const mkdir = (...p) => do_('mkdir', p);
+export const readFile = (path) => do_('readFile', path);
+export const readdir = (...p) => do_('readdir', p);
+export const writeFile = (...p) => do_('writeFile', p);
+export const error = (msg) => do_('error', msg);
+export const log = (msg) => do_('log', msg);

package/types/effect/node/test.f.d.ts

@@ -0,0 +1,27 @@
+declare const _default: {
+    map: () => void;
+    mkdir: {
+        one: () => void;
+        rec: () => void;
+        nonRec: () => void;
+    };
+    readFile: {
+        one: () => void;
+        nested: () => void;
+        noSuchFile: () => void;
+        nestedPath: () => void;
+    };
+    readdir: {
+        one: () => void;
+        nonRecursive: () => void;
+        nested: () => void;
+        noSuchDir: () => void;
+    };
+    writeFile: {
+        one: () => void;
+        overwrite: () => void;
+        nestedPath: () => void;
+        directory: () => void;
+    };
+};
+export default _default;

package/types/effect/node/test.f.js

@@ -0,0 +1,259 @@
+import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
+import { run } from "../mock/module.f.js";
+import { mkdir, readdir, readFile, writeFile } from "./module.f.js";
+import { emptyState, virtual } from "./virtual/module.f.js";
+export default {
+    map: () => {
+        let e = readFile('hello').map(([k, v]) => {
+            if (k === 'error') {
+                throw v;
+            }
+            return uint(v) * 2n;
+        });
+        //
+        while (true) {
+            if ('pure' in e) {
+                const result = e.pure;
+                if (result !== 0x2an) {
+                    throw result;
+                }
+                return;
+            }
+            const [cmd, p, cont] = e.do;
+            if (cmd !== 'readFile') {
+                throw cmd;
+            }
+            if (p !== 'hello') {
+                throw p;
+            }
+            e = cont(['ok', vec8(0x15n)]);
+        }
+    },
+    mkdir: {
+        one: () => {
+            const v = run(virtual);
+            const [state, [t, result]] = v(emptyState)(mkdir('a'));
+            if (t === 'error') {
+                throw result;
+            }
+            const a = state.root.a;
+            if (a === undefined || isVec(a)) {
+                throw a;
+            }
+        },
+        rec: () => {
+            const [state, [t, result]] = run(virtual)(emptyState)(mkdir('tmp/cache', { recursive: true }));
+            if (t !== 'ok') {
+                throw result;
+            }
+            const tmp = state.root.tmp;
+            if (tmp === undefined || isVec(tmp)) {
+                throw state.root;
+            }
+            const cache = tmp.cache;
+            if (cache === undefined || isVec(cache)) {
+                throw tmp;
+            }
+        },
+        nonRec: () => {
+            const [state, [t, result]] = run(virtual)(emptyState)(mkdir('tmp/cache'));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (state.root.tmp !== undefined) {
+                throw state.root.tmp;
+            }
+        }
+    },
+    readFile: {
+        one: () => {
+            const v = run(virtual);
+            const initial = {
+                ...emptyState,
+                root: {
+                    hello: vec8(0x2an),
+                },
+            };
+            const [state, [t, result]] = v(initial)(readFile('hello'));
+            if (t === 'error') {
+                throw result;
+            }
+            if (!isVec(result)) {
+                throw result;
+            }
+            if (uint(result) !== 0x2an) {
+                throw result;
+            }
+            if (state.root.hello === undefined) {
+                throw state.root;
+            }
+        },
+        nested: () => {
+            const [_, [tag, result]] = run(virtual)({
+                ...emptyState,
+                root: { tmp: { cache: vec8(0x15n) } }
+            })(readFile('tmp/cache'));
+            if (tag === 'error') {
+                throw result;
+            }
+            if (uint(result) !== 0x15n) {
+                throw result;
+            }
+        },
+        noSuchFile: () => {
+            const [_, [t, result]] = run(virtual)(emptyState)(readFile('hello'));
+            if (t !== 'error') {
+                throw result;
+            }
+        },
+        nestedPath: () => {
+            const [_, [t, result]] = run(virtual)(emptyState)(readFile('tmp/cache'));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (result !== 'no such file') {
+                throw result;
+            }
+        }
+    },
+    readdir: {
+        one: () => {
+            const [_, [t, result]] = run(virtual)({
+                ...emptyState,
+                root: {
+                    file: vec8(0x2an),
+                    dir: {
+                        a: empty
+                    },
+                },
+            })(readdir('', { recursive: true }));
+            if (t !== 'ok') {
+                throw result;
+            }
+            const file = result.find(x => x.name === 'file');
+            if (file === undefined || file.parentPath !== '' || !file.isFile) {
+                throw `file: ${file}`;
+            }
+            const dirA = result.find(x => x.name === 'a');
+            if (dirA === undefined || dirA.parentPath !== '/dir') {
+                throw `dirA: ${dirA?.parentPath}`;
+            }
+        },
+        nonRecursive: () => {
+            const [_, [t, result]] = run(virtual)({
+                ...emptyState,
+                root: {
+                    file: vec8(0x2an),
+                    dir: {
+                        a: empty
+                    },
+                },
+            })(readdir('', {}));
+            if (t !== 'ok') {
+                throw result;
+            }
+            if (result.length !== 2) {
+                throw result;
+            }
+            const file = result.find(x => x.name === 'file');
+            if (file === undefined) {
+                throw file;
+            }
+            const dir = result.find(x => x.name === 'dir');
+            if (dir === undefined) {
+                throw dir;
+            }
+        },
+        nested: () => {
+            const [_, [t, result]] = run(virtual)({
+                ...emptyState,
+                root: { tmp: { cache: vec8(0x15n) } }
+            })(readdir('tmp', { recursive: true }));
+            if (t !== 'ok') {
+                throw result;
+            }
+            if (result.length !== 1) {
+                throw result;
+            }
+            const [r0] = result;
+            if (r0.name !== 'cache') {
+                throw r0;
+            }
+            if (r0.parentPath !== 'tmp') {
+                throw r0;
+            }
+        },
+        noSuchDir: () => {
+            const [_, [t, result]] = run(virtual)(emptyState)(readdir('tmp', { recursive: true }));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (result !== 'invalid path') {
+                throw result;
+            }
+        },
+    },
+    writeFile: {
+        one: () => {
+            const [state, [t, result]] = run(virtual)(emptyState)(writeFile('hello', vec8(0x2an)));
+            if (t !== 'ok') {
+                throw result;
+            }
+            const file = state.root.hello;
+            if (!isVec(file)) {
+                throw file;
+            }
+            if (uint(file) !== 0x2an) {
+                throw file;
+            }
+        },
+        overwrite: () => {
+            const [state, [t, result]] = run(virtual)({
+                ...emptyState,
+                root: {
+                    hello: vec8(0x15n),
+                },
+            })(writeFile('hello', vec8(0x2an)));
+            if (t !== 'ok') {
+                throw result;
+            }
+            const file = state.root.hello;
+            if (!isVec(file)) {
+                throw file;
+            }
+            if (uint(file) !== 0x2an) {
+                throw file;
+            }
+        },
+        nestedPath: () => {
+            const [state, [t, result]] = run(virtual)(emptyState)(writeFile('tmp/cache', vec8(0x2an)));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (result !== 'invalid file') {
+                throw result;
+            }
+            if (state.root.tmp !== undefined) {
+                throw state.root;
+            }
+        },
+        directory: () => {
+            const [state, [t, result]] = run(virtual)({
+                ...emptyState,
+                root: {
+                    tmp: {},
+                },
+            })(writeFile('tmp', vec8(0x2an)));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (result !== 'invalid file') {
+                throw result;
+            }
+            const tmp = state.root.tmp;
+            if (tmp === undefined || isVec(tmp)) {
+                throw tmp;
+            }
+        },
+    },
+};