timonel 2.14.0-beta.1 → 3.0.0

package/dist/lib/utils/helmYamlSerializer.js

@@ -1,5 +1,34 @@
-import { Document, Scalar, isMap, isScalar, visit } from 'yaml';
+import { Document, Scalar, isMap, isScalar, visit, Pair } from 'yaml';
+import { SecurityUtils } from '../security.js';
 import { isHelmConstruct, isHelmExpression, createHelmExpression, } from './helmControlStructures.js';
+import { isHelmValue, isHelmFieldConditional, isHelmRange, isHelmWith, } from './valuesRef.js';
+const FIELD_CONDITIONAL = '__FIELD_CONDITIONAL__:';
+const FIELD_WITH = '__FIELD_WITH__:';
+const FIELD_WITH_MARKER = '__FIELD_WITH_MARKER__:';
+function simpleHelmYaml(obj) {
+    function convertToPlain(value) {
+        if (isHelmValue(value)) {
+            return `{{ ${value.__path} }}`;
+        }
+        if (isHelmExpression(value)) {
+            return value.value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(convertToPlain);
+        }
+        if (value !== null && typeof value === 'object') {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = convertToPlain(v);
+            }
+            return result;
+        }
+        return value;
+    }
+    const plain = convertToPlain(obj);
+    const doc = new Document(plain);
+    return doc.toString({ lineWidth: 0 });
+}
 function serializeElseIfChain(elseContent, openTag, closeTag) {
     let result = '';
     let currentElse = elseContent;
@@ -14,6 +43,9 @@ function serializeElseIfChain(elseContent, openTag, closeTag) {
     return { result, remainingElse: currentElse };
 }
 function serializeHelmConstruct(construct) {
+    if (construct.type === 'fieldConditional') {
+        throw new Error('fieldConditional should not be serialized directly. It must be handled in preprocessHelmConstructs.');
+    }
     const trimLeft = construct.options?.trimLeft ?? true;
     const trimRight = construct.options?.trimRight ?? true;
     const openTag = `{{${trimLeft ? '-' : ''} `;
@@ -21,22 +53,117 @@ function serializeHelmConstruct(construct) {
     switch (construct.type) {
         case 'if': {
             const data = construct.data;
-            let result = `${openTag}if ${data.condition}${closeTag}\n`;
+            const isInline = construct.options?.inline ?? false;
+            const newline = isInline ? '' : '\n';
+            const space = isInline ? ' ' : '';
+            let result = `${openTag}if ${data.condition}${closeTag}${newline}`;
             result += serializeHelmContent(data.then);
             if (data.else !== undefined) {
-                const { result: elseIfResult, remainingElse } = serializeElseIfChain(data.else, openTag, closeTag);
-                result += elseIfResult;
-                if (remainingElse !== undefined) {
-                    result += `\n${openTag}else${closeTag}\n`;
-                    result += serializeHelmContent(remainingElse);
+                if (isInline) {
+                    result += `${space}${openTag}else${closeTag}${space}`;
+                    result += serializeHelmContent(data.else);
+                }
+                else {
+                    const { result: elseIfResult, remainingElse } = serializeElseIfChain(data.else, openTag, closeTag);
+                    result += elseIfResult;
+                    if (remainingElse !== undefined) {
+                        result += `\n${openTag}else${closeTag}\n`;
+                        result += serializeHelmContent(remainingElse);
+                    }
                 }
             }
-            result += `\n${openTag}end${closeTag}`;
+            result += `${newline}${openTag}end${closeTag}`;
             return result;
         }
         case 'fragment': {
             const data = construct.data;
-            return data.map((item) => serializeHelmContent(item)).join('\n');
+            const strings = [];
+            const objects = [];
+            for (const item of data) {
+                if (typeof item === 'object' &&
+                    item !== null &&
+                    !Array.isArray(item) &&
+                    !isHelmConstruct(item) &&
+                    !isHelmExpression(item)) {
+                    objects.push(item);
+                }
+                else {
+                    const serialized = serializeHelmContent(item);
+                    if (serialized.trim().length > 0) {
+                        strings.push(serialized);
+                    }
+                }
+            }
+            if (strings.length > 0 && objects.length > 0) {
+                const combinedObject = objects.reduce((acc, obj) => {
+                    if (typeof obj === 'object' && obj !== null) {
+                        return { ...acc, ...obj };
+                    }
+                    return acc;
+                }, {});
+                const preprocessed = preprocessHelmConstructs(combinedObject);
+                const doc = new Document(preprocessed);
+                visit(doc, (_key, node) => {
+                    if (isMap(node)) {
+                        const isHelmExpr = node.items.some((pair) => isScalar(pair.key) &&
+                            pair.key.value === '__helmExpression' &&
+                            isScalar(pair.value) &&
+                            pair.value.value === true);
+                        if (isHelmExpr) {
+                            const valuePair = node.items.find((pair) => isScalar(pair.key) && pair.key.value === 'value');
+                            if (valuePair && isScalar(valuePair.value)) {
+                                const value = String(valuePair.value.value);
+                                const scalar = new Scalar(value);
+                                if (value.trim().startsWith('{{') && value.includes('\n')) {
+                                    scalar.type = 'BLOCK_LITERAL';
+                                }
+                                else {
+                                    scalar.type = 'QUOTE_DOUBLE';
+                                }
+                                return scalar;
+                            }
+                        }
+                    }
+                    return undefined;
+                });
+                let objectYaml = doc.toString({ lineWidth: 0 }).trim();
+                return [...strings, objectYaml].filter((s) => s.trim().length > 0).join('\n');
+            }
+            if (objects.length > 0) {
+                const combinedObject = objects.reduce((acc, obj) => {
+                    if (typeof obj === 'object' && obj !== null) {
+                        return { ...acc, ...obj };
+                    }
+                    return acc;
+                }, {});
+                const preprocessed = preprocessHelmConstructs(combinedObject);
+                const doc = new Document(preprocessed);
+                visit(doc, (_key, node) => {
+                    if (isMap(node)) {
+                        const isHelmExpr = node.items.some((pair) => isScalar(pair.key) &&
+                            pair.key.value === '__helmExpression' &&
+                            isScalar(pair.value) &&
+                            pair.value.value === true);
+                        if (isHelmExpr) {
+                            const valuePair = node.items.find((pair) => isScalar(pair.key) && pair.key.value === 'value');
+                            if (valuePair && isScalar(valuePair.value)) {
+                                const value = String(valuePair.value.value);
+                                const scalar = new Scalar(value);
+                                if (value.trim().startsWith('{{') && value.includes('\n')) {
+                                    scalar.type = 'BLOCK_LITERAL';
+                                }
+                                else {
+                                    scalar.type = 'QUOTE_DOUBLE';
+                                }
+                                return scalar;
+                            }
+                        }
+                    }
+                    return undefined;
+                });
+                return doc.toString({ lineWidth: 0 }).trim();
+            }
+            return strings.filter((s) => s.trim().length > 0).join('\n');
         }
         case 'range': {
             const data = construct.data;
@@ -58,7 +185,7 @@ function serializeHelmConstruct(construct) {
             if (data.pipe) {
                 result += ` | ${data.pipe}`;
             }
-            result += `${closeTag}`;
+            result += closeTag;
             return result;
         }
         case 'define': {
@@ -104,15 +231,47 @@ function serializeHelmContent(content) {
         return String(content);
     }
     if (typeof content === 'object') {
-        const doc = new Document(content);
+        const preprocessed = preprocessHelmConstructs(content);
+        const doc = new Document(preprocessed);
         let yaml = doc.toString({ lineWidth: 0 });
         yaml = yaml.trim();
         return yaml;
     }
     return '';
 }
-function preprocessHelmConstructs(obj) {
+export function preprocessHelmConstructs(obj) {
+    if (isHelmValue(obj)) {
+        const value = obj;
+        return createHelmExpression(`{{ ${value.__path} }}`);
+    }
+    if (isHelmFieldConditional(obj)) {
+        return obj;
+    }
+    if (isHelmRange(obj)) {
+        const range = obj;
+        const sourcePath = range.source.__path;
+        const itemProxy = { __path: '$item' };
+        const indexProxy = { __path: '$index' };
+        const content = range.callback(itemProxy, indexProxy);
+        const processedContent = preprocessHelmConstructs(content);
+        const contentDoc = new Document(processedContent);
+        const contentStr = contentDoc.toString({ lineWidth: 0 }).trim();
+        return createHelmExpression(`{{- range ${sourcePath} }}\n${contentStr}\n{{- end }}`);
+    }
+    if (isHelmWith(obj)) {
+        return obj;
+    }
     if (isHelmConstruct(obj)) {
+        if (obj.type === 'fieldConditional') {
+            return obj;
+        }
+        if (obj.type === 'if') {
+            const ifData = obj.data;
+            const isInline = obj.options?.inline ?? false;
+            if (!isInline && (ifData.else === undefined || !('else' in ifData))) {
+                return obj;
+            }
+        }
         const helmTemplate = serializeHelmConstruct(obj);
         return createHelmExpression(helmTemplate);
     }
@@ -125,6 +284,111 @@ function preprocessHelmConstructs(obj) {
         }
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
+            if (isHelmWith(value)) {
+                const withBlock = value;
+                const source = withBlock.source;
+                const sourcePath = source?.__path;
+                if (!sourcePath) {
+                    throw new Error('HelmWith source must have a valid __path');
+                }
+                const ctxProxy = { __path: '.' };
+                const content = withBlock.callback(ctxProxy);
+                let contentStr;
+                if (isHelmExpression(content)) {
+                    contentStr = content.value;
+                }
+                else {
+                    const processedContent = preprocessHelmConstructs(content);
+                    const contentDoc = new Document(processedContent);
+                    contentStr = contentDoc.toString({ lineWidth: 0 }).trim();
+                }
+                const template = `{{- with ${sourcePath} }}\n${key}:\n  ${contentStr}\n{{- end }}`;
+                const marker = `__FIELD_WITH__:${key}:${template}`;
+                result[`__fieldWithTemplate_${key}`] = createHelmExpression(marker);
+                continue;
+            }
+            if (isHelmConstruct(value) && value.type === 'if') {
+                const ifData = value.data;
+                const isInline = value.options?.inline ?? false;
+                if (!isInline && (ifData.else === undefined || !('else' in ifData))) {
+                    const preprocessedThen = preprocessHelmConstructs(ifData.then);
+                    let thenValueStr = '';
+                    let isMultilineObject = false;
+                    if (isHelmExpression(preprocessedThen)) {
+                        thenValueStr = preprocessedThen.value.trim();
+                        isMultilineObject = thenValueStr.includes('\n');
+                    }
+                    else if (typeof preprocessedThen === 'string') {
+                        thenValueStr = preprocessedThen.trim();
+                        isMultilineObject = thenValueStr.includes('\n');
+                    }
+                    else if (Array.isArray(preprocessedThen)) {
+                        const tempDoc = new Document(preprocessedThen);
+                        thenValueStr = tempDoc.toString({ lineWidth: 0 }).trim();
+                        isMultilineObject = true;
+                    }
+                    else {
+                        const tempDoc = new Document(preprocessedThen);
+                        thenValueStr = tempDoc.toString({ lineWidth: 0 }).trim();
+                        isMultilineObject = thenValueStr.includes('\n');
+                    }
+                    const constructOptions = isHelmConstruct(value) ? value.options : undefined;
+                    const trimLeft = constructOptions?.trimLeft ?? true;
+                    const openTag = `{{${trimLeft ? '-' : ''} `;
+                    const closeTag = ` ${(constructOptions?.trimRight ?? true) ? '-' : ''}}}`;
+                    let formattedContent;
+                    if (isMultilineObject) {
+                        const indentedValue = thenValueStr
+                            .split('\n')
+                            .map((line) => '    ' + line)
+                            .join('\n');
+                        formattedContent = `${key}:\n${indentedValue}`;
+                    }
+                    else {
+                        formattedContent = `${key}: ${thenValueStr}`;
+                    }
+                    const conditionalTemplate = `${openTag}if ${ifData.condition}${closeTag}\n  ${formattedContent}\n${openTag}end${closeTag}`;
+                    result[key] = createHelmExpression(`__FIELD_CONDITIONAL__:${key}:${conditionalTemplate}`);
+                    continue;
+                }
+            }
+            if (isHelmFieldConditional(value)) {
+                const fieldCond = value;
+                const condition = fieldCond.condition.__condition;
+                const thenValueStr = simpleHelmYaml(fieldCond.thenValue).trim();
+                const isMultilineObject = thenValueStr.includes('\n');
+                const startsWithDash = thenValueStr.trimStart().startsWith('-');
+                let formattedContent;
+                if (isMultilineObject || startsWithDash) {
+                    const lines = thenValueStr.split('\n');
+                    const indentedValue = lines.map((line) => '  ' + line).join('\n');
+                    formattedContent = `${key}:\n${indentedValue}`;
+                }
+                else {
+                    formattedContent = `${key}: ${thenValueStr}`;
+                }
+                const conditionalTemplate = `{{- if ${condition} }}\n${formattedContent}\n{{- end }}`;
+                result[key] = createHelmExpression(`__FIELD_CONDITIONAL__:${key}:${conditionalTemplate}`);
+                continue;
+            }
+            if (isHelmConstruct(value) && value.type === 'fieldConditional') {
+                const fieldData = value.data;
+                const preprocessedThen = preprocessHelmConstructs(fieldData.then);
+                let thenValueStr = '';
+                if (isHelmExpression(preprocessedThen)) {
+                    thenValueStr = preprocessedThen.value;
+                }
+                else if (typeof preprocessedThen === 'string') {
+                    thenValueStr = preprocessedThen;
+                }
+                else {
+                    const tempDoc = new Document(preprocessedThen);
+                    thenValueStr = tempDoc.toString({ lineWidth: 0 }).trim();
+                }
+                const conditionalTemplate = `{{- if ${fieldData.condition} }}\n  ${fieldData.fieldKey}: ${thenValueStr}\n{{- end }}`;
+                result[`__fieldConditionalTemplate_${fieldData.fieldKey}`] = conditionalTemplate;
+                continue;
+            }
             result[key] = preprocessHelmConstructs(value);
         }
         return result;
@@ -144,10 +408,22 @@ export function dumpHelmAwareYaml(obj, options = {}) {
                 const valuePair = node.items.find((pair) => isScalar(pair.key) && pair.key.value === 'value');
                 if (valuePair && isScalar(valuePair.value)) {
                     const value = String(valuePair.value.value);
+                    if (value.startsWith(FIELD_CONDITIONAL) ||
+                        value.startsWith(FIELD_WITH) ||
+                        value.startsWith(FIELD_WITH_MARKER)) {
+                        const scalar = new Scalar(value);
+                        scalar.type = 'BLOCK_LITERAL';
+                        return scalar;
+                    }
                     const scalar = new Scalar(value);
-                    if (value.trim().startsWith('{{') && value.includes('\n')) {
+                    const isMultilineTemplate = value.includes('\n') && value.trim().startsWith('{{');
+                    const isWithOrRange = value.trim().startsWith('{{- with ') || value.trim().startsWith('{{- range ');
+                    if (isMultilineTemplate && !isWithOrRange) {
                         scalar.type = 'BLOCK_LITERAL';
                     }
+                    else if (isWithOrRange) {
+                        scalar.type = 'PLAIN';
+                    }
                     else {
                         scalar.type = 'QUOTE_DOUBLE';
                     }
@@ -157,14 +433,216 @@ export function dumpHelmAwareYaml(obj, options = {}) {
         }
         return undefined;
     });
-    const toStringOptions = {};
+    const toStringOptions = { lineWidth: 0 };
     if (options.lineWidth !== undefined) {
         toStringOptions.lineWidth = options.lineWidth;
     }
+    const templatePairs = [];
+    visit(doc, (_key, node) => {
+        if (isMap(node)) {
+            for (let i = 0; i < node.items.length; i++) {
+                const pair = node.items[i];
+                if (pair && isScalar(pair.key)) {
+                    const keyStr = String(pair.key.value);
+                    if (keyStr.startsWith('__fieldConditionalTemplate_') && isScalar(pair.value)) {
+                        const template = String(pair.value.value);
+                        const fieldKey = keyStr.replace('__fieldConditionalTemplate_', '');
+                        templatePairs.push({ parent: node, index: i, template, fieldKey });
+                    }
+                }
+            }
+        }
+        return undefined;
+    });
+    for (let i = templatePairs.length - 1; i >= 0; i--) {
+        const templatePair = templatePairs[i];
+        if (!templatePair)
+            continue;
+        const { parent, index, template } = templatePair;
+        parent.items.splice(index, 1);
+        const tempDoc = new Document({ __temp: template });
+        const _tempYaml = tempDoc.toString({ lineWidth: 0 });
+        const templateScalar = new Scalar(template);
+        templateScalar.type = 'BLOCK_LITERAL';
+        const specialKeyScalar = new Scalar('__fieldConditionalContent');
+        const templatePairObj = new Pair(specialKeyScalar, templateScalar);
+        parent.items.splice(index, 0, templatePairObj);
+    }
     let result = doc.toString(toStringOptions);
+    while (result.includes('__fieldConditionalContent:')) {
+        const markerIndex = result.indexOf('__fieldConditionalContent:');
+        if (markerIndex === -1)
+            break;
+        const lineStart = result.lastIndexOf('\n', markerIndex);
+        const lineBeforeMarker = result.substring(lineStart + 1, markerIndex);
+        const indentMatch = lineBeforeMarker.match(/^(\s*)/);
+        const baseIndent = indentMatch && indentMatch[1] ? indentMatch[1] : '';
+        const afterMarker = result.substring(markerIndex);
+        let pipeLineMatch = afterMarker.match(/^__fieldConditionalContent:\s*(\|-?)\s*\n(\s*)/);
+        let pipeOnSameLine = true;
+        if (!pipeLineMatch) {
+            pipeLineMatch = afterMarker.match(/^__fieldConditionalContent:\s*\n(\s*)(\|-?)\s*\n/);
+            pipeOnSameLine = false;
+        }
+        if (!pipeLineMatch)
+            break;
+        const pipeChar = pipeOnSameLine ? pipeLineMatch[1] : pipeLineMatch[2];
+        const pipeIndent = pipeOnSameLine ? pipeLineMatch[2] || '' : pipeLineMatch[1] || '';
+        if (!pipeChar)
+            break;
+        const pipeIndex = markerIndex + pipeLineMatch[0].length;
+        const afterPipe = result.substring(pipeIndex);
+        const templateStartMatch = afterPipe.match(/^\n(\s*)(\{\{-)/);
+        if (!templateStartMatch) {
+            const templateStartMatchNoNewline = afterPipe.match(/^(\s*)(\{\{-)/);
+            if (!templateStartMatchNoNewline)
+                break;
+            const _templateIndent = templateStartMatchNoNewline[1] || '';
+            const templateStart = templateStartMatchNoNewline[2];
+            if (!templateStart)
+                break;
+            const templateStartIndex = pipeIndex + templateStartMatchNoNewline[0].length;
+            const templateSection = result.substring(templateStartIndex);
+            const endMatch = templateSection.match(/(\{\{-?\s*end\s*-?\}\})/);
+            if (!endMatch)
+                break;
+            const endIndex = endMatch.index;
+            if (endIndex === undefined)
+                break;
+            const templateEndIndex = templateStartIndex + endIndex + endMatch[0].length;
+            const templateContent = result.substring(templateStartIndex, templateEndIndex);
+            const beforeMarker = result.substring(0, lineStart + 1);
+            const afterTemplate = result.substring(templateEndIndex);
+            const pipeIndentEscaped = pipeIndent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const adjustedTemplate = templateContent.replace(new RegExp(`^${pipeIndentEscaped}`, 'gm'), baseIndent);
+            result = beforeMarker + adjustedTemplate + afterTemplate;
+            continue;
+        }
+        const _templateIndent = templateStartMatch[1] || '';
+        const templateStart = templateStartMatch[2];
+        if (!templateStart)
+            break;
+        const templateStartIndex = pipeIndex + templateStartMatch[0].length;
+        const templateSection = result.substring(templateStartIndex);
+        const endMatch = templateSection.match(/(\{\{-?\s*end\s*-?\}\})/);
+        if (!endMatch)
+            break;
+        const endIndex = endMatch.index;
+        if (endIndex === undefined)
+            break;
+        const templateEndIndex = templateStartIndex + endIndex + endMatch[0].length;
+        const templateContent = result.substring(templateStartIndex, templateEndIndex);
+        const beforeMarker = result.substring(0, lineStart + 1);
+        const afterTemplate = result.substring(templateEndIndex);
+        const pipeIndentEscaped = pipeIndent.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const adjustedTemplate = templateContent.replace(new RegExp(`^${pipeIndentEscaped}`, 'gm'), baseIndent);
+        result = beforeMarker + adjustedTemplate + afterTemplate;
+    }
     result = result.replace(/\\"/g, '"');
-    result = result.replace(/\\\\/g, '');
-    result = result.replace(/:\s*\|[-+]?\s*\n(\s*\{\{)/g, ':\n$1');
+    result = result.replace(/^(\s+)(\w+):\s+(\{\{-?\s*if\s+[^}]+\}\})\s*\n(\s+)(.+?)\n(\s+)(\{\{-?\s*end\s*-?\}\})/gm, (match, baseIndent, fieldKey, ifTag, contentIndent, content, endIndent, endTag) => {
+        const contentLines = content.split('\n');
+        const firstContentLine = contentLines[0]?.trim() || '';
+        if (firstContentLine.startsWith(`${fieldKey}:`)) {
+            const escapedFieldKey = fieldKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            contentLines[0] = contentLines[0].replace(new RegExp(`^\\s*${escapedFieldKey}:\\s*`), '');
+            content = contentLines.join('\n');
+        }
+        const contentFormatted = content
+            ? '\n' +
+                content
+                    .split('\n')
+                    .map((line) => baseIndent + '    ' + line.trimStart())
+                    .join('\n')
+            : '';
+        return `${baseIndent}${ifTag}\n${baseIndent}  ${fieldKey}:${contentFormatted}\n${baseIndent}${endTag}`;
+    });
+    result = postProcessFieldConditionals(result);
+    return result;
+}
+export function postProcessFieldConditionals(yaml) {
+    let result = yaml;
+    while (result.includes('__FIELD_WITH_MARKER__:')) {
+        const markerIndex = result.indexOf('__FIELD_WITH_MARKER__:');
+        if (markerIndex === -1)
+            break;
+        const beforeMarker = result.substring(0, markerIndex);
+        const lastNewline = beforeMarker.lastIndexOf('\n');
+        const secondLastNewline = beforeMarker.lastIndexOf('\n', lastNewline - 1);
+        const fieldKeyLine = result.substring(secondLastNewline + 1, lastNewline);
+        const fieldKeyMatch = fieldKeyLine.match(/^(\s*)(\w+):\s*|[-]?\s*$/);
+        if (!fieldKeyMatch || !fieldKeyMatch[2])
+            break;
+        const baseIndent = fieldKeyMatch[1] || '';
+        const fieldKey = fieldKeyMatch[2];
+        const afterMarker = result.substring(markerIndex);
+        const markerMatch = afterMarker.match(/^__FIELD_WITH_MARKER__:([^:]+):(.+?)$/m);
+        if (!markerMatch || !markerMatch[1] || !markerMatch[2])
+            break;
+        const path = markerMatch[1];
+        const content = markerMatch[2].trim();
+        const markerEnd = markerIndex + markerMatch[0].length;
+        const template = `${baseIndent}{{- with ${path} }}\n${baseIndent}${fieldKey}:\n${baseIndent}  ${content}\n${baseIndent}{{- end }}`;
+        result = result.substring(0, secondLastNewline + 1) + template + result.substring(markerEnd);
+    }
+    while (result.includes('__FIELD_WITH__:')) {
+        const markerIndex = result.indexOf('__FIELD_WITH__:');
+        if (markerIndex === -1)
+            break;
+        const beforeMarker = result.substring(0, markerIndex);
+        const lastNewline = beforeMarker.lastIndexOf('\n');
+        const secondLastNewline = beforeMarker.lastIndexOf('\n', lastNewline - 1);
+        const fieldKeyLine = result.substring(secondLastNewline + 1, lastNewline);
+        const fieldKeyMatch = fieldKeyLine.match(/^(\s*)__fieldWithTemplate_\w+:\s*|[-]?\s*$/);
+        if (!fieldKeyMatch)
+            break;
+        const baseIndent = fieldKeyMatch[1];
+        const afterMarker = result.substring(markerIndex);
+        const markerMatch = afterMarker.match(/^__FIELD_WITH__:\w+:(.+?\{\{-?\s*end\s*-?\}\})/s);
+        if (!markerMatch || !markerMatch[1])
+            break;
+        const template = markerMatch[1];
+        const markerEnd = markerIndex + markerMatch[0].length;
+        const lines = template.split('\n');
+        const processed = lines
+            .map((line) => {
+            if (!line.trim())
+                return '';
+            const trimmed = line.trimStart();
+            return baseIndent + trimmed;
+        })
+            .join('\n');
+        result = result.substring(0, secondLastNewline + 1) + processed + result.substring(markerEnd);
+    }
+    while (result.includes('__FIELD_CONDITIONAL__:')) {
+        const markerIndex = result.indexOf('__FIELD_CONDITIONAL__:');
+        if (markerIndex === -1)
+            break;
+        const beforeMarker = result.substring(0, markerIndex);
+        const lastNewline = beforeMarker.lastIndexOf('\n');
+        const secondLastNewline = beforeMarker.lastIndexOf('\n', lastNewline - 1);
+        const fieldKeyLine = result.substring(secondLastNewline + 1, lastNewline);
+        const fieldKeyMatch = fieldKeyLine.match(/^(\s*)(\w+):\s*|[-]?\s*$/);
+        if (!fieldKeyMatch)
+            break;
+        const baseIndent = fieldKeyMatch[1];
+        const afterMarker = result.substring(markerIndex);
+        const markerMatch = afterMarker.match(/^__FIELD_CONDITIONAL__:\w+:(.+?\{\{-?\s*end\s*-?\}\})/s);
+        if (!markerMatch || !markerMatch[1])
+            break;
+        const template = markerMatch[1];
+        const markerEnd = markerIndex + markerMatch[0].length;
+        const lines = template.split('\n');
+        const processed = lines
+            .map((line) => {
+            if (!line.trim())
+                return '';
+            const trimmed = line.trimStart();
+            return baseIndent + trimmed;
+        })
+            .join('\n');
+        result = result.substring(0, secondLastNewline + 1) + processed + result.substring(markerEnd);
+    }
+    result = result.replace(/:\s*\|[-+]?\s*\n([ \t]*\{\{)/g, ':\n$1');
     result = result.replace(/"(\{\{[\s\S]*?\}\})"/g, '$1');
     return result;
 }
@@ -242,13 +720,14 @@ export function parseHelmExpressions(content) {
             let match;
             regex.lastIndex = 0;
             while ((match = regex.exec(line)) !== null) {
+                const sanitizedExpression = SecurityUtils.sanitizeLogMessage(match[0] || '');
                 expressions.push({
                     type,
-                    expression: match[0],
+                    expression: sanitizedExpression,
                     startLine: i + 1,
                     startCol: match.index + 1,
                     endLine: i + 1,
-                    endCol: match.index + match[0].length + 1,
+                    endCol: match.index + (match[0]?.length || 0) + 1,
                 });
                 if (match.index === regex.lastIndex)
                     regex.lastIndex++;
@@ -304,14 +783,19 @@ function validateFunctionCalls(_content) {
 function checkCommonIssues(yaml, warnings) {
     const deprecatedFunctions = ['template'];
     for (const func of deprecatedFunctions) {
-        const pattern = new RegExp(`\\{\\{[^}]*\\b${func}\\b[^}]*\\}\\}`, 'g');
+        if (!/^[a-zA-Z0-9_]+$/.test(func)) {
+            continue;
+        }
+        const escapedFunc = func.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const pattern = new RegExp(`\\{\\{[^}]*\\b${escapedFunc}\\b[^}]*\\}\\}`, 'g');
         let match;
         while ((match = pattern.exec(yaml)) !== null) {
+            const sanitizedFunc = SecurityUtils.sanitizeLogMessage(func);
             warnings.push({
                 type: 'semantic',
-                message: `Function '${func}' is deprecated`,
+                message: `Function '${sanitizedFunc}' is deprecated`,
                 expression: match[0],
-                suggestion: `Consider avoiding deprecated function '${func}'`,
+                suggestion: `Consider avoiding deprecated function '${sanitizedFunc}'`,
             });
         }
     }
@@ -322,11 +806,13 @@ function checkQuotedExpressions(yaml, warnings) {
         let match;
         pattern.lastIndex = 0;
         while ((match = pattern.exec(yaml)) !== null) {
+            const sanitizedMatch = SecurityUtils.sanitizeLogMessage(match[1] || '');
+            const sanitizedExpression = SecurityUtils.sanitizeLogMessage(match[0] || '');
             warnings.push({
                 type: 'semantic',
                 message: 'Helm expression should not be quoted',
-                expression: match[0],
-                suggestion: `Remove quotes around: ${match[1]}`,
+                expression: sanitizedExpression,
+                suggestion: `Remove quotes around: ${sanitizedMatch}`,
             });
         }
     }