papagaio 0.4.2 → 0.5.2

package/src/papagaio.js

@@ -1,507 +1,265 @@
-// https://github.com/jardimdanificado/papagaio
-  
-function parsePattern(papagaio, pattern) {
-  const tokens = [], S = papagaio.symbols.sigil, S2 = S + S;
-  let i = 0;
-  const isWhitespaceChar = c => /\s/.test(c);
-  const getWhitespaceType = c => c === ' ' ? 'space' : c === '\t' ? 'tab' : c === '\n' ? 'newline' : c === '\r' ? 'carriage-return' : 'other';
-  while (i < pattern.length) {
-    if (pattern.startsWith(S + S + S, i) && i + 3 < pattern.length && isWhitespaceChar(pattern[i + 3])) {
-      tokens.push({ type: 'any-ws-required', wsChar: pattern[i + 3] });
-      i += 4;
-      continue;
-    }
-    if (pattern.startsWith(S + S + S + S, i) && i + 4 < pattern.length && isWhitespaceChar(pattern[i + 4])) {
-      tokens.push({ type: 'any-ws-optional', wsChar: pattern[i + 4] });
-      i += 5;
-      continue;
-    }
-    if (pattern.startsWith(S2, i)) {
-      let j = i + S2.length, varName = '';
-      while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
-      if (varName) {
-        if (j < pattern.length && isWhitespaceChar(pattern[j])) {
-          tokens.push({ type: 'var-ws', varName, wsTrailing: getWhitespaceType(pattern[j]), wsChar: pattern[j] });
-          i = j + 1;
-          continue;
-        } else if (j < pattern.length && pattern[j] === S) {
-          tokens.push({ type: 'var-ws', varName, wsTrailing: 'optional', wsChar: null });
-          i = j + 1;
-          continue;
-        } else {
-          tokens.push({ type: 'var-ws', varName });
-          i = j;
-          continue;
+function parsePattern(p, pat) {
+    const t = [], S = p.symbols.sigil, O = p.symbols.open;
+    let i = 0;
+    
+    while (i < pat.length) {
+        if (pat.startsWith(S + p.symbols.regex, i)) {
+            let j = i + S.length + p.symbols.regex.length;
+            while (j < pat.length && /\s/.test(pat[j])) j++;
+            let v = '';
+            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
+            if (v) {
+                while (j < pat.length && /\s/.test(pat[j])) j++;
+                if (pat[j] === O) {
+                    const [rx, e] = extractBlock(p, pat, j);
+                    t.push({ type: 'regex', varName: v, regex: rx.trim() });
+                    i = e; continue;
+                }
+            }
         }
-      }
-    }
-    if (pattern.startsWith(S2, i) && i + 2 < pattern.length && isWhitespaceChar(pattern[i + 2])) {
-      tokens.push({ type: 'ws-optional', wsType: getWhitespaceType(pattern[i + 2]), wsChar: pattern[i + 2] });
-      i += 3;
-      continue;
-    }
-    if (pattern.startsWith(S2, i)) {
-      tokens.push({ type: 'whitespace-optional' });
-      i += S2.length;
-      continue;
-    }
-    if (pattern[i] === S && i + 1 < pattern.length && isWhitespaceChar(pattern[i + 1])) {
-      tokens.push({ type: 'ws-required', wsType: getWhitespaceType(pattern[i + 1]), wsChar: pattern[i + 1] });
-      i += 2;
-      continue;
-    }
-    if (pattern.startsWith(S + 'block', i)) {
-      let j = i + S.length + 5;
-      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 openDelim = papagaio.symbols.open, closeDelim = papagaio.symbols.close;
-        let openDelimIsWs = false, closeDelimIsWs = false;
-        if (j < pattern.length && pattern[j] === papagaio.symbols.open) {
-          const [c, e] = extractBlock(papagaio, pattern, j);
-          const trimmed = c.trim();
-          if (trimmed === '') {
-            openDelimIsWs = true;
-            let wsStart = j + papagaio.symbols.open.length, wsEnd = wsStart;
-            while (wsEnd < pattern.length && pattern[wsEnd] !== papagaio.symbols.close) wsEnd++;
-            openDelim = pattern.substring(wsStart, wsEnd);
-          } else openDelim = unescapeDelimiter(trimmed) || papagaio.symbols.open;
-          j = e;
-          while (j < pattern.length && /\s/.test(pattern[j])) j++;
+        if (pat.startsWith(S + p.symbols.block, i)) {
+            let j = i + S.length + p.symbols.block.length;
+            while (j < pat.length && /\s/.test(pat[j])) j++;
+            let v = '';
+            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
+            if (v) {
+                while (j < pat.length && /\s/.test(pat[j])) j++;
+                let od = O, cd = p.symbols.close;
+                if (pat[j] === O) {
+                    const [c, e] = extractBlock(p, pat, j);
+                    od = unescapeDelim(c.trim()) || O;
+                    j = e; while (j < pat.length && /\s/.test(pat[j])) j++;
+                }
+                if (pat[j] === O) {
+                    const [c, e] = extractBlock(p, pat, j);
+                    cd = unescapeDelim(c.trim()) || cd;
+                    j = e;
+                }
+                t.push({ type: 'block', varName: v, open: od, close: cd }); 
+                i = j; continue;
+            }
         }
-        if (j < pattern.length && pattern[j] === papagaio.symbols.open) {
-          const [c, e] = extractBlock(papagaio, pattern, j);
-          const trimmed = c.trim();
-          if (trimmed === '') {
-            closeDelimIsWs = true;
-            let wsStart = j + papagaio.symbols.open.length, wsEnd = wsStart;
-            while (wsEnd < pattern.length && pattern[wsEnd] !== papagaio.symbols.close) wsEnd++;
-            closeDelim = pattern.substring(wsStart, wsEnd);
-          } else closeDelim = unescapeDelimiter(trimmed) || papagaio.symbols.close;
-          j = e;
+        if (pat[i] === S) {
+            let j = i + S.length, v = '';
+            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
+            if (v) { 
+                const optional = pat[j] === '?';
+                if (optional) j++;
+                t.push({ type: 'var', varName: v, optional }); 
+                i = j; 
+                continue; 
+            }
+            t.push({ type: 'lit', value: S }); i += S.length; continue;
         }
-        tokens.push({ type: 'block', varName, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs });
-        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) {
-        if (j < pattern.length && isWhitespaceChar(pattern[j])) {
-          tokens.push({ type: 'var', varName, wsTrailing: getWhitespaceType(pattern[j]), wsChar: pattern[j] });
-          i = j + 1;
-          continue;
-        } else if (j < pattern.length && pattern[j] === S) {
-          tokens.push({ type: 'var', varName, wsTrailing: 'optional', wsChar: null });
-          i = j + 1;
-          continue;
-        } else {
-          tokens.push({ type: 'var', varName });
-          i = j;
-          continue;
+        if (/\s/.test(pat[i])) {
+            while (i < pat.length && /\s/.test(pat[i])) i++;
+            t.push({ type: 'ws' }); continue;
         }
-      }
-    }
-    if (isWhitespaceChar(pattern[i])) {
-      let ws = '';
-      while (i < pattern.length && isWhitespaceChar(pattern[i])) ws += pattern[i++];
-      tokens.push({ type: 'literal-ws', value: ws });
-      continue;
+        let lit = '';
+        while (i < pat.length && pat[i] !== S && !/\s/.test(pat[i])) lit += pat[i++];
+        if (lit) t.push({ type: 'lit', value: lit });
     }
-    let literal = '';
-    while (i < pattern.length && !pattern.startsWith(S, i) && !isWhitespaceChar(pattern[i])) literal += pattern[i++];
-    if (literal) tokens.push({ type: 'literal', value: literal });
-  }
-  return tokens;
+    return t;
 }
 
-function matchPattern(papagaio, src, tokens, startPos = 0) {
-  let pos = startPos, captures = {};
-  const matchWhitespaceType = (str, idx, wsType) => {
-    if (idx >= str.length) return { matched: '', newPos: idx };
-    if (wsType === 'space' && str[idx] === ' ') {
-      let j = idx;
-      while (j < str.length && str[j] === ' ') j++;
-      return { matched: str.slice(idx, j), newPos: j };
-    }
-    if (wsType === 'tab' && str[idx] === '\t') {
-      let j = idx;
-      while (j < str.length && str[j] === '\t') j++;
-      return { matched: str.slice(idx, j), newPos: j };
-    }
-    if (wsType === 'newline' && str[idx] === '\n') {
-      let j = idx;
-      while (j < str.length && str[j] === '\n') j++;
-      return { matched: str.slice(idx, j), newPos: j };
-    }
-    return { matched: '', newPos: idx };
-  };
-  for (let ti = 0; ti < tokens.length; ti++) {
-    const token = tokens[ti];
-    if (token.type === 'literal-ws') {
-      if (!src.startsWith(token.value, pos)) return null;
-      pos += token.value.length;
-      continue;
-    }
-    if (token.type === 'ws-required') {
-      const { matched, newPos } = matchWhitespaceType(src, pos, token.wsType);
-      if (!matched) return null;
-      pos = newPos;
-      continue;
-    }
-    if (token.type === 'ws-optional') {
-      const { newPos } = matchWhitespaceType(src, pos, token.wsType);
-      pos = newPos;
-      continue;
-    }
-    if (token.type === 'any-ws-required') {
-      if (pos >= src.length || !/\s/.test(src[pos])) return null;
-      while (pos < src.length && /\s/.test(src[pos])) pos++;
-      continue;
-    }
-    if (token.type === 'any-ws-optional') {
-      while (pos < src.length && /\s/.test(src[pos])) pos++;
-      continue;
-    }
-    if (token.type === 'whitespace-optional') {
-      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') {
-      let v = '';
-      const nextToken = findNextSignificantToken(tokens, ti);
-      
-      // Se o próximo token é um block, captura até o delimitador de abertura
-      if (nextToken && nextToken.type === 'block') {
-        while (pos < src.length && !src.startsWith(nextToken.openDelim, pos) && !/\s/.test(src[pos])) {
-          v += src[pos++];
-        }
-      } else if (nextToken && nextToken.type === 'literal') {
-        while (pos < src.length && !src.startsWith(nextToken.value, pos) && !/\s/.test(src[pos])) {
-          v += src[pos++];
-        }
-      } else {
-        while (pos < src.length && !/\s/.test(src[pos])) {
-          v += src[pos++];
+function matchPattern(p, src, tokens, pos = 0) {
+    let cap = {};
+    for (let ti = 0; ti < tokens.length; ti++) {
+        const tok = tokens[ti];
+        if (tok.type === 'ws') { while (pos < src.length && /\s/.test(src[pos])) pos++; continue; }
+        if (tok.type === 'lit') { if (!src.startsWith(tok.value, pos)) return null; pos += tok.value.length; continue; }
+        if (tok.type === 'regex') {
+            try {
+                let regex = p._regexCache.get(tok.regex);
+                if (!regex) {
+                    regex = new RegExp(tok.regex);
+                    p._regexCache.set(tok.regex, regex);
+                }
+                const m = src.slice(pos).match(regex);
+                if (!m || m.index !== 0) return null;
+                cap[p.symbols.sigil + tok.varName] = m[0];
+                pos += m[0].length;
+            } catch { return null; }
+            continue;
         }
-      }
-      
-      if (token.wsTrailing && token.wsTrailing !== 'optional') {
-        const { newPos } = matchWhitespaceType(src, pos, token.wsTrailing);
-        pos = newPos;
-      } else if (token.wsTrailing === 'optional') {
-        const { newPos } = matchWhitespaceType(src, pos, 'space');
-        pos = newPos;
-      }
-      if (!v) return null;
-      captures[papagaio.symbols.sigil + token.varName] = v;
-      continue;
-    }
-    if (token.type === 'var-ws') {
-      while (pos < src.length && /\s/.test(src[pos])) pos++;
-      const n = findNextSignificantToken(tokens, ti);
-      let v = '';
-      
-      // Se o próximo token é um block, captura até o delimitador de abertura
-      if (n && n.type === 'block') {
-        while (pos < src.length && !src.startsWith(n.openDelim, pos) && src[pos] !== '\n') {
-          v += src[pos++];
-        }
-        v = v.trimEnd();
-      } else if (!n || ['var', 'var-ws'].includes(n.type)) {
-        while (pos < src.length && !/\s/.test(src[pos])) {
-          v += src[pos++];
+        if (tok.type === 'var') {
+            while (pos < src.length && /\s/.test(src[pos])) pos++;
+            const nx = findNext(tokens, ti);
+            let v = '';
+            if (nx?.type === 'block') {
+                while (pos < src.length && !src.startsWith(nx.open, pos) && src[pos] !== '\n') v += src[pos++];
+                v = v.trimEnd();
+            } else if (nx?.type === 'lit') {
+                while (pos < src.length && !src.startsWith(nx.value, pos) && src[pos] !== '\n') v += src[pos++];
+                v = v.trimEnd();
+            } else {
+                while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
+            }
+            if (!v && !tok.optional) return null;
+            cap[p.symbols.sigil + tok.varName] = v;
+            continue;
         }
-      } else if (n.type === 'literal') {
-        while (pos < src.length && !src.startsWith(n.value, pos) && src[pos] !== '\n') {
-          v += src[pos++];
+        if (tok.type === 'block') {
+            if (!src.startsWith(tok.open, pos)) return null;
+            const [c, e] = extractBlock(p, src, pos, tok.open, tok.close);
+            cap[p.symbols.sigil + tok.varName] = c; pos = e; continue;
         }
-        v = v.trimEnd();
-      }
-      
-      if (token.wsTrailing && token.wsTrailing !== 'optional') {
-        const { newPos } = matchWhitespaceType(src, pos, token.wsTrailing);
-        pos = newPos;
-      } else if (token.wsTrailing === 'optional') {
-        const { newPos } = matchWhitespaceType(src, pos, 'space');
-        pos = newPos;
-      }
-      if (!v) return null;
-      captures[papagaio.symbols.sigil + token.varName] = v;
-      continue;
-    }
-    if (token.type === 'block') {
-      const { varName, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs } = token;
-      if (!src.startsWith(openDelim, pos)) return null;
-      const [c, e] = extractBlockWithWsDelimiter(papagaio, src, pos, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs);
-      captures[papagaio.symbols.sigil + varName] = c;
-      pos = e;
-      continue;
     }
-  }
-  return { captures, endPos: pos };
+    return { captures: cap, endPos: pos };
 }
 
-function findNextSignificantToken(t, i) {
-  for (let k = i + 1; k < t.length; k++) {
-    if (!['whitespace-optional', 'ws-optional', 'ws-required', 'any-ws-optional', 'any-ws-required'].includes(t[k].type)) return t[k];
-  }
-  return null;
-}
+function findNext(t, i) { for (let k = i + 1; k < t.length; k++) if (t[k].type !== 'ws') return t[k]; return null; }
 
-function extractBlockWithWsDelimiter(p, src, openPos, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs) {
-  let i = openPos;
-  if (openDelimIsWs || closeDelimIsWs) {
-    if (src.substring(i, i + openDelim.length) === openDelim) {
-      i += openDelim.length;
-      const s = 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) return [src.substring(s, i), i + closeDelim.length];
-          d--;
-          i += closeDelim.length;
-        } else i++;
-      }
-      return [src.substring(s), src.length];
-    }
-    return ['', i];
-  }
-  if (openDelim.length > 1 || closeDelim.length > 1) {
-    if (src.substring(i, i + openDelim.length) === openDelim) {
-      i += openDelim.length;
-      const s = 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) return [src.substring(s, i), i + closeDelim.length];
-          d--;
-          i += closeDelim.length;
-        } else i++;
-      }
-      return [src.substring(s), src.length];
-    }
-  }
-  if (src[i] === openDelim) {
-    i++;
-    const s = i;
-    if (openDelim === closeDelim) {
-      while (i < src.length && src[i] !== closeDelim) i++;
-      return [src.substring(s, i), i + 1];
+function extractBlock(p, src, i, od = p.symbols.open, cd = p.symbols.close) {
+    if (od.length > 1 || cd.length > 1) {
+        if (src.substring(i, i + od.length) === od) {
+            i += od.length; const s = i; let d = 0;
+            while (i < src.length) {
+                if (src.substring(i, i + od.length) === od) { d++; i += od.length; }
+                else if (src.substring(i, i + cd.length) === cd) {
+                    if (!d) return [src.substring(s, i), i + cd.length];
+                    d--; i += cd.length;
+                } else i++;
+            }
+            return [src.substring(s), src.length];
+        }
     }
-    let d = 1;
-    while (i < src.length && d > 0) {
-      if (src[i] === openDelim) d++;
-      else if (src[i] === closeDelim) d--;
-      if (d > 0) i++;
+    if (src[i] === od) {
+        i++; const s = i;
+        if (od === cd) { while (i < src.length && src[i] !== cd) i++; return [src.substring(s, i), i + 1]; }
+        let d = 1;
+        while (i < src.length && d > 0) { if (src[i] === od) d++; else if (src[i] === cd) d--; if (d > 0) i++; }
+        return [src.substring(s, i), i + 1];
     }
-    return [src.substring(s, i), i + 1];
-  }
-  return ['', i];
+    return ['', i];
 }
 
-function extractBlock(p, src, openPos, openDelim = p.symbols.open, closeDelim = p.symbols.close) {
-  let i = openPos;
-  if (openDelim.length > 1 || closeDelim.length > 1) {
-    if (src.substring(i, i + openDelim.length) === openDelim) {
-      i += openDelim.length;
-      const s = 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) return [src.substring(s, i), i + closeDelim.length];
-          d--;
-          i += closeDelim.length;
-        } else i++;
-      }
-      return [src.substring(s), src.length];
-    }
-  }
-  if (src[i] === openDelim) {
-    i++;
-    const s = i;
-    if (openDelim === closeDelim) {
-      while (i < src.length && src[i] !== closeDelim) i++;
-      return [src.substring(s, i), i + 1];
-    }
-    let d = 1;
-    while (i < src.length && d > 0) {
-      if (src[i] === openDelim) d++;
-      else if (src[i] === closeDelim) d--;
-      if (d > 0) i++;
+function collectPats(p, src) {
+    const arr = [];
+    const rx = new RegExp(`(?:^|\\b)${esc(p.symbols.pattern)}\\s*${esc(p.symbols.open)}`, "g");
+    let out = src;
+    while (1) {
+        rx.lastIndex = 0; const m = rx.exec(out); if (!m) break;
+        const s = m.index, o = m.index + m[0].length - p.symbols.open.length;
+        const [mp, em] = extractBlock(p, out, o); let k = em;
+        while (k < out.length && /\s/.test(out[k])) k++;
+        if (k < out.length && out.substring(k, k + p.symbols.open.length) === p.symbols.open) {
+            const [rp, er] = extractBlock(p, out, k);
+            arr.push({ m: mp.trim(), r: rp.trim() });
+            out = out.slice(0, s) + out.slice(er); continue;
+        }
+        out = out.slice(0, s) + out.slice(em);
     }
-    return [src.substring(s, i), i + 1];
-  }
-  return ['', i];
+    return [arr, out];
 }
 
-function collectPatterns(p, src) {
-  const A = [], r = new RegExp(`\\b${p.symbols.pattern}\\s*\\${p.symbols.open}`, "g");
-  let out = src;
-  while (1) {
-    r.lastIndex = 0;
-    const m = r.exec(out);
-    if (!m) break;
-    const s = m.index, o = m.index + m[0].length - 1;
-    const [mp, em] = extractBlock(p, out, o);
-    let k = em;
-    while (k < out.length && /\s/.test(out[k])) k++;
-    if (k < out.length && out[k] === p.symbols.open) {
-      const [rp, er] = extractBlock(p, out, k);
-      A.push({ match: mp.trim(), replace: rp.trim() });
-      out = out.slice(0, s) + out.slice(er);
-      continue;
+function extractNested(p, txt) {
+    const n = [];
+    const rx = new RegExp(`${esc(p.symbols.sigil)}${esc(p.symbols.pattern)}\\s*${esc(p.symbols.open)}`, "g");
+    let out = txt;
+    while (1) {
+        rx.lastIndex = 0; const m = rx.exec(out); if (!m) break;
+        const s = m.index, o = m.index + m[0].length - p.symbols.open.length;
+        const [mp, em] = extractBlock(p, out, o); let k = em;
+        while (k < out.length && /\s/.test(out[k])) k++;
+        if (k < out.length && out.substring(k, k + p.symbols.open.length) === p.symbols.open) {
+            const [rp, er] = extractBlock(p, out, k);
+            n.push({ m: mp.trim(), r: rp.trim() });
+            out = out.slice(0, s) + out.slice(er); continue;
+        }
+        out = out.slice(0, s) + out.slice(em);
     }
-    out = out.slice(0, s) + out.slice(em);
-  }
-  return [A, out];
+    return [n, out];
 }
 
-function extractNestedPatterns(p, replaceText) {
-  const nested = [];
-  const r = new RegExp(`\\${p.symbols.sigil}${escapeRegex(p.symbols.pattern)}\\s*\\${p.symbols.open}`, "g");
-  let out = replaceText;
-  
-  while (1) {
-    r.lastIndex = 0;
-    const m = r.exec(out);
-    if (!m) break;
-    
-    const s = m.index, o = m.index + m[0].length - 1;
-    const [mp, em] = extractBlock(p, out, o);
-    let k = em;
-    
-    while (k < out.length && /\s/.test(out[k])) k++;
-    
-    if (k < out.length && out[k] === p.symbols.open) {
-      const [rp, er] = extractBlock(p, out, k);
-      nested.push({ match: mp.trim(), replace: rp.trim() });
-      out = out.slice(0, s) + out.slice(er);
-      continue;
+function extractEvals(p, txt) {
+    const ev = [], S = p.symbols.sigil, O = p.symbols.open;
+    let i = 0, out = txt, off = 0;
+    while (i < txt.length) {
+        if (txt.substring(i, i + S.length) === S && txt.substring(i + S.length, i + S.length + p.symbols.eval.length) === p.symbols.eval) {
+            let j = i + S.length + p.symbols.eval.length;
+            while (j < txt.length && /\s/.test(txt[j])) j++;
+            if (j < txt.length && txt.substring(j, j + O.length) === O) {
+                const sp = i, bp = j;
+                const [c, ep] = extractBlock(p, txt, bp);
+                ev.push({ code: c, sp: sp - off, ep: ep - off });
+                const ph = `__E${ev.length - 1}__`;
+                out = out.substring(0, sp - off) + ph + out.substring(ep - off);
+                off += (ep - sp) - ph.length; i = ep; continue;
+            }
+        }
+        i++;
     }
-    out = out.slice(0, s) + out.slice(em);
-  }
-  
-  return [nested, out];
+    return [ev, out];
 }
 
-function applyPatterns(p, src, pats) {
-  let clear = false, last = "", S = p.symbols.sigil;
-  for (const pat of pats) {
-    const t = parsePattern(p, pat.match);
-    let n = '', pos = 0, ok = false;
-    while (pos < src.length) {
-      const m = matchPattern(p, src, t, pos);
-      if (m) {
-        ok = true;
-        const { captures, endPos } = m;
-        let r = pat.replace;
-        
-        // Extrai e processa padrões aninhados ($pattern)
-        const [nestedPats, cleanReplace] = extractNestedPatterns(p, r);
-        r = cleanReplace;
-        
-        for (const [k, v] of Object.entries(captures)) {
-          const e = escapeRegex(k);
-          r = r.replace(new RegExp(e + '(?![A-Za-z0-9_])', 'g'), v);
-        }
-        
-        // Aplica padrões aninhados ao resultado
-        if (nestedPats.length > 0) {
-          r = applyPatterns(p, r, nestedPats);
-        }
-        
-        const uid = p.unique_id++;
-        r = r.replace(new RegExp(`${escapeRegex(S)}unique\\b`, 'g'), () => String(uid));
-        r = r.replace(/\$eval\{([^}]*)\}/g, (_, c) => {
-          try {
-            return String(Function("papagaio", "ctx", `"use strict";return(function(){${c}})();`)(p, {}));
-          } catch {
-            return "";
-          }
-        });
-        r = r.replace(new RegExp(escapeRegex(S + S), 'g'), '');
-        if (new RegExp(`${escapeRegex(S)}clear\\b`, 'g').test(r)) {
-          r = r.replace(new RegExp(`${escapeRegex(S)}clear\\b\\s?`, 'g'), '');
-          clear = true;
-        }
-        const ms = pos, me = endPos;
-        r = r.replace(new RegExp(`${escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, ms))
-          .replace(new RegExp(`${escapeRegex(S)}suffix\\b`, 'g'), src.slice(me))
-          .replace(new RegExp(`${escapeRegex(S)}match\\b`, 'g'), src.slice(ms, me));
-        n += r;
-        last = r;
-        pos = endPos;
-      } else {
-        n += src[pos];
-        pos++;
-      }
-    }
-    if (ok) {
-      src = clear ? last : n;
-      clear = false;
-    }
-  }
-  return src;
+function applyEvals(p, txt, ev) {
+    let r = txt;
+    for (let i = ev.length - 1; i >= 0; i--) {
+        const ph = `__E${i}__`;
+        let res;
+        try { res = String(Function("papagaio", "ctx", `"use strict";return(function(){${ev[i].code}})();`)(p, {})); }
+        catch (e) { res = "error: " + e.message; }
+        r = r.replace(ph, res);
+    }
+    return r;
 }
 
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
+function applyPats(p, src, pats) {
+    let last = "", S = p.symbols.sigil;
+    for (const pat of pats) {
+        const tok = parsePattern(p, pat.m); 
+        let n = '', pos = 0, ok = false;
+        while (pos < src.length) {
+            const m = matchPattern(p, src, tok, pos);
+            if (m) {
+                ok = true; 
+                let r = pat.r;
+                const [nested, clean] = extractNested(p, r);
+                r = clean;
+                for (const [k, v] of Object.entries(m.captures)) {
+                    r = r.replace(new RegExp(esc(k) + '(?![A-Za-z0-9_])', 'g'), v);
+                }
+                if (nested.length) r = applyPats(p, r, nested);
+                p.match = src.slice(pos, m.endPos);
+                const [ev, ct] = extractEvals(p, r);
+                if (ev.length) r = applyEvals(p, ct, ev);
+                n += r; last = r; pos = m.endPos;
+            } else { n += src[pos]; pos++; }
+        }
+        if (ok) src = n;
+    }
+    return src;
 }
 
-function unescapeDelimiter(s) {
-  let r = '';
-  for (let i = 0; i < s.length; i++) {
-    if (s[i] === '\\' && i + 1 < s.length) {
-      const n = s[i + 1];
-      if (n === '"' || n === "'" || n === '\\') {
-        r += n;
-        i++;
-      } else r += s[i];
-    } else r += s[i];
-  }
-  return r;
+function esc(s) { return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&'); }
+function unescapeDelim(s) {
+    let r = ''; 
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '\\' && i + 1 < s.length && (s[i+1] === '"' || s[i+1] === "'" || s[i+1] === '\\')) { r += s[i+1]; i++; }
+        else r += s[i];
+    }
+    return r;
 }
 
 export class Papagaio {
-  constructor(sigil = "$", open = "{", close = "}", pattern = "pattern") {
-    this.recursion_limit = 512;
-    this.unique_id = 0;
-    this.symbols = { sigil: sigil, open: open, close: close, pattern: pattern};
-    this.content = "";
-  }
-  process(input) {
-    this.content = input;
-    let src = input, last = null, it = 0;
-    const pend = () => {
-      const r2 = new RegExp(`\\b${this.symbols.pattern}\\s*\\${this.symbols.open}`, "g");
-      return r2.test(src);
-    };
-    while (src !== last && it < this.recursion_limit) {
-      it++;
-      last = src;
-      const [p, s2] = collectPatterns(this, src);
-      src = applyPatterns(this, s2, p);
-      if (!pend()) break;
+    constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKeyword = 'eval', blockKeyword = 'block', regexKeyword = 'regex') {
+        this.recursion_limit = 512;
+        this.symbols = { pattern, open, close, sigil, eval: evalKeyword, block: blockKeyword, regex: regexKeyword };
+        this.content = "";
+        this.match = "";
+        this._regexCache = new Map();
+    }
+    process(input) {
+        this.content = input; 
+        let src = input, last = null, it = 0;
+        const pending = () => new RegExp(`(?:^|\\b)${esc(this.symbols.pattern)}\\s*${esc(this.symbols.open)}`, "g").test(src);
+        while (src !== last && it < this.recursion_limit) {
+            it++; last = src;
+            const [p, s2] = collectPats(this, src); 
+            src = applyPats(this, s2, p);
+            if (!pending()) break;
+        }
+        return this.content = src, src;
     }
-    return this.content = src, src;
-  }
 }