Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

const textarea = document.getElementById('code'); const previewFrame =…

  1. User

    const textarea = document.getElementById('code'); const previewFrame = document.getElementById('previewFrame'); const errorMessage = document.getElementById('error-message');

    function compileToHTML(customCode) { const lines = customCode.split('\n'); let html = ''; let errors = []; let i = 0; const totalLines = lines.length; let inBlockComment = false;

    while (i < totalLines) {
        let line = lines[i].trim();
    
        // Handle block comments
        if (inBlockComment) {
            if (line.endsWith('#}')) {
                inBlockComment = false;
            }
            i++;
            continue;
        }
    
        if (line.startsWith('#{')) {
            inBlockComment = true;
            i++;
            continue;
        }
    
        // Handle single-line comments
        if (line.startsWith('#') && !line.startsWith('#{')) {
            i++;
            continue;
        }
    
        // Handle block closures
        if (line === '\\}') {
            errors.push(`Unexpected block closure '\\}' at line ${i + 1}.`);
            i++;
            continue;
        }
    
        // Handle block openings
        const blockStartMatch = line.match(/^(\w+)(\[[^\]]+\])?(#[\w\-]+)?((?:\.[\w\-]+)*?)\\\{$/);
        if (blockStartMatch) {
            const tag = blockStartMatch[1].toLowerCase();
            const attrs = blockStartMatch[2] ? replaceIndexPlaceholders(blockStartMatch[2].slice(1, -1), 0) : '';
            const id = blockStartMatch[3] ? replaceIndexPlaceholders(blockStartMatch[3].slice(1), 0) : '';
            const classesRaw = blockStartMatch[4] ? blockStartMatch[4] : '';
            const classes = classesRaw.split('.').filter(cls => cls !== '');
    
            let blockContent = '';
            i++;
            let openBlocks = 1; // Track nested blocks
    
            while (i < totalLines && openBlocks > 0) {
                let currentLine = lines[i].trim();
    
                if (currentLine.endsWith('\\{')) {
                    openBlocks++;
                }
    
                if (currentLine === '\\}') {
                    openBlocks--;
                    if (openBlocks === 0) {
                        i++;
                        break;
                    }
                }
    
                if (openBlocks > 0) {
                    blockContent += lines[i] + '\n';
                }
    
                i++;
            }
    
            if (openBlocks > 0) {
                errors.push(`Unclosed block starting with <${tag}>.`);
                break;
            }
    
            let innerHTML = '';
    
            if (tag === 'script' || tag === 'style' || tag === 'html') {
                innerHTML = blockContent;
            } else {
                const compiledBlock = compileToHTML(blockContent);
                if (compiledBlock.errors.length > 0) {
                    errors = errors.concat(compiledBlock.errors);
                }
                innerHTML = compiledBlock.html;
            }
    
            let attrString = '';
            if (attrs) attrString += ` ${attrs}`;
            if (id) attrString += ` id="${id}"`;
            if (classes.length > 0) attrString += ` class="${classes.join(' ')}"`;
    
            html += `<${tag}${attrString}>\n${innerHTML}</${tag}>\n`;
    
            continue;
        }
    
        // Handle inline element declarations like tag{content}
        const inlineMatch = line.match(/^(\w+)(\[[^\]]+\])?(#[\w\-]+)?((?:\.[\w\-]+)*?)\{([^}]*)\}(?:\*(\d+))?$/);
        if (inlineMatch) {
            const tag = inlineMatch[1].toLowerCase();
            const attrs = inlineMatch[2] ? replaceIndexPlaceholders(inlineMatch[2].slice(1, -1), 0) : '';
            const id = inlineMatch[3] ? replaceIndexPlaceholders(inlineMatch[3].slice(1), 0) : '';
            const classesRaw = inlineMatch[4] ? inlineMatch[4] : '';
            const classes = classesRaw.split('.').filter(cls => cls !== '');
            const content = replaceIndexPlaceholders(inlineMatch[5], 0);
            const repeat = inlineMatch[6] ? parseInt(inlineMatch[6]) : 1;
    
            let finalAttrString = '';
            if (attrs) finalAttrString += ` ${attrs}`;
            if (id) finalAttrString += ` id="${id}"`;
            if (classes.length > 0) finalAttrString += ` class="${classes.join(' ')}"`;
    
            for (let j = 1; j <= repeat; j++) {
                html += `<${tag}${finalAttrString}>${content}</${tag}>\n`;
            }
    
            i++;
            continue;
        }
    
        // Handle nested and sibling selectors separated by '+' and '>'
        const siblingTokens = splitRespectingBlocks(line, '+');
        siblingTokens.forEach(token => {
            const nestingTokens = splitRespectingBlocks(token, '>');
            // Use processNesting to handle each nested token
            html = processNesting(nestingTokens, 0, html, errors, i + 1);
        });
    
        // Handle lines that are pure text
        const textLineMatch = line.match(/^[^+\>]+$/);
        if (!blockStartMatch && !inlineMatch && textLineMatch) {
            // Append text within the current context
            html += `${escapeHTML(line)}\n`;
        }
    
        i++;
    }
    
    return { html, errors };
    
    /**
     * Recursive function to process nested tokens.
     * @param {Array} nestingTokens - Array of tokens split by '>'.
     * @param {number} index - Current index in the nestingTokens array.
     * @param {string} html - The accumulated HTML string.
     * @param {Array} errors - Array to collect error messages.
     * @param {number} lineNumber - Current line number for error reporting.
     * @returns {string} - The updated HTML string after processing.
     */
    function processNesting(nestingTokens, index, html, errors, lineNumber) {
        if (index >= nestingTokens.length) return html;
    
        const nestedToken = nestingTokens[index].trim();
        const isLast = index === nestingTokens.length - 1;
    
        if (nestedToken === '') return html;
    
        try {
            const { tag, attributes, id, classes, content, repeat } = parseElement(nestedToken, lineNumber);
            let attrString = '';
            if (attributes) attrString += ` ${attributes}`;
            if (id) attrString += ` id="${id}"`;
            if (classes.length > 0) attrString += ` class="${classes.join(' ')}"`;
    
            for (let j = 1; j <= repeat; j++) {
                let finalContent = replaceIndexPlaceholders(content, j);
                let finalAttrString = replaceIndexPlaceholders(attrString, j);
                let finalId = replaceIndexPlaceholders(id, j);
                let finalClasses = classes.map(cls => replaceIndexPlaceholders(cls, j));
    
                if (finalId) {
                    finalAttrString = finalAttrString.replace(` id="${id}"`, ` id="${finalId}"`);
                }
    
                if (finalClasses.length > 0) {
                    // Replace existing class names with updated ones
                    const classRegex = /class="([^"]+)"/;
                    const match = finalAttrString.match(classRegex);
                    if (match) {
                        const existingClasses = match[1].split(' ');
                        const updatedClasses = [...new Set([...existingClasses, ...finalClasses])];
                        finalAttrString = finalAttrString.replace(classRegex, `class="${updatedClasses.join(' ')}"`);
                    } else {
                        finalAttrString += ` class="${finalClasses.join(' ')}"`;
                    }
                }
    
                html += `<${tag}${finalAttrString}>`;
    
                if (finalContent) {
                    html += finalContent;
                }
    
                if (!isLast) {
                    html += '\n';
                    html = processNesting(nestingTokens, index + 1, html, errors, lineNumber);
                    html += `</${tag}>\n`;
                } else {
                    html += `</${tag}>\n`;
                }
            }
        } catch (err) {
            // If it's an invalid syntax but not a tag/block, treat as text
            if (nestedToken.startsWith('\\}')) {
                // Ignore unexpected block closure inside nesting
                return html;
            } else {
                // Escape and append the text
                html += `${escapeHTML(nestedToken)}\n`;
            }
        }
    
        return html;
    }
    

    }

    /**

    • Splits a string by a delimiter but ignores delimiters inside quotes or blocks.

    • @param {string} str - The string to split.

    • @param {string} delimiter - The delimiter to split by.

    • @returns {Array} - Array of split tokens. */ function splitRespectingBlocks(str, delimiter) { const tokens = []; let current = ''; let inQuotes = false; let quoteChar = ''; let escape = false; let blockDepth = 0;

      for (let i = 0; i < str.length; i++) { let char = str[i];

       if (escape) {
           current += char;
           escape = false;
           continue;
       }
      
       if (char === '\\') {
           escape = true;
           current += char;
           continue;
       }
      
       if ((char === '"' || char === "'") && !inQuotes) {
           inQuotes = true;
           quoteChar = char;
           current += char;
           continue;
       }
      
       if (char === quoteChar && inQuotes) {
           inQuotes = false;
           quoteChar = '';
           current += char;
           continue;
       }
      
       // Track nested blocks to avoid splitting on delimiters inside blocks
       if (!inQuotes && char === '{') {
           blockDepth++;
           current += char;
           continue;
       }
      
       if (!inQuotes && char === '}') {
           blockDepth = Math.max(blockDepth - 1, 0);
           current += char;
           continue;
       }
      
       if (!inQuotes && blockDepth === 0 && char === delimiter) {
           tokens.push(current);
           current = '';
           continue;
       }
      
       current += char;
      

      }

      if (current !== '') { tokens.push(current); }

      return tokens; }

    /**

    • Replaces all instances of &index; with the provided index number.
    • @param {string} str - The string to process.
    • @param {number} index - The index to replace &index; with.
    • @returns {string} - The processed string. */ function replaceIndexPlaceholders(str, index) { return str.replace(/&index;/g, index); }

    /**

    • Parses an element definition from the custom syntax.

    • @param {string} token - A token from the custom code.

    • @param {number} lineNumber - The line number for error reporting.

    • @returns {Object} - Parsed element details. / function parseElement(token, lineNumber) { const regex = /^(\w+)([[^]]+])?(#[\w-]+)?((?:.[\w-]+)?){([^}]*)}(?:*(\d+))?$/; const match = token.match(regex);

      if (!match) { throw { message: Invalid syntax near "${token}"., line: lineNumber }; }

      const [, tag, attrs, id, classNames, content, repeat] = match; let attributes = ''; let classes = [];

      if (attrs) { const attrContent = attrs.slice(1, -1); const attrRegex = /(\w+)="([^"]+)"/g; let attrMatch; while ((attrMatch = attrRegex.exec(attrContent)) !== null) { const [, attrName, attrValue] = attrMatch; attributes += ${attrName}="${attrValue}"; }

       const validAttrFormat = [...attrContent.matchAll(attrRegex)].length > 0;
       if (attributes.trim() === '' && attrContent.trim() !== '') {
           throw { message: `Attributes must be in the format key="value".`, line: lineNumber };
       }
      

      }

      if (classNames) { classes = classNames.split('.').filter(cls => cls !== '').map(cls => cls.trim()); }

      const element = { tag: tag, attributes: attributes, id: id ? id.slice(1) : '', classes: classes, content: content ? content.slice(1, -1) : '', repeat: repeat ? parseInt(repeat) : 1 };

      return element; }

    /**

    • Escapes HTML special characters in a string.
    • @param {string} str - The string to escape.
    • @returns {string} - The escaped string. */ function escapeHTML(str) { const replacements = { '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }; return str.replace(/[&<>"']/g, match => replacements[match]); }

    function updatePreview() { const customCode = textarea.value; let compilationResult; try { compilationResult = compileToHTML(customCode); } catch (error) { compilationResult = { html: '', errors: [Unexpected error: ${error.message}] }; }

    const { html, errors } = compilationResult;
    
    if (errors && errors.length > 0) {
        errorMessage.textContent = errors.join(' | ');
        errorMessage.style.display = 'block';
        previewFrame.srcdoc = '';
    } else {
        errorMessage.textContent = '';
        errorMessage.style.display = 'none';
        const fullHTML = `
    

    /**

    • Extracts embedded blocks from the generated HTML to include in the preview's head.
    • @param {string} html - The generated HTML content.
    • @returns {string} - Extracted CSS from blocks. / function extractEmbeddedStyles(html) { const styleRegex = /<style[^>]>([\s\S]*?)</style>/gi; let styles = ''; let match; while ((match = styleRegex.exec(html)) !== null) { styles += match[1] + '\n'; } return styles; }

    updatePreview();

    let timeout; textarea.addEventListener('input', () => { clearTimeout(timeout); timeout = setTimeout(updatePreview, 300); });

    const tabEditor = document.getElementById('tab-editor'); const tabPreview = document.getElementById('tab-preview'); const editor = document.querySelector('.editor'); const preview = document.querySelector('.preview');

    function activateTab(tab) { if (tab === 'editor') { tabEditor.classList.add('active'); tabPreview.classList.remove('active'); editor.classList.add('active'); preview.classList.remove('active'); } else if (tab === 'preview') { tabPreview.classList.add('active'); tabEditor.classList.remove('active'); preview.classList.add('active'); editor.classList.remove('active'); } }

    tabEditor.addEventListener('click', () => activateTab('editor')); tabPreview.addEventListener('click', () => activateTab('preview'));

    textarea.addEventListener('keydown', e => { const openingChars = { '"': '"', "'": "'", '(': ')', '{': '}', '[': ']', '<': '>' };

    const closingChars = Object.values(openingChars);
    
    if (e.key === 'Backspace') {
        const cursorPos = textarea.selectionStart;
        const textBeforeCursor = textarea.value.substring(0, cursorPos);
        const lastTwoChars = textBeforeCursor.slice(-2);
        return;
    }
    
    if (e.key === '"' || e.key === "'") {
        const closingChar = openingChars[e.key];
        const cursorPos = textarea.selectionStart;
        const beforeCursor = textarea.value.substring(0, cursorPos);
        const afterCursor = textarea.value.substring(cursorPos);
    
        if (afterCursor.startsWith(closingChar)) {
            e.preventDefault();
            textarea.setSelectionRange(cursorPos + 1, cursorPos + 1);
        } else {
            e.preventDefault();
            textarea.value = beforeCursor + e.key + closingChar + afterCursor;
            setTimeout(() => {
                textarea.setSelectionRange(cursorPos + 1, cursorPos + 1);
                textarea.dispatchEvent(new Event('input'));
            }, 0);
        }
        return;
    }
    
    if (e.key in openingChars) {
        e.preventDefault();
        const closingChar = openingChars[e.key];
        const cursorPos = textarea.selectionStart;
        const beforeCursor = textarea.value.substring(0, cursorPos);
        const afterCursor = textarea.value.substring(cursorPos);
    
        textarea.value = beforeCursor + e.key + closingChar + afterCursor;
        setTimeout(() => {
            textarea.setSelectionRange(cursorPos + e.key.length, cursorPos + e.key.length);
            textarea.dispatchEvent(new Event('input'));
        }, 0);
    }
    
    if (closingChars.includes(e.key)) {
        const cursorPos = textarea.selectionStart;
        const nextChar = textarea.value.substring(cursorPos, cursorPos + 1);
        if (e.key === nextChar) {
            e.preventDefault();
            textarea.setSelectionRange(cursorPos + 1, cursorPos + 1);
        }
    }
    

    });


    Multi-line nesting works properly:

    ul{ li{ Item ul{ li{ Subitem ul{ li{Sub subitem} } } } } }


    However, the inline nesting is messed up:

    ul>li{Item}>ul>li{Subitem}>ul>li{Sub subitem}

    -> The inline nesting being compiled:



    I want you to fix the bugs of the inline nesting, without breaking the multi-line nesting... and DO NOT remove or nerf any of the original features/functionalities, as they're all important...

  2. Assistant

    Thank you for providing the detailed context and code. I understand that your custom compiler correctly handles multi-line nesting but encounters issues with inline nesting using the > operator. The problem lies in how the processNesting function handles the recursive generation of nested HTML elements.

    Problem Analysis

    When processing inline nesting like ul>li{Item}>ul>li{Subitem}>ul>li{Sub subitem}, the current implementation of processNesting appends to the html string in a way that disrupts the proper nesting of tags. Specifically, the recursive calls modify the same html string, leading to improper closure and incomplete HTML structure.

    Solution

    To fix the inline nesting issue without affecting multi-line nesting and preserving all existing functionalities, we need to refactor the processNesting function. The key idea is to make processNesting a pure function that returns the generated HTML for the current nesting level instead of modifying the html string directly. This ensures that each level of nesting correctly encapsulates its child elements.

    Here’s how you can implement this fix:

    1. Refactor processNesting to Return HTML:

      • Modify processNesting so that it returns the generated HTML for the current nesting level.
      • This change ensures that each recursive call generates and returns its own HTML segment, which can be correctly nested within its parent.
    2. Update compileToHTML to Accumulate Returned HTML:

      • Adjust the part of the code where processNesting is called to accumulate the returned HTML instead of expecting processNesting to modify html directly.

    Updated Code

    Below is the revised version of your original code with the necessary changes highlighted and explained:

    const textarea = document.getElementById('code');
    const previewFrame = document.getElementById('previewFrame');
    const errorMessage = document.getElementById('error-message');
    
    function compileToHTML(customCode) {
        const lines = customCode.split('\n');
        let html = '';
        let errors = [];
        let i = 0;
        const totalLines = lines.length;
        let inBlockComment = false;
    
        while (i < totalLines) {
            let line = lines[i].trim();
    
            // Handle block comments
            if (inBlockComment) {
                if (line.endsWith('#}')) {
                    inBlockComment = false;
                }
                i++;
                continue;
            }
    
            if (line.startsWith('#{')) {
                inBlockComment = true;
                i++;
                continue;
            }
    
            // Handle single-line comments
            if (line.startsWith('#') && !line.startsWith('#{')) {
                i++;
                continue;
            }
    
            // Handle block closures
            if (line === '\\}') {
                errors.push(`Unexpected block closure '\\}' at line ${i + 1}.`);
                i++;
                continue;
            }
    
            // Handle block openings
            const blockStartMatch = line.match(/^(\w+)(\[[^\]]+\])?(#[\w\-]+)?((?:\.[\w\-]+)*?)\\\{$/);
            if (blockStartMatch) {
                const tag = blockStartMatch[1].toLowerCase();
                const attrs = blockStartMatch[2] ? replaceIndexPlaceholders(blockStartMatch[2].slice(1, -1), 0) : '';
                const id = blockStartMatch[3] ? replaceIndexPlaceholders(blockStartMatch[3].slice(1), 0) : '';
                const classesRaw = blockStartMatch[4] ? blockStartMatch[4] : '';
                const classes = classesRaw.split('.').filter(cls => cls !== '');
    
                let blockContent = '';
                i++;
                let openBlocks = 1; // Track nested blocks
    
                while (i < totalLines && openBlocks > 0) {
                    let currentLine = lines[i].trim();
    
                    if (currentLine.endsWith('\\{')) {
                        openBlocks++;
                    }
    
                    if (currentLine === '\\}') {
                        openBlocks--;
                        if (openBlocks === 0) {
                            i++;
                            break;
                        }
                    }
    
                    if (openBlocks > 0) {
                        blockContent += lines[i] + '\n';
                    }
    
                    i++;
                }
    
                if (openBlocks > 0) {
                    errors.push(`Unclosed block starting with <${tag}>.`);
                    break;
                }
    
                let innerHTML = '';
    
                if (tag === 'script' || tag === 'style' || tag === 'html') {
                    innerHTML = blockContent;
                } else {
                    const compiledBlock = compileToHTML(blockContent);
                    if (compiledBlock.errors.length > 0) {
                        errors = errors.concat(compiledBlock.errors);
                    }
                    innerHTML = compiledBlock.html;
                }
    
                let attrString = '';
                if (attrs) attrString += ` ${attrs}`;
                if (id) attrString += ` id="${id}"`;
                if (classes.length > 0) attrString += ` class="${classes.join(' ')}"`;
    
                html += `<${tag}${attrString}>\n${innerHTML}</${tag}>\n`;
    
                continue;
            }
    
            // Handle inline element declarations like tag{content}
            const inlineMatch = line.match(/^(\w+)(\[[^\]]+\])?(#[\w\-]+)?((?:\.[\w\-]+)*?)\{([^}]*)\}(?:\*(\d+))?$/);
            if (inlineMatch) {
                const tag = inlineMatch[1].toLowerCase();
                const attrs = inlineMatch[2] ? replaceIndexPlaceholders(inlineMatch[2].slice(1, -1), 0) : '';
                const id = inlineMatch[3] ? replaceIndexPlaceholders(inlineMatch[3].slice(1), 0) : '';
                const classesRaw = inlineMatch[4] ? inlineMatch[4] : '';
                const classes = classesRaw.split('.').filter(cls => cls !== '');
                const content = replaceIndexPlaceholders(inlineMatch[5], 0);
                const repeat = inlineMatch[6] ? parseInt(inlineMatch[6]) : 1;
    
                let finalAttrString = '';
                if (attrs) finalAttrString += ` ${attrs}`;
                if (id) finalAttrString += ` id="${id}"`;
                if (classes.length > 0) finalAttrString += ` class="${classes.join(' ')}"`;
    
                for (let j = 1; j <= repeat; j++) {
                    html += `<${tag}${finalAttrString}>${content}</${tag}>\n`;
                }
    
                i++;
                continue;
            }
    
            // Handle nested and sibling selectors separated by '+' and '>'
            const siblingTokens = splitRespectingBlocks(line, '+');
            siblingTokens.forEach(token => {
                const nestingTokens = splitRespectingBlocks(token, '>');
                // Use processNesting to handle each nested token
                const nestedHTML = processNesting(nestingTokens, 0, errors, i + 1);
                html += nestedHTML;
            });
    
            // Handle lines that are pure text
            const textLineMatch = line.match(/^[^+\>]+$/);
            if (!blockStartMatch && !inlineMatch && textLineMatch) {
                // Append text within the current context
                html += `${escapeHTML(line)}\n`;
            }
    
            i++;
        }
    
        return { html, errors };
    
        /**
         * Recursive function to process nested tokens.
         * @param {Array} nestingTokens - Array of tokens split by '>'.
         * @param {number} index - Current index in the nestingTokens array.
         * @param {Array} errors - Array to collect error messages.
         * @param {number} lineNumber - Current line number for error reporting.
         * @returns {string} - The generated HTML string after processing nesting.
         */
        function processNesting(nestingTokens, index, errors, lineNumber) {
            if (index >= nestingTokens.length) return '';
    
            const nestedToken = nestingTokens[index].trim();
            const isLast = index === nestingTokens.length - 1;
    
            if (nestedToken === '') return '';
    
            let generatedHTML = '';
    
            try {
                const { tag, attributes, id, classes, content, repeat } = parseElement(nestedToken, lineNumber);
                let attrString = '';
                if (attributes) attrString += ` ${attributes}`;
                if (id) attrString += ` id="${id}"`;
                if (classes.length > 0) attrString += ` class="${classes.join(' ')}"`;
    
                for (let j = 1; j <= repeat; j++) {
                    let finalContent = replaceIndexPlaceholders(content, j);
                    let finalAttrString = replaceIndexPlaceholders(attrString, j);
                    let finalId = replaceIndexPlaceholders(id, j);
                    let finalClasses = classes.map(cls => replaceIndexPlaceholders(cls, j));
    
                    if (finalId) {
                        finalAttrString = finalAttrString.replace(` id="${id}"`, ` id="${finalId}"`);
                    }
    
                    if (finalClasses.length > 0) {
                        // Replace existing class names with updated ones
                        const classRegex = /class="([^"]+)"/;
                        const match = finalAttrString.match(classRegex);
                        if (match) {
                            const existingClasses = match[1].split(' ');
                            const updatedClasses = [...new Set([...existingClasses, ...finalClasses])];
                            finalAttrString = finalAttrString.replace(classRegex, `class="${updatedClasses.join(' ')}"`);
                        } else {
                            finalAttrString += ` class="${finalClasses.join(' ')}"`;
                        }
                    }
    
                    generatedHTML += `<${tag}${finalAttrString}>`;
    
                    if (finalContent) {
                        generatedHTML += finalContent;
                    }
    
                    if (!isLast) {
                        generatedHTML += '\n';
                        // Recursive call to handle deeper nesting
                        generatedHTML += processNesting(nestingTokens, index + 1, errors, lineNumber);
                        generatedHTML += `</${tag}>\n`;
                    } else {
                        generatedHTML += `</${tag}>\n`;
                    }
                }
            } catch (err) {
                // If it's an invalid syntax but not a tag/block, treat as text
                if (nestedToken.startsWith('\\}')) {
                    // Ignore unexpected block closure inside nesting
                    return '';
                } else {
                    // Escape and append the text
                    generatedHTML += `${escapeHTML(nestedToken)}\n`;
                }
            }
    
            return generatedHTML;
        }
    }
    
    /**
     * Splits a string by a delimiter but ignores delimiters inside quotes or blocks.
     * @param {string} str - The string to split.
     * @param {string} delimiter - The delimiter to split by.
     * @returns {Array} - Array of split tokens.
     */
    function splitRespectingBlocks(str, delimiter) {
        const tokens = [];
        let current = '';
        let inQuotes = false;
        let quoteChar = '';
        let escape = false;
        let blockDepth = 0;
    
        for (let i = 0; i < str.length; i++) {
            let char = str[i];
    
            if (escape) {
                current += char;
                escape = false;
                continue;
            }
    
            if (char === '\\') {
                escape = true;
                current += char;
                continue;
            }
    
            if ((char === '"' || char === "'") && !inQuotes) {
                inQuotes = true;
                quoteChar = char;
                current += char;
                continue;
            }
    
            if (char === quoteChar && inQuotes) {
                inQuotes = false;
                quoteChar = '';
                current += char;
                continue;
            }
    
            // Track nested blocks to avoid splitting on delimiters inside blocks
            if (!inQuotes && char === '{') {
                blockDepth++;
                current += char;
                continue;
            }
    
            if (!inQuotes && char === '}') {
                blockDepth = Math.max(blockDepth - 1, 0);
                current += char;
                continue;
            }
    
            if (!inQuotes && blockDepth === 0 && char === delimiter) {
                tokens.push(current);
                current = '';
                continue;
            }
    
            current += char;
        }
    
        if (current !== '') {
            tokens.push(current);
        }
    
        return tokens;
    }
    
    /**
     * Replaces all instances of &index; with the provided index number.
     * @param {string} str - The string to process.
     * @param {number} index - The index to replace &index; with.
     * @returns {string} - The processed string.
     */
    function replaceIndexPlaceholders(str, index) {
        return str.replace(/&index;/g, index);
    }
    
    /**
     * Parses an element definition from the custom syntax.
     * @param {string} token - A token from the custom code.
     * @param {number} lineNumber - The line number for error reporting.
     * @returns {Object} - Parsed element details.
     */
    function parseElement(token, lineNumber) {
        const regex = /^(\w+)(\[[^\]]+\])?(#[\w\-]+)?((?:\.[\w\-]+)*?)\{([^}]*)\}(?:\*(\d+))?$/;
        const match = token.match(regex);
    
        if (!match) {
            throw { message: `Invalid syntax near "${token}".`, line: lineNumber };
        }
    
        const [, tag, attrs, id, classNames, content, repeat] = match;
        let attributes = '';
        let classes = [];
    
        if (attrs) {
            const attrContent = attrs.slice(1, -1);
            const attrRegex = /(\w+)="([^"]+)"/g;
            let attrMatch;
            while ((attrMatch = attrRegex.exec(attrContent)) !== null) {
                const [, attrName, attrValue] = attrMatch;
                attributes += ` ${attrName}="${attrValue}"`;
            }
    
            const validAttrFormat = [...attrContent.matchAll(attrRegex)].length > 0;
            if (attributes.trim() === '' && attrContent.trim() !== '') {
                throw { message: `Attributes must be in the format key="value".`, line: lineNumber };
            }
        }
    
        if (classNames) {
            classes = classNames.split('.').filter(cls => cls !== '').map(cls => cls.trim());
        }
    
        const element = {
            tag: tag,
            attributes: attributes,
            id: id ? id.slice(1) : '',
            classes: classes,
            content: content ? content.slice(1, -1) : '',
            repeat: repeat ? parseInt(repeat) : 1
        };
    
        return element;
    }
    
    /**
     * Escapes HTML special characters in a string.
     * @param {string} str - The string to escape.
     * @returns {string} - The escaped string.
     */
    function escapeHTML(str) {
        const replacements = {
            '&': '&amp;',
            '<': '&lt;',
            '>': '&gt;',
            '"': '&quot;',
            "'": '&#039;'
        };
        return str.replace(/[&<>"']/g, match => replacements[match]);
    }
    
    function updatePreview() {
        const customCode = textarea.value;
        let compilationResult;
        try {
            compilationResult = compileToHTML(customCode);
        } catch (error) {
            compilationResult = { html: '', errors: [`Unexpected error: ${error.message}`] };
        }
    
        const { html, errors } = compilationResult;
    
        if (errors && errors.length > 0) {
            errorMessage.textContent = errors.join(' | ');
            errorMessage.style.display = 'block';
            previewFrame.srcdoc = '';
        } else {
            errorMessage.textContent = '';
            errorMessage.style.display = 'none';
            const fullHTML = `
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Preview</title>
        <style>
            body {
                background-color: #1e1e1e;
                color: #cccccc;
                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
                padding: 20px;
            }
            h1, h2, h3, h4, h5, h6 {
                color: #ffffff;
            }
            p {
                color: #dcdcdc;
                margin-bottom: 10px;
            }
            button {
                padding: 10px 20px;
                background-color: #3498db;
                color: #fff;
                border: none;
                cursor: pointer;
                border-radius: 4px;
                margin-top: 10px;
            }
            button:hover {
                background-color: #2980b9;
            }
            a {
                color: #9b59b6;
            }
            a:hover {
                color: #8e44ad;
            }
            /* Additional styles for various elements */
            ul {
                list-style-type: disc;
                padding-left: 20px;
                margin-bottom: 10px;
            }
            li {
                margin-bottom: 5px;
            }
            input, textarea {
                background-color: #333333;
                color: #ffffff;
                border: 1px solid #555555;
                padding: 8px;
                border-radius: 4px;
                margin-top: 5px;
            }
            input:focus, textarea:focus {
                border-color: #3498db;
                outline: none;
            }
            table {
                width: 100%;
                border-collapse: collapse;
                margin-top: 10px;
            }
            th, td {
                border: 1px solid #555555;
                padding: 8px;
                text-align: left;
            }
            th {
                background-color: #444444;
            }
            tr:nth-child(even) {
                background-color: #2d2d2d;
            }
            /* Embedded Styles */
            ${extractEmbeddedStyles(html)}
        </style>
    </head>
    <body>
    ${html}
    </body>
    </html>`;
            previewFrame.srcdoc = fullHTML;
        }
    }
    
    /**
     * Extracts embedded <style> blocks from the generated HTML to include in the preview's head.
     * @param {string} html - The generated HTML content.
     * @returns {string} - Extracted CSS from <style> blocks.
     */
    function extractEmbeddedStyles(html) {
        const styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
        let styles = '';
        let match;
        while ((match = styleRegex.exec(html)) !== null) {
            styles += match[1] + '\n';
        }
        return styles;
    }
    
    updatePreview();
    
    let timeout;
    textarea.addEventListener('input', () => {
        clearTimeout(timeout);
        timeout = setTimeout(updatePreview, 300);
    });
    
    const tabEditor = document.getElementById('tab-editor');
    const tabPreview = document.getElementById('tab-preview');
    const editor = document.querySelector('.editor');
    const preview = document.querySelector('.preview');
    
    function activateTab(tab) {
        if (tab === 'editor') {
            tabEditor.classList.add('active');
            tabPreview.classList.remove('active');
            editor.classList.add('active');
            preview.classList.remove('active');
        } else if (tab === 'preview') {
            tabPreview.classList.add('active');
            tabEditor.classList.remove('active');
            preview.classList.add('active');
            editor.classList.remove('active');
        }
    }
    
    tabEditor.addEventListener('click', () => activateTab('editor'));
    tabPreview.addEventListener('click', () => activateTab('preview'));
    
    textarea.addEventListener('keydown', e => {
        const openingChars = {
            '"': '"',
            "'": "'",
            '(': ')',
            '{': '}',
            '[': ']',
            '<': '>'
        };
    
        const closingChars = Object.values(openingChars);
    
        if (e.key === 'Backspace') {
            const cursorPos = textarea.selectionStart;
            const textBeforeCursor = textarea.value.substring(0, cursorPos);
            const lastTwoChars = textBeforeCursor.slice(-2);
            return;
        }
    
        if (e.key === '"' || e.key === "'") {
            const closingChar = openingChars[e.key];
            const cursorPos = textarea.selectionStart;
            const beforeCursor = textarea.value.substring(0, cursorPos);
            const afterCursor = textarea.value.substring(cursorPos);
    
            if (afterCursor.startsWith(closingChar)) {
                e.preventDefault();
                textarea.setSelectionRange(cursorPos + 1, cursorPos + 1);
            } else {
                e.preventDefault();
                textarea.value = beforeCursor + e.key + closingChar + afterCursor;
                setTimeout(() => {
                    textarea.setSelectionRange(cursorPos + 1, cursorPos + 1);
                    textarea.dispatchEvent(new Event('input'));
                }, 0);
            }
            return;
        }
    
        if (e.key in openingChars) {
            e.preventDefault();
            const closingChar = openingChars[e.key];
            const cursorPos = textarea.selectionStart;
            const beforeCursor = textarea.value.substring(0, cursorPos);
            const afterCursor = textarea.value.substring(cursorPos);
    
            textarea.value = beforeCursor + e.key + closingChar + afterCursor;
            setTimeout(() => {
                textarea.setSelectionRange(cursorPos + e.key.length, cursorPos + e.key.length);
                textarea.dispatchEvent(new Event('input'));
            }, 0);
        }
    
        if (closingChars.includes(e.key)) {
            const cursorPos = textarea.selectionStart;
            const nextChar = textarea.value.substring(cursorPos, cursorPos + 1);
            if (e.key === nextChar) {
                e.preventDefault();
                textarea.setSelectionRange(cursorPos + 1, cursorPos + 1);
            }
        }
    });
    

    Key Changes Explained

    1. Refactored processNesting Function:

      function processNesting(nestingTokens, index, errors, lineNumber) {
          if (index >= nestingTokens.length) return '';
      
          const nestedToken = nestingTokens[index].trim();
          const isLast = index === nestingTokens.length - 1;
      
          if (nestedToken === '') return '';
      
          let generatedHTML = '';
      
          try {
              const { tag, attributes, id, classes, content, repeat } = parseElement(nestedToken, lineNumber);
              let attrString = '';
              if (attributes) attrString += ` ${attributes}`;
              if (id) attrString += ` id="${id}"`;
              if (classes.length > 0) attrString += ` class="${classes.join(' ')}"`;
      
              for (let j = 1; j <= repeat; j++) {
                  let finalContent = replaceIndexPlaceholders(content, j);
                  let finalAttrString = replaceIndexPlaceholders(attrString, j);
                  let finalId = replaceIndexPlaceholders(id, j);
                  let finalClasses = classes.map(cls => replaceIndexPlaceholders(cls, j));
      
                  if (finalId) {
                      finalAttrString = finalAttrString.replace(` id="${id}"`, ` id="${finalId}"`);
                  }
      
                  if (finalClasses.length > 0) {
                      // Replace existing class names with updated ones
                      const classRegex = /class="([^"]+)"/;
                      const match = finalAttrString.match(classRegex);
                      if (match) {
                          const existingClasses = match[1].split(' ');
                          const updatedClasses = [...new Set([...existingClasses, ...finalClasses])];
                          finalAttrString = finalAttrString.replace(classRegex, `class="${updatedClasses.join(' ')}"`);
                      } else {
                          finalAttrString += ` class="${finalClasses.join(' ')}"`;
                      }
                  }
      
                  generatedHTML += `<${tag}${finalAttrString}>`;
      
                  if (finalContent) {
                      generatedHTML += finalContent;
                  }
      
                  if (!isLast) {
                      generatedHTML += '\n';
                      // Recursive call to handle deeper nesting
                      generatedHTML += processNesting(nestingTokens, index + 1, errors, lineNumber);
                      generatedHTML += `</${tag}>\n`;
                  } else {
                      generatedHTML += `</${tag}>\n`;
                  }
              }
          } catch (err) {
              // If it's an invalid syntax but not a tag/block, treat as text
              if (nestedToken.startsWith('\\}')) {
                  // Ignore unexpected block closure inside nesting
                  return '';
              } else {
                  // Escape and append the text
                  generatedHTML += `${escapeHTML(nestedToken)}\n`;
              }
          }
      
          return generatedHTML;
      }
      
      • What Changed: Instead of modifying the html string directly and passing it down through recursive calls, the processNesting function now returns the generated HTML string for its current level and any nested levels.
      • Why: This ensures that each level of nesting is correctly encapsulated and appended to the parent without interference, maintaining the proper hierarchical structure.
    2. Updated compileToHTML to Accumulate Returned HTML:

      // Handle nested and sibling selectors separated by '+' and '>'
      const siblingTokens = splitRespectingBlocks(line, '+');
      siblingTokens.forEach(token => {
          const nestingTokens = splitRespectingBlocks(token, '>');
          // Use processNesting to handle each nested token
          const nestedHTML = processNesting(nestingTokens, 0, errors, i + 1);
          html += nestedHTML;
      });
      
      • What Changed: After calling processNesting, the returned HTML (nestedHTML) is now concatenated to the main html string.
      • Why: This ensures that the nested structures returned by processNesting are correctly appended to the main HTML output.
    3. Other Minor Adjustments:

      • Avoid Passing html as a Mutable Parameter: By ensuring processNesting does not depend on a mutable html parameter, we prevent unintended side effects and maintain the purity of the function.
      • Consistent Indentation and Formatting: To improve readability and maintainability, consistent indentation and formatting have been applied.

    Testing the Fix

    With these changes, your inline nesting example:

    ul>li{Item}>ul>li{Subitem}>ul>li{Sub subitem}
    

    Should correctly compile to the following HTML structure:

    <ul>
        <li>Item
            <ul>
                <li>Subitem
                    <ul>
                        <li>Sub subitem</li>
                    </ul>
                </li>
            </ul>
        </li>
    </ul>
    

    This nested structure properly reflects the intended hierarchy, ensuring that each ul contains the appropriate li elements with their respective sublists.

    Conclusion

    By refactoring the processNesting function to return the generated HTML instead of modifying a shared html string, the inline nesting issue is resolved. This approach maintains all existing functionalities, including multi-line nesting, and ensures that the generated HTML accurately represents the intended structure from both inline and multi-line inputs.

    Feel free to integrate these changes into your project. If you encounter any further issues or have additional questions, please don't hesitate to ask!