functionalscript 0.43.1 → 0.45.0

package/fjs/bnf/testlib.f.mjs

@@ -0,0 +1,196 @@
+/**
+ * @module
+ *
+ * @import { Rule } from './types.ts'
+ */
+
+import {
+    commaJoin0Plus,
+    none,
+    option,
+    range,
+    remove,
+    repeat,
+    repeat0Plus,
+    set,
+    unicodeMax,
+} from './module.f.mjs'
+
+/** @type {() => Rule} */
+export const classic = () => {
+
+    // https://www.json.org/json-en.html
+
+    const json = () => [element]
+
+    const value = () => ({
+        object,
+        array,
+        string,
+        number,
+        true: 'true',
+        false: 'false',
+        null: 'null'
+    })
+
+    const object = () => ({
+        ws: ['{', ws, '}'],
+        members: ['{', members, '}'],
+    })
+
+    const members = () => ({
+        member,
+        members: [member, ',', members],
+    })
+
+    const member = () => [ws, string, ws, ':', element]
+
+    const array = () => ({
+        ws: ['[', ws, ']'],
+        elements: ['[', elements, ']'],
+    })
+
+    const elements = () => ({
+        element,
+        elements: [element, ',', elements],
+    })
+
+    const element = () => [ws, value, ws]
+
+    const string = () => ['"', characters, '"']
+
+    const characters = () => ({
+        none,
+        characters: [character, characters],
+    })
+
+    /** @type {Rule} */
+    const character = () => ({
+        0: 0x20_000021,
+        1: 0x23_00005B,
+        2: 0x5D_10FFFF,
+        escape: ['\\', escape],
+    })
+
+    const escape = () => ({
+        ...set('"\\/bfnrt'),
+        u: ['u', hex, hex, hex, hex],
+    })
+
+    const hex = () => ({
+        digit,
+        AF: range('AF'),
+        af: range('af'),
+    })
+
+    const number = () => [integer, fraction, exponent]
+
+    const integer = () => ({
+        digit,
+        onenine: [onenine, digits],
+        negDigit: ['-', digit],
+        negOnenine: ['-', onenine, digits],
+    })
+
+    const digits = () => ({
+        digit,
+        digits: [digit, digits],
+    })
+
+    /** @type {Rule} */
+    const digit = () => ({
+        '0': '0',
+        onenine,
+    })
+
+    const onenine = range('19')
+
+    const fraction = () => ({
+        none,
+        digits: ['.', digits],
+    })
+
+    const exponent = () => ({
+        none,
+        E: ['E', sign, digits],
+        e: ['e', sign, digits],
+    })
+
+    const sign = {
+        none,
+        ...set('+-'),
+    }
+
+    const ws = () => ({
+        none,
+        ' ': [' ', ws],
+        '\n': ['\n', ws],
+        '\r': ['\r', ws],
+        '\t': ['\t', ws],
+    })
+
+    return json
+}
+
+/** @type {() => Rule} */
+export const deterministic = () => {
+
+    const onenine = range('19')
+
+    /** @type {Rule} */
+    const digit = range('09')
+
+    const string = [
+        '"',
+        repeat0Plus({
+            ...remove(range(` ${unicodeMax}`), set('"\\')),
+            escape: [
+                '\\',
+                {
+                    ...set('"\\/bfnrt'),
+                    u: [
+                        'u',
+                        ...repeat(4)({
+                            digit,
+                            AF: range('AF'),
+                            af: range('af'),
+                        })
+                    ],
+                }
+            ],
+        }),
+        '"'
+    ]
+
+    const digits0 = repeat0Plus(digit)
+
+    const digits = [digit, digits0]
+
+    const number = [
+        option('-'),
+        {
+            0: '0',
+            onenine: [onenine, digits0],
+        },
+        option(['.', digits]),
+        option([set('Ee'), option(set('+-')), digits])
+    ]
+
+    const ws = repeat0Plus(set(' \n\r\t'))
+
+    const cj = commaJoin0Plus(ws)
+
+    const value = () => ({
+        array: cj('[]', value),
+        object: cj('{}', [string, ws, ':', ws, value]),
+        string,
+        number,
+        true: 'true',
+        false: 'false',
+        null: 'null'
+    })
+
+    const json = [ws, value, ws]
+
+    return json
+}

package/fjs/bnf/token_symbol/module.f.d.mts

@@ -0,0 +1,36 @@
+/**
+ * Encoding of multi-character token names as single BNF input symbols.
+ *
+ * A parser built on top of a tokenizer consumes one input symbol per token, so
+ * multi-character operators (`>>>=`) and keywords (`instanceof`) each need a
+ * symbol of their own. Names are registered as one fixed alphabet and get a
+ * symbol from their position in it, above the Unicode range and up to the last
+ * ordinary symbol.
+ *
+ * See `./types.ts` for the `Encoding<T>` type-level API.
+ *
+ * @module
+ *
+ * @import { Encoding } from './types.ts'
+ */
+import type { Encoding } from './types.ts';
+/**
+ * How many names one encoding holds: every symbol from {@link start} up to and
+ * including the last ordinary symbol (`0xFFFFFE`, the top of `fullRange`).
+ *
+ * @type {number}
+ */
+export declare const capacity: number;
+/**
+ * Builds an encoding over the complete list of token names.
+ *
+ * A name takes the symbol at its index in `names`, so the list is append-only:
+ * inserting or reordering names changes the symbols of everything after the
+ * edit.
+ *
+ * @throws When `names` holds more than {@link capacity} entries, or when a name
+ * repeats — a repeated name has no single symbol to decode back to.
+ *
+ * @type {<T extends string>(names: readonly T[]) => Encoding<T>}
+ */
+export declare const encoding: <T extends string>(names: readonly T[]) => Encoding<T>;

package/fjs/bnf/token_symbol/module.f.mjs

@@ -0,0 +1,63 @@
+/**
+ * Encoding of multi-character token names as single BNF input symbols.
+ *
+ * A parser built on top of a tokenizer consumes one input symbol per token, so
+ * multi-character operators (`>>>=`) and keywords (`instanceof`) each need a
+ * symbol of their own. Names are registered as one fixed alphabet and get a
+ * symbol from their position in it, above the Unicode range and up to the last
+ * ordinary symbol.
+ *
+ * See `./types.ts` for the `Encoding<T>` type-level API.
+ *
+ * @module
+ *
+ * @import { Encoding } from './types.ts'
+ */
+
+import { assert } from '../../asserts/module.f.mjs'
+import { fromUndefined } from '../../types/nullable/module.f.mjs'
+import { fullRange, rangeDecode, unicodeRange } from '../module.f.mjs'
+
+const [, unicodeLast] = rangeDecode(unicodeRange)
+
+const [, lastOrdinary] = rangeDecode(fullRange)
+
+/**
+ * The symbol of the first registered name: `0x110000`, one past the last
+ * Unicode scalar value, so a token symbol can never be mistaken for a code
+ * point of the layer below.
+ */
+const start = unicodeLast + 1
+
+/**
+ * How many names one encoding holds: every symbol from {@link start} up to and
+ * including the last ordinary symbol (`0xFFFFFE`, the top of `fullRange`).
+ *
+ * @type {number}
+ */
+export const capacity = lastOrdinary - start + 1
+
+/**
+ * Builds an encoding over the complete list of token names.
+ *
+ * A name takes the symbol at its index in `names`, so the list is append-only:
+ * inserting or reordering names changes the symbols of everything after the
+ * edit.
+ *
+ * @throws When `names` holds more than {@link capacity} entries, or when a name
+ * repeats — a repeated name has no single symbol to decode back to.
+ *
+ * @type {<T extends string>(names: readonly T[]) => Encoding<T>}
+ */
+export const encoding = names => {
+    assert(names.length <= capacity, ['too many token names', names.length])
+    assert(new Set(names).size === names.length, ['duplicate token name', names])
+    return {
+        encode: name => {
+            const index = names.indexOf(name)
+            assert(index !== -1, ['unregistered token name', name])
+            return start + index
+        },
+        decode: symbol => fromUndefined(names[symbol - start]),
+    }
+}

package/fjs/bnf/token_symbol/proof.f.mjs

@@ -0,0 +1,46 @@
+import { assertEq } from '../../asserts/module.f.mjs'
+import { eofSymbol } from '../module.f.mjs'
+import { capacity, encoding } from './module.f.mjs'
+
+const names = /** @type {const} */ (['>>', '>>>=', 'instanceof'])
+
+export const proof = {
+    encode: () => {
+        const { encode } = encoding(names)
+        assertEq(encode('>>'), 0x110000)
+        assertEq(encode('instanceof'), 0x110002)
+    },
+    decode: [
+        () => {
+            const { decode } = encoding(names)
+            assertEq(decode(0x110000), '>>')
+            assertEq(decode(0x110002), 'instanceof')
+        },
+        () => {
+            const { decode } = encoding(names)
+            // past the end of the alphabet, a code point, the last ordinary
+            // symbol, and `eof`
+            assertEq(decode(0x110003), null)
+            assertEq(decode(0x10FFFF), null)
+            assertEq(decode(0xFFFFFE), null)
+            assertEq(decode(eofSymbol), null)
+        },
+    ],
+    roundTrip: () => {
+        const { encode, decode } = encoding(names)
+        for (const name of names) {
+            assertEq(decode(encode(name)), name)
+        }
+    },
+    throw: {
+        duplicateName: () => { encoding(['a', 'b', 'a']) },
+        unregisteredName: () => {
+            /** @type {readonly string[]} */
+            const names = ['a']
+            encoding(names).encode('b')
+        },
+        // `capacity` names fit, so one more is the smallest list that doesn't.
+        // The array is sparse, so this costs a length, not the strings.
+        tooManyNames: () => { encoding(new Array(capacity + 1)) },
+    },
+}

package/fjs/bnf/token_symbol/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Types for encoding multi-character token names as single BNF input symbols.
+ *
+ * @module
+ */
+import type { Nullable } from '../../types/nullable/types.ts';
+/**
+ * A bidirectional map between a fixed alphabet of token names and the symbol
+ * range reserved for them.
+ */
+export type Encoding<T extends string> = {
+    /**
+     * The input symbol standing for `name`.
+     *
+     * The result is a bare symbol, the form a tokenizer emits. Wrap it in
+     * `oneEncode` to use it as a terminal of a grammar rule — a symbol and a
+     * `TerminalRange` are both plain numbers, so passing one where the other
+     * belongs is not a type error.
+     */
+    readonly encode: (name: T) => number;
+    /**
+     * The name a symbol stands for, or `null` when the symbol belongs to no
+     * registered name — a code point, the `eof` symbol, or a symbol past the
+     * end of the alphabet.
+     */
+    readonly decode: (symbol: number) => Nullable<T>;
+};

package/fjs/bnf/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Type-level API for BNF grammar primitives and helpers.
+ *
+ * @module
+ */
+import type { StringMap } from '../types/object/types.ts';
+/**
+ * A range of symbols. Two 24-bit endpoint codes are stored in one JS number
+ * (48 bits).
+ *
+ * For example: 0xBBBBBB_EEEEEE
+ * - 0xBBBBBB is the first endpoint's stored code (24 bits)
+ * - 0xEEEEEE is the last endpoint's stored code (24 bits)
+ *
+ * A stored code is not the semantic terminal value: the semantic domain is
+ * `[-1] | [0, 2 ** 24 - 2]` — EOF plus every ordinary symbol — and EOF's code
+ * is `0xFFFFFF`, the top of the stored space. `rangeEncode` / `rangeDecode` in
+ * `./module.f.mjs` convert between the two, and everything that compares
+ * terminals compares decoded values.
+ *
+ * 24 bits per half, not 26 (the most `float64`'s 52-bit safe-integer mantissa
+ * could fit two of): 24 is divisible by 4, so each half is exactly 6 hex
+ * digits, and the packed pair reads as a plain `0xYYYYYY_ZZZZZZ` literal with
+ * no partial hex digit at either boundary. 26 bits would still be safe to
+ * store but wouldn't align to hex nibbles, making the packed literal harder
+ * to read and split by eye.
+ *
+ * Not 16 bits (32 bits total) either, even though a 32-bit pair would fit in
+ * a JS bitwise operator's native 32-bit range (JS `|`/`&`/`<<`/etc. operate on
+ * 32-bit ints, whereas the 48-bit pair used here, and even a 52-bit one,
+ * would need converting to `BigInt` for bitwise operations). 16 bits per
+ * symbol can't hold a full Unicode code point: the max scalar value `0x10FFFF`
+ * needs 21 bits, well past `0xFFFF`. So the bitwise-op convenience of 16 loses
+ * to the requirement of representing every Unicode code point in one half.
+ */
+export type TerminalRange = number;
+/** A sequence of rules. */
+export type Sequence = readonly Rule[];
+/** A variant */
+export type Variant = {
+    readonly [k in string]?: Rule;
+};
+/**
+ * Data-only grammar rule.
+ */
+export type DataRule = Variant | Sequence | TerminalRange | string;
+/**
+ * Lazily evaluated grammar rule.
+ */
+export type LazyRule = () => DataRule;
+/**
+ * Grammar rule, either immediate data or lazy rule factory.
+ */
+export type Rule = DataRule | LazyRule;
+/**
+ * A set of terminal ranges compatible with the `Variant` rule.
+ */
+export type RangeVariant = StringMap<TerminalRange>;
+/**
+ * Empty sequence type for optional grammar branches.
+ */
+export type None = readonly [];
+/**
+ * Optional grammar branch.
+ */
+export type Option<S> = {
+    some: S;
+    none: None;
+};
+export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;
+export type Repeat1Plus<T> = readonly [T, Repeat0Plus<T>];
+export type Join1Plus<T, S> = readonly [T, Repeat0Plus<readonly [S, T]>];
+export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>;
+export type Repeat<T> = readonly T[];

package/fjs/cas/cli/module.f.d.mts

@@ -0,0 +1,17 @@
+/**
+ * CAS CLI command handlers.
+ *
+ * @module
+ *
+ * @import { All, Read, Write, WriteFile } from '../../effects/node/types.ts'
+ * @import { Commands } from '../../cli/types.ts'
+ * @import { MemOp } from '../../effects/memory/types.ts'
+ * @import { FileCasOperation } from '../types.ts'
+ */
+import type { All, Read, Write, WriteFile } from '../../effects/node/types.ts';
+import type { Commands } from '../../cli/types.ts';
+import type { MemOp } from '../../effects/memory/types.ts';
+import type { FileCasOperation } from '../types.ts';
+/** @type {Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>} */
+export declare const commands: Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>;
+export declare const main: (options: import("../../effects/node/types.ts").NodeProgramOptions) => import("../../effects/types.ts").Effect<All | Read | Write | WriteFile | FileCasOperation | MemOp, number>;

package/fjs/cas/cli/module.f.mjs

@@ -0,0 +1,73 @@
+/**
+ * CAS CLI command handlers.
+ *
+ * @module
+ *
+ * @import { All, Read, Write, WriteFile } from '../../effects/node/types.ts'
+ * @import { Commands } from '../../cli/types.ts'
+ * @import { MemOp } from '../../effects/memory/types.ts'
+ * @import { FileCasOperation } from '../types.ts'
+ */
+
+import { sha256 } from '../../crypto/sha2/module.f.mjs'
+import { cBase32ToVec, vecToCBase32 } from '../../basen/cbase32/module.f.mjs'
+import { forEachStep, pure, step } from '../../effects/module.f.mjs'
+import { errorExit, log, writeFromStream } from '../../effects/node/module.f.mjs'
+import { dispatch } from '../../cli/module.f.mjs'
+import { casAddFile, fileCas } from '../module.f.mjs'
+
+/** @type {Commands<FileCasOperation | WriteFile | Write | All | MemOp | Read>} */
+export const commands = [
+    {
+        names: ['add'],
+        description: 'Store file content and print its hash',
+        handler: ({ home, args: [path, ...rest] }) => {
+            if (path === undefined || rest.length !== 0) {
+                return errorExit("'cas add' expects one parameter")
+            }
+            const c = fileCas(sha256)(home)
+            return step(
+                casAddFile(c)(path),
+                hashResult => hashResult[0] === 'error'
+                    ? pure(1)
+                    : step(
+                        log(vecToCBase32(hashResult[1])),
+                        () => pure(0)
+                    )
+            )
+        },
+    },
+    {
+        names: ['get'],
+        description: 'Restore content by hash into a file',
+        handler: ({ home, args: [hashCBase32, path, ...rest] }) => {
+            if (hashCBase32 === undefined || path === undefined || rest.length !== 0) {
+                return errorExit("'cas get' expects two parameters")
+            }
+            const hash = cBase32ToVec(hashCBase32)
+            if (hash === null) {
+                return errorExit(`invalid hash format: ${hashCBase32}`)
+            }
+            const c = fileCas(sha256)(home)
+            const x = c.read(hash)
+            return step(
+                writeFromStream(path, x),
+                ([r, v]) => r === 'error' ? errorExit(`e: ` + String(v)) : pure(0),
+            )
+        },
+    },
+    {
+        names: ['list'],
+        description: 'List all stored content hashes',
+        handler: ({ home }) => {
+            const c = fileCas(sha256)(home)
+            const x0 = forEachStep(c.list(), j => log(vecToCBase32(j)))
+            return step(
+                x0,
+                () => pure(0)
+            )
+        },
+    },
+]
+
+export const main = dispatch(commands)

package/fjs/cas/cli/proof.f.d.mts

@@ -0,0 +1,20 @@
+/**
+ * @import { NodeProgramOptions } from '../../effects/node/types.ts'
+ */
+export declare const proof: {
+    mainAdd: () => void;
+    mainAddGetBig: () => void;
+    mainAddWrongArgs: () => void;
+    mainAddMissingFile: () => void;
+    mainGetFound: () => void;
+    mainGetNotFound: () => void;
+    mainGetWrongArgs: () => void;
+    mainGetInvalidHash: () => void;
+    mainList: () => void;
+    mainListEmptyStore: () => void;
+    mainNoCmd: () => void;
+    mainUnknownCmd: () => void;
+    throw: {
+        mainListCorruptStore: () => readonly [import("../../effects/node/virtual/types.ts").State, number];
+    };
+};

package/fjs/cas/cli/proof.f.mjs

@@ -0,0 +1,120 @@
+/**
+ * @import { NodeProgramOptions } from '../../effects/node/types.ts'
+ */
+
+import { commands } from './module.f.mjs'
+import { computeSync, sha256 } from '../../crypto/sha2/module.f.mjs'
+import { maxLength, vec, vec8 } from '../../types/bit_vec/module.f.mjs'
+import { defaultNodeProgramOptions, emptyState, virtual } from '../../effects/node/virtual/module.f.mjs'
+import { dispatch } from '../../cli/module.f.mjs'
+import { vecToCBase32 } from '../../basen/cbase32/module.f.mjs'
+import { assert, assertEq } from '../../asserts/module.f.mjs'
+
+/** @type {(args: readonly string[]) => NodeProgramOptions} */
+const makeOptions = args =>
+    ({ ...defaultNodeProgramOptions, args })
+
+const main = dispatch(commands)
+
+export const proof = {
+    mainAdd: () => {
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        assertEq(exitCode, 0, ['expected exit 0', exitCode])
+        assert(finalState.stdout.length !== 0, 'expected hash in stdout')
+    },
+    mainAddGetBig: () => {
+        const chunk = vec(maxLength)(1n)
+        const content = [chunk, chunk]
+        const state = { ...emptyState, root: { myfile: content } }
+        //
+        const [finalState, exitCode] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        assertEq(exitCode, 0)
+        const stdout = finalState.stdout
+        assert(stdout.length !== 0)
+        //
+        const h = computeSync(sha256)(content)
+        const hs = vecToCBase32(h)
+        assertEq(stdout, `${hs}\n`)
+        //
+        const [finalState2, exitCode2] = virtual(finalState)(main(makeOptions(['get', hs, 'myfile2'])))
+        // console.log(finalState2.stderr)
+        assertEq(exitCode2, 0, 'e2')
+        const { myfile2 } = finalState2.root
+        assert(myfile2 instanceof Array)
+        const h2 = computeSync(sha256)(myfile2)
+        assertEq(h, h2, 'h')
+    },
+    mainAddWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['add'])))
+        assertEq(exitCode, 1)
+        assert(finalState.stderr.length !== 0)
+    },
+    mainAddMissingFile: () => {
+        // The source path doesn't exist, so `streamFile`'s first read comes back as an
+        // error item; `write` fails closed with that error and the handler exits 1
+        // without ever calling `log` — covers the `hashResult[0] === 'error'` branch.
+        const [, exitCode] = virtual(emptyState)(main(makeOptions(['add', 'missing'])))
+        assertEq(exitCode, 1)
+    },
+    mainGetFound: () => {
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [state1, exitCode1] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        assertEq(exitCode1, 0, ['expected add exit 0', exitCode1])
+        const hashStr = state1.stdout.trim()
+        const [, exitCode2] = virtual(state1)(main(makeOptions(['get', hashStr, 'output'])))
+        assertEq(exitCode2, 0, ['expected get exit 0', exitCode2])
+    },
+    mainGetNotFound: () => {
+        // valid cBase32 hash that has not been stored
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        const hashStr = state1.stdout.trim()
+        // use an empty store so the hash is not found
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', hashStr, 'output'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainGetWrongArgs: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainGetInvalidHash: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['get', 'not-a-valid-hash', 'output'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainList: () => {
+        const content = vec8(0x2An)
+        const state = { ...emptyState, root: { myfile: [content] } }
+        const [state1] = virtual(state)(main(makeOptions(['add', 'myfile'])))
+        const [, exitCode] = virtual(state1)(main(makeOptions(['list'])))
+        assertEq(exitCode, 0, ['expected exit 0', exitCode])
+    },
+    mainListEmptyStore: () => {
+        // A fresh directory has no `.cas` yet; listing must succeed (empty),
+        // not crash unwrapping a readdir ENOENT.
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['list'])))
+        assertEq(exitCode, 0, ['expected exit 0', exitCode])
+        assertEq(finalState.stdout, '', ['expected empty stdout', finalState.stdout])
+    },
+    mainNoCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions([])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    mainUnknownCmd: () => {
+        const [finalState, exitCode] = virtual(emptyState)(main(makeOptions(['bogus'])))
+        assertEq(exitCode, 1, ['expected exit 1', exitCode])
+        assert(finalState.stderr.length !== 0, 'expected error in stderr')
+    },
+    throw: {
+        // `.cas` exists but is a file, not a directory: a real storage error
+        // that must surface, not be masked as an empty list.
+        mainListCorruptStore: () => virtual({ ...emptyState, root: { '.cas': [vec8(0x2An)] } })(main(makeOptions(['list']))),
+    },
+}