@jsonstudio/llms 0.6.633 → 0.6.743

package/dist/tools/tool-registry.js

@@ -27,15 +27,471 @@ const readNumber = (value) => {
     }
     return value;
 };
+const stripArgKeyArtifacts = (input) => {
+    try {
+        return String(input || '')
+            .replace(/<\/?\s*tool_call[^>]*>/gi, '')
+            .replace(/<\/?\s*arg_key\s*>/gi, '')
+            .replace(/<\/?\s*arg_value\s*>/gi, '');
+    }
+    catch {
+        return input;
+    }
+};
+const coercePrimitive = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    if (/^(true|false)$/i.test(trimmed))
+        return /^true$/i.test(trimmed);
+    if (/^-?\d+(?:\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return trimmed;
+        }
+    }
+    return trimmed;
+};
+const extractInjectedArgPairs = (raw) => {
+    const delimiter = '</arg_key><arg_value>';
+    if (typeof raw !== 'string' || !raw.includes(delimiter))
+        return null;
+    const parts = raw.split(delimiter);
+    if (parts.length < 2)
+        return null;
+    const looksLikeKey = (s) => /^[A-Za-z_][A-Za-z0-9_-]*$/.test(s.trim());
+    const pairs = [];
+    let baseValue = parts[0] ?? '';
+    if (parts.length === 2) {
+        const k = (parts[0] ?? '').trim();
+        const v = (parts[1] ?? '').trim();
+        if (looksLikeKey(k) && v.length > 0) {
+            baseValue = '';
+            pairs.push({ key: k, value: coercePrimitive(v) });
+        }
+        return pairs.length ? { baseValue, pairs } : null;
+    }
+    for (let i = 1; i + 1 < parts.length; i += 2) {
+        const key = (parts[i] ?? '').trim();
+        const rawValue = (parts[i + 1] ?? '').trim();
+        if (!looksLikeKey(key)) {
+            continue;
+        }
+        if (rawValue.length === 0) {
+            continue;
+        }
+        pairs.push({ key, value: coercePrimitive(rawValue) });
+    }
+    if (!pairs.length)
+        return null;
+    return { baseValue, pairs };
+};
+const repairArgKeyArtifactsInObject = (value) => {
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            for (const entry of node) {
+                visit(entry);
+            }
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        for (const [k, v] of Object.entries(node)) {
+            if (typeof v === 'string') {
+                const injected = extractInjectedArgPairs(v);
+                if (injected) {
+                    if (injected.baseValue !== '') {
+                        node[k] = injected.baseValue;
+                    }
+                    for (const pair of injected.pairs) {
+                        if (!Object.prototype.hasOwnProperty.call(node, pair.key)) {
+                            node[pair.key] = pair.value;
+                        }
+                    }
+                }
+            }
+            visit(node[k]);
+        }
+    };
+    visit(value);
+};
 const tryParseJson = (input) => {
+    const raw = typeof input === 'string' ? input : '';
+    if (!raw.trim())
+        return {};
     try {
-        const parsed = JSON.parse(input);
-        return isRecord(parsed) ? parsed : {};
+        const parsed = JSON.parse(raw);
+        repairArgKeyArtifactsInObject(parsed);
+        return parsed;
     }
     catch {
+        // try stripping common tool-call markup artifacts and parsing again
+        try {
+            const stripped = stripArgKeyArtifacts(raw).trim();
+            if (stripped && stripped !== raw) {
+                const parsed = JSON.parse(stripped);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // continue
+        }
+        // attempt to parse the first JSON container substring
+        try {
+            const candidate = raw.match(/\{[\s\S]*\}|\[[\s\S]*\]/)?.[0];
+            if (candidate) {
+                const strippedCandidate = stripArgKeyArtifacts(candidate).trim();
+                const parsed = JSON.parse(strippedCandidate);
+                repairArgKeyArtifactsInObject(parsed);
+                return parsed;
+            }
+        }
+        catch {
+            // ignore
+        }
         return {};
     }
 };
+const stripCodeFences = (text) => {
+    const trimmed = text.trim();
+    // Only treat the entire payload as fenced when it *starts* with a code fence.
+    // Patch bodies (especially added Markdown files) may legitimately contain ``` blocks;
+    // we must not strip those.
+    if (!trimmed.startsWith('```')) {
+        return text;
+    }
+    const fenceRe = /^```(?:diff|patch|apply_patch|text|json)?[ \t]*\n([\s\S]*?)\n```/gmi;
+    const candidates = [];
+    let match = null;
+    while ((match = fenceRe.exec(trimmed))) {
+        if (match[1]) {
+            candidates.push(match[1].trim());
+        }
+    }
+    if (!candidates.length) {
+        return text;
+    }
+    for (const candidate of candidates) {
+        if (candidate.includes('*** Begin Patch') ||
+            candidate.includes('*** Update File:') ||
+            candidate.includes('diff --git')) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? text;
+};
+const looksLikePatch = (text) => {
+    if (!text)
+        return false;
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (t.includes('*** Begin Patch') ||
+        t.includes('*** Update File:') ||
+        t.includes('*** Add File:') ||
+        t.includes('*** Delete File:') ||
+        t.includes('diff --git') ||
+        /^(?:@@|\+\+\+\s|---\s)/m.test(t));
+};
+const convertGitDiffToApplyPatch = (text) => {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const files = [];
+    let current = null;
+    let sawDiff = false;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.path && current.kind === 'delete') {
+            files.push(current);
+            current = null;
+            return;
+        }
+        if (!current.path || (current.kind === 'update' && current.lines.length === 0)) {
+            current = null;
+            return;
+        }
+        files.push(current);
+        current = null;
+    };
+    for (const raw of lines) {
+        const line = raw;
+        const diffMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (diffMatch) {
+            sawDiff = true;
+            flush();
+            const path = diffMatch[2] || diffMatch[1];
+            current = { path, kind: 'update', lines: [] };
+            continue;
+        }
+        if (!current) {
+            continue;
+        }
+        if (line.startsWith('new file mode')) {
+            current.kind = 'add';
+            continue;
+        }
+        if (line.startsWith('deleted file mode')) {
+            current.kind = 'delete';
+            continue;
+        }
+        if (line.startsWith('index ') || line.startsWith('old mode') || line.startsWith('new mode')) {
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            if (line.includes('/dev/null')) {
+                current.kind = 'add';
+            }
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            if (line.includes('/dev/null')) {
+                current.kind = 'delete';
+            }
+            else {
+                const plusMatch = line.match(/^\+\+\+\s+(?:b\/)?(.+)$/);
+                if (plusMatch && plusMatch[1]) {
+                    current.path = plusMatch[1];
+                }
+            }
+            continue;
+        }
+        if (current.kind === 'delete') {
+            continue;
+        }
+        if (current.kind === 'add') {
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                current.lines.push(line);
+            }
+            else if (line.startsWith('\\')) {
+                current.lines.push(`+${line}`);
+            }
+            continue;
+        }
+        if (line.startsWith('@@') ||
+            line.startsWith('+') ||
+            line.startsWith('-') ||
+            line.startsWith(' ') ||
+            line.startsWith('\\')) {
+            current.lines.push(line.startsWith('\\') ? ` ${line}` : line);
+        }
+    }
+    flush();
+    if (!sawDiff || files.length === 0) {
+        return null;
+    }
+    const output = ['*** Begin Patch'];
+    for (const file of files) {
+        if (!file.path)
+            continue;
+        if (file.kind === 'add') {
+            output.push(`*** Add File: ${file.path}`);
+            for (const line of file.lines) {
+                if (line.startsWith('+')) {
+                    output.push(line);
+                }
+                else {
+                    output.push(`+${line}`);
+                }
+            }
+            continue;
+        }
+        if (file.kind === 'delete') {
+            output.push(`*** Delete File: ${file.path}`);
+            continue;
+        }
+        output.push(`*** Update File: ${file.path}`);
+        for (const line of file.lines) {
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else {
+                output.push(` ${line}`);
+            }
+        }
+    }
+    output.push('*** End Patch');
+    return output.join('\n');
+};
+const decodeEscapedNewlinesIfNeeded = (value) => {
+    if (!value)
+        return value;
+    if (value.includes('\n'))
+        return value;
+    if (!value.includes('\\n') && !value.includes('\\r') && !value.toLowerCase().includes('\\u000a') && !value.toLowerCase().includes('\\u000d')) {
+        return value;
+    }
+    // Only decode when the patch appears to be newline-escaped into a single line.
+    // This avoids corrupting legitimate file content that contains "\n" sequences.
+    let out = value;
+    out = out.replace(/\\r\\n/g, '\n');
+    out = out.replace(/\\n/g, '\n');
+    out = out.replace(/\\r/g, '\n');
+    out = out.replace(/\\u000a/gi, '\n');
+    out = out.replace(/\\u000d/gi, '\n');
+    return out;
+};
+const normalizeApplyPatchText = (raw) => {
+    if (!raw)
+        return raw;
+    let text = raw.replace(/\r\n/g, '\n');
+    text = decodeEscapedNewlinesIfNeeded(text);
+    text = stripCodeFences(text);
+    text = text.trim();
+    if (!text) {
+        return raw;
+    }
+    if (!text.includes('*** Begin Patch') && text.includes('diff --git')) {
+        const converted = convertGitDiffToApplyPatch(text);
+        if (converted) {
+            text = converted;
+        }
+    }
+    else if (!text.includes('*** Begin Patch') && !text.includes('diff --git')) {
+        // 兼容只包含 --- / +++ / @@ 的 Git diff 片段（无 diff --git 头）
+        const minusMatch = text.match(/^---\s+(.*)$/m);
+        const plusMatch = text.match(/^\+\+\+\s+(.*)$/m);
+        if (minusMatch && plusMatch) {
+            const rawPlus = plusMatch[1] || '';
+            const pathMatch = rawPlus.match(/^(?:b\/)?(.+)$/);
+            const path = (pathMatch && pathMatch[1] ? pathMatch[1] : rawPlus).trim();
+            if (path) {
+                const synthetic = `diff --git a/${path} b/${path}\n${text}`;
+                const converted = convertGitDiffToApplyPatch(synthetic);
+                if (converted) {
+                    text = converted;
+                }
+            }
+        }
+    }
+    if (text.includes('*** Create File:')) {
+        text = text.replace(/\*\*\* Create File:/g, '*** Add File:');
+    }
+    let hasBegin = text.includes('*** Begin Patch');
+    const hasEnd = text.includes('*** End Patch');
+    if (hasBegin && !hasEnd) {
+        text = `${text}\n*** End Patch`;
+    }
+    if (!hasBegin && /^\*\*\* (Add|Update|Delete) File:/m.test(text)) {
+        text = `*** Begin Patch\n${text}\n*** End Patch`;
+        hasBegin = true;
+    }
+    if (!text.includes('*** Begin Patch')) {
+        return text;
+    }
+    // 容错处理：如果补丁前后包裹了多余的 JSON / 文本（例如 {"patch":"*** Begin Patch ... *** End Patch"}），
+    // 则截断到第一个 '*** Begin Patch' 与 '*** End Patch' 之间的主体，恢复为标准 apply_patch 片段。
+    const beginIndex = text.indexOf('*** Begin Patch');
+    if (beginIndex > 0) {
+        text = text.slice(beginIndex);
+    }
+    const endMarker = '*** End Patch';
+    const firstEndIndex = text.indexOf(endMarker);
+    const concatSignatures = [
+        `${endMarker}","input":"*** Begin Patch`,
+        `${endMarker}","patch":"*** Begin Patch`,
+        `${endMarker}\\",\\"input\\":\\"*** Begin Patch`,
+        `${endMarker}\\",\\"patch\\":\\"*** Begin Patch`
+    ];
+    const hasConcatenationSignal = concatSignatures.some((sig) => text.includes(sig));
+    if (hasConcatenationSignal && firstEndIndex >= 0) {
+        text = text.slice(0, firstEndIndex + endMarker.length);
+    }
+    else {
+        const lastEndIndex = text.lastIndexOf(endMarker);
+        if (lastEndIndex >= 0) {
+            const afterEnd = text.slice(lastEndIndex + endMarker.length);
+            if (afterEnd.trim().length > 0) {
+                text = text.slice(0, lastEndIndex + endMarker.length);
+            }
+        }
+    }
+    const lines = text.split('\n');
+    const output = [];
+    let inUpdateSection = false;
+    let afterUpdateHeader = false;
+    for (const line of lines) {
+        if (line.startsWith('*** Begin Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** End Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** Update File:')) {
+            output.push(line);
+            inUpdateSection = true;
+            afterUpdateHeader = true;
+            continue;
+        }
+        if (line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (inUpdateSection) {
+            if (afterUpdateHeader && line.trim() === '') {
+                continue;
+            }
+            afterUpdateHeader = false;
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else {
+                output.push(` ${line}`);
+            }
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join('\n');
+};
+const buildSingleChangePayload = (record) => {
+    const kindRaw = asString(record.kind);
+    if (!kindRaw)
+        return undefined;
+    const change = {
+        kind: kindRaw.toLowerCase(),
+        lines: record.lines ?? record.text ?? record.body,
+        target: asString(record.target) ?? undefined,
+        anchor: asString(record.anchor) ?? undefined
+    };
+    if (typeof record.use_anchor_indent === 'boolean') {
+        change.use_anchor_indent = record.use_anchor_indent;
+    }
+    const changeFile = asString(record.file);
+    if (changeFile) {
+        change.file = changeFile;
+    }
+    return {
+        file: changeFile,
+        changes: [change]
+    };
+};
+const coerceStructuredPayload = (record) => {
+    if (isStructuredApplyPatchPayload(record)) {
+        return record;
+    }
+    if (Array.isArray(record.changes) && record.changes.length === 0) {
+        return undefined;
+    }
+    const single = buildSingleChangePayload(record);
+    if (single) {
+        return single;
+    }
+    return undefined;
+};
 const toJson = (value) => {
     try {
         return JSON.stringify(value ?? {});
@@ -44,6 +500,62 @@ const toJson = (value) => {
         return '{}';
     }
 };
+const extractApplyPatchText = (argsString, rawArgs) => {
+    const rawTrimmed = typeof argsString === 'string' ? argsString.trim() : '';
+    const looksJsonContainer = rawTrimmed.startsWith('{') || rawTrimmed.startsWith('[');
+    if (!looksJsonContainer && looksLikePatch(rawTrimmed)) {
+        return { patchText: normalizeApplyPatchText(rawTrimmed) };
+    }
+    if (isRecord(rawArgs)) {
+        // Special case: argsString claims to be JSON but isn't parseable (tryParseJson fallback returns {}),
+        // and the raw text looks like a patch. Treat it as a patch string to avoid dropping edits.
+        if (looksJsonContainer && Object.keys(rawArgs).length === 0 && looksLikePatch(rawTrimmed)) {
+            return { patchText: normalizeApplyPatchText(rawTrimmed) };
+        }
+        const patchField = asString(rawArgs.patch);
+        if (patchField && looksLikePatch(patchField)) {
+            return { patchText: normalizeApplyPatchText(patchField) };
+        }
+        const inputField = asString(rawArgs.input);
+        if (inputField && looksLikePatch(inputField)) {
+            return { patchText: normalizeApplyPatchText(inputField) };
+        }
+        const payload = coerceStructuredPayload(rawArgs);
+        if (payload) {
+            try {
+                return { patchText: buildStructuredPatch(payload) };
+            }
+            catch (error) {
+                if (!(error instanceof StructuredApplyPatchError)) {
+                    throw error;
+                }
+                return { failureReason: error.reason || 'structured_apply_patch_error' };
+            }
+        }
+    }
+    else if (Array.isArray(rawArgs) && rawArgs.length > 0) {
+        // 兼容形态：arguments 直接是单元素数组 [{ file, changes: [...] }]
+        const first = rawArgs.find((entry) => isRecord(entry));
+        if (first) {
+            const payload = coerceStructuredPayload(first);
+            if (payload) {
+                try {
+                    return { patchText: buildStructuredPatch(payload) };
+                }
+                catch (error) {
+                    if (!(error instanceof StructuredApplyPatchError)) {
+                        throw error;
+                    }
+                    return { failureReason: error.reason || 'structured_apply_patch_error' };
+                }
+            }
+        }
+    }
+    else if (typeof rawArgs === 'string' && looksLikePatch(rawArgs)) {
+        return { patchText: normalizeApplyPatchText(rawArgs) };
+    }
+    return {};
+};
 const detectForbiddenWrite = (script) => {
     const normalized = script.toLowerCase();
     if (!normalized) {
@@ -93,25 +605,30 @@ export function validateToolCall(name, argsString) {
     if (!allowed.has(normalizedName)) {
         return { ok: false, reason: 'unknown_tool' };
     }
-    const rawArgs = tryParseJson(typeof argsString === 'string' ? argsString : '{}');
+    const rawArgsAny = tryParseJson(typeof argsString === 'string' ? argsString : '{}');
     switch (normalizedName) {
         case 'apply_patch': {
-            const record = rawArgs;
-            if (!isStructuredApplyPatchPayload(record)) {
-                return { ok: false, reason: 'missing_changes' };
-            }
-            try {
-                const patchText = buildStructuredPatch(record);
-                return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
-            }
-            catch (error) {
-                if (error instanceof StructuredApplyPatchError) {
-                    return { ok: false, reason: error.reason || 'invalid_patch_payload' };
+            const extracted = extractApplyPatchText(argsString, rawArgsAny);
+            const patchText = extracted.patchText;
+            if (!patchText) {
+                const rawTrimmed = typeof argsString === 'string' ? argsString.trim() : '';
+                const looksJsonContainer = rawTrimmed.startsWith('{') || rawTrimmed.startsWith('[');
+                if (extracted.failureReason) {
+                    return { ok: false, reason: extracted.failureReason };
                 }
-                return { ok: false, reason: 'invalid_patch_payload' };
+                if (looksJsonContainer &&
+                    isRecord(rawArgsAny) &&
+                    Object.keys(rawArgsAny).length === 0 &&
+                    rawTrimmed.length > 0 &&
+                    !looksLikePatch(rawTrimmed)) {
+                    return { ok: false, reason: 'invalid_json' };
+                }
+                return { ok: false, reason: 'missing_changes' };
             }
+            return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
         }
         case 'shell': {
+            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
             const rawCommand = rawArgs.command;
             let normalizedCommand = null;
             if (typeof rawCommand === 'string') {
@@ -153,6 +670,7 @@ export function validateToolCall(name, argsString) {
             return { ok: true, normalizedArgs: toJson(shellArgs) };
         }
         case 'update_plan': {
+            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
             if (!Array.isArray(rawArgs.plan)) {
                 return { ok: false, reason: 'missing_plan' };
             }
@@ -174,6 +692,7 @@ export function validateToolCall(name, argsString) {
             };
         }
         case 'view_image': {
+            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
             const pathValue = asString(rawArgs.path);
             if (!pathValue || !isImagePath(pathValue)) {
                 return { ok: false, reason: 'invalid_image_path' };
@@ -181,6 +700,7 @@ export function validateToolCall(name, argsString) {
             return { ok: true, normalizedArgs: toJson({ path: pathValue }) };
         }
         case 'list_mcp_resources': {
+            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
             const payload = {};
             const server = asString(rawArgs.server);
             if (server) {
@@ -197,6 +717,7 @@ export function validateToolCall(name, argsString) {
             return { ok: true, normalizedArgs: toJson(payload) };
         }
         case 'read_mcp_resource': {
+            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
             const server = asString(rawArgs.server);
             const uri = asString(rawArgs.uri);
             if (!server || !uri) {
@@ -205,6 +726,7 @@ export function validateToolCall(name, argsString) {
             return { ok: true, normalizedArgs: toJson({ server, uri }) };
         }
         case 'list_mcp_resource_templates': {
+            const rawArgs = isRecord(rawArgsAny) ? rawArgsAny : {};
             const payload = {};
             const server = asString(rawArgs.server);
             if (server) {

package/dist/utils/toon.d.ts

@@ -0,0 +1,4 @@
+export type ToonKeyValue = Record<string, string>;
+export declare function decodeToonToKeyValue(toon: string): ToonKeyValue | null;
+export declare function coerceToonValue(value: string): unknown;
+export declare function decodeToonToJson(toon: string): Record<string, unknown> | null;

package/dist/utils/toon.js

@@ -0,0 +1,75 @@
+export function decodeToonToKeyValue(toon) {
+    try {
+        const output = {};
+        const lines = String(toon ?? '')
+            .replace(/\r\n/g, '\n')
+            .split('\n');
+        let currentKey = null;
+        let currentValue = '';
+        const flush = () => {
+            if (currentKey) {
+                output[currentKey] = currentValue;
+            }
+            currentKey = null;
+            currentValue = '';
+        };
+        for (const raw of lines) {
+            const match = raw.match(/^([A-Za-z0-9_\-]+)\s*:\s*(.*)$/);
+            if (match) {
+                flush();
+                currentKey = match[1];
+                currentValue = match[2] ?? '';
+            }
+            else if (currentKey) {
+                currentValue += (currentValue ? '\n' : '') + raw;
+            }
+            else if (raw.trim()) {
+                // Encountered non-empty line before any key was established → treat as invalid TOON.
+                return null;
+            }
+        }
+        flush();
+        return Object.keys(output).length ? output : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function coerceToonValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const lowered = trimmed.toLowerCase();
+    if (lowered === 'true')
+        return true;
+    if (lowered === 'false')
+        return false;
+    if (/^[+-]?\d+(\.\d+)?$/.test(trimmed)) {
+        const num = Number(trimmed);
+        if (Number.isFinite(num)) {
+            return num;
+        }
+    }
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
+        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // fall through
+        }
+    }
+    return value;
+}
+export function decodeToonToJson(toon) {
+    const kv = decodeToonToKeyValue(toon);
+    if (!kv) {
+        return null;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(kv)) {
+        result[key] = coerceToonValue(value);
+    }
+    return result;
+}