functionalscript 0.37.0 → 0.39.0

package/fs/cas/proof.f.js

@@ -1,294 +0,0 @@
-import { length, maxLength, msb, vec, vec8 } from '../types/bit_vec/module.f.js';
-import { cBase32ToVec, vecToCBase32 } from '../basen/cbase32/module.f.js';
-import { computeSync, sha256 } from '../crypto/sha2/module.f.js';
-import { fileCas, casAddFile, casUpload } from './module.f.js';
-import { pure } from '../effects/module.f.js';
-import { mkdir, writeFile, rm, readFile, access } from '../effects/node/module.f.js';
-import { error, ok } from '../types/result/module.f.js';
-import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
-import { join } from '../path/module.f.js';
-import { nonEmpty, empty } from '../effects/list/module.f.js';
-const testDir = './test-cas-cli';
-// Create a 128 KiB big file content (at the max Vec size limit)
-// This tests the boundary where files are at the chunk size limit
-const createBigFileContent = () => {
-    const byteCount = 128n * 1024n; // 128 KiB
-    // Create a repeating pattern: 0x42 repeated across the file
-    return vec(byteCount * 8n)(0x42424242n);
-};
-// Test adding a big file and verifying the hash
-const testAddBigFile = () => mkdir(testDir, { recursive: true }).step(() => {
-    const bigContent = createBigFileContent();
-    const bigFilePath = `${testDir}/big-file.bin`;
-    return writeFile(bigFilePath, bigContent).step(writeRes => {
-        if (writeRes[0] === 'error') {
-            throw new Error(`Failed to write test file: ${writeRes[1]}`);
-        }
-        const cas = fileCas(sha256)(testDir);
-        return casAddFile(cas)(bigFilePath).step(addRes => {
-            if (addRes[0] === 'error') {
-                throw new Error(`Failed to add file to CAS: ${addRes[1]}`);
-            }
-            const hash = addRes[1];
-            // Verify hash is 256 bits (SHA-256)
-            if (length(hash) !== 256n) {
-                throw new Error(`Expected hash length 256 bits, got ${length(hash)}`);
-            }
-            // Verify hash can be encoded/decoded
-            const hashCBase32 = vecToCBase32(hash);
-            const decodedHash = cBase32ToVec(hashCBase32);
-            if (decodedHash === null) {
-                throw new Error('Failed to decode hash from base32');
-            }
-            return rm(testDir).step(() => pure(undefined));
-        });
-    });
-});
-// Test adding and retrieving a big file
-const testAddAndGetBigFile = () => mkdir(testDir, { recursive: true })
-    .step(() => {
-    const bigContent = createBigFileContent();
-    const bigFilePath = `${testDir}/big-file.bin`;
-    return writeFile(bigFilePath, bigContent)
-        .step(writeRes => {
-        if (writeRes[0] === 'error') {
-            throw new Error(`Failed to write test file: ${writeRes[1]}`);
-        }
-        const cas = fileCas(sha256)(testDir);
-        return casAddFile(cas)(bigFilePath)
-            .step(addRes => {
-            if (addRes[0] === 'error') {
-                throw new Error(`Failed to add file to CAS: ${addRes[1]}`);
-            }
-            const hash = addRes[1];
-            const storedPath = cas.url(hash);
-            // Verify file is stored at the expected location
-            return readFile(storedPath).step(readRes => {
-                if (readRes[0] === 'error') {
-                    throw new Error(`Failed to read stored file: ${readRes[1]}`);
-                }
-                const storedContent = readRes[1];
-                // Verify content is the same size as original
-                const storedLen = length(storedContent);
-                const originalLen = length(bigContent);
-                if (storedLen !== originalLen) {
-                    throw new Error(`Content size mismatch: stored ${storedLen} bits, expected ${originalLen} bits`);
-                }
-                return rm(testDir).step(() => pure(undefined));
-            });
-        });
-    });
-});
-export const proof = {
-    addBigFile: testAddBigFile,
-    addAndGetBigFile: testAddAndGetBigFile,
-    //
-    casWriteRead: () => {
-        // Round-trip a single-chunk payload through the real streaming CAS: `write` returns
-        // the content hash, and `read` streams the same bytes back as `ok` chunk items.
-        const content = vec8(0x2an);
-        const c = fileCas(sha256)('.');
-        const payload = nonEmpty(ok(content), empty());
-        const [state1, writeResult] = virtual(emptyState)(c.write(payload));
-        if (writeResult[0] !== 'ok') {
-            throw ['expected write ok', writeResult];
-        }
-        const hash = writeResult[1];
-        if (length(hash) !== 256n) {
-            throw ['expected 256-bit hash', length(hash)];
-        }
-        if (msb.cmp(hash)(computeSync(sha256)([content])) !== 0) {
-            throw 'write hash mismatch';
-        }
-        const drain = (acc) => (stream) => stream.step((node) => {
-            if (node === undefined) {
-                return pure(ok(acc));
-            }
-            const { first, tail } = node;
-            if (first[0] === 'error') {
-                return pure(first);
-            }
-            return drain([...acc, first[1]])(tail);
-        });
-        const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
-        if (readResult[0] !== 'ok') {
-            throw ['expected read ok', readResult];
-        }
-        if (msb.cmp(msb.listToVec(readResult[1]))(content) !== 0) {
-            throw 'read content mismatch';
-        }
-    },
-    casReadMissingShard: () => {
-        // A missing shard surfaces as an explicit error *item*, never as end-of-stream.
-        const c = fileCas(sha256)('.');
-        const hash = computeSync(sha256)([vec8(0x2an)]);
-        const node = virtual(emptyState)(c.read(hash))[1];
-        if (node === undefined) {
-            throw 'missing shard must not be EOF';
-        }
-        if (node.first[0] !== 'error') {
-            throw ['expected error item', node.tail];
-        }
-    },
-    casWriteMultiChunk: () => {
-        // A multi-chunk payload streams through `writeBytes` chunk-by-chunk (the lease is
-        // renewed between chunks); the hash equals the SHA-256 of the concatenated bytes,
-        // and read streams the same content back.
-        const chunks = [vec8(0x11n), vec8(0x22n), vec8(0x33n)];
-        const c = fileCas(sha256)('.');
-        const payload = chunks.reduceRight((tail, chunk) => nonEmpty(ok(chunk), tail), empty());
-        const [state1, writeResult] = virtual(emptyState)(c.write(payload));
-        if (writeResult[0] !== 'ok') {
-            throw ['expected write ok', writeResult];
-        }
-        const hash = writeResult[1];
-        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
-            throw 'multi-chunk write hash mismatch';
-        }
-        const drain = (acc) => (stream) => stream.step((node) => {
-            if (node === undefined) {
-                return pure(ok(acc));
-            }
-            const { first, tail } = node;
-            if (first[0] === 'error') {
-                return pure(first);
-            }
-            return drain([...acc, first[1]])(tail);
-        });
-        const [, readResult] = virtual(state1)(drain([])(c.read(hash)));
-        if (readResult[0] !== 'ok') {
-            throw ['expected read ok', readResult];
-        }
-        const expected = msb.concat(msb.concat(chunks[0])(chunks[1]))(chunks[2]);
-        if (msb.cmp(msb.listToVec(readResult[1]))(expected) !== 0) {
-            throw 'multi-chunk read content mismatch';
-        }
-    },
-    casWriteDedup: () => {
-        // Same content ⇒ same hash; the second upload's replace-`rename` publishes over the
-        // first, leaving exactly one shard in the store.
-        const content = vec8(0x2an);
-        const c = fileCas(sha256)('.');
-        const payload = () => nonEmpty(ok(content), empty());
-        const [state1, w1] = virtual(emptyState)(c.write(payload()));
-        const [state2, w2] = virtual(state1)(c.write(payload()));
-        if (w1[0] !== 'ok' || w2[0] !== 'ok') {
-            throw ['expected both writes ok', w1, w2];
-        }
-        if (msb.cmp(w1[1])(w2[1]) !== 0) {
-            throw 'dedup hash mismatch';
-        }
-        const [, hashes] = virtual(state2)(c.list());
-        if (hashes.length !== 1) {
-            throw ['expected one shard after dedup', hashes.length];
-        }
-    },
-    casWriteErrorItemAborts: () => {
-        // An error item mid-stream deletes the partial staging file and fails; nothing is
-        // published, so the store stays empty.
-        const c = fileCas(sha256)('.');
-        const okItem = ok(vec8(0x11n));
-        const errItem = error({ code: 'BOOM' });
-        const payload = nonEmpty(okItem, nonEmpty(errItem, empty()));
-        const [state1, result] = virtual(emptyState)(c.write(payload));
-        if (result[0] !== 'error') {
-            throw ['expected write error', result];
-        }
-        const [, hashes] = virtual(state1)(c.list());
-        if (hashes.length !== 0) {
-            throw ['expected nothing published on abort', hashes];
-        }
-    },
-    casWriteReadExceedsMaxLength: () => {
-        // The point of streaming: a payload larger than a single `Vec`'s `maxLength`
-        // (128 KiB) must round-trip. `write` lands the chunks on disk without ever
-        // holding them as one `Vec`, and `read` streams them back the same way — so the
-        // round-trip is verified by hashing the read stream incrementally rather than
-        // concatenating it (which would itself overflow `maxLength`).
-        const big = vec(maxLength)(0xabn); // one full-size chunk: exactly maxLength bits
-        const tail = vec8(0x2an); // one more byte ⇒ total > maxLength
-        const chunks = [big, tail];
-        const c = fileCas(sha256)('.');
-        const payload = chunks.reduceRight((tl, chunk) => nonEmpty(ok(chunk), tl), empty());
-        const [state1, w] = virtual(emptyState)(c.write(payload));
-        if (w[0] !== 'ok') {
-            throw ['expected write ok', w];
-        }
-        const hash = w[1];
-        if (msb.cmp(hash)(computeSync(sha256)(chunks)) !== 0) {
-            throw 'oversized write hash mismatch';
-        }
-        // Fold the read stream straight into a fresh SHA-2 state — never one `Vec`.
-        const rehash = (state) => (stream) => stream.step((node) => {
-            if (node === undefined) {
-                return pure(ok(sha256.end(state)));
-            }
-            const { first, tail } = node;
-            if (first[0] === 'error') {
-                return pure(first);
-            }
-            return rehash(sha256.append(first[1])(state))(tail);
-        });
-        const [, readBack] = virtual(state1)(rehash(sha256.init)(c.read(hash)));
-        if (readBack[0] !== 'ok') {
-            throw ['expected read ok', readBack];
-        }
-        if (msb.cmp(readBack[1])(hash) !== 0) {
-            throw 'oversized read-back hash mismatch';
-        }
-    },
-    casWriteGcReclaimsExpired: () => {
-        // A staging file whose deadline is in the past is reclaimed by the GC that `write`
-        // runs before staging its own file.
-        const stalePath = join('.', '.cas', '_stage', '0000000000000000000-stale');
-        const state0 = {
-            ...emptyState,
-            epochNs: 1_000_000,
-            root: { '.cas': { '_stage': { '0000000000000000000-stale': [vec8(0x99n)] } } },
-        };
-        const content = vec8(0x2an);
-        const c = fileCas(sha256)('.');
-        const x = c.write(nonEmpty(ok(content), empty()));
-        const [state1, w] = virtual(state0)(x);
-        if (w[0] !== 'ok') {
-            throw ['expected write ok', w];
-        }
-        const [, present] = virtual(state1)(access(stalePath));
-        if (present[0] !== 'error') {
-            throw 'expected GC to reclaim the expired staging file';
-        }
-    },
-    casUploadSuccess: () => {
-        // A successful upload returns the hash and deletes the source file from cas_upload/.
-        const content = vec8(0x2an);
-        const state0 = { ...emptyState, root: { 'cas_upload': { 'myfile': [content] } } };
-        const [state1, result] = virtual(state0)(casUpload('.')('myfile'));
-        if (result[0] !== 'ok') {
-            throw ['expected casUpload ok', result];
-        }
-        if (length(result[1]) !== 256n) {
-            throw ['expected 256-bit hash', length(result[1])];
-        }
-        // Source must be deleted after successful publish.
-        const srcPath = join('.', 'cas_upload', 'myfile');
-        const [, srcAccess] = virtual(state1)(access(srcPath));
-        if (srcAccess[0] !== 'error') {
-            throw 'expected source to be deleted after successful upload';
-        }
-    },
-    casUploadFailureKeepsSource: () => {
-        // A missing source file causes write to fail; casUpload returns error and the
-        // source is left in place (trivially: it was never there, but the upload is not published).
-        const state0 = { ...emptyState, root: {} };
-        const [state1, result] = virtual(state0)(casUpload('.')('nonexistent'));
-        if (result[0] !== 'error') {
-            throw ['expected casUpload to fail on missing source', result];
-        }
-        // Nothing published to the store.
-        const c = fileCas(sha256)('.');
-        const [, hashes] = virtual(state1)(c.list());
-        if (hashes.length !== 0) {
-            throw ['expected nothing published on failed upload', hashes];
-        }
-    },
-};

package/fs/common/monoid/module.f.js

@@ -1,44 +0,0 @@
-/**
- * Repeats a monoid operation `n` times on the given element `a`.
- * This function efficiently performs the operation using exponentiation by squaring.
- *
- * @template T The type of the elements in the monoid.
- * @param monoid The monoid structure, including the identity and binary operation.
- * @returns A function that takes an element `a` and a repetition count `n`,
- * and returns the result of applying the operation `n` times.
- *
- * See also {@link https://en.wikipedia.org/wiki/Exponentiation_by_squaring}.
- *
- * @example
- *
- * ```ts
- * const add: Monoid<number> = {
- *     identity: 0,
- *     operation: a => b => a + b,
- * };
- *
- * const resultAdd = repeat(add)(10n)(2) // 20
- *
- * const concat: Monoid<string> = {
- *     identity: '',
- *     operation: a => b => a + b,
- * };
- *
- * const resultConcat = repeat(concat)(3n)('ha') // 'hahaha'
- * ```
- */
-export const repeat = ({ identity, operation }) => n => a => {
-    let ai = a;
-    let ni = n;
-    let result = identity;
-    while (true) {
-        if ((ni & 1n) !== 0n) {
-            result = operation(result)(ai);
-        }
-        ni >>= 1n;
-        if (ni === 0n) {
-            return result;
-        }
-        ai = operation(ai)(ai);
-    }
-};

package/fs/common/monoid/proof.f.d.ts

@@ -1,4 +0,0 @@
-export declare const proof: {
-    numberAdd: () => void;
-    stringConcat: () => void;
-};

package/fs/common/monoid/proof.f.js

@@ -1,27 +0,0 @@
-import { repeat } from "./module.f.js";
-export const proof = {
-    numberAdd: () => {
-        const add = {
-            identity: 0,
-            operation: a => b => a + b,
-        };
-        const resultAdd = repeat(add)(10n)(2); // 20
-        if (resultAdd !== 20) {
-            throw resultAdd;
-        }
-        const id = repeat(add)(0n)(42);
-        if (id !== 0) {
-            throw id;
-        }
-    },
-    stringConcat: () => {
-        const concat = {
-            identity: '',
-            operation: a => b => a + b,
-        };
-        const resultConcat = repeat(concat)(3n)('ha'); // 'hahaha'
-        if (resultConcat !== 'hahaha') {
-            throw resultConcat;
-        }
-    }
-};

package/fs/crypto/pow/proof.f.js

@@ -1,161 +0,0 @@
-import { utf8 } from '../../text/module.f.js';
-import { empty, uint } from '../../types/bit_vec/module.f.js';
-import { computeSync, sha224, sha256 } from '../sha2/module.f.js';
-import { bitcoinPow, genesisNBits, genesisTarget, pow, sha256Pow, targetFromNBits } from './module.f.js';
-const p256 = sha256Pow;
-const p224 = pow(sha224);
-const sample = utf8('functionalscript pow proof');
-const emptyData = empty;
-/** Target large enough for {@link sample} under SHA-256 (`0x207fffff`). */
-const easyNBits = 0x207fffffn;
-/** Compact encoding for target `1` (`0x03000001`). */
-const hardNBits = 0x03000001n;
-/** SHA-256 of the empty message (NIST / Bitcoin block merkle uses this primitive). */
-const sha256EmptyHash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
-/** Bitcoin block #0 header hash as big-endian uint256. */
-const block0Hash = 0x000000000019d6689c085ae165831e934ff763ae46a2a6cffb388491c27dc990n;
-const expectNull = (nBits) => {
-    if (targetFromNBits(nBits) !== null) {
-        throw nBits;
-    }
-};
-export const proof = {
-    targetFromNBits: {
-        genesis: () => {
-            if (targetFromNBits(genesisNBits) !== genesisTarget) {
-                throw 'genesis target';
-            }
-        },
-        block0HashWithinGenesisTarget: () => {
-            if (block0Hash > genesisTarget) {
-                throw 'block0 hash exceeds genesis target';
-            }
-        },
-        exponent3: () => {
-            if (targetFromNBits(0x030000ffn) !== 0xffn) {
-                throw 'exponent 3';
-            }
-        },
-        exponent2: () => {
-            if (targetFromNBits(0x02008000n) !== 0x80n) {
-                throw 'exponent 2';
-            }
-        },
-        hardTargetOne: () => {
-            if (targetFromNBits(hardNBits) !== 1n) {
-                throw 'hard target';
-            }
-        },
-        zero: () => {
-            if (targetFromNBits(0n) !== 0n) {
-                throw 'zero nBits';
-            }
-        },
-        negative: () => {
-            expectNull(0x01800001n);
-        },
-        negativeHighMantissa: () => {
-            expectNull(0x22ffffffn);
-        },
-        overflowExponent: () => {
-            expectNull(0x23000001n);
-        },
-        exceeds256: () => {
-            expectNull(0x227fffffn);
-        },
-    },
-    meets: {
-        easy: () => {
-            if (!p256.meets(easyNBits)(sample)) {
-                throw 'easy nBits should pass';
-            }
-        },
-        hard: () => {
-            if (p256.meets(hardNBits)(sample)) {
-                throw 'target 1 should fail';
-            }
-        },
-        genesisFailsSample: () => {
-            if (p256.meets(genesisNBits)(sample)) {
-                throw 'genesis target too hard for sample';
-            }
-        },
-        zeroTargetRejectsSample: () => {
-            if (p256.meets(0n)(sample)) {
-                throw 'non-zero hash vs zero target';
-            }
-        },
-        invalidNBits: () => {
-            if (p256.meets(0x01800001n)(sample)) {
-                throw 'invalid nBits should not pass';
-            }
-        },
-        hashLeqTarget: () => {
-            const h = p256.hashInt(sample);
-            const target = targetFromNBits(easyNBits);
-            if (target === null) {
-                throw 'easy nBits decode';
-            }
-            if (h > target) {
-                throw 'hash above easy target';
-            }
-            if (!(h <= target)) {
-                throw 'hash <= target';
-            }
-        },
-    },
-    hashInt: {
-        sha256Sample: () => {
-            const digest = computeSync(sha256)([sample]);
-            if (p256.hashInt(sample) !== uint(digest)) {
-                throw 'sha256 sample';
-            }
-        },
-        sha256Empty: () => {
-            if (p256.hashInt(emptyData) !== sha256EmptyHash) {
-                throw 'sha256 empty constant';
-            }
-            const digest = computeSync(sha256)([emptyData]);
-            if (p256.hashInt(emptyData) !== uint(digest)) {
-                throw 'sha256 empty';
-            }
-        },
-        sha224: () => {
-            const digest = computeSync(sha224)([sample]);
-            if (p224.hashInt(sample) !== uint(digest)) {
-                throw 'sha224';
-            }
-        },
-        stable: () => {
-            if (p256.hashInt(sample) !== p256.hashInt(sample)) {
-                throw 'stable';
-            }
-        },
-    },
-    pow: {
-        sha256Pow: () => {
-            const built = pow(sha256);
-            if (sha256Pow.hashInt(sample) !== built.hashInt(sample)) {
-                throw 'hashInt';
-            }
-            if (sha256Pow.meets(easyNBits)(sample) !== built.meets(easyNBits)(sample)) {
-                throw 'meets';
-            }
-        },
-        bitcoinPow: () => {
-            if (bitcoinPow.hashInt(sample) !== sha256Pow.hashInt(sample)) {
-                throw 'bitcoinPow';
-            }
-        },
-        independentInstances: () => {
-            const a = pow(sha256);
-            const b = pow(sha256);
-            if (a.hashInt(sample) !== b.hashInt(sample)) {
-                throw 'hashInt';
-            }
-            if (a.meets(easyNBits)(sample) !== b.meets(easyNBits)(sample)) {
-                throw 'meets';
-            }
-        },
-    },
-};

package/fs/djs/tokenizer/module.f.d.ts

@@ -1,12 +0,0 @@
-import { type List } from '../../types/list/module.f.ts';
-import * as jsTokenizer from '../../js/tokenizer/module.f.ts';
-export type DjsToken = {
-    readonly kind: 'true' | 'false' | 'null' | 'undefined';
-} | {
-    readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=';
-} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.IdToken | jsTokenizer.BigIntToken | jsTokenizer.WhitespaceToken | jsTokenizer.NewLineToken | jsTokenizer.CommentToken | jsTokenizer.EofToken;
-export type DjsTokenWithMetadata = {
-    readonly token: DjsToken;
-    readonly metadata: jsTokenizer.TokenMetadata;
-};
-export declare const tokenize: (input: List<number>) => (path: string) => List<DjsTokenWithMetadata>;

package/fs/djs/tokenizer/module.f.js

@@ -1,62 +0,0 @@
-import { empty, flat, map, stateScan } from '../../types/list/module.f.js';
-import { multiply } from '../../types/bigfloat/module.f.js';
-import * as jsTokenizer from '../../js/tokenizer/module.f.js';
-const mapToken = input => {
-    switch (input.kind) {
-        case 'id':
-        case 'bigint':
-        case '{':
-        case '}':
-        case ':':
-        case ',':
-        case '[':
-        case ']':
-        case '.':
-        case '=':
-        case 'true':
-        case 'false':
-        case 'null':
-        case 'string':
-        case 'number':
-        case 'ws':
-        case 'nl':
-        case 'undefined':
-        case '//':
-        case '/*':
-        case 'eof':
-        case 'error': return [input];
-        default: return jsTokenizer.isKeywordToken(input) ? [{ kind: 'id', value: input.kind }] : [{ kind: 'error', message: 'invalid token' }];
-    }
-};
-const parseDefaultState = input => {
-    switch (input.kind) {
-        case 'eof': return [[{ kind: 'eof' }], { kind: 'def' }];
-        case '-': return [empty, { kind: '-' }];
-        default: return [mapToken(input), { kind: 'def' }];
-    }
-};
-const parseMinusState = input => {
-    switch (input.kind) {
-        case 'eof': return [[{ kind: 'error', message: 'invalid token' }, { kind: 'eof' }], { kind: 'def' }];
-        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }];
-        case 'bigint': return [[{ kind: 'bigint', value: -1n * input.value }], { kind: 'def' }];
-        case 'number': return [[{ kind: 'number', bf: multiply(input.bf)(-1n), value: `-${input.value}` }], { kind: 'def' }];
-        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input) }, { kind: 'def' }];
-    }
-};
-const scanToken = (input, state) => {
-    switch (state.kind) {
-        case '-': return parseMinusState(input);
-        default: return parseDefaultState(input);
-    }
-};
-const mapTokenWithMetadata = metadata => token => { return { token, metadata }; };
-const scanTokenWithMetadata = (input, state) => {
-    const [djsTokens, newState] = scanToken(input.token, state);
-    const djsTokensWithMetadata = map(mapTokenWithMetadata(input.metadata))(djsTokens);
-    return [djsTokensWithMetadata, newState];
-};
-export const tokenize = input => path => {
-    const jsTokens = jsTokenizer.tokenize(input)(path);
-    return flat(stateScan(scanTokenWithMetadata)({ kind: 'def' })(jsTokens));
-};

package/fs/djs/tokenizer/proof.f.d.ts

@@ -1,7 +0,0 @@
-export declare const proof: {
-    djs: (() => void)[];
-    id: (() => void)[];
-    keywords: (() => void)[];
-    comments: (() => void)[];
-    metadata: (() => void)[];
-};