pi-lens 4.2.1 → 4.4.0

package/dist/clients/review-graph/workspace-modules.js

@@ -1,449 +0,0 @@
-/**
- * Workspace / monorepo module scanner
- *
- * Detects monorepo structure from common manifest files and builds a
- * module-level dependency graph for cascade downstream analysis.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { hasCargoWorkspaceTable, readCargoDependencyNames, readCargoPackageName, readCargoWorkspaceMembers, } from "../cargo-manifest.js";
-import { getProjectIgnoreMatcher, isExcludedDirName, } from "../file-utils.js";
-import { normalizeMapKey } from "../path-utils.js";
-import { getWorkspaceManifestMarkers } from "../workspace-topology.js";
-// Cap on candidate sub-directories probed per workspace glob level (#262).
-const MAX_WORKSPACE_CANDIDATES = 5_000;
-const SOURCE_EXTS = new Set([
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".py",
-    ".go",
-    ".rs",
-    ".rb",
-    ".cpp",
-    ".c",
-    ".cc",
-    ".h",
-    ".hpp",
-]);
-function readJsonSafe(filePath) {
-    try {
-        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Presence checks for the four workspace-manifest markers are sourced from
- * the shared workspace-topology marker index (#806) — one `readdir` pass at
- * `cwd` collects them alongside `.pi-lens.json`/`tsconfig.json` other
- * consumers need for the SAME directory, instead of four independent
- * `existsSync` probes. Manifest CONTENT (workspace globs, the `[workspace]`
- * TOML section, the `workspaces` package.json field) is still read and
- * parsed here — the topology index only answers "is the marker present".
- */
-function detectWorkspaceType(cwd) {
-    const markers = getWorkspaceManifestMarkers(cwd);
-    if (markers.hasPnpmWorkspaceYaml)
-        return "pnpm";
-    if (markers.hasGoWork)
-        return "go";
-    if (markers.hasCargoToml) {
-        try {
-            const content = fs.readFileSync(path.join(cwd, "Cargo.toml"), "utf-8");
-            // The shared presence check (#2498) — see its own doc comment in
-            // cargo-manifest.ts for why a bare `.includes`/regex reimplementation
-            // of this test is wrong (comment/sentinel handling).
-            if (hasCargoWorkspaceTable(content)) {
-                return "cargo";
-            }
-        }
-        catch { }
-    }
-    if (markers.hasPackageJson) {
-        const pkgJson = readJsonSafe(path.join(cwd, "package.json"));
-        const workspaces = normalizeWorkspacePatterns(pkgJson?.workspaces);
-        if (workspaces.length > 0)
-            return "npm";
-    }
-    return null;
-}
-function stripQuotes(value) {
-    return value.trim().replace(/^['"]|['"]$/g, "");
-}
-function normalizeWorkspacePatterns(value) {
-    if (Array.isArray(value))
-        return value.map(stripQuotes).filter(Boolean);
-    if (value?.packages && Array.isArray(value.packages)) {
-        return value.packages.map(stripQuotes).filter(Boolean);
-    }
-    return [];
-}
-function expandWorkspacePattern(cwd, pattern) {
-    const normalized = stripQuotes(pattern.trim()).replace(/\\/g, "/");
-    if (!normalized || normalized.startsWith("!"))
-        return [];
-    const starIndex = normalized.indexOf("*");
-    if (starIndex === -1) {
-        const root = path.resolve(cwd, normalized);
-        return fs.existsSync(path.join(root, "package.json")) ||
-            fs.existsSync(path.join(root, "Cargo.toml")) ||
-            fs.existsSync(path.join(root, "go.mod"))
-            ? [root]
-            : [];
-    }
-    // Support the common workspace forms: packages/* and apps/*.
-    const prefix = normalized.slice(0, starIndex).replace(/\/$/, "");
-    const baseDir = path.resolve(cwd, prefix || ".");
-    let entries = [];
-    try {
-        entries = fs.readdirSync(baseDir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const ignoreMatcher = getProjectIgnoreMatcher(cwd);
-    return (entries
-        .filter((entry) => {
-        const fullPath = path.join(baseDir, entry.name);
-        return (entry.isDirectory() &&
-            !isExcludedDirName(entry.name) &&
-            !ignoreMatcher.isIgnored(fullPath, true));
-    })
-        // Bound the manifest-probe fan-out so a pathological single directory
-        // can't trigger an unbounded existsSync sweep (#262).
-        .slice(0, MAX_WORKSPACE_CANDIDATES)
-        .map((entry) => path.join(baseDir, entry.name))
-        .filter((root) => fs.existsSync(path.join(root, "package.json")) ||
-        fs.existsSync(path.join(root, "Cargo.toml")) ||
-        fs.existsSync(path.join(root, "go.mod"))));
-}
-function depsFromPackageJson(pkgJson) {
-    return Object.keys({
-        ...pkgJson.dependencies,
-        ...pkgJson.devDependencies,
-        ...pkgJson.peerDependencies,
-    });
-}
-function extractYamlList(content, key) {
-    const values = [];
-    let inList = false;
-    for (const rawLine of content.split(/\r?\n/)) {
-        const trimmed = rawLine.trim();
-        if (!trimmed || trimmed.startsWith("#"))
-            continue;
-        if (!inList) {
-            if (trimmed === `${key}:`)
-                inList = true;
-            continue;
-        }
-        if (trimmed.startsWith("-")) {
-            const value = stripQuotes(trimmed.slice(1).trim()).replace(/\/$/, "");
-            if (value)
-                values.push(value);
-            continue;
-        }
-        // A new top-level key ends the list.
-        if (!rawLine.startsWith(" ") && !rawLine.startsWith("\t"))
-            break;
-    }
-    return values;
-}
-function moduleFromPackageJson(cwd, pkgRoot) {
-    const pkgJson = readJsonSafe(path.join(pkgRoot, "package.json"));
-    if (!pkgJson?.name)
-        return null;
-    return {
-        name: pkgJson.name,
-        root: normalizeMapKey(pkgRoot),
-        relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
-        entrypoints: pkgJson.main ? [pkgJson.main] : ["index.js"],
-        internalDeps: [],
-        externalDeps: depsFromPackageJson(pkgJson),
-    };
-}
-function scanPnpmModules(cwd) {
-    let patterns = [];
-    try {
-        const content = fs.readFileSync(path.join(cwd, "pnpm-workspace.yaml"), "utf-8");
-        patterns = extractYamlList(content, "packages");
-    }
-    catch {
-        return [];
-    }
-    return patterns
-        .flatMap((pattern) => expandWorkspacePattern(cwd, pattern))
-        .map((pkgRoot) => moduleFromPackageJson(cwd, pkgRoot))
-        .filter((mod) => mod !== null);
-}
-function scanNpmModules(cwd) {
-    const pkgJson = readJsonSafe(path.join(cwd, "package.json"));
-    const patterns = normalizeWorkspacePatterns(pkgJson?.workspaces);
-    return patterns
-        .flatMap((pattern) => expandWorkspacePattern(cwd, pattern))
-        .map((pkgRoot) => moduleFromPackageJson(cwd, pkgRoot))
-        .filter((mod) => mod !== null);
-}
-function scanCargoModules(cwd) {
-    let members = [];
-    try {
-        const content = fs.readFileSync(path.join(cwd, "Cargo.toml"), "utf-8");
-        members = readCargoWorkspaceMembers(content);
-    }
-    catch {
-        return [];
-    }
-    const modules = [];
-    for (const member of members) {
-        const pkgRoot = path.resolve(cwd, member);
-        const memberToml = path.join(pkgRoot, "Cargo.toml");
-        let name = "";
-        let deps = [];
-        try {
-            const content = fs.readFileSync(memberToml, "utf-8");
-            name = readCargoPackageName(content) ?? "";
-            deps = readCargoDependencyNames(content);
-        }
-        catch {
-            continue;
-        }
-        if (!name)
-            continue;
-        modules.push({
-            name,
-            root: normalizeMapKey(pkgRoot),
-            relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
-            entrypoints: ["src/lib.rs", "src/main.rs"],
-            internalDeps: [],
-            externalDeps: deps,
-        });
-    }
-    return modules;
-}
-function scanGoModules(cwd) {
-    let dirs = [];
-    try {
-        const content = fs.readFileSync(path.join(cwd, "go.work"), "utf-8");
-        dirs = [...content.matchAll(/(?:^|\s)(\.\/?[^\s)]+)/gm)].map((m) => m[1]);
-    }
-    catch {
-        return [];
-    }
-    const modules = [];
-    for (const dir of dirs) {
-        const pkgRoot = path.resolve(cwd, dir);
-        let name = "";
-        try {
-            const content = fs.readFileSync(path.join(pkgRoot, "go.mod"), "utf-8");
-            const match = content.match(/^module\s+(\S+)/m);
-            if (match)
-                name = match[1];
-        }
-        catch {
-            continue;
-        }
-        if (!name)
-            continue;
-        modules.push({
-            name,
-            root: normalizeMapKey(pkgRoot),
-            relativePath: path.relative(cwd, pkgRoot).replace(/\\/g, "/"),
-            entrypoints: ["."],
-            internalDeps: [],
-            externalDeps: [],
-        });
-    }
-    return modules;
-}
-function resolveInternalDeps(modules) {
-    const nameSet = new Set(modules.map((m) => m.name));
-    for (const mod of modules) {
-        const internal = [];
-        const external = [];
-        for (const dep of mod.externalDeps) {
-            if (nameSet.has(dep))
-                internal.push(dep);
-            else
-                external.push(dep);
-        }
-        mod.internalDeps = internal;
-        mod.externalDeps = external;
-    }
-}
-function buildDependents(modules) {
-    const dependents = new Map();
-    for (const mod of modules) {
-        for (const dep of mod.internalDeps) {
-            const list = dependents.get(dep) ?? [];
-            list.push(mod.name);
-            dependents.set(dep, list);
-        }
-    }
-    return dependents;
-}
-let _moduleGraphCache = null;
-/**
- * Build a module-level dependency graph for the workspace at cwd.
- * Cached per session (cleared when cwd changes).
- */
-export function buildModuleGraph(cwd) {
-    if (_moduleGraphCache && _moduleGraphCache.cwd === cwd) {
-        return _moduleGraphCache.graph;
-    }
-    const type = detectWorkspaceType(cwd);
-    if (!type)
-        return null;
-    let modules = [];
-    switch (type) {
-        case "pnpm":
-            modules = scanPnpmModules(cwd);
-            break;
-        case "npm":
-            modules = scanNpmModules(cwd);
-            break;
-        case "cargo":
-            modules = scanCargoModules(cwd);
-            break;
-        case "go":
-            modules = scanGoModules(cwd);
-            break;
-    }
-    if (modules.length === 0)
-        return null;
-    resolveInternalDeps(modules);
-    const graph = {
-        root: cwd,
-        modules: new Map(modules.map((m) => [m.name, m])),
-        dependents: buildDependents(modules),
-    };
-    _moduleGraphCache = { cwd, graph };
-    return graph;
-}
-export function clearModuleGraphCache() {
-    _moduleGraphCache = null;
-    _moduleSourceFilesMemo.clear();
-}
-/**
- * Find the module that owns a given file path.
- */
-export function findModuleForPath(graph, filePath) {
-    const normalized = normalizeMapKey(filePath);
-    let best;
-    for (const mod of graph.modules.values()) {
-        if (normalized === mod.root || normalized.startsWith(`${mod.root}/`)) {
-            if (!best || mod.root.length > best.root.length)
-                best = mod;
-        }
-    }
-    return best;
-}
-/**
- * Get all transitive downstream dependent module names for a given module.
- */
-export function getDownstreamModules(graph, moduleName) {
-    const downstream = new Set();
-    const queue = [moduleName];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        for (const dep of graph.dependents.get(current) ?? []) {
-            if (!downstream.has(dep)) {
-                downstream.add(dep);
-                queue.push(dep);
-            }
-        }
-    }
-    return [...downstream];
-}
-const _moduleSourceFilesMemo = new Map();
-const MTIME_GRANULARITY_GUARD_MS = 2_000;
-function isMemoEntryFresh(entry) {
-    const validatedAt = Date.now();
-    for (const { dir, mtimeMs, stampedAt } of entry.dirs) {
-        if (validatedAt - stampedAt < MTIME_GRANULARITY_GUARD_MS)
-            return false;
-        try {
-            if (fs.statSync(dir).mtimeMs !== mtimeMs)
-                return false;
-        }
-        catch {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Get representative source files in a module. Memoized per module root (see
- * above) — the returned array is a copy; mutating it does not affect the memo.
- */
-export function getModuleSourceFiles(moduleRoot, maxFiles = 20) {
-    const root = normalizeMapKey(moduleRoot);
-    const ignoreMatcher = getProjectIgnoreMatcher(root);
-    const cached = _moduleSourceFilesMemo.get(root);
-    if (cached &&
-        cached.maxFiles === maxFiles &&
-        cached.matcher === ignoreMatcher &&
-        isMemoEntryFresh(cached)) {
-        return [...cached.files];
-    }
-    const files = [];
-    const dirs = [];
-    let allDirsStamped = true;
-    const visit = (dir, depth) => {
-        if (files.length >= maxFiles || depth > 4)
-            return;
-        let entries = [];
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        // Stamp AFTER the readdir: a change landing between readdir and stat
-        // records the newer mtime, so validation re-walks (fail-safe direction).
-        try {
-            dirs.push({
-                dir,
-                mtimeMs: fs.statSync(dir).mtimeMs,
-                stampedAt: Date.now(),
-            });
-        }
-        catch {
-            allDirsStamped = false;
-        }
-        entries.sort((a, b) => a.name.localeCompare(b.name));
-        for (const entry of entries) {
-            if (files.length >= maxFiles)
-                break;
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (!isExcludedDirName(entry.name) &&
-                    !ignoreMatcher.isIgnored(fullPath, true)) {
-                    visit(fullPath, depth + 1);
-                }
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            // #1974: extension gate before isIgnored — isIgnored recompiles
-            // minimatch patterns per ancestor dir per call, so it should only run
-            // for files the cheap extension check already flags as source.
-            if (!SOURCE_EXTS.has(path.extname(entry.name).toLowerCase()))
-                continue;
-            if (ignoreMatcher.isIgnored(fullPath, false))
-                continue;
-            files.push(normalizeMapKey(fullPath));
-        }
-    };
-    visit(root, 0);
-    if (allDirsStamped) {
-        _moduleSourceFilesMemo.set(root, {
-            files: [...files],
-            maxFiles,
-            dirs,
-            matcher: ignoreMatcher,
-        });
-    }
-    return files;
-}

package/dist/clients/review-graph-logger.js

@@ -1,81 +0,0 @@
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalPiLensLogDir } from "./probe-home-state.js";
-import { getMaxLogSizeMB } from "./log-cleanup.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { getTurnId } from "./turn-context.js";
-const REVIEW_GRAPH_LOG_DIR = getGlobalPiLensLogDir();
-const REVIEW_GRAPH_LOG_FILE = path.join(REVIEW_GRAPH_LOG_DIR, "review-graph.log");
-// Bounded like every other global sink (#2505) — see sessionstart-logger.
-const writer = createNdjsonLogger({
-    filePath: REVIEW_GRAPH_LOG_FILE,
-    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
-    backupPath: `${REVIEW_GRAPH_LOG_FILE}.1`,
-});
-/**
- * Build the one canonical graph metadata shape used by build and persist logs.
- * Counts come from the graph instance; source-file count may use the exact
- * signature-map count when the build has one, otherwise the graph file index.
- */
-export function makeReviewGraphBuildMetadata(graph, options = {}) {
-    return {
-        ...(options.buildId === undefined ? {} : { buildId: options.buildId }),
-        ...(graph.buildGeneration === undefined
-            ? {}
-            : { graphGeneration: graph.buildGeneration }),
-        builtAt: graph.builtAt,
-        ...(options.projectSeq === undefined
-            ? {}
-            : { projectSeq: options.projectSeq }),
-        ...(options.seqHint === undefined ? {} : { seqHint: options.seqHint }),
-        ...(options.mode === undefined ? {} : { mode: options.mode }),
-        sourceFiles: options.sourceFileCount ?? graph.fileNodes.size,
-        ...(options.sourceFileCountTruncated ||
-            graph.persistCoverage?.sourceFilesTruncated
-            ? { sourceFilesTruncated: true }
-            : {}),
-        ...(options.pathNormalizeCalls === undefined
-            ? {}
-            : { pathNormalizeCalls: options.pathNormalizeCalls }),
-        nodes: graph.nodes.size,
-        edges: graph.edges.length,
-        ...(graph.persistCoverage
-            ? { persistCoverage: graph.persistCoverage }
-            : {}),
-    };
-}
-/**
- * #2141: call sites feed this a mix of raw `cwd` params and already-normalized
- * cache keys (`normalizeMapKey(path.resolve(cwd))`), so the same project root
- * showed up in the log as both `C:\...\pi-free` and `C:/.../pi-free`. Rather
- * than auditing every call site, normalize once here — the single emit
- * seam — matching the form `normalizeFilePath` already produces for every
- * other structured log's `cwd` field (bus-publish, disposition-publish,
- * diagnostics-publish, format-events-publish all normalize at their publish
- * call sites; this pulls the same conversion in-house so no future call site
- * can regress it).
- */
-export function logReviewGraph(entry) {
-    if (isTestMode()) {
-        return;
-    }
-    writer.log({
-        ts: new Date().toISOString(),
-        ...entry,
-        cwd: normalizeFilePath(entry.cwd),
-        pid: process.pid,
-        turnId: getTurnId(),
-    });
-}
-export function getReviewGraphLogPath() {
-    return REVIEW_GRAPH_LOG_FILE;
-}
-/** Resolve once all enqueued review-graph writes are on disk (tests/shutdown). */
-export function flushReviewGraphLog() {
-    return writer.flush();
-}
-/** Teardown-only: force queued entries to disk before the process exits. */
-export function flushReviewGraphLogSync() {
-    writer.flushSync();
-}

package/dist/clients/ruff-client.js

@@ -1,152 +0,0 @@
-/**
- * Ruff Client for pi-lens
- *
- * Fast Python linting and formatting via Ruff CLI.
- * Replaces flake8, pylint, isort, black, pyupgrade.
- *
- * Requires: pip install ruff
- * Docs: https://docs.astral.sh/ruff/
- */
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./dispatch/runners/utils/runner-helpers.js";
-import { isFileKind } from "./file-kinds.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { resolveToolCwd } from "./tool-cwd.js";
-import { ruffConfigArgs } from "./tool-policy.js";
-// --- Client ---
-const ruffAvailability = createAvailabilityChecker("ruff", ".exe");
-export class RuffClient {
-    ruffCommand = "ruff";
-    log;
-    constructor(verbose = false) {
-        this.log = verbose ? createSubsystemLogger("ruff") : () => { };
-    }
-    /**
-     * Check if ruff CLI is available, auto-install if not.
-     *
-     * Re-entrancy safe: the shared availability seam deduplicates the complete
-     * probe/auto-install transaction per cwd and tool, so concurrent callers do
-     * not duplicate installation attempts.
-     */
-    async ensureAvailable() {
-        const resolved = await resolveAvailableOrInstall(ruffAvailability, "ruff", process.cwd());
-        if (!resolved)
-            return false;
-        this.ruffCommand = resolved;
-        return true;
-    }
-    /**
-     * Check if a file is a Python file
-     */
-    isPythonFile(filePath) {
-        return isFileKind(filePath, "python");
-    }
-    /**
-     * Async auto-fix variant for pipeline use (non-blocking spawn).
-     * `cwd` is the dispatch language root. It is the seam's starting point,
-     * not the answer: `resolveToolCwd` walks from the file to the nearest
-     * `pyproject.toml`/`ruff.toml`/`.ruff.toml` at or above it, capped inside
-     * `cwd` (and at `$HOME` when there is none), so a file in a nested package
-     * gets that package's config rather than the workspace-root one.
-     */
-    async fixFileAsync(filePath, cwd) {
-        if (!(await this.ensureAvailable())) {
-            return {
-                success: false,
-                changed: false,
-                fixed: 0,
-                error: "Ruff not available",
-            };
-        }
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath)) {
-            return {
-                success: false,
-                changed: false,
-                fixed: 0,
-                error: "File not found",
-            };
-        }
-        try {
-            const before = await fs.promises.readFile(absolutePath, "utf-8");
-            // #2894: the root ruff resolves its config from now comes from the
-            // shared seam, not a local `cwd ?? path.dirname(file)`. `tool-policy.ts`
-            // requires the lint runner (`ruff.ts`, on `resolveRunnerCwd`) and this
-            // autofix path to consume the SAME policy; deriving the root two
-            // different ways is how they drift, and the hand-rolled form ignored a
-            // nested `pyproject.toml` whenever the caller passed a workspace root.
-            const ruffCwd = resolveToolCwd("runner", "ruff", absolutePath, {
-                ...(cwd !== undefined && { cwd }),
-            }).cwd;
-            // Shared config-args seam (#1247): the lint runner consumes the same
-            // builder, so `check --fix` can never drift to ruff's default rule
-            // set when the project lacks its own config and the package-owned
-            // core.toml fallback applies.
-            const configArgs = ruffConfigArgs(ruffCwd);
-            const pre = await safeSpawnAsync(this.ruffCommand, [
-                "check",
-                "--output-format",
-                "json",
-                "--target-version",
-                "py310",
-                ...configArgs,
-                absolutePath,
-            ], { timeout: 10000, cwd: ruffCwd });
-            const beforeDiags = pre.stdout?.trim()
-                ? this.parseOutput(pre.stdout, absolutePath)
-                : [];
-            const fixableCount = beforeDiags.filter((d) => d.fixable).length;
-            const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15000, cwd: ruffCwd });
-            if (fix.error) {
-                return {
-                    success: false,
-                    changed: false,
-                    fixed: 0,
-                    error: fix.error.message,
-                };
-            }
-            const after = await fs.promises.readFile(absolutePath, "utf-8");
-            const changed = before !== after;
-            if (changed) {
-                this.log(`Fixed ${fixableCount} issue(s) in ${path.basename(filePath)}`);
-            }
-            return { success: true, changed, fixed: fixableCount };
-        }
-        catch (err) {
-            return { success: false, changed: false, fixed: 0, error: err.message };
-        }
-    }
-    // --- Internal ---
-    parseOutput(output, filterFile) {
-        if (!output.trim())
-            return [];
-        try {
-            const items = JSON.parse(output);
-            const diagnostics = [];
-            for (const item of items) {
-                // Filter to single file if requested
-                if (filterFile && path.resolve(item.filename) !== filterFile)
-                    continue;
-                diagnostics.push({
-                    line: item.location.row - 1, // ruff is 1-indexed
-                    column: item.location.column - 1,
-                    endLine: item.end_location.row - 1,
-                    endColumn: item.end_location.column - 1,
-                    severity: item.code?.startsWith("E") ? "error" : "warning",
-                    message: item.message,
-                    rule: item.code || "unknown",
-                    file: item.filename,
-                    fixable: item.fix !== null,
-                });
-            }
-            return diagnostics;
-        }
-        catch (err) {
-            void err;
-            this.log("Failed to parse ruff JSON output");
-            return [];
-        }
-    }
-}