noteconnection 1.7.0 → 1.8.0

package/dist/src/notemd/cli/commands.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCommands = listCommands;
+exports.findCommand = findCommand;
+exports.getOperationForCommand = getOperationForCommand;
+const registry_1 = require("../operations/registry");
+const CLI_COMMANDS = [
+    {
+        name: 'process-file',
+        aliases: ['process'],
+        description: 'Process a markdown file to add wiki-links and extract concepts',
+        operationId: 'file.process-add-links',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true },
+            { name: 'output', aliases: ['o'], description: 'Custom output path', required: false }
+        ],
+        flags: [
+            { name: 'dry-run', aliases: ['n'], description: 'Preview changes without writing' },
+            { name: 'no-concepts', aliases: ['nc'], description: 'Skip concept note creation' }
+        ]
+    },
+    {
+        name: 'process-folder',
+        aliases: ['pf'],
+        description: 'Process all markdown files in a folder',
+        operationId: 'file.process-folder-add-links',
+        automationLevel: 'interactive-ui',
+        requiredContext: 'folder-selection',
+        sideEffectClass: 'batch-write',
+        params: [
+            { name: 'path', aliases: ['p', 'folder'], description: 'Path to the folder', required: true },
+            { name: 'output', aliases: ['o'], description: 'Custom output folder', required: false }
+        ],
+        flags: [
+            { name: 'dry-run', aliases: ['n'], description: 'Preview changes without writing' }
+        ]
+    },
+    {
+        name: 'generate-content',
+        aliases: ['gen', 'generate'],
+        description: 'Generate content from a note title',
+        operationId: 'content.generate-from-title',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the title file', required: true },
+            { name: 'output', aliases: ['o'], description: 'Custom output path', required: false }
+        ],
+        flags: [
+            { name: 'research', aliases: ['r'], description: 'Enable web research for context' }
+        ]
+    },
+    {
+        name: 'batch-generate',
+        aliases: ['bg'],
+        description: 'Batch generate content from all titles in a folder',
+        operationId: 'content.batch-generate-from-titles',
+        automationLevel: 'interactive-ui',
+        requiredContext: 'folder-selection',
+        sideEffectClass: 'batch-write',
+        params: [
+            { name: 'path', aliases: ['p', 'folder'], description: 'Path to the folder', required: true }
+        ],
+        flags: []
+    },
+    {
+        name: 'translate',
+        aliases: ['tr'],
+        description: 'Translate a markdown file',
+        operationId: 'translate.file',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true },
+            { name: 'language', aliases: ['l', 'lang'], description: 'Target language code', required: true },
+            { name: 'output', aliases: ['o'], description: 'Custom output path', required: false }
+        ],
+        flags: []
+    },
+    {
+        name: 'translate-folder',
+        aliases: ['tf'],
+        description: 'Translate all markdown files in a folder',
+        operationId: 'translate.folder-batch',
+        automationLevel: 'interactive-ui',
+        requiredContext: 'folder-selection',
+        sideEffectClass: 'batch-write',
+        params: [
+            { name: 'path', aliases: ['p', 'folder'], description: 'Path to the folder', required: true },
+            { name: 'language', aliases: ['l', 'lang'], description: 'Target language code', required: true }
+        ],
+        flags: []
+    },
+    {
+        name: 'search',
+        aliases: ['s'],
+        description: 'Search the web for a topic',
+        operationId: 'research.summarize-topic',
+        automationLevel: 'requires-selection',
+        requiredContext: 'editor-selection',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'query', aliases: ['q'], description: 'Search query', required: true },
+            { name: 'provider', aliases: ['prov'], description: 'Search provider (tavily or duckduckgo)', required: false, defaultValue: 'duckduckgo' }
+        ],
+        flags: []
+    },
+    {
+        name: 'generate-diagram',
+        aliases: ['diagram', 'gd'],
+        description: 'Generate a diagram from markdown content',
+        operationId: 'diagram.generate',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'read-only',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true },
+            { name: 'intent', aliases: ['i'], description: 'Diagram intent (mermaid, vega-lite, canvas)', required: false, defaultValue: 'mermaid' },
+            { name: 'output', aliases: ['o'], description: 'Custom output path', required: false },
+            { name: 'mode', aliases: ['m'], description: 'Compatibility mode (best-fit, legacy-mermaid)', required: false, defaultValue: 'best-fit' }
+        ],
+        flags: [
+            { name: 'preview', aliases: ['pv'], description: 'Preview instead of saving' }
+        ]
+    },
+    {
+        name: 'fix-mermaid',
+        aliases: ['fm'],
+        description: 'Fix Mermaid syntax errors in a markdown file',
+        operationId: 'mermaid.batch-fix',
+        automationLevel: 'interactive-ui',
+        requiredContext: 'folder-selection',
+        sideEffectClass: 'batch-write',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file or folder', required: true }
+        ],
+        flags: [
+            { name: 'in-place', aliases: ['i'], description: 'Modify file in place (default: true)' }
+        ]
+    },
+    {
+        name: 'fix-formulas',
+        aliases: ['ff'],
+        description: 'Fix LaTeX formula formatting in markdown',
+        operationId: 'formula.fix-file',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true }
+        ],
+        flags: [
+            { name: 'in-place', aliases: ['i'], description: 'Modify file in place (default: true)' }
+        ]
+    },
+    {
+        name: 'check-duplicates',
+        aliases: ['cd', 'dup'],
+        description: 'Check for duplicate wiki-links and terms',
+        operationId: 'duplicate.check-file',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'read-only',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true }
+        ],
+        flags: []
+    },
+    {
+        name: 'extract-concepts',
+        aliases: ['ec'],
+        description: 'Extract concepts from a markdown file',
+        operationId: 'concept.extract-file',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true }
+        ],
+        flags: []
+    },
+    {
+        name: 'extract-original',
+        aliases: ['eo'],
+        description: 'Extract original text from a processed file',
+        operationId: 'content.extract-original-text',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown file', required: true },
+            { name: 'output', aliases: ['o'], description: 'Custom output path', required: false }
+        ],
+        flags: [
+            { name: 'merged', aliases: ['m'], description: 'Use merged extraction mode' }
+        ]
+    },
+    {
+        name: 'diagnose',
+        aliases: ['diag'],
+        description: 'Diagnose LLM provider connectivity',
+        operationId: 'provider.diagnostic.run',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'read-only',
+        params: [
+            { name: 'provider', aliases: ['p', 'prov'], description: 'Provider name to diagnose', required: false }
+        ],
+        flags: []
+    },
+    {
+        name: 'test-connection',
+        aliases: ['test'],
+        description: 'Test LLM provider connection',
+        operationId: 'provider.connection.test',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'read-only',
+        params: [
+            { name: 'provider', aliases: ['p', 'prov'], description: 'Provider name to test', required: false }
+        ],
+        flags: []
+    },
+    {
+        name: 'capability-manifest',
+        aliases: ['manifest'],
+        description: 'Export the CLI capability manifest',
+        operationId: 'cli.capability-manifest.export',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'output', aliases: ['o'], description: 'Output path for the manifest JSON', required: false }
+        ],
+        flags: []
+    },
+    {
+        name: 'invocation-contract',
+        aliases: ['contract'],
+        description: 'Export the CLI invocation contract',
+        operationId: 'cli.invocation-contract.export',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'output', aliases: ['o'], description: 'Output path for the contract JSON', required: false }
+        ],
+        flags: []
+    },
+    {
+        name: 'export-providers',
+        aliases: ['export'],
+        description: 'Export provider configurations',
+        operationId: 'provider.profile.export',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'output', aliases: ['o'], description: 'Output path for the profile JSON', required: false }
+        ],
+        flags: []
+    },
+    {
+        name: 'import-providers',
+        aliases: ['import'],
+        description: 'Import provider configurations',
+        operationId: 'provider.profile.import',
+        automationLevel: 'safe',
+        requiredContext: 'none',
+        sideEffectClass: 'write-file',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the provider profile JSON', required: true }
+        ],
+        flags: []
+    },
+    {
+        name: 'concept-dedupe',
+        aliases: ['dedupe'],
+        description: 'Check and remove duplicate concept notes',
+        operationId: 'concept.dedupe',
+        automationLevel: 'interactive-ui',
+        requiredContext: 'folder-selection',
+        sideEffectClass: 'destructive',
+        params: [
+            { name: 'path', aliases: ['p', 'folder'], description: 'Path to the concept folder', required: true }
+        ],
+        flags: [
+            { name: 'force', aliases: ['f'], description: 'Delete without confirmation' }
+        ]
+    },
+    {
+        name: 'workflow',
+        aliases: ['wf', 'run'],
+        description: 'Run pipeline: extract concepts → (add wikilinks) → generate titles → fix mermaid',
+        operationId: 'workflow.extract-and-generate',
+        automationLevel: 'requires-active-file',
+        requiredContext: 'active-file',
+        sideEffectClass: 'batch-write',
+        params: [
+            { name: 'path', aliases: ['p', 'file'], description: 'Path to the markdown/text file', required: true },
+            { name: 'output', aliases: ['o'], description: 'Custom output folder path', required: false },
+            { name: 'language', aliases: ['l', 'lang'], description: 'Output language code', required: false }
+        ],
+        flags: [
+            { name: 'with-wikilinks', aliases: ['ww', 'links'], description: 'Add [[wiki-links]] for extracted concepts in source' },
+            { name: 'wikilinks-in-place', aliases: ['wi'], description: 'Modify source in place (default: write _wikified copy)' },
+            { name: 'no-generate', aliases: ['ng'], description: 'Skip content generation stage' },
+            { name: 'no-mermaid', aliases: ['nm'], description: 'Skip Mermaid fix stage' }
+        ]
+    },
+    {
+        name: 'batch-workflow',
+        aliases: ['bwf', 'batch'],
+        description: 'Run pipeline on all matching files in a folder with regex filtering',
+        operationId: 'workflow.batch',
+        automationLevel: 'interactive-ui',
+        requiredContext: 'folder-selection',
+        sideEffectClass: 'batch-write',
+        params: [
+            { name: 'path', aliases: ['p', 'folder'], description: 'Path to the folder', required: true },
+            { name: 'output', aliases: ['o'], description: 'Output base folder path', required: false },
+            { name: 'pattern', aliases: ['filter', 'regex'], description: 'Regex pattern for filename matching', required: false },
+            { name: 'extensions', aliases: ['ext'], description: 'Comma-separated extensions (e.g. ".md,.txt")', required: false },
+            { name: 'max', aliases: ['max-files'], description: 'Maximum files to process', required: false }
+        ],
+        flags: [
+            { name: 'with-wikilinks', aliases: ['ww', 'links'], description: 'Add [[wiki-links]] for extracted concepts in each source' },
+            { name: 'wikilinks-in-place', aliases: ['wi'], description: 'Modify source in place (default: write _wikified copy)' },
+            { name: 'no-generate', aliases: ['ng'], description: 'Skip content generation stage' },
+            { name: 'no-mermaid', aliases: ['nm'], description: 'Skip Mermaid fix stage' }
+        ]
+    }
+];
+const COMMAND_MAP = new Map();
+for (const cmd of CLI_COMMANDS) {
+    COMMAND_MAP.set(cmd.name, cmd);
+    for (const alias of cmd.aliases) {
+        COMMAND_MAP.set(alias, cmd);
+    }
+}
+function listCommands() {
+    return [...CLI_COMMANDS];
+}
+function findCommand(name) {
+    return COMMAND_MAP.get(name);
+}
+function getOperationForCommand(commandName) {
+    const cmd = findCommand(commandName);
+    if (!cmd)
+        return undefined;
+    return (0, registry_1.getOperationDefinition)(cmd.operationId);
+}

package/dist/src/notemd/cli/dispatcher.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchCommand = dispatchCommand;
+const parser_1 = require("./parser");
+const commands_1 = require("./commands");
+const capabilityManifest_1 = require("../operations/capabilityManifest");
+const cliContracts_1 = require("../operations/cliContracts");
+async function dispatchCommand(args, ctx, service, settings) {
+    const parsed = (0, parser_1.parseCliArgs)(args);
+    const cmd = (0, commands_1.findCommand)(parsed.command);
+    if (!cmd) {
+        return {
+            success: false,
+            error: `Unknown command: ${parsed.command}. Available commands:\n${(0, commands_1.listCommands)().map(c => `  ${c.name} - ${c.description}`).join('\n')}`
+        };
+    }
+    try {
+        const result = await executeCommand(cmd, parsed, ctx, service, settings);
+        return { success: true, data: result, operationId: cmd.operationId };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            operationId: cmd.operationId
+        };
+    }
+}
+async function executeCommand(cmd, args, ctx, service, settings) {
+    const { params, flags } = args;
+    switch (cmd.operationId) {
+        case 'file.process-add-links': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            return service.processFile({ filePath, createConceptNotes: !flags.has('no-concepts') }, settings);
+        }
+        case 'file.process-folder-add-links': {
+            const folderPath = (0, parser_1.resolveParam)(params, ['path', 'p', 'folder']);
+            if (!folderPath)
+                throw new Error('Missing required param: --path');
+            return service.processFolder({ folderPath }, settings);
+        }
+        case 'content.generate-from-title': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            const source = await ctx.readFile(filePath);
+            const title = source.split('\n')[0]?.replace(/^#\s*/, '').trim() || 'Untitled';
+            return service.generateContent(title, flags.has('research') ? source : undefined, settings);
+        }
+        case 'content.batch-generate-from-titles': {
+            const folderPath = (0, parser_1.resolveParam)(params, ['path', 'p', 'folder']);
+            if (!folderPath)
+                throw new Error('Missing required param: --path');
+            return service.generateFolderContent(folderPath, settings);
+        }
+        case 'translate.file': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            const language = (0, parser_1.resolveParam)(params, ['language', 'l', 'lang']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            if (!language)
+                throw new Error('Missing required param: --language');
+            return service.translateFile({ filePath, targetLanguage: language }, settings);
+        }
+        case 'research.summarize-topic': {
+            const query = (0, parser_1.resolveParam)(params, ['query', 'q']);
+            if (!query)
+                throw new Error('Missing required param: --query');
+            const provider = (0, parser_1.resolveParam)(params, ['provider', 'prov']);
+            return service.search({ query, provider }, settings);
+        }
+        case 'diagram.generate': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            const content = await ctx.readFile(filePath);
+            const intent = (0, parser_1.resolveParam)(params, ['intent', 'i']);
+            const mode = ((0, parser_1.resolveParam)(params, ['mode', 'm']) || 'best-fit');
+            return service.generateDiagram({
+                content,
+                intent,
+                compatibilityMode: mode,
+                title: filePath
+            }, settings);
+        }
+        case 'mermaid.batch-fix': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            const inPlace = (0, parser_1.resolveBool)(params, flags, ['in-place', 'i']);
+            return service.batchFixMermaid(filePath, inPlace);
+        }
+        case 'formula.fix-file': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            const inPlace = (0, parser_1.resolveBool)(params, flags, ['in-place', 'i']);
+            return service.fixFormulas(filePath, inPlace);
+        }
+        case 'duplicate.check-file': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            return service.checkDuplicates(filePath);
+        }
+        case 'concept.extract-file': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            return service.extractConcepts(filePath, settings);
+        }
+        case 'workflow.extract-and-generate': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            const output = (0, parser_1.resolveParam)(params, ['output', 'o']);
+            const language = (0, parser_1.resolveParam)(params, ['language', 'l', 'lang']);
+            return service.runWorkflow({
+                filePath,
+                outputFolderPath: output,
+                language,
+                addWikiLinks: flags.has('with-wikilinks') || flags.has('ww') || flags.has('links'),
+                wikiLinksInPlace: flags.has('wikilinks-in-place') || flags.has('wi'),
+                skipGenerate: flags.has('no-generate'),
+                skipMermaidFix: flags.has('no-mermaid')
+            }, settings);
+        }
+        case 'content.extract-original-text': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            return service.extractOriginalText({
+                filePath,
+                mergedMode: flags.has('merged')
+            }, settings);
+        }
+        case 'cli.capability-manifest.export':
+            return (0, capabilityManifest_1.buildCliCapabilityManifest)('notemd');
+        case 'cli.invocation-contract.export':
+            return (0, cliContracts_1.buildCliInvocationContract)();
+        case 'provider.diagnostic.run': {
+            const provider = (0, parser_1.resolveParam)(params, ['provider', 'p', 'prov']);
+            return service.diagnoseLlmProvider({ provider }, settings);
+        }
+        case 'provider.connection.test': {
+            const provider = (0, parser_1.resolveParam)(params, ['provider', 'p', 'prov']);
+            return { provider: provider || settings.activeProvider, status: 'not-implemented' };
+        }
+        case 'concept.dedupe': {
+            const folderPath = (0, parser_1.resolveParam)(params, ['path', 'p', 'folder']);
+            if (!folderPath)
+                throw new Error('Missing required param: --path');
+            return { folderPath, dedupeStatus: 'not-implemented' };
+        }
+        case 'workflow.batch': {
+            const folderPath = (0, parser_1.resolveParam)(params, ['path', 'p', 'folder']);
+            if (!folderPath)
+                throw new Error('Missing required param: --path');
+            const output = (0, parser_1.resolveParam)(params, ['output', 'o']);
+            const pattern = (0, parser_1.resolveParam)(params, ['pattern', 'filter', 'regex']);
+            const extensions = (0, parser_1.resolveParam)(params, ['ext', 'extensions']);
+            const maxFiles = (0, parser_1.resolveParam)(params, ['max', 'max-files']);
+            return service.runBatchWorkflow({
+                folderPath,
+                outputBasePath: output,
+                filePattern: pattern,
+                fileExtensions: extensions?.split(',').map(e => e.trim()),
+                addWikiLinks: flags.has('with-wikilinks') || flags.has('ww') || flags.has('links'),
+                wikiLinksInPlace: flags.has('wikilinks-in-place') || flags.has('wi'),
+                skipGenerate: flags.has('no-generate'),
+                skipMermaidFix: flags.has('no-mermaid'),
+                maxFiles: maxFiles ? parseInt(maxFiles, 10) : undefined
+            }, settings);
+        }
+        case 'provider.profile.export': {
+            const { buildProviderProfileExport } = await Promise.resolve().then(() => __importStar(require('../providerProfiles')));
+            return buildProviderProfileExport(settings.providers);
+        }
+        case 'provider.profile.import': {
+            const filePath = (0, parser_1.resolveParam)(params, ['path', 'p', 'file']);
+            if (!filePath)
+                throw new Error('Missing required param: --path');
+            const jsonData = await ctx.readFile(filePath);
+            const { parseProviderProfileImport } = await Promise.resolve().then(() => __importStar(require('../providerProfiles')));
+            return parseProviderProfileImport(jsonData, settings.providers);
+        }
+        default:
+            throw new Error(`Operation ${cmd.operationId} not yet implemented in CLI dispatcher.`);
+    }
+}