papagaio 0.2.7 → 0.3.1

package/README.md

@@ -46,17 +46,6 @@ apple banana cherry
 ```
 Output: `cherry, banana, apple`
 
-### 3. Flexible Whitespace (`$$`)
-
-```
-pattern {$x$$and$$$y} {$x & $y}
-hello   and   world
-hello and world
-```
-Output: `hello & world` (both)
-
-`$$` = zero or more spaces/tabs/newlines.
-
 ## Blocks
 
 Capture content between delimiters.
@@ -136,7 +125,7 @@ context {
 Output:
 ```
 <apple>
-<banana>
+ <banana>
 ```
 
 **Empty contexts are automatically removed.**
@@ -266,9 +255,13 @@ Output:
 
 ### Matching
 - Variables (`$x`) capture **one word** (no spaces)
-- `$$` = flexible whitespace (0+ spaces/tabs/newlines)
+- 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
@@ -280,8 +273,11 @@ Output:
 - Reuse: `$x` appears multiple times in replace
 - Undefined: becomes empty string
 
-### Sigil
-- You cannot match words containing the sigil character.
+### 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.
 
 ---
 
@@ -289,11 +285,13 @@ Output:
 
 | Problem | Solution |
 |---------|----------|
-| Pattern doesn't match | Use `$$` between elements for flexible whitespace |
 | 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. |
 
 ## Known Bugs
 
@@ -305,7 +303,7 @@ Output:
 
 ```
 pattern {$x $y} {$y, $x}               # basic pattern
-pattern {$x$$y} {$x-$y}                # flexible whitespace
+pattern {$x$ $y} {$x-$y}               # flexible whitespace
 pattern {$block n {o}{c}} {$n}         # block
 context { ... }                        # recursive scope
 $unique                                # unique ID per pattern
@@ -313,6 +311,7 @@ $match                                 # full match
 $prefix / $suffix                      # before/after
 $clear                                 # clear before
 $eval{code}                            # execute JS
+$ / $$ / $$$ / $$$$                    # whitespace operators
 ```
 
 ---

package/package.json

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

package/src/papagaio.js

@@ -1,95 +1,88 @@
 // https://github.com/jardimdanificado/papagaio
-
-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);
+  
+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;
     }
-    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;
-}
-
-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++;
-      }
-      return [src.substring(innerStart), src.length];
+    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 (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++;
+    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;
+        }
       }
-      return [src.substring(innerStart, i), i + 1];
     }
-  }
-  return ['', i];
-}
-
-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) && 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 + 'block'.length;
+      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;
+        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);
-          openDelim = unescapeDelimiter(c.trim()) || papagaio.symbols.open;
+          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++;
         }
-        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;
+          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;
         }
-        tokens.push({ type: 'block', varName, openDelim, closeDelim });
+        tokens.push({ type: 'block', varName, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs });
         i = j;
         continue;
       }
@@ -98,210 +91,375 @@ function parsePattern(papagaio, pattern) {
       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;
+        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;
+        }
       }
-      tokens.push({ type: 'literal', value: S });
-      i += S.length;
-      continue;
     }
-    if (/\s/.test(pattern[i])) {
+    if (isWhitespaceChar(pattern[i])) {
       let ws = '';
-      while (i < pattern.length && /\s/.test(pattern[i])) ws += pattern[i++];
-      tokens.push({ type: 'whitespace', value: ws });
+      while (i < pattern.length && isWhitespaceChar(pattern[i])) ws += pattern[i++];
+      tokens.push({ type: 'literal-ws', value: ws });
       continue;
     }
     let literal = '';
-    while (i < pattern.length && !pattern.startsWith(S, i) && !/\s/.test(pattern[i])) literal += pattern[i++];
+    while (i < pattern.length && !pattern.startsWith(S, i) && !isWhitespaceChar(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;
-  const captures = {};
+  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 === 'whitespace-optional') {
-      while (pos < src.length && /\s/.test(src[pos])) pos++;
+    if (token.type === 'literal-ws') {
+      if (!src.startsWith(token.value, pos)) return null;
+      pos += token.value.length;
       continue;
     }
-    if (token.type === 'whitespace') {
+    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') {
-      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++];
-        }
+      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++];
       } else {
-        while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
+        while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
       }
-      if (!varValue) return null;
-      captures[papagaio.symbols.sigil + token.varName] = varValue;
+      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 = '';
+      if (!n || ['var', 'var-ws', 'block'].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.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 } = token;
+      const { varName, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs } = 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;
+      const [c, e] = extractBlockWithWsDelimiter(papagaio, src, pos, openDelim, closeDelim, openDelimIsWs, closeDelimIsWs);
+      captures[papagaio.symbols.sigil + varName] = c;
+      pos = e;
       continue;
     }
   }
   return { captures, endPos: pos };
 }
 
-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);
+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 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];
+    }
+    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 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 processContext(p, src) {
+  const r = new RegExp(`\\b${p.symbols.context}\\s*\\${p.symbols.open}`, "g");
+  let m, a = [];
+  while ((m = r.exec(src)) !== null) a.push({ idx: m.index, pos: m.index + m[0].length - 1 });
+  for (let j = a.length - 1; j >= 0; j--) {
+    const x = a[j], [c, e] = extractBlock(p, src, x.pos);
+    if (!c.trim()) {
+      src = src.slice(0, x.idx) + src.slice(e);
+      continue;
+    }
+    const r2 = p.process(c);
+    let L = src.substring(0, x.idx), R = src.substring(e);
+    let pre = L.endsWith("\n") ? "\n" : "";
+    if (pre) L = L.slice(0, -1);
+    src = L + pre + r2 + R;
+  }
+  return src;
+}
+
+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 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);
+    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;
     }
-    result = result.slice(0, start) + result.slice(posAfterMatch);
+    out = out.slice(0, s) + out.slice(em);
   }
-  return [patterns, result];
+  return [A, out];
 }
 
-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;
+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 matchResult = matchPattern(papagaio, src, tokens, pos);
-      if (matchResult) {
-        matched = true;
-        const { captures, endPos } = matchResult;
-        let result = pat.replace;
+      const m = matchPattern(p, src, t, pos);
+      if (m) {
+        ok = true;
+        const { captures, endPos } = m;
+        let r = 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 e = escapeRegex(k);
+          r = r.replace(new RegExp(e + '(?![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) => {
+        const uid = p.unique_id++;
+        r = r.replace(new RegExp(`${escapeRegex(S)}unique\\b`, 'g'), () => String(uid));
+        r = r.replace(/\$eval\{([^}]*)\}/g, (_, c) => {
           try {
-            const wrapped = `"use strict"; return (function() { ${code} })();`;
-            return String(Function("papagaio", "ctx", wrapped)(papagaio, {}));
+            return String(Function("papagaio", "ctx", `"use strict";return(function(){${c}})();`)(p, {}));
           } catch {
             return "";
           }
         });
-        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;
+        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 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;
+        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 {
-        newSrc += src[pos];
+        n += src[pos];
         pos++;
       }
     }
-    if (matched) {
-      src = clearFlag ? lastResult : newSrc;
-      clearFlag = false;
+    if (ok) {
+      src = clear ? last : n;
+      clear = false;
     }
   }
   return src;
 }
 
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
 }
 
-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;
+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 {
-        result += str[i];
-      }
-    } else {
-      result += str[i];
-    }
+      } else r += s[i];
+    } else r += s[i];
   }
-  return result;
+  return r;
 }
 
 export class Papagaio {
   constructor() {
     this.recursion_limit = 512;
     this.unique_id = 0;
-    this.symbols = {
-      pattern: "pattern",
-      context: "context",
-      open: "{",
-      close: "}",
-      sigil: "$"
-    };
+    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);
+    let src = input, last = null, it = 0;
+    const pend = () => {
+      const r1 = new RegExp(`\\b${this.symbols.context}\\s*\\${this.symbols.open}`, "g");
+      const r2 = new RegExp(`\\b${this.symbols.pattern}\\s*\\${this.symbols.open}`, "g");
+      return r1.test(src) || r2.test(src);
     };
-    while (src !== last && iter < this.recursion_limit) {
-      iter++;
+    while (src !== last && it < this.recursion_limit) {
+      it++;
       last = src;
       src = processContext(this, src);
-      const [patterns, s2] = collectPatterns(this, src);
-      src = applyPatterns(this, s2, patterns);
-      if (!pending()) break;
+      const [p, s2] = collectPatterns(this, src);
+      src = applyPatterns(this, s2, p);
+      if (!pend()) break;
     }
     return this.content = src, src;
   }

package/tests/tests.json

@@ -9,7 +9,7 @@
     {
       "id": 2,
       "name": "Flexible whitespace ($)",
-      "code": "pattern {$x$$and$$$y} {$x & $y}\nhello   and   world",
+      "code": "pattern {$$x and $$y} {$x & $y}\nhello   and   world",
       "expected": "hello & world"
     },
     {
@@ -75,7 +75,7 @@
     {
       "id": 13,
       "name": "Pattern with flexible whitespace in middle",
-      "code": "pattern {from$$to} {path: from -> to}\nfrom     to\nfrom  to\nfrom to",
+      "code": "pattern {from to} {path: from -> to}\nfrom     to\nfrom  to\nfrom to",
       "expected": "path: from -> to"
     },
     {
@@ -129,7 +129,7 @@
     {
       "id": 22,
       "name": "Flexible whitespace with semicolon",
-      "code": "pattern {$$$a$$;$$$b$$} {$a AND $b}\nx ; y\nx; y\nx  ;  y",
+      "code": "pattern {$$a;$$b} {$a AND $b}\nx ; y\nx; y\nx  ;  y",
       "expected": "x AND y"
     },
     {
@@ -182,8 +182,8 @@
     },
     {
       "id": 31,
-      "name": "Block with empty delimiter (default)",
-      "code": "pattern {$block data {}{}} {DATA:$data}\ndata { hello world }",
+      "name": "Delimiter test",
+      "code": "pattern {$block data {[}{]}} {DATA:$data}\ndata [ hello world ]",
       "expected": "DATA: hello world"
     },
     {
@@ -267,7 +267,7 @@
     {
       "id": 45,
       "name": "Pattern with flexible space before and after",
-      "code": "pattern {$$hello$$} {FOUND}\n   hello   ",
+      "code": "pattern {$$ hello$$ } {FOUND}\n   hello   ",
       "expected": "FOUND"
     },
     {
@@ -315,7 +315,7 @@
     {
       "id": 53,
       "name": "Trim multiple surrounding spaces",
-      "code": "pattern {$$$word$$} {FOUND: $word}\n   word    ",
+      "code": "pattern {$ $word$ } {FOUND: $word}\n   word    ",
       "expected": "FOUND: word"
     },
     {
@@ -422,296 +422,296 @@
     },
     {
       "id": 71,
-      "name": "README: Simple Variables",
+      "name": "Simple Variables",
       "code": "pattern {$x} {$x}\nhello",
       "expected": "hello"
     },
     {
       "id": 72,
-      "name": "README: Multiple Variables",
+      "name": "Multiple Variables",
       "code": "pattern {$x $y $z} {$z, $y, $x}\napple banana cherry",
       "expected": "cherry, banana, apple"
     },
     {
       "id": 73,
-      "name": "README: Flexible Whitespace",
+      "name": "Flexible Whitespace",
       "code": "pattern {$x$$and$$$y} {$x & $y}\nhello   and   world",
       "expected": "hello & world"
     },
     {
       "id": 74,
-      "name": "README: Flexible Whitespace (compact)",
+      "name": "Flexible Whitespace (compact)",
       "code": "pattern {$x$$and$$$y} {$x & $y}\nhello and world",
       "expected": "hello & world"
     },
     {
       "id": 75,
-      "name": "README: Block with parentheses",
-      "code": "pattern {$block content {(}{)}} {[$content]}\ndata ( hello world )",
+      "name": "Block with parentheses",
+      "code": "pattern {$name $block content {(}{)}} {[$content]}\ndata (hello world)",
       "expected": "[hello world]"
     },
     {
       "id": 76,
-      "name": "README: Block with custom delimiters <<>>",
+      "name": "Block with custom delimiters <<>>",
       "code": "pattern {$block data {<<}{>>}} {DATA: $data}\n<<json stuff>>",
       "expected": "DATA: json stuff"
     },
     {
       "id": 77,
-      "name": "README: Multiple Blocks in pattern",
+      "name": "Multiple Blocks in pattern",
       "code": "pattern {$block a {(}{)}, $block b {[}{]}} {$a|$b}\n(first), [second]",
       "expected": "first|second"
     },
     {
       "id": 78,
-      "name": "README: Basic pattern with literals",
+      "name": "Basic pattern with literals",
       "code": "pattern {match} {replace}\nmatch",
       "expected": "replace"
     },
     {
       "id": 79,
-      "name": "README: Markdown heading example",
+      "name": "Markdown heading example",
       "code": "pattern {# $title} {<h1>$title</h1>}\n# Welcome",
       "expected": "<h1>Welcome</h1>"
     },
     {
       "id": 80,
-      "name": "README: Multiple patterns cascade",
+      "name": "Multiple patterns cascade",
       "code": "pattern {a} {b}\npattern {b} {c}\npattern {c} {d}\na",
       "expected": "d"
     },
     {
       "id": 81,
-      "name": "README: Context basic",
+      "name": "Context basic",
       "code": "context {\n  pattern {$x} {<$x>}\n  \n  apple\n  banana\n}",
-      "expected": "<apple>\n<banana>"
+      "expected": "<apple>\n  <banana>"
     },
     {
       "id": 82,
-      "name": "README: $unique incremental",
+      "name": "$unique incremental",
       "code": "pattern {item} {[$unique]item_$unique}\nitem\nitem\nitem",
       "expected": "[0]item_0\n[1]item_1\n[2]item_2"
     },
     {
       "id": 83,
-      "name": "README: $unique same ID in replacement",
+      "name": "$unique same ID in replacement",
       "code": "pattern {a} {$unique $unique}\na",
       "expected": "0 0"
     },
     {
       "id": 84,
-      "name": "README: $match full match",
+      "name": "$match full match",
       "code": "pattern {[$x]} {FOUND: $match}\n[data]",
       "expected": "FOUND: [data]"
     },
     {
       "id": 85,
-      "name": "README: $prefix e $suffix",
+      "name": "$prefix e $suffix",
       "code": "pattern {world} {$prefix$suffix}hello world test",
       "expected": "hello hello  test test"
     },
     {
       "id": 86,
-      "name": "README: $clear remove before match",
+      "name": "$clear remove before match",
       "code": "pattern {SKIP $x} {$clear KEEP: $x}\nIGNORE_THIS SKIP keep_this",
       "expected": "KEEP: keep_this"
     },
     {
       "id": 87,
-      "name": "README: $eval arithmetic multiplication",
+      "name": "$eval arithmetic multiplication",
       "code": "pattern {$x} {$eval{return parseInt($x) * 2;}}\n5",
       "expected": "10"
     },
     {
       "id": 88,
-      "name": "README: Markdown h1 and h2",
+      "name": "Markdown h1 and h2",
       "code": "pattern {## $t} {<h2>$t</h2>}\npattern {# $t} {<h1>$t</h1>}\n# Title\n## Subtitle",
       "expected": "<h1>Title</h1>\n<h2>Subtitle</h2>"
     },
     {
       "id": 89,
-      "name": "README: Markdown bold and italic",
+      "name": "Markdown bold and italic",
       "code": "pattern {**$t**} {<strong>$t</strong>}\npattern {*$t*} {<em>$t</em>}\n**bold** and *italic*",
       "expected": "<strong>bold</strong> and <em>italic</em>"
     },
     {
       "id": 90,
-      "name": "README: Markdown list",
+      "name": "Markdown list",
       "code": "pattern {- $i} {<li>$i</li>}\n- item1\n- item2",
       "expected": "<li>item1</li>\n<li>item2</li>"
     },
     {
       "id": 91,
-      "name": "README: CSV to JSON",
-      "code": "pattern {$a,$b,$c} {{ id: '$a', name: '$b', role: '$c' }}\n1,Alice,Engineer\n2,Bob,Designer",
+      "name": "CSV to JSON",
+      "code": "pattern {$a,$$b,$$c} {{ id: '$a', name: '$b', role: '$c' }}\n1,Alice,Engineer\n2,Bob,Designer",
       "expected": "{ id: '1', name: 'Alice', role: 'Engineer' }\n{ id: '2', name: 'Bob', role: 'Designer' }"
     },
     {
       "id": 92,
-      "name": "README: Config parser",
+      "name": "Config parser",
       "code": "pattern {$key = $value} {const $key = '$value';}\nhost = localhost\nport = 3000",
       "expected": "const host = 'localhost';\nconst port = '3000';"
     },
     {
       "id": 93,
-      "name": "README: HTML generator",
+      "name": "HTML generator",
       "code": "pattern {$tag $content} {<$tag>$content</$tag>}\ndiv HelloWorld\nspan Test",
       "expected": "<div>HelloWorld</div>\n<span>Test</span>"
     },
     {
       "id": 94,
-      "name": "BONUS: Variable reuse in replacement",
+      "name": "Variable reuse in replacement",
       "code": "pattern {$x} {$x:$x:$x}\ndata",
       "expected": "data:data:data"
     },
     {
       "id": 95,
-      "name": "BONUS: Literal dollar sign in replacement",
+      "name": "Literal dollar sign in replacement",
       "code": "pattern {price} {Price: $50}\nprice",
       "expected": "Price: $50"
     },
     {
       "id": 96,
-      "name": "BONUS: Block with angle brackets nesting",
+      "name": "Block with angle brackets nesting",
       "code": "pattern {$block content {<}{>}} {CONTENT:$content}\nouter <inner <deep> more>",
       "expected": "CONTENT:inner <deep> more"
     },
     {
       "id": 97,
-      "name": "BONUS: Pattern with special regex characters",
+      "name": "Pattern with special regex characters",
       "code": "pattern {a.*b} {MATCHED}\na.*b",
       "expected": "MATCHED"
     },
     {
       "id": 98,
-      "name": "BONUS: Multiple $eval operations",
+      "name": "Multiple $eval operations",
       "code": "pattern {add $a $b} {$eval{return parseInt($a) + parseInt($b)}}\nadd 15 25",
       "expected": "40"
     },
     {
       "id": 99,
-      "name": "BONUS: $eval with division and decimals",
+      "name": "$eval with division and decimals",
       "code": "pattern {div $a $b} {$eval{return $a / $b}}\ndiv 7 2",
       "expected": "3.5"
     },
     {
       "id": 100,
-      "name": "BONUS: Unicode characters support",
+      "name": "Unicode characters support",
       "code": "pattern {oi $name} {Olá $name!}\noi Mundo",
       "expected": "Olá Mundo!"
     },
     {
       "id": 101,
-      "name": "BONUS: Emoji support",
+      "name": "Emoji support",
       "code": "pattern {react $emoji} {Você reagiu: $emoji}\nreact 😊",
       "expected": "Você reagiu: 😊"
     },
     {
       "id": 102,
-      "name": "BONUS: Tab as flexible whitespace",
+      "name": "Tab as flexible whitespace",
       "code": "pattern {from$$to} {path: from -> to}\nfrom\tto",
       "expected": "path: from -> to"
     },
     {
       "id": 103,
-      "name": "BONUS: No match leaves input intact",
+      "name": "No match leaves input intact",
       "code": "pattern {nomatch $x} {REPLACED}\nnothing matches here",
       "expected": "nothing matches here"
     },
     {
       "id": 104,
-      "name": "BONUS: Empty context is removed",
+      "name": "Empty context is removed",
       "code": "Start\ncontext {}End",
       "expected": "Start\nEnd"
     },
     {
       "id": 105,
-      "name": "BONUS: Block with pipe delimiters",
+      "name": "Block with pipe delimiters",
       "code": "pattern {$block content {|}{|}} {PIPE[$content]}\n|value|",
       "expected": "PIPE[value]"
     },
     {
       "id": 106,
-      "name": "BONUS: Block with double quotes delimiter",
+      "name": "Block with double quotes delimiter",
       "code": "pattern {$block str {\"}{\"}} {STR[$str]}\n\"hello world\"",
       "expected": "STR[hello world]"
     },
     {
       "id": 107,
-      "name": "BONUS: Comma-separated pattern matching",
-      "code": "pattern {$a,$b,$c} {[$a] [$b] [$c]}\none,two,three",
+      "name": "Comma-separated pattern matching",
+      "code": "pattern {$$a,$$b,$$c} {[$a] [$b] [$c]}\none,two,three",
       "expected": "[one] [two] [three]"
     },
     {
       "id": 108,
-      "name": "BONUS: Apostrophe in pattern literal",
+      "name": "Apostrophe in pattern literal",
       "code": "pattern {It's $name} {Hello $name}\nIt's John",
       "expected": "Hello John"
     },
     {
       "id": 109,
-      "name": "BONUS: Math operation with $eval",
+      "name": "Math operation with $eval",
       "code": "pattern {num $a} {$eval{return parseInt($a) + 1}}\nnum 999",
       "expected": "1000"
     },
     {
       "id": 110,
-      "name": "BONUS: Multi-character block delimiters",
+      "name": "Multi-character block delimiters",
       "code": "pattern {$block code {open}{close}} {CODE[$code]}\nopenFunction()close",
       "expected": "CODE[Function()]"
     },
     {
       "id": 111,
-      "name": "BONUS: Pattern with dot literal",
-      "code": "pattern {$file.txt} {File: $file}\ndocument.txt",
+      "name": "Pattern with dot literal",
+      "code": "pattern {$$file.txt} {File: $file.txt}\ndocument.txt",
       "expected": "File: document"
     },
     {
       "id": 112,
-      "name": "BONUS: Repeated global pattern matching",
+      "name": "Repeated global pattern matching",
       "code": "pattern {x} {X}\nxxxxx",
       "expected": "XXXXX"
     },
     {
       "id": 113,
-      "name": "BONUS: Overlapping patterns cascade",
+      "name": "Overlapping patterns cascade",
       "code": "pattern {a} {A}\npattern {A} {B}\npattern {B} {C}\na",
       "expected": "C"
     },
     {
       "id": 114,
-      "name": "BONUS: Context with nested patterns",
+      "name": "Context with nested patterns",
       "code": "context {\n  pattern {$x} {\n<$x>}\napple\nbanana\ncherry\n}",
       "expected": "<apple>\n<banana>\n<cherry>"
     },
     {
       "id": 115,
-      "name": "BONUS: $eval with subtraction (negatives)",
+      "name": "$eval with subtraction (negatives)",
       "code": "pattern {calc $a $b} {$eval{return $a - $b}}\ncalc -5 -10",
       "expected": "5"
     },
     {
       "id": 116,
-      "name": "BONUS: Multiple spaces trim with flexible whitespace",
-      "code": "pattern {$$$word$$} {FOUND: $word}\n   word    ",
+      "name": "Multiple spaces trim with flexible whitespace",
+      "code": "pattern {$ $word$ } {FOUND: $word}\n   word    ",
       "expected": "FOUND: word"
     },
     {
       "id": 117,
-      "name": "BONUS: Block captures parentheses with nesting",
+      "name": "Block captures parentheses with nesting",
       "code": "pattern {$block content {(}{)}} {B[$content]}\n(a(b)c)",
       "expected": "B[a(b)c]"
     },
     {
       "id": 118,
-      "name": "BONUS: Arithmetic in config pattern",
+      "name": "Arithmetic in config pattern",
       "code": "pattern {$x + $y = $z} {$z is sum of $x and $y}\n5 + 3 = 8",
       "expected": "8 is sum of 5 and 3"
     },
     {
       "id": 119,
-      "name": "BONUS: Trailing punctuation in pattern",
-      "code": "pattern {$w,} {$w!}\nhello,",
+      "name": "Trailing punctuation in pattern",
+      "code": "pattern {$$w,} {$$w!}\nhello,",
       "expected": "hello!"
     }
   ]