functionalscript 0.0.231 → 0.0.232

package/types/result/index.js

@@ -0,0 +1,28 @@
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+
+/** @type {<T>(value: T) => Ok<T>} */
+const ok = value => ['ok', value]
+
+/** @type {<E>(e: E) => Error<E>} */
+const error = e => ['error', e]
+
+module.exports = {
+    /** @readonly */
+    ok,
+    /** @readonly */
+    error,
+}

package/{sequence → types/sequence}/index.js

@@ -1,4 +1,4 @@
-const { compose } = require('../function')
+const { compose, identity } = require('../function')
 const { logicalNot, strictEqual, addition } = require('../function/operator')
 const op = require('../function/operator')
 
@@ -19,7 +19,7 @@ const op = require('../function/operator')
 
 /**
  * @template T
- * @typedef { readonly[Sequence<T>, Sequence<T>]} Concat<T>
+ * @typedef { readonly[Sequence<T>, Sequence<T>] } Concat<T>
  */
 
 /**
@@ -54,6 +54,9 @@ const fromArray = array => {
 /** @type {<T>(sequence: Sequence<T>) => Node<T>} */
 const node = sequence => sequence instanceof Array ? fromArray(sequence) : sequence()
 
+/** @type {<T>(a: Sequence<T>) => (b: Sequence<T>) => Thunk<T>} */
+const concat = a => b => () => [a, b]
+
 /** @type {<T>(sequence: Sequence<T>) => Result<T>} */
 const next = sequence => {
     let i = sequence
@@ -66,10 +69,10 @@ const next = sequence => {
             i = b
         } else if (aNode instanceof Array) {
             const [aa, ab] = aNode
-            i = () => [aa, () => [ab, b]]
+            i = concat(aa)(concat(ab)(b))
         } else {
             const { first, tail } = aNode
-            return { first, tail: () => [tail, b] }
+            return { first, tail: concat(tail)(b) }
         }
     }
 }
@@ -79,7 +82,6 @@ const iterable = sequence => ({
     *[Symbol.iterator]() {
         let i = sequence
         while (true) {
-            if (i instanceof Array) { return yield *i }
             const n = next(i)
             if (n === undefined) { return }
             const { first, tail } = n
@@ -95,64 +97,73 @@ const toArray = sequence => {
     return Array.from(iterable(sequence))
 }
 
-/** @type {<I, O>(f: (result: ResultOne<I>) => Node<O>) => (input: Sequence<I>) => Thunk<O>} */
-const nextMap = f => input => () => {
+/** @type {<I, O>(step: (result: ResultOne<I>) => Node<O>) => (input: Sequence<I>) => Thunk<O>} */
+const apply = f => input => () => {
     const n = next(input)
     if (n === undefined) { return undefined }
     return f(n)
 }
 
 /** @type {<T>(result: ResultOne<Sequence<T>>) => Node<T>} */
-const flatFn = ({first, tail}) => [first, flat(tail)]
+const flatStep = ({first, tail}) => [first, flat(tail)]
 
 /** @type {<T>(sequence: Sequence<Sequence<T>>) => Thunk<T>} */
-const flat = nextMap(flatFn)
-
-/** @type {<T>(...array: readonly Sequence<T>[]) => Thunk<T>} */
-const concat = (...array) => flat(array)
+const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (result: ResultOne<I>) => Node<O>} */
-const mapFn = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
+const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
 
 /** @type {<I, O>(f: (value: I) => O) => (input: Sequence<I>) => Thunk<O>} */
-const map = f => nextMap(mapFn(f))
+const map = f => apply(mapStep(f))
 
 /** @type {<I, O>(f: (value: I) => Sequence<O>) => (input: Sequence<I>) => Thunk<O>} */
 const flatMap = f => compose(map(f))(flat)
 
 /** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
-const filterFn = f => ({ first, tail }) => {
+const filterStep = f => ({ first, tail }) => {
     const fTail = filter(f)(tail)
     return f(first) ? { first, tail: fTail } : nodeOne(fTail)
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const filter = f => nextMap(filterFn(f))
+const filter = f => apply(filterStep(f))
 
 /** @type {<I, O>(f: (value: I) => O|undefined) => (result: ResultOne<I>) => Node<O>} */
-const filterMapFn = f => ({first, tail}) => {
+const filterMapStep = f => ({first, tail}) => {
     const fFirst = f(first)
     const fTail = filterMap(f)(tail)
     return fFirst === undefined ? nodeOne(fTail) : { first: fFirst, tail: fTail }
 }
 
 /** @type {<I, O>(f: (value: I) => O|undefined) => (input: Sequence<I>) => Thunk<O>} */
-const filterMap = f => nextMap(filterMapFn(f))
+const filterMap = f => apply(filterMapStep(f))
 
 /** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
-const takeWhileFn = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } :undefined
+const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } :undefined
 
 /** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const takeWhile = f => nextMap(takeWhileFn(f))
+const takeWhile = f => apply(takeWhileStep(f))
+
+/** @type {(n: number) => <T>(result: ResultOne<T>) => Node<T>} */
+const takeStep = n => ({ first, tail }) => 0 < n ? { first, tail: take(n - 1)(tail) } : undefined
+
+/** @type {(n: number) => <T>(result: Sequence<T>) => Sequence<T>} */
+const take = n => apply(takeStep(n))
 
 /** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
-const dropWhileFn = f => result => {
+const dropWhileStep = f => result => {
     const { first, tail } = result
     return f(first) ? nodeOne(dropWhile(f)(tail)) : result
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const dropWhile = f => nextMap(dropWhileFn(f))
+const dropWhile = f => apply(dropWhileStep(f))
+
+/** @type {(n: number) => <T>(result: ResultOne<T>) => Node<T>} */
+const dropFn = n => result => 0 < n ? nodeOne(drop(n - 1)(result.tail)) : result
+
+/** @type {(n: number) => <T>(result: Sequence<T>) => Sequence<T>} */
+const drop = n => apply(dropFn(n))
 
 /** @type {<D>(def: D) => <T>(input: Sequence<T>) => D|T} */
 const first = def => input => {
@@ -180,14 +191,17 @@ const last = def => input => {
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => D|T} */
 const find = def => f => input => first(def)(filter(f)(input))
 
-/** @type {<T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => boolean} */
-const some = f => input => find(false)(x => x)(map(f)(input))
+/** @type {(value: boolean) => boolean} */
+const boolIdentity = identity
 
-/** @type {<T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => boolean} */
-const every = f => input => !some(compose(f)(logicalNot))(input)
+/** @type {(sequence: Sequence<boolean>) => boolean} */
+const some = input => find(false)(boolIdentity)(input)
+
+/** @type {(sequence: Sequence<boolean>) => boolean} */
+const every = input => !some(map(logicalNot)(input))
 
 /** @type {<T>(value: T) => (sequence: Sequence<T>) => boolean} */
-const includes = value => some(strictEqual(value))
+const includes = value => input => some(map(strictEqual(value))(input))
 
 /** @type {(count: number) => Thunk<number>} */
 const countdown = count => () => {
@@ -213,7 +227,7 @@ const scanFn = operator => ({first, tail}) => {
 }
 
 /** @type {<T,A>(operator: ScanOperator<T, A>) => (input: Sequence<T>) => Thunk<A>} */
-const scan = operator => nextMap(scanFn(operator))
+const scan = operator => apply(scanFn(operator))
 
 /** @type {<T,A>(operator: ScanOperator<T, A>) => <D>(def: D)=> (input: Sequence<T>) => D|A} */
 const scanReduce = operator => def => input => last(def)(scan(operator)(input))
@@ -227,10 +241,7 @@ const scanReduce = operator => def => input => last(def)(scan(operator)(input))
 const scanState = operator => init => [init, scanOperator(operator)(init)]
 
 /** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => ScanOperator<T, A>} */
-const scanOperator = operator => init => value => {
-    const result = operator(init)(value)
-    return scanState(operator)(result)
-}
+const scanOperator = operator => init => value => scanState(operator)(operator(init)(value))
 
 /** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => (input: Sequence<T>) => A} */
 const reduce = operator => init => scanReduce(scanOperator(operator)(init))(init)
@@ -245,6 +256,10 @@ const fold = operator => def => scanReduce(scanState(operator))(def)
 
 const sum = fold(addition)(0)
 
+const min = fold(op.min)(undefined)
+
+const max = fold(op.max)(undefined)
+
 /** @type {(separator: string) => (input: Sequence<string>) => string} */
 const join = separator => fold(op.join(separator))('')
 
@@ -271,9 +286,29 @@ const reverseOp = prior => value => sequence(value)(prior)
 /** @type {<T>(input: Sequence<T>) => Sequence<T>} */
 const reverse = reduce(reverseOp)(empty)
 
+/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Thunk<readonly[A, B]>} */
+const zip = a => b => () => {
+    const aResult = next(a)
+    if (aResult === undefined) { return undefined }
+    const bResult = next(b)
+    if (bResult === undefined) { return undefined }
+    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
+}
+
+/** @type {<T>(e: op.EqualOperator<T>) => (a: Sequence<T>) => (b: Sequence<T>) => Thunk<boolean>} */
+const equalZip = e => a => b => () => {
+    const aResult = next(a)
+    const bResult = next(b)
+    if (aResult === undefined || bResult === undefined) {
+        return { first: aResult === bResult, tail: empty }
+    }
+    return { first: e(aResult.first)(bResult.first), tail: equalZip(e)(aResult.tail)(bResult.tail) }
+}
+
+/** @type {<T>(e: op.EqualOperator<T>) => (a: Sequence<T>) => (b: Sequence<T>) => boolean} */
+const equal = e => a => b => every(equalZip(e)(a)(b))
+
 module.exports = {
-    /** @readonly */
-    empty,
     /** @readonly */
     sequence,
     /** @readonly */
@@ -309,9 +344,13 @@ module.exports = {
     /** @readonly */
     takeWhile,
     /** @readonly */
+    take,
+    /** @readonly */
     dropWhile,
     /** @readonly */
-    scanFunc: scanOperator,
+    drop,
+    /** @readonly */
+    scanOperator,
     /** @readonly */
     scanState,
     /** @readonly */
@@ -323,6 +362,10 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
+    min,
+    /** @readonly */
+    max,
+    /** @readonly */
     join,
     /** @readonly */
     entries,
@@ -331,5 +374,9 @@ module.exports = {
     /** @readonly */
     reverse,
     /** @readonly */
-    countdown,
+    zip,
+    /** @readonly */
+    equal,
+    /** @readonly */
+    countdown,    
 }

package/{sequence → types/sequence}/test.js

@@ -1,9 +1,9 @@
 const _ = require('.')
-const json = require('../json')
+const json = require('../../json')
 const { sort } = require('../object')
-const { addition } = require('../function/operator')
+const { addition, strictEqual } = require('../function/operator')
 
-/** @type {(sequence: _.Sequence<json.Json>) => string} */
+/** @type {(sequence: _.Sequence<json.Unknown>) => string} */
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 {
@@ -17,13 +17,15 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 }
 
 {
-    const result = stringify(_.concat([1, 2, 3], [4, 5], [6], [], [7, 8, 9]))
+    const result = stringify(_.flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]))
     if (result !== '[1,2,3,4,5,6,7,8,9]') { throw result }
 }
 
 {
-    const result = _.concat([1], [2])
+    const result = _.concat([1])([2])
     const x = _.next(result)
+    if (x === undefined) { throw x }
+    if (x.first !== 1) { throw x }
 }
 
 {
@@ -36,6 +38,21 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== '[1,2,3,4,5]') { throw result }
 }
 
+{
+    const result = stringify(_.take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
+    if (result !== '[1,2,3]') { throw result }
+}
+
+{
+    const result = stringify(_.take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
+    if (result !== '[1,2,3,4,5,6,7,8,9]') { throw result }
+}
+
+{
+    const result = stringify(_.take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
+    if (result !== '[]') { throw result }
+}
+
 {
     const result = _.find(undefined)(x => x % 2 === 0)([1, 2, 3, 4])
     if (result !== 2) { throw result }
@@ -51,6 +68,21 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== '[10,11]') { throw result }
 }
 
+{
+    const result = stringify(_.drop(3)([1, 2, 3, 4, 5, 10, 11]))
+    if (result !== '[4,5,10,11]') { throw result }
+}
+
+{
+    const result = stringify(_.drop(0)([1, 2, 3, 4, 5, 10, 11]))
+    if (result !== '[1,2,3,4,5,10,11]') { throw result }
+}
+
+{
+    const result = stringify(_.drop(10)([1, 2, 3, 4, 5, 10, 11]))
+    if (result !== '[]') { throw result }
+}
+
 {
     const op = _.scanState(addition)
     const result = stringify(_.scan(op)([2, 3, 4, 5]))
@@ -102,6 +134,81 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== '[5,4,3,2,1]') { throw result }
 }
 
+{
+    const result = stringify(_.zip([0, 1, 2])(['a', 'b', 'c', 'd']))
+    if (result !== '[[0,"a"],[1,"b"],[2,"c"]]') { throw result }
+}
+
+{
+    const result = stringify(_.zip([0, 1, 2])(['a', 'b']))
+    if (result !== '[[0,"a"],[1,"b"]]') { throw result }
+}
+
+{
+    const result = _.some(_.map(x => x > 5)([0, 1, 7]))
+    if (!result) { throw result}
+}
+
+{
+    const result = _.some(_.map(x => x > 5)([0, 1, 4]))
+    if (result) { throw result }
+}
+
+{
+    const result = _.some(_.map(x => x > 5)([]))
+    if (result) { throw result }
+}
+
+{
+    const result = _.every(_.map(x => x > 5)([0, 1, 7]))
+    if (result) { throw result }
+}
+
+{
+    const result = _.every(_.map(x => x > 5)([6, 11, 7]))
+    if (!result) { throw result }
+}
+
+{
+    const result = _.every(_.map(x => x > 5)([]))
+    if (!result) { throw result }
+}
+
+{
+    const result = _.equal(strictEqual)([1])([2, 3])
+    if (result) { throw result}
+}
+
+{
+    const result = _.equal(strictEqual)([1, 3])([1])
+    if (result) { throw result }
+}
+
+{
+    const result = _.equal(strictEqual)([15, 78])([15, 78])
+    if (!result) { throw result }
+}
+
+{
+    const result = _.equal(strictEqual)([])([])
+    if (!result) { throw result }
+}
+
+{
+    const result = _.min([])
+    if (result !== undefined) { throw result }
+}
+
+{
+    const result = _.min([1, 2, 12, -4, 8])
+    if (result !== -4) { throw result }
+}
+
+{
+    const result = _.max([1, 2, 12, -4, 8])
+    if (result !== 12) { throw result }
+}
+
 // stress tests
 
 const stress = () => {
@@ -129,9 +236,19 @@ const stress = () => {
     {
         /** @type {_.Sequence<number>} */
         let sequence = []
-        // 2_000_000 is too much
-        for (let i = 0; i < 1_000_000; ++i) {
-            sequence = _.concat(sequence, [i])
+        // 10_000_000 is too much
+        for (let i = 0; i < 5_000_000; ++i) {
+            sequence = _.concat(sequence)([i])
+        }
+        const r = _.toArray(sequence)
+    }
+
+    {
+        /** @type {_.Sequence<number>} */
+        let sequence = []
+        // 4_000_000 is too much
+        for (let i = 0; i < 2_000_000; ++i) {
+            sequence = _.flat([sequence, [i]])
         }
         const r = _.toArray(sequence)
     }
@@ -141,7 +258,17 @@ const stress = () => {
         let sequence = []
         // 5_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
-            sequence = _.concat(sequence, [i])
+            sequence = _.flat([sequence, [i]])
+        }
+        const a = _.next(sequence)
+    }
+
+    {
+        /** @type {_.Sequence<number>} */
+        let sequence = []
+        // 20_000_000 is too much
+        for (let i = 0; i < 10_000_000; ++i) {
+            sequence = _.concat([i])(sequence)
         }
         const a = _.next(sequence)
     }
@@ -151,7 +278,7 @@ const stress = () => {
         let sequence = []
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {
-            sequence = _.concat([i], sequence)
+            sequence = _.flat([[i], sequence])
         }
         const a = _.next(sequence)
     }
@@ -183,4 +310,4 @@ const stress = () => {
 
 module.exports = {
 
-}
+}

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: [] }
-}