npm - papagaio - Versions diffs - 0.6.2 → 0.7.1 - Mend

papagaio 0.6.2 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -22,8 +22,9 @@ papagaio.symbols = {
   close: "}",              // closing delimiter (multi-char supported)
   sigil: "$",              // variable marker
   eval: "eval",            // eval keyword
-  block: "block",          // block keyword
-  regex: "regex"           // regex keyword
+  block: "recursive",      // block keyword (recursive nesting)
+  regex: "regex",          // regex keyword
+  blockseq: "sequential"   // blockseq keyword (sequential blocks)
 };
 ```
@@ -64,7 +65,7 @@ hello world
 Output: `[hello] [world]`
 ```
-$pattern {$name $block content {(}{)}} {$name: $content}
+$pattern {$name ${(}{)}content} {$name: $content}
 greeting (hello world)
 ```
 Output: `greeting: hello world`
@@ -126,48 +127,104 @@ Output: `Month 03 in 2024`
 ## Blocks
-Capture content between delimiters with full nesting support.
+Papagaio supports two types of block capture: **nested** and **adjacent**.
-### Syntax
+### Nested Blocks - `${open}{close}varName`
+Captures content between delimiters with full nesting support. Nested delimiters are handled recursively.
+#### Basic Syntax
 ```
-$block varName {open}{close}
+${opening_delimiter}{closing_delimiter}varName
 ```
-### Basic Example
+#### Examples
+**Basic Recursive Block:**
 ```
-$pattern {$name $block content {(}{)}} {[$content]}
+$pattern {$name ${(}{)}content} {[$content]}
 data (hello world)
 ```
 Output: `[hello world]`
-### Custom Delimiters
+**Custom Delimiters:**
 ```
-$pattern {$block data {<<}{>>}} {DATA: $data}
+$pattern {${<<}{>>}data} {DATA: $data}
 <<json stuff>>
 ```
 Output: `DATA: json stuff`
-### Multi-Character Delimiters
+**Multi-Character Delimiters:**
 ```
-$pattern {$block code {```}{```}} {<pre>$code</pre>}
+$pattern {${```}{```}code} {<pre>$code</pre>}
 ```markdown
 # Title
 ```
 Output: `<pre># Title</pre>`
-### Multiple Blocks
+**Default Delimiters (empty blocks):**
+```
+$pattern {${}{}data} {[$data]}
+{hello world}
+```
+Output: `[hello world]`
+*(Uses default `{` and `}` when delimiters are empty)*
+**Nested Blocks:**
+```
+$pattern {${(}{)}outer} {[$outer]}
+(outer (inner (deep)))
+```
+Output: `[outer (inner (deep))]`
+### Adjancent Blocks - `$${open}{close}varName`
+Captures multiple adjacent blocks with the same delimiters and concatenates their content (separated by spaces).
+#### Basic Syntax
 ```
-$pattern {$block a {(}{)}, $block b {[}{]}} {$a|$b}
-(first), [second]
+$${opening_delimiter}{closing_delimiter}varName
 ```
-Output: `first|second`
-### Nested Blocks
+#### Examples
+**Basic Adjacent Block:**
+```
+$pattern {$${[}{]}items} {Items: $items}
+[first][second][third]
+```
+Output: `Items: first second third`
+**Adjacent with Custom Delimiters:**
+```
+$pattern {$${<}{>}tags} {Tags: $tags}
+<html><body><div>
+```
+Output: `Tags: html body div`
+**Default Delimiters:**
 ```
-$pattern {$block outer {(}{)}} {[$outer]}
-(outer (inner))
+$pattern {$${}{}data} {Result: $data}
+{a}{b}{c}
 ```
-Output: `[outer (inner)]`
+Output: `Result: a b c`
+**Mixed Usage:**
+```
+$pattern {${(}{)}nested, $${[}{]}seq} {Nested: $nested | Seq: $seq}
+(a (b c)), [x][y][z]
+```
+Output: `Nested: a (b c) | Seq: x y z`
+### Block Comparison
+| Feature | Nested `${}{}var` | Adjacent `$${}{}var` |
+|---------|---------------------|------------------------|
+| Purpose | Capture nested content | Capture adjacent blocks |
+| Input | `[a [b [c]]]` | `[a][b][c]` |
+| Output | `a [b [c]]` | `a b c` |
+| Nesting | Handled recursively | Not nested, sequential |
+| Spacing | Preserves internal structure | Joins with spaces |
 ---
@@ -274,17 +331,18 @@ Output: `10`
 * Variables automatically skip leading whitespace
 * Trailing whitespace is trimmed when variables appear before literals
+### Block Matching
+* `${open}{close}name` = nested block capture
+* `$${open}{close}name` = adjacent block capture (captures adjacent blocks)
+* Supports multi-character delimiters of any length
+* Empty delimiters `${}{}name` or `$${}{}name` use defaults from `symbols.open` and `symbols.close`
+* Sequential blocks are joined with spaces in the captured variable
 ### 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., `{>>>}{<<<}`)
-* Blocks support arbitrary nesting depth
 ---
 ## Multi-Character Delimiter Support
@@ -305,7 +363,7 @@ Output: `[hello]`
 ### In Blocks
 ```
-$pattern<<<$block data {<<}{>>}>>> <<<$data>>>
+$pattern<<<${<<}{>>}data>>> <<<$data>>>
 <<content>>
 ```
 Output: `content`
@@ -341,6 +399,27 @@ p.process(template);
 // <strong>bold text</strong>
 ```
+### Array/List Processor
+```javascript
+const p = new Papagaio();
+const template = `
+$pattern {$${[}{]}items} {
+  $eval{
+    const arr = '$items'.split(' ');
+    return arr.map((x, i) => \`\${i + 1}. \${x}\`).join('\\n');
+  }
+}
+[apple][banana][cherry]
+`;
+p.process(template);
+// Output:
+// 1. apple
+// 2. banana
+// 3. cherry
+```
 ### Template System with State
 ```javascript
 const p = new Papagaio();
@@ -371,7 +450,7 @@ p.process(template);
 ```javascript
 const p = new Papagaio();
 const template = `
-$pattern {if $block cond {(}{)} then $block yes {[}{]} else $block no {<}{>}} {
+$pattern {if ${(}{)}cond then ${[}{]}yes else ${<}{>}no} {
   $eval{
     const condition = ($cond).trim();
     return condition === 'true' ? '$yes' : '$no';
@@ -407,6 +486,24 @@ p.process(template);
 // 18
 ```
+### Sequential Block Processing
+```javascript
+const p = new Papagaio();
+const template = `
+$pattern {sum $${[}{]}nums} {
+  $eval{
+    const numbers = '$nums'.split(' ').map(x => parseInt(x));
+    return numbers.reduce((a, b) => a + b, 0);
+  }
+}
+sum [10][20][30][40]
+`;
+p.process(template);
+// Output: 100
+```
 ---
 ## Troubleshooting
@@ -421,6 +518,7 @@ p.process(template);
 | 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 |
+| Empty delimiter behavior | `${}{}x` uses defaults; explicitly set if you need different behavior |
 ---
@@ -430,7 +528,9 @@ p.process(template);
 $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
+$pattern {${o}{c}n} {$n}             # recursive block (nested)
+$pattern {$${o}{c}n} {$n}            # sequential block (adjacent)
+$pattern {${}{}n} {$n}               # block with default delimiters
 $eval{code}                          # JavaScript evaluation
 ```
@@ -440,7 +540,7 @@ $eval{code}                          # JavaScript evaluation
 ### Constructor
 ```javascript
-new Papagaio(sigil, open, close, pattern, evalKw, blockKw, regexKw)
+new Papagaio(sigil, open, close, pattern, evalKw, blockKw, regexKw, blockseqKw)
 ```
 **Parameters:**
@@ -449,7 +549,6 @@ new Papagaio(sigil, open, close, pattern, evalKw, blockKw, regexKw)
 - `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
@@ -475,6 +574,7 @@ p.process('$pattern {x} {y}\nx');
 ## Performance Notes
 * Multi-character delimiter matching is optimized with substring operations
+* Sequential blocks scan for adjacent matches without recursion overhead
 * 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

package/examples/simple.html CHANGED Viewed

@@ -7,7 +7,7 @@
 </head>
 <script src="../src/papagaio-bootstrap.mjs" type="module"></script>
 <script type="papagaio">
-    $pattern {abc} {$eval{console.log(papagaio)} aaaaaaaaaaaaaaaaaaaaaaaaaaaa}
+    $pattern {abc} {$eval{console.log(this)} aaaaaaaaaaaaaaaaaaaaaaaaaaaa}
     abc
 </script>
 <body>

package/examples/wasm.papagaio CHANGED Viewed

@@ -13,7 +13,7 @@ $eval{
     return ""
 }
-$pattern {export function $name $block params{(}{)}:$rets $block content{}{}} {
+$pattern {export function $name ${(}{)}params:$rets ${}{}content} {
     $pattern {parametrize}
     {
         $eval {
@@ -36,7 +36,7 @@ $pattern {export function $name $block params{(}{)}:$rets $block content{}{}} {
     )
 }
-$pattern {function $name $block params{(}{)}:$rets $block content{}{}} {
+$pattern {function $name ${}{}params{(}{)}:$rets ${}{}content} {
     $pattern {parametrize}
     {
         $eval {

package/mobile.html ADDED Viewed

@@ -0,0 +1,209 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <title>🦜 papagaio</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            -webkit-tap-highlight-color: transparent;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #fff;
+            color: #000;
+            overflow: hidden;
+        }
+        .app {
+            max-width: 100%;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+        .header {
+            background: #fff;
+            padding: 24px 20px;
+            text-align: center;
+            border-bottom: 1px solid #ddd;
+        }
+        .header h1 {
+            font-size: 2rem;
+            color: #000;
+            margin-bottom: 4px;
+        }
+        .header p {
+            font-size: 0.9rem;
+            color: #666;
+        }
+        .tabs {
+            display: flex;
+            background: #fff;
+            border-bottom: 1px solid #ddd;
+        }
+        .tab {
+            flex: 1;
+            padding: 18px;
+            text-align: center;
+            font-size: 1rem;
+            font-weight: 500;
+            background: #f5f5f5;
+            border: none;
+            cursor: pointer;
+            transition: all 0.2s;
+            color: #666;
+            border-right: 1px solid #ddd;
+        }
+        .tab:last-child {
+            border-right: none;
+        }
+        .tab.active {
+            background: #fff;
+            color: #000;
+            border-bottom: 2px solid #000;
+        }
+        .content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+        .editor-container {
+            display: none;
+            flex-direction: column;
+            flex: 1;
+        }
+        .editor-container.active {
+            display: flex;
+        }
+        textarea {
+            flex: 1;
+            padding: 20px;
+            border: none;
+            font-family:
+                ui-monospace,
+                SFMono-Regular,
+                Menlo,
+                Consolas,
+                "Liberation Mono",
+                monospace;
+            font-size: 15px;
+            line-height: 1.55;
+            font-weight: 500;
+            letter-spacing: 0.2px;
+            resize: none;
+            background: #fff;
+            color: #000;
+            white-space: pre;
+            overflow-x: auto;
+            overflow-y: auto;
+            word-break: normal;
+        }
+        textarea:focus {
+            outline: none;
+        }
+        #output {
+            background: #fafafa;
+        }
+        @media (min-width: 768px) {
+            .app {
+                max-width: 600px;
+                margin: 0 auto;
+                border-left: 1px solid #ddd;
+                border-right: 1px solid #ddd;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="app">
+        <div class="header">
+            <h1>🦜 papagaio</h1>
+            <p>easy yet powerful text preprocessor</p>
+        </div>
+        <div class="tabs">
+            <button class="tab active" onclick="switchTab('input')">INPUT</button>
+            <button class="tab" onclick="switchTab('output')">OUTPUT</button>
+        </div>
+        <div class="content">
+            <div class="editor-container active" id="inputContainer">
+                <textarea id="input"></textarea>
+            </div>
+            <div class="editor-container" id="outputContainer">
+                <textarea id="output" readonly></textarea>
+            </div>
+        </div>
+    </div>
+    <script type="module">
+        import { Papagaio } from './src/papagaio.js';
+        const processor = new Papagaio();
+        function loadSaved() {
+            try {
+                const saved = localStorage.getItem('papagaio_input');
+                if (saved) {
+                    document.getElementById('input').value = saved;
+                }
+            } catch {}
+        }
+        function saveInput() {
+            try {
+                const input = document.getElementById('input').value;
+                localStorage.setItem('papagaio_input', input);
+            } catch {}
+        }
+        function switchTab(tab) {
+            document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+            document.querySelectorAll('.editor-container').forEach(c => c.classList.remove('active'));
+            if (tab === 'input') {
+                document.querySelectorAll('.tab')[0].classList.add('active');
+                document.getElementById('inputContainer').classList.add('active');
+            } else {
+                document.querySelectorAll('.tab')[1].classList.add('active');
+                document.getElementById('outputContainer').classList.add('active');
+                processCode();
+            }
+        }
+        function processCode() {
+            try {
+                const input = document.getElementById('input').value;
+                const output = processor.process(input);
+                document.getElementById('output').value = output;
+                saveInput();
+            } catch (err) {
+                document.getElementById('output').value = `Error: ${err.message}`;
+            }
+        }
+        window.addEventListener('load', loadSaved);
+        setInterval(saveInput, 2000);
+        window.switchTab = switchTab;
+    </script>
+</body>
+</html>

package/package.json CHANGED Viewed

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

package/src/papagaio.js CHANGED Viewed

@@ -1,6 +1,6 @@
 // papagaio - https://github.com/jardimdanificado/papagaio
 function parsePattern(p, pat) {
-    const t = [], S = p.symbols.sigil, O = p.symbols.open;
+    const t = [], S = p.symbols.sigil, O = p.symbols.open, C = p.symbols.close;
     let i = 0;
     while (i < pat.length) {
         if (pat.startsWith(S + p.symbols.regex, i)) {
@@ -17,36 +17,30 @@ function parsePattern(p, pat) {
                 }
             }
         }
-        if (pat.startsWith(S + p.symbols.block, i)) {
-            let j = i + S.length + p.symbols.block.length;
-            while (j < pat.length && /\s/.test(pat[j])) j++;
-            let v = '';
-            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
-            if (v) {
-                while (j < pat.length && /\s/.test(pat[j])) j++;
-                let od = O, cd = p.symbols.close;
-                if (pat[j] === O) {
-                    const [c, e] = extractBlock(p, pat, j);
-                    od = unescapeDelim(c.trim()) || O;
-                    j = e; while (j < pat.length && /\s/.test(pat[j])) j++;
-                }
-                if (pat[j] === O) {
-                    const [c, e] = extractBlock(p, pat, j);
-                    cd = unescapeDelim(c.trim()) || cd;
-                    j = e;
+        if (pat[i] === S) {
+            let j = i + S.length;
+            const isDouble = pat[j] === S;
+            if (isDouble) j++;
+            if (pat[j] === O) {
+                const [od, e1] = extractBlock(p, pat, j);
+                if (pat[e1] === O) {
+                    const [cd, e2] = extractBlock(p, pat, e1);
+                    let v = '', k = e2;
+                    while (k < pat.length && /[A-Za-z0-9_]/.test(pat[k])) v += pat[k++];
+                    if (v) {
+                        t.push({ type: isDouble ? 'blockseq' : 'block', varName: v, open: unescapeDelim(od.trim()) || O, close: unescapeDelim(cd.trim()) || C });
+                        i = k; continue;
+                    }
                 }
-                t.push({ type: 'block', varName: v, open: od, close: cd });
-                i = j; continue;
             }
-        }
-        if (pat[i] === S) {
-            let j = i + S.length, v = '';
+            j = i + S.length;
+            let v = '';
             while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
-            if (v) {
+            if (v) {
                 const optional = pat[j] === '?';
                 if (optional) j++;
-                t.push({ type: 'var', varName: v, optional });
-                i = j; continue;
+                t.push({ type: 'var', varName: v, optional });
+                i = j; continue;
             }
             t.push({ type: 'lit', value: S }); i += S.length; continue;
         }
@@ -80,11 +74,9 @@ function matchPattern(p, src, tok, pos = 0) {
             while (pos < src.length && /\s/.test(src[pos])) pos++;
             const nx = findNext(tok, ti);
             let v = '';
-            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 && nx.type === 'lit') {
-                while (pos < src.length && !src.startsWith(nx.value, pos) && src[pos] !== '\n') v += src[pos++];
+            if (nx && (nx.type === 'block' || nx.type === 'lit')) {
+                const stop = nx.type === 'block' ? nx.open : nx.value;
+                while (pos < src.length && !src.startsWith(stop, pos) && src[pos] !== '\n') v += src[pos++];
                 v = v.trimEnd();
             } else {
                 while (pos < src.length && !/\s/.test(src[pos])) v += src[pos++];
@@ -93,6 +85,18 @@ function matchPattern(p, src, tok, pos = 0) {
             cap[p.symbols.sigil + t.varName] = v;
             continue;
         }
+        if (t.type === 'blockseq') {
+            let blocks = [];
+            while (pos < src.length && src.startsWith(t.open, pos)) {
+                const [c, e] = extractBlock(p, src, pos, t.open, t.close);
+                blocks.push(c);
+                pos = e;
+                while (pos < src.length && /\s/.test(src[pos])) pos++;
+            }
+            if (!blocks.length) return null;
+            cap[p.symbols.sigil + t.varName] = blocks.join(' ');
+            continue;
+        }
         if (t.type === 'block') {
             if (!src.startsWith(t.open, pos)) return null;
             const [c, e] = extractBlock(p, src, pos, t.open, t.close);
@@ -151,18 +155,15 @@ 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) {
-            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;
-                }
+        if (txt.substring(i, i + S.length) === S && txt.substring(i + S.length).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++;
@@ -174,10 +175,12 @@ function applyEvals(p, txt, ev) {
     let r = txt;
     for (let i = ev.length - 1; i >= 0; i--) {
         const ph = `__E${i}__`;
-        let res;
-        try { res = String(Function("papagaio", "ctx", `"use strict";return(function(){${ev[i].code}})();`)(p, {})); }
-        catch (e) { res = "error: " + e.message; }
-        r = r.replace(ph, res);
+        try {
+            r = r.replace(ph, String(
+                Function("ctx", `"use strict";${ev[i].code}`).call(p, {})
+            ));
+        }
+        catch (e) { r = r.replace(ph, "error: " + e.message); }
     }
     return r;
 }
@@ -219,8 +222,8 @@ function unescapeDelim(s) {
 }
 export class Papagaio {
-    constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'block', regexKw = 'regex') {
-        this.symbols = { pattern, open, close, sigil, eval: evalKw, block: blockKw, regex: regexKw };
+    constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'recursive', regexKw = 'regex', blockseqKw = 'sequential') {
+        this.symbols = { pattern, open, close, sigil, eval: evalKw, block: blockKw, regex: regexKw, blockseq: blockseqKw };
         this.content = "";
         this.match = "";
     }

package/tests/tests.json CHANGED Viewed

@@ -15,19 +15,19 @@
     {
       "id": 3,
       "name": "Block with custom delimiters",
-      "code": "$pattern {$block content {(}{)}} {[$content]}\ndata (hello world)",
+      "code": "$pattern {${(}{)}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 {${<<}{>>}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 {${<}{>}txt} {[$txt]}\nouter <middle <inner> content>",
       "expected": "outer [middle <inner> content]"
     },
     {
@@ -63,7 +63,7 @@
     {
       "id": 11,
       "name": "Multiple blocks in one pattern",
-      "code": "$pattern {$block a {(}{)} and $block b {[}{]}} {$a|$b}\n(first) and [second]",
+      "code": "$pattern {${(}{)}a  and ${[}{]}b} {$a|$b}\n(first) and [second]",
       "expected": "first|second"
     },
     {
@@ -87,7 +87,7 @@
     {
       "id": 15,
       "name": "Block with angle brackets",
-      "code": "$pattern {$block inner {<}{>}} {WRAPPED[$inner]}\n<content>",
+      "code": "$pattern {${<}{>}inner} {WRAPPED[$inner]}\n<content>",
       "expected": "WRAPPED[content]"
     },
     {
@@ -105,7 +105,7 @@
     {
       "id": 18,
       "name": "Block capturing with square brackets",
-      "code": "$pattern {$block arr {[}{]}} {ARRAY[$arr]}\n[1, 2, 3]",
+      "code": "$pattern {${[}{]}arr} {ARRAY[$arr]}\n[1, 2, 3]",
       "expected": "ARRAY[1, 2, 3]"
     },
     {
@@ -129,31 +129,31 @@
     {
       "id": 22,
       "name": "Block delimiter balancing - parentheses",
-      "code": "$pattern {$block code {(}{)}} {RESULT[$code]}\n(a (b (c) d) e)",
+      "code": "$pattern {${(}{)}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 {${<}{>}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 {${[}{]}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 {${}{}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 {${(}{)}a ${[}{]}b} {[$a|$b]}\n(test1) [test2]",
       "expected": "[test1|test2]"
     },
     {
@@ -165,25 +165,25 @@
     {
       "id": 28,
       "name": "Block with quotes as delimiters",
-      "code": "$pattern {$block str {\"}{\"}} {STRING[$str]}\n\"hello world\"",
+      "code": "$pattern {${\"}{\"}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 {${|}{|}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 {${<}{>}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]}\n$pattern {BLOCK $x} {RESULT: $x}\n(inner data)",
+      "code": "$pattern {${(}{)}content} {BLOCK [$content]}\n$pattern {BLOCK $x} {RESULT: $x}\n(inner data)",
       "expected": "RESULT: [inner data]"
     },
     {
@@ -195,13 +195,13 @@
     {
       "id": 33,
       "name": "Block delimiter edge case - empty content",
-      "code": "$pattern {$block empty {(}{)}} {EMPTY[$empty]}\n()",
+      "code": "$pattern {${(}{)}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 {${<<}{>>}code} {CODE[$code]}\n<<outer <<inner>> more>>",
       "expected": "CODE[outer <<inner>> more]"
     },
     {