papagaio 0.5.2 → 0.6.1

package/README.md

@@ -1,5 +1,11 @@
 # Papagaio
-Minimal yet powerful text preprocessor with support for multi-character delimiters.
+Minimal yet powerful text preprocessor.
+
+- **It's portable!** papagaio requires only ES6 and nothing else.
+- **It's small!** papagaio is around ~250 lines and ~10kb.
+- **It's easy!** papagaio doesnt have any complicated stuff, 1 class and 1 method for doing everything!
+- **It's flexible!** do papagaio sigil and delimiters conflict with whatever you want to process? then simply change it! papagaio allow us to modify ANY of its keywords and symbols.
+- **It's powerful!!** aside been inspired by the m4 preprocessor and meant to be a preprocessor, papagaio still a fully-featured programming language because it can evaluate any valid javascript code using $eval;
 
 ## Installation
 ```javascript
@@ -19,7 +25,6 @@ papagaio.symbols = {
   block: "block",          // block keyword
   regex: "regex"           // regex keyword
 };
-papagaio.recursion_limit = 512;
 ```
 
 ---
@@ -28,14 +33,14 @@ papagaio.recursion_limit = 512;
 
 ### 1. Simple Variables
 ```
-pattern {$x} {$x}
+$pattern {$x} {$x}
 hello
 ```
 Output: `hello`
 
 ### 2. Multiple Variables
 ```
-pattern {$x $y $z} {$z, $y, $x}
+$pattern {$x $y $z} {$z, $y, $x}
 apple banana cherry
 ```
 Output: `cherry, banana, apple`
@@ -53,19 +58,19 @@ Automatically adapts based on context:
 - **Otherwise**: Captures a single word (non-whitespace token)
 
 ```
-pattern {$x} {[$x]}
+$pattern {$x} {[$x]}
 hello world
 ```
-Output: `[hello]`
+Output: `[hello] [world]`
 
 ```
-pattern {$name $block content {(}{)}} {$name: $content}
+$pattern {$name $block content {(}{)}} {$name: $content}
 greeting (hello world)
 ```
 Output: `greeting: hello world`
 
 ```
-pattern {$prefix:$suffix} {$suffix-$prefix}
+$pattern {$prefix:$suffix} {$suffix-$prefix}
 key:value
 ```
 Output: `value-key`
@@ -74,13 +79,13 @@ Output: `value-key`
 Same behavior as `$x`, but won't fail if empty or not found.
 
 ```
-pattern {$x? world} {<$x>}
+$pattern {$x? world} {<$x>}
 world
 ```
 Output: `<>`
 
 ```
-pattern {$greeting? $name} {Hello $name$greeting}
+$pattern {$greeting? $name} {Hello $name$greeting}
 Hi John
 ```
 Output: `Hello JohnHi`
@@ -98,30 +103,25 @@ $regex varName {pattern}
 
 ### Basic Example
 ```
-pattern {$regex num {[0-9]+}} {Number: $num}
+$pattern {$regex num {[0-9]+}} {Number: $num}
 The answer is 42
 ```
 Output: `Number: 42`
 
 ### Complex Patterns
 ```
-pattern {$regex email {\w+@\w+\.\w+}} {Email found: $email}
+$pattern {$regex email {\w+@\w+\.\w+}} {Email found: $email}
 Contact: user@example.com
 ```
 Output: `Email found: user@example.com`
 
 ### Multiple Regex Variables
 ```
-pattern {$regex year {[0-9]{4}}-$regex month {[0-9]{2}}} {Month $month in $year}
+$pattern {$regex year {[0-9]{4}}-$regex month {[0-9]{2}}} {Month $month in $year}
 2024-03
 ```
 Output: `Month 03 in 2024`
 
-### Notes
-- Regex patterns are cached for performance
-- Matches are anchored at the current position (no searching ahead)
-- Invalid regex patterns will cause the match to fail gracefully
-
 ---
 
 ## Blocks
@@ -135,21 +135,21 @@ $block varName {open}{close}
 
 ### Basic Example
 ```
-pattern {$name $block content {(}{)}} {[$content]}
+$pattern {$name $block content {(}{)}} {[$content]}
 data (hello world)
 ```
 Output: `[hello world]`
 
 ### Custom Delimiters
 ```
-pattern {$block data {<<}{>>}} {DATA: $data}
+$pattern {$block data {<<}{>>}} {DATA: $data}
 <<json stuff>>
 ```
 Output: `DATA: json stuff`
 
 ### Multi-Character Delimiters
 ```
-pattern {$block code {```}{```}} {<pre>$code</pre>}
+$pattern {$block code {```}{```}} {<pre>$code</pre>}
 ```markdown
 # Title
 ```
@@ -157,91 +157,108 @@ Output: `<pre># Title</pre>`
 
 ### Multiple Blocks
 ```
-pattern {$block a {(}{)}, $block b {[}{]}} {$a|$b}
+$pattern {$block a {(}{)}, $block b {[}{]}} {$a|$b}
 (first), [second]
 ```
 Output: `first|second`
 
 ### Nested Blocks
 ```
-pattern {$block outer {(}{)}} {[$outer]}
+$pattern {$block outer {(}{)}} {[$outer]}
 (outer (inner))
 ```
 Output: `[outer (inner)]`
 
 ---
 
-## Patterns
+## Pattern Scopes
+
+Patterns defined within a replacement body create nested scopes with hierarchical inheritance.
 
 ### Basic Pattern
 ```
-pattern {match} {replace}
+$pattern {hello} {world}
+hello
 ```
+Output: `world`
 
-### Example
-```
-pattern {# $title} {<h1>$title</h1>}
-# Welcome
-```
-Output: `<h1>Welcome</h1>`
+**Key Properties:**
+* Patterns are scoped to their context
+* Child patterns inherit parent patterns
+* Patterns do not persist between `process()` calls
+* Perfect for hierarchical transformations
 
-### Multiple Patterns Cascade
+### Nested Patterns with Inheritance
 ```
-pattern {a} {b}
-pattern {b} {c}
-pattern {c} {d}
-a
+$pattern {outer $x} {
+  $pattern {inner $y} {[$y from $x]}
+  inner $x
+}
+outer hello
 ```
-Output: `d`
-
----
-
-## Subpatterns
+Output: `[hello from hello]`
 
-Subpatterns are patterns declared *inside* replacement bodies, existing only during parent pattern execution.
+The inner pattern has access to `$x` from the outer pattern's capture.
 
-### Syntax
+### Deep Nesting
 ```
-$pattern {match} {replace}
+$pattern {level1 $a} {
+  $pattern {level2 $b} {
+    $pattern {level3 $c} {$a > $b > $c}
+    level3 $b
+  }
+  level2 $a
+}
+level1 ROOT
 ```
+Output: `ROOT > ROOT > ROOT`
 
-### Example
+Each nested level inherits all patterns from parent scopes.
+
+### Sibling Scopes Don't Share
 ```
-pattern {eval $block code {(}{)}} {
-  $eval{
-    $pattern {undefined} {}
-    $code;
-    return "";
-  }
+$pattern {branch1} {
+  $pattern {x} {A}
+  x
+}
+$pattern {branch2} {
+  x
 }
-eval(console.log(123))
+branch1
+branch2
 ```
 Output:
 ```
-123
+A
+x
 ```
 
-### 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.
-* Multiple subpatterns can coexist in the same replacement.
+Patterns in `branch1` are not available in `branch2` (they are siblings, not parent-child).
 
 ---
 
 ## Special Keywords
 
 ### $eval
-Executes JavaScript code.
+Executes JavaScript code with access to the Papagaio instance.
+
 ```
-pattern {$x} {$eval{return parseInt($x)*2;}}
+$pattern {$x} {$eval{return parseInt($x)*2;}}
 5
 ```
 Output: `10`
 
-Supports multi-character delimiters:
+**Accessing Papagaio Instance:**
+```
+$pattern {info} {$eval{
+  return `Content length: ${papagaio.content.length}`;
+}}
+info
 ```
-pattern {$x} {$eval<<parseInt($x)*2>>}
+
+**Multi-character delimiters:**
+```
+$pattern {$x} {$eval<<parseInt($x)*2>>}
 5
 ```
 Output: `10`
@@ -254,41 +271,141 @@ Output: `10`
 * `$x` = smart capture (context-aware: word, until literal, or until block)
 * `$x?` = optional version of `$x` (won't fail if empty)
 * `$regex name {pattern}` = regex-based capture
-* Patterns apply globally until stable
-* Blocks support arbitrary nesting depth
+* Variables automatically skip leading whitespace
+* Trailing whitespace is trimmed when variables appear before literals
+
+### Pattern Matching
+* `$pattern {match} {replace}` = pattern scoped to current context
+* Patterns inherit from parent scopes hierarchically
+* Each `process()` call starts with a clean slate (no persistence)
 
 ### Block Matching
 * `$block name {open}{close}` captures delimited regions
 * Supports nested delimiters of any length
 * Multi-character delimiters fully supported (e.g., `{>>>}{<<<}`)
-
-### Whitespace Handling
-* Variables automatically skip leading whitespace when needed
-* Trailing whitespace is trimmed when variables appear before literals
+* Blocks support arbitrary nesting depth
 
 ---
 
 ## Multi-Character Delimiter Support
 
-The updated version fully supports multi-character delimiters throughout all features.
+Papagaio fully supports multi-character delimiters throughout all features.
 
-### Examples
+### Configuration
 ```javascript
 const p = new Papagaio('$', '<<<', '>>>');
 ```
 
+### In Patterns
+```
+$pattern<<<$x>>> <<<[$x]>>>
+hello
+```
+Output: `[hello]`
+
 ### In Blocks
 ```
-pattern {$block data {<<}{>>}} {$data}
+$pattern<<<$block data {<<}{>>}>>> <<<$data>>>
 <<content>>
 ```
+Output: `content`
 
 ### In Eval
 ```
-// const p = new Papagaio('$', '<<<', '>>>');
-pattern <<<$x>>> <<<$eval<<<return $x + 1>>>>>>
+$pattern<<<$x>>> <<<$eval<<<return $x + 1>>>>>>
 5
 ```
+Output: `6`
+
+---
+
+## Advanced Examples
+
+### Markdown-like Processor
+```javascript
+const p = new Papagaio();
+const template = `
+$pattern {# $title} {<h1>$title</h1>}
+$pattern {## $title} {<h2>$title</h2>}
+$pattern {**$text**} {<strong>$text</strong>}
+
+# Hello World
+## Subtitle
+**bold text**
+`;
+
+p.process(template);
+// Output:
+// <h1>Hello World</h1>
+// <h2>Subtitle</h2>
+// <strong>bold text</strong>
+```
+
+### Template System with State
+```javascript
+const p = new Papagaio();
+p.vars = {}; // Custom property for storing variables
+
+const template = `
+$pattern {var $name = $value} {$eval{
+  papagaio.vars['$name'] = '$value';
+  return '';
+}}
+$pattern {get $name} {$eval{
+  return papagaio.vars['$name'] || 'undefined';
+}}
+
+var title = My Page
+var author = John Doe
+Title: get title
+Author: get author
+`;
+
+p.process(template);
+// Output:
+// Title: My Page
+// Author: John Doe
+```
+
+### Conditional Processing
+```javascript
+const p = new Papagaio();
+const template = `
+$pattern {if $block cond {(}{)} then $block yes {[}{]} else $block no {<}{>}} {
+  $eval{
+    const condition = ($cond).trim();
+    return condition === 'true' ? '$yes' : '$no';
+  }
+}
+
+if (true) then [yes branch] else <no branch>
+if (false) then [yes branch] else <no branch>
+`;
+
+p.process(template);
+// Output:
+// yes branch
+// no branch
+```
+
+### Function-like Patterns
+```javascript
+const p = new Papagaio();
+const template = `
+$pattern {double $x} {$eval{return parseInt('$x') * 2}}
+$pattern {add $x $y} {$eval{return parseInt('$x') + parseInt('$y')}}
+
+double 5
+add 3 7
+add (double 4) 10
+`;
+
+p.process(template);
+// Output:
+// 10
+// 10
+// 18
+```
 
 ---
 
@@ -298,8 +415,9 @@ pattern <<<$x>>> <<<$eval<<<return $x + 1>>>>>>
 |---------|----------|
 | Variable not captured | Check context: use `$x?` for optional, or verify literals/blocks exist |
 | Block mismatch | Verify opening and closing delimiters match the declaration |
-| Infinite recursion | Reduce `recursion_limit` or simplify pattern dependencies |
+| Infinite recursion | Pattern creates circular transformation; redesign pattern logic |
 | Pattern not matching | Verify whitespace between tokens, check if variable should be optional |
+| Pattern not available | Check scope hierarchy; patterns only inherit from parents, not siblings |
 | Nested blocks fail | Ensure delimiters are properly balanced |
 | Multi-char delimiters broken | Check delimiters don't conflict; use escaping if needed |
 | Regex not matching | Test regex pattern separately; ensure it matches at the exact position |
@@ -309,20 +427,59 @@ pattern <<<$x>>> <<<$eval<<<return $x + 1>>>>>>
 ## Syntax Reference
 
 ```
-pattern {$x $y} {$y, $x}           # basic pattern with variables
-pattern {$x? $y} {$y, $x}          # optional variable
-pattern {$regex n {[0-9]+}} {$n}   # regex capture
-pattern {$block n {o}{c}} {$n}     # block capture with custom delimiters
-$pattern {a} {b}                   # subpattern (scoped to parent)
-$eval{code}                        # JavaScript evaluation
+$pattern {$x $y} {$y, $x}            # pattern with variables
+$pattern {$x? $y} {$y, $x}           # optional variable
+$pattern {$regex n {[0-9]+}} {$n}    # regex capture
+$pattern {$block n {o}{c}} {$n}      # block capture with custom delimiters
+$eval{code}                          # JavaScript evaluation
+```
+
+---
+
+## API Reference
+
+### Constructor
+```javascript
+new Papagaio(sigil, open, close, pattern, evalKw, blockKw, regexKw)
+```
+
+**Parameters:**
+- `sigil` (default: `'$'`) - Variable prefix
+- `open` (default: `'{'`) - Opening delimiter
+- `close` (default: `'}'`) - Closing delimiter
+- `pattern` (default: `'pattern'`) - Pattern keyword
+- `evalKw` (default: `'eval'`) - Eval keyword
+- `blockKw` (default: `'block'`) - Block keyword
+- `regexKw` (default: `'regex'`) - Regex keyword
+
+### Properties
+- `papagaio.content` - Last processed output
+- `papagaio.match` - Last matched substring (available in replacements)
+- `papagaio.symbols` - Configuration object
+- `papagaio.exit` - Optional hook function called after processing
+
+### Methods
+- `papagaio.process(input)` - Process input text and return transformed output
+
+### Exit Hook
+```javascript
+const p = new Papagaio();
+p.exit = function() {
+  console.log('Processing complete:', this.content);
+};
+p.process('$pattern {x} {y}\nx');
 ```
 
 ---
 
 ## Performance Notes
 
-* Patterns apply recursively until no changes occur (up to `recursion_limit`)
-* Multi-character delimiter matching is optimized with regex escaping
-* Regex patterns are automatically cached to improve performance
-* Nested blocks and subpatterns have no theoretical depth limit
-* Large recursion limits can impact performance on complex inputs
+* Multi-character delimiter matching is optimized with substring operations
+* Nested patterns inherit parent patterns through recursive application
+* Nested blocks and patterns have no theoretical depth limit
+* Large recursion limits can impact performance on complex inputs
+* Each `process()` call is independent with no persistent state between calls
+
+---
+
+***PAPAGAIO IS CURRENTLY IN HEAVY DEVELOPMENT AND EXPERIMENTATION PHASE***

package/bin/cli.qjs

@@ -7,7 +7,7 @@ import * as os from "os";
 import { Papagaio } from "../src/papagaio.js";
 
 // Version (você pode hardcoded ou ler de um arquivo JSON se necessário)
-const VERSION = "1.0.0";
+const VERSION = "0.6.0";
 
 // Parse command line arguments
 const args = scriptArgs.slice(1); // QuickJS usa scriptArgs ao invés de process.argv

package/examples/simple.html

@@ -5,9 +5,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>papagaio test</title>
 </head>
-<script src="src/papagaio-bootstrap.mjs" type="module"></script>
+<script src="../src/papagaio-bootstrap.mjs" type="module"></script>
 <script type="papagaio">
-    pattern {abc} {$eval{console.log(papagaio)}}
+    $pattern {abc} {$eval{console.log(papagaio)} aaaaaaaaaaaaaaaaaaaaaaaaaaaa}
     abc
 </script>
 <body>

package/examples/wasm.papagaio

@@ -0,0 +1,70 @@
+// generic ts-like to wasm compiler
+
+// util patterns
+$pattern {// $comment $regex newline{[^\n]*}} {}
+$pattern {$regex spaces{\s\s}}{ }
+
+$eval{
+    papagaio.exit = function()
+    {
+        papagaio.content = "(module\n" + papagaio.content + "\n)";
+        papagaio.exit = null;
+    };
+    return ""
+}
+
+$pattern {export function $name $block params{(}{)}:$rets $block content{}{}} {
+    $pattern {parametrize}
+    {
+        $eval {
+            let str = "$params".replace("(", "").replace(")", "");
+            let params = str.split(",").map(p => p.trim()).filter(p => p);
+            let new_stuff = "";
+            for (const param of params) {
+                if (!param.includes(":")) continue; // Pula se não tem ':'
+                const [name, type] = param.split(":");
+                if (name && type) { // Verifica se ambos existem
+                    new_stuff += ` (param $${name.trim()} ${type.trim()}) `;
+                }
+            }
+            return new_stuff;
+        }
+    }
+
+    (func (export "$name") parametrize (result $rets)
+        $content
+    )
+}
+
+$pattern {function $name $block params{(}{)}:$rets $block content{}{}} {
+    $pattern {parametrize}
+    {
+        $eval {
+            let str = "$params".replace("(", "").replace(")", "");
+            let params = str.split(",").map(p => p.trim()).filter(p => p);
+            let new_stuff = "";
+            for (const param of params) {
+                if (!param.includes(":")) continue; // Pula se não tem ':'
+                const [name, type] = param.split(":");
+                if (name && type) { // Verifica se ambos existem
+                    new_stuff += ` (param $${name.trim()} ${type.trim()}) `;
+                }
+            }
+            return new_stuff;
+        }
+    }
+
+    (func $$name parametrize (result $rets)
+        $content
+    )
+}
+
+function name(a:i32, b:i32):i64 i64
+{
+    contentnans
+}
+
+export function funcao_exportada(a:f32, b:f32, c:f32):i64 i64 i64 i64
+{
+    fução expoortada1
+}

package/index.html

@@ -7,13 +7,16 @@
 </head>
 <body>
     
-    <h1>🦜 papagaio</h1>
+    <h1>🦜 papagaio </h1>
     <p>
         easy yet powerful text preprocessor.
     </p>
     <hr>
     <div>
-        <label for="sketchSelect">Current Sketch:</label>
+        <strong>
+            <label for="sketchSelect">Current Sketch:</label>
+        </strong>
+
         <select id="sketchSelect" onchange="switchSketch()">
             <option value="">-- Select Sketch --</option>
         </select>
@@ -24,7 +27,9 @@
     </div>
     <hr>
     <div>
+        <strong>
         <label for="sketchSelect">Sketches:</label>
+        </strong>
         <button onclick="exportSketches()">Export</button>
         <input type="file" id="importFileInput" onchange="importSketches(this.files[0])" accept=".json">
     </div>
@@ -270,7 +275,8 @@
         function exportSketches() {
             const data = {
                 papagaio_sketches: localStorage.getItem('papagaio_sketches'),
-                papagaio_current_sketch: localStorage.getItem('papagaio_current_sketch')
+                papagaio_current_sketch: localStorage.getItem('papagaio_current_sketch'),
+                papagaio_config: localStorage.getItem('papagaio_config')
             };
 
             const blob = new Blob([JSON.stringify(data, null, 2)], {
@@ -297,6 +303,9 @@
                     if (data.papagaio_current_sketch) {
                         localStorage.setItem('papagaio_current_sketch', data.papagaio_current_sketch);
                     }
+                    if (data.papagaio_config) {
+                        localStorage.setItem('papagaio_config', data.papagaio_config);
+                    }
                     location.reload();
                 } catch (err) {
                     alert('Error importing file: ' + err.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papagaio",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "easy yet powerful preprocessor",
   "main": "src/papagaio.js",
   "type": "module",
@@ -16,7 +16,11 @@
     "macro",
     "pattern",
     "eval",
-    "parser"
+    "parser",
+    "codegen",
+    "regex",
+    "syntax",
+    "easy"
   ],
   "author": "jardimdanificado",
   "bugs": {
@@ -24,6 +28,6 @@
   },
   "homepage": "https://github.com/jardimdanificado/papagaio#readme",
   "bin": {
-    "papagaio": "./bin/cli.js"
+    "papagaio": "bin/cli.js"
   }
 }

package/src/papagaio-bootstrap.mjs

@@ -1,4 +1,5 @@
 // papagaio-bootstrap.js
+// only needed if using <script type="papagaio"> in browser
 import { Papagaio } from "./papagaio.js";
 
 (async () => {
@@ -15,11 +16,8 @@ import { Papagaio } from "./papagaio.js";
 
     const out = p.process(src);
 
-    const s = document.createElement("script");
-    s.type = "module";
+    const s = document.createElement("div");
     s.textContent = out;
-
-    // executa no mesmo ponto onde script estava
-    el.replaceWith(s);
+    window.document.body.appendChild(s);
   }
 })();

package/src/papagaio.js

@@ -1,7 +1,7 @@
+// papagaio - https://github.com/jardimdanificado/papagaio
 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;
@@ -46,8 +46,7 @@ function parsePattern(p, pat) {
                 const optional = pat[j] === '?';
                 if (optional) j++;
                 t.push({ type: 'var', varName: v, optional }); 
-                i = j; 
-                continue; 
+                i = j; continue; 
             }
             t.push({ type: 'lit', value: S }); i += S.length; continue;
         }
@@ -62,47 +61,42 @@ function parsePattern(p, pat) {
     return t;
 }
 
-function matchPattern(p, src, tokens, pos = 0) {
+function matchPattern(p, src, tok, 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') {
+    for (let ti = 0; ti < tok.length; ti++) {
+        const t = tok[ti];
+        if (t.type === 'ws') { while (pos < src.length && /\s/.test(src[pos])) pos++; continue; }
+        if (t.type === 'lit') { if (!src.startsWith(t.value, pos)) return null; pos += t.value.length; continue; }
+        if (t.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);
+                const rx = new RegExp(t.regex), m = src.slice(pos).match(rx);
                 if (!m || m.index !== 0) return null;
-                cap[p.symbols.sigil + tok.varName] = m[0];
+                cap[p.symbols.sigil + t.varName] = m[0];
                 pos += m[0].length;
-            } catch { return null; }
+            } catch (e) { return null; }
             continue;
         }
-        if (tok.type === 'var') {
+        if (t.type === 'var') {
             while (pos < src.length && /\s/.test(src[pos])) pos++;
-            const nx = findNext(tokens, ti);
+            const nx = findNext(tok, ti);
             let v = '';
-            if (nx?.type === 'block') {
+            if (nx && 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') {
+            } else if (nx && 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;
+            if (!v && !t.optional) return null;
+            cap[p.symbols.sigil + t.varName] = v;
             continue;
         }
-        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;
+        if (t.type === 'block') {
+            if (!src.startsWith(t.open, pos)) return null;
+            const [c, e] = extractBlock(p, src, pos, t.open, t.close);
+            cap[p.symbols.sigil + t.varName] = c; pos = e; continue;
         }
     }
     return { captures: cap, endPos: pos };
@@ -134,58 +128,41 @@ function extractBlock(p, src, i, od = p.symbols.open, cd = p.symbols.close) {
     return ['', 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 [arr, out];
-}
-
 function extractNested(p, txt) {
-    const n = [];
-    const rx = new RegExp(`${esc(p.symbols.sigil)}${esc(p.symbols.pattern)}\\s*${esc(p.symbols.open)}`, "g");
+    const loc = [], S = p.symbols.sigil, O = p.symbols.open;
     let out = txt;
+    const rx = new RegExp(`${esc(S)}${esc(p.symbols.pattern)}\\s*${esc(O)}`, "g");
     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 s = m.index, o = m.index + m[0].length - O.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) {
+        if (k < out.length && out.substring(k, k + O.length) === O) {
             const [rp, er] = extractBlock(p, out, k);
-            n.push({ m: mp.trim(), r: rp.trim() });
+            loc.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 [n, out];
+    return [loc, out];
 }
 
 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;
+        if (txt.substring(i, i + S.length) === S) {
+            const rest = txt.substring(i + S.length);
+            if (rest.startsWith(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, [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++;
@@ -206,7 +183,6 @@ function applyEvals(p, txt, ev) {
 }
 
 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;
@@ -215,16 +191,16 @@ function applyPats(p, src, pats) {
             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);
+                const [loc, cln] = extractNested(p, r);
+                r = cln;
+                Object.keys(m.captures).forEach(k => {
+                    r = r.replace(new RegExp(esc(k) + '(?![A-Za-z0-9_])', 'g'), m.captures[k]);
+                });
+                if (loc.length) r = applyPats(p, r, loc);
                 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;
+                n += r; pos = m.endPos;
             } else { n += src[pos]; pos++; }
         }
         if (ok) src = n;
@@ -243,23 +219,28 @@ function unescapeDelim(s) {
 }
 
 export class Papagaio {
-    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 };
+    constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'block', regexKw = 'regex') {
+        this.symbols = { pattern, open, close, sigil, eval: evalKw, block: blockKw, regex: regexKw };
         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;
+        const [loc, cln] = extractNested(this, input);
+        const [evals, ph] = extractEvals(this, cln);
+        let proc = applyEvals(this, ph, evals);
+        if (loc.length === 0) {
+            this.content = proc;
+            return proc;
+        }
+        let src = proc, last = null;
+        while (src !== last) {
+            last = src;
+            src = applyPats(this, src, loc);
+            const [nested] = extractNested(this, src);
+            if (nested.length === 0) break;
         }
-        return this.content = src, src;
+        this.content = src;
+        if (typeof this.exit == "function") this.exit();
+        return this.content;
     }
 }

package/tests/tests.json

@@ -3,211 +3,211 @@
     {
       "id": 1,
       "name": "Basic variable substitution",
-      "code": "pattern {$x $y} {$y, $x}\nhello world",
+      "code": "$pattern {$x $y} {$y, $x}\nhello world",
       "expected": "world, hello"
     },
     {
       "id": 2,
       "name": "Flexible whitespace with $",
-      "code": "pattern {$x and $y} {$x & $y}\nhello   and   world",
+      "code": "$pattern {$x and $y} {$x & $y}\nhello   and   world",
       "expected": "hello & world"
     },
     {
       "id": 3,
       "name": "Block with custom delimiters",
-      "code": "pattern {$block content {(}{)}} {[$content]}\ndata (hello world)",
+      "code": "$pattern {$block content {(}{)}} {[$content]}\ndata (hello world)",
       "expected": "data [hello world]"
     },
     {
       "id": 4,
       "name": "Block with multi-char delimiters",
-      "code": "pattern {$block code {<<}{>>}} {CODE[$code]}\n<<console.log()>>",
+      "code": "$pattern {$block code {<<}{>>}} {CODE[$code]}\n<<console.log()>>",
       "expected": "CODE[console.log()]"
     },
     {
       "id": 5,
       "name": "Block with nested delimiters",
-      "code": "pattern {$block txt {<}{>}} {[$txt]}\nouter <middle <inner> content>",
+      "code": "$pattern {$block txt {<}{>}} {[$txt]}\nouter <middle <inner> content>",
       "expected": "outer [middle <inner> content]"
     },
     {
       "id": 6,
       "name": "Eval expression with arithmetic",
-      "code": "pattern {sum $a $b} {$eval{return parseInt($a) + parseInt($b)}}\nsum 5 3",
+      "code": "$pattern {sum $a $b} {$eval{return parseInt($a) + parseInt($b)}}\nsum 5 3",
       "expected": "8"
     },
     {
       "id": 7,
       "name": "Eval with arithmetic and variable",
-      "code": "pattern {multiply $n} {Result: $eval{return $n * 3}}\nmultiply 5",
+      "code": "$pattern {multiply $n} {Result: $eval{return $n * 3}}\nmultiply 5",
       "expected": "Result: 15"
     },
     {
       "id": 8,
       "name": "Multiple patterns cascade",
-      "code": "pattern {a} {b}\npattern {b} {c}\na",
+      "code": "$pattern {a} {b}\n$pattern {b} {c}\na",
       "expected": "c"
     },
     {
       "id": 9,
       "name": "Global pattern matching",
-      "code": "pattern {x} {X}\nx y x z x",
+      "code": "$pattern {x} {X}\nx y x z x",
       "expected": "X y X z X"
     },
     {
       "id": 10,
       "name": "Pattern with special regex characters",
-      "code": "pattern {a.*b} {MATCHED}\na.*b",
+      "code": "$pattern {a.*b} {MATCHED}\na.*b",
       "expected": "MATCHED"
     },
     {
       "id": 11,
       "name": "Multiple blocks in one pattern",
-      "code": "pattern {$block a {(}{)} and $block b {[}{]}} {$a|$b}\n(first) and [second]",
+      "code": "$pattern {$block a {(}{)} and $block b {[}{]}} {$a|$b}\n(first) and [second]",
       "expected": "first|second"
     },
     {
       "id": 12,
       "name": "Variable reuse in replacement",
-      "code": "pattern {$x} {$x:$x}\ndata",
+      "code": "$pattern {$x} {$x:$x}\ndata",
       "expected": "data:data"
     },
     {
       "id": 13,
       "name": "Literal dollar sign in replacement",
-      "code": "pattern {price} {$50}\nprice",
+      "code": "$pattern {price} {$50}\nprice",
       "expected": "$50"
     },
     {
       "id": 14,
       "name": "Optional whitespace with $ optional",
-      "code": "pattern {hello$world} {HI}\nhello\n\nworld",
+      "code": "$pattern {hello$world} {HI}\nhello\n\nworld",
       "expected": "HI"
     },
     {
       "id": 15,
       "name": "Block with angle brackets",
-      "code": "pattern {$block inner {<}{>}} {WRAPPED[$inner]}\n<content>",
+      "code": "$pattern {$block inner {<}{>}} {WRAPPED[$inner]}\n<content>",
       "expected": "WRAPPED[content]"
     },
     {
       "id": 16,
       "name": "Pattern with literal characters",
-      "code": "pattern {Mr. $name} {Hello $name}\nMr. Smith",
+      "code": "$pattern {Mr. $name} {Hello $name}\nMr. Smith",
       "expected": "Hello Smith"
     },
     {
       "id": 17,
       "name": "Eval with division and decimals",
-      "code": "pattern {div $a $b} {$eval{return $a / $b}}\ndiv 7 2",
+      "code": "$pattern {div $a $b} {$eval{return $a / $b}}\ndiv 7 2",
       "expected": "3.5"
     },
     {
       "id": 18,
       "name": "Block capturing with square brackets",
-      "code": "pattern {$block arr {[}{]}} {ARRAY[$arr]}\n[1, 2, 3]",
+      "code": "$pattern {$block arr {[}{]}} {ARRAY[$arr]}\n[1, 2, 3]",
       "expected": "ARRAY[1, 2, 3]"
     },
     {
       "id": 19,
       "name": "Pattern without whitespace matching",
-      "code": "pattern {$a,$b} {$b,$a} one,two",
+      "code": "$pattern {$a,$b} {$b,$a} one,two",
       "expected": "two,one"
     },
     {
       "id": 20,
       "name": "Nested pattern in replacement",
-      "code": "pattern {$x} {->$x<-}\ntext",
+      "code": "$pattern {$x} {->$x<-}\ntext",
       "expected": "->text<-"
     },
     {
       "id": 21,
       "name": "First pattern applies, second doesn't match",
-      "code": "pattern {hello} {goodbye}\npattern {goodbye} {hi}\nhello",
+      "code": "$pattern {hello} {goodbye}\n$pattern {goodbye} {hi}\nhello",
       "expected": "hi"
     },
     {
       "id": 22,
       "name": "Block delimiter balancing - parentheses",
-      "code": "pattern {$block code {(}{)}} {RESULT[$code]}\n(a (b (c) d) e)",
+      "code": "$pattern {$block code {(}{)}} {RESULT[$code]}\n(a (b (c) d) e)",
       "expected": "RESULT[a (b (c) d) e]"
     },
     {
       "id": 23,
       "name": "Block delimiter balancing - angle brackets",
-      "code": "pattern {$block inner {<}{>}} {X[$inner]}\n<outer <middle <deep>> more>",
+      "code": "$pattern {$block inner {<}{>}} {X[$inner]}\n<outer <middle <deep>> more>",
       "expected": "X[outer <middle <deep>> more]"
     },
     {
       "id": 24,
       "name": "Block delimiter balancing - square brackets",
-      "code": "pattern {$block data {[}{]}} {DATA[$data]}\n[outer [inner [deep]] more]",
+      "code": "$pattern {$block data {[}{]}} {DATA[$data]}\n[outer [inner [deep]] more]",
       "expected": "DATA[outer [inner [deep]] more]"
     },
     {
       "id": 25,
       "name": "Block delimiter balancing - curly braces",
-      "code": "pattern {$block obj {}{}} {OBJ[$obj]}\n{key: {nested: {value}}}",
+      "code": "$pattern {$block obj {}{}} {OBJ[$obj]}\n{key: {nested: {value}}}",
       "expected": "OBJ[key: {nested: {value}}]"
     },
     {
       "id": 26,
       "name": "Multiple nested delimiters in same pattern",
-      "code": "pattern {$block a {(}{)} $block b {[}{]}} {[$a|$b]}\n(test1) [test2]",
+      "code": "$pattern {$block a {(}{)} $block b {[}{]}} {[$a|$b]}\n(test1) [test2]",
       "expected": "[test1|test2]"
     },
     {
       "id": 27,
       "name": "Simple pattern cascade",
-      "code": "pattern {START $x END} {RESULT[$x]}\nSTART data END",
+      "code": "$pattern {START $x END} {RESULT[$x]}\nSTART data END",
       "expected": "RESULT[data]"
     },
     {
       "id": 28,
       "name": "Block with quotes as delimiters",
-      "code": "pattern {$block str {\"}{\"}} {STRING[$str]}\n\"hello world\"",
+      "code": "$pattern {$block str {\"}{\"}} {STRING[$str]}\n\"hello world\"",
       "expected": "STRING[hello world]"
     },
     {
       "id": 29,
       "name": "Block with pipe delimiters",
-      "code": "pattern {$block val {|}{|}} {PIPE[$val]}\n|content here|",
+      "code": "$pattern {$block val {|}{|}} {PIPE[$val]}\n|content here|",
       "expected": "PIPE[content here]"
     },
     {
       "id": 30,
       "name": "Deeply nested block delimiters",
-      "code": "pattern {$block deep {<}{>}} {[$deep]}\n<a <b <c <d> c> b> a>",
+      "code": "$pattern {$block deep {<}{>}} {[$deep]}\n<a <b <c <d> c> b> a>",
       "expected": "[a <b <c <d> c> b> a]"
     },
     {
       "id": 31,
       "name": "Two sequential patterns",
-      "code": "pattern {$block content {(}{)}} {BLOCK [$content]}\npattern {BLOCK $x} {RESULT: $x}\n(inner data)",
+      "code": "$pattern {$block content {(}{)}} {BLOCK [$content]}\n$pattern {BLOCK $x} {RESULT: $x}\n(inner data)",
       "expected": "RESULT: [inner data]"
     },
     {
       "id": 32,
       "name": "Multiple eval operations in sequence",
-      "code": "pattern {calc $x} {$eval{return parseInt($x) * 2}}\ncalc 3",
+      "code": "$pattern {calc $x} {$eval{return parseInt($x) * 2}}\ncalc 3",
       "expected": "6"
     },
     {
       "id": 33,
       "name": "Block delimiter edge case - empty content",
-      "code": "pattern {$block empty {(}{)}} {EMPTY[$empty]}\n()",
+      "code": "$pattern {$block empty {(}{)}} {EMPTY[$empty]}\n()",
       "expected": "EMPTY[]"
     },
     {
       "id": 34,
       "name": "Multi-char delimiters with nesting",
-      "code": "pattern {$block code {<<}{>>}} {CODE[$code]}\n<<outer <<inner>> more>>",
+      "code": "$pattern {$block code {<<}{>>}} {CODE[$code]}\n<<outer <<inner>> more>>",
       "expected": "CODE[outer <<inner>> more]"
     },
     {
       "id": 35,
       "name": "Cascading pattern transformations",
-      "code": "pattern {START $x END} {STEP1[$x]}\npattern {STEP1 $y} {STEP2[$y]}\npattern {STEP2 $z} {FINAL[$z]}\nSTART test END",
+      "code": "$pattern {START $x END} {STEP1[$x]}\n$pattern {STEP1 $y} {STEP2[$y]}\n$pattern {STEP2 $z} {FINAL[$z]}\nSTART test END",
       "expected": "FINAL[[[test]]]"
     }
   ]