papagaio 0.2.3 → 0.2.4

package/README.md

@@ -52,17 +52,6 @@ Output: `hello & world` (both)
 
 `$$` = zero or more spaces/tabs/newlines.
 
-### 4. Literal Output (`$$`)
-
-```
-Price: $$50
-```
-Output: `Price: $50`
-
-Use `$$` for literal `$` output.
-
----
-
 ## Blocks
 
 Capture content between delimiters.
@@ -281,6 +270,9 @@ Output:
 - Reuse: `$x` appears multiple times in replace
 - Undefined: becomes empty string
 
+### Sigil
+- You cannot match words containing the sigil character.
+
 ---
 
 ## Troubleshooting
@@ -293,25 +285,19 @@ Output:
 | Infinite recursion | Use `$clear` or reduce `maxRecursion` |
 | $eval not working | Errors return empty string, use try-catch |
 
----
-
-## Performance
+## Known Bugs
 
-- Simple patterns > complex patterns
-- Blocks have minor overhead
-- Avoid unlimited recursion
-- For large inputs, use multiple contexts
+- Multi-character block delimiters that contains double quotes doesnt match properly.
 
 ---
 
 ## Syntax Reference
 
 ```
-pattern {$x $y} {$y, $x}              # basic pattern
-pattern {$x$$y} {$x-$y}               # flexible whitespace
-pattern {$block n {o}{c}} {$n}        # block
+pattern {$x $y} {$y, $x}               # basic pattern
+pattern {$x$$y} {$x-$y}                # flexible whitespace
+pattern {$block n {o}{c}} {$n}         # block
 context { ... }                        # recursive scope
-$$literal                              # output literal $
 $unique                                # unique ID
 $match                                 # full match
 $prefix / $suffix                      # before/after
@@ -327,7 +313,6 @@ $eval{code}                            # execute JS
 context {
   # Markdown headers
   pattern {# $title} {<h1>$title</h1>}
-  pattern {## $title} {<h2>$title</h2>}
   
   # Lists
   pattern {- $item} {<li>$item</li>}
@@ -338,7 +323,7 @@ context {
   
   # Process content
   # Welcome
-  ## Getting Started
+  # Getting Started
   This is **important** and *italic*
   - First item
   - Second item

package/package.json

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

package/src/papagaio.js

@@ -8,8 +8,7 @@ export class Papagaio {
   content = "";
 
   constructor() {
-    this.#counter.value = 0;
-    this.#counter.unique = 0;
+    this.#counter = { value: 0, unique: 0 };
   }
 
   process(input) {
@@ -23,16 +22,15 @@ export class Papagaio {
     while (src !== last && iter < this.maxRecursion) {
       iter++;
       last = src;
-      src = this.#procContext(src);
+      src = this.#processContext(src);
       const [patterns, s2] = this.#collectPatterns(src);
-      src = s2;
-      src = this.#applyPatterns(src, patterns);
+      src = this.#applyPatterns(s2, patterns);
       if (!pending()) break;
     }
     return this.content = src, src;
   }
 
-  #procContext(src) {
+  #processContext(src) {
     const ctxRe = new RegExp(`\\b${this.keywords.context}\\s*\\${this.open}`, "g");
     let m, matches = [];
     while ((m = ctxRe.exec(src)) !== null)
@@ -53,103 +51,75 @@ export class Papagaio {
   }
 
   #extractBlock(src, openPos, openDelim = this.open, closeDelim = this.close) {
-    let i = openPos, depth = 0, innerStart = null, inStr = false, strChar = '';
-    
-    // Se openDelim tem múltiplos caracteres, processa diferente
-    if (openDelim.length > 1) {
-      // Pula o delimitador de abertura
+    let i = openPos;
+    if (openDelim.length > 1 || closeDelim.length > 1) {
       if (src.substring(i, i + openDelim.length) === openDelim) {
         i += openDelim.length;
-        innerStart = i;
-        // Procura pelo delimitador de fechamento com balanceamento
+        const innerStart = i;
         let d = 0;
         while (i < src.length) {
           if (src.substring(i, i + openDelim.length) === openDelim) {
             d++;
             i += openDelim.length;
           } else if (src.substring(i, i + closeDelim.length) === closeDelim) {
-            if (d === 0) {
-              return [src.substring(innerStart, i), i + closeDelim.length];
-            }
+            if (d === 0) return [src.substring(innerStart, i), i + closeDelim.length];
             d--;
             i += closeDelim.length;
-          } else {
-            i++;
-          }
+          } else i++;
         }
         return [src.substring(innerStart), src.length];
       }
     }
-    
-    // Para delimitadores single-char, balanceia
-    while (i < src.length) {
-      const ch = src[i];
-      if (inStr) {
-        if (ch === '\\') i += 2;
-        else if (ch === strChar) { inStr = false; strChar = ''; i++; }
-        else i++;
-        continue;
-      }
-      if (ch === "'" || ch === "`") {
-        inStr = true;
-        strChar = ch;
-        i++;
-        continue;
-      }
-      if (ch === openDelim) {
-        depth++;
-        if (innerStart === null) innerStart = i + 1;
-      } else if (ch === closeDelim) {
-        depth--;
-        if (depth === 0) return [innerStart !== null ? src.substring(innerStart, i) : '', i + 1];
-      }
+    if (src[i] === openDelim) {
       i++;
+      const innerStart = i;
+      if (openDelim === closeDelim) {
+        while (i < src.length && src[i] !== closeDelim) i++;
+        return [src.substring(innerStart, i), i + 1];
+      } else {
+        let depth = 1;
+        while (i < src.length && depth > 0) {
+          if (src[i] === openDelim) depth++;
+          else if (src[i] === closeDelim) depth--;
+          if (depth > 0) i++;
+        }
+        return [src.substring(innerStart, i), i + 1];
+      }
     }
-    return [innerStart !== null ? src.substring(innerStart) : '', src.length];
+    return ['', i];
   }
 
-  #patternToRegex(pattern) {
-    let regex = '', i = 0;
+  #parsePattern(pattern) {
+    const tokens = [];
+    let i = 0;
     const S = this.sigil, S2 = S + S;
     while (i < pattern.length) {
       if (pattern.startsWith(S2, i)) {
-        regex += '\\s*';
+        tokens.push({ type: 'whitespace-optional' });
         i += S2.length;
         continue;
       }
       if (pattern.startsWith(S + 'block', i)) {
         let j = i + S.length + 'block'.length;
         while (j < pattern.length && /\s/.test(pattern[j])) j++;
-        
         let varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) {
-          varName += pattern[j++];
-        }
-        
+        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
         if (varName) {
           while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          
-          // Extrair delimitador de abertura - com balanceamento
           let openDelim = this.open;
           if (j < pattern.length && pattern[j] === this.open) {
             const [c, e] = this.#extractBlock(pattern, j);
-            openDelim = c.trim() || this.open;
+            openDelim = this.#unescapeDelimiter(c.trim()) || this.open;
             j = e;
             while (j < pattern.length && /\s/.test(pattern[j])) j++;
           }
-          
-          // Extrair delimitador de fechamento - com balanceamento
           let closeDelim = this.close;
           if (j < pattern.length && pattern[j] === this.open) {
-            const [c, e] = this.#extractBlock(pattern, j, this.open, this.close);
-            closeDelim = c.trim() || this.close;
+            const [c, e] = this.#extractBlock(pattern, j);
+            closeDelim = this.#unescapeDelimiter(c.trim()) || this.close;
             j = e;
           }
-          
-          const eoMask = this.#escapeRegex(openDelim);
-          const ecMask = this.#escapeRegex(closeDelim);
-          // Use greedy match to allow nested delimiters to be captured (will match up to the last closing delimiter)
-          regex += `${eoMask}([\\s\\S]*)${ecMask}`;
+          tokens.push({ type: 'block', varName, openDelim, closeDelim });
           i = j;
           continue;
         }
@@ -158,92 +128,89 @@ export class Papagaio {
         let j = i + S.length, varName = '';
         while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
         if (varName) {
-          regex += '(\\S+)';
+          tokens.push({ type: 'var', varName });
           i = j;
-        } else {
-          regex += this.#escapeRegex(S);
-          i += S.length;
+          continue;
         }
+        tokens.push({ type: 'literal', value: S });
+        i += S.length;
         continue;
       }
       if (/\s/.test(pattern[i])) {
-        regex += '\\s+';
-        while (i < pattern.length && /\s/.test(pattern[i])) i++;
+        let ws = '';
+        while (i < pattern.length && /\s/.test(pattern[i])) ws += pattern[i++];
+        tokens.push({ type: 'whitespace', value: ws });
         continue;
       }
-      const ch = pattern[i];
-      regex += /[.*+?^${}()|[\]\\]/.test(ch) ? '\\' + ch : ch;
-      i++;
+      let literal = '';
+      while (i < pattern.length && !pattern.startsWith(S, i) && !/\s/.test(pattern[i])) literal += pattern[i++];
+      if (literal) tokens.push({ type: 'literal', value: literal });
     }
-    return new RegExp(regex, 'g');
+    return tokens;
   }
 
-  #extractVarNames(pattern) {
-    const vars = [], seen = new Set(), S = this.sigil, S2 = S + S;
-    let i = 0;
-    while (i < pattern.length) {
-      if (pattern.startsWith(S + 'block', i)) {
-        let j = i + S.length + 'block'.length;
-        while (j < pattern.length && /\s/.test(pattern[j])) j++;
-        
-        // Extrair nome como identificador simples
-        let varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) {
-          varName += pattern[j++];
-        }
-        
-        if (varName && !seen.has(varName)) {
-          vars.push(S + varName);
-          seen.add(varName);
-        }
-        
-        if (varName) {
-          while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          
-          // Pular delimitador de abertura
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [, ne] = this.#extractBlock(pattern, j);
-            j = ne;
-            while (j < pattern.length && /\s/.test(pattern[j])) j++;
-          }
-          
-          // Pular delimitador de fechamento
-          if (j < pattern.length && pattern[j] === this.open) {
-            const [, ne] = this.#extractBlock(pattern, j);
-            j = ne;
-          }
-        }
-        
-        i = j;
+  #matchPattern(src, tokens, startPos = 0) {
+    let pos = startPos;
+    const captures = {};
+    for (let ti = 0; ti < tokens.length; ti++) {
+      const token = tokens[ti];
+      if (token.type === 'whitespace-optional') {
+        while (pos < src.length && /\s/.test(src[pos])) pos++;
         continue;
       }
-      if (pattern.startsWith(S2, i)) {
-        i += S2.length;
+      if (token.type === 'whitespace') {
+        if (pos >= src.length || !/\s/.test(src[pos])) return null;
+        while (pos < src.length && /\s/.test(src[pos])) pos++;
         continue;
       }
-      if (pattern.startsWith(S, i)) {
-        let j = i + S.length, varName = '';
-        while (j < pattern.length && /[A-Za-z0-9_]/.test(pattern[j])) varName += pattern[j++];
-        if (varName && !seen.has(varName)) {
-          vars.push(S + varName);
-          seen.add(varName);
+      if (token.type === 'literal') {
+        if (!src.startsWith(token.value, pos)) return null;
+        pos += token.value.length;
+        continue;
+      }
+      if (token.type === 'var') {
+        const nextToken = ti + 1 < tokens.length ? tokens[ti + 1] : null;
+        let varValue = '';
+        if (nextToken) {
+          if (nextToken.type === 'whitespace' || nextToken.type === 'whitespace-optional') {
+            while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
+          } else if (nextToken.type === 'literal') {
+            const stopChar = nextToken.value[0];
+            while (pos < src.length && src[pos] !== stopChar && !/\s/.test(src[pos])) varValue += src[pos++];
+          } else if (nextToken.type === 'block') {
+            while (pos < src.length && !src.startsWith(nextToken.openDelim, pos) && !/\s/.test(src[pos])) varValue += src[pos++];
+          } else {
+            while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
+          }
+        } else {
+          while (pos < src.length && !/\s/.test(src[pos])) varValue += src[pos++];
         }
-        i = j;
+        if (!varValue) return null;
+        captures[this.sigil + token.varName] = varValue;
+        continue;
+      }
+      if (token.type === 'block') {
+        const { varName, openDelim, closeDelim } = token;
+        if (!src.startsWith(openDelim, pos)) return null;
+        const [blockContent, endPos] = this.#extractBlock(src, pos, openDelim, closeDelim);
+        captures[this.sigil + varName] = blockContent;
+        pos = endPos;
         continue;
       }
-      i++;
     }
-    return vars;
+    return { captures, endPos: pos };
   }
 
   #collectPatterns(src) {
-    const patterns = [], patRe = new RegExp(`\\b${this.keywords.pattern}\\s*\\${this.open}`, "g");
-    let result = src, i = 0;
-    while (i < result.length) {
-      patRe.lastIndex = i;
+    const patterns = [];
+    const patRe = new RegExp(`\\b${this.keywords.pattern}\\s*\\${this.open}`, "g");
+    let result = src;
+    while (true) {
+      patRe.lastIndex = 0;
       const m = patRe.exec(result);
       if (!m) break;
-      const start = m.index, openPos = m.index + m[0].length - 1;
+      const start = m.index;
+      const openPos = m.index + m[0].length - 1;
       const [matchPat, posAfterMatch] = this.#extractBlock(result, openPos);
       let k = posAfterMatch;
       while (k < result.length && /\s/.test(result[k])) k++;
@@ -251,10 +218,9 @@ export class Papagaio {
         const [replacePat, posAfterReplace] = this.#extractBlock(result, k);
         patterns.push({ match: matchPat.trim(), replace: replacePat.trim() });
         result = result.slice(0, start) + result.slice(posAfterReplace);
-        i = start;
         continue;
       }
-      i = start + 1;
+      result = result.slice(0, start) + result.slice(posAfterMatch);
     }
     return [patterns, result];
   }
@@ -262,47 +228,49 @@ export class Papagaio {
   #applyPatterns(src, patterns) {
     let clearFlag = false, lastResult = "", S = this.sigil;
     for (const pat of patterns) {
-      // Aplicar uma única vez
-      const regex = this.#patternToRegex(pat.match);
-      const varNames = this.#extractVarNames(pat.match);
-      src = src.replace(regex, (...args) => {
-        const fullMatch = args[0];
-        const captures = args.slice(1, -2);
-        const matchStart = args[args.length - 2];
-        const matchEnd = matchStart + fullMatch.length;
-        let result = pat.replace;
-        const varMap = {};
-        for (let i = 0; i < varNames.length; i++)
-          varMap[varNames[i]] = captures[i] || '';
-        for (const [k, v] of Object.entries(varMap)) {
-          const keyEsc = this.#escapeRegex(k);
-          result = result.replace(new RegExp(keyEsc + '(?![A-Za-z0-9_])', 'g'), v);
-        }
-        result = result.replace(new RegExp(`${this.#escapeRegex(S)}unique\\b`, 'g'), 
-          () => this.#genUnique());
-        result = result.replace(/\$eval\{([^}]*)\}/g, (_, code) => {
-          try {
-            const wrapped = `"use strict"; return (function() { ${code} })();`;
-            return String(Function("papagaio", "ctx", wrapped)(this, {}));
-          } catch {
-            return "";
+      const tokens = this.#parsePattern(pat.match);
+      let newSrc = '';
+      let pos = 0, matched = false;
+      while (pos < src.length) {
+        const matchResult = this.#matchPattern(src, tokens, pos);
+        if (matchResult) {
+          matched = true;
+          const { captures, endPos } = matchResult;
+          let result = pat.replace;
+          for (const [k, v] of Object.entries(captures)) {
+            const keyEsc = this.#escapeRegex(k);
+            result = result.replace(new RegExp(keyEsc + '(?![A-Za-z0-9_])', 'g'), v);
           }
-        });
-        const S2 = S + S;
-        result = result.replace(new RegExp(this.#escapeRegex(S2), 'g'), '');
-        if (new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g').test(result)) {
-          result = result.replace(new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g'), '');
-          clearFlag = true;
+          result = result.replace(new RegExp(`${this.#escapeRegex(S)}unique\\b`, 'g'), () => this.#genUnique());
+          result = result.replace(/\$eval\{([^}]*)\}/g, (_, code) => {
+            try {
+              const wrapped = `"use strict"; return (function() { ${code} })();`;
+              return String(Function("papagaio", "ctx", wrapped)(this, {}));
+            } catch {
+              return "";
+            }
+          });
+          const S2 = S + S;
+          result = result.replace(new RegExp(this.#escapeRegex(S2), 'g'), '');
+          if (new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g').test(result)) {
+            result = result.replace(new RegExp(`${this.#escapeRegex(S)}clear\\b`, 'g'), '');
+            clearFlag = true;
+          }
+          const matchStart = pos, matchEnd = endPos;
+          result = result
+            .replace(new RegExp(`${this.#escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, matchStart))
+            .replace(new RegExp(`${this.#escapeRegex(S)}suffix\\b`, 'g'), src.slice(matchEnd))
+            .replace(new RegExp(`${this.#escapeRegex(S)}match\\b`, 'g'), src.slice(matchStart, matchEnd));
+          newSrc += result;
+          lastResult = result;
+          pos = endPos;
+        } else {
+          newSrc += src[pos];
+          pos++;
         }
-        result = result
-          .replace(new RegExp(`${this.#escapeRegex(S)}prefix\\b`, 'g'), src.slice(0, matchStart))
-          .replace(new RegExp(`${this.#escapeRegex(S)}suffix\\b`, 'g'), src.slice(matchEnd))
-          .replace(new RegExp(`${this.#escapeRegex(S)}match\\b`, 'g'), fullMatch);
-        lastResult = result;
-        return result;
-      });
-      if (clearFlag) {
-        src = lastResult;
+      }
+      if (matched) {
+        src = clearFlag ? lastResult : newSrc;
         clearFlag = false;
       }
     }
@@ -314,6 +282,24 @@ export class Papagaio {
   }
 
   #escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\\"']/g, '\\$&');
+    return str.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&');
+  }
+
+  #unescapeDelimiter(str) {
+    let result = '';
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === '\\' && i + 1 < str.length) {
+        const next = str[i + 1];
+        if (next === '"' || next === "'" || next === '\\') {
+          result += next;
+          i++;
+        } else {
+          result += str[i];
+        }
+      } else {
+        result += str[i];
+      }
+    }
+    return result;
   }
 }

package/tests/tests.json

@@ -261,7 +261,7 @@
     {
       "id": 44,
       "name": "Block with double quotes",
-      "code": "pattern {$block str {\\\"}{\\\"}} {STR[$str]}\n\\\"hello\\\"",
+      "code": "pattern {$block str {\"}{\"}} {STR[$str]}\n\"hello\"",
       "shouldContain": "STR[hello]"
     },
     {
@@ -326,7 +326,7 @@
     },
     {
       "id": 55,
-      "name": "Block captures first simple angle block(known issue)",
+      "name": "Block captures first simple angle block",
       "code": "pattern {$block txt {<}{>}} {CAP[$txt]}\nstart <one> middle <two> end",
       "shouldContain": "CAP[one]"
     },
@@ -344,8 +344,8 @@
     },
     {
       "id": 58,
-      "name": "Dot in variable suffix(known issue)",
-      "code": "pattern {$file.ext} {file: $file}\nphoto.png",
+      "name": "Simple Test",
+      "code": "pattern {$file.$ext} {file: $file}\nphoto.png",
       "shouldContain": "file: photo"
     },
     {
@@ -362,7 +362,7 @@
     },
     {
       "id": 61,
-      "name": "Block with pipe delimiters(known issue)",
+      "name": "Block with pipe delimiters",
       "code": "pattern {$block mid {|}{|}} {PIPE[$mid]}\n|a| and |b|",
       "shouldContain": "PIPE[a]"
     },
@@ -380,7 +380,7 @@
     },
     {
       "id": 64,
-      "name": "Apostrophe in pattern literal(known issue)",
+      "name": "Apostrophe in pattern literal",
       "code": "pattern {It's $name} {Hello $name}\nIt's John",
       "shouldContain": "Hello John"
     },
@@ -401,6 +401,18 @@
       "name": "Literal special regex characters in pattern",
       "code": "pattern {a.*b} {PAT}\na.*b",
       "shouldContain": "PAT"
+    },
+    {
+      "id": 68,
+      "name": "Block with multi-character delimiters containing double quotes(known issue)",
+      "code": "pattern {$block str {\"k}{\"k}} {STR[$str]}\n\"khello\"k",
+      "shouldContain": "STR[hello]"
+    },
+    {
+      "id": 69,
+      "name": "Block with multi-character delimiters",
+      "code": "pattern {$block str {open}{close}} {$str World!}\nopenHelloclose",
+      "shouldContain": "Hello World!"
     }
   ]
 }