papagaio 0.1.7 → 0.1.9

package/README.md

@@ -1,336 +1,817 @@
-# Papagaio Preprocessor
+# Papagaio
 
-Papagaio is a lightweight, class‑based text preprocessor designed to support pattern rewriting, macro expansion, scoped transforms, and embedded JavaScript evaluation. It is engineered to be predictable, recursion‑safe, and easily embeddable in any JavaScript runtime.
+Papagaio is a flexible text preprocessor. It allows defining patterns, context blocks, dynamic variable capture, and runtime transformations directly within text. It is ideal for templates, macros, DSLs, or any structured text manipulation.
+
+The JavaScript API is minimal: just instantiate and call `process(input)`. Everything else happens in the text itself.
+
+---
+
+# Core Concepts
+
+Papagaio operates with four central mechanisms:
+
+1. **pattern{match}{replace}**  
+   Defines transformation rules. Can capture arbitrary content from the input.
+
+2. **context{...}**  
+   Processes its content recursively before reinserting it into the output.
+
+3. **Sigils (default `$`)**  
+   Introduce variables, special operations, optional spaces, and greedy captures.
+
+4. **Configurable delimiters**  
+   Define which pairs of characters are recognized as block boundaries (`{}`, `[]`, `()`, etc.).
+
+The engine processes text in layers: it detects patterns and contexts, applies transformations, and repeats until the text stabilizes.
 
 ---
 
-## Overview
+# 1. Patterns
 
-Papagaio processes an input string through a deterministic multi‑stage pipeline:
+```
 
-1. **Scope blocks** (recursive processing)
-2. **Eval blocks** (JS execution)
-3. **Macro collection**
-4. **Pattern collection**
-5. **Pattern application**
-6. **Macro expansion**
+pattern{MATCH}{REPLACE}
 
-The engine runs until it reaches a fixed point or hits the recursion limit.
+```
 
-Papagaio supports **nested delimiters**, **custom sigils**, and **configurable keywords**.
+- **MATCH**: the string or structure to detect.
+- **REPLACE**: the replacement string, which may include captured variables.
 
 ---
 
-## Installation
+## 1.1 Simple variables
+
+```
+
+pattern{Hello $name}{Hi $name}
+Hello John
+
+```
+
+Output:
+
+```
+
+Hi John
+
+```
+
+`$name` captures a single token (non-whitespace).
+
+---
+
+## 1.2 Greedy variables: `$var...TOKEN`
+
+Captures everything until it encounters `TOKEN`.
+
+```
+
+pattern{start $x...end}{X=$x}
+start abc def end
+
+```
+
+Output:
+
+```
+
+X=abc def
+
+```
+
+`TOKEN` can include spaces, and you can use `$$` for zero or more optional spaces.
+
+```
+
+pattern{A $y...B$$C}{Y=$y}
+A hello world B   C
+
+```
+
+Also matches:
+
+```
 
-Papagaio ships as a standalone ES module.
+A hello world BC
 
-```js
-import { Papagaio } from "./papagaio.js";
 ```
 
 ---
 
-## Basic Usage
+## 1.3 Balanced variables: `<$var>`
+
+Captures content inside delimiters, respecting nested structures.
+
+```
+
+pattern{<$c>}{C=$c}
+<one {two} three>
+
+```
+
+Output:
+
+```
+
+C=one {two} three
 
-```js
-const p = new Papagaio();
-const output = p.process("pattern {a} {b}  a a a");
-console.log(output); // "b b b"
 ```
 
 ---
 
-## Core Features
+## 1.4 Multiple captures
+
+```
+
+pattern{$a + $b}{sum($a,$b)}
+2 + 3
 
-### 1. Pattern Blocks
+```
 
-Patterns rewrite text using a match → replacement structure:
+Output:
 
 ```
-pattern { MATCH } { REPLACEMENT }
+
+sum(2,3)
+
 ```
 
-Patterns are collected once per iteration and applied globally.
+---
+
+## 1.5 Special substitutions in REPLACE
+
+- `$pre` — text before the match
+- `$post` — text after the match
+- `$match` — the raw matched content
+- `$unique` — generates unique identifiers
+- `$eval{JS}` — executes JavaScript and substitutes the return value
 
 Example:
 
 ```
-pattern {hello} {hi}
-hello world
+
+pattern{calc $num}{value=$eval{return $num*2;} }
+calc 21
+
 ```
 
 Output:
 
 ```
-hi world
+
+value=42
+
 ```
 
-#### Variables
+---
+
+## 1.6 Clearing the content with `$clear`
 
-Variables use the configured **sigil** (default `$`).
+If `$clear` appears in REPLACE, the entire current text is replaced with the latest result.
 
 ```
-pattern {say $x} {[$x]}
-say hello
+
+pattern{reset}{RESULT$clear}
+x y z reset aaa
+
 ```
 
-→ `[hello]`
+Output:
 
-#### Balanced Block Variables
+```
 
-Papagaio supports deep matching of balanced blocks:
+RESULT
 
 ```
-pattern {($x)} {[BLOCK:$x]}
-(do something)
+
+---
+
+## 1.7 Recursive patterns
+
+Papagaio applies patterns until text stabilizes:
+
 ```
 
-→ `[BLOCK:do something]`
+pattern{a}{b}
+pattern{b}{c}
+pattern{c}{stop}
+a
 
-#### Spread Variables
+```
 
-Spread variables capture until a terminating token:
+Output:
 
 ```
-pattern {from $x...to} {$x}
-from A B C to
+
+stop
+
 ```
 
-→ `A B C`
+---
 
-#### Metavariables
+# 2. Context
 
-Papagaio provides special `$keywords` inside replacements:
+Blocks `context{}` process their content recursively.
 
-| Variable  | Meaning                                    |
-| --------- | ------------------------------------------ |
-| `$match`  | Full matched text                          |
-| `$pre`    | Text before match                          |
-| `$post`   | Text after match                           |
-| `$unique` | Auto‑increment unique token                |
-| `$$`      | Whitespace wildcard in patterns            |
-| `$clear`  | Triggers clear‑rewrite of last replacement |
+```
 
-Example:
+context{
+pattern{Hi $x}{Hello $x}
+Hi Alice
+}
+
+```
+
+Output:
 
 ```
-pattern {x} {$pre[${unique}]$post}
-abcxdef
+
+Hello Alice
+
 ```
 
 ---
 
-### 2. Macro Blocks
+## 2.1 Empty context
+
+```
+
+before context{} after
+
+```
 
-Macros behave like simple template functions.
+Output:
 
 ```
-macro name { BODY }
-name(arg1, arg2)
+
+before  after
+
 ```
 
-Example:
+---
+
+## 2.2 Nested contexts
 
 ```
-macro wrap {[$1][$2]}
-wrap(a, b)
+
+context{
+pattern{X}{$unique}
+context{
+X
+X
+}
+}
+
 ```
 
-→ `[a][b]`
+Generates two different unique IDs.
 
-#### Argument Mapping
+---
 
-Arguments map to `$1`, `$2`, … automatically. `$0` expands to the macro name.
+## 2.3 Sandbox behavior
 
-Example:
+Patterns defined inside a context do not affect outer text.
 
 ```
-macro tag {<$0 $1>}  
-tag(title)
+
+context{
+pattern{A}{1}
+A
+}
+A
+
+```
+
+Output:
+
 ```
 
-→ `<tag title>`
+1
+A
+
+```
 
 ---
 
-### 3. Eval Blocks
+# 3. Custom delimiters
 
-Executes embedded JavaScript and returns the result as a string.
+`delimiters` define block boundaries. Defaults: `{}`, `[]`, `()`.
+
+You can change them at runtime:
 
 ```
-eval { return 3 + 7 }
+
+pap.delimiters = [["<", ">"], ["{", "}"]];
+
 ```
 
-→ `10`
+### Example: XML-style parsing
 
-Eval executes inside a strict IIFE.
+```
 
-You may access:
+pap.delimiters = [["<", ">"]];
 
-* `papagaio` → the processor instance
-* `ctx` → an empty object for temporary state
+pattern{<tag $x>}{TAG=$x} <tag content>
 
-Example:
+```
+
+Output:
+
+```
+
+TAG=content
+
+```
+
+---
+
+# 4. Custom sigil
+
+Default: `$`. Can be changed:
+
+```
+
+pap.sigil = "@";
+pattern{hello @x}{H=@x}
+hello world
+
+```
+
+Output:
+
+```
+
+H=world
+
+```
+
+---
+
+# 5. Custom keywords
+
+`pattern` and `context` words can be redefined:
+
+```
+
+pap.keywords.pattern = "macro";
+pap.keywords.context = "scope";
+
+```
+```
+
+macro{Hello $x}{Hi $x}
+Hello World
+
+```
+
+Output:
+
+```
+
+Hi World
+
+```
+
+---
+
+# 6. Advanced hacks
+
+## 6.1 Dynamic delimiter changes mid-process
+
+```
+
+pattern{setdelim}{$eval{ pap.delimiters=[["<",">"]]; return "";} }
+setdelim <hello>
+
+```
+
+---
+
+## 6.2 Custom syntax macros
+
+```
+
+pap.keywords.pattern = "::";
+pap.sigil = "%";
+
+::{hello %x}{HELLO %x}
+hello world
+
+```
+
+Output:
+
+```
+
+HELLO world
+
+```
+
+---
+
+## 6.3 Mini DSL creation
+
+```
+
+pattern{IF $cond THEN $body}{if ($cond) { $body }}
+pattern{PRINT $x}{console.log($x)}
+
+IF x > 10 THEN PRINT x
+
+```
+
+---
+
+## 6.4 Template engine
+
+```
+
+pattern{{{$var}}}{$var}
+Hello {{{$user}}}
+
+```
+
+---
+
+## 6.5 Multiline captures
+
+```
+
+pattern{BEGIN $x...END}{[$x]}
+BEGIN
+multi
+line
+text
+END
+
+```
+
+---
+
+## 6.6 $pre and $post example
+
+```
+
+pattern{<$x>}{($pre|$x|$post)}
+A <mid> B
 
 ```
-pattern {sum $a $b} {eval { return Number($a) + Number($b) }}
-sum 2 8
+
+Output:
+
+```
+
+A (A | mid |  B) B
+
 ```
 
-→ `10`
+---
+
+## 6.7 Full rewrite via $clear
+
+```
+
+pattern{main}{program initialized$clear}
+xxx main yyy
+
+```
 
 ---
 
-### 4. Scope Blocks
+# 7. Depth-isolated patterns
 
-Scope blocks create isolated processing regions using the same pipeline.
+Inner patterns are ignored until outer patterns resolve:
 
 ```
-scope {
-    pattern {x} {y}
-    x x x
+
+pattern{A}{1}
+pattern{
+B
+}{
+context{
+pattern{C}{2}
+C
+}
 }
+B
+
+```
+
+---
+
+# 8. Complete Examples
+
+### Example 1: Components DSL
+
 ```
 
-→ `y y y`
+pattern{component $name { $body...} }
+{
+function $name(){return `$body`;}
+}
 
-Scopes do not leak macros or patterns to the outside.
+component Button { <button>click</button>
+}
+
+Button
+
+```
 
 ---
 
-## Delimiters
+### Example 2: Sequential expansion with $unique
+
+```
+
+pattern{ID}{id_$unique}
+X: ID, Y: ID, Z: ID
 
-Papagaio supports configurable opening/closing pairs.
+```
+
+---
+
+### Example 3: Markdown preprocessor
 
-```js
-p.delimiters = [["{", "}"], ["(", ")"]];
 ```
 
-Balanced variable matching works across all registered delimiter pairs.
+pattern{# $t}{<h1>$t</h1>}
+pattern{## $t}{<h2>$t</h2>}
+
+# Title
+
+## Subtitle
+
+```
 
 ---
 
-## Recursion Model
+### Example 4: Embedded interpreter
+
+```
 
-Papagaio runs a fixed‑point loop:
+pattern{calc $x + $y}{ $eval{return Number($x)+Number($y);} }
+calc 2 + 5
 
-1. Process scopes
-2. Process eval blocks
-3. Collect macros
-4. Collect top‑level patterns
-5. Apply patterns
-6. Expand macros
+```
 
-If any Papagaio keyword remains in the output, it repeats.
+---
 
-You can configure the iteration cap:
+### Example 5: Selective removal with context
+
+```
+
+context{
+pattern{debug $x}{}
+debug remove this
+}
+debug keep
+
+```
+
+Output:
+
+```
+
+debug keep
 
-```js
-p.maxRecursion = 256;
 ```
 
 ---
 
-## Error Handling
+# 9. Public properties
 
-Eval blocks are wrapped in a try/catch. Exceptions produce empty output.
+- `maxRecursion`
+- `delimiters`
+- `sigil`
+- `keywords.pattern`
+- `keywords.context`
+- `content`
 
-Pattern/macro recursion halts upon reaching `maxRecursion`.
+All mutable at runtime.
 
 ---
 
-## Advanced Examples
+# 10. Summary
+
+Papagaio is a powerful text transformation engine. By combining recursive patterns, isolated contexts, configurable sigils, mutable delimiters, and `$eval`, you can build full DSLs, templating engines, mini-transpilers, or entirely new macro systems directly within text.
+
+Perfect. Let’s expand the README with **advanced topics** that push Papagaio into full meta-programming territory. I’ll add new sections on **self-modifying patterns, hybrid pipelines, self-referential patterns, Lisp-style macros, and advanced transpiler flows**. Everything stays text-focused; JavaScript API calls remain just `process(text)`.
+
+---
+
+# 11. Self-Modifying Patterns
+
+Papagaio patterns can modify themselves or other patterns at runtime using `$eval` and `$unique`. This allows dynamic generation of rules inside the same preprocessing pass.
 
-### Nested Macros
+### Example: generating numbered variables
 
 ```
-macro A {($1)}
-macro B {A($1)}
-B(hello)
+
+pattern{define $x}{pattern{$x}{$x_$unique}}
+define foo
+foo
+foo
+
 ```
 
-→ `(hello)`
+Output:
+
+```
 
-### Dynamic Rewriting with `$unique`
+foo_u0
+foo_u1
 
 ```
-pattern {node} {id_$unique}
-node node node
+
+The first line defines a new pattern dynamically; subsequent uses expand into unique identifiers.
+
+---
+
+# 12. Hybrid Parsing Pipelines
+
+You can combine multiple processing passes with different delimiters, sigils, and keywords.
+
+### Example: XML and Markdown pipeline
+
 ```
 
-→ `id_0 id_1 id_2`
+pap.delimiters = [["<", ">"], ["{", "}"]];
+pap.sigil = "$";
 
-### Working with Pre/Post Context
+pattern{<bold $x>}{**$x**}
+pattern{# $t}{<h1>$t</h1>}
 
 ```
-pattern {x} {$pre|X|$post}
-a x b
+
+Text:
+
 ```
 
-→ `a |X| b`
+# Title
+
+<bold text>
+```
 
-### Spread Matching
+Output:
 
 ```
-pattern {let $name = $v...;} {[decl $name $v]}
-let x = 1 + 2 + 3;
+<h1>Title</h1>
+**text**
 ```
 
-→ `[decl x 1 + 2 + 3]`
+This allows building multi-layer pre-processing pipelines where each pass targets different syntax conventions.
 
 ---
 
-## API Reference
+# 13. Self-Referential Patterns
 
-### Class: `Papagaio`
+Patterns can reference themselves or other patterns recursively.
 
-#### `process(input: string): string`
+### Example: expanding repeated lists
 
-Runs the full pipeline and returns the transformed text.
+```
+pattern{LIST $x}{ITEM $x LIST $x}
+pattern{LIST $x}{ITEM $x}
+LIST A
+```
 
-#### `delimiters: Array<[string, string]>`
+Output:
 
-List of opening/closing delimiter pairs.
+```
+ITEM A
+```
 
-#### `sigil: string`
+Patterns resolve recursively until the text stabilizes. Use `maxRecursion` to prevent infinite loops.
 
-Variable prefix. Default `$`.
+---
 
-#### `keywords`
+# 14. Lisp-Style Macro Systems
 
-Keyword configuration:
+Papagaio can emulate a Lisp-like macro expansion engine using contexts and dynamic patterns.
 
-* `pattern`
-* `macro`
-* `eval`
-* `scope`
+### Example: defining macros inside contexts
 
-#### Internal State
+```
+context{
+  pattern{defmacro $name { $body... }}{pattern{$name}{$body}}
+  defmacro greet {Hello $1}
+  greet John
+}
+```
+
+Output:
 
-For debugging only:
+```
+Hello John
+```
 
-* `content` → latest processed text
-* `#matchContent`
-* `#scopeContent`
-* `#evalContent`
+Inside a `context`, macro definitions are local and can create arbitrary code expansions dynamically.
 
 ---
 
-## Embedding
+# 15. Advanced Transpiler Flows
 
-Papagaio is pure JS and safe to embed in build pipelines, CLIs, game engines, or runtime scripting layers.
+Papagaio can be used to build mini-transpilers by chaining pattern expansions and contexts.
 
-Example minimal CLI wrapper:
+### Example: pseudo-language to JavaScript
 
-```js
-#!/usr/bin/env node
-const fs = require("fs");
-const { Papagaio } = require("./papagaio");
+```
+context{
+  pattern{PRINT $x}{console.log($x);}
+  pattern{IF $cond THEN $body}{if ($cond) { $body }}
+  PRINT 42
+  IF x > 10 THEN PRINT x
+}
+```
+
+Output:
 
-const input = fs.readFileSync(0, "utf8");
-const out = new Papagaio().process(input);
-process.stdout.write(out);
 ```
+console.log(42);
+if (x > 10) { console.log(x); }
+```
+
+You can extend this by defining multiple layers of contexts, dynamically switching delimiters, or even generating patterns on the fly.
+
+---
+
+# 16. Dynamic Runtime Hacks
+
+### 16.1 Change delimiters mid-process
+
+```
+pattern{switch}{ $eval{ pap.delimiters=[["<",">"]]; return ""; } }
+switch
+<hello>
+```
+
+Output:
+
+```
+hello
+```
+
+### 16.2 Dynamic sigil change
+
+```
+pattern{sigil}{ $eval{ pap.sigil="@"; return ""; } }
+sigil
+@var
+```
+
+Output:
+
+```
+var
+```
+
+### 16.3 Keywords swapping
+
+```
+pattern{switch_keywords}{ $eval{ pap.keywords.pattern="macro"; pap.keywords.context="scope"; return ""; } }
+switch_keywords
+macro{X}{Y}
+```
+
+Output:
+
+```
+Y
+```
+
+---
+
+# 17. Meta-Programming Examples
+
+* **Dynamic template engines**: generate arbitrary nested templates inside contexts.
+* **Self-expanding DSLs**: macros that define other macros.
+* **Text-based code generation**: precompile repetitive boilerplate using `$unique` and `$eval`.
+* **Hybrid syntaxes**: combine HTML, Markdown, custom DSL, and other syntaxes in a single pipeline.
+* **Sandboxed rule execution**: define rules inside a context that never leak to the global scope.
+
+---
+
+# 18. Practical Guidelines
+
+* Use `$eval` carefully; errors will produce empty output.
+* `$unique` is essential for safe auto-generated identifiers.
+* `maxRecursion` prevents infinite loops with recursive or self-referential patterns.
+* Contexts act like local scopes for patterns; define macros or temporary rules inside them.
+* Delimiters and sigils can be swapped mid-processing for DSL adaptation.
+* Always trim input to avoid unintended whitespace captures with `...` patterns.
+
+---
+
+# 19. Summary
+
+With self-modifying patterns, hybrid pipelines, recursive expansions, Lisp-style macros, and dynamic runtime hacks, Papagaio is a **full meta-programming framework** entirely based on text. You can:
+
+* Build DSLs
+* Create macro engines
+* Implement templating pipelines
+* Write mini-transpilers
+* Automate complex text generation
+
+Everything is declarative in the text, and runtime manipulation of delimiters, sigils, and keywords allows infinite flexibility.
 
 ---

package/cli.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 import { Papagaio } from "./papagaio.js";
 import fs from "fs";
-import pkg from "./package.json" assert { type: "json" };
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const pkg = require("./package.json");
+
 
 // Help & Version
 const args = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papagaio",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "easy yet powerful preprocessor",
   "main": "papagaio.js",
   "type": "module",
@@ -13,7 +13,6 @@
     "macro",
     "pattern",
     "eval",
-    "isolate",
     "parser"
   ],
   "author": "jardimdanificado",

package/papagaio.js

@@ -9,20 +9,19 @@ export class Papagaio {
     #counterState = { value: 0, unique: 0 };
     
     // Public configuration
-    delimiters = [["{", "}"]];
+    delimiters = [
+        ["{", "}"],
+        ["[", "]"],
+        ["(", ")"],
+    ];
     sigil = "$";
     keywords = {
         pattern: "pattern",
-        macro: "macro", 
-        eval: "eval",
-        scope: "scope"
+        context: "context"
     };
     
     // Public state - processing state
     content = "";
-    #matchContent = "";
-    #scopeContent = "";
-    #evalContent = "";
 
     constructor() {
         this.#resetCounterState();
@@ -44,14 +43,10 @@ export class Papagaio {
 
         // regex para detectar blocos papagaio remanescentes
         const pending = () => {
-            const rEval    = new RegExp(`\\b${this.keywords.eval}\\s*\\${open}`, "g");
-            const rScope   = new RegExp(`\\b${this.keywords.scope}\\s*\\${open}`, "g");
+            const rContext   = new RegExp(`\\b${this.keywords.context}\\s*\\${open}`, "g");
             const rPattern = new RegExp(`\\b${this.keywords.pattern}\\s*\\${open}`, "g");
-            const rMacro   = new RegExp(`\\b${this.keywords.macro}\\s+[A-Za-z_][A-Za-z0-9_]*\\s*\\${open}`, "g");
-            return rEval.test(src)
-                || rScope.test(src)
+            return rContext.test(src)
                 || rPattern.test(src)
-                || rMacro.test(src);
         };
 
         // fixpoint loop
@@ -60,17 +55,12 @@ export class Papagaio {
             last = src;
 
             // --- pipeline padrão ---
-            src = this.#processScopeBlocks(src);
-            src = this.#processEvalBlocks(src);
-
-            const [macros, s1] = this.#collectMacros(src);
-            src = s1;
+            src = this.#processContextBlocks(src);
 
             const [patterns, s2] = this.#collectPatterns(src);
             src = s2;
 
             src = this.#applyPatterns(src, patterns);
-            src = this.#expandMacros(src, macros);
 
             // --- se sobrou bloco papagaio → roda de novo ---
             if (!pending()) break;
@@ -323,35 +313,6 @@ export class Papagaio {
         return vars;
     }
 
-    #collectMacros(src) {
-        const macros = {};
-        const open = this.#getDefaultOpen();
-        const macroRegex = new RegExp(`\\b${this.keywords.macro}\\s+([A-Za-z_][A-Za-z0-9_]*)\\s*\\${open}`, "g");
-
-        let match;
-        const matches = [];
-
-        while ((match = macroRegex.exec(src)) !== null) {
-            matches.push({
-                name: match[1],
-                matchStart: match.index,
-                openPos: match.index + match[0].length - 1
-            });
-        }
-
-        for (let j = matches.length - 1; j >= 0; j--) {
-            const m = matches[j];
-            const [body, posAfter] = this.#extractBlock(src, m.openPos);
-            macros[m.name] = body;
-
-            let left = src.substring(0, m.matchStart);
-            let right = src.substring(posAfter);
-            src = this.#collapseLocalNewlines(left, right);
-        }
-
-        return [macros, src];
-    }
-
     #patternDepthAt(src, pos) {
         const open = this.keywords.pattern;
         let depth = 0;
@@ -465,8 +426,6 @@ export class Papagaio {
                         varMap[varNames[i]] = captures[i] || '';
                     }
 
-                    this.#matchContent = fullMatch;
-
                     const _pre = src.slice(0, matchStart);
                     const _post = src.slice(matchEnd);
 
@@ -481,6 +440,20 @@ export class Papagaio {
                         () => this.#genUnique()
                     );
 
+                    result = result.replace(/\$eval\{([^}]*)\}/g, (_, code) => {
+                        try {
+                            // O conteúdo é o corpo de uma função autoinvocada
+                            const wrappedCode = `"use strict"; return (function() { ${code} })();`;
+
+                            let out = String(
+                                Function("papagaio", "ctx", wrappedCode)(this, {})
+                            );
+                            return out;
+                        } catch {
+                            return "";
+                        }
+                    });
+
                     const S2 = S + S;
                     result = result.replace(new RegExp(this.#escapeRegex(S2), 'g'), '');
 
@@ -510,83 +483,18 @@ export class Papagaio {
         return src;
     }
 
-    #expandMacros(src, macros) {
-        const S = this.sigil;
-
-        for (const name of Object.keys(macros)) {
-            const body = macros[name];
-            let changed = true;
-            let iterations = 0;
-
-            while (changed && iterations < this.maxRecursion) {
-                changed = false;
-                iterations++;
-
-                const callRegex = new RegExp(`\\b${this.#escapeRegex(name)}\\s*\\(`, 'g');
-                
-                let match;
-                const matches = [];
-
-                while ((match = callRegex.exec(src)) !== null) {
-                    matches.push({
-                        matchStart: match.index,
-                        openPos: match.index + match[0].length - 1
-                    });
-                }
-
-                for (let j = matches.length - 1; j >= 0; j--) {
-                    const m = matches[j];
-                    const [argsStr, posAfter] = this.#extractBlock(src, m.openPos, '(', ')');
-                    const vals = argsStr.split(',').map(v => v.trim());
-
-                    let exp = body;
-
-                    // Substituição flexível de $0, $1, $2 etc, mesmo dentro de palavras
-                    for (let k = vals.length; k >= 0; k--) {
-                        const sigil = k === 0 ? S + '0' : S + k;
-                        const pattern = new RegExp(this.#escapeRegex(sigil) + '(?![0-9])', 'g');
-                        const replacement = k === 0 ? name : (vals[k - 1] !== undefined ? vals[k - 1] : '');
-                        exp = exp.replace(pattern, replacement);
-                    }
-
-                    let left = src.substring(0, m.matchStart);
-                    let right = src.substring(posAfter);
-                    src = left + exp + right;
-                    changed = true;
-                }
-            }
-        }
-
-        return src;
-    }
-
     #escapeRegex(str) {
         return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
 
-    #collapseLocalNewlines(left, right) {
-        left = left.replace(/\n+$/, '\n');
-        right = right.replace(/^\n+/, '\n');
-
-        if (left.endsWith('\n') && right.startsWith('\n')) {
-            right = right.replace(/^\n+/, '\n');
-        }
-
-        if (left === '' && right.startsWith('\n')) {
-            right = right.replace(/^\n+/, '');
-        }
-
-        return left + right;
-    }
-
-    #processEvalBlocks(src) {
+    #processContextBlocks(src) {
         const open = this.#getDefaultOpen();
-        const evalRegex = new RegExp(`\\b${this.keywords.eval}\\s*\\${open}`, "g");
+        const contextRegex = new RegExp(`\\b${this.keywords.context}\\s*\\${open}`, "g");
 
         let match;
         const matches = [];
 
-        while ((match = evalRegex.exec(src)) !== null) {
+        while ((match = contextRegex.exec(src)) !== null) {
             matches.push({
                 matchStart: match.index,
                 openPos: match.index + match[0].length - 1
@@ -595,49 +503,14 @@ export class Papagaio {
 
         for (let j = matches.length - 1; j >= 0; j--) {
             const m = matches[j];
-
             const [content, posAfter] = this.#extractBlock(src, m.openPos);
-            this.#evalContent = content;
-
-            let out = "";
-            try {
-                // O conteúdo é o corpo de uma função autoinvocada
-                const wrappedCode = `"use strict"; return (function() { ${content} })();`;
-
-                out = String(
-                    Function("papagaio", "ctx", wrappedCode)(this, {})
-                );
-            } catch (e) {
-                out = "";
-            }
 
-            let left = src.substring(0, m.matchStart);
-            let right = src.substring(posAfter);
-            src = left + out + right;
-        }
-
-        return src;
-    }
-
-    #processScopeBlocks(src) {
-        const open = this.#getDefaultOpen();
-        const scopeRegex = new RegExp(`\\b${this.keywords.scope}\\s*\\${open}`, "g");
-
-        let match;
-        const matches = [];
-
-        while ((match = scopeRegex.exec(src)) !== null) {
-            matches.push({
-                matchStart: match.index,
-                openPos: match.index + match[0].length - 1
-            });
-        }
-
-        for (let j = matches.length - 1; j >= 0; j--) {
-            const m = matches[j];
-            const [content, posAfter] = this.#extractBlock(src, m.openPos);
+            if (!content.trim()) {
+                // Contexto vazio → apenas remove a palavra "context" mas mantém o resto intacto
+                src = src.slice(0, m.matchStart) + src.slice(posAfter);
+                continue;
+            }
 
-            this.#scopeContent = content;
             const processedContent = this.process(content);
 
             let left = src.substring(0, m.matchStart);
@@ -654,6 +527,4 @@ export class Papagaio {
 
         return src;
     }
-
-
-}
+}