@snovon/solast 0.2.0

package/dist/ast/solc-walker.js

@@ -0,0 +1,497 @@
+"use strict";
+/**
+ * Walker for solc compact JSON ASTs (`solc --ast-compact-json`).
+ *
+ * The classic-reentrancy detector in `index.ts` is written against the
+ * `@solidity-parser/parser` AST shape (nodes carry a `type` field). solc's
+ * compact JSON uses `nodeType` and different child field names. This module
+ * walks the solc tree and, at each detector-relevant node, fires the same
+ * visitor events the parser path fires, with parser-shaped payloads. That
+ * keeps `ReentrancyDetector` shape-agnostic and the two `scanAst` entrypoints
+ * emitting identical `ScanResult` records.
+ *
+ * Child traversal is deliberately scoped to a known set of container fields
+ * rather than reflecting over all keys, so the walker stays predictable and
+ * does not accidentally descend into typeDescriptions / scope / id metadata.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkSolcAst = walkSolcAst;
+const CONTAINER_FIELDS = [
+    'nodes',
+    'statements',
+    'body',
+    'trueBody',
+    'falseBody',
+    'expression',
+    'leftHandSide',
+    'rightHandSide',
+    'leftExpression',
+    'rightExpression',
+    'baseExpression',
+    'indexExpression',
+    'initialValue',
+    'value',
+    'arguments',
+    'declarations',
+    'components',
+    'subExpression',
+    'condition',
+    'initializationExpression',
+    'loopExpression',
+    // try/catch (solc): TryStatement.clauses[i] of nodeType TryCatchClause
+    // wraps a Block under `block` and a ParameterList under `parameters`. We
+    // descend into both so other detectors still see the inner statements and
+    // expressions; ReentrancyDetector handles the TryStatement event itself.
+    'clauses',
+    'externalCall',
+    'block',
+];
+function buildLineOffsets(sourceText) {
+    if (sourceText === undefined)
+        return undefined;
+    const lineOffsets = [0];
+    let byteOffset = 0;
+    for (const char of sourceText) {
+        byteOffset += Buffer.byteLength(char, 'utf8');
+        if (char === '\n') {
+            lineOffsets.push(byteOffset);
+        }
+    }
+    return lineOffsets;
+}
+function byteOffsetToLineColumn(byteOffset, lineOffsets) {
+    let low = 0;
+    let high = lineOffsets.length - 1;
+    let lineIndex = 0;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        if (lineOffsets[mid] <= byteOffset) {
+            lineIndex = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return {
+        line: lineIndex + 1,
+        column: byteOffset - lineOffsets[lineIndex],
+    };
+}
+function srcToLoc(src, lineOffsets) {
+    if (!src || !lineOffsets)
+        return undefined;
+    const [offsetRaw, lengthRaw] = src.split(':');
+    const offset = Number(offsetRaw);
+    const length = Number(lengthRaw);
+    if (!Number.isFinite(offset) || !Number.isFinite(length) || offset < 0 || length < 0) {
+        return undefined;
+    }
+    return {
+        start: byteOffsetToLineColumn(offset, lineOffsets),
+        end: byteOffsetToLineColumn(offset + length, lineOffsets),
+    };
+}
+function withLoc(normalized, node, lineOffsets) {
+    const loc = srcToLoc(node?.src, lineOffsets);
+    return loc ? { ...normalized, loc } : normalized;
+}
+function normalizeExpression(node, lineOffsets) {
+    if (!node || typeof node !== 'object')
+        return node;
+    switch (node.nodeType) {
+        case 'Identifier':
+            return withLoc({ type: 'Identifier', name: node.name || '' }, node, lineOffsets);
+        case 'MemberAccess':
+            return withLoc({
+                type: 'MemberAccess',
+                memberName: node.memberName,
+                expression: normalizeExpression(node.expression, lineOffsets),
+            }, node, lineOffsets);
+        case 'IndexAccess':
+            return withLoc({
+                type: 'IndexAccess',
+                base: normalizeExpression(node.baseExpression, lineOffsets),
+                index: normalizeExpression(node.indexExpression, lineOffsets),
+            }, node, lineOffsets);
+        case 'FunctionCall':
+            return withLoc({
+                type: 'FunctionCall',
+                expression: normalizeExpression(node.expression, lineOffsets),
+                arguments: (node.arguments || []).map((arg) => normalizeExpression(arg, lineOffsets)),
+            }, node, lineOffsets);
+        case 'FunctionCallOptions':
+            // msg.sender.call{value: amount} — parser equivalent is NameValueExpression
+            return withLoc({
+                type: 'NameValueExpression',
+                expression: normalizeExpression(node.expression, lineOffsets),
+                names: (node.names || []).map((name) => String(name || '')),
+                arguments: (node.options || node.arguments || []).map((arg) => normalizeExpression(arg, lineOffsets)),
+            }, node, lineOffsets);
+        case 'Assignment':
+            // Parser models assignments as BinaryOperation with the assignment operator
+            return withLoc({
+                type: 'BinaryOperation',
+                operator: node.operator,
+                left: normalizeExpression(node.leftHandSide, lineOffsets),
+                right: normalizeExpression(node.rightHandSide, lineOffsets),
+            }, node, lineOffsets);
+        case 'BinaryOperation':
+            return withLoc({
+                type: 'BinaryOperation',
+                operator: node.operator,
+                left: normalizeExpression(node.leftExpression, lineOffsets),
+                right: normalizeExpression(node.rightExpression, lineOffsets),
+            }, node, lineOffsets);
+        case 'UnaryOperation':
+            return withLoc({
+                type: 'UnaryOperation',
+                operator: node.operator,
+                subExpression: normalizeExpression(node.subExpression, lineOffsets),
+            }, node, lineOffsets);
+        case 'Conditional':
+            return withLoc({
+                type: 'Conditional',
+                condition: normalizeExpression(node.condition, lineOffsets),
+                trueExpression: normalizeExpression(node.trueExpression, lineOffsets),
+                falseExpression: normalizeExpression(node.falseExpression, lineOffsets),
+            }, node, lineOffsets);
+        case 'TupleExpression':
+            return withLoc({
+                type: 'TupleExpression',
+                components: (node.components || []).map((c) => c ? normalizeExpression(c, lineOffsets) : null),
+            }, node, lineOffsets);
+        case 'Literal':
+            return withLoc({
+                type: node.kind === 'string' ? 'StringLiteral' : 'NumberLiteral',
+                value: node.value,
+                number: node.kind === 'number' ? node.value : undefined,
+                subdenomination: node.subdenomination,
+            }, node, lineOffsets);
+        case 'ElementaryTypeNameExpression':
+            return withLoc({
+                type: 'ElementaryTypeName',
+                name: node.typeName?.name || '',
+            }, node, lineOffsets);
+        default:
+            return node;
+    }
+}
+function normalizeStatement(node, lineOffsets) {
+    if (!node || typeof node !== 'object')
+        return node;
+    switch (node.nodeType) {
+        case 'Block':
+        case 'UncheckedBlock':
+            return {
+                type: 'Block',
+                statements: (node.statements || []).map((statement) => normalizeStatement(statement, lineOffsets)),
+                loc: srcToLoc(node.src, lineOffsets),
+            };
+        case 'ExpressionStatement':
+            return normalizeExpressionStatement(node, lineOffsets);
+        case 'IfStatement':
+            return {
+                type: 'IfStatement',
+                condition: normalizeExpression(node.condition, lineOffsets),
+                trueBody: normalizeStatement(node.trueBody, lineOffsets),
+                falseBody: normalizeStatement(node.falseBody, lineOffsets),
+                loc: srcToLoc(node.src, lineOffsets),
+            };
+        case 'VariableDeclarationStatement':
+            return normalizeVariableDeclarationStatement(node, lineOffsets);
+        case 'Return':
+            return {
+                type: 'ReturnStatement',
+                expression: normalizeExpression(node.expression, lineOffsets),
+                loc: srcToLoc(node.src, lineOffsets),
+            };
+        case 'TryStatement':
+            return normalizeTryStatement(node, lineOffsets);
+        default:
+            return normalizeExpression(node, lineOffsets);
+    }
+}
+/**
+ * Solc compact JSON `TryStatement.clauses` is `[successClause, ...catchClauses]`
+ * where each entry is a `TryCatchClause` with a `block` and a `ParameterList`
+ * under `parameters`. The first clause is always the success path regardless of
+ * its `errorName`. Normalize to the parser shape ReentrancyDetector consumes:
+ * `{ expression, returnParameters, body, catchClauses[{kind, parameters, body}] }`.
+ */
+function normalizeTryStatement(node, lineOffsets) {
+    const clauses = node.clauses || [];
+    const successClause = clauses[0];
+    const catchSolcClauses = clauses.slice(1);
+    const returnParameters = ((successClause?.parameters?.parameters) || []).map((p) => ({
+        name: p?.name || '',
+        typeName: p?.typeName || null,
+    }));
+    const catchClauses = catchSolcClauses.map((cc) => ({
+        type: 'CatchClause',
+        kind: cc?.errorName || '',
+        parameters: ((cc?.parameters?.parameters) || []).map((p) => ({
+            name: p?.name || '',
+            typeName: p?.typeName || null,
+        })),
+        body: cc?.block ? normalizeStatement(cc.block, lineOffsets) : null,
+        loc: srcToLoc(cc?.src, lineOffsets),
+    }));
+    return {
+        type: 'TryStatement',
+        expression: normalizeExpression(node.externalCall, lineOffsets),
+        returnParameters,
+        body: successClause?.block ? normalizeStatement(successClause.block, lineOffsets) : null,
+        catchClauses,
+        loc: srcToLoc(node.src, lineOffsets),
+    };
+}
+function normalizeFunctionDefinition(node, lineOffsets) {
+    const params = node.parameters?.parameters || [];
+    const returnParams = node.returnParameters?.parameters || [];
+    const modifiers = (node.modifiers || []).map((m) => ({
+        type: 'ModifierInvocation',
+        name: { type: 'Identifier', name: m.modifierName?.name || '' },
+    }));
+    return {
+        type: 'FunctionDefinition',
+        name: node.name || '',
+        kind: node.kind || '',
+        visibility: node.visibility || '',
+        stateMutability: node.stateMutability || '',
+        parameters: params.map((p) => ({ name: p.name || '', typeName: p.typeName || null })),
+        returnParameters: returnParams.map((p) => ({ name: p.name || '', typeName: p.typeName || null })),
+        modifiers,
+        body: node.body ? normalizeStatement(node.body, lineOffsets) : null,
+        loc: srcToLoc(node.src, lineOffsets),
+    };
+}
+function normalizeVariableDeclarationStatement(node, lineOffsets) {
+    const variables = (node.declarations || []).map((d) => d ? { name: d.name || '', typeName: d.typeName || null } : null);
+    return {
+        type: 'VariableDeclarationStatement',
+        variables,
+        initialValue: node.initialValue ? normalizeExpression(node.initialValue, lineOffsets) : null,
+        loc: srcToLoc(node.src, lineOffsets),
+    };
+}
+function normalizeExpressionStatement(node, lineOffsets) {
+    return {
+        type: 'ExpressionStatement',
+        expression: node.expression ? normalizeExpression(node.expression, lineOffsets) : null,
+        loc: srcToLoc(node.src, lineOffsets),
+    };
+}
+function dispatchEvent(node, lineOffsets) {
+    switch (node.nodeType) {
+        case 'SourceUnit':
+            return {
+                eventName: 'SourceUnit',
+                normalized: node,
+            };
+        case 'ContractDefinition':
+            return {
+                eventName: 'ContractDefinition',
+                normalized: {
+                    type: 'ContractDefinition',
+                    name: node.name || '',
+                    kind: node.contractKind || '',
+                    baseContracts: (node.baseContracts || []).map((base) => ({
+                        baseName: {
+                            type: 'UserDefinedTypeName',
+                            namePath: base.baseName?.name || '',
+                        },
+                    })),
+                },
+            };
+        case 'VariableDeclaration':
+            if (node.stateVariable) {
+                const isConstant = node.mutability === 'constant' || node.constant === true;
+                return {
+                    eventName: 'StateVariableDeclaration',
+                    normalized: {
+                        type: 'StateVariableDeclaration',
+                        variables: [{
+                                name: node.name || '',
+                                typeName: node.typeName || null,
+                                expression: node.value || node.initialValue
+                                    ? normalizeExpression(node.value || node.initialValue, lineOffsets)
+                                    : null,
+                                isDeclaredConst: isConstant,
+                            }],
+                        loc: srcToLoc(node.src, lineOffsets),
+                    },
+                };
+            }
+            return null;
+        case 'FunctionDefinition':
+            return {
+                eventName: 'FunctionDefinition',
+                normalized: normalizeFunctionDefinition(node, lineOffsets),
+            };
+        case 'VariableDeclarationStatement':
+            return {
+                eventName: 'VariableDeclarationStatement',
+                normalized: normalizeVariableDeclarationStatement(node, lineOffsets),
+            };
+        case 'StructDefinition':
+            return {
+                eventName: 'StructDefinition',
+                normalized: {
+                    type: 'StructDefinition',
+                    name: node.name || '',
+                    members: (node.members || []).map((member) => ({
+                        name: member?.name || '',
+                        typeName: member?.typeName || null,
+                    })),
+                    loc: srcToLoc(node.src, lineOffsets),
+                },
+            };
+        case 'ExpressionStatement':
+            return {
+                eventName: 'ExpressionStatement',
+                normalized: normalizeExpressionStatement(node, lineOffsets),
+            };
+        case 'IfStatement':
+            return {
+                eventName: 'IfStatement',
+                normalized: {
+                    type: 'IfStatement',
+                    condition: normalizeExpression(node.condition, lineOffsets),
+                    trueBody: normalizeStatement(node.trueBody, lineOffsets),
+                    falseBody: normalizeStatement(node.falseBody, lineOffsets),
+                    loc: srcToLoc(node.src, lineOffsets),
+                },
+            };
+        case 'TryStatement':
+            return {
+                eventName: 'TryStatement',
+                normalized: normalizeTryStatement(node, lineOffsets),
+            };
+        case 'Conditional':
+            return {
+                eventName: 'Conditional',
+                normalized: normalizeExpression(node, lineOffsets),
+            };
+        case 'PragmaDirective': {
+            const literals = node.literals || [];
+            const name = literals.length > 0 ? literals[0] : '';
+            const value = literals.length > 1 ? literals.slice(1).join('') : '';
+            return {
+                eventName: 'PragmaDirective',
+                normalized: { type: 'PragmaDirective', name, value },
+            };
+        }
+        case 'UncheckedBlock':
+            return {
+                eventName: 'UncheckedStatement',
+                normalized: { type: 'UncheckedStatement' },
+            };
+        case 'BinaryOperation': {
+            const normalized = normalizeExpression(node, lineOffsets);
+            const loc = srcToLoc(node.src, lineOffsets);
+            if (loc)
+                normalized.loc = loc;
+            return { eventName: 'BinaryOperation', normalized };
+        }
+        case 'UnaryOperation': {
+            const normalized = normalizeExpression(node, lineOffsets);
+            return { eventName: 'UnaryOperation', normalized };
+        }
+        case 'Assignment': {
+            // The parser models compound assignments as `BinaryOperation` with the
+            // assignment operator (e.g. `+=`); fire the same event from the solc
+            // walker so detectors that watch arithmetic ops see both shapes.
+            const normalized = normalizeExpression(node, lineOffsets);
+            return { eventName: 'BinaryOperation', normalized };
+        }
+        case 'FunctionCall': {
+            const normalized = normalizeExpression(node, lineOffsets);
+            const loc = srcToLoc(node.src, lineOffsets);
+            if (loc)
+                normalized.loc = loc;
+            return { eventName: 'FunctionCall', normalized };
+        }
+        default:
+            return null;
+    }
+}
+function isNestedStatementBody(parent, field) {
+    if (!parent || typeof parent !== 'object')
+        return false;
+    if (field === 'trueBody' || field === 'falseBody')
+        return true;
+    if (field === 'statements')
+        return parent.nodeType === 'UncheckedBlock';
+    if (field !== 'body')
+        return false;
+    return parent.nodeType !== 'FunctionDefinition' &&
+        parent.nodeType !== 'ModifierDefinition' &&
+        parent.nodeType !== 'ContractDefinition' &&
+        parent.nodeType !== 'SourceUnit';
+}
+function visitChildNode(parent, field, child, visitor, lineOffsets) {
+    const restoreGuardAfterBody = isNestedStatementBody(parent, field) &&
+        typeof visitor.enterNestedStatementBody === 'function' &&
+        typeof visitor.exitNestedStatementBody === 'function';
+    if (restoreGuardAfterBody)
+        visitor.enterNestedStatementBody.call(visitor);
+    try {
+        visitNode(child, visitor, lineOffsets);
+    }
+    finally {
+        if (restoreGuardAfterBody)
+            visitor.exitNestedStatementBody.call(visitor);
+    }
+}
+function visitChildArray(parent, field, children, visitor, lineOffsets) {
+    const restoreGuardAfterBody = isNestedStatementBody(parent, field) &&
+        typeof visitor.enterNestedStatementBody === 'function' &&
+        typeof visitor.exitNestedStatementBody === 'function';
+    if (restoreGuardAfterBody)
+        visitor.enterNestedStatementBody.call(visitor);
+    try {
+        for (const item of children) {
+            if (item && typeof item === 'object' && item.nodeType) {
+                if (restoreGuardAfterBody) {
+                    visitNode(item, visitor, lineOffsets);
+                }
+                else {
+                    visitChildNode(parent, field, item, visitor, lineOffsets);
+                }
+            }
+        }
+    }
+    finally {
+        if (restoreGuardAfterBody)
+            visitor.exitNestedStatementBody.call(visitor);
+    }
+}
+function visitNode(node, visitor, lineOffsets) {
+    if (!node || typeof node !== 'object' || !node.nodeType)
+        return;
+    const event = dispatchEvent(node, lineOffsets);
+    if (event) {
+        const handler = visitor[event.eventName];
+        if (typeof handler === 'function')
+            handler.call(visitor, event.normalized);
+    }
+    for (const field of CONTAINER_FIELDS) {
+        const value = node[field];
+        if (Array.isArray(value)) {
+            visitChildArray(node, field, value, visitor, lineOffsets);
+        }
+        else if (value && typeof value === 'object' && value.nodeType) {
+            visitChildNode(node, field, value, visitor, lineOffsets);
+        }
+    }
+    if (event) {
+        const postHandler = visitor[`${event.eventName}_post`];
+        if (typeof postHandler === 'function')
+            postHandler.call(visitor, event.normalized);
+    }
+}
+function walkSolcAst(ast, visitor, sourceText) {
+    visitNode(ast, visitor, buildLineOffsets(sourceText));
+}
+//# sourceMappingURL=solc-walker.js.map

package/dist/ast/storage-layout.d.ts

@@ -0,0 +1,21 @@
+export interface StorageLayoutInput {
+    storage?: StorageLayoutEntry[];
+    types?: Record<string, StorageLayoutType | undefined>;
+}
+export interface StorageLayoutEntry {
+    label: string;
+    slot: string;
+    offset?: number | string;
+    type: string;
+}
+export interface StorageLayoutType {
+    numberOfBytes?: number | string;
+}
+export interface StorageAccessResolution {
+    label: string;
+    slot: string;
+    slots: string[];
+    straddlesSlotBoundary: boolean;
+    ambiguous: boolean;
+}
+export declare function resolveStorageLayoutAccess(storageLayout: StorageLayoutInput, label: string): StorageAccessResolution | null;

package/dist/ast/storage-layout.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStorageLayoutAccess = resolveStorageLayoutAccess;
+const SLOT_BYTES = 32n;
+function resolveStorageLayoutAccess(storageLayout, label) {
+    const entry = storageLayout.storage?.find((item) => item.label === label);
+    if (!entry)
+        return null;
+    const slot = parseBigInt(entry.slot);
+    const offset = parseBigInt(entry.offset ?? 0);
+    const byteLength = parseBigInt(storageLayout.types?.[entry.type]?.numberOfBytes);
+    if (slot === null || offset === null) {
+        return {
+            label,
+            slot: entry.slot,
+            slots: [entry.slot],
+            straddlesSlotBoundary: false,
+            ambiguous: true,
+        };
+    }
+    if (byteLength === null || byteLength <= 0n) {
+        return {
+            label,
+            slot: entry.slot,
+            slots: [entry.slot],
+            straddlesSlotBoundary: false,
+            ambiguous: true,
+        };
+    }
+    const lastByte = offset + byteLength - 1n;
+    const extraSlots = lastByte / SLOT_BYTES;
+    const slots = [];
+    for (let i = 0n; i <= extraSlots; i++) {
+        slots.push((slot + i).toString());
+    }
+    const straddlesSlotBoundary = extraSlots > 0n;
+    return {
+        label,
+        slot: entry.slot,
+        slots,
+        straddlesSlotBoundary,
+        ambiguous: straddlesSlotBoundary,
+    };
+}
+function parseBigInt(value) {
+    if (value === undefined || value === null)
+        return null;
+    try {
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value) || value < 0)
+                return null;
+            return BigInt(value);
+        }
+        const text = String(value).trim();
+        if (!/^(0x[0-9a-fA-F]+|[0-9]+)$/.test(text))
+            return null;
+        const parsed = BigInt(text);
+        return parsed >= 0n ? parsed : null;
+    }
+    catch (_e) {
+        return null;
+    }
+}
+//# sourceMappingURL=storage-layout.js.map

package/dist/cli.d.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { ScanOptions, ScanResult } from './index';
+import { formatFindings } from './formatters/text';
+import { ExitCode } from './exit-codes';
+import { type SeverityLabel } from './severity';
+type ScanFormat = 'text' | 'json' | 'sarif';
+type CiSeverityThreshold = SeverityLabel | 'none';
+interface ScanCommandOptions {
+    format?: ScanFormat;
+    ci?: boolean;
+    output?: string;
+    quiet?: boolean;
+    json?: boolean;
+    color?: boolean;
+    rule?: string[];
+    ignorePattern?: string[];
+    enable?: string[];
+    paths?: string[];
+    dedup?: boolean;
+    fpThreshold?: number;
+    severityThreshold?: string;
+    severityOverrides?: Record<string, SeverityLabel>;
+    verbose?: boolean;
+    /**
+     * Number of worker_threads to spread the scan across. `0`/unset
+     * keeps the existing sync path. Threshold-gated inside the parallel
+     * adapter so a small file set still runs sync even when the user
+     * passes `--workers 8`.
+     */
+    workers?: number;
+    /**
+     * Path to a persisted SolAST NDJSON baseline. When set, normal
+     * scan output is filtered to net-new findings and the process exits
+     * 1 only if that filtered set is non-empty.
+     */
+    diffBaseline?: string;
+    detectorOptions?: Record<string, any>;
+    sarifSeverityTuning?: boolean;
+    tier?: 'core' | 'extended' | 'all';
+}
+interface ScanCommandDeps {
+    scan?: (path: string | string[], options?: ScanOptions) => ScanResult[];
+    scanFiles?: (files: string[], options?: ScanOptions) => ScanResult[];
+    discoverFiles?: (paths: string | string[]) => string[];
+    formatFindings?: typeof formatFindings;
+    cwd?: () => string;
+    stdout?: (message: string) => void;
+    stderr?: (message: string) => void;
+    writeFile?: (path: string, content: string) => void;
+}
+export declare function parseCiSeverityThreshold(value: string | undefined): CiSeverityThreshold | undefined;
+export declare function getExitCode(results: ScanResult[]): ExitCode;
+export declare function resolveScanFiles(inputPaths: string | string[]): string[];
+export declare function runScanCommand(targetPath: string | string[], options?: ScanCommandOptions, deps?: ScanCommandDeps): ExitCode;
+/**
+ * Async sibling of `runScanCommand` that runs the scan across a worker
+ * thread pool when `options.workers > 1`. Falls through to the sync
+ * `runScanCommand` whenever the worker count is 0/1 or the file count
+ * is below the threshold inside `scanFilesParallel`. The CLI binding
+ * routes here when the user passes `--workers <n>`; everything else
+ * keeps the existing synchronous code path so this PR doesn't perturb
+ * behaviour for callers that don't opt in.
+ */
+export declare function runScanCommandParallel(targetPath: string | string[], options?: ScanCommandOptions, deps?: ScanCommandDeps): Promise<ExitCode>;
+export {};