papagaio 0.7.7 → 0.7.9

package/bin/cli.mjs

@@ -1,62 +1,22 @@
 #!/usr/bin/env node
-// Detecta o runtime
-const isQuickJS = typeof scriptArgs !== 'undefined';
-const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
 
-// ============================================================================
-// MAIN FUNCTION
-// ============================================================================
-async function main() {
-    // ============================================================================
-    // IMPORTS - Branch por runtime
-    // ============================================================================
-    let Papagaio, std, os, fs, pkg;
-
-    if (isQuickJS) {
-        // QuickJS imports
-        const stdModule = await import("std");
-        const osModule = await import("os");
-        std = stdModule;
-        os = osModule;
-        const { Papagaio: P } = await import("../papagaio.js");
-        Papagaio = P;
-    } else {
-        // Node.js imports
-        const fsModule = await import("fs");
-        fs = fsModule.default;
-
-        // Load package.json usando fs ao invés de require
-        const pkgPath = new URL("../package.json", import.meta.url);
-        const pkgContent = fs.readFileSync(pkgPath, "utf8");
-        pkg = JSON.parse(pkgContent);
+import fs from "fs";
+import Papagaio from "../papagaio.js";
 
-        const { Papagaio: P } = await import("../papagaio.js");
-        Papagaio = P;
-    }
-
-    // ============================================================================
-    // ABSTRAÇÃO DE CONSOLE/STD
-    // ============================================================================
-    const output = {
-        log: isQuickJS ? (msg) => std.out.puts(msg + "\n") : console.log,
-        error: isQuickJS ? (msg) => std.err.puts(msg + "\n") : console.error,
-        exit: isQuickJS ? std.exit : process.exit
-    };
+async function main() {
+    const args = process.argv.slice(2);
 
-    // ============================================================================
-    // PARSE ARGUMENTS
-    // ============================================================================
-    const args = isQuickJS ? scriptArgs.slice(1) : process.argv.slice(2);
-    const VERSION = isQuickJS ? "0.6.0" : pkg.version;
+    const pkgPath = new URL("../package.json", import.meta.url);
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const VERSION = pkg.version;
 
-    // Help & Version
     if (args.includes("-v") || args.includes("--version")) {
-        output.log(VERSION);
-        output.exit(0);
+        console.log(VERSION);
+        process.exit(0);
     }
 
     if (args.includes("-h") || args.includes("--help")) {
-        output.log(`Usage: papagaio [options] <file1> [file2] [...]
+        console.log(`Usage: papagaio [options] <file1> [file2] [...]
 
 Options:
   -h, --help            Show this help message
@@ -66,72 +26,41 @@ Examples:
   papagaio input.txt
   papagaio file1.txt file2.txt file3.txt
   papagaio *.txt`);
-        output.exit(0);
+        process.exit(0);
     }
 
-    // Get input files
-    const files = args.filter((arg, i) => {
-        if (arg.startsWith("-")) return false;
-        return true;
-    });
+    const files = args.filter(arg => !arg.startsWith("-"));
 
     if (files.length === 0) {
-        output.error("Error: no input file specified.\nUse --help for usage.");
-        output.exit(1);
+        console.error("Error: no input file specified.\nUse --help for usage.");
+        process.exit(1);
     }
 
-    // ============================================================================
-    // FILE READING ABSTRACTION
-    // ============================================================================
-    function readFile(filepath) {
-        if (isQuickJS) {
-            const f = std.open(filepath, "r");
-            if (!f) {
-                throw new Error(`cannot open file '${filepath}'`);
-            }
-            const content = f.readAsString();
-            f.close();
-            return content;
-        } else {
-            if (!fs.existsSync(filepath)) {
-                throw new Error(`file not found: ${filepath}`);
-            }
-            return fs.readFileSync(filepath, "utf8");
-        }
-    }
-
-    // ============================================================================
-    // READ AND CONCATENATE FILES
-    // ============================================================================
     let concatenatedSrc = "";
     let hasErrors = false;
 
     for (const file of files) {
         try {
-            const src = readFile(file);
-            concatenatedSrc += src;
-        } catch (error) {
-            output.error(`Error reading ${file}: ${error.message || error}`);
+            if (!fs.existsSync(file)) {
+                throw new Error(`file not found: ${file}`);
+            }
+            concatenatedSrc += fs.readFileSync(file, "utf8");
+        } catch (err) {
+            console.error(`Error reading ${file}: ${err.message || err}`);
             hasErrors = true;
         }
     }
 
     if (hasErrors) {
-        output.exit(1);
+        process.exit(1);
     }
 
-    // PROCESS CONCATENATED INPUT
     const p = new Papagaio();
     const out = p.process(concatenatedSrc);
-    output.log(out);
+    console.log(out);
 }
 
-// main
 main().catch(err => {
-    const output = isQuickJS
-        ? (msg) => std.err.puts(msg + "\n")
-        : console.error;
-    output("Fatal error: " + (err.message || err));
-    const exit = isQuickJS ? std.exit : process.exit;
-    exit(1);
-});
+    console.error("Fatal error:", err.message || err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papagaio",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "easy yet powerful preprocessor",
   "main": "papagaio.js",
   "type": "module",
@@ -29,8 +29,5 @@
   "homepage": "https://github.com/jardimdanificado/papagaio#readme",
   "bin": {
     "papagaio": "bin/cli.mjs"
-  },
-  "dependencies": {
-    "louro": "^0.1.1"
   }
 }

package/papagaio.js

@@ -1,13 +1,120 @@
 // 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) {
+                        const 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;
+}
 
-if (typeof window !== "undefined") {
-    // Browser
-    await import('https://unpkg.com/louro@latest/louro.js');
-} else {
-    // Node.js
-    await import('louro');
+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 && !t.optional) return null;
+            cap[p.symbols.sigil + t.varName] = blocks.join(' ');
+            continue;
+        }
+        if (t.type === 'block') {
+            if (!src.startsWith(t.open, pos)) {
+                if (t.optional) {
+                    cap[p.symbols.sigil + t.varName] = '';
+                    continue;
+                }
+                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; }
 
 function extractBlock(p, src, i, od = p.symbols.open, cd = p.symbols.close) {
     if (od.length > 1 || cd.length > 1) {
@@ -76,111 +183,51 @@ function applyEvals(p, txt, ev) {
     let r = txt;
     for (let i = ev.length - 1; i >= 0; i--) {
         const ph = `__E${i}__`;
-        try {
+        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);
-
+        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; 
                 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]);
+                Object.keys(m.captures).forEach(k => {
+                    r = r.replace(new RegExp(esc(k) + '(?![A-Za-z0-9_])', 'g'), m.captures[k]);
                 });
-
                 if (loc.length) r = applyPats(p, r, loc);
-                p.match = match.matched;
+                p.match = src.slice(pos, m.endPos);
                 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;
-                });
-            }
+                n += r; pos = m.endPos;
+            } else { n += src[pos]; pos++; }
         }
+        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 default class Papagaio {
     constructor(sigil = '$', open = '{', close = '}', pattern = 'pattern', evalKw = 'eval', blockKw = 'recursive', regexKw = 'regex', blockseqKw = 'sequential') {