functionalscript 0.0.421 → 0.0.424

package/.github/workflows/bun.yml

@@ -12,4 +12,4 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - run: curl https://bun.sh/install | bash
-    - run: /home/runner/.bun/bin/bun ./test.f.cjs
+    - run: /home/runner/.bun/bin/bun ./test.mjs

package/.github/workflows/deno.yml

@@ -14,4 +14,4 @@ jobs:
     - uses: denoland/setup-deno@v1
       with:
         deno-version: v1.x
-    - run: deno run --allow-read ./denotest.mjs
+    - run: deno run --allow-read --allow-env --allow-net ./test.mjs

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "functionalscript",
-  "version": "0.0.421",
+  "version": "0.0.424",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "version": "node ./nodejs/version/main.cjs",
-    "test-only": "node --trace-uncaught ./test.f.cjs"
+    "test-only": "node --trace-uncaught ./test.mjs"
   },
   "repository": {
     "type": "git",

package/test.f.cjs

@@ -1,95 +1,58 @@
 const i = require('./module.f.cjs')
 
-require('./types/list/test.f.cjs')
-require('./types/number/test.f.cjs')
-require('./types/bigint/module.f.cjs')
-require('./types/array/test.f.cjs')
-require('./types/btree/test.f.cjs')
-require('./types/byteSet/test.f.cjs')
-require('./types/nibbleSet/test.f.cjs')
-require('./sha2/test.f.cjs')
-require('./types/map/test.f.cjs')
-require('./json/test.f.cjs')
-require('./types/string/test.f.cjs')
-require('./json/tokenizer/test.f.cjs')
-require('./types/object/test.f.cjs')
-// require('./commonjs/test.cjs')
-require('./commonjs/package/dependencies/test.f.cjs')
-require('./commonjs/package/test.f.cjs')
-require('./commonjs/path/test.f.cjs')
-require('./types/function/test.f.cjs')
-require('./types/function/compare/test.f.cjs')
-require('./types/stringset/test.f.cjs')
-require('./types/option/test.f.cjs')
-require('./commonjs/build/test.f.cjs')
-require('./types/range/test.f.cjs')
-require('./html/test.f.cjs')
-require('./text/test.f.cjs')
-require('./text/utf8/test.f.cjs')
-require('./text/utf16/test.f.cjs')
-require('./com/cs/test.f.cjs')
-require('./com/cpp/test.f.cjs')
-require('./nodejs/version/test.f.cjs')
-require('./com/rust/test.f.cjs')
-
 /** @type {() => never} */
 const assert = () => { throw 'assert' }
 
 /** @type {(_: boolean) => void} */
 const assert_if = c => { if (c) { throw 'assert_if' } }
 
-{
-    const c = (()=>{})['constructor']
-    const f = c('return 5')
-    const result = f()
-    if (result !== 5) { throw 'function' }
-}
-
-{
-    /** @type {any} */
-    const o = {}
-    const c = o['constructor']
-    // console.log(c)
-    // console.log(c(()=>{}))
-}
-
-{
-    /** @type {any} */
-    const o = {
-        constructor: undefined
+module.exports = {
+    ctor: () => {
+        const c = (() => { })['constructor']
+        const f = c('return 5')
+        const result = f()
+        if (result !== 5) { throw 'function' }
+    },
+    ctorEmpty: () => {
+        /** @type {any} */
+        const o = {}
+        const c = o['constructor']
+        // console.log(c)
+        // console.log(c(()=>{}))
+    },
+    ctorUndefined: () => {
+        /** @type {any} */
+        const o = {
+            constructor: undefined
+        }
+        const c = o['constructor']
+        //console.log(c)
+    },
+    number: () => {
+        /** @type {any} */
+        const b = '42'
+        const r = Number(b)
+        //console.log(r)
+    },
+    properties: () => {
+        /** @type {any} */
+        const o = {}
+        //const c = o['constructor']
+        //const c = o['__proto__']
+        //const c = o['__defineGetter__']
+        //const c = o['__defineSetter__']
+        //const c = o['__lookupGetter__']
+        //const c = o['__lookupSetter__']
+        //const c = o['hasOwnProperty']
+        //const c = o['isPrototypeOf']
+        //const c = o['propertyIsEnumerable']
+        //const c = o['toString']
+        const c = o['valueOf']
+        //console.log(c)
+    },
+    getOwnPropertyDescriptor: () => {
+        const x = { 'a': 12 }
+        const c = Object.getOwnPropertyDescriptor(x, 'constructor')
+        const a = Object.getOwnPropertyDescriptor(x, 'a')
     }
-    const c = o['constructor']
-    //console.log(c)
-}
-
-{
-    /** @type {any} */
-    const b = '42'
-    const r = Number(b)
-    //console.log(r)
-}
-
-{
-    /** @type {any} */
-    const o = {}
-    //const c = o['constructor']
-    //const c = o['__proto__']
-    //const c = o['__defineGetter__']
-    //const c = o['__defineSetter__']
-    //const c = o['__lookupGetter__']
-    //const c = o['__lookupSetter__']
-    //const c = o['hasOwnProperty']
-    //const c = o['isPrototypeOf']
-    //const c = o['propertyIsEnumerable']
-    //const c = o['toString']
-    const c = o['valueOf']
-    //console.log(c)
-}
-
-{
-    const x = { 'a': 12 }
-    const c = Object.getOwnPropertyDescriptor(x, 'constructor')
-    const a = Object.getOwnPropertyDescriptor(x, 'a')
-}
-
-module.exports = {}
+}

package/test.mjs

@@ -0,0 +1,142 @@
+/**
+ * @typedef {{
+ *  readonly withFileTypes: true
+ * }} Options
+ */
+
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly isDirectory: () => boolean
+ * }} Dirent
+ */
+
+/**
+ * @typedef {{
+ *  readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>
+ *  readonly readFile: (path: string, options: 'utf8') => Promise<Buffer>
+ * }} FsPromises
+ */
+
+/** @type {FsPromises} */
+const { readdir, readFile } = await import(globalThis.Deno ? 'https://deno.land/std/node/fs/promises.ts' : 'node:fs/promises')
+
+/** @typedef {{ exports?: unknown }} Module */
+
+/** @typedef {(name: string) => unknown} Require */
+
+/**
+ * @typedef {{
+ *  readonly[k in string]: Function
+ * }} FunctionMap
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+
+/** @type {(a: Entry<Function>, b: Entry<Function>) => number} */
+const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+
+/** @type {() => Promise<FunctionMap>} */
+const load = async () => {
+    /** @type {(readonly[string, Function])[]} */
+    const map = []
+    /** @type {(path: string) => Promise<void>} */
+    const f = async p => {
+        for (const i of await readdir(p, { withFileTypes: true })) {
+            const { name } = i
+            if (!name.startsWith('.')) {
+                const file = `${p}/${name}`
+                if (i.isDirectory()) {
+                    if (!['node_modules', 'target'].includes(name)) {
+                        await f(file)
+                    }
+                } else if (name.endsWith('.f.cjs')) {
+                    console.log(`loading ${file}`)
+                    const source = await readFile(file, 'utf8')
+                    map.push([file, Function('module', 'require', `"use strict";${source}`)])
+                }
+            }
+        }
+    }
+    await f('.')
+    map.sort(cmp)
+    return Object.fromEntries(map)
+}
+
+const map = await load()
+
+/**
+ * @typedef {{
+ *  [k in string]: unknown
+ * }} ModuleMap
+ */
+
+const build = async () => {
+    /** @type {ModuleMap} */
+    const d = {}
+    /** @type {(base: readonly string[]) => (i: string) => (k: string) => unknown} */
+    const req = p => i => k => {
+        const relativePath = k.split('/')
+        const dif = relativePath.filter(v => v === '..').length
+        const path = [p.slice(0, p.length - dif), relativePath.filter(v => !['..', '.'].includes(v))]
+            .flat()
+        const pathStr = path.join('/')
+        const newBase = path.slice(0, path.length - 1)
+        const result = d[pathStr]
+        if (result === undefined) {
+            /** @type {Module} */
+            const me = {}
+            console.log(`${i}building ${pathStr}`)
+            map[pathStr](me, req(newBase)(`${i}| `))
+            const newResult = me.exports
+            d[pathStr] = newResult
+            return newResult
+        } else {
+            return result
+        }
+    }
+    const r = req(['.'])('')
+    for (const k of Object.keys(map)) {
+        r(k)
+    }
+    return d
+}
+
+const modules = await build()
+
+const test = i => v => {
+    switch (typeof v) {
+        case 'function': {
+            if (v.length === 0) {
+                const r = v()
+                console.log(`${i}() passed`)
+                test(`${i}| `)(r)
+            }
+            return;
+        }
+        case 'object': {
+            if (v instanceof Array) {
+                for (const v2 of v) {
+                    test(`${i}| `)(v2)
+                }
+            } else {
+                for (const [k, v2] of Object.entries(v)) {
+                    const i2 = `${i}| `
+                    console.log(`${i}${k}:`)
+                    test(i2)(v2)
+                }
+            }
+            return;
+        }
+    }
+}
+
+for (const [k, v] of Object.entries(modules)) {
+    if (k.endsWith('test.f.cjs')) {
+        console.log(`testing ${k}`)
+        test('| ')(v)
+    }
+}

package/text/utf16/module.f.cjs

@@ -1,9 +1,8 @@
 const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
-const array = require('../../types/array/module.f.cjs')
 const { contains } = require('../../types/range/module.f.cjs')
-const { compose } = require('../../types/function/module.f.cjs')
-const { map, flat, stateScan, concat, reduce, flatMap } = list
+const { fn } = require('../../types/function/module.f.cjs')
+const { map, flat, stateScan, reduce, flatMap } = list
 
 /** @typedef {u16|undefined} WordOrEof */
 
@@ -13,48 +12,57 @@ const { map, flat, stateScan, concat, reduce, flatMap } = list
 
 /** @typedef {number} i32 */
 
-/** @type {(a:number) => boolean} */
-const isBmpCodePoint = a => a >= 0x0000 && a <= 0xd7ff || a >= 0xe000 && a <= 0xffff
+const lowBmp = contains([0x0000, 0xd7ff])
+const highBmp = contains([0xe000, 0xffff])
 
+/** @type {(codePoint: i32) => boolean} */
+const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint)
+
+/** @type {(codePoint: i32) => boolean} */
 const isHighSurrogate = contains([0xd800, 0xdbff])
 
-/** @type {(a:number) => boolean} */
+/** @type {(codePoint: i32) => boolean} */
 const isLowSurrogate = contains([0xdc00, 0xdfff])
 
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
-/** @type {(input:i32) => list.List<u16>} */
-const codePointToUtf16 = input =>
-{
-    if (isBmpCodePoint(input)) { return [input] }
-    if (input >= 0x010000 && input <= 0x10ffff) {
-        const high = ((input - 0x10000) >> 10) + 0xd800
-        const low = ((input - 0x10000) & 0b0011_1111_1111) + 0xdc00
+/** @type {(a: i32) => boolean} */
+const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff])
+
+/** @type {(input: i32) => list.List<u16>} */
+const codePointToUtf16 = codePoint => {
+    if (isBmpCodePoint(codePoint)) { return [codePoint] }
+    if (isSupplementaryPlane(codePoint)) {
+        const n = codePoint - 0x1_0000
+        const high = (n >> 10) + 0xd800
+        const low = (n & 0b0011_1111_1111) + 0xdc00
         return [high, low]
     }
-    return [input & 0xffff]
+    return [codePoint & 0xffff]
 }
 
 const fromCodePointList = flatMap(codePointToUtf16)
 
+const u16 = contains([0x0000, 0xFFFF])
+
 /** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
-const utf16ByteToCodePointOp = state => byte => {
-    if (byte < 0x00 || byte > 0xffff) {
+const utf16ByteToCodePointOp = state => word => {
+    if (!u16(word)) {
         return [[0xffffffff], state]
     }
     if (state === undefined) {
-        if (isBmpCodePoint(byte)) { return [[byte], undefined] }
-        if (isHighSurrogate(byte)) { return [[], byte] }
-        return [[byte | errorMask], undefined]
+        if (isBmpCodePoint(word)) { return [[word], undefined] }
+        if (isHighSurrogate(word)) { return [[], word] }
+        return [[word | errorMask], undefined]
     }
-    if (isLowSurrogate(byte)) {
+    if (isLowSurrogate(word)) {
         const high = state - 0xd800
-        const low = byte - 0xdc00
+        const low = word - 0xdc00
         return [[(high << 10) + low + 0x10000], undefined]
     }
-    if (isBmpCodePoint(byte)) { return [[state | errorMask, byte], undefined] }
-    if (isHighSurrogate(byte)) { return [[state | errorMask], byte] }
-    return [[state | errorMask, byte | errorMask], undefined]
+    if (isBmpCodePoint(word)) { return [[state | errorMask, word], undefined] }
+    if (isHighSurrogate(word)) { return [[state | errorMask], word] }
+    return [[state | errorMask, word | errorMask], undefined]
 }
 
 /** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
@@ -63,8 +71,11 @@ const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state
 /** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
 const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
+/** @type {list.List<WordOrEof>} */
+const eofList = [undefined]
+
 /** @type {(input: list.List<u16>) => list.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(flat([input, eofList])))
 
 /** @type {(s: string) => list.List<u16>} */
 const stringToList = s => {
@@ -76,7 +87,10 @@ const stringToList = s => {
     return at(0)
 }
 
-const listToString = compose(map(String.fromCharCode))(reduce(operator.concat)(''))
+/** @type {(input: list.List<u16>) => string} */
+const listToString = fn(map(String.fromCharCode))
+    .then(reduce(operator.concat)(''))
+    .result
 
 module.exports = {
     /** @readonly */

package/text/utf8/module.f.cjs

@@ -1,7 +1,7 @@
 const list = require('../../types/list/module.f.cjs')
 const operator = require('../../types/function/operator/module.f.cjs')
 const array = require('../../types/array/module.f.cjs')
-const { flatMap } = list
+const { flatMap, flat, stateScan } = list
 
 /** @typedef {u8|undefined} ByteOrEof */
 
@@ -16,8 +16,7 @@ const { flatMap } = list
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
 /** @type {(input:number) => list.List<u8>} */
-const codePointToUtf8 = input =>
-{
+const codePointToUtf8 = input => {
     if (input >= 0x0000 && input <= 0x007f) { return [input & 0b01111_1111] }
     if (input >= 0x0080 && input <= 0x07ff) { return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000] }
     if (input >= 0x0800 && input <= 0xffff) { return [input >> 12 | 0b1110_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000] }
@@ -35,9 +34,9 @@ const fromCodePointList = flatMap(codePointToUtf8)
 
 /** @type {(state: Utf8NonEmptyState) => i32}*/
 const utf8StateToError = state => {
-    switch(state.length) {
+    switch (state.length) {
         case 1:
-             return state[0] | errorMask
+            return state[0] | errorMask
         case 2:
             if (state[0] < 0b1111_0000) return (((state[0] & 0b0000_1111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0100_0000_0000) | errorMask
             return (((state[0] & 0b0000_0111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0010_0000_0000) | errorMask
@@ -57,7 +56,7 @@ const utf8ByteToCodePointOp = state => byte => {
         return [[byte | errorMask], undefined]
     }
     if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
-        switch(state.length) {
+        switch (state.length) {
             case 1:
                 if (state[0] < 0b1110_0000) { return [[((state[0] & 0b0001_1111) << 6) + (byte & 0b0011_1111)], undefined] }
                 if (state[0] < 0b1111_1000) { return [[], [state[0], byte]] }
@@ -85,8 +84,11 @@ const utf8EofToCodePointOp = state => {
 /** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
 const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
+/** @type {list.List<ByteOrEof>} */
+const eofList = [undefined]
+
 /** @type {(input: list.List<u8>) => list.List<i32>} */
-const toCodePointList = input => list.flat(list.stateScan(utf8ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
+const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(undefined)(flat([input, eofList])))
 
 module.exports = {
     /** @readonly */

package/tsconfig.json

@@ -97,5 +97,5 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
   },
-  "exclude": ["target", "denotest.mjs"]
+  "exclude": ["target", "test.mjs"]
 }

package/types/array/test.f.cjs

@@ -89,6 +89,4 @@ const stringify = a => json.stringify(sort)(a)
     if (result !== undefined) {throw result}
 }
 
-module.exports = {
-
-}
+module.exports = {}

package/types/bigint/test.f.cjs

@@ -1,8 +1,8 @@
 const { sum } = require('./module.f.cjs')
 
-{
-    const result = sum([2n, 3n, 4n, 5n])
-    if (result !== 14n) { throw result }
-}
-
-module.exports = {}
+module.exports = {
+    sum: () => {
+        const result = sum([2n, 3n, 4n, 5n])
+        if (result !== 14n) { throw result }
+    }
+}

package/types/string/test.f.cjs

@@ -1,44 +1,41 @@
 const { join, concat, repeat, cmp } = require('./module.f.cjs')
 const { repeat: repeatList } = require('../list/module.f.cjs')
 
-{
-    const result = join('/')([])
-    if (result !== '') { throw result }
+module.exports = {
+    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 }
+    }
 }
-
-{
-    const result = join('/')([''])
-    if (result !== '') { throw result }
-}
-
-{
-    const result = join(' ')(['hello', 'world', '!'])
-    if (result !== 'hello world !') { throw result }
-}
-
-{
-    const result = concat(['hello', 'world'])
-    if (result !== 'helloworld') { throw result }
-}
-
-{
-    const s = join('.')(repeatList('x')(0))
-    if (s != '') { throw s }
-}
-
-{
-    const s = join('.')(repeatList('x')(5))
-    if (s != 'x.x.x.x.x') { throw s }
-}
-
-{
-    const s = repeat('x')(5)
-    if (s != 'xxxxx') { throw s }
-}
-
-{
-    const result = cmp('3')('4')
-    if (result !== -1) { throw result }
-}
-
-module.exports = {}

package/types/stringset/test.f.cjs

@@ -1,35 +1,34 @@
 const _ = require('./module.f.cjs')
 
-{
-    const r = _.set('hello')(undefined)
-    if (!_.contains('hello')(r)) { throw r }
-    if (_.contains('hello1')(r)) { throw r }
-}
-
-{
-    let r = _.set('hello')(undefined)
-    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 !== undefined) { throw r }
-}
-
-module.exports = {}
+module.exports = {
+    contains: () => {
+        const r = _.set('hello')(undefined)
+        if (!_.contains('hello')(r)) { throw r }
+        if (_.contains('hello1')(r)) { throw r }
+    },
+    remove: () => {
+        let r = _.set('hello')(undefined)
+        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 !== undefined) { throw r }
+    }
+}

package/denotest.mjs

@@ -1,89 +0,0 @@
-const {
-    /** @type {(path: string | URL) => AsyncIterable<DirEntry>} */
-    readDir,
-    /** @type {(path: string | URL) => Promise<string>} */
-    readTextFile,
-} = Deno
-
-/**
- * @typedef {{
- *  readonly isDirectory: boolean
- *  readonly isFile: boolean
- *  readonly isSymlink: boolean
- *  readonly name: string
- * }} DirEntry
- */
-
-/** @typedef {{ exports?: unknown }} Module */
-
-/** @typedef {(name: string) => unknown} Require */
-
-/**
- * @typedef {{
- *  [k in string]: Function
- * }} FunctionMap
- */
-
-/** @type {(path: string) => Promise<FunctionMap>} */
-const dir = async p => {
-    /** @type {FunctionMap} */
-    const map = {}
-    /** @type {(path: string) => Promise<void>} */
-    const f = async p => {
-        for await (const i of readDir(p)) {
-            const { name } = i
-            if (!name.startsWith('.')) {
-                const file = `${p}/${name}`
-                if (i.isDirectory) {
-                    if (!['node_modules', 'target'].includes(name)) {
-                        await f(file)
-                    }
-                } else if (name.endsWith('.f.cjs')) {
-                    // console.log(name)
-                    const source = await readTextFile(file)
-                    map[file] = Function('module', 'require', `"use strict";${source}`)
-                }
-            }
-        }
-    }
-    await f(p)
-    return map
-}
-
-/**
- * @typedef {{
- *  [k in string]: unknown
- * }} ModuleMap
- */
-
-const run = async () => {
-    const m = await dir('.')
-    /** @type {ModuleMap} */
-    const d = {}
-    /** @type {(base: readonly string[]) => (k: string) => unknown} */
-    const req = p => k => {
-        const relativePath = k.split('/')
-        const bPath = relativePath.filter(v => !['..', '.'].includes(v))
-        const dif = relativePath.filter(v => v === '..').length
-        const path = [p.slice(0, p.length - dif), bPath.slice(0, bPath.length)].flat()
-        const pathStr = path.join('/')
-        const newBase = path.slice(0, path.length - 1)
-        const result = d[pathStr]
-        if (result === undefined) {
-            /** @type {Module} */
-            const me = {}
-            m[pathStr](me, req(newBase))
-            const newResult = me.exports
-            d[pathStr] = newResult
-            return newResult
-        } else {
-            return result
-        }
-    }
-    const r = req(['.'])
-    for (const k of Object.keys(m)) {
-        r(k)
-    }
-}
-
-run()