{"version":3,"sources":["jsdelivr-header.js","/npm/derivaintegra@1.0.0/derivaintegra.js"],"names":[],"mappings":"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","file":"/npm/derivaintegra@1.0.0/derivaintegra.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/derivaintegra@1.0.0/derivaintegra.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\r\n * Derivaintegra - Biblioteca de Cálculo Simbólico (Derivada e Integral)\r\n * Versão: 1.0.0 (Correção de Simplificação e Constantes)\r\n */\r\n\r\nconst VERSION = \"2.1.2\";\r\n\r\nclass StepsBuilder {\r\n    constructor() {\r\n        this.steps = [];\r\n        this.isIntegral = false; \r\n    }\r\n    \r\n    addStep(title, explanation, formula, calculo, isError = false) { \r\n        this.steps.push({ title, explanation, formula, calculo, isError }); \r\n    }\r\n    \r\n    addNestedSteps(title, nestedBuilder) { \r\n        this.steps.push({ title, nestedBuilder }); \r\n    }\r\n    \r\n    render() {\r\n        if (this.steps.length === 0) return \"Nenhum passo gerado.\";\r\n        return this.steps.map((step, index) => {\r\n            let html = `<div class=\"step\">`;\r\n            html += `<div class=\"step-title\">${index + 1}. ${step.title}</div>`;\r\n            if (step.nestedBuilder) {\r\n                html += `<div style=\"padding-left: 20px; border-left: 2px solid #ccc; margin-top: 10px;\">`;\r\n                html += step.nestedBuilder.render();\r\n                html += `</div>`;\r\n            } else {\r\n                html += `<ul>`;\r\n                if (step.explanation) html += `<li>${step.explanation}</li>`;\r\n                if (step.formula) html += `<li><strong>Fórmula:</strong> $${step.formula}$</li>`;\r\n                if (step.calculo) html += `<li><strong>Cálculo:</strong> $${step.calculo}$</li>`;\r\n                html += `</ul>`;\r\n            }\r\n            html += `</div>`;\r\n            return html;\r\n        }).join('');\r\n    }\r\n}\r\n\r\n// --- FUNÇÕES UTILITÁRIAS ---\r\n\r\nfunction wrapIfNeeded(term) {\r\n    let parenCount = 0;\r\n    for (let i = 0; i < term.length; i++) {\r\n        if (term[i] === '(') parenCount++;\r\n        if (term[i] === ')') parenCount--;\r\n        if (parenCount === 0 && (term[i] === '+' || (term[i] === '-' && i > 0))) {\r\n            return `(${term})`;\r\n        }\r\n    }\r\n    return term;\r\n}\r\n\r\nfunction toKaTeX(str) { \r\n    if (!str) return \"\";\r\n    let katexStr = str.replace(/\\s+/g, ' '); \r\n    katexStr = katexStr.replace(/\\b(sin|cos|tan|ln|sqrt)\\(/g, \"\\\\$1(\");\r\n    katexStr = katexStr.replace(/exp\\(([^)]+)\\)/g, (match, content) => {\r\n        if (content.match(/^-?([\\d\\.]*x(\\^[\\d\\.-]+)?|[\\d\\.]+)$/)) {\r\n            return `e^{${content}}`;\r\n        }\r\n        return `e^{(${content})}`;\r\n    });\r\n    katexStr = katexStr.replace(/e\\^\\(([^)]+)\\)/g, \"e^{$1}\");\r\n    // Remove asteriscos entre números e variáveis/funções para visual limpo\r\n    katexStr = katexStr.replace(/(\\d)\\s*\\*\\s*(\\d)/g, '$1 \\\\cdot $2');\r\n    katexStr = katexStr.replace(/\\s*\\*\\s*/g, \" \"); \r\n    return katexStr;\r\n}\r\n\r\nfunction simplifyExpression(expr) {\r\n    let simplified = expr;\r\n    let lastExpr;\r\n    \r\n    do {\r\n        lastExpr = simplified;\r\n        simplified = simplified.replace(/\\s+/g, ''); // Remove espaços para análise precisa\r\n        \r\n        // 1. Limpeza básica de parênteses duplos e redundantes\r\n        simplified = simplified.replace(/\\(\\(([^()]+)\\)\\)/g, '($1)');\r\n        \r\n        // 2. Multiplicação por 0 (Esquerda e Direita)\r\n        // Cobre casos como \"sin(x)*0\", \"0*cos(x)\", \"(...) * 0\"\r\n        simplified = simplified.replace(/(\\w+\\([^)]+\\)|[a-z0-9^]+|\\([^)]+\\))\\*0(?![.0-9])/gi, '0');\r\n        simplified = simplified.replace(/(^|[^.0-9])0\\*(\\w+\\([^)]+\\)|[a-z0-9^]+|\\([^)]+\\))/gi, '$10');\r\n\r\n        // 3. Adição/Subtração de 0\r\n        simplified = simplified.replace(/\\+0(?![.0-9])/g, '');\r\n        simplified = simplified.replace(/-0(?![.0-9])/g, '');\r\n        simplified = simplified.replace(/^0\\+/g, '');\r\n        \r\n        // 4. Multiplicação por 1\r\n        simplified = simplified.replace(/\\*1(?![.0-9])/g, '');\r\n        simplified = simplified.replace(/(^|[^.0-9])1\\*/g, '$1');\r\n\r\n        // 5. Agrupamento de Coeficientes (Ajuste Solicitado)\r\n        // Caso: 2 * 2x -> 4x\r\n        simplified = simplified.replace(/(\\d+)\\*(\\d+)x/g, (m, n1, n2) => (parseFloat(n1)*parseFloat(n2)) + 'x');\r\n        // Caso: 2x * 2 -> 4x\r\n        simplified = simplified.replace(/(\\d+)x\\*(\\d+)/g, (m, n1, n2) => (parseFloat(n1)*parseFloat(n2)) + 'x');\r\n        // Caso: (2x) * 2 -> 4x (com parenteses)\r\n        simplified = simplified.replace(/\\((\\d+)x\\)\\*(\\d+)/g, (m, n1, n2) => (parseFloat(n1)*parseFloat(n2)) + 'x');\r\n        simplified = simplified.replace(/(\\d+)\\*\\((\\d+)x\\)/g, (m, n1, n2) => (parseFloat(n1)*parseFloat(n2)) + 'x');\r\n        \r\n        // 6. Sinais\r\n        simplified = simplified.replace(/\\+\\s*-\\s*/g, '- ');\r\n        simplified = simplified.replace(/-\\s*-\\s*/g, '+ ');\r\n        \r\n    } while (simplified !== lastExpr);\r\n    \r\n    // Limpeza final de parênteses externos\r\n    if (simplified.startsWith('(') && simplified.endsWith(')')) {\r\n        let parenCount = 0; let valid = true;\r\n        for (let i = 0; i < simplified.length - 1; i++) { \r\n            if (simplified[i] === '(') parenCount++; \r\n            if (simplified[i] === ')') parenCount--; \r\n            if (parenCount === 0) { valid = false; break; } \r\n        }\r\n        if (valid) { simplified = simplified.substring(1, simplified.length - 1); }\r\n    }\r\n\r\n    // Formatação estética final (Espaços ao redor de operadores)\r\n    simplified = simplified.replace(/\\*/g, ' * ').replace(/\\+/g, ' + ').replace(/-/g, ' - ');\r\n    // Remove espaços extras criados\r\n    simplified = simplified.replace(/\\s\\s+/g, ' ').trim();\r\n    // Corrige notação 4x (remove o * entre numero e var para ficar bonito)\r\n    simplified = simplified.replace(/(\\d) \\* ([a-zA-Z])/g, '$1$2');\r\n\r\n    return simplified;\r\n}\r\n\r\nfunction splitTopLevel(str) {\r\n    let parts = [];\r\n    let depth = 0;\r\n    let current = \"\";\r\n    for (let i = 0; i < str.length; i++) {\r\n        let char = str[i];\r\n        if (char === '(') depth++;\r\n        if (char === ')') depth--;\r\n        if (depth === 0 && (char === '+' || char === '-')) {\r\n            if (current.trim()) parts.push(current.trim());\r\n            parts.push(char); \r\n            current = \"\";\r\n        } else {\r\n            current += char;\r\n        }\r\n    }\r\n    if (current.trim()) parts.push(current.trim());\r\n    return parts;\r\n}\r\n\r\nfunction distribuirProduto(coef, expr) {\r\n    let inner = expr.trim();\r\n    if (inner.startsWith('(') && inner.endsWith(')')) {\r\n        let depth = 0, ok = true;\r\n        for(let i=0; i<inner.length-1; i++) {\r\n            if(inner[i]=='(') depth++; if(inner[i]==')') depth--;\r\n            if(depth==0) { ok=false; break; }\r\n        }\r\n        if(ok) inner = inner.substring(1, inner.length-1);\r\n    }\r\n    let parts = splitTopLevel(inner);\r\n    let result = \"\";\r\n    if (parts.length === 1) { return `${coef} * ${parts[0]}`; }\r\n    for (let i = 0; i < parts.length; i++) {\r\n        let p = parts[i];\r\n        if (p === '+' || p === '-') { result += ` ${p} `; } else { result += `${coef} * ${p}`; }\r\n    }\r\n    return result;\r\n}\r\n\r\nfunction extrairCoeficiente(termo) {\r\n    let t = termo.replace(/\\s+/g, '');\r\n    if (t.startsWith('(') && t.endsWith(')')) t = t.substring(1, t.length-1);\r\n    let coef = 1; let resto = t;\r\n    const matchNum = t.match(/^(-?[\\d\\.]+)(\\*)?/);\r\n    if (matchNum) {\r\n        coef = parseFloat(matchNum[1]);\r\n        resto = t.substring(matchNum[0].length);\r\n        if (resto === '') resto = '1';\r\n    } else if (t.startsWith('-')) {\r\n        coef = -1; resto = t.substring(1);\r\n    }\r\n    return { coef, resto };\r\n}\r\n\r\n// --- MOTOR DE DERIVAÇÃO ---\r\n\r\nfunction derivar(expr, notation) {\r\n    const stepsBuilder = new StepsBuilder();\r\n    let d_final = \"\";\r\n    let expr_str_limpa = expr.replace(/\\s+/g, '');\r\n    if (!expr_str_limpa) return { derivadaStr: \"0\", stepsBuilder };\r\n    const result = derivarExpressao(expr_str_limpa, stepsBuilder, notation);\r\n    stepsBuilder.addStep(\"União dos Resultados\", \"Juntando todos os resultados parciais...\", `f'(x) = ${result.derivadaStr}`, null);\r\n    d_final = simplifyExpression(result.derivadaStr);\r\n    return { derivadaStr: d_final, stepsBuilder: stepsBuilder };\r\n}\r\n\r\nfunction derivarExpressao(expr, parentSteps, notation) {\r\n    let d_final = \"\";\r\n    let termos = []; let operadores = []; let parenCount = 0; let start = 0;\r\n    for (let i = 0; i < expr.length; i++) {\r\n        const char = expr[i]; if (char === '(') parenCount++; if (char === ')') parenCount--;\r\n        if (parenCount === 0 && (char === '+' || char === '-')) {\r\n            if (i > 0 || (char === '+' && start === 0)) { \r\n                if (i > 0) { termos.push(expr.substring(start, i)); operadores.push(char); }\r\n                start = i + 1; \r\n            }\r\n        }\r\n    }\r\n    termos.push(expr.substring(start));\r\n    if (termos.length === 1 && operadores.length === 0) return derivarTermo(expr, parentSteps, notation);\r\n    \r\n    let formula, calculo;\r\n    if (notation === 'leibniz') { formula = `\\\\frac{d}{dx}(u \\u00B1 v) = \\\\frac{d}{dx}(u) \\u00B1 \\\\frac{d}{dx}(v)`; calculo = `\\\\text{Aplicando a } \\\\frac{d}{dx}(${toKaTeX(expr)})`; }\r\n    else { formula = `(u \\u00B1 v)' = u' \\u00B1 v'`; calculo = `\\\\text{Aplicando a } (${toKaTeX(expr)})'`; }\r\n    parentSteps.addStep( \"Regra da Soma/Subtração\", \"A derivada de uma soma/subtração é a soma/subtração das derivadas.\", formula, calculo);\r\n    \r\n    let derivadasTermos = [];\r\n    for (let i = 0; i < termos.length; i++) {\r\n        const termo = termos[i]; if(termo === \"\") continue;\r\n        const nestedSteps = new StepsBuilder(); nestedSteps.isIntegral = parentSteps.isIntegral;\r\n        const result = derivarTermo(termo, nestedSteps, notation);\r\n        derivadasTermos.push(result.derivadaStr);\r\n        const title = (notation === 'leibniz') ? `Derivando $\\\\frac{d}{dx}(${toKaTeX(termo)})$:` : `Derivando $(${toKaTeX(termo)})'$:`;\r\n        parentSteps.addNestedSteps(title, result.stepsBuilder);\r\n    }\r\n    d_final = derivadasTermos[0] || \"\";\r\n    for (let i = 0; i < operadores.length; i++) { if(derivadasTermos[i+1]) { d_final += ` ${operadores[i]} ${derivadasTermos[i + 1]}`; } }\r\n    return { derivadaStr: d_final, stepsBuilder: parentSteps };\r\n}\r\n\r\nfunction derivarTermo(expr, parentSteps, notation) {\r\n    let parenCount = 0;\r\n    for (let i = expr.length - 1; i >= 0; i--) {\r\n        const char = expr[i]; if (char === ')') parenCount++; if (char === '(') parenCount--;\r\n        if (parenCount === 0 && (char === '*' || char === '/' || char === '.')) {\r\n            const u = expr.substring(0, i); const v = expr.substring(i + 1); const op = char;\r\n            if(!u || !v) continue;\r\n            const u_nested_steps = new StepsBuilder(); u_nested_steps.isIntegral = parentSteps.isIntegral;\r\n            const v_nested_steps = new StepsBuilder(); v_nested_steps.isIntegral = parentSteps.isIntegral;\r\n            const u_result = derivarFator(u, u_nested_steps, notation);\r\n            const v_result = derivarFator(v, v_nested_steps, notation);\r\n            const du_str = u_result.derivadaStr; const dv_str = v_result.derivadaStr;\r\n            const u_wrapped = wrapIfNeeded(u); const v_wrapped = wrapIfNeeded(toKaTeX(v));\r\n            const du_wrapped = wrapIfNeeded(du_str); const dv_wrapped = wrapIfNeeded(dv_str);\r\n            let d_final = ''; let formula = ''; let calculo = ''; let u_deriv_str, v_deriv_str;\r\n            \r\n            if (op === '*' || op === '.') {\r\n                // --- OTIMIZAÇÃO: Verifica zeros antes de montar a string final ---\r\n                const u_is_zero = (du_str === \"0\");\r\n                const v_is_zero = (dv_str === \"0\");\r\n\r\n                if (u_is_zero && v_is_zero) {\r\n                    d_final = \"0\";\r\n                    calculo = `\\\\text{Ambos constantes} \\\\Rightarrow 0`;\r\n                } else if (u_is_zero) {\r\n                    // u é constante (du=0), sobrou u * dv\r\n                    d_final = `${u_wrapped} * ${dv_wrapped}`;\r\n                    calculo = `u' = 0, v' = ${dv_str} \\\\\\\\ \\\\text{Res} = ${u_wrapped} \\\\cdot ${dv_wrapped}`;\r\n                } else if (v_is_zero) {\r\n                    // v é constante (dv=0), sobrou du * v\r\n                    d_final = `${du_wrapped} * ${v_wrapped}`;\r\n                    calculo = `u' = ${du_str}, v' = 0 \\\\\\\\ \\\\text{Res} = ${du_wrapped} \\\\cdot ${v_wrapped}`;\r\n                } else {\r\n                    // Caso padrão\r\n                    d_final = `(${du_wrapped} * ${v_wrapped} + ${u_wrapped} * ${dv_wrapped})`;\r\n                    calculo = `u = ${u}, v = ${v} \\\\\\\\ u'=${du_str}, v'=${dv_str} \\\\\\\\ \\\\text{Res} = ${du_wrapped} \\\\cdot ${v_wrapped} + ${u_wrapped} \\\\cdot ${dv_wrapped}`;\r\n                }\r\n\r\n                if (notation === 'leibniz') { formula = `\\\\frac{d}{dx}(u \\\\cdot v) = \\\\frac{d}{dx}(u)v + u\\\\frac{d}{dx}(v)`; }\r\n                else { formula = `(u \\\\cdot v)' = u'v + uv'`; }\r\n                \r\n                parentSteps.addStep(\"Regra do Produto\", \"Aplicando a regra do produto.\", formula, calculo);\r\n            } else {\r\n                // Regra do quociente\r\n                d_final = `((${du_wrapped} * ${v_wrapped} - ${u_wrapped} * ${dv_wrapped}) / (${v_wrapped})^2)`;\r\n                if (notation === 'leibniz') { formula = `\\\\frac{d}{dx}(\\\\frac{u}{v}) = \\\\frac{\\\\frac{d}{dx}(u)v - u\\\\frac{d}{dx}(v)}{v^2}`; u_deriv_str = `... = ${du_str}`; v_deriv_str = `... = ${dv_str}`; }\r\n                else { formula = `(\\\\frac{u}{v})' = \\\\frac{u'v - uv'}{v^2}`; u_deriv_str = `u' = ${du_str}`; v_deriv_str = `v' = ${dv_str}`; }\r\n                calculo = `u = ${u}, v = ${v} \\\\\\\\ ${u_deriv_str}, ${v_deriv_str} \\\\\\\\ \\\\text{Res} = \\\\frac{${du_wrapped} \\\\cdot ${v_wrapped} - ${u_wrapped} \\\\cdot ${dv_wrapped}}{(${v_wrapped})^2}`;\r\n                parentSteps.addStep(\"Regra do Quociente\", \"Aplicando a regra do quociente.\", formula, calculo);\r\n            }\r\n            const title_u = (notation === 'leibniz') ? `Cálculo de $\\\\frac{d}{dx}(${toKaTeX(u)})$:` : `Cálculo de $u'$:`;\r\n            const title_v = (notation === 'leibniz') ? `Cálculo de $\\\\frac{d}{dx}(${toKaTeX(v)})$:` : `Cálculo de $v'$:`;\r\n            parentSteps.addNestedSteps(title_u, u_result.stepsBuilder);\r\n            parentSteps.addNestedSteps(title_v, v_result.stepsBuilder);\r\n            return { derivadaStr: d_final, stepsBuilder: parentSteps };\r\n        }\r\n    }\r\n    return derivarFator(expr, parentSteps, notation);\r\n}\r\n\r\nfunction derivarFator(expr, parentSteps, notation) {\r\n    if (!isNaN(parseFloat(expr)) && isFinite(expr) && !expr.toLowerCase().includes('x')) { \r\n        parentSteps.addStep(\"Regra da Constante\", \"A derivada de uma constante (c) é 0.\", `(c)' = 0`, `(${expr})' = 0`); \r\n        return { derivadaStr: \"0\", stepsBuilder: parentSteps }; \r\n    }\r\n    if (expr === 'x') { \r\n        parentSteps.addStep(\"Regra da Variável\", \"A derivada de x (em relação a x) é 1.\", `(x)' = 1`, `(${expr})' = 1`); \r\n        return { derivadaStr: \"1\", stepsBuilder: parentSteps }; \r\n    }\r\n    let match = expr.match(/^(-?[\\d\\.]*)x(\\^([\\d\\.-]+))?$/);\r\n    if (match) {\r\n        let a = match[1]; let n = match[3]; if (a === \"\") a = \"1\"; if (a === \"-\") a = \"-1\"; if (n === undefined) n = \"1\";\r\n        const a_val = parseFloat(a); const n_val = parseFloat(n);\r\n        const novo_a = a_val * n_val; const novo_n = n_val - 1;\r\n        let d_final = \"\";\r\n        if (novo_a === 0) { d_final = \"0\"; }\r\n        else if (novo_n === 0) { d_final = `${novo_a}`; }\r\n        else if (novo_n === 1) { d_final = `${novo_a === 1 ? '' : (novo_a === -1 ? '-' : novo_a)}x`; }\r\n        else { d_final = `${novo_a === 1 ? '' : (novo_a === -1 ? '-' : novo_a)}x^${novo_n}`; }\r\n        parentSteps.addStep(\"Regra da Potência\", \"Aplicando a regra (ax^n)' = anx^{n-1}.\", `(ax^n)' = anx^{n-1}`, `a=${a_val}, n=${n_val} \\\\\\\\ ${a_val} \\\\cdot ${n_val}x^{${n_val}-1} = ${d_final}`);\r\n        return { derivadaStr: d_final, stepsBuilder: parentSteps };\r\n    }\r\n    if (expr.startsWith('(') && expr.endsWith(')')) {\r\n        let parenCount = 0; let valid = true;\r\n        for (let i = 0; i < expr.length -1; i++) { if (expr[i] === '(') parenCount++; if (expr[i] === ')') parenCount--; if (parenCount === 0) { valid = false; break; } }\r\n        if (parenCount !== 1) valid = false;\r\n        if (valid) {\r\n            const innerExpr = expr.substring(1, expr.length - 1);\r\n            const nestedSteps = new StepsBuilder(); nestedSteps.isIntegral = parentSteps.isIntegral;\r\n            const innerResult = derivarExpressao(innerExpr, nestedSteps, notation);\r\n            parentSteps.addStep(\"Regra dos Parênteses\", \"A derivada de (f(x)) é a derivada do conteúdo interno.\", \"\", `Derivando ${innerExpr}`);\r\n            parentSteps.addNestedSteps(\"Passos internos:\", innerResult.stepsBuilder);\r\n            return { derivadaStr: `(${innerResult.derivadaStr})`, stepsBuilder: parentSteps };\r\n        }\r\n    }\r\n    match = expr.match(/^(.+)\\^([\\d\\.-]+)$/);\r\n    if (match) {\r\n        const u = match[1];\r\n        const n = parseFloat(match[2]);\r\n        let parenCount = 0;\r\n        let unbalanced = false;\r\n        for(let char of u) {\r\n            if(char === '(') parenCount++;\r\n            if(char === ')') parenCount--;\r\n            if(parenCount < 0) { unbalanced = true; break; }\r\n        }\r\n        if(!unbalanced && parenCount === 0) {\r\n            const nestedSteps = new StepsBuilder();\r\n            const uResult = derivarFator(u, nestedSteps, notation);\r\n            if (!uResult.derivadaStr.startsWith('[Erro')) {\r\n                const novo_n = n - 1;\r\n                let u_pow_str = \"\";\r\n                const u_latex = toKaTeX(u);\r\n                const du_latex = toKaTeX(uResult.derivadaStr);\r\n                if (novo_n === 1) u_pow_str = wrapIfNeeded(u);\r\n                else if (novo_n === 0) u_pow_str = \"1\";\r\n                else u_pow_str = `(${u})^${novo_n}`;\r\n                let d_final = `${n} * ${u_pow_str} * (${uResult.derivadaStr})`;\r\n                parentSteps.addStep(\r\n                    \"Regra da Cadeia (Potência)\", \r\n                    \"Aplicando $(u^n)' = n \\\\cdot u^{n-1} \\\\cdot u'$\", \r\n                    `u = ${u_latex}, \\\\quad n = ${n}`, \r\n                    `f' = ${n} \\\\cdot (${u_latex})^{${novo_n}} \\\\cdot (${du_latex})`\r\n                );\r\n                parentSteps.addNestedSteps(`Derivada da base $u$:`, uResult.stepsBuilder);\r\n                return { derivadaStr: d_final, stepsBuilder: parentSteps };\r\n            }\r\n        }\r\n    }\r\n\r\n    match = expr.match(/^(sin|cos|tan|ln|exp|sqrt)\\((.+)\\)$/);\r\n    if (match) {\r\n        const func = match[1]; const innerExpr = match[2];\r\n        let parenCount = 0;\r\n        for(let char of innerExpr) { if (char === '(') parenCount++; if (char === ')') parenCount--; }\r\n        if (parenCount !== 0) {\r\n            parentSteps.addStep(\"Erro\", `Parênteses desbalanceados em: ${expr}`, \"\", \"\", true);\r\n            return { derivadaStr: `[Erro em '${expr}']`, stepsBuilder: parentSteps };\r\n        }\r\n        const nestedSteps = new StepsBuilder(); nestedSteps.isIntegral = parentSteps.isIntegral;\r\n        const innerResult = derivarExpressao(innerExpr, nestedSteps, notation); const inner_d_str = innerResult.derivadaStr;\r\n        let d_func_u = \"\"; let d_final = \"\"; let formula = \"\";\r\n        switch (func) {\r\n            case 'sin': d_func_u = `\\\\cos(${toKaTeX(innerExpr)})`; formula = `(\\\\sin(u))' = \\\\cos(u) \\\\cdot u'`; break;\r\n            case 'cos': d_func_u = `-\\\\sin(${toKaTeX(innerExpr)})`; formula = `(\\\\cos(u))' = -\\\\sin(u) \\\\cdot u'`; break;\r\n            case 'tan': d_func_u = `(1 / (\\\\cos(${toKaTeX(innerExpr)}))^2)`; formula = `(\\\\tan(u))' = \\\\sec^2(u) \\\\cdot u'`; break;\r\n            case 'ln': d_func_u = `(1 / (${toKaTeX(innerExpr)}))`; formula = `(\\\\ln(u))' = \\\\frac{1}{u} \\\\cdot u'`; break;\r\n            case 'exp': d_func_u = `exp(${toKaTeX(innerExpr)})`; formula = `(e^u)' = e^u \\\\cdot u'`; break;\r\n            case 'sqrt': d_func_u = `(1 / (2 * \\\\sqrt(${toKaTeX(innerExpr)})))`; formula = `(\\\\sqrt(u))' = \\\\frac{1}{2\\\\sqrt{u}} \\\\cdot u'`; break;\r\n        }\r\n        d_final = `${d_func_u}`;\r\n        if (innerExpr !== 'x' && inner_d_str !== '1') { d_final += ` * (${inner_d_str})`; }\r\n        parentSteps.addStep(`Regra da Cadeia (${func})`, `u = ${toKaTeX(innerExpr)}`, formula, `Res = ${d_final}`);\r\n        parentSteps.addNestedSteps(`Cálculo de $u'$:`, innerResult.stepsBuilder);\r\n        return { derivadaStr: d_final, stepsBuilder: parentSteps };\r\n    }\r\n    parentSteps.addStep(\"Erro\", `Termo não reconhecido: ${expr}`, \"\", \"\", true);\r\n    return { derivadaStr: `[Erro: ${expr}]`, stepsBuilder: parentSteps };\r\n}\r\n\r\n// --- MOTOR DE INTEGRAÇÃO ---\r\n\r\nfunction integrar(expr) {\r\n    let exprLimpa = expr.replace(/\\s+/g, '');\r\n    let termos = []; let operadores = ['+']; let parenCount = 0; let start = 0;\r\n    for (let i = 0; i < exprLimpa.length; i++) {\r\n        const char = exprLimpa[i]; if (char === '(') parenCount++; if (char === ')') parenCount--;\r\n        if (parenCount === 0 && (char === '+' || char === '-')) {\r\n            if (i > 0) { termos.push(exprLimpa.substring(start, i)); operadores.push(char); start = i + 1; } else if (char === '-' && i === 0) { start = 1; operadores[0] = '-'; }\r\n        }\r\n    }\r\n    termos.push(exprLimpa.substring(start));\r\n    const mainStepsBuilder = new StepsBuilder();\r\n    mainStepsBuilder.isIntegral = true;\r\n    let finalIntegralTerms = []; \r\n    mainStepsBuilder.addStep( \r\n        \"Regra da Soma (Integração)\", \r\n        \"A integral da soma é a soma das integrais de cada termo.\", \r\n        \"\\\\int (f(x) + g(x)) dx = \\\\int f(x) dx + \\\\int g(x) dx\", \r\n        `\\\\text{Separando a expressão: } \\\\int ${toKaTeX(expr)} dx` \r\n    );\r\n    for (let i = 0; i< termos.length; i++) {\r\n        let termo = termos[i]; if (!termo) continue;\r\n        let sinal = operadores[i]; let termoOriginal = (sinal === '+' ? (i>0 ? ' + ' : '') : ' - ') + termo;\r\n        if(sinal === '-') termo = '-' + termo;\r\n        let sinalOperador = (sinal === '-' ? ' - ' : ' + '); if (i === 0 && sinal === '+') sinalOperador = '';\r\n        const nestedSteps = new StepsBuilder(); nestedSteps.isIntegral = true;\r\n        const { integralStr: termoResultStr } = analisarEIntegrarTermo(termo, nestedSteps);\r\n        finalIntegralTerms.push(sinalOperador + termoResultStr); \r\n        mainStepsBuilder.addNestedSteps( `Integrando o termo: $${toKaTeX(termoOriginal)} dx$`, nestedSteps );\r\n    }\r\n    let rawIntegralStr = finalIntegralTerms.join('').trim(); \r\n    if (rawIntegralStr.startsWith(' + ')) rawIntegralStr = rawIntegralStr.substring(3);\r\n    let finalIntegralStr_raw = simplifyExpression(rawIntegralStr); \r\n    return { integralStr: finalIntegralStr_raw, stepsBuilder: mainStepsBuilder };\r\n}\r\n\r\nfunction integrarTermoSimples(expr, variable = 'x', parentSteps = null) {\r\n    const addStep = (title, exp, f, c, isErr=false) => { if (parentSteps) { parentSteps.isIntegral = true; parentSteps.addStep(title, exp, f, c, isErr); } };\r\n    const v = variable.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n    if (!isNaN(parseFloat(expr)) && isFinite(expr) && !expr.toLowerCase().includes(variable)) {\r\n        const c = expr; const i_final = (c === '0') ? '0' : `${c}${variable}`;\r\n        if(c === '0') { addStep(\"Integral de Zero\", \"A integral de 0 é 0.\", `\\\\int 0 d${v} = 0`, ``); return { integralStr: '0' }; }\r\n        addStep(\"Regra da Constante (Int.)\", \"A integral de uma constante 'c' é 'cv'.\", `\\\\int c d${v} = c${v}`, `\\\\int ${c} d${v} = ${i_final}`);\r\n        return { integralStr: i_final };\r\n    }\r\n    const potRegex = new RegExp(`^(-?[\\\\d\\\\.]*)${v}(\\\\^([\\\\d\\\\.-]+))?$`);\r\n    let match = expr.match(potRegex);\r\n    if (match) {\r\n        let a = match[1]; let n = match[3]; if (a === \"\") a = \"1\"; if (a === \"-\") a = \"-1\"; if (n === undefined) n = \"1\";\r\n        const a_val = parseFloat(a); const n_val = parseFloat(n);\r\n        if (n_val === -1) {\r\n            const i_final = `${a_val === 1 ? '' : (a_val === -1 ? '-' : a_val)} \\\\cdot \\\\ln|${variable}|`;\r\n            addStep(\"Regra do Logaritmo (Int.)\", \"A integral de a/v é a*ln|v|.\", `\\\\int \\\\frac{a}{${v}} d${v} = a \\\\cdot \\\\ln|${v}|`, `\\\\int ${expr} d${v} = ${i_final}`);\r\n            return { integralStr: i_final };\r\n        }\r\n        const novo_n = n_val + 1; const novo_a = (a_val / novo_n); let i_final = \"\";\r\n        if (Number.isInteger(novo_a) && novo_a !== 0) {\r\n            let novo_a_str = novo_a; if (novo_a_str === 1 && novo_n !== 0) novo_a_str = \"\"; if (novo_a_str === -1 && novo_n !== 0) novo_a_str = \"-\";\r\n            if (novo_n === 1) { i_final = `${novo_a_str}${variable}`; } else if (novo_n === 0) { i_final = `${novo_a_str}`; } else { i_final = `${novo_a_str}${variable}^${novo_n}`; }\r\n        } else {\r\n            let num_str = (a_val === 1) ? \"\" : ( (a_val === -1) ? \"-\" : a_val );\r\n            if (num_str === 0) { i_final = \"0\"; }\r\n            else if (num_str === \"\") { \r\n                if (novo_n === 1) { i_final = `\\\\frac{${variable}}{${novo_n}}`; } else if (novo_n === 0) { i_final = `\\\\frac{1}{${novo_n}}`; } else { i_final = `\\\\frac{${variable}^${novo_n}}{${novo_n}}`; }\r\n            } else { \r\n                if (novo_n === 1) { i_final = `\\\\frac{${num_str}}{${novo_n}}${variable}`; } else if (novo_n === 0) { i_final = `\\\\frac{${num_str}}{${novo_n}}`; } else { i_final = `\\\\frac{${num_str}}{${novo_n}}${variable}^${novo_n}`; }\r\n            }\r\n        }\r\n        if(n_val === 0) { i_final = `${a_val}${variable}`; } if(a_val === 0) { i_final = \"0\"; }\r\n        addStep(\"Regra da Potência (Int.)\", \"Aplicando a regra da potência.\", `\\\\int a${v}^n d${v} = a \\\\frac{${v}^{n+1}}{n+1}`, `\\\\int ${expr} d${v} = ${i_final}`);\r\n        return { integralStr: i_final };\r\n    }\r\n    const logRegex = new RegExp(`^(-?[\\\\d\\\\.]*)\\\\/${v}$`);\r\n    match = expr.match(logRegex);\r\n    if (match) {\r\n            let a = match[1]; if (a === \"\") a = \"1\"; if (a === \"-\") a = \"-1\";\r\n            const i_final = `${a === '1' ? '' : (a === '-1' ? '-' : a)} \\\\cdot \\\\ln|${variable}|`;\r\n            addStep(\"Regra do Logaritmo (Int.)\", \"A integral de a/v é a*ln|v|.\", `\\\\int \\\\frac{a}{${v}} d${v} = a \\\\ln|${v}|`, `\\\\int ${expr} d${v} = ${i_final}`);\r\n            return { integralStr: i_final };\r\n    }\r\n    const potURegex = new RegExp(`^${v}(\\\\^([\\\\d\\\\.-]+))?$`);\r\n    match = expr.match(potURegex);\r\n        if (match) {\r\n            let n = match[2]; if (n === undefined) n = \"1\"; const n_val = parseFloat(n);\r\n            if(n_val === -1) {\r\n                const i_final = `\\\\ln|${variable}|`;\r\n                addStep(\"Regra do Logaritmo (Int.)\", \"A integral de 1/v é ln|v|.\", `\\\\int \\\\frac{1}{${v}} d${v} = \\\\ln|${v}|`, `\\\\int ${expr} d${v} = ${i_final}`);\r\n                return { integralStr: i_final };\r\n            }\r\n            const novo_n = n_val + 1; const i_final = `\\\\frac{${variable}^${novo_n}}{${novo_n}}`;\r\n            addStep( \"Regra da Potência (Int.)\", \"Aplicando a regra da potência para u.\", `\\\\int ${v}^n d${v} = \\\\frac{${v}^{n+1}}{n+1}`, `\\\\int ${expr} d${v} = ${i_final}`);\r\n            return { integralStr: i_final };\r\n        }\r\n    const funcRegex = new RegExp(`^\\\\\\\\?(sin|cos|exp)\\\\(${v}\\\\)$`); \r\n    match = expr.match(funcRegex);\r\n    if (match) {\r\n        const func = match[1]; let i_final = \"\"; let formula = \"\";\r\n        switch (func) {\r\n            case 'sin': i_final = `-\\\\cos(${variable})`; formula = `\\\\int \\\\sin(${v}) d${v} = -\\\\cos(${v})`; break;\r\n            case 'cos': i_final = `\\\\sin(${variable})`; formula = `\\\\int \\\\cos(${v}) d${v} = \\\\sin(${v})`; break;\r\n            case 'exp': i_final = `exp(${variable})`; formula = `\\\\int e^${v} d${v} = e^${v}`; break;\r\n        }\r\n        addStep(`Integral Imediata de ${func}(${v})`, \"Esta é uma integral conhecida.\", formula, `\\\\int ${expr} d${v} = ${i_final}`);\r\n        return { integralStr: i_final };\r\n    }\r\n    \r\n    if (expr.includes('*') || expr.includes('/')) {\r\n        const partsResult = tentarIntegrarPorPartes(expr, parentSteps);\r\n        if (partsResult) return partsResult;\r\n\r\n        addStep(\"Recurso Não Suportado\", `O termo $${toKaTeX(expr)}$ parece requerer <strong>Integração por Partes</strong> complexa ou simplificação algébrica.`, \"\", \"Esta versão suporta apenas integrais imediatas, substituição e integração por partes simples (polinômio x trig/exp).\", true);\r\n        return { integralStr: `\\\\text{[Complexo: } ${toKaTeX(expr)} \\\\text{]}` };\r\n    }\r\n\r\n    addStep(\"Erro (Int.)\", `Termo simples não reconhecido: ${expr}`, \"\", \"\", true);\r\n    return { integralStr: `[Erro em ${expr}]` };\r\n}\r\n\r\nfunction tentarIntegrarPorPartes(expr, parentSteps) {\r\n    // console.log(\"Tentando Integração por Partes em:\", expr);\r\n\r\n    const parts = expr.split('*');\r\n    if (parts.length !== 2) return null;\r\n    \r\n    let u_cand = parts[0].trim();\r\n    let dv_cand_raw = parts[1].trim();\r\n    let u = \"\", dv_raw = \"\";\r\n\r\n    const isPoly = (s) => /^(-?[\\d\\.]*)x(\\^[\\d\\.]+)?$/.test(s);\r\n    const isTrigExp = (s) => /^\\\\?(sin|cos|exp)\\(x\\)$/.test(s.replace(/\\\\/g, ''));\r\n\r\n    if (isPoly(u_cand) && isTrigExp(dv_cand_raw)) {\r\n        u = u_cand; dv_raw = dv_cand_raw;\r\n    } else if (isPoly(dv_cand_raw) && isTrigExp(u_cand)) {\r\n        u = dv_cand_raw; dv_raw = u_cand;\r\n    } else {\r\n        return null;\r\n    }\r\n    \r\n    parentSteps.addStep(\r\n        \"Integração por Partes\",\r\n        \"Identificamos um produto de polinômio por função transcendente.\",\r\n        \"\\\\int u \\\\cdot dv = u \\\\cdot v - \\\\int v \\\\cdot du\",\r\n        `\\\\text{Escolha (LIATE): } u = {${toKaTeX(u)}}, \\\\quad dv = {${toKaTeX(dv_raw)} dx}`\r\n    );\r\n\r\n    const du_res = derivar(u, 'leibniz');\r\n    const du = du_res.derivadaStr;\r\n    \r\n    const v_res = integrarTermoSimples(dv_raw.replace(/\\\\/g, ''), 'x', null);\r\n    const v = v_res.integralStr;\r\n    \r\n    const v_data = extrairCoeficiente(v);\r\n    const du_data = extrairCoeficiente(du);\r\n    \r\n    const coefTotal = v_data.coef * du_data.coef;\r\n    \r\n    let partsToJoin = [];\r\n    if (v_data.resto !== '1') partsToJoin.push(v_data.resto);\r\n    if (du_data.resto !== '1') partsToJoin.push(du_data.resto);\r\n    \r\n    let novaIntegralCore = partsToJoin.length > 0 ? partsToJoin.join(' * ') : '1';\r\n\r\n    let finalIntegralCore = novaIntegralCore;\r\n    if (finalIntegralCore.match(/^(\\\\?)(sin|cos|exp)\\(x\\) \\* [\\d\\.]+x/)) {\r\n        let p = finalIntegralCore.split('*');\r\n        finalIntegralCore = `${p[1].trim()} * ${p[0].trim()}`;\r\n    }\r\n    \r\n    let sinalStr = \"\";\r\n    let coefAbs = Math.abs(coefTotal);\r\n    \r\n    if (coefTotal < 0) {\r\n            sinalStr = \" + \";\r\n            if (Math.abs(coefTotal + 1) > 1e-9) sinalStr += `${coefAbs} * `;\r\n    } else {\r\n            sinalStr = \" - \";\r\n            if (Math.abs(coefTotal - 1) > 1e-9) sinalStr += `${coefTotal} * `;\r\n    }\r\n    \r\n    parentSteps.addStep(\r\n        \"Aplicação da Fórmula\",\r\n        \"Calculamos $du$ e $v$ e aplicamos a fórmula.\",\r\n        `du = {(${toKaTeX(du)}) dx}, \\\\quad v = {${toKaTeX(v)}}`,\r\n        `\\\\text{Parcial} = {${toKaTeX(u)}} \\\\cdot ({${toKaTeX(v)}}) - \\\\int ({${toKaTeX(v)}}) \\\\cdot ({${toKaTeX(du)}}) dx`\r\n    );\r\n\r\n    const nestedSteps = new StepsBuilder();\r\n    nestedSteps.isIntegral = true;\r\n\r\n    let recursaoStr = \"\";\r\n    if (!finalIntegralCore.includes('*')) {\r\n            const r = integrarTermoSimples(finalIntegralCore, 'x', nestedSteps);\r\n            recursaoStr = r.integralStr;\r\n    } else {\r\n            const r = analisarEIntegrarTermo(finalIntegralCore, nestedSteps);\r\n            recursaoStr = r.integralStr;\r\n    }\r\n\r\n    parentSteps.addNestedSteps(`Resolvendo a integral restante: $\\\\int ${toKaTeX(finalIntegralCore)} dx$`, nestedSteps);\r\n    \r\n    // --- MONTAGEM INTELIGENTE DO RESULTADO ---\r\n    let uv_final = \"\";\r\n    let u_clean = u.trim();\r\n    let v_clean = v.trim();\r\n    let globalSign = 1;\r\n    \r\n    if (u_clean.startsWith('-')) { globalSign *= -1; u_clean = u_clean.substring(1); }\r\n    if (v_clean.startsWith('-')) { globalSign *= -1; v_clean = v_clean.substring(1); }\r\n    \r\n    if (globalSign === -1) uv_final = `-${u_clean} * ${v_clean}`;\r\n    else uv_final = `${u_clean} * ${v_clean}`;\r\n\r\n    // --- DISTRIBUIÇÃO INTELIGENTE DA CONSTANTE ---\r\n    let recursao_final = recursaoStr;\r\n    \r\n    if (sinalStr.includes('*')) {\r\n        let matchSinal = sinalStr.match(/(\\d+(?:\\.\\d+)?)/);\r\n        if (matchSinal) {\r\n            let constVal = parseFloat(matchSinal[1]);\r\n            // Se o sinal era negativo (sinalStr começa com \" - \"), distribuimos -constVal?\r\n            // Na formula uv - int, o sinalStr já tem o sinal correto da operação.\r\n            if (sinalStr.trim().startsWith(\"-\")) {\r\n                constVal = -constVal;\r\n            }\r\n\r\n            let distributed = distribuirProduto(constVal, recursaoStr);\r\n            \r\n            if (distributed !== \"\" && !distributed.includes(\"undefined\")) {\r\n                recursao_final = distributed;\r\n                sinalStr = \"\"; \r\n            } else {\r\n                    if (recursaoStr.includes('+') || recursaoStr.includes('-')) {\r\n                    if (!recursaoStr.startsWith('(')) recursao_final = `(${recursaoStr})`;\r\n                }\r\n            }\r\n        }\r\n    } else {\r\n            if ((sinalStr.trim() === '-' || sinalStr.trim() === '+') && (recursaoStr.includes('+') || recursaoStr.includes('-'))) {\r\n                if (!recursaoStr.startsWith('(')) recursao_final = `(${recursaoStr})`;\r\n            }\r\n    }\r\n\r\n    let resultadoFinal = \"\";\r\n    if (sinalStr === \"\") {\r\n        if (!recursao_final.trim().startsWith(\"+\") && !recursao_final.trim().startsWith(\"-\")) {\r\n                resultadoFinal = `${uv_final} + ${recursao_final}`;\r\n        } else {\r\n                resultadoFinal = `${uv_final} ${recursao_final}`;\r\n        }\r\n    } else {\r\n        resultadoFinal = `${uv_final} ${sinalStr} ${recursao_final}`;\r\n    }\r\n    \r\n    resultadoFinal = simplifyExpression(resultadoFinal);\r\n\r\n    parentSteps.addStep(\r\n        \"Conclusão da Integração por Partes\",\r\n        \"Combinando e simplificando.\",\r\n        `\\\\text{Resultado} = {${toKaTeX(resultadoFinal)}}`\r\n    );\r\n\r\n    return { integralStr: resultadoFinal };\r\n}\r\n\r\nfunction getParts(s) {\r\n    s = s.replace(/\\s+/g, '').replace(/[()]/g, '');\r\n    if (s === \"\") return { k: 1, v: \"\" };\r\n    if (!isNaN(parseFloat(s)) && isFinite(s)) return { k: parseFloat(s), v: \"\" };\r\n    const partRegex = /^(-?[\\d\\.]+)?\\*?([a-z].*)$/i; const match = s.match(partRegex);\r\n    if (match) {\r\n        let k_str = match[1]; let v_str = match[2]; let k = 1;\r\n        if (k_str === \"-\") k = -1; else if (k_str !== \"\" && k_str !== undefined) k = parseFloat(k_str);\r\n        return { k: k, v: v_str };\r\n    }\r\n    if (s.match(/^[a-z]/i)) { return { k: 1, v: s }; }\r\n    return { k: 1, v: s };\r\n}\r\n\r\nfunction analisarTermo(termo) {\r\n    let match; let analiseBase = null;\r\n    const funcRegex = /\\\\?(sin|cos|tan|ln|exp|sqrt)\\(([^)]+)\\)/i; \r\n    const potRegex = /\\(([^)]+)\\)\\^([\\d\\.]+)$/i; \r\n    const expRegex = /(e|exp)\\^?\\(([^)]+)\\)/i;\r\n    \r\n    let funcCompleta = \"\"; let funcMatch = termo.match(funcRegex); let potMatch = termo.match(potRegex); let expMatch = termo.match(expRegex);\r\n    if (expMatch) {\r\n        const funcInterna = expMatch[2]; if(funcInterna !== 'x') { analiseBase = { u: funcInterna, f_u: `e^u`, f_u_raw: `exp(u)` }; funcCompleta = expMatch[0]; }\r\n    } else if (funcMatch) {\r\n            const funcExterna = funcMatch[1]; const funcInterna = funcMatch[2];\r\n            if (funcInterna !== 'x') { analiseBase = { u: funcInterna, f_u: `${toKaTeX(funcExterna)}(u)`, f_u_raw: `${funcExterna}(u)` }; funcCompleta = funcMatch[0]; }\r\n    } else if (potMatch) {\r\n            const funcInterna = potMatch[1]; const expoente = potMatch[2];\r\n            if(funcInterna !== 'x') { analiseBase = { u: funcInterna, f_u: `u^${expoente}`, f_u_raw: `u^${expoente}` }; funcCompleta = potMatch[0]; }\r\n    }\r\n    if (!analiseBase) { return { tipo: 'simples', original: termo }; }\r\n    let otherPart = termo.replace(funcCompleta, \"\").replace(\"()\", \"\").replace(/\\*$/, \"\").replace(/^\\*/, \"\"); \r\n    if (otherPart === \"\") otherPart = \"1\";\r\n    const { derivadaStr, stepsBuilder } = derivar(analiseBase.u, 'leibniz');\r\n    return { tipo: 'composto', original: termo, u: analiseBase.u, f_u: analiseBase.f_u, f_u_raw: analiseBase.f_u_raw, otherPart: otherPart, du_str: derivadaStr, du_steps: stepsBuilder };\r\n}\r\n\r\nfunction analisarEIntegrarTermo(termo, parentSteps) {\r\n    const analise = analisarTermo(termo);\r\n    if (analise.tipo === 'simples') { const { integralStr } = integrarTermoSimples(termo, 'x', parentSteps); return { integralStr }; }\r\n    parentSteps.addStep( \"Análise de Substituição (u-sub)\", \"Tentando aplicar a Regra da Substituição.\", `f(g(x)) = ${toKaTeX(analise.original)}`, `Função Externa: $f(u) = ${analise.f_u}$ \\\\\\\\ Função Interna: $u = ${toKaTeX(analise.u)}$ \\\\\\\\ Parte Restante: $${toKaTeX(analise.otherPart) || '1'}$` );\r\n    parentSteps.addNestedSteps(`Cálculo da Derivada Interna ($du/dx$):`, analise.du_steps);\r\n    const du_parts = getParts(analise.du_str); const other_parts = getParts(analise.otherPart);\r\n    let matchType = 'Inválida'; let k_str = \"\"; let k = 1; let formulaFinal = \"\"; let u_integral_steps = null; \r\n    if (du_parts.v === other_parts.v) { \r\n        if (other_parts.k === 0) { if(du_parts.k === 0) { matchType = 'Perfeita'; k = 1; } else { matchType = 'Inválida'; } } else {\r\n            k = du_parts.k / other_parts.k;\r\n            if (Math.abs(k - 1) < 1e-9) { matchType = 'Perfeita'; k = 1; formulaFinal = `\\\\int ${analise.f_u} du`; } else {\r\n                matchType = 'Constante'; let k_val = 1/k;\r\n                if (Math.abs(k_val + 1) < 1e-9) { k_str = \"-\"; } else if (Math.abs(k_val - 1) > 1e-9) { k_str = (k_val === 0.5) ? \"\\\\frac{1}{2}\" : ( (k_val === 0.25) ? \"\\\\frac{1}{4}\" : `${parseFloat(k_val.toPrecision(4))}` ); if(k_val < 0) k_str = `(${k_str})`; }\r\n                formulaFinal = `\\\\int ${k_str} ${analise.f_u} du`;\r\n            }\r\n        }\r\n    }\r\n    if (matchType === 'Perfeita' || matchType === 'Constante') {\r\n        u_integral_steps = new StepsBuilder();\r\n        const { integralStr: u_integral_result } = integrarTermoSimples(analise.f_u_raw, 'u', u_integral_steps);\r\n        let k_final_str = \"\"; let k_step_str = \"\";  \r\n        if (matchType === 'Constante') {\r\n            let k_val = (1/k);\r\n            if (Math.abs(k_val + 1) < 1e-9) { k_final_str = \"-\"; k_step_str = \"-\"; } else if (Math.abs(k_val - 1) > 1e-9) { k_step_str = k_str; k_final_str = k_str + \" \\\\cdot \"; }\r\n        }\r\n        const final_result_str = `${k_final_str}(${u_integral_result.replace(/u/g, `(${analise.u})`)})`;\r\n        parentSteps.addNestedSteps( `Passos da Integração em $u$: $${formulaFinal}$`, u_integral_steps );\r\n        parentSteps.addStep( \"Re-substituição\", \"Substituindo $u$ de volta para a expressão original.\", `u = ${toKaTeX(analise.u)}`, `${k_step_str.length > 0 ? k_step_str + \" \\\\cdot \" : \"\"}(${u_integral_result}) \\\\Rightarrow ${final_result_str}` );\r\n        return { integralStr: final_result_str };\r\n    } else { \r\n            const partsResult = tentarIntegrarPorPartes(termo, parentSteps);\r\n            if (partsResult) return partsResult;\r\n\r\n            parentSteps.addStep( \"Substituição Inválida\", `$du/dx$ ($${analise.du_str}$) não corresponde à \"parte restante\" ($${toKaTeX(analise.otherPart)}$).`, \"\", \"Não é possível aplicar a Regra da Substituição.\", true);\r\n            return { integralStr: `[Erro: ${termo}]` }; \r\n    }\r\n}\r\n\r\n// --- EXPORTAÇÃO ES MODULE ---\r\nexport {\r\n    derivar,\r\n    integrar,\r\n    StepsBuilder,\r\n    VERSION // Exportando a versão\r\n};"]}