papagaio 0.7.1 → 0.7.5

package/papagaio.js

@@ -0,0 +1,202 @@
+// papagaio - https://github.com/jardimdanificado/papagaio
+import 'https://unpkg.com/louro@latest/louro.js';
+
+function extractBlock(p, src, i, od = p.symbols.open, cd = p.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 extractNested(p, txt) {
+    const loc = [], S = p.symbols.sigil, O = p.symbols.open;
+    let out = txt;
+    const rx = new RegExp(`${esc(S)}${esc(p.symbols.pattern)}\\s*${esc(O)}`, "g");
+    while (1) {
+        rx.lastIndex = 0; const m = rx.exec(out); if (!m) break;
+        const s = m.index, o = m.index + m[0].length - O.length;
+        const [mp, em] = extractBlock(p, out, o); let k = em;
+        while (k < out.length && /\s/.test(out[k])) k++;
+        if (k < out.length && out.substring(k, k + O.length) === O) {
+            const [rp, er] = extractBlock(p, out, k);
+            loc.push({ m: mp.trim(), r: rp.trim() });
+            out = out.slice(0, s) + out.slice(er); continue;
+        }
+        out = out.slice(0, s) + out.slice(em);
+    }
+    return [loc, out];
+}
+
+function extractEvals(p, txt) {
+    const ev = [], S = p.symbols.sigil, O = p.symbols.open;
+    let i = 0, out = txt, off = 0;
+    while (i < txt.length) {
+        if (txt.substring(i, i + S.length) === S && txt.substring(i + S.length).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++;
+    }
+    return [ev, out];
+}
+
+function applyEvals(p, txt, ev) {
+    let r = txt;
+    for (let i = ev.length - 1; i >= 0; i--) {
+        const ph = `__E${i}__`;
+        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;
+}
+
+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) {
+        // 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(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);
+                
+                n += r;
+                lastPos = match.end;
+            }
+            
+            n += src.slice(lastPos);
+            if (regexMatches.length > 0) src = n;
+        } else {
+            // Usa louro para padrões normais
+            const result = src.capture(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;
+                });
+            }
+        }
+    }
+    return src;
+}
+
+function esc(s) { return s.replace(/[.*+?^${}()|[\]\\""']/g, '\\$&'); }
+
+export default class Papagaio {
+    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 = "";
+    }
+    process(input) {
+        const [loc, cln] = extractNested(this, input);
+        const [evals, ph] = extractEvals(this, cln);
+        let proc = applyEvals(this, ph, evals);
+        if (loc.length === 0) {
+            this.content = proc;
+            return proc;
+        }
+        let src = proc, last = null;
+        while (src !== last) {
+            last = src;
+            src = applyPats(this, src, loc);
+            const [nested] = extractNested(this, src);
+            if (nested.length === 0) break;
+        }
+        this.content = src;
+        if (typeof this.exit == "function") this.exit();
+        return this.content;
+    }
+}

package/tests/test.js

@@ -1,4 +1,4 @@
-import { Papagaio } from '../src/papagaio.js';
+import { Papagaio } from '../papagaio.js';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';

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/mobile.html

@@ -1,209 +0,0 @@
-<!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/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);
-  }
-})();