papagaio 0.7.1 → 0.7.3

package/package.json

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

package/src/louro.js

@@ -0,0 +1,235 @@
+// louro - https://github.com/jardimdanificado/papagaio
+function parsePattern(symbols, pat) {
+    const t = [], S = symbols.sigil, O = symbols.open, C = symbols.close;
+    let i = 0;
+    while (i < pat.length) {
+        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(symbols, pat, j);
+                if (pat[e1] === O) {
+                    const [cd, e2] = extractBlock(symbols, pat, e1);
+                    let v = '', k = e2;
+                    while (k < pat.length && /[A-Za-z0-9_]/.test(pat[k])) v += pat[k++];
+                    if (v) {
+                        let optional = pat[k] === '?';
+                        if (optional) k++;
+
+                        t.push({
+                            type: isDouble ? 'blockseq' : 'block',
+                            varName: v,
+                            open: unescapeDelim(od.trim()) || O,
+                            close: unescapeDelim(cd.trim()) || C,
+                            optional
+                        });
+                        i = k; continue;
+                    }
+                }
+            }
+            j = i + S.length;
+            let v = '';
+            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
+            if (v) {
+                const optional = pat[j] === '?';
+                if (optional) j++;
+                t.push({ type: 'var', varName: v, optional });
+                i = j; continue;
+            }
+            t.push({ type: 'lit', value: S }); i += S.length; continue;
+        }
+        if (/\s/.test(pat[i])) {
+            while (i < pat.length && /\s/.test(pat[i])) i++;
+            t.push({ type: 'ws' }); continue;
+        }
+        let lit = '';
+        while (i < pat.length && pat[i] !== S && !/\s/.test(pat[i])) lit += pat[i++];
+        if (lit) t.push({ type: 'lit', value: lit });
+    }
+    return t;
+}
+
+function matchPattern(symbols, src, tok, pos = 0) {
+    let cap = {};
+    const startPos = pos;
+
+    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 === 'var') {
+            while (pos < src.length && /\s/.test(src[pos])) pos++;
+            const nx = findNext(tok, ti);
+            let v = '';
+            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++];
+            }
+            if (!v && !t.optional) return null;
+            cap[t.varName] = v;
+            continue;
+        }
+        if (t.type === 'blockseq') {
+            let blocks = [];
+            while (pos < src.length && src.startsWith(t.open, pos)) {
+                const [c, e] = extractBlock(symbols, src, pos, t.open, t.close);
+                blocks.push(c);
+                pos = e;
+                while (pos < src.length && /\s/.test(src[pos])) pos++;
+            }
+            if (!blocks.length && !t.optional) return null;
+            cap[t.varName] = blocks;
+            continue;
+        }
+        if (t.type === 'block') {
+            if (!src.startsWith(t.open, pos)) {
+                if (t.optional) {
+                    cap[t.varName] = '';
+                    continue;
+                }
+                return null;
+            }
+
+            const [c, e] = extractBlock(symbols, src, pos, t.open, t.close);
+            cap[t.varName] = c; pos = e; continue;
+        }
+    }
+    return { captures: cap, startPos, endPos: pos, matched: src.slice(startPos, pos) };
+}
+
+function findNext(t, i) {
+    for (let k = i + 1; k < t.length; k++)
+        if (t[k].type !== 'ws') return t[k];
+    return null;
+}
+
+function extractBlock(symbols, src, i, od = symbols.open, cd = symbols.close) {
+    if (od.length > 1 || cd.length > 1) {
+        if (src.substring(i, i + od.length) === od) {
+            i += od.length; const s = i; let d = 0;
+            while (i < src.length) {
+                if (src.substring(i, i + od.length) === od) { d++; i += od.length; }
+                else if (src.substring(i, i + cd.length) === cd) {
+                    if (!d) return [src.substring(s, i), i + cd.length];
+                    d--; i += cd.length;
+                } else i++;
+            }
+            return [src.substring(s), src.length];
+        }
+    }
+    if (src[i] === od) {
+        i++; const s = i;
+        if (od === cd) { while (i < src.length && src[i] !== cd) i++; return [src.substring(s, i), i + 1]; }
+        let d = 1;
+        while (i < src.length && d > 0) { if (src[i] === od) d++; else if (src[i] === cd) d--; if (d > 0) i++; }
+        return [src.substring(s, i), i + 1];
+    }
+    return ['', i];
+}
+
+function esc(s) { return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&'); }
+function unescapeDelim(s) {
+    let r = '';
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '\\' && i + 1 < s.length && (s[i + 1] === '"' || s[i + 1] === "'" || s[i + 1] === '\\')) { r += s[i + 1]; i++; }
+        else r += s[i];
+    }
+    return r;
+}
+
+export function capture(content, pattern, symbols = { sigil: '$', open: '{', close: '}' }) {
+    const tokens = parsePattern(symbols, pattern);
+    const matches = [];
+
+    let pos = 0;
+    while (pos < content.length) {
+        const m = matchPattern(symbols, content, tokens, pos);
+        if (m) {
+            matches.push({
+                matched: m.matched,
+                captures: m.captures,
+                start: m.startPos,
+                end: m.endPos,
+                index: matches.length
+            });
+            pos = m.endPos;
+        } else {
+            pos++;
+        }
+    }
+
+    return {
+        content,
+        pattern,
+        matches,
+        count: matches.length,
+
+        replace(replacement) {
+            if (matches.length === 0) return { content, matches: [], count: 0 };
+
+            let result = '';
+            let lastPos = 0;
+
+            for (const match of matches) {
+                result += content.slice(lastPos, match.start);
+
+                let rep = typeof replacement === 'function'
+                    ? replacement(match)
+                    : replacement;
+
+                for (const [key, value] of Object.entries(match.captures)) {
+                    const varPattern = new RegExp(esc(symbols.sigil + key) + '(?![A-Za-z0-9_])', 'g');
+                    rep = rep.replace(varPattern, value);
+                }
+
+                result += rep;
+                lastPos = match.end;
+            }
+
+            result += content.slice(lastPos);
+
+            return result;
+        },
+
+        filter(predicate) {
+            const filtered = matches.filter(predicate);
+            return {
+                content,
+                pattern,
+                matches: filtered,
+                count: filtered.length,
+                replace: this.replace.bind({ ...this, matches: filtered }),
+                filter: this.filter,
+                only: this.only
+            };
+        },
+
+        only(n) {
+            const len = this.matches.length;
+            let idx = n >= 0 ? n : len + n;
+            if (idx < 0 || idx >= len) {
+                return {
+                    ...this,
+                    matches: []
+                };
+            }
+            return {
+                ...this,
+                matches: [this.matches[idx]]
+            };
+        }
+    };
+}
+
+Object.defineProperty(String.prototype, "capture", {
+    value: function (pattern, symbols) {
+        return capture(this.toString(), pattern, symbols);
+    },
+    writable: true,
+    configurable: true,
+    enumerable: false
+});

package/src/papagaio.js

@@ -1,112 +1,5 @@
 // papagaio - https://github.com/jardimdanificado/papagaio
-function parsePattern(p, pat) {
-    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)) {
-            let j = i + S.length + p.symbols.regex.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++;
-                if (pat[j] === O) {
-                    const [rx, e] = extractBlock(p, pat, j);
-                    t.push({ type: 'regex', varName: v, regex: rx.trim() });
-                    i = e; continue;
-                }
-            }
-        }
-        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;
-                    }
-                }
-            }
-            j = i + S.length;
-            let v = '';
-            while (j < pat.length && /[A-Za-z0-9_]/.test(pat[j])) v += pat[j++];
-            if (v) {
-                const optional = pat[j] === '?';
-                if (optional) j++;
-                t.push({ type: 'var', varName: v, optional });
-                i = j; continue;
-            }
-            t.push({ type: 'lit', value: S }); i += S.length; continue;
-        }
-        if (/\s/.test(pat[i])) {
-            while (i < pat.length && /\s/.test(pat[i])) i++;
-            t.push({ type: 'ws' }); continue;
-        }
-        let lit = '';
-        while (i < pat.length && pat[i] !== S && !/\s/.test(pat[i])) lit += pat[i++];
-        if (lit) t.push({ type: 'lit', value: lit });
-    }
-    return t;
-}
-
-function matchPattern(p, src, tok, pos = 0) {
-    let cap = {};
-    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 {
-                const rx = new RegExp(t.regex), m = src.slice(pos).match(rx);
-                if (!m || m.index !== 0) return null;
-                cap[p.symbols.sigil + t.varName] = m[0];
-                pos += m[0].length;
-            } catch (e) { return null; }
-            continue;
-        }
-        if (t.type === 'var') {
-            while (pos < src.length && /\s/.test(src[pos])) pos++;
-            const nx = findNext(tok, ti);
-            let v = '';
-            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++];
-            }
-            if (!v && !t.optional) return null;
-            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);
-            cap[p.symbols.sigil + t.varName] = c; pos = e; continue;
-        }
-    }
-    return { captures: cap, endPos: pos };
-}
-
-function findNext(t, i) { for (let k = i + 1; k < t.length; k++) if (t[k].type !== 'ws') return t[k]; return null; }
+import { capture } from './louro.js';
 
 function extractBlock(p, src, i, od = p.symbols.open, cd = p.symbols.close) {
     if (od.length > 1 || cd.length > 1) {
@@ -185,41 +78,101 @@ function applyEvals(p, txt, ev) {
     return r;
 }
 
+function processRegexPatterns(p, src, pattern) {
+    // Processa padrões regex que o louro não suporta nativamente
+    const S = p.symbols.sigil, O = p.symbols.open;
+    const regexMatch = pattern.match(new RegExp(`${esc(S)}${esc(p.symbols.regex)}\\s+([A-Za-z0-9_]+)\\s*${esc(O)}([^${esc(p.symbols.close)}]*)${esc(p.symbols.close)}`));
+    
+    if (!regexMatch) return null;
+    
+    const varName = regexMatch[1];
+    const regexStr = regexMatch[2].trim();
+    
+    try {
+        const rx = new RegExp(regexStr);
+        const matches = [];
+        let pos = 0;
+        
+        while (pos < src.length) {
+            const m = src.slice(pos).match(rx);
+            if (m && m.index === 0) {
+                matches.push({
+                    matched: m[0],
+                    captures: { [varName]: m[0] },
+                    start: pos,
+                    end: pos + m[0].length
+                });
+                pos += m[0].length;
+            } else {
+                pos++;
+            }
+        }
+        
+        return matches;
+    } catch (e) {
+        return null;
+    }
+}
+
 function applyPats(p, src, pats) {
     for (const pat of pats) {
-        const tok = parsePattern(p, pat.m); 
-        let n = '', pos = 0, ok = false;
-        while (pos < src.length) {
-            const m = matchPattern(p, src, tok, pos);
-            if (m) {
-                ok = true; 
+        // Verifica se é um padrão regex
+        const regexMatches = processRegexPatterns(p, src, pat.m);
+        
+        if (regexMatches) {
+            // Processa como padrão regex
+            let n = '', lastPos = 0;
+            
+            for (const match of regexMatches) {
+                n += src.slice(lastPos, match.start);
+                
                 let r = pat.r;
                 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]);
+                
+                Object.keys(match.captures).forEach(k => {
+                    r = r.replace(new RegExp(esc(p.symbols.sigil + k) + '(?![A-Za-z0-9_])', 'g'), match.captures[k]);
                 });
+                
                 if (loc.length) r = applyPats(p, r, loc);
-                p.match = src.slice(pos, m.endPos);
+                p.match = match.matched;
                 const [ev, ct] = extractEvals(p, r);
                 if (ev.length) r = applyEvals(p, ct, ev);
-                n += r; pos = m.endPos;
-            } else { n += src[pos]; pos++; }
+                
+                n += r;
+                lastPos = match.end;
+            }
+            
+            n += src.slice(lastPos);
+            if (regexMatches.length > 0) src = n;
+        } else {
+            // Usa louro para padrões normais
+            const result = capture(src, pat.m, p.symbols);
+            
+            if (result.count > 0) {
+                src = result.replace((match) => {
+                    let r = pat.r;
+                    const [loc, cln] = extractNested(p, r);
+                    r = cln;
+                    
+                    Object.keys(match.captures).forEach(k => {
+                        r = r.replace(new RegExp(esc(p.symbols.sigil + k) + '(?![A-Za-z0-9_])', 'g'), match.captures[k]);
+                    });
+                    
+                    if (loc.length) r = applyPats(p, r, loc);
+                    p.match = match.matched;
+                    const [ev, ct] = extractEvals(p, r);
+                    if (ev.length) r = applyEvals(p, ct, ev);
+                    
+                    return r;
+                });
+            }
         }
-        if (ok) src = n;
     }
     return src;
 }
 
 function esc(s) { return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&'); }
-function unescapeDelim(s) {
-    let r = ''; 
-    for (let i = 0; i < s.length; i++) {
-        if (s[i] === '\\' && i + 1 < s.length && (s[i+1] === '"' || s[i+1] === "'" || s[i+1] === '\\')) { r += s[i+1]; i++; }
-        else r += s[i];
-    }
-    return r;
-}
 
 export class Papagaio {
     constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'recursive', regexKw = 'regex', blockseqKw = 'sequential') {

package/examples/simple.html

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <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 type="papagaio">
-    $pattern {abc} {$eval{console.log(this)} aaaaaaaaaaaaaaaaaaaaaaaaaaaa}
-    abc
-</script>
-<body>
-</body>
-</html>

package/examples/wasm.papagaio

@@ -1,70 +0,0 @@
-// 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 ${(}{)}params:$rets ${}{}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 ${}{}params{(}{)}:$rets ${}{}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/src/papagaio-bootstrap.mjs

@@ -1,23 +0,0 @@
-// papagaio-bootstrap.js
-// only needed if using <script type="papagaio"> in browser
-import { Papagaio } from "./papagaio.js";
-
-(async () => {
-  const p = new Papagaio();
-
-  const nodes = [...document.querySelectorAll('script[type="papagaio"]')];
-
-  for (const el of nodes) {
-    let src = el.textContent;
-
-    if (el.src) {
-      src = await fetch(el.src).then(r => r.text());
-    }
-
-    const out = p.process(src);
-
-    const s = document.createElement("div");
-    s.textContent = out;
-    window.document.body.appendChild(s);
-  }
-})();