From 8e79b61cf9861dcc6bf30ee3d9487e7591fe2309 Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Thu, 11 Sep 2025 16:15:53 -0400
Subject: [PATCH 01/10] Working integration of expanded line formatting for
 exp:channel tags

---
 package.json                         |   6 +
 src/extension.ts                     |   8 +-
 src/providers/EEFormatterProvider.ts |  25 +++
 src/services/EEFormatterService.ts   | 235 +++++++++++++++++++++++++++
 4 files changed, 271 insertions(+), 3 deletions(-)
 create mode 100644 src/providers/EEFormatterProvider.ts
 create mode 100644 src/services/EEFormatterService.ts

diff --git a/package.json b/package.json
index aafddc9..7a67a8e 100644
--- a/package.json
+++ b/package.json
@@ -46,6 +46,12 @@
           "type": "boolean",
           "default": true,
           "description": "Determines if auto-completion and IntelliSense suggestions will show"
+        },
+        "ee.format.wrapAttributes": {
+          "type": "string",
+          "enum": ["auto", "force", "force-expand-multiline", "preserve"],
+          "default": "auto",
+          "description": "Controls how EE tag attributes are wrapped. 'auto' wraps when tag exceeds 80 characters, 'force' always wraps, 'force-expand-multiline' wraps when multiple attributes exist, 'preserve' keeps original formatting."
         }
       }
     },
diff --git a/src/extension.ts b/src/extension.ts
index 27486ca..89241a7 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -8,13 +8,14 @@ import CompletionProvider from './providers/CompletionProvider';
 import ModifierCompletionProvider from './providers/ModifierCompletionProvider';
 import ParametersProvider from './providers/ParameterProvider';
 import GlobalVariableProvider from './providers/GlobalVariableProvider';
+import EEFormatterProvider from './providers/EEFormatterProvider';
 
 /**
  * Activate
- * 
+ *
  * This method is called when your extension is activated
- * 
- * @param context 
+ *
+ * @param context
  */
 export function activate(context: vscode.ExtensionContext) {
   CompletionProvider.register(context);
@@ -23,6 +24,7 @@ export function activate(context: vscode.ExtensionContext) {
   GlobalVariableProvider.register(context);
   IndentRulesProvider.register(context);
   CommandsProvider.register(context);
+  EEFormatterProvider.register(context);
 }
 
 // this method is called when your extension is deactivated
diff --git a/src/providers/EEFormatterProvider.ts b/src/providers/EEFormatterProvider.ts
new file mode 100644
index 0000000..da7685d
--- /dev/null
+++ b/src/providers/EEFormatterProvider.ts
@@ -0,0 +1,25 @@
+import * as vscode from 'vscode';
+import EEFormatterService from '../services/EEFormatterService';
+
+export default class EEFormatterProvider {
+
+    private static formatter: EEFormatterService;
+
+    /**
+     * Register the EE formatter provider
+     * @param context VS Code extension context
+     */
+    public static register(context: vscode.ExtensionContext) {
+        // Create formatter instance
+        this.formatter = new EEFormatterService();
+
+        // Register document formatting provider for HTML language
+        const disposable = vscode.languages.registerDocumentFormattingEditProvider(
+            'html',
+            this.formatter
+        );
+
+        // Add to context subscriptions
+        context.subscriptions.push(disposable);
+    }
+}
diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
new file mode 100644
index 0000000..4d0fb0a
--- /dev/null
+++ b/src/services/EEFormatterService.ts
@@ -0,0 +1,235 @@
+import * as vscode from 'vscode';
+
+export default class EEFormatterService implements vscode.DocumentFormattingEditProvider {
+
+    /**
+     * Format EE tags in the document
+     * @param document The document to format
+     * @param options Formatting options
+     * @param token Cancellation token
+     * @returns Array of text edits
+     */
+    public provideDocumentFormattingEdits(
+        document: vscode.TextDocument,
+        options: vscode.FormattingOptions,
+        token: vscode.CancellationToken
+    ): vscode.ProviderResult<vscode.TextEdit[]> {
+
+        const edits: vscode.TextEdit[] = [];
+        const text = document.getText();
+        const lines = text.split('\n');
+
+        // Get EE formatting configuration
+        const config = vscode.workspace.getConfiguration('ee.format');
+        const wrapAttributes = config.get<string>('wrapAttributes', 'auto');
+        const indentSize = options.insertSpaces ? options.tabSize : 1;
+        const indentChar = options.insertSpaces ? ' '.repeat(indentSize) : '\t';
+
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            const eeTagMatch = this.findEETag(line);
+
+            if (eeTagMatch) {
+                const formattedLines = this.formatEETag(
+                    eeTagMatch,
+                    lines,
+                    i,
+                    indentChar,
+                    wrapAttributes
+                );
+
+                if (formattedLines.length > 1) {
+                    // Replace the original line(s) with formatted lines
+                    const startLine = i;
+                    const endLine = i + eeTagMatch.lineSpan - 1;
+
+                    edits.push(
+                        vscode.TextEdit.replace(
+                            new vscode.Range(
+                                document.positionAt(document.offsetAt(new vscode.Position(startLine, 0))),
+                                document.positionAt(document.offsetAt(new vscode.Position(endLine + 1, 0)))
+                            ),
+                            formattedLines.join('\n') + '\n'
+                        )
+                    );
+
+                    i = endLine + 1;
+                } else {
+                    i++;
+                }
+            } else {
+                i++;
+            }
+        }
+
+        return edits;
+    }
+
+    /**
+     * Find EE tag in a line
+     * @param line The line to search
+     * @returns EE tag match or null
+     */
+    private findEETag(line: string): EETagMatch | null {
+        // Match EE tags: {exp:...} or {variable} or {/exp:...}
+        const eeTagRegex = /\{([^}]+)\}/g;
+        const match = eeTagRegex.exec(line);
+
+        if (match) {
+            const fullMatch = match[0];
+            const content = match[1];
+
+            // Check if it's a tag that can have attributes (exp: tags)
+            if (content.includes(':') && !content.startsWith('/')) {
+                return {
+                    fullMatch,
+                    content,
+                    isClosing: false,
+                    isPair: true,
+                    lineSpan: 1,
+                    startPos: match.index,
+                    endPos: match.index + fullMatch.length
+                };
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Format an EE tag with proper attribute wrapping
+     * @param tagMatch The EE tag match
+     * @param lines All lines in the document
+     * @param startLineIndex Starting line index
+     * @param indentChar Character(s) to use for indentation
+     * @param wrapAttributes Wrap attributes setting
+     * @returns Array of formatted lines
+     */
+    private formatEETag(
+        tagMatch: EETagMatch,
+        lines: string[],
+        startLineIndex: number,
+        indentChar: string,
+        wrapAttributes: string
+    ): string[] {
+
+        const line = lines[startLineIndex];
+        const beforeTag = line.substring(0, tagMatch.startPos);
+        const afterTag = line.substring(tagMatch.endPos);
+
+        // Extract attributes from the tag content
+        const tagContent = tagMatch.content;
+        const attributes = this.parseEETagAttributes(tagContent);
+
+        if (wrapAttributes === 'preserve') {
+            // Don't format if preserve is set
+            return [line];
+        }
+
+        // Determine if we should wrap attributes
+        const shouldWrap = wrapAttributes === 'force' ||
+                          (wrapAttributes === 'force-expand-multiline' && attributes.length > 1) ||
+                          (wrapAttributes === 'auto' && this.shouldWrapAttributes(tagContent));
+
+        if (!shouldWrap || attributes.length <= 1) {
+            return [line];
+        }
+
+        // Format with wrapped attributes
+        const formattedLines: string[] = [];
+
+        // Opening tag with first attribute
+        formattedLines.push(`${beforeTag}{${attributes[0]}`);
+
+        // Additional attributes on separate lines
+        for (let i = 1; i < attributes.length; i++) {
+            formattedLines.push(`${beforeTag}${indentChar}${attributes[i]}`);
+        }
+
+        // Closing brace
+        formattedLines.push(`${beforeTag}}${afterTag}`);
+
+        return formattedLines;
+    }
+
+    /**
+     * Parse EE tag attributes
+     * @param tagContent The content inside the EE tag braces
+     * @returns Array of attribute strings
+     */
+    private parseEETagAttributes(tagContent: string): string[] {
+        const attributes: string[] = [];
+
+        // Split by spaces but preserve quoted values
+        const parts = this.splitPreservingQuotes(tagContent);
+
+        for (const part of parts) {
+            const trimmed = part.trim();
+            if (trimmed) {
+                attributes.push(trimmed);
+            }
+        }
+
+        return attributes;
+    }
+
+    /**
+     * Split string preserving quoted values
+     * @param str String to split
+     * @returns Array of parts
+     */
+    private splitPreservingQuotes(str: string): string[] {
+        const parts: string[] = [];
+        let current = '';
+        let inQuotes = false;
+        let quoteChar = '';
+
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+
+            if (!inQuotes && (char === '"' || char === "'")) {
+                inQuotes = true;
+                quoteChar = char;
+                current += char;
+            } else if (inQuotes && char === quoteChar) {
+                inQuotes = false;
+                quoteChar = '';
+                current += char;
+            } else if (!inQuotes && char === ' ') {
+                if (current.trim()) {
+                    parts.push(current.trim());
+                    current = '';
+                }
+            } else {
+                current += char;
+            }
+        }
+
+        if (current.trim()) {
+            parts.push(current.trim());
+        }
+
+        return parts;
+    }
+
+    /**
+     * Determine if attributes should be wrapped
+     * @param tagContent The tag content
+     * @returns True if attributes should be wrapped
+     */
+    private shouldWrapAttributes(tagContent: string): boolean {
+        // Simple heuristic: wrap if tag is longer than 80 characters
+        return tagContent.length > 80;
+    }
+}
+
+interface EETagMatch {
+    fullMatch: string;
+    content: string;
+    isClosing: boolean;
+    isPair: boolean;
+    lineSpan: number;
+    startPos: number;
+    endPos: number;
+}

From 20ca30e3c2f99d02e709d344e2c1b9c5405acac3 Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Thu, 11 Sep 2025 16:21:17 -0400
Subject: [PATCH 02/10] Added indentation enforcement for elements inside
 expanded tags

---
 src/services/EEFormatterService.ts | 166 ++++++++++++++++++++++++++---
 1 file changed, 150 insertions(+), 16 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index 4d0fb0a..f050b6b 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -40,21 +40,39 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                 );
 
                 if (formattedLines.length > 1) {
-                    // Replace the original line(s) with formatted lines
-                    const startLine = i;
-                    const endLine = i + eeTagMatch.lineSpan - 1;
-
-                    edits.push(
-                        vscode.TextEdit.replace(
-                            new vscode.Range(
-                                document.positionAt(document.offsetAt(new vscode.Position(startLine, 0))),
-                                document.positionAt(document.offsetAt(new vscode.Position(endLine + 1, 0)))
-                            ),
-                            formattedLines.join('\n') + '\n'
-                        )
-                    );
-
-                    i = endLine + 1;
+                    // Check if this is a paired tag that spans multiple lines
+                    const closingTagInfo = this.findClosingTag(eeTagMatch.content, lines, i);
+
+                    if (closingTagInfo) {
+                        // Replace the entire paired tag section
+                        const startLine = i;
+                        const endLine = closingTagInfo.lineIndex;
+
+                        edits.push(
+                            vscode.TextEdit.replace(
+                                new vscode.Range(
+                                    document.positionAt(document.offsetAt(new vscode.Position(startLine, 0))),
+                                    document.positionAt(document.offsetAt(new vscode.Position(endLine + 1, 0)))
+                                ),
+                                formattedLines.join('\n') + '\n'
+                            )
+                        );
+
+                        i = endLine + 1;
+                    } else {
+                        // Single-line tag formatting
+                        edits.push(
+                            vscode.TextEdit.replace(
+                                new vscode.Range(
+                                    document.positionAt(document.offsetAt(new vscode.Position(i, 0))),
+                                    document.positionAt(document.offsetAt(new vscode.Position(i + 1, 0)))
+                                ),
+                                formattedLines.join('\n') + '\n'
+                            )
+                        );
+
+                        i++;
+                    }
                 } else {
                     i++;
                 }
@@ -136,7 +154,41 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
             return [line];
         }
 
-        // Format with wrapped attributes
+        // Check if this is a paired tag that spans multiple lines
+        const closingTagInfo = this.findClosingTag(tagContent, lines, startLineIndex);
+
+        if (closingTagInfo) {
+            // Format paired tag with content indentation
+            return this.formatPairedEETag(
+                tagMatch,
+                lines,
+                startLineIndex,
+                closingTagInfo,
+                indentChar,
+                attributes,
+                beforeTag,
+                afterTag
+            );
+        } else {
+            // Format single-line tag
+            return this.formatSingleLineEETag(
+                attributes,
+                beforeTag,
+                afterTag,
+                indentChar
+            );
+        }
+    }
+
+    /**
+     * Format a single-line EE tag
+     */
+    private formatSingleLineEETag(
+        attributes: string[],
+        beforeTag: string,
+        afterTag: string,
+        indentChar: string
+    ): string[] {
         const formattedLines: string[] = [];
 
         // Opening tag with first attribute
@@ -153,6 +205,81 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         return formattedLines;
     }
 
+    /**
+     * Format a paired EE tag with content indentation
+     */
+    private formatPairedEETag(
+        tagMatch: EETagMatch,
+        lines: string[],
+        startLineIndex: number,
+        closingTagInfo: ClosingTagInfo,
+        indentChar: string,
+        attributes: string[],
+        beforeTag: string,
+        afterTag: string
+    ): string[] {
+        const formattedLines: string[] = [];
+
+        // Opening tag with first attribute
+        formattedLines.push(`${beforeTag}{${attributes[0]}`);
+
+        // Additional attributes on separate lines
+        for (let i = 1; i < attributes.length; i++) {
+            formattedLines.push(`${beforeTag}${indentChar}${attributes[i]}`);
+        }
+
+        // Closing brace of opening tag
+        formattedLines.push(`${beforeTag}}${afterTag}`);
+
+        // Add indented content between tags
+        for (let i = startLineIndex + 1; i < closingTagInfo.lineIndex; i++) {
+            const contentLine = lines[i];
+            if (contentLine.trim()) {
+                formattedLines.push(`${beforeTag}${indentChar}${contentLine}`);
+            } else {
+                formattedLines.push(contentLine); // Preserve empty lines
+            }
+        }
+
+        // Add closing tag with proper indentation
+        const closingLine = lines[closingTagInfo.lineIndex];
+        const closingBeforeTag = closingLine.substring(0, closingTagInfo.startPos);
+        const closingAfterTag = closingLine.substring(closingTagInfo.endPos);
+        formattedLines.push(`${closingBeforeTag}{${closingTagInfo.content}}${closingAfterTag}`);
+
+        return formattedLines;
+    }
+
+    /**
+     * Find the closing tag for a paired EE tag
+     */
+    private findClosingTag(
+        openingContent: string,
+        lines: string[],
+        startLineIndex: number
+    ): ClosingTagInfo | null {
+        // Extract the tag name (e.g., "exp:channel:entries" from "exp:channel:entries channel=...")
+        const tagName = openingContent.split(' ')[0];
+        const closingTagPattern = `{/${tagName}}`;
+
+        // Search for closing tag in subsequent lines
+        for (let i = startLineIndex + 1; i < lines.length; i++) {
+            const line = lines[i];
+            const closingMatch = line.match(new RegExp(`(\\{[^}]*/${tagName}\\})`));
+
+            if (closingMatch) {
+                return {
+                    lineIndex: i,
+                    startPos: closingMatch.index!,
+                    endPos: closingMatch.index! + closingMatch[0].length,
+                    content: closingMatch[0].slice(1, -1) // Remove { and }
+                };
+            }
+        }
+
+        return null;
+    }
+
     /**
      * Parse EE tag attributes
      * @param tagContent The content inside the EE tag braces
@@ -233,3 +360,10 @@ interface EETagMatch {
     startPos: number;
     endPos: number;
 }
+
+interface ClosingTagInfo {
+    lineIndex: number;
+    startPos: number;
+    endPos: number;
+    content: string;
+}

From 3e06642326d21e07723735787ffaa2b773cb4c3b Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Wed, 1 Oct 2025 20:45:51 -0400
Subject: [PATCH 03/10] Introduced 'nest scanning' to identify and apply
 formatting to nested EE tags, worked on preserving nested html

---
 src/services/EEFormatterService.ts | 255 ++++++++++++++++++++++-------
 1 file changed, 200 insertions(+), 55 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index f050b6b..0e762e5 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -31,7 +31,7 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
             const eeTagMatch = this.findEETag(line);
 
             if (eeTagMatch) {
-                const formattedLines = this.formatEETag(
+                const result = this.formatEETag(
                     eeTagMatch,
                     lines,
                     i,
@@ -39,9 +39,10 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                     wrapAttributes
                 );
 
-                if (formattedLines.length > 1) {
+                if (result.formattedLines.length > 1) {
                     // Check if this is a paired tag that spans multiple lines
-                    const closingTagInfo = this.findClosingTag(eeTagMatch.content, lines, i);
+                    const { tagName } = this.parseEETagAttributes(eeTagMatch.content);
+                    const closingTagInfo = this.findClosingTag(tagName, lines, i);
 
                     if (closingTagInfo) {
                         // Replace the entire paired tag section
@@ -54,7 +55,7 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                                     document.positionAt(document.offsetAt(new vscode.Position(startLine, 0))),
                                     document.positionAt(document.offsetAt(new vscode.Position(endLine + 1, 0)))
                                 ),
-                                formattedLines.join('\n') + '\n'
+                                result.formattedLines.join('\n') + '\n'
                             )
                         );
 
@@ -67,7 +68,7 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                                     document.positionAt(document.offsetAt(new vscode.Position(i, 0))),
                                     document.positionAt(document.offsetAt(new vscode.Position(i + 1, 0)))
                                 ),
-                                formattedLines.join('\n') + '\n'
+                                result.formattedLines.join('\n') + '\n'
                             )
                         );
 
@@ -90,13 +91,29 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
      * @returns EE tag match or null
      */
     private findEETag(line: string): EETagMatch | null {
-        // Match EE tags: {exp:...} or {variable} or {/exp:...}
-        const eeTagRegex = /\{([^}]+)\}/g;
-        const match = eeTagRegex.exec(line);
+        // Handle nested braces in EE tags
+        let braceCount = 0;
+        let start = -1;
+        let end = -1;
+
+        for (let i = 0; i < line.length; i++) {
+            if (line[i] === '{') {
+                if (start === -1) {
+                    start = i;
+                }
+                braceCount++;
+            } else if (line[i] === '}') {
+                braceCount--;
+                if (braceCount === 0 && start !== -1) {
+                    end = i;
+                    break;
+                }
+            }
+        }
 
-        if (match) {
-            const fullMatch = match[0];
-            const content = match[1];
+        if (start !== -1 && end !== -1) {
+            const fullMatch = line.substring(start, end + 1);
+            const content = line.substring(start + 1, end);
 
             // Check if it's a tag that can have attributes (exp: tags)
             if (content.includes(':') && !content.startsWith('/')) {
@@ -106,8 +123,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                     isClosing: false,
                     isPair: true,
                     lineSpan: 1,
-                    startPos: match.index,
-                    endPos: match.index + fullMatch.length
+                    startPos: start,
+                    endPos: end + 1
                 };
             }
         }
@@ -122,7 +139,7 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
      * @param startLineIndex Starting line index
      * @param indentChar Character(s) to use for indentation
      * @param wrapAttributes Wrap attributes setting
-     * @returns Array of formatted lines
+     * @returns Object with formatted lines and skip count
      */
     private formatEETag(
         tagMatch: EETagMatch,
@@ -130,53 +147,67 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         startLineIndex: number,
         indentChar: string,
         wrapAttributes: string
-    ): string[] {
+    ): { formattedLines: string[]; skipLines: number } {
 
         const line = lines[startLineIndex];
         const beforeTag = line.substring(0, tagMatch.startPos);
         const afterTag = line.substring(tagMatch.endPos);
 
+        // Calculate proper indentation from surrounding context
+        const contextIndent = this.calculateContextIndentation(lines, startLineIndex, indentChar);
+
         // Extract attributes from the tag content
         const tagContent = tagMatch.content;
-        const attributes = this.parseEETagAttributes(tagContent);
+        const { tagName, attributes } = this.parseEETagAttributes(tagContent);
 
         if (wrapAttributes === 'preserve') {
             // Don't format if preserve is set
-            return [line];
+            return { formattedLines: [line], skipLines: 0 };
         }
 
-        // Determine if we should wrap attributes
-        const shouldWrap = wrapAttributes === 'force' ||
-                          (wrapAttributes === 'force-expand-multiline' && attributes.length > 1) ||
-                          (wrapAttributes === 'auto' && this.shouldWrapAttributes(tagContent));
-
-        if (!shouldWrap || attributes.length <= 1) {
-            return [line];
+        // For exp: tags, always format if they have attributes
+        // For other tags, use the wrap attributes setting
+        const isExpTag = tagName.startsWith('exp:');
+        const shouldWrap = isExpTag ?
+            (attributes.length > 0) : // Always format exp tags with attributes
+            (wrapAttributes === 'force' ||
+             (wrapAttributes === 'force-expand-multiline' && attributes.length > 0) ||
+             (wrapAttributes === 'auto' && this.shouldWrapAttributes(tagContent)));
+
+        if (!shouldWrap || attributes.length === 0) {
+            return { formattedLines: [line], skipLines: 0 };
         }
 
         // Check if this is a paired tag that spans multiple lines
-        const closingTagInfo = this.findClosingTag(tagContent, lines, startLineIndex);
+        const closingTagInfo = this.findClosingTag(tagName, lines, startLineIndex);
 
         if (closingTagInfo) {
             // Format paired tag with content indentation
-            return this.formatPairedEETag(
+            const formattedLines = this.formatPairedEETag(
                 tagMatch,
                 lines,
                 startLineIndex,
                 closingTagInfo,
                 indentChar,
+                tagName,
                 attributes,
                 beforeTag,
-                afterTag
+                afterTag,
+                contextIndent
             );
+
+            // Skip the lines that were processed
+            return { formattedLines, skipLines: closingTagInfo.lineIndex - startLineIndex };
         } else {
             // Format single-line tag
-            return this.formatSingleLineEETag(
+            const formattedLines = this.formatSingleLineEETag(
+                tagName,
                 attributes,
                 beforeTag,
                 afterTag,
                 indentChar
             );
+            return { formattedLines, skipLines: 0 };
         }
     }
 
@@ -184,6 +215,7 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
      * Format a single-line EE tag
      */
     private formatSingleLineEETag(
+        tagName: string,
         attributes: string[],
         beforeTag: string,
         afterTag: string,
@@ -191,12 +223,12 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     ): string[] {
         const formattedLines: string[] = [];
 
-        // Opening tag with first attribute
-        formattedLines.push(`${beforeTag}{${attributes[0]}`);
+        // Opening tag with tag name
+        formattedLines.push(`${beforeTag}{${tagName}`);
 
-        // Additional attributes on separate lines
-        for (let i = 1; i < attributes.length; i++) {
-            formattedLines.push(`${beforeTag}${indentChar}${attributes[i]}`);
+        // Attributes on separate lines
+        for (const attribute of attributes) {
+            formattedLines.push(`${beforeTag}${indentChar}${attribute}`);
         }
 
         // Closing brace
@@ -214,38 +246,45 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         startLineIndex: number,
         closingTagInfo: ClosingTagInfo,
         indentChar: string,
+        tagName: string,
         attributes: string[],
         beforeTag: string,
-        afterTag: string
+        afterTag: string,
+        contextIndent: string
     ): string[] {
         const formattedLines: string[] = [];
 
-        // Opening tag with first attribute
-        formattedLines.push(`${beforeTag}{${attributes[0]}`);
+        // Use context-aware indentation for the opening tag
+        const openingIndent = contextIndent;
 
-        // Additional attributes on separate lines
-        for (let i = 1; i < attributes.length; i++) {
-            formattedLines.push(`${beforeTag}${indentChar}${attributes[i]}`);
+        // Opening tag with tag name
+        formattedLines.push(`${openingIndent}{${tagName}`);
+
+        // Attributes on separate lines
+        for (const attribute of attributes) {
+            formattedLines.push(`${openingIndent}${indentChar}${attribute}`);
         }
 
         // Closing brace of opening tag
-        formattedLines.push(`${beforeTag}}${afterTag}`);
+        formattedLines.push(`${openingIndent}}${afterTag}`);
 
-        // Add indented content between tags
+        // Add content between tags, indenting the whole block as one unit
         for (let i = startLineIndex + 1; i < closingTagInfo.lineIndex; i++) {
             const contentLine = lines[i];
             if (contentLine.trim()) {
-                formattedLines.push(`${beforeTag}${indentChar}${contentLine}`);
+                // Remove original indentation and add proper indentation relative to EE tag
+                const trimmedContent = contentLine.trim();
+                formattedLines.push(`${openingIndent}${indentChar}${trimmedContent}`);
             } else {
-                formattedLines.push(contentLine); // Preserve empty lines
+                // Preserve empty lines
+                formattedLines.push(contentLine);
             }
         }
 
         // Add closing tag with proper indentation
         const closingLine = lines[closingTagInfo.lineIndex];
-        const closingBeforeTag = closingLine.substring(0, closingTagInfo.startPos);
         const closingAfterTag = closingLine.substring(closingTagInfo.endPos);
-        formattedLines.push(`${closingBeforeTag}{${closingTagInfo.content}}${closingAfterTag}`);
+        formattedLines.push(`${openingIndent}{${closingTagInfo.content}}${closingAfterTag}`);
 
         return formattedLines;
     }
@@ -254,14 +293,10 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
      * Find the closing tag for a paired EE tag
      */
     private findClosingTag(
-        openingContent: string,
+        tagName: string,
         lines: string[],
         startLineIndex: number
     ): ClosingTagInfo | null {
-        // Extract the tag name (e.g., "exp:channel:entries" from "exp:channel:entries channel=...")
-        const tagName = openingContent.split(' ')[0];
-        const closingTagPattern = `{/${tagName}}`;
-
         // Search for closing tag in subsequent lines
         for (let i = startLineIndex + 1; i < lines.length; i++) {
             const line = lines[i];
@@ -283,22 +318,25 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     /**
      * Parse EE tag attributes
      * @param tagContent The content inside the EE tag braces
-     * @returns Array of attribute strings
+     * @returns Object with tagName and attributes array
      */
-    private parseEETagAttributes(tagContent: string): string[] {
+    private parseEETagAttributes(tagContent: string): { tagName: string; attributes: string[] } {
         const attributes: string[] = [];
 
         // Split by spaces but preserve quoted values
         const parts = this.splitPreservingQuotes(tagContent);
 
-        for (const part of parts) {
-            const trimmed = part.trim();
+        // First part is the tag name, rest are attributes
+        const tagName = parts[0] || '';
+
+        for (let i = 1; i < parts.length; i++) {
+            const trimmed = parts[i].trim();
             if (trimmed) {
                 attributes.push(trimmed);
             }
         }
 
-        return attributes;
+        return { tagName, attributes };
     }
 
     /**
@@ -349,6 +387,113 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         // Simple heuristic: wrap if tag is longer than 80 characters
         return tagContent.length > 80;
     }
+
+    /**
+     * Calculate proper indentation based on surrounding context
+     * @param lines All lines in the document
+     * @param currentLineIndex Current line index
+     * @param indentChar Character(s) to use for indentation
+     * @returns Proper indentation string
+     */
+    private calculateContextIndentation(lines: string[], currentLineIndex: number, indentChar: string): string {
+        // Look backwards to find the nearest opening block
+        for (let i = currentLineIndex - 1; i >= 0; i--) {
+            const line = lines[i];
+            const trimmedLine = line.trim();
+
+            // Skip empty lines and comments
+            if (!trimmedLine || trimmedLine.startsWith('<!--')) {
+                continue;
+            }
+
+            // Check for opening EE blocks
+            if (this.isOpeningEEBlock(trimmedLine)) {
+                // Get the indentation of the opening block
+                const blockIndent = line.substring(0, line.length - line.trimStart().length);
+                // Add one level of indentation for content inside the block
+                return blockIndent + indentChar;
+            }
+
+            // Check for HTML opening tags
+            if (this.isOpeningHTMLTag(trimmedLine)) {
+                // Get the indentation of the HTML tag
+                const htmlIndent = line.substring(0, line.length - line.trimStart().length);
+                // Add one level of indentation for content inside the HTML tag
+                return htmlIndent + indentChar;
+            }
+
+            // Check for any non-empty line to determine base indentation
+            if (trimmedLine) {
+                // Get the indentation of this line as the base
+                const baseIndent = line.substring(0, line.length - line.trimStart().length);
+                // Add one level of indentation for the EE tag
+                return baseIndent + indentChar;
+            }
+        }
+
+        // If no opening block found, use no indentation
+        return '';
+    }
+
+    /**
+     * Check if a line contains an opening EE block
+     * @param trimmedLine The trimmed line content
+     * @returns True if it's an opening EE block
+     */
+    private isOpeningEEBlock(trimmedLine: string): boolean {
+        // Check for various EE opening blocks
+        const openingBlocks = [
+            '{if ',
+            '{if:',
+            '{exp:',
+            '{layout:',
+            '{embed:',
+            '{path:',
+            '{route:',
+            '{redirect:'
+        ];
+
+        return openingBlocks.some(block => trimmedLine.startsWith(block));
+    }
+
+    /**
+     * Check if a line contains an opening HTML tag
+     * @param trimmedLine The trimmed line content
+     * @returns True if it's an opening HTML tag
+     */
+    private isOpeningHTMLTag(trimmedLine: string): boolean {
+        // Check for HTML opening tags (not self-closing)
+        const htmlOpeningTags = [
+            '<div',
+            '<section',
+            '<article',
+            '<header',
+            '<footer',
+            '<main',
+            '<aside',
+            '<nav',
+            '<ul',
+            '<ol',
+            '<li',
+            '<p',
+            '<h1',
+            '<h2',
+            '<h3',
+            '<h4',
+            '<h5',
+            '<h6',
+            '<form',
+            '<fieldset',
+            '<table',
+            '<thead',
+            '<tbody',
+            '<tr',
+            '<td',
+            '<th'
+        ];
+
+        return htmlOpeningTags.some(tag => trimmedLine.startsWith(tag) && !trimmedLine.endsWith('/>'));
+    }
 }
 
 interface EETagMatch {

From 19e27ec7999ad35857df126287056fc4e4dd99da Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Mon, 6 Oct 2025 16:42:22 -0400
Subject: [PATCH 04/10] Fixed indentation bug for when EE tags are inside root
 level html tags

---
 src/services/EEFormatterService.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index 0e762e5..f138c1f 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -254,8 +254,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     ): string[] {
         const formattedLines: string[] = [];
 
-        // Use context-aware indentation for the opening tag
-        const openingIndent = contextIndent;
+        // Use the original line's indentation for the opening tag
+        const openingIndent = beforeTag;
 
         // Opening tag with tag name
         formattedLines.push(`${openingIndent}{${tagName}`);
@@ -426,8 +426,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
             if (trimmedLine) {
                 // Get the indentation of this line as the base
                 const baseIndent = line.substring(0, line.length - line.trimStart().length);
-                // Add one level of indentation for the EE tag
-                return baseIndent + indentChar;
+                // Use the same indentation level as the surrounding content
+                return baseIndent;
             }
         }
 

From eadeb30d54d039e28c3de3810456f1584bc92469 Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Mon, 6 Oct 2025 16:48:28 -0400
Subject: [PATCH 05/10] Fixed more indentation bugs

---
 src/services/EEFormatterService.ts | 35 +++++++++++++++++++++++++++---
 1 file changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index f138c1f..b74e201 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -268,13 +268,21 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         // Closing brace of opening tag
         formattedLines.push(`${openingIndent}}${afterTag}`);
 
-        // Add content between tags, indenting the whole block as one unit
+        // Add content between tags, preserving relative indentation structure
         for (let i = startLineIndex + 1; i < closingTagInfo.lineIndex; i++) {
             const contentLine = lines[i];
             if (contentLine.trim()) {
-                // Remove original indentation and add proper indentation relative to EE tag
+                // Find the minimum indentation in the content block to preserve relative structure
+                const minIndent = this.findMinimumIndentation(lines, startLineIndex + 1, closingTagInfo.lineIndex);
+                const originalIndent = contentLine.substring(0, contentLine.length - contentLine.trimStart().length);
+
+                // Calculate the relative indentation from the minimum
+                const relativeIndent = originalIndent.length - minIndent;
+                const baseIndent = openingIndent + indentChar;
+                const finalIndent = baseIndent + ' '.repeat(Math.max(0, relativeIndent));
+
                 const trimmedContent = contentLine.trim();
-                formattedLines.push(`${openingIndent}${indentChar}${trimmedContent}`);
+                formattedLines.push(`${finalIndent}${trimmedContent}`);
             } else {
                 // Preserve empty lines
                 formattedLines.push(contentLine);
@@ -494,6 +502,27 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
 
         return htmlOpeningTags.some(tag => trimmedLine.startsWith(tag) && !trimmedLine.endsWith('/>'));
     }
+
+    /**
+     * Find the minimum indentation level within a content block
+     * @param lines All lines in the document
+     * @param startLine Start line index (inclusive)
+     * @param endLine End line index (exclusive)
+     * @returns Minimum indentation level in spaces
+     */
+    private findMinimumIndentation(lines: string[], startLine: number, endLine: number): number {
+        let minIndent = Infinity;
+
+        for (let i = startLine; i < endLine; i++) {
+            const line = lines[i];
+            if (line.trim()) {
+                const indent = line.length - line.trimStart().length;
+                minIndent = Math.min(minIndent, indent);
+            }
+        }
+
+        return minIndent === Infinity ? 0 : minIndent;
+    }
 }
 
 interface EETagMatch {

From b62d62c454c14965fb2874bedaf893854b79f802 Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Mon, 6 Oct 2025 17:49:04 -0400
Subject: [PATCH 06/10] Added support for ALL exp tags, fixed multi-nested EE
 tags

---
 src/services/EEFormatterService.ts | 72 ++++++++++++++++++++++++++++--
 1 file changed, 68 insertions(+), 4 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index b74e201..c451e74 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -193,7 +193,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                 attributes,
                 beforeTag,
                 afterTag,
-                contextIndent
+                contextIndent,
+                wrapAttributes
             );
 
             // Skip the lines that were processed
@@ -250,7 +251,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         attributes: string[],
         beforeTag: string,
         afterTag: string,
-        contextIndent: string
+        contextIndent: string,
+        wrapAttributes: string
     ): string[] {
         const formattedLines: string[] = [];
 
@@ -269,6 +271,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         formattedLines.push(`${openingIndent}}${afterTag}`);
 
         // Add content between tags, preserving relative indentation structure
+        // Also process any nested EE tags within the content
+        const contentLines = [];
         for (let i = startLineIndex + 1; i < closingTagInfo.lineIndex; i++) {
             const contentLine = lines[i];
             if (contentLine.trim()) {
@@ -282,13 +286,17 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                 const finalIndent = baseIndent + ' '.repeat(Math.max(0, relativeIndent));
 
                 const trimmedContent = contentLine.trim();
-                formattedLines.push(`${finalIndent}${trimmedContent}`);
+                contentLines.push(`${finalIndent}${trimmedContent}`);
             } else {
                 // Preserve empty lines
-                formattedLines.push(contentLine);
+                contentLines.push(contentLine);
             }
         }
 
+        // Process any nested EE tags in the content
+        const processedContentLines = this.processNestedEETags(contentLines, indentChar, wrapAttributes);
+        formattedLines.push(...processedContentLines);
+
         // Add closing tag with proper indentation
         const closingLine = lines[closingTagInfo.lineIndex];
         const closingAfterTag = closingLine.substring(closingTagInfo.endPos);
@@ -523,6 +531,62 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
 
         return minIndent === Infinity ? 0 : minIndent;
     }
+
+    /**
+     * Process nested EE tags within content lines
+     * @param contentLines Array of content lines
+     * @param indentChar Character(s) to use for indentation
+     * @param wrapAttributes Wrap attributes setting
+     * @returns Processed content lines with formatted EE tags
+     */
+    private processNestedEETags(contentLines: string[], indentChar: string, wrapAttributes: string): string[] {
+        const processedLines: string[] = [];
+        let i = 0;
+
+        while (i < contentLines.length) {
+            const line = contentLines[i];
+            const eeTagMatch = this.findEETag(line);
+
+            if (eeTagMatch) {
+                // Create a mock lines array for the nested processing
+                const mockLines = contentLines.slice(i);
+                const mockStartIndex = 0;
+
+                const result = this.formatEETag(
+                    eeTagMatch,
+                    mockLines,
+                    mockStartIndex,
+                    indentChar,
+                    wrapAttributes
+                );
+
+                if (result.formattedLines.length > 1) {
+                    // Check if this is a paired tag
+                    const { tagName } = this.parseEETagAttributes(eeTagMatch.content);
+                    const closingTagInfo = this.findClosingTag(tagName, mockLines, mockStartIndex);
+
+                    if (closingTagInfo) {
+                        // Add the formatted lines
+                        processedLines.push(...result.formattedLines);
+                        // Skip the lines that were processed
+                        i += closingTagInfo.lineIndex - mockStartIndex + 1;
+                    } else {
+                        // Single-line tag
+                        processedLines.push(...result.formattedLines);
+                        i++;
+                    }
+                } else {
+                    processedLines.push(line);
+                    i++;
+                }
+            } else {
+                processedLines.push(line);
+                i++;
+            }
+        }
+
+        return processedLines;
+    }
 }
 
 interface EETagMatch {

From 91719ecc9681ade75c13c0d47ebc003deb3c5533 Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Mon, 6 Oct 2025 19:20:18 -0400
Subject: [PATCH 07/10] First real point of completion. Fixed nested
 indentation bugs

---
 src/services/EEFormatterService.ts | 129 +++++++++++++++++++++++++++--
 1 file changed, 122 insertions(+), 7 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index c451e74..d4d41fb 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -272,20 +272,20 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
 
         // Add content between tags, preserving relative indentation structure
         // Also process any nested EE tags within the content
+        // Add content between tags with proper HTML structure parsing
+        // Also process any nested EE tags within the content
         const contentLines = [];
+        const htmlStructure = this.parseHTMLStructure(lines, startLineIndex + 1, closingTagInfo.lineIndex);
+
         for (let i = startLineIndex + 1; i < closingTagInfo.lineIndex; i++) {
             const contentLine = lines[i];
             if (contentLine.trim()) {
-                // Find the minimum indentation in the content block to preserve relative structure
-                const minIndent = this.findMinimumIndentation(lines, startLineIndex + 1, closingTagInfo.lineIndex);
-                const originalIndent = contentLine.substring(0, contentLine.length - contentLine.trimStart().length);
+                const trimmedContent = contentLine.trim();
+                const indentLevel = htmlStructure.get(i) || 0;
 
-                // Calculate the relative indentation from the minimum
-                const relativeIndent = originalIndent.length - minIndent;
                 const baseIndent = openingIndent + indentChar;
-                const finalIndent = baseIndent + ' '.repeat(Math.max(0, relativeIndent));
+                const finalIndent = baseIndent + indentChar.repeat(indentLevel);
 
-                const trimmedContent = contentLine.trim();
                 contentLines.push(`${finalIndent}${trimmedContent}`);
             } else {
                 // Preserve empty lines
@@ -532,6 +532,121 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         return minIndent === Infinity ? 0 : minIndent;
     }
 
+    /**
+     * Calculate HTML indentation level based on tag structure
+     * @param content The HTML content line
+     * @param currentLevel Current indentation level
+     * @returns Object with current indent level and next level for tracking
+     */
+    private calculateHTMLIndentationLevel(content: string, currentLevel: number): { currentLevel: number; nextLevel: number } {
+        // Check if it's a closing tag
+        if (content.startsWith('</')) {
+            // Closing tag uses current level, then decrease for next
+            return { currentLevel, nextLevel: Math.max(0, currentLevel - 1) };
+        }
+        // Check if it's a self-closing tag
+        else if (content.endsWith('/>') || content.match(/<[^>]+\/>/)) {
+            // Self-closing tag uses current level, no change for next
+            return { currentLevel, nextLevel: currentLevel };
+        }
+        // Check if it's an opening tag
+        else if (content.startsWith('<') && !content.startsWith('<!--')) {
+            // Opening tag uses current level, then increase for next
+            return { currentLevel, nextLevel: currentLevel + 1 };
+        }
+        // For other content (text, comments, EE tags), maintain current level
+        else {
+            return { currentLevel, nextLevel: currentLevel };
+        }
+    }
+
+    /**
+     * Parse HTML structure and return indentation levels for each line
+     * @param lines All lines in the document
+     * @param startLine Start line index (inclusive)
+     * @param endLine End line index (exclusive)
+     * @returns Map of line index to indentation level
+     */
+    private parseHTMLStructure(lines: string[], startLine: number, endLine: number): Map<number, number> {
+        const indentMap = new Map<number, number>();
+        const tagStack: Array<{ tagName: string; lineIndex: number; indentLevel: number }> = [];
+        let currentIndentLevel = 0;
+
+        for (let i = startLine; i < endLine; i++) {
+            const line = lines[i];
+            const trimmedLine = line.trim();
+
+            if (!trimmedLine) {
+                continue; // Skip empty lines
+            }
+
+            // Check if it's a closing tag
+            if (trimmedLine.startsWith('</')) {
+                const tagName = this.extractTagName(trimmedLine);
+
+                // Find matching opening tag in stack
+                for (let j = tagStack.length - 1; j >= 0; j--) {
+                    if (tagStack[j].tagName === tagName) {
+                        // Set indentation level for closing tag (same as opening)
+                        indentMap.set(i, tagStack[j].indentLevel);
+
+                        // Reset current indent level to the level of the closing tag
+                        currentIndentLevel = tagStack[j].indentLevel;
+
+                        // Remove from stack
+                        tagStack.splice(j, 1);
+                        break;
+                    }
+                }
+            }
+            // Check if it's a self-closing tag
+            else if (trimmedLine.endsWith('/>') || trimmedLine.match(/<[^>]+\/>/)) {
+                indentMap.set(i, currentIndentLevel);
+            }
+            // Check if it's an opening tag
+            else if (trimmedLine.startsWith('<') && !trimmedLine.startsWith('<!--')) {
+                const tagName = this.extractTagName(trimmedLine);
+
+                // Check if it's a self-contained tag (opening and closing on same line)
+                if (trimmedLine.includes('</' + tagName + '>')) {
+                    // Self-contained tag - use current level, don't increase for next
+                    indentMap.set(i, currentIndentLevel);
+                } else {
+                    // Opening tag - set level and add to stack
+                    indentMap.set(i, currentIndentLevel);
+
+                    tagStack.push({
+                        tagName,
+                        lineIndex: i,
+                        indentLevel: currentIndentLevel
+                    });
+
+                    // Increase indent level for next elements
+                    currentIndentLevel++;
+                }
+            }
+            // For other content (text, comments, EE tags), maintain current level
+            else {
+                indentMap.set(i, currentIndentLevel);
+            }
+        }
+
+        return indentMap;
+    }
+
+    /**
+     * Extract tag name from HTML tag
+     * @param tag The HTML tag string
+     * @returns Tag name
+     */
+    private extractTagName(tag: string): string {
+        // Remove < and > or />
+        const cleanTag = tag.replace(/^<\/?/, '').replace(/\/?>$/, '');
+        // Extract tag name (before any attributes or spaces)
+        const match = cleanTag.match(/^([^\s>]+)/);
+        return match ? match[1] : cleanTag;
+    }
+
     /**
      * Process nested EE tags within content lines
      * @param contentLines Array of content lines

From e71ea90bf5f9252047b136d6c6a51cad89b3042b Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Mon, 6 Oct 2025 20:17:10 -0400
Subject: [PATCH 08/10] Added increased support for attributes, specifically
 whitespace inside an attribute

---
 src/services/EEFormatterService.ts | 50 +++++++++++++++++++++++-------
 1 file changed, 38 insertions(+), 12 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index d4d41fb..9bfe890 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -166,13 +166,17 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         }
 
         // For exp: tags, always format if they have attributes
+        // For if tags, never format (keep as single line)
         // For other tags, use the wrap attributes setting
         const isExpTag = tagName.startsWith('exp:');
-        const shouldWrap = isExpTag ?
-            (attributes.length > 0) : // Always format exp tags with attributes
-            (wrapAttributes === 'force' ||
-             (wrapAttributes === 'force-expand-multiline' && attributes.length > 0) ||
-             (wrapAttributes === 'auto' && this.shouldWrapAttributes(tagContent)));
+        const isIfTag = tagName === 'if' || tagName.startsWith('if:');
+        const shouldWrap = isIfTag ?
+            false : // Never format if tags
+            (isExpTag ?
+                (attributes.length > 0) : // Always format exp tags with attributes
+                (wrapAttributes === 'force' ||
+                 (wrapAttributes === 'force-expand-multiline' && attributes.length > 0) ||
+                 (wrapAttributes === 'auto' && this.shouldWrapAttributes(tagContent))));
 
         if (!shouldWrap || attributes.length === 0) {
             return { formattedLines: [line], skipLines: 0 };
@@ -339,8 +343,8 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     private parseEETagAttributes(tagContent: string): { tagName: string; attributes: string[] } {
         const attributes: string[] = [];
 
-        // Split by spaces but preserve quoted values
-        const parts = this.splitPreservingQuotes(tagContent);
+        // Split by spaces but preserve quoted values and attribute assignments
+        const parts = this.splitPreservingQuotesAndAssignments(tagContent);
 
         // First part is the tag name, rest are attributes
         const tagName = parts[0] || '';
@@ -356,15 +360,16 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     }
 
     /**
-     * Split string preserving quoted values
+     * Split string preserving quoted values and attribute assignments
      * @param str String to split
      * @returns Array of parts
      */
-    private splitPreservingQuotes(str: string): string[] {
+    private splitPreservingQuotesAndAssignments(str: string): string[] {
         const parts: string[] = [];
         let current = '';
         let inQuotes = false;
         let quoteChar = '';
+        let inAssignment = false;
 
         for (let i = 0; i < str.length; i++) {
             const char = str[i];
@@ -377,10 +382,31 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                 inQuotes = false;
                 quoteChar = '';
                 current += char;
+                // If we were in an assignment and just closed quotes, we're done
+                if (inAssignment) {
+                    inAssignment = false;
+                }
+            } else if (!inQuotes && char === '=') {
+                // This is an assignment operator, keep it with current part
+                current += char;
+                inAssignment = true;
             } else if (!inQuotes && char === ' ') {
-                if (current.trim()) {
-                    parts.push(current.trim());
-                    current = '';
+                if (inAssignment) {
+                    // We're in an assignment, keep the space
+                    current += char;
+                } else {
+                    // Check if the next non-space character is =
+                    const remaining = str.substring(i + 1).trim();
+                    if (remaining.startsWith('=')) {
+                        // This space is before an assignment, keep it
+                        current += char;
+                    } else {
+                        // Regular space separator
+                        if (current.trim()) {
+                            parts.push(current.trim());
+                            current = '';
+                        }
+                    }
                 }
             } else {
                 current += char;

From d2b5ecb8627c470dbc399752d8dc19b32750a97f Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Tue, 7 Oct 2025 17:31:33 -0400
Subject: [PATCH 09/10] Cleaned up the class, remove old methods, format code

---
 src/services/EEFormatterService.ts | 161 +++++++++++++----------------
 1 file changed, 73 insertions(+), 88 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index 9bfe890..0fd7c5d 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -1,13 +1,58 @@
 import * as vscode from 'vscode';
 
+/**
+ * Interface for EE tag match results
+ */
+interface EETagMatch {
+    fullMatch: string;
+    content: string;
+    isClosing: boolean;
+    isPair: boolean;
+    lineSpan: number;
+    startPos: number;
+    endPos: number;
+}
+
+/**
+ * Interface for closing tag information
+ */
+interface ClosingTagInfo {
+    lineIndex: number;
+    startPos: number;
+    endPos: number;
+    content: string;
+}
+
+/**
+ * Interface for formatting result
+ */
+interface FormatResult {
+    formattedLines: string[];
+    skipLines: number;
+}
+
+/**
+ * ExpressionEngine Code Formatter Service
+ *
+ * Provides formatting capabilities for ExpressionEngine tags within HTML documents.
+ * Handles attribute wrapping, indentation, and nested tag structures.
+ *
+ * Key Features:
+ * - Brace counting algorithm for accurate EE tag detection
+ * - Assignment state tracking for proper attribute parsing
+ * - HTML structure parsing for correct indentation
+ * - Context-aware indentation calculation
+ * - Support for nested EE tags and complex HTML structures
+ */
 export default class EEFormatterService implements vscode.DocumentFormattingEditProvider {
 
     /**
-     * Format EE tags in the document
-     * @param document The document to format
-     * @param options Formatting options
-     * @param token Cancellation token
-     * @returns Array of text edits
+     * Provides document formatting edits for ExpressionEngine tags
+     *
+     * @param document - The document to format
+     * @param options - VS Code formatting options (indentation, etc.)
+     * @param token - Cancellation token for long-running operations
+     * @returns Promise resolving to array of text edits, or undefined if no changes needed
      */
     public provideDocumentFormattingEdits(
         document: vscode.TextDocument,
@@ -22,8 +67,9 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         // Get EE formatting configuration
         const config = vscode.workspace.getConfiguration('ee.format');
         const wrapAttributes = config.get<string>('wrapAttributes', 'auto');
-        const indentSize = options.insertSpaces ? options.tabSize : 1;
-        const indentChar = options.insertSpaces ? ' '.repeat(indentSize) : '\t';
+
+        // Use consistent 4-space indentation as requested
+        const indentChar = '    '; // 4 spaces
 
         let i = 0;
         while (i < lines.length) {
@@ -86,9 +132,10 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     }
 
     /**
-     * Find EE tag in a line
-     * @param line The line to search
-     * @returns EE tag match or null
+     * Finds ExpressionEngine tags in a line using brace counting
+     *
+     * @param line - The line to search for EE tags
+     * @returns EETagMatch object if found, null otherwise
      */
     private findEETag(line: string): EETagMatch | null {
         // Handle nested braces in EE tags
@@ -133,13 +180,14 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     }
 
     /**
-     * Format an EE tag with proper attribute wrapping
-     * @param tagMatch The EE tag match
-     * @param lines All lines in the document
-     * @param startLineIndex Starting line index
-     * @param indentChar Character(s) to use for indentation
-     * @param wrapAttributes Wrap attributes setting
-     * @returns Object with formatted lines and skip count
+     * Formats an ExpressionEngine tag based on its type and attributes
+     *
+     * @param eeTagMatch - The matched EE tag information
+     * @param lines - All document lines for context
+     * @param currentLineIndex - Current line being processed
+     * @param indentChar - Character(s) used for indentation
+     * @param wrapAttributes - Configuration for attribute wrapping
+     * @returns FormatResult with formatted lines and skip count
      */
     private formatEETag(
         tagMatch: EETagMatch,
@@ -175,7 +223,7 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
             (isExpTag ?
                 (attributes.length > 0) : // Always format exp tags with attributes
                 (wrapAttributes === 'force' ||
-                 (wrapAttributes === 'force-expand-multiline' && attributes.length > 0) ||
+                          (wrapAttributes === 'force-expand-multiline' && attributes.length > 0) ||
                  (wrapAttributes === 'auto' && this.shouldWrapAttributes(tagContent))));
 
         if (!shouldWrap || attributes.length === 0) {
@@ -336,9 +384,10 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     }
 
     /**
-     * Parse EE tag attributes
-     * @param tagContent The content inside the EE tag braces
-     * @returns Object with tagName and attributes array
+     * Parses EE tag attributes while preserving quoted values and assignments
+     *
+     * @param tagContent - The content inside the EE tag braces
+     * @returns Object containing tag name and array of attributes
      */
     private parseEETagAttributes(tagContent: string): { tagName: string; attributes: string[] } {
         const attributes: string[] = [];
@@ -402,9 +451,9 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                         current += char;
                     } else {
                         // Regular space separator
-                        if (current.trim()) {
-                            parts.push(current.trim());
-                            current = '';
+                if (current.trim()) {
+                    parts.push(current.trim());
+                    current = '';
                         }
                     }
                 }
@@ -537,54 +586,6 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         return htmlOpeningTags.some(tag => trimmedLine.startsWith(tag) && !trimmedLine.endsWith('/>'));
     }
 
-    /**
-     * Find the minimum indentation level within a content block
-     * @param lines All lines in the document
-     * @param startLine Start line index (inclusive)
-     * @param endLine End line index (exclusive)
-     * @returns Minimum indentation level in spaces
-     */
-    private findMinimumIndentation(lines: string[], startLine: number, endLine: number): number {
-        let minIndent = Infinity;
-
-        for (let i = startLine; i < endLine; i++) {
-            const line = lines[i];
-            if (line.trim()) {
-                const indent = line.length - line.trimStart().length;
-                minIndent = Math.min(minIndent, indent);
-            }
-        }
-
-        return minIndent === Infinity ? 0 : minIndent;
-    }
-
-    /**
-     * Calculate HTML indentation level based on tag structure
-     * @param content The HTML content line
-     * @param currentLevel Current indentation level
-     * @returns Object with current indent level and next level for tracking
-     */
-    private calculateHTMLIndentationLevel(content: string, currentLevel: number): { currentLevel: number; nextLevel: number } {
-        // Check if it's a closing tag
-        if (content.startsWith('</')) {
-            // Closing tag uses current level, then decrease for next
-            return { currentLevel, nextLevel: Math.max(0, currentLevel - 1) };
-        }
-        // Check if it's a self-closing tag
-        else if (content.endsWith('/>') || content.match(/<[^>]+\/>/)) {
-            // Self-closing tag uses current level, no change for next
-            return { currentLevel, nextLevel: currentLevel };
-        }
-        // Check if it's an opening tag
-        else if (content.startsWith('<') && !content.startsWith('<!--')) {
-            // Opening tag uses current level, then increase for next
-            return { currentLevel, nextLevel: currentLevel + 1 };
-        }
-        // For other content (text, comments, EE tags), maintain current level
-        else {
-            return { currentLevel, nextLevel: currentLevel };
-        }
-    }
 
     /**
      * Parse HTML structure and return indentation levels for each line
@@ -730,19 +731,3 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
     }
 }
 
-interface EETagMatch {
-    fullMatch: string;
-    content: string;
-    isClosing: boolean;
-    isPair: boolean;
-    lineSpan: number;
-    startPos: number;
-    endPos: number;
-}
-
-interface ClosingTagInfo {
-    lineIndex: number;
-    startPos: number;
-    endPos: number;
-    content: string;
-}

From c5a83a1a942d3942c1e0ff5ab9d61cfa651c1bbd Mon Sep 17 00:00:00 2001
From: TJ <tj@hopstudios.com>
Date: Tue, 7 Oct 2025 19:10:41 -0400
Subject: [PATCH 10/10] Removed old variables

---
 src/services/EEFormatterService.ts | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/services/EEFormatterService.ts b/src/services/EEFormatterService.ts
index 0fd7c5d..39b6af9 100644
--- a/src/services/EEFormatterService.ts
+++ b/src/services/EEFormatterService.ts
@@ -68,11 +68,16 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         const config = vscode.workspace.getConfiguration('ee.format');
         const wrapAttributes = config.get<string>('wrapAttributes', 'auto');
 
-        // Use consistent 4-space indentation as requested
-        const indentChar = '    '; // 4 spaces
+        // Attempt to use VS Code formatting options for indentation
+        const indentChar = options.insertSpaces ? ' '.repeat(options.tabSize) : '\t';
 
         let i = 0;
         while (i < lines.length) {
+            // Check for cancellation
+            if (token.isCancellationRequested) {
+                return [];
+            }
+
             const line = lines[i];
             const eeTagMatch = this.findEETag(line);
 
@@ -236,7 +241,6 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         if (closingTagInfo) {
             // Format paired tag with content indentation
             const formattedLines = this.formatPairedEETag(
-                tagMatch,
                 lines,
                 startLineIndex,
                 closingTagInfo,
@@ -245,7 +249,6 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
                 attributes,
                 beforeTag,
                 afterTag,
-                contextIndent,
                 wrapAttributes
             );
 
@@ -294,7 +297,6 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
      * Format a paired EE tag with content indentation
      */
     private formatPairedEETag(
-        tagMatch: EETagMatch,
         lines: string[],
         startLineIndex: number,
         closingTagInfo: ClosingTagInfo,
@@ -303,7 +305,6 @@ export default class EEFormatterService implements vscode.DocumentFormattingEdit
         attributes: string[],
         beforeTag: string,
         afterTag: string,
-        contextIndent: string,
         wrapAttributes: string
     ): string[] {
         const formattedLines: string[] = [];