functionalscript 0.0.229 → 0.0.233

package/version.js

@@ -12,6 +12,6 @@ console.log(`version: ${v}`)
 
 let package_json = json.parse(fs.readFileSync('package.json').toString())
 
-package_json = json.addProperty(v)(['version'])(package_json)
+package_json = json.setProperty(v)(['version'])(package_json)
 
-fs.writeFileSync('package.json', JSON.stringify(package_json, null, 3))
+fs.writeFileSync('package.json', JSON.stringify(package_json, null, 2))

package/module-manager/README.md

@@ -1,35 +0,0 @@
-# Module Manager
-
-## Module Provider
-
-```js
-/** @typedef {(packageName: string) => PackageMap|Package|undefined} PackageMap */
-
-/** 
- * @typedef {readonly[
- *  string, 
- *  PackageMap, 
- *  (fileName: string) => string|undefined
- * ]} Package 
- */
-```
-
-## Runner IO
-
-The main target of this design is to simplify `RunnerIo` as much as possible.
-
-```js
-/**
- * @template T 
- * @typedef {readonly[Result<unknown, Error>, Require<T>]} RunnerResult
- */
-
-/** @typedef {<T>(require: Require<T>) => (source: string) => RunnerResult<T>} RunnerIo */
-
-/**
- * @template T
- * @typedef {readonly[(path: string) => RunnerResult<T>, T]} Require<T>
- */
-```
-
-`Require` is using a `Package` and it contains also `RunnerIo` to provide sources also it contains

package/module-manager/index.js

@@ -1,110 +0,0 @@
-const array = require('../sequence/array')
-const { compose } = require('../function')
-const option = require('../option')
-const { head, last, splitLast, splitFirst } = array
-const iter = require('../sequence/iterable')
-const seq = require('../sequence/operator')
-
-/**
- * @template T
- * @typedef {array.Array<T>} Array
- */
-
-/** @typedef {Array<string>} Path */
-
-/** @typedef {(_: string) => string|undefined} ReadFile */
-
-/**
- * @typedef {{
- *  readonly id: Array<string>
- *  readonly dependencies: Dependencies
- *  readonly file: ReadFile
- * }} Package
- */
-
-/**
- * @typedef {{
- *  readonly pack: Package,
- *  readonly local: Array<string>,
- * }} Location
- */
-
-/**
- * @typedef {{
- *  readonly fileName: string
- *  readonly location: Location
- *  readonly source: string
- * }} Module
- */
-
-/** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
-
-/** @type {seq.ExclusiveScan<string, undefined|Path>} */
-const pathNormReduce = seq.exclusiveScan
-    (path => item =>
-        path === undefined ?
-            undefined :
-        ['', '.'].includes(item) ?
-            path :
-        item === '..' ?
-            head(path) :
-            [...path, item])
-    ([])
-
-/** @type {(_: Array<string>) => boolean} */
-const isRelative = localId => ['.', '..'].includes(localId[0])
-
-const pathNorm = iter.reduce(pathNormReduce)
-
-/** @type {(_: Package) => (_: Path) => Module|undefined} */
-const internal = pack => {
-    /** @type {(_: Path) => (_: string) => Module|undefined} */
-    const readFile = local => fileName => {
-        const source = pack.file([...local, fileName].join('/'))
-        return source === undefined ? undefined : { fileName, location: { pack, local }, source}
-    }
-    return path => {
-        /** @type {(_: Path) => Module|undefined} */
-        const read = local => {
-            /** @type {(_: readonly[Path, string]) => Module|undefined} */
-            const tryFiles = ([head, file]) => {
-                /** @type {(_: string) => Module|undefined} */                
-                const one = ext => readFile(head)(file + ext)
-                return ['.', '..', '', undefined].includes(last(path)) ? undefined : one('') ?? one('.js')
-            }
-            return option.map(tryFiles)(splitLast(local)) ?? readFile(local)('index.js')
-        }
-        return option.map(read)(pathNorm(path))
-    }
-}
-
-/** @type {(_: Package|Dependencies|undefined) => (_: Path) => Module|undefined} */
-const externalOrInternal = p => 
-    p === undefined ? () => undefined : (typeof p === 'function' ? external(p) : internal(p))
-
-/** @type {(_: Dependencies) => (path: Path) => Module|undefined} */
-const external = packages => { 
-    /** @type {(_: readonly [string, Path]) => Module|undefined} */
-    const defined = ([first, tail]) => externalOrInternal(packages(first))(tail)
-    return path => option.map(defined)(splitFirst(path))
-}
-
-/** @type {(_: Location) => (_: string) => Module|undefined} */
-const getModule = ({pack, local}) => path => {
-    const pathArray = path.split('/')
-    return isRelative(pathArray) ? internal(pack)([...local, ...pathArray]) : external(pack.dependencies)(pathArray)
-}
-
-/** @type {(_: Module) => string} */
-const moduleId = module => [...module.location.pack.id, ...module.location.local, module.fileName].join('/') 
-
-module.exports = {
-    /** @readonly */
-    isRelative,
-    /** @readonly */
-    pathNorm,
-    /** @readonly */
-    getModule,
-    /** @readonly */
-    moduleId,
-}

package/module-manager/node/index.js

@@ -1,18 +0,0 @@
-const m = require('..')
-
-/** @type {(_: m.ReadFile) => m.Location} */
-module.exports = readFile => {
-    /** @type {(_: string[]) => (_: string) => m.Package|m.Dependencies|undefined} */
-    const packages = path => name => {
-        const newPath = [...path, name]
-        // we only need to check if 'package.json' exist
-        return (readFile([...newPath, 'package.json'].join('/')) === undefined ? packages : pack)(newPath)
-    }
-    /** @type {(_: string[]) => m.Package} */
-    const pack = path => ({
-        id: path,
-        dependencies: packages(['node_modules']),
-        file: filePath => readFile([...path, ...filePath.split('/')].join('/'))
-    })
-    return { pack: pack([]), local: [] }
-}

package/module-manager/node/test.js

@@ -1,75 +0,0 @@
-const mm = require('..')
-const i = require('.')
-
-/** @type {{ readonly [_ in string]: string}} */
-const files = {
-    'index.js': './index.js',
-    'a/index.js': './a/index.js',
-    'a/b/x.js': './a/b/x.js',
-    'c/t.js': './c/t.js',
-    'node_modules/@functionalscript/functionalscript/package.json': '',
-    'node_modules/@functionalscript/functionalscript/index.js': '@functionalscript/functionalscript ./index.js',
-    'node_modules/my/package.json': '',
-    'node_modules/my/src/x.js': 'my ./src/x.js',
-    'node_modules/my/b/index.js': 'my ./b/index.js',
-}
-
-/** @type {(_: string) => string|undefined} */
-const readFile = path => files[path]
-
-const root = i(readFile)
-
-{
-    const index = mm.getModule(root)('.')
-    if (index === undefined) { throw 'no module' }
-    if (index.fileName !== 'index.js') { throw 'fileName' }
-    if (index.source !== './index.js') { throw 'source' }
-    if (index.location.local.join('/') !== '') { throw 'location' }
-    if (index.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.moduleId(index) !== 'index.js') { throw 'moduleId' }
-    const a = mm.getModule(index.location)('./a')   
-    if (a === undefined) { throw 'no module' }
-    if (a.fileName !== 'index.js') { throw 'fileName' }
-    if (a.source !== './a/index.js') { throw 'source' }
-    if (a.location.local.join('/') !== 'a') { throw 'location' }
-    if (a.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.moduleId(a) !== 'a/index.js') { throw 'moduleId' }
-    const abx = mm.getModule(a.location)('./b/x')
-    if (abx === undefined) { throw 'no module' }
-    if (abx.fileName !== 'x.js') { throw 'fileName' }
-    if (abx.source !== './a/b/x.js') { throw 'source' }
-    if (abx.location.local.join('/') !== 'a/b') { throw 'location' }
-    if (abx.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.moduleId(abx) !== 'a/b/x.js') { throw 'moduleId' }
-    const ct = mm.getModule(abx.location)('../../c/t.js')
-    if (ct === undefined) { throw 'no module' }
-    if (ct.fileName !== 't.js') { throw 'fileName' }
-    if (ct.source !== './c/t.js') { throw 'source' }
-    if (ct.location.local.join('/') !== 'c') { throw 'location' }
-    if (ct.location.pack.id.join('/') !== '') { throw 'pack.id' }
-    if (mm.getModule(ct.location)('./d') !== undefined) { throw 'no module' }
-    if (mm.getModule(ct.location)('@functionalscript') !== undefined) { throw 'no module' }
-    if (mm.moduleId(ct) !== 'c/t.js') { throw 'moduleId' }
-    const fs = mm.getModule(ct.location)('@functionalscript/functionalscript')
-    if (fs === undefined) { throw 'no module' }    
-    if (fs.source !== '@functionalscript/functionalscript ./index.js') { throw 'source' }
-    if (fs.fileName !== 'index.js') { throw 'fileName' }
-    if (fs.location.local.join('/') !== '') { throw 'location' }
-    if (fs.location.pack.id.join('/') !== 'node_modules/@functionalscript/functionalscript') { throw 'pack.id' }
-    if (mm.getModule(fs.location)('my/src/x/') !== undefined) { throw 'no module '}
-    if (mm.moduleId(fs) !== 'node_modules/@functionalscript/functionalscript/index.js') { throw 'moduleId' }
-    const mySrcX = mm.getModule(fs.location)('my/src/x')
-    if (mySrcX === undefined) { throw 'no module' }
-    if (mySrcX.fileName !== 'x.js') { throw 'fileName' }
-    if (mySrcX.source !== 'my ./src/x.js') { throw 'source' }
-    if (mySrcX.location.local.join('/') !== 'src') { throw 'location' }
-    if (mySrcX.location.pack.id.join('/') !== 'node_modules/my') { throw 'pack.id' }
-    if (mm.moduleId(mySrcX) !== 'node_modules/my/src/x.js') { throw 'moduleId' }
-    const myB = mm.getModule(mySrcX.location)('../b/')
-    if (myB === undefined) { throw 'no module' }
-    if (myB.fileName !== 'index.js') { throw 'fileName' }
-    if (myB.source !== 'my ./b/index.js') { throw 'source' }
-    if (myB.location.local.join('/') !== 'b') { throw 'location' }
-    if (myB.location.pack.id.join('/') !== 'node_modules/my') { throw 'pack.id' }
-    if (mm.moduleId(myB) !== 'node_modules/my/b/index.js') { throw 'moduleId' }
-}

package/module-manager/test.js

@@ -1,120 +0,0 @@
-const i = require('.')
-
-require('./node/test')
-
-/** @type {<T>(_: T | undefined) => T} */
-const cast = x => {
-    if (x === undefined) { throw 'x' } 
-    return x
-}
-
-if (i.isRelative('a/b/c'.split('/'))) { throw 'error '}
-if (!i.isRelative('./a/b/c'.split('/'))) { throw 'error ' }
-if (cast(i.pathNorm('a/../b'.split('/'))).join('/') !== 'b') { throw 'error ' }
-if (cast(i.pathNorm('a/../b/../c'.split('/'))).join('/') !== 'c') { throw 'error ' }
-if (cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d') { throw 'error ' }
-
-{
-    /** @type {i.Package} */
-    const a = { 
-        dependencies: () => undefined,
-        file: path => {
-            /** @type {{ [_ in string]?: string}} */
-            const f = {
-                'index.js': 'a ./index.js',
-            }
-            return f[path]
-        },
-        id: ['a']
-    }
-    /** @type {i.Package} */
-    const c = { 
-        dependencies: () => undefined,
-        file: path => {
-            /** @type {{ readonly [_ in string]?: string}} */
-            const f = {
-                'index.js': 'b/c ./index.js',
-                'x/index.js': 'b/c ./x/index.js',
-            }
-            if (['.js', '', 'undefined.js'].includes(path)) { throw '.js' }
-            return f[path]
-        },
-        id: ['c']
-    }
-    /** @type {{ readonly [_ in string]: i.Package|i.Dependencies}} */
-    const packages = {
-        a,
-        b: s => {
-            /** @type {{ readonly [_ in string]: i.Package|i.Dependencies}} */
-            const p = { c }
-            return p[s]
-        }
-    }
-    /** @type {i.Package} */
-    const pack = {
-        dependencies: s => packages[s],
-        file: path => {
-            /** @type {{ readonly [_ in string]?: string}} */
-            const f = {
-                'index.js': './index.js',
-                'index/index.js': './index/index.js',
-                'a/index.js': './a/index.js',
-                'a/index.js.js': './a/index.js.js',
-            }
-            if (['.js', '', 'undefined.js'].includes(path)) { throw '.js' }
-            return  f[path] 
-        },
-        id: ['']
-    }
-    /** @type {(_: i.Module|undefined) => (_: i.Module) => void} */
-    const expect = a => b => {            
-        if (a === undefined) { throw 'undefined' }
-        if (a.location.local.join('/') !== b.location.local.join('/')) { throw 'local'}
-        if (a.location.pack !== b.location.pack) { throw 'pack' }
-        if (a.source !== b.source) { throw 'source' }
-    }
-    {        
-        const g = i.getModule({pack, local: []})
-        if (g('') !== undefined) { throw 'error' }
-        if (g('..') !== undefined) { throw 'error' }
-        expect(g('.'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('./index'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('./index.js'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('./index/'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        expect(g('./a'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('./a/index'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('./a/index.js'))({ fileName: 'index.js.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        if (g('./x') !== undefined) { throw 'error' }
-        expect(g('a'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        expect(g('a/index'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        if (g('b') !== undefined) { throw 'error' }
-        expect(g('b/c'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index.js'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/x'))({ fileName: 'index.js', location: { pack: c, local: ['x']}, source: 'b/c ./x/index.js'})
-        expect(g('b/c/r/..'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-    }
-    {
-        const g = i.getModule({pack, local: ['index']})
-        if (g('') !== undefined) { throw 'error' }
-        expect(g('..'))({ fileName: 'index.js', location: { pack, local: []}, source: './index.js'})
-        expect(g('.'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        expect(g('./index'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        expect(g('./index.js'))({ fileName: 'index.js', location: { pack, local: ['index']}, source: './index/index.js'})
-        if (g('./index/') !== undefined) { throw 'error' }
-        if (g('./a') !== undefined) { throw 'error' }
-        expect(g('../a'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('../a/index'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('../a/index.js'))({ fileName: 'index.js', location: { pack, local: ['a']}, source: './a/index.js'})
-        expect(g('../a/index.js.js'))({ fileName: 'index.js.js', location: { pack, local: ['a']}, source: './a/index.js.js'})
-        if (g('./x') !== undefined) { throw 'error' }
-        expect(g('a'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        expect(g('a/index'))({ fileName: 'index.js', location: { pack: a, local: []}, source: 'a ./index.js'})
-        if (g('b') !== undefined) { throw 'error' }
-        expect(g('b/c'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/index.js'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-        expect(g('b/c/x'))({ fileName: 'index.js', location: { pack: c, local: ['x']}, source: 'b/c ./x/index.js'})
-        expect(g('b/c/r/..'))({ fileName: 'index.js', location: { pack: c, local: []}, source: 'b/c ./index.js'})
-    }    
-}

package/result/index.js

@@ -1,17 +0,0 @@
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-
-module.exports = {}

package/sequence/asyncIterable/index.js

@@ -1,111 +0,0 @@
-const { compose } = require('../../function')
-const seq = require('../operator')
-
-/**
- * @template T 
- * @typedef {Promise<T>|T} PromiseOrValue 
- */
-
-/**
- * @template T
- * @typedef {Iterable<T> | AsyncIterable<T>} AsyncOrSyncIterable
- */
-
-/** @type {<T>(c: AsyncOrSyncIterable<AsyncOrSyncIterable<T>>) => AsyncIterable<T>} */
-const flat = c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield* i
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => AsyncOrSyncIterable<R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield* await f(i)
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => R) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const map = seq.map(flatMap)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncOrSyncIterable<T>} */
-const filter = seq.filter(flatMap)
-
-/** @type {<T>(a: AsyncOrSyncIterable<T>) => (b: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
-const concat = a => b => ({
-    async *[Symbol.asyncIterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<T, R>(s: seq.Scan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const scan = s => c => ({
-    async *[Symbol.asyncIterator]() {
-        let next = s
-        for await (const i of c) {
-            const result = next(i)
-            next = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
-
-/** @type {<T, R>(is: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
-const reduce = ([first, s]) => async c => {
-    let next = first
-    for await (const i of scan(s)(c)) {
-        next = i
-    }
-    return next
-}
-
-const sum = reduce(seq.sum)
-
-const join = compose(seq.join)(reduce)
-
-const length = reduce(seq.length)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
-const takeWhile = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            if (!f(i)) { return }
-            yield i
-        }
-    }
-})
-
-module.exports = {
-    /** @readonly */
-    concat,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    join,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    takeWhile,
-}

package/sequence/asyncIterable/test.js

@@ -1,24 +0,0 @@
-const { map, filter, flatMap, sum } = require('.')
-
-const test = async () => {
-    {
-        const a = [1, 2, 3]
-        const m = map(x => x * x)(a)
-        const result = await sum(m)
-        if (result !== 14) { throw 'filter' }
-    }
-    {
-        const a = [1, 2, 3, 4]
-        const f = filter(x => x !== 2)(a)
-        const result = await sum(f)
-        if (result !== 8) { throw 'filter' }
-    }
-    {
-        const a = [1, 2]
-        const f = flatMap(x => [x, x * x])(a)
-        const result = await sum(f)
-        if (result !== 8) { throw 'filter' }
-    }
-}
-
-test()

package/sequence/iterable/index.js

@@ -1,109 +0,0 @@
-const { compose } = require('../../function')
-const seq = require('../operator')
-
-/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
-const concat = a => b => ({
-    *[Symbol.iterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<T, R>(s: seq.Scan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const scan = s => c => ({
-    *[Symbol.iterator]() {
-        let next = s
-        for (const i of c) {
-            const result = next(i)
-            next = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => R} */
-const reduce = ([first, s]) => c => {
-    let next = first
-    for (const i of scan(s)(c)) {
-        next = i
-    }
-    return next
-}
-
-const entries = scan(seq.entries)
-
-const sum = reduce(seq.sum)
-
-const length = reduce(seq.length)
-
-const join = compose(seq.join)(reduce)
-
-/** @type {<T, R>(f: (value: T) => Iterable<R>) => (c: Iterable<T>) => Iterable<R>} */
-const flatMap = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            yield* f(i)
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
-const map = seq.map(flatMap)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
-const filter = seq.filter(flatMap)
-
-/** @type {<T>(c: Iterable<Iterable<T>>) => Iterable<T>} */
-const flat = flatMap(x => x)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
-const takeWhile = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            if (!f(i)) { return }
-            yield i
-        }
-    }
-})
-
-/** @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} */
-const find = f => c => {
-    for (const i of c) {
-        if (f(i)) {
-            return i
-        }
-    }
-    return undefined
-}
-
-module.exports = {
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    join,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    takeWhile,
-    /** @readonly */
-    find,
-}