papagaio 0.2.4 → 0.2.7

package/src/papagaio.js

@@ -1,305 +1,308 @@
-export class Papagaio {
-  maxRecursion = 512;
-  #counter = { value: 0, unique: 0 };
-  open = "{";
-  close = "}";
-  sigil = "$";
-  keywords = { pattern: "pattern", context: "context" };
-  content = "";
+// https://github.com/jardimdanificado/papagaio
 
-  constructor() {
-    this.#counter = { value: 0, unique: 0 };
-  }
-
-  process(input) {
-    this.content = input;
-    let src = input, last = null, iter = 0;
-    const pending = () => {
-      const rCtx = new RegExp(`\\b${this.keywords.context}\\s*\\${this.open}`, "g");
-      const rPat = new RegExp(`\\b${this.keywords.pattern}\\s*\\${this.open}`, "g");
-      return rCtx.test(src) || rPat.test(src);
-    };
-    while (src !== last && iter < this.maxRecursion) {
-      iter++;
-      last = src;
-      src = this.#processContext(src);
-      const [patterns, s2] = this.#collectPatterns(src);
-      src = this.#applyPatterns(s2, patterns);
-      if (!pending()) break;
+function processContext(papagaio, src) {
+  const ctxRe = new RegExp(`\\b${papagaio.symbols.context}\\s*\\${papagaio.symbols.open}`, "g");
+  let m, matches = [];
+  while ((m = ctxRe.exec(src)) !== null)
+    matches.push({ idx: m.index, pos: m.index + m[0].length - 1 });
+  for (let j = matches.length - 1; j >= 0; j--) {
+    const x = matches[j], [content, posAfter] = extractBlock(papagaio, src, x.pos);
+    if (!content.trim()) {
+      src = src.slice(0, x.idx) + src.slice(posAfter);
+      continue;
     }
-    return this.content = src, src;
+    const proc = papagaio.process(content);
+    let left = src.substring(0, x.idx), right = src.substring(posAfter);
+    let prefix = left.endsWith("\n") ? "\n" : "";
+    if (prefix) left = left.slice(0, -1);
+    src = left + prefix + proc + right;
   }
+  return src;
+}
 
-  #processContext(src) {
-    const ctxRe = new RegExp(`\\b${this.keywords.context}\\s*\\${this.open}`, "g");
-    let m, matches = [];
-    while ((m = ctxRe.exec(src)) !== null)
-      matches.push({ idx: m.index, pos: m.index + m[0].length - 1 });
-    for (let j = matches.length - 1; j >= 0; j--) {
-      const x = matches[j], [content, posAfter] = this.#extractBlock(src, x.pos);
-      if (!content.trim()) {
-        src = src.slice(0, x.idx) + src.slice(posAfter);
-        continue;
+function extractBlock(papagaio, src, openPos, openDelim = papagaio.symbols.open, closeDelim = papagaio.symbols.close) {
+  let i = openPos;
+  if (openDelim.length > 1 || closeDelim.length > 1) {
+    if (src.substring(i, i + openDelim.length) === openDelim) {
+      i += openDelim.length;
+      const innerStart = i;
+      let d = 0;
+      while (i < src.length) {
+        if (src.substring(i, i + openDelim.length) === openDelim) {
+          d++;
+          i += openDelim.length;
+        } else if (src.substring(i, i + closeDelim.length) === closeDelim) {
+          if (d === 0) return [src.substring(innerStart, i), i + closeDelim.length];
+          d--;
+          i += closeDelim.length;
+        } else i++;
       }
-      const proc = this.process(content);
-      let left = src.substring(0, x.idx), right = src.substring(posAfter);
-      let prefix = left.endsWith("\n") ? "\n" : "";
-      if (prefix) left = left.slice(0, -1);
-      src = left + prefix + proc + right;
+      return [src.substring(innerStart), src.length];
     }
-    return src;
   }
-
-  #extractBlock(src, openPos, openDelim = this.open, closeDelim = this.close) {
-    let i = openPos;
-    if (openDelim.length > 1 || closeDelim.length > 1) {
-      if (src.substring(i, i + openDelim.length) === openDelim) {
-        i += openDelim.length;
-        const innerStart = i;
-        let d = 0;
-        while (i < src.length) {
-          if (src.substring(i, i + openDelim.length) === openDelim) {
-            d++;
-            i += openDelim.length;
-          } else if (src.substring(i, i + closeDelim.length) === closeDelim) {
-            if (d === 0) return [src.substring(innerStart, i), i + closeDelim.length];
-            d--;
-            i += closeDelim.length;
-          } else i++;
-        }
-        return [src.substring(innerStart), src.length];
-      }
-    }
-    if (src[i] === openDelim) {
-      i++;
-      const innerStart = i;
-      if (openDelim === closeDelim) {
-        while (i < src.length && src[i] !== closeDelim) i++;
-        return [src.substring(innerStart, i), i + 1];
-      } else {
-        let depth = 1;
-        while (i < src.length && depth > 0) {
-          if (src[i] === openDelim) depth++;
-          else if (src[i] === closeDelim) depth--;
-          if (depth > 0) i++;
-        }
-        return [src.substring(innerStart, i), i + 1];
+  if (src[i] === openDelim) {
+    i++;
+    const innerStart = i;
+    if (openDelim === closeDelim) {
+      while (i < src.length && src[i] !== closeDelim) i++;
+      return [src.substring(innerStart, i), i + 1];
+    } else {
+      let depth = 1;
+      while (i < src.length && depth > 0) {
+        if (src[i] === openDelim) depth++;
+        else if (src[i] === closeDelim) depth--;
+        if (depth > 0) i++;
       }
+      return [src.substring(innerStart, i), i + 1];
     }
-    return ['', i];
   }
+  return ['', i];
+}
 
-  #parsePattern(pattern) {
-    const tokens = [];
-    let i = 0;
-    const S = this.sigil, S2 = S + S;
-    while (i < pattern.length) {
-      if (pattern.startsWith(S2, i)) {
-        tokens.push({ type: 'whitespace-optional' });
-        i += S2.length;
-        continue;
-      }
-      if (pattern.startsWith(S + 'block', i)) {
-        let j = i + S.length + 'block'.length;
+function parsePattern(papagaio, pattern) {
+  const tokens = [];
+  let i = 0;
+  const S = papagaio.symbols.sigil, S2 = S + S;
+  while (i < pattern.length) {
+    if (pattern.startsWith(S2, i)) {
+      tokens.push({ type: 'whitespace-optional' });
+      i += S2.length;
+      continue;
+    }
+    if (pattern.startsWith(S + 'block', i)) {
+      let j = i + S.length + 'block'.length;
+      while (j < pattern.length && /\s/.test(pattern[j])) j++;
+      let varName = '';
+      while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
+      if (varName) {
         while (j < pattern.length && /\s/.test(pattern[j])) j++;
-        let varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
-        if (varName) {
+        let openDelim = papagaio.symbols.open;
+        if (j < pattern.length && pattern[j] === papagaio.symbols.open) {
+          const [c, e] = extractBlock(papagaio, pattern, j);
+          openDelim = unescapeDelimiter(c.trim()) || papagaio.symbols.open;
+          j = e;
           while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          let openDelim = this.open;
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [c, e] = this.#extractBlock(pattern, j);
-            openDelim = this.#unescapeDelimiter(c.trim()) || this.open;
-            j = e;
-            while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          }
-          let closeDelim = this.close;
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [c, e] = this.#extractBlock(pattern, j);
-            closeDelim = this.#unescapeDelimiter(c.trim()) || this.close;
-            j = e;
-          }
-          tokens.push({ type: 'block', varName, openDelim, closeDelim });
-          i = j;
-          continue;
         }
-      }
-      if (pattern[i] === S) {
-        let j = i + S.length, varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
-        if (varName) {
-          tokens.push({ type: 'var', varName });
-          i = j;
-          continue;
+        let closeDelim = papagaio.symbols.close;
+        if (j < pattern.length && pattern[j] === papagaio.symbols.open) {
+          const [c, e] = extractBlock(papagaio, pattern, j);
+          closeDelim = unescapeDelimiter(c.trim()) || papagaio.symbols.close;
+          j = e;
         }
-        tokens.push({ type: 'literal', value: S });
-        i += S.length;
+        tokens.push({ type: 'block', varName, openDelim, closeDelim });
+        i = j;
         continue;
       }
-      if (/\s/.test(pattern[i])) {
-        let ws = '';
-        while (i < pattern.length && /\s/.test(pattern[i])) ws += pattern[i++];
-        tokens.push({ type: 'whitespace', value: ws });
+    }
+    if (pattern[i] === S) {
+      let j = i + S.length, varName = '';
+      while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
+      if (varName) {
+        tokens.push({ type: 'var', varName });
+        i = j;
         continue;
       }
-      let literal = '';
-      while (i < pattern.length && !pattern.startsWith(S, i) && !/\s/.test(pattern[i])) literal += pattern[i++];
-      if (literal) tokens.push({ type: 'literal', value: literal });
+      tokens.push({ type: 'literal', value: S });
+      i += S.length;
+      continue;
     }
-    return tokens;
+    if (/\s/.test(pattern[i])) {
+      let ws = '';
+      while (i < pattern.length && /\s/.test(pattern[i])) ws += pattern[i++];
+      tokens.push({ type: 'whitespace', value: ws });
+      continue;
+    }
+    let literal = '';
+    while (i < pattern.length && !pattern.startsWith(S, i) && !/\s/.test(pattern[i])) literal += pattern[i++];
+    if (literal) tokens.push({ type: 'literal', value: literal });
   }
+  return tokens;
+}
 
-  #matchPattern(src, tokens, startPos = 0) {
-    let pos = startPos;
-    const captures = {};
-    for (let ti = 0; ti < tokens.length; ti++) {
-      const token = tokens[ti];
-      if (token.type === 'whitespace-optional') {
-        while (pos < src.length && /\s/.test(src[pos])) pos++;
-        continue;
-      }
-      if (token.type === 'whitespace') {
-        if (pos >= src.length || !/\s/.test(src[pos])) return null;
-        while (pos < src.length && /\s/.test(src[pos])) pos++;
-        continue;
-      }
-      if (token.type === 'literal') {
-        if (!src.startsWith(token.value, pos)) return null;
-        pos += token.value.length;
-        continue;
-      }
-      if (token.type === 'var') {
-        const nextToken = ti + 1 < tokens.length ? tokens[ti + 1] : null;
-        let varValue = '';
-        if (nextToken) {
-          if (nextToken.type === 'whitespace' || nextToken.type === 'whitespace-optional') {
-            while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
-          } else if (nextToken.type === 'literal') {
-            const stopChar = nextToken.value[0];
-            while (pos < src.length && src[pos] !== stopChar && !/\s/.test(src[pos])) varValue += src[pos++];
-          } else if (nextToken.type === 'block') {
-            while (pos < src.length && !src.startsWith(nextToken.openDelim, pos) && !/\s/.test(src[pos])) varValue += src[pos++];
-          } else {
-            while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
-          }
+function matchPattern(papagaio, src, tokens, startPos = 0) {
+  let pos = startPos;
+  const captures = {};
+  for (let ti = 0; ti < tokens.length; ti++) {
+    const token = tokens[ti];
+    if (token.type === 'whitespace-optional') {
+      while (pos < src.length && /\s/.test(src[pos])) pos++;
+      continue;
+    }
+    if (token.type === 'whitespace') {
+      if (pos >= src.length || !/\s/.test(src[pos])) return null;
+      while (pos < src.length && /\s/.test(src[pos])) pos++;
+      continue;
+    }
+    if (token.type === 'literal') {
+      if (!src.startsWith(token.value, pos)) return null;
+      pos += token.value.length;
+      continue;
+    }
+    if (token.type === 'var') {
+      const nextToken = ti + 1 < tokens.length ? tokens[ti + 1] : null;
+      let varValue = '';
+      if (nextToken) {
+        if (nextToken.type === 'whitespace' || nextToken.type === 'whitespace-optional') {
+          while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
+        } else if (nextToken.type === 'literal') {
+          const stopChar = nextToken.value[0];
+          while (pos < src.length && src[pos] !== stopChar && !/\s/.test(src[pos])) varValue += src[pos++];
+        } else if (nextToken.type === 'block') {
+          while (pos < src.length && !src.startsWith(nextToken.openDelim, pos) && !/\s/.test(src[pos])) varValue += src[pos++];
         } else {
           while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
         }
-        if (!varValue) return null;
-        captures[this.sigil + token.varName] = varValue;
-        continue;
-      }
-      if (token.type === 'block') {
-        const { varName, openDelim, closeDelim } = token;
-        if (!src.startsWith(openDelim, pos)) return null;
-        const [blockContent, endPos] = this.#extractBlock(src, pos, openDelim, closeDelim);
-        captures[this.sigil + varName] = blockContent;
-        pos = endPos;
-        continue;
+      } else {
+        while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
       }
+      if (!varValue) return null;
+      captures[papagaio.symbols.sigil + token.varName] = varValue;
+      continue;
+    }
+    if (token.type === 'block') {
+      const { varName, openDelim, closeDelim } = token;
+      if (!src.startsWith(openDelim, pos)) return null;
+      const [blockContent, endPos] = extractBlock(papagaio, src, pos, openDelim, closeDelim);
+      captures[papagaio.symbols.sigil + varName] = blockContent;
+      pos = endPos;
+      continue;
     }
-    return { captures, endPos: pos };
   }
+  return { captures, endPos: pos };
+}
 
-  #collectPatterns(src) {
-    const patterns = [];
-    const patRe = new RegExp(`\\b${this.keywords.pattern}\\s*\\${this.open}`, "g");
-    let result = src;
-    while (true) {
-      patRe.lastIndex = 0;
-      const m = patRe.exec(result);
-      if (!m) break;
-      const start = m.index;
-      const openPos = m.index + m[0].length - 1;
-      const [matchPat, posAfterMatch] = this.#extractBlock(result, openPos);
-      let k = posAfterMatch;
-      while (k < result.length && /\s/.test(result[k])) k++;
-      if (k < result.length && result[k] === this.open) {
-        const [replacePat, posAfterReplace] = this.#extractBlock(result, k);
-        patterns.push({ match: matchPat.trim(), replace: replacePat.trim() });
-        result = result.slice(0, start) + result.slice(posAfterReplace);
-        continue;
-      }
-      result = result.slice(0, start) + result.slice(posAfterMatch);
+function collectPatterns(papagaio, src) {
+  const patterns = [];
+  const patRe = new RegExp(`\\b${papagaio.symbols.pattern}\\s*\\${papagaio.symbols.open}`, "g");
+  let result = src;
+  while (true) {
+    patRe.lastIndex = 0;
+    const m = patRe.exec(result);
+    if (!m) break;
+    const start = m.index;
+    const openPos = m.index + m[0].length - 1;
+    const [matchPat, posAfterMatch] = extractBlock(papagaio, result, openPos);
+    let k = posAfterMatch;
+    while (k < result.length && /\s/.test(result[k])) k++;
+    if (k < result.length && result[k] === papagaio.symbols.open) {
+      const [replacePat, posAfterReplace] = extractBlock(papagaio, result, k);
+      patterns.push({ match: matchPat.trim(), replace: replacePat.trim() });
+      result = result.slice(0, start) + result.slice(posAfterReplace);
+      continue;
     }
-    return [patterns, result];
+    result = result.slice(0, start) + result.slice(posAfterMatch);
   }
+  return [patterns, result];
+}
 
-  #applyPatterns(src, patterns) {
-    let clearFlag = false, lastResult = "", S = this.sigil;
-    for (const pat of patterns) {
-      const tokens = this.#parsePattern(pat.match);
-      let newSrc = '';
-      let pos = 0, matched = false;
-      while (pos < src.length) {
-        const matchResult = this.#matchPattern(src, tokens, pos);
-        if (matchResult) {
-          matched = true;
-          const { captures, endPos } = matchResult;
-          let result = pat.replace;
-          for (const [k, v] of Object.entries(captures)) {
-            const keyEsc = this.#escapeRegex(k);
-            result = result.replace(new RegExp(keyEsc + '(?![A-Za-z0-9_])', 'g'), v);
-          }
-          result = result.replace(new RegExp(`${this.#escapeRegex(S)}unique\\b`, 'g'), () => this.#genUnique());
-          result = result.replace(/\$eval\{([^}]*)\}/g, (_, code) => {
-            try {
-              const wrapped = `"use strict"; return (function() { ${code} })();`;
-              return String(Function("papagaio", "ctx", wrapped)(this, {}));
-            } catch {
-              return "";
-            }
-          });
-          const S2 = S + S;
-          result = result.replace(new RegExp(this.#escapeRegex(S2), 'g'), '');
-          if (new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g').test(result)) {
-            result = result.replace(new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g'), '');
-            clearFlag = true;
+function applyPatterns(papagaio, src, patterns) {
+  let clearFlag = false, lastResult = "", S = papagaio.symbols.sigil;
+  for (const pat of patterns) {
+    const tokens = parsePattern(papagaio, pat.match);
+    let newSrc = '';
+    let pos = 0, matched = false;
+    while (pos < src.length) {
+      const matchResult = matchPattern(papagaio, src, tokens, pos);
+      if (matchResult) {
+        matched = true;
+        const { captures, endPos } = matchResult;
+        let result = pat.replace;
+        for (const [k, v] of Object.entries(captures)) {
+          const keyEsc = escapeRegex(k);
+          result = result.replace(new RegExp(keyEsc + '(?![A-Za-z0-9_])', 'g'), v);
+        }
+        
+        const uniqueId = papagaio.unique_id++;
+        result = result.replace(new RegExp(`${escapeRegex(S)}unique\\b`, 'g'), () => String(uniqueId));
+        result = result.replace(/\$eval\{([^}]*)\}/g, (_, code) => {
+          try {
+            const wrapped = `"use strict"; return (function() { ${code} })();`;
+            return String(Function("papagaio", "ctx", wrapped)(papagaio, {}));
+          } catch {
+            return "";
           }
-          const matchStart = pos, matchEnd = endPos;
-          result = result
-            .replace(new RegExp(`${this.#escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, matchStart))
-            .replace(new RegExp(`${this.#escapeRegex(S)}suffix\\b`, 'g'), src.slice(matchEnd))
-            .replace(new RegExp(`${this.#escapeRegex(S)}match\\b`, 'g'), src.slice(matchStart, matchEnd));
-          newSrc += result;
-          lastResult = result;
-          pos = endPos;
-        } else {
-          newSrc += src[pos];
-          pos++;
+        });
+        const S2 = S + S;
+        result = result.replace(new RegExp(escapeRegex(S2), 'g'), '');
+        
+        if (new RegExp(`${escapeRegex(S)}clear\\b`, 'g').test(result)) {
+          result = result.replace(new RegExp(`${escapeRegex(S)}clear\\b\\s?`, 'g'), '');
+          clearFlag = true;
         }
-      }
-      if (matched) {
-        src = clearFlag ? lastResult : newSrc;
-        clearFlag = false;
+        
+        const matchStart = pos, matchEnd = endPos;
+        result = result
+          .replace(new RegExp(`${escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, matchStart))
+          .replace(new RegExp(`${escapeRegex(S)}suffix\\b`, 'g'), src.slice(matchEnd))
+          .replace(new RegExp(`${escapeRegex(S)}match\\b`, 'g'), src.slice(matchStart, matchEnd));
+        newSrc += result;
+        lastResult = result;
+        pos = endPos;
+      } else {
+        newSrc += src[pos];
+        pos++;
       }
     }
-    return src;
-  }
-
-  #genUnique() {
-    return "u" + (this.#counter.unique++).toString(36);
+    if (matched) {
+      src = clearFlag ? lastResult : newSrc;
+      clearFlag = false;
+    }
   }
+  return src;
+}
 
-  #escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
-  }
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
+}
 
-  #unescapeDelimiter(str) {
-    let result = '';
-    for (let i = 0; i < str.length; i++) {
-      if (str[i] === '\\' && i + 1 < str.length) {
-        const next = str[i + 1];
-        if (next === '"' || next === "'" || next === '\\') {
-          result += next;
-          i++;
-        } else {
-          result += str[i];
-        }
+function unescapeDelimiter(str) {
+  let result = '';
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === '\\' && i + 1 < str.length) {
+      const next = str[i + 1];
+      if (next === '"' || next === "'" || next === '\\') {
+        result += next;
+        i++;
       } else {
         result += str[i];
       }
+    } else {
+      result += str[i];
+    }
+  }
+  return result;
+}
+
+export class Papagaio {
+  constructor() {
+    this.recursion_limit = 512;
+    this.unique_id = 0;
+    this.symbols = {
+      pattern: "pattern",
+      context: "context",
+      open: "{",
+      close: "}",
+      sigil: "$"
+    };
+    this.content = "";
+  }
+
+  process(input) {
+    this.content = input;
+    let src = input, last = null, iter = 0;
+    const pending = () => {
+      const rCtx = new RegExp(`\\b${this.symbols.context}\\s*\\${this.symbols.open}`, "g");
+      const rPat = new RegExp(`\\b${this.symbols.pattern}\\s*\\${this.symbols.open}`, "g");
+      return rCtx.test(src) || rPat.test(src);
+    };
+    while (src !== last && iter < this.recursion_limit) {
+      iter++;
+      last = src;
+      src = processContext(this, src);
+      const [patterns, s2] = collectPatterns(this, src);
+      src = applyPatterns(this, s2, patterns);
+      if (!pending()) break;
     }
-    return result;
+    return this.content = src, src;
   }
 }

package/tests/test.js

@@ -20,8 +20,6 @@ const testsPath = path.join(__dirname, 'tests.json');
 const testsData = JSON.parse(fs.readFileSync(testsPath, 'utf-8'));
 const tests = testsData.tests;
 
-const p = new Papagaio();
-
 console.log(`${colors.cyan}[TEST] PAPAGAIO - TEST RUNNER${colors.reset}\n`);
 console.log('='.repeat(80));
 
@@ -30,22 +28,25 @@ let failed = 0;
 const failedTests = [];
 
 for (const test of tests) {
+  // Criar nova instância de Papagaio para cada teste
+  const p = new Papagaio();
+  
   try {
     const result = p.process(test.code).trim();
-    const success = result.includes(test.shouldContain);
+    const success = result.includes(test.expected);
     
     if (success) {
       console.log(`${colors.green}[PASS]${colors.reset} [${test.id}] ${test.name}`);
       passed++;
     } else {
       console.log(`${colors.red}[FAIL]${colors.reset} [${test.id}] ${test.name}`);
-      console.log(`       ${colors.yellow}Expected:${colors.reset} "${test.shouldContain}"`);
+      console.log(`       ${colors.yellow}Expected:${colors.reset} "${test.expected}"`);
       console.log(`       ${colors.yellow}Got:${colors.reset}      "${result.substring(0, 80)}${result.length > 80 ? '...' : ''}"`);
       failed++;
       failedTests.push({
         id: test.id,
         name: test.name,
-        expected: test.shouldContain,
+        expected: test.expected,
         got: result.substring(0, 150)
       });
     }
@@ -93,6 +94,7 @@ const report = {
 
 const reportPath = path.join(__dirname, 'test-report.json');
 fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+
 console.log(`\n${colors.cyan}[INFO]${colors.reset} Report saved at: ${reportPath}`);
 
 process.exit(failed > 0 ? 1 : 0);