timonel 2.13.0 → 3.0.0-beta.1

package/dist/lib/utils/helmYamlSerializer.js

@@ -1,114 +1,660 @@
-import * as jsYaml from 'js-yaml';
-const _HELM_EXPRESSION_PATTERNS = [
-    /\{\{-?\s*define\s+[^}]+\s*-?\}\}[\s\S]*?\{\{-?\s*end\s*-?\}\}/g,
-    /\{\{[^}]*\{\{[^}]*\}\}[^}]*\}\}/g,
-    /\{\{\/\*[\s\S]*?\*\/\}\}/g,
-    /\{\{-?[\s\S]*?-?\}\}/g,
-];
-const COMPILED_PATTERNS = [
-    { regex: /\{\{-?\s*define\s+[^}]+\s*-?\}\}[\s\S]*?\{\{-?\s*end\s*-?\}\}/g, type: 'block' },
-    { regex: /\{\{[^}]*\{\{[^}]*\}\}[^}]*\}\}/g, type: 'nested' },
-    { regex: /\{\{\/\*[\s\S]*?\*\/\}\}/g, type: 'comment' },
-    { regex: /\{\{-?[\s\S]*?-?\}\}/g, type: 'action-trimmed' },
-    { regex: /\{\{`[\s\S]*?`\}\}/g, type: 'raw' },
-    { regex: /\{\{\s*include\s+"[^"]+"\s+[^}]+\s*\}\}/g, type: 'include-context' },
-];
-function createHelmExpression(value) {
-    return {
-        __helmExpression: true,
-        value,
-    };
+import { Document, Scalar, isMap, isScalar, visit, Pair } from 'yaml';
+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 isHelmExpression(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        '__helmExpression' in value &&
-        value.__helmExpression === true);
+function serializeElseIfChain(elseContent, openTag, closeTag) {
+    let result = '';
+    let currentElse = elseContent;
+    if (isHelmConstruct(currentElse) && currentElse.type === 'if') {
+        while (isHelmConstruct(currentElse) && currentElse.type === 'if') {
+            const elseIfData = currentElse.data;
+            result += `\n${openTag}else if ${elseIfData.condition}${closeTag}\n`;
+            result += serializeHelmContent(elseIfData.then);
+            currentElse = elseIfData.else;
+        }
+    }
+    return { result, remainingElse: currentElse };
 }
-function detectHelmExpressions(str) {
-    const matches = [];
-    for (const { regex, type } of COMPILED_PATTERNS) {
-        regex.lastIndex = 0;
-        let result;
-        while ((result = regex.exec(str)) !== null) {
-            matches.push({
-                type,
-                expression: result[0],
-                start: result.index,
-                end: result.index + result[0].length,
-            });
-            if (result.index === regex.lastIndex)
-                regex.lastIndex++;
+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 ? '-' : ''} `;
+    const closeTag = ` ${trimRight ? '-' : ''}}}`;
+    switch (construct.type) {
+        case 'if': {
+            const data = construct.data;
+            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) {
+                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 += `${newline}${openTag}end${closeTag}`;
+            return result;
+        }
+        case 'fragment': {
+            const data = construct.data;
+            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;
+            let result = `${openTag}range ${data.vars} := ${data.collection}${closeTag}\n`;
+            result += serializeHelmContent(data.content);
+            result += `\n${openTag}end${closeTag}`;
+            return result;
+        }
+        case 'with': {
+            const data = construct.data;
+            let result = `${openTag}with ${data.scope}${closeTag}\n`;
+            result += serializeHelmContent(data.content);
+            result += `\n${openTag}end${closeTag}`;
+            return result;
+        }
+        case 'include': {
+            const data = construct.data;
+            let result = `${openTag}include "${data.templateName}" ${data.scope}`;
+            if (data.pipe) {
+                result += ` | ${data.pipe}`;
+            }
+            result += closeTag;
+            return result;
+        }
+        case 'define': {
+            const data = construct.data;
+            let result = `${openTag}define "${data.name}"${closeTag}\n`;
+            result += serializeHelmContent(data.content);
+            result += `\n${openTag}end${closeTag}`;
+            return result;
+        }
+        case 'var': {
+            const data = construct.data;
+            return `${openTag}${data.name} := ${data.value}${closeTag}`;
+        }
+        case 'block': {
+            const data = construct.data;
+            let result = `${openTag}block "${data.name}" .${closeTag}\n`;
+            result += serializeHelmContent(data.content);
+            result += `\n${openTag}end${closeTag}`;
+            return result;
         }
+        case 'comment': {
+            const data = construct.data;
+            return `{{/* ${data.text} */}}`;
+        }
+        default:
+            throw new Error(`Unknown Helm construct type: ${construct.type}`);
     }
-    return matches.sort((a, b) => a.start - b.start);
 }
-function preprocessHelmExpressions(obj, depth = 0) {
-    if (depth > 100) {
-        throw new Error('Maximum recursion depth exceeded during Helm preprocessing');
+function serializeHelmContent(content) {
+    if (isHelmConstruct(content)) {
+        return serializeHelmConstruct(content);
+    }
+    if (isHelmExpression(content)) {
+        return content.value;
+    }
+    if (content === null || content === undefined) {
+        return '';
+    }
+    if (typeof content === 'string') {
+        return content;
     }
-    if (isHelmExpression(obj)) {
+    if (typeof content === 'number' || typeof content === 'boolean') {
+        return String(content);
+    }
+    if (typeof content === 'object') {
+        const preprocessed = preprocessHelmConstructs(content);
+        const doc = new Document(preprocessed);
+        let yaml = doc.toString({ lineWidth: 0 });
+        yaml = yaml.trim();
+        return yaml;
+    }
+    return '';
+}
+export function preprocessHelmConstructs(obj) {
+    if (isHelmValue(obj)) {
+        const value = obj;
+        return createHelmExpression(`{{ ${value.__path} }}`);
+    }
+    if (isHelmFieldConditional(obj)) {
         return obj;
     }
-    if (typeof obj === 'string') {
-        if (detectHelmExpressions(obj).length > 0) {
-            return createHelmExpression(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);
+    }
     if (Array.isArray(obj)) {
-        return obj.map((item) => preprocessHelmExpressions(item, depth + 1));
+        return obj.map((item) => preprocessHelmConstructs(item));
     }
-    if (typeof obj === 'object' && obj !== null) {
+    if (obj !== null && typeof obj === 'object') {
+        if (isHelmExpression(obj)) {
+            return obj;
+        }
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
-            Object.defineProperty(result, key, {
-                value: preprocessHelmExpressions(value, depth + 1),
-                writable: true,
-                enumerable: true,
-                configurable: true,
-            });
+            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;
     }
     return obj;
 }
-function helmAwareReplacer(key, value) {
-    if (isHelmExpression(value)) {
-        return value.value;
+export function dumpHelmAwareYaml(obj, options = {}) {
+    const preprocessed = preprocessHelmConstructs(obj);
+    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);
+                    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);
+                    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';
+                    }
+                    return scalar;
+                }
+            }
+        }
+        return undefined;
+    });
+    const toStringOptions = { lineWidth: 0 };
+    if (options.lineWidth !== undefined) {
+        toStringOptions.lineWidth = options.lineWidth;
     }
-    return value;
-}
-function postProcessHelmExpressions(yaml) {
-    let processed = yaml;
-    processed = processed.replace(/'(\{\{[^}]*\}\})'/g, '$1');
-    processed = processed.replace(/"(\{\{[^}]*\}\})"/g, '$1');
-    processed = processed.replace(/'(\{\{[^}]*\\"[^}]*\}\})'/g, '$1');
-    processed = processed.replace(/"(\{\{[^}]*\\"[^}]*\}\})"/g, '$1');
-    processed = processed.replace(/\\(\{\{[^}]+\}\})/g, '$1');
-    return processed;
+    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(/^(\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}:`)) {
+            contentLines[0] = contentLines[0].replace(new RegExp(`^\\s*${fieldKey}:\\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 dumpHelmAwareYaml(obj, options = {}) {
-    const preprocessed = preprocessHelmExpressions(obj);
-    const dumpOptions = {
-        forceQuotes: false,
-        lineWidth: options.lineWidth ?? 0,
-        flowLevel: options.flowLevel ?? -1,
-        replacer: helmAwareReplacer,
-        ...options,
-    };
-    let yamlOutput = jsYaml.dump(preprocessed, dumpOptions);
-    yamlOutput = postProcessHelmExpressions(yamlOutput);
-    return yamlOutput;
+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(\s*\{\{)/g, ':\n$1');
+    result = result.replace(/"(\{\{[\s\S]*?\}\})"/g, '$1');
+    return result;
 }
 export function stringify(obj, options = {}) {
-    const jsYamlOptions = {
-        lineWidth: options.lineWidth ?? 0,
-        quotingType: options.doubleQuotedAsJSON ? '"' : "'",
-        forceQuotes: options.doubleQuotedAsJSON,
-    };
-    return dumpHelmAwareYaml(obj, jsYamlOptions);
+    return dumpHelmAwareYaml(obj, options.lineWidth !== undefined ? { lineWidth: options.lineWidth } : {});
 }
+const COMPILED_PATTERNS = [
+    { regex: /\{\{-?\s*define\s+[^}]+\s*-?\}\}[\s\S]*?\{\{-?\s*end\s*-?\}\}/g, type: 'block' },
+    { regex: /\{\{[^}]*\{\{[^}]*\}\}[^}]*\}\}/g, type: 'nested' },
+    { regex: /\{\{\/\*[\s\S]*?\*\/\}\}/g, type: 'comment' },
+    { regex: /\{\{-?[\s\S]*?-?\}\}/g, type: 'action-trimmed' },
+    { regex: /\{\{`[\s\S]*?`\}\}/g, type: 'raw' },
+    { regex: /\{\{\s*include\s+"[^"]+"\s+[^}]+\s*\}\}/g, type: 'include-context' },
+];
 export function validateHelmYaml(yaml) {
     const errors = [];
     const warnings = [];
@@ -280,120 +826,12 @@ function calculateComplexity(expressions) {
     }
     return score;
 }
-export function prettifyHelmTemplate(yaml, options = {}) {
-    const { indentSize = 2, alignExpressions = true, preserveComments: _preserveComments = true, maxLineWidth = 120, sortKeys = false, groupHelpers = true, } = options;
-    let formatted = yaml;
-    if (groupHelpers) {
-        formatted = groupHelmHelpers(formatted);
-    }
-    if (alignExpressions) {
-        formatted = alignTemplateExpressions(formatted, indentSize);
-    }
-    formatted = formatConditionalBlocks(formatted, indentSize);
-    formatted = formatLoopBlocks(formatted, indentSize);
-    formatted = wrapLongLines(formatted, maxLineWidth);
-    if (sortKeys) {
-        formatted = sortYamlKeys(formatted);
-    }
-    return formatted;
-}
-function alignTemplateExpressions(yaml, _indentSize) {
-    const lines = yaml.split('\n');
-    const aligned = [];
-    for (const line of lines) {
-        const expressions = line.match(/\{\{[^}]*\}\}/g);
-        if (expressions && expressions.length > 1) {
-            const baseIndent = (line.match(/^\s*/) || [''])[0];
-            const content = line.trim();
-            const parts = content.split(/(\{\{[^}]*\}\})/);
-            let alignedLine = baseIndent;
-            for (let i = 0; i < parts.length; i++) {
-                alignedLine += parts[i] || '';
-                const nextPart = parts[i + 1];
-                if (i < parts.length - 1 && nextPart && nextPart.startsWith('{{')) {
-                    alignedLine += ' ';
-                }
-            }
-            aligned.push(alignedLine);
-        }
-        else {
-            aligned.push(line);
-        }
-    }
-    return aligned.join('\n');
+export function detectHelmExpressions(str) {
+    return parseHelmExpressions(str);
 }
-function groupHelmHelpers(yaml) {
-    const lines = yaml.split('\n');
-    const groups = {
-        comments: [],
-        definitions: [],
-        conditionals: [],
-        loops: [],
-        other: [],
-    };
-    for (const line of lines) {
-        if (line.includes('{{/*')) {
-            groups.comments.push(line);
-        }
-        else if (line.includes('{{- define')) {
-            groups.definitions.push(line);
-        }
-        else if (/\{\{\s*(if|else|end)\s/.test(line)) {
-            groups.conditionals.push(line);
-        }
-        else if (/\{\{\s*(range|with)\s/.test(line)) {
-            groups.loops.push(line);
-        }
-        else {
-            groups.other.push(line);
-        }
-    }
-    return [
-        ...groups.comments,
-        ...groups.definitions,
-        ...groups.conditionals,
-        ...groups.loops,
-        ...groups.other,
-    ].join('\n');
-}
-function formatConditionalBlocks(yaml, indentSize) {
-    const indent = ' '.repeat(indentSize);
-    return yaml
-        .replace(/(\{\{\s*if\s+[^}]+\}\})/g, '$1\n' + indent)
-        .replace(/(\{\{\s*else\s*\}\})/g, '$1\n' + indent)
-        .replace(/(\{\{\s*end\s*\}\})/g, '\n$1');
-}
-function formatLoopBlocks(yaml, indentSize) {
-    const indent = ' '.repeat(indentSize);
-    return yaml
-        .replace(/(\{\{\s*range\s+[^}]+\}\})/g, '$1\n' + indent)
-        .replace(/(\{\{\s*with\s+[^}]+\}\})/g, '$1\n' + indent);
-}
-function wrapLongLines(yaml, maxLineWidth) {
-    if (maxLineWidth <= 0)
-        return yaml;
-    const lines = yaml.split('\n');
-    const wrapped = [];
-    for (const line of lines) {
-        if (line.length <= maxLineWidth) {
-            wrapped.push(line);
-            continue;
-        }
-        let remaining = line;
-        while (remaining.length > maxLineWidth) {
-            let wrapIndex = remaining.lastIndexOf(' ', maxLineWidth);
-            if (wrapIndex === -1)
-                wrapIndex = maxLineWidth;
-            wrapped.push(remaining.slice(0, wrapIndex));
-            remaining = remaining.slice(wrapIndex).trim();
-        }
-        if (remaining.length > 0) {
-            wrapped.push(remaining);
-        }
-    }
-    return wrapped.join('\n');
+export function preprocessHelmExpressions(obj) {
+    return preprocessHelmConstructs(obj);
 }
-function sortYamlKeys(yaml) {
+export function postProcessHelmExpressions(yaml) {
     return yaml;
 }
-export { createHelmExpression, isHelmExpression, detectHelmExpressions, preprocessHelmExpressions, postProcessHelmExpressions, };