papagaio 0.4.1 → 0.4.2

package/README.md

@@ -15,13 +15,13 @@ const result = p.process(input);
 ```javascript
 p.symbols = {
   pattern: "pattern",      // pattern keyword
-  context: "context",      // context keyword
   open: "{",               // opening delimiter
   close: "}",              // closing delimiter
   sigil: "$"               // variable marker
 };
-p.recursion_limit = 512;   // iteration limit
-p.unique_id = 0;           // unique ID counter
+
+p.recursion_limit = 512;
+p.unique_id = 0;
 ```
 
 ---
@@ -34,9 +34,8 @@ p.unique_id = 0;           // unique ID counter
 pattern {$x} {$x}
 hello
 ```
-Output: `hello`
 
-Variables capture words (non-whitespace sequences).
+Output: `hello`
 
 ### 2. Multiple Variables
 
@@ -44,8 +43,11 @@ Variables capture words (non-whitespace sequences).
 pattern {$x $y $z} {$z, $y, $x}
 apple banana cherry
 ```
+
 Output: `cherry, banana, apple`
 
+---
+
 ## Blocks
 
 Capture content between delimiters.
@@ -62,6 +64,7 @@ $block name {open}{close}
 pattern {$name $block content {(}{)}} {[$content]}
 data (hello world)
 ```
+
 Output: `[hello world]`
 
 ### Custom Delimiters
@@ -70,6 +73,7 @@ Output: `[hello world]`
 pattern {$block data {<<}{>>}} {DATA: $data}
 <<json stuff>>
 ```
+
 Output: `DATA: json stuff`
 
 ### Multiple Blocks
@@ -78,6 +82,7 @@ Output: `DATA: json stuff`
 pattern {$block a {(}{)}, $block b {[}{]}} {$a|$b}
 (first), [second]
 ```
+
 Output: `first|second`
 
 ---
@@ -90,15 +95,16 @@ Output: `first|second`
 pattern {match} {replace}
 ```
 
-### Real Example
+### Example
 
 ```
 pattern {# $title} {<h1>$title</h1>}
 # Welcome
 ```
+
 Output: `<h1>Welcome</h1>`
 
-### Multiple Patterns
+### Multiple Patterns Cascade
 
 ```
 pattern {a} {b}
@@ -106,246 +112,160 @@ pattern {b} {c}
 pattern {c} {d}
 a
 ```
-Output: `d` (automatic cascade)
+
+Output: `d`
 
 ---
 
-## Contexts
+# Subpatterns
+
+Subpatterns allow patterns to be declared *inside* other patterns, existing only during the execution of that parent pattern.
+
+### Syntax
+
+```
+$pattern {match} {replace}
+```
 
-Recursive processing scope.
+A subpattern behaves like a normal pattern but is **scoped only to the replacement body where it appears**.
+
+### Example
 
 ```
-context {
-  pattern {$x} {<$x>}
-  
-  apple
-  banana
+pattern {eval $block code {(}{)}} {
+  $eval{
+    $pattern {undefined} {}
+    $code;
+    return "";
+  }
 }
+
+eval(console.log(123))
 ```
+
 Output:
+
 ```
-<apple>
- <banana>
+123
 ```
 
-**Empty contexts are automatically removed.**
+### Key Properties
+
+* Subpatterns exist only within the running pattern.
+* They do not leak into the global pattern list.
+* They can recursively modify inner content before `$eval` or other processors handle it.
+* Multiple subpatterns can coexist inside the same replacement.
 
 ---
 
 ## Special Keywords
 
 ### $unique
-Generate unique incremental IDs for each pattern call. All occurrences of `$unique` within the same pattern replacement share the same ID.
+
+Generates unique incremental IDs.
 
 ```
 pattern {item} {[$unique]item_$unique}
 item
 item
-item
 ```
-Output: `[0]item_0`, `[1]item_1`, `[2]item_2`
+
+Outputs:
 
 ```
-pattern {a} {$unique $unique}
-a
+[0]item_0
+[1]item_1
 ```
-Output: `0 0` (same ID for both occurrences)
 
 ### $match
-Return the full match.
+
+Full matched text.
 
 ```
 pattern {[$x]} {FOUND: $match}
 [data]
 ```
+
 Output: `FOUND: [data]`
 
 ### $prefix / $suffix
-Text before and after the match.
+
+Text before and after match.
 
 ```
 pattern {world} {$prefix$suffix}hello world test
 ```
+
 Output: `hello hello  test test`
 
 ### $clear
-Remove everything before the match.
-
-```
-pattern {SKIP $x} {$clear KEEP: $x}
-IGNORE_THIS SKIP keep_this
-```
-Output: `KEEP: keep_this`
 
-### $eval
-Execute JavaScript code.
+Removes everything before match.
 
 ```
-pattern {$x} {$eval{return parseInt($x) * 2;}}
-5
-```
-Output: `10`
-
----
-
-## Practical Examples
-
-### Markdown → HTML
-
-```
-context {
-  pattern {## $t} {<h2>$t</h2>}
-  pattern {# $t} {<h1>$t</h1>}
-  pattern {**$t**} {<strong>$t</strong>}
-  pattern {*$t*} {<em>$t</em>}
-  pattern {- $i} {<li>$i</li>}
-  
-  # Title
-  **bold** and *italic*
-  - item1
-  - item2
-}
-```
-
-### CSV → JSON
-
-```
-pattern {$a,$b,$c} {{ id: '$a', name: '$b', role: '$c' }}
-1,Alice,Engineer
-2,Bob,Designer
-```
-
-Output:
-```
-{ id: '1', name: 'Alice', role: 'Engineer' }
-{ id: '2', name: 'Bob', role: 'Designer' }
+pattern {SKIP $x} {$clear KEEP: $x}
+IGNORE SKIP keep
 ```
 
-### Config Parser
+Output: `KEEP: keep`
 
-```
-pattern {$key = $value} {const $key = '$value';}
-host = localhost
-port = 3000
-```
-
-Output:
-```
-const host = 'localhost';
-const port = '3000';
-```
+### $eval
 
-### HTML Generator
+Executes JS.
 
 ```
-pattern {$tag $content} {<$tag>$content</$tag>}
-div HelloWorld
-span Test
+pattern {$x} {$eval{return parseInt($x)*2;}}
+5
 ```
 
-Output:
-```
-<div>HelloWorld</div>
-<span>Test</span>
-```
+Output: `10`
 
 ---
 
 ## Important Rules
 
 ### Matching
-- Variables (`$x`) capture **one word** (no spaces)
-- Variables (`$$x`) captures one or more words (with spaces)
-- Patterns apply **globally** each iteration
-- Auto-recursion until: max 512 iterations OR no changes
-- `$ `  = one or more of this whitespace (spaces, tabs, newlines)
-- `$$ ` = zero or more of this whitespace (spaces, tabs, newlines)
-- `$$$ `= one or more whitespaces
-- `$$$$ `= zero or more whitespaces
 
-### Block Matching
-- `$block name {open}{close}` captures between delimiters
-- Supports nested delimiters automatically
-- Multiple blocks in one pattern work
+* `$x` = one word
+* `$$x` = multiword (captures whitespace too)
+* `$`, `$$`, `$$$`, `$$$$` = whitespace operators
+* Patterns apply globally until stable
+* Blocks can be nested
 
-### Variables
-- Names: `[A-Za-z0-9_]`
-- Reuse: `$x` appears multiple times in replace
-- Undefined: becomes empty string
+### Block Matching
 
-### Limitations
-- You cannot match words containing the current sigil character.
-- You cannot match a $block{}{} using the current delimiters.
-- By design, whitespace operators need a whitespace after them to work properly, even the `$$$ ` and `$$$$ ` ones.
-- Multiple word variables (`$$x`) also captures leading/trailing whitespaces, so be careful when using them together with whitespace operators.
+* `$block name {open}{close}` captures delimited regions
+* Supports nested delimiters
 
 ---
 
 ## Troubleshooting
 
-| Problem | Solution |
-|---------|----------|
-| Variable not captured | Check space between variables |
-| Block not working | Verify balanced delimiters `{` `}` |
-| Infinite recursion | Use `$clear` or reduce `recursion_limit` |
-| $eval not working | Errors return empty string, use try-catch |
-| Pattern doesn't match | Use whitespace operators between elements for flexible whitespace |
-| Whitespace operators | Remember they need a whitespace after them to work properly |
-| Whitespace operators not matching | Multiple word variables (`$$x`) also captures leading/trailing whitespaces, so be careful when using them together with whitespace operators. |
+| Problem               | Solution                   |
+| --------------------- | -------------------------- |
+| Variable not captured | Check spacing              |
+| Block wrong           | Verify delimiters          |
+| Infinite recursion    | Reduce recursion limit     |
+| Pattern not matching  | Add whitespace operators   |
+| Multiword var issues  | Beware whitespace consumed |
+
+---
 
 ## Known Bugs
 
-- Multi-character block delimiters that contains double quotes doesnt match properly.
+* Multi-character delimiters containing `"` break nested parsing.
 
 ---
 
 ## Syntax Reference
 
 ```
-pattern {$x $y} {$y, $x}               # basic pattern
-pattern {$x$ $y} {$x-$y}               # flexible whitespace
-pattern {$block n {o}{c}} {$n}         # block
-context { ... }                        # recursive scope
-$unique                                # unique ID per pattern
-$match                                 # full match
-$prefix / $suffix                      # before/after
-$clear                                 # clear before
-$eval{code}                            # execute JS
-$ / $$ / $$$ / $$$$                    # whitespace operators
-```
-
----
-
-## Complete Example
-
-```
-context {
-  # Markdown headers
-  pattern {# $title} {<h1>$title</h1>}
-  
-  # Lists
-  pattern {- $item} {<li>$item</li>}
-  
-  # Inline formatting
-  pattern {**$text**} {<strong>$text</strong>}
-  pattern {*$text*} {<em>$text</em>}
-  
-  # Process content
-  # Welcome
-  # Getting Started
-  This is **important** and *italic*
-  - First item
-  - Second item
-}
-```
-
-Output:
-```html
-<h1>Welcome</h1>
-<h2>Getting Started</h2>
-This is <strong>important</strong> and <em>italic</em>
-<li>First item</li>
-<li>Second item</li>
+pattern {$x $y} {$y, $x}
+pattern {$block n {o}{c}} {$n}
+$pattern {a} {b}       # subpattern
+$unique
+$match
+$prefix / $suffix
+$clear
+$eval{code}
 ```
-
----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papagaio",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "easy yet powerful preprocessor",
   "main": "src/papagaio.js",
   "type": "module",

package/src/louro.js

@@ -0,0 +1,259 @@
+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 + S, i)) {
+      let j = i + S2.length + S.length, varName = '';
+      while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
+      if (varName) { tokens.push({ type: 'var-ws-optional', varName }); i = j; 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) { tokens.push({ type: 'var-ws', varName }); i = j; continue; }
+      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 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 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: '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; }
+      tokens.push({ type: 'literal', value: S }); i += S.length; continue;
+    }
+    if (/\s/.test(pattern[i])) {
+      while (i < pattern.length && /\s/.test(pattern[i])) i++;
+      tokens.push({ type: 'whitespace-optional' }); 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;
+}
+
+function matchPattern(papagaio, src, tokens, startPos = 0) {
+  let pos = startPos, 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 === 'literal') { if (!src.startsWith(token.value, pos)) return null; pos += token.value.length; continue; }
+    if (token.type === 'var') {
+      const nextToken = findNextSignificantToken(tokens, ti);
+      let v = '';
+      
+      // 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 {
+        while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
+      }
+      
+      if (!v) return null;
+      captures[papagaio.symbols.sigil + token.varName] = v;
+      continue;
+    }
+    if (token.type === 'var-ws' || token.type === 'var-ws-optional') {
+      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','var-ws-optional'].includes(n.type)) {
+        while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
+      } else if (n.type === 'literal') {
+        while (pos < src.length && !src.startsWith(n.value, pos) && src[pos] !== '\n') v += src[pos++];
+        v = v.trimEnd();
+      }
+      
+      if (token.type === 'var-ws' && !v) return null;
+      captures[papagaio.symbols.sigil + token.varName] = v;
+      continue;
+    }
+    if (token.type === 'block') {
+      const { varName, openDelim, closeDelim } = token;
+      if (!src.startsWith(openDelim, pos)) return null;
+      const [c, e] = extractBlock(papagaio, src, pos, openDelim, closeDelim);
+      captures[papagaio.symbols.sigil + varName] = c; pos = e; continue;
+    }
+  }
+  return { captures, endPos: pos };
+}
+
+function findNextSignificantToken(t, i) { for (let k = i + 1; k < t.length; k++) if (t[k].type !== 'whitespace-optional') return t[k]; return null; }
+
+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++; }
+    return [src.substring(s, i), i + 1];
+  }
+  return ['', i];
+}
+
+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;
+    }
+    out = out.slice(0, s) + out.slice(em);
+  }
+  return [A, out];
+}
+
+function extractNestedPatterns(p, replaceText) {
+  const nested = [];
+  const r = new RegExp(`\\${p.symbols.sigil}${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;
+    }
+    out = out.slice(0, s) + out.slice(em);
+  }
+  
+  return [nested, 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 escapeRegex(s) { return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&'); }
+
+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;
+}
+
+export class Papagaio {
+  constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern') {
+    this.recursion_limit = 512;
+    this.unique_id = 0;
+    this.symbols = { pattern: pattern, open: open, close: close, sigil: sigil };
+    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;
+    }
+    return this.content = src, src;
+  }
+}

package/src/papagaio.js

@@ -179,11 +179,22 @@ function matchPattern(papagaio, src, tokens, startPos = 0) {
     if (token.type === 'var') {
       let v = '';
       const nextToken = findNextSignificantToken(tokens, ti);
-      if (nextToken && nextToken.type === 'literal') {
-        while (pos < src.length && !src.startsWith(nextToken.value, pos) && !/\s/.test(src[pos])) v += src[pos++];
+      
+      // 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++];
+        while (pos < src.length && !/\s/.test(src[pos])) {
+          v += src[pos++];
+        }
       }
+      
       if (token.wsTrailing && token.wsTrailing !== 'optional') {
         const { newPos } = matchWhitespaceType(src, pos, token.wsTrailing);
         pos = newPos;
@@ -199,12 +210,24 @@ function matchPattern(papagaio, src, tokens, startPos = 0) {
       while (pos < src.length && /\s/.test(src[pos])) pos++;
       const n = findNextSignificantToken(tokens, ti);
       let v = '';
-      if (!n || ['var', 'var-ws', 'block'].includes(n.type)) {
-        while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
+      
+      // 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++];
+        }
       } else if (n.type === 'literal') {
-        while (pos < src.length && !src.startsWith(n.value, pos) && src[pos] !== '\n') v += src[pos++];
+        while (pos < src.length && !src.startsWith(n.value, pos) && src[pos] !== '\n') {
+          v += src[pos++];
+        }
         v = v.trimEnd();
       }
+      
       if (token.wsTrailing && token.wsTrailing !== 'optional') {
         const { newPos } = matchWhitespaceType(src, pos, token.wsTrailing);
         pos = newPos;

package/tests/test.js

@@ -33,7 +33,7 @@ for (const test of tests) {
   
   try {
     const result = p.process(test.code).trim();
-    const success = result.includes(test.expected);
+    const success = result === test.expected.trim();
     
     if (success) {
       console.log(`${colors.green}[PASS]${colors.reset} [${test.id}] ${test.name}`);

package/tests/tests.json

@@ -15,7 +15,7 @@
     {
       "id": 3,
       "name": "Block with delimiters ( )",
-      "code": "pattern {$block content {(}{)}} {[$content]}\ndata (hello world)",
+      "code": "pattern {$name $block content {(}{)}} {[$content]}\ndata (hello world)",
       "expected": "[hello world]"
     },
     {
@@ -57,7 +57,7 @@
     {
       "id": 10,
       "name": "Block with parentheses ( )",
-      "code": "pattern {$block params {(}{)}} {FUNC[$params]}\ncalcular(a, b, c)",
+      "code": "pattern {$nome$$ $block params {(}{)}} {FUNC[$params]}\ncalcular(a, b, c)",
       "expected": "FUNC[a, b, c]"
     },
     {
@@ -69,14 +69,14 @@
     {
       "id": 12,
       "name": "Nested block with multiple levels",
-      "code": "pattern {$block inner {<}{>}} {INNER{$inner}}\nouter <inner content here>",
+      "code": "pattern {$block inner {<}{>}} {INNER{$inner}}\n<inner content here>",
       "expected": "INNER{inner content here}"
     },
     {
       "id": 13,
       "name": "Pattern with flexible whitespace in middle",
       "code": "pattern {from to} {path: from -> to}\nfrom     to\nfrom  to\nfrom to",
-      "expected": "path: from -> to"
+      "expected": "path: from -> to\npath: from -> to\npath: from -> to"
     },
     {
       "id": 14,
@@ -135,7 +135,7 @@
     {
       "id": 23,
       "name": "Context with nested pattern",
-      "code": "context {\npattern {$x} {<$x>}\napple\nbanana\ncherry\n}",
+      "code": "context {pattern {$x} {<$x>} apple banana cherry}",
       "expected": "<apple>"
     },
     {