@kirigami/php-prepros 1.0.0

package/src/libraries/yaml.class.php

@@ -0,0 +1,453 @@
+<?php
+
+/**
+ * YAML — Parseur YAML léger, entièrement statique.
+ *
+ * Utilisation :
+ *   $data = YAML::parse($yamlString);          // mappings → stdClass (défaut)
+ *   $data = YAML::parse($yamlString, true);    // mappings → array associatif
+ *   $data = YAML::parseFile('/chemin/vers/config.yaml');
+ *
+ * Supporte :
+ *  - Scalaires typés (string, int, float, bool, null)
+ *  - Guillemets simples et doubles (avec séquences d'échappement)
+ *  - Blocs multi-lignes (| littéral et > replié, avec chomping -, +)
+ *  - Plain scalars multi-lignes (continuation sans indicateur)
+ *  - Mappings et séquences imbriqués
+ *  - Collections inline [a, b] et {k: v}
+ *  - Commentaires (#)
+ *  - Documents multiples séparés par ---
+ */
+class YAML
+{
+    private function __construct() {}
+
+    // -------------------------------------------------------------------------
+    // Points d'entrée publics
+    // -------------------------------------------------------------------------
+
+    public static function parse(string $yaml, bool $assoc = false): mixed
+    {
+        $yaml  = str_replace(["\r\n", "\r"], "\n", $yaml);
+        $lines = explode("\n", $yaml);
+        $pos   = 0;
+
+        $documents = [];
+
+        while ($pos < count($lines)) {
+            $line = $lines[$pos];
+            if (preg_match('/^---/', $line)) { $pos++; continue; }
+            if (preg_match('/^\.\.\./', $line)) { $pos++; break; }
+
+            $doc = self::parseBlock($lines, $pos, 0, $assoc);
+            $documents[] = $doc;
+        }
+
+        return count($documents) === 1 ? $documents[0] : $documents;
+    }
+
+    public static function parseFile(string $path, bool $assoc = false): mixed
+    {
+        if (!is_readable($path)) {
+            throw new \RuntimeException("Impossible de lire le fichier : $path");
+        }
+        return self::parse(file_get_contents($path), $assoc);
+    }
+
+    // -------------------------------------------------------------------------
+    // Parsing récursif
+    // -------------------------------------------------------------------------
+
+    private static function parseBlock(array $lines, int &$pos, int $indent, bool $assoc = false): mixed
+    {
+        self::skipEmptyAndComments($lines, $pos);
+
+        if ($pos >= count($lines)) return null;
+
+        $line       = $lines[$pos];
+        $lineIndent = self::getIndent($line);
+        $trimmed    = ltrim($line);
+
+        if (str_starts_with($trimmed, '- ') || $trimmed === '-') {
+            return self::parseSequence($lines, $pos, $lineIndent, $assoc);
+        }
+
+        if (self::isMapping($trimmed)) {
+            return self::parseMapping($lines, $pos, $lineIndent, $assoc);
+        }
+
+        return null;
+    }
+
+    private static function parseMapping(array $lines, int &$pos, int $indent, bool $assoc = false): array|object
+    {
+        $result = [];
+
+        while ($pos < count($lines)) {
+            self::skipEmptyAndComments($lines, $pos);
+            if ($pos >= count($lines)) break;
+
+            $line       = $lines[$pos];
+            $lineIndent = self::getIndent($line);
+            $trimmed    = ltrim($line);
+
+            if ($lineIndent < $indent) break;
+            if ($lineIndent > $indent) break;
+            if (preg_match('/^(---|\.\.\.)\s*$/', $trimmed)) break;
+            if (!self::isMapping($trimmed)) break;
+
+            [$key, $rest] = self::splitKeyValue($trimmed);
+            $pos++;
+
+            if ($rest === null) {
+                // Valeur sur les lignes suivantes : sous-bloc ou plain scalar multi-ligne
+                self::skipEmptyAndComments($lines, $pos);
+                if ($pos < count($lines)) {
+                    $nextIndent = self::getIndent($lines[$pos]);
+                    if ($nextIndent > $indent) {
+                        $nextTrimmed = ltrim($lines[$pos]);
+                        // Plain scalar si ce n'est ni un mapping ni une séquence
+                        if (!self::isMapping($nextTrimmed) && !str_starts_with($nextTrimmed, '- ')) {
+                            $result[$key] = self::parseScalar(
+                                self::collectPlainScalar($lines, $pos, $indent, '')
+                            );
+                        } else {
+                            $result[$key] = self::parseBlock($lines, $pos, $nextIndent, $assoc);
+                        }
+                    } else {
+                        $result[$key] = null;
+                    }
+                } else {
+                    $result[$key] = null;
+                }
+            } elseif ($rest === '|' || $rest === '|-' || $rest === '|+') {
+                $result[$key] = self::parseLiteralBlock($lines, $pos, $indent, $rest);
+            } elseif ($rest === '>' || $rest === '>-' || $rest === '>+') {
+                $result[$key] = self::parseFoldedBlock($lines, $pos, $indent, $rest);
+            } elseif ($rest !== '' && ($rest[0] === '[' || $rest[0] === '{')) {
+                $result[$key] = self::parseInlineCollection($rest, $assoc);
+            } else {
+                // Scalaire inline, peut être suivi de lignes de continuation
+                $result[$key] = self::parseScalar(
+                    self::collectPlainScalar($lines, $pos, $indent, $rest)
+                );
+            }
+        }
+
+        return $assoc ? $result : (object) $result;
+    }
+
+    private static function parseSequence(array $lines, int &$pos, int $indent, bool $assoc = false): array
+    {
+        $result = [];
+
+        while ($pos < count($lines)) {
+            self::skipEmptyAndComments($lines, $pos);
+            if ($pos >= count($lines)) break;
+
+            $line       = $lines[$pos];
+            $lineIndent = self::getIndent($line);
+            $trimmed    = ltrim($line);
+
+            if ($lineIndent < $indent) break;
+            if ($lineIndent > $indent) break;
+            if (preg_match('/^(---|\.\.\.)\s*$/', $trimmed)) break;
+            if (!str_starts_with($trimmed, '- ') && $trimmed !== '-') break;
+
+            $itemContent = $trimmed === '-' ? '' : substr($trimmed, 2);
+            $pos++;
+
+            if ($itemContent === '') {
+                self::skipEmptyAndComments($lines, $pos);
+                if ($pos < count($lines)) {
+                    $nextIndent = self::getIndent($lines[$pos]);
+                    $result[] = $nextIndent > $indent
+                        ? self::parseBlock($lines, $pos, $nextIndent, $assoc)
+                        : null;
+                } else {
+                    $result[] = null;
+                }
+            } elseif (self::isMapping($itemContent)) {
+                // Mapping inline dans la séquence :
+                // On reconstruit un tableau de lignes virtuel en préfixant la première clé
+                // avec fakeIndent, puis on délègue entièrement à parseMapping pour bénéficier
+                // de toute sa logique (|, >, plain scalars, sous-blocs…).
+                $fakeIndent   = $lineIndent + 2;
+                $fakePrefix   = str_repeat(' ', $fakeIndent);
+                $virtualLines = array_merge(
+                    [$fakePrefix . $itemContent],
+                    array_slice($lines, $pos)
+                );
+                $vPos    = 0;
+                $itemMap = self::parseMapping($virtualLines, $vPos, $fakeIndent, $assoc);
+                $pos    += max(0, $vPos - 1);
+                $result[] = $itemMap;
+            } elseif ($itemContent[0] === '[' || $itemContent[0] === '{') {
+                $result[] = self::parseInlineCollection($itemContent, $assoc);
+            } else {
+                $result[] = self::parseScalar($itemContent);
+            }
+        }
+
+        return $result;
+    }
+
+    // -------------------------------------------------------------------------
+    // Plain scalar multi-ligne
+    // -------------------------------------------------------------------------
+
+    /**
+     * Collecte un scalaire qui peut continuer sur des lignes plus indentées que $parentIndent.
+     * Les lignes de continuation sont jointes par un espace (repli implicite).
+     */
+    private static function collectPlainScalar(array $lines, int &$pos, int $parentIndent, string $first): string
+    {
+        $parts = $first !== '' ? [trim($first)] : [];
+
+        while ($pos < count($lines)) {
+            $raw     = $lines[$pos];
+            $trimmed = trim($raw);
+
+            // Ligne vide : fin du scalaire
+            if ($trimmed === '') break;
+
+            $lineIndent = self::getIndent($raw);
+
+            // Retour à l'indentation parente ou moins : fin
+            if ($lineIndent <= $parentIndent) break;
+
+            // Commentaire seul sur la ligne : fin
+            if (str_starts_with($trimmed, '#')) break;
+
+            // C'est un mapping ou une séquence : fin
+            if (self::isMapping($trimmed) || str_starts_with($trimmed, '- ')) break;
+
+            $parts[] = $trimmed;
+            $pos++;
+        }
+
+        return implode(' ', $parts);
+    }
+
+    // -------------------------------------------------------------------------
+    // Blocs multi-lignes
+    // -------------------------------------------------------------------------
+
+    private static function parseLiteralBlock(array $lines, int &$pos, int $parentIndent, string $indicator): string
+    {
+        $blockLines  = [];
+        $blockIndent = null;
+        $chomping    = self::getChomping($indicator);
+
+        while ($pos < count($lines)) {
+            $raw = $lines[$pos];
+
+            if (trim($raw) === '') {
+                $blockLines[] = '';
+                $pos++;
+                continue;
+            }
+
+            $lineIndent = self::getIndent($raw);
+            if ($blockIndent === null) {
+                if ($lineIndent <= $parentIndent) break;
+                $blockIndent = $lineIndent;
+            }
+            if ($lineIndent < $blockIndent) break;
+
+            $blockLines[] = substr($raw, $blockIndent);
+            $pos++;
+        }
+
+        return self::applyChomping(implode("\n", $blockLines), $chomping);
+    }
+
+    private static function parseFoldedBlock(array $lines, int &$pos, int $parentIndent, string $indicator): string
+    {
+        $blockLines  = [];
+        $blockIndent = null;
+        $chomping    = self::getChomping($indicator);
+
+        while ($pos < count($lines)) {
+            $raw = $lines[$pos];
+
+            if (trim($raw) === '') {
+                $blockLines[] = '';
+                $pos++;
+                continue;
+            }
+
+            $lineIndent = self::getIndent($raw);
+            if ($blockIndent === null) {
+                if ($lineIndent <= $parentIndent) break;
+                $blockIndent = $lineIndent;
+            }
+            if ($lineIndent < $blockIndent) break;
+
+            $blockLines[] = rtrim(substr($raw, $blockIndent));
+            $pos++;
+        }
+
+        $folded = '';
+        $count  = count($blockLines);
+        for ($i = 0; $i < $count; $i++) {
+            if ($blockLines[$i] === '') {
+                $folded .= "\n";
+            } elseif ($i < $count - 1 && $blockLines[$i + 1] !== '') {
+                $folded .= $blockLines[$i] . ' ';
+            } else {
+                $folded .= $blockLines[$i];
+            }
+        }
+
+        return self::applyChomping(rtrim($folded, ' '), $chomping);
+    }
+
+    // -------------------------------------------------------------------------
+    // Collections inline  [a, b]  {k: v}
+    // -------------------------------------------------------------------------
+
+    private static function parseInlineCollection(string $raw, bool $assoc = false): mixed
+    {
+        $raw = trim($raw);
+        if ($raw[0] === '[') return self::parseInlineSequence($raw, $assoc);
+        if ($raw[0] === '{') return self::parseInlineMapping($raw, $assoc);
+        return self::parseScalar($raw);
+    }
+
+    private static function parseInlineSequence(string $raw, bool $assoc = false): array
+    {
+        $inner = trim(substr($raw, 1, strrpos($raw, ']') - 1));
+        if ($inner === '') return [];
+
+        return array_map(
+            fn($item) => self::parseInlineCollection(trim($item), $assoc),
+            self::splitInline($inner)
+        );
+    }
+
+    private static function parseInlineMapping(string $raw, bool $assoc = false): array|object
+    {
+        $inner = trim(substr($raw, 1, strrpos($raw, '}') - 1));
+        if ($inner === '') return $assoc ? [] : new \stdClass();
+
+        $result = [];
+        foreach (self::splitInline($inner) as $pair) {
+            $colonPos = strpos($pair, ':');
+            if ($colonPos === false) continue;
+            $k          = trim(substr($pair, 0, $colonPos));
+            $v          = trim(substr($pair, $colonPos + 1));
+            $result[$k] = self::parseInlineCollection($v, $assoc);
+        }
+        return $assoc ? $result : (object) $result;
+    }
+
+    private static function splitInline(string $str): array
+    {
+        $parts    = [];
+        $depth    = 0;
+        $current  = '';
+        $inSingle = false;
+        $inDouble = false;
+
+        for ($i = 0, $len = strlen($str); $i < $len; $i++) {
+            $c = $str[$i];
+
+            if ($c === "'" && !$inDouble) { $inSingle = !$inSingle; $current .= $c; continue; }
+            if ($c === '"'  && !$inSingle) { $inDouble = !$inDouble; $current .= $c; continue; }
+            if ($inSingle || $inDouble)    { $current .= $c; continue; }
+
+            if ($c === '[' || $c === '{') { $depth++; $current .= $c; continue; }
+            if ($c === ']' || $c === '}') { $depth--; $current .= $c; continue; }
+
+            if ($c === ',' && $depth === 0) { $parts[] = $current; $current = ''; continue; }
+            $current .= $c;
+        }
+
+        if ($current !== '') $parts[] = $current;
+        return $parts;
+    }
+
+    // -------------------------------------------------------------------------
+    // Scalaires
+    // -------------------------------------------------------------------------
+
+    private static function parseScalar(string $value): mixed
+    {
+        $value = trim($value);
+
+        if (!preg_match('/^[\'"]/', $value)) {
+            $value = rtrim(preg_replace('/(^|\s)#.*$/', '', $value));
+        }
+
+        if ($value === '') return null;
+
+        if (str_starts_with($value, '"') && str_ends_with($value, '"') && strlen($value) >= 2) {
+            return stripcslashes(substr($value, 1, -1));
+        }
+
+        if (str_starts_with($value, "'") && str_ends_with($value, "'") && strlen($value) >= 2) {
+            return str_replace("''", "'", substr($value, 1, -1));
+        }
+
+        if (in_array(strtolower($value), ['~', 'null'], true))           return null;
+        if (in_array(strtolower($value), ['true', 'yes', 'on'], true))   return true;
+        if (in_array(strtolower($value), ['false', 'no', 'off'], true))  return false;
+        if (preg_match('/^-?\d+$/', $value))                             return (int) $value;
+        if (preg_match('/^-?\d+\.\d*([eE][+-]?\d+)?$/', $value))        return (float) $value;
+        if (in_array(strtolower($value), ['.inf', '+.inf'], true))       return INF;
+        if (strtolower($value) === '-.inf')                              return -INF;
+        if (strtolower($value) === '.nan')                               return NAN;
+
+        return $value;
+    }
+
+    // -------------------------------------------------------------------------
+    // Utilitaires
+    // -------------------------------------------------------------------------
+
+    private static function getIndent(string $line): int
+    {
+        return strlen($line) - strlen(ltrim($line));
+    }
+
+    private static function isMapping(string $trimmed): bool
+    {
+        return (bool) preg_match('/^(?:"[^"]*"|\'[^\']*\'|[^:\'"\[\{]+):\s?/', $trimmed);
+    }
+
+    private static function splitKeyValue(string $line): array
+    {
+        if (preg_match('/^("(?:[^"\\\\]|\\\\.)*"|\'(?:[^\']|\'\')*\'|[^:]+?):\s*(.*)$/', $line, $m)) {
+            $key = self::parseScalar($m[1]);
+            $val = trim($m[2]) !== '' ? trim($m[2]) : null;
+            return [$key, $val];
+        }
+        return [$line, null];
+    }
+
+    private static function skipEmptyAndComments(array $lines, int &$pos): void
+    {
+        while ($pos < count($lines)) {
+            $t = trim($lines[$pos]);
+            if ($t === '' || str_starts_with($t, '#')) $pos++;
+            else break;
+        }
+    }
+
+    private static function getChomping(string $indicator): string
+    {
+        if (str_ends_with($indicator, '-')) return 'strip';
+        if (str_ends_with($indicator, '+')) return 'keep';
+        return 'clip';
+    }
+
+    private static function applyChomping(string $text, string $chomping): string
+    {
+        return match ($chomping) {
+            'strip' => rtrim($text, "\n"),
+            'keep'  => $text,
+            default => rtrim($text, "\n") . "\n",
+        };
+    }
+}

package/src/prepros.js

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path, { dirname } from "path";
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { getPHPRuntime, getPHPRuntimeWithNetwork } from "@kirigami/php-wasm";
+import isBinary from './utils/isbinary.js';
+import joinWith from './utils/joinwith.js'
+import yaml from "js-yaml";
+
+
+const __project = process.cwd();
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __configpath = path.join(__project, 'kirigami.yaml');
+
+
+const mountPath = (php, localPath, virtualDir) => {
+    const includeExtensions = new Set(['.php', '.json', '.yaml', '.md', '.db', ...(config?.prepros?.mountext || [])]);
+    const stat = fs.statSync(localPath);
+    if (stat.isDirectory()) {
+        php.mkdir(virtualDir);
+        for (const entry of fs.readdirSync(localPath, { withFileTypes: true })) {
+            mountPath(php, path.join(localPath, entry.name), virtualDir + '/' + entry.name);
+        }
+    } else {
+        const ext = path.extname(localPath).toLowerCase();
+        if (includeExtensions.has(ext)) {
+            const buf = fs.readFileSync(localPath);
+            php.writeFile(virtualDir, isBinary(buf) ? buf : buf.toString('utf8'));
+        }
+    }
+}
+
+
+const run = async (args) => {
+    php.setSpawnHandler((command, args, options) => spawn(command, args, options));
+    const output = await php.runStream({
+        scriptPath: '/prepros/prepros.php',
+        env: { PREPROS_ARGS: JSON.stringify(args), PREPROS_CONFIG: JSON.stringify(preprosConfig) }
+    });
+    const stdout = await output.stdoutText;
+    const stderr = await output.stderrText;
+    console.log(stdout);
+    let retobj;
+    try {
+        retobj = JSON.parse(stdout);
+		await Promise.all(retobj.files.map(async (file, i) => {
+			const buffer = php.readFileAsBuffer(file);
+			const dest = file.replace(/^\/project\//i, '');
+			fs.writeFileSync(path.join(__project, dest), buffer);
+			retobj.files[i] = dest;
+		}));
+    } catch(e) {
+        retobj = { success: false, error: 'Response parsing error.', response: stdout };
+    }
+    if (stderr) {
+        try {
+            retobj = JSON.parse(stderr);
+        } catch(e) { 
+            retobj = { success: false, error: stderr };
+        }
+    }
+    return retobj;
+}
+
+
+const render = async (file = '.') => {
+    const target = path.resolve(__project, config?.kirigami?.root, file);
+    const fsvm = path.join('/project', config?.kirigami?.root, file).replace(/\\/g, '/');
+    mountPath(php, target, fsvm);
+    return run([fsvm]);
+}
+
+
+const sitemap = async (dir) => {
+    mountPath(php, __root, '/project/' + config?.kirigami?.root);
+    return run(['sitemap']);
+}
+
+
+if (!fs.existsSync(__configpath)) throw `Config file not found: ${__configpath}`;
+const configContents = fs.readFileSync(__configpath, 'utf8');
+const config = yaml.load(configContents);
+if(!config) throw `Invalid config file: ${__configpath}`;
+
+
+if(config?.kirigami?.root === undefined) throw `Missing prepros:root property in config file: ${__configpath}`;
+const __root = path.join(__project, config.kirigami.root);
+if (!fs.existsSync(__root)) throw `Invalid prepros:root path: ${__root}`;
+
+
+const preprosConfig = config.prepros;
+preprosConfig.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+preprosConfig.root = joinWith('/project/', config?.kirigami?.root);
+preprosConfig.data = config.kirigami || {};
+
+
+const php = await (preprosConfig.network ? getPHPRuntimeWithNetwork() : getPHPRuntime());
+
+
+const mountPaths = [];
+const __cache = path.join(__project, '.cache.db');
+mountPath(php, __dirname, '/prepros');
+mountPath(php, joinWith(__project, config?.kirigami?.root), joinWith('/project', config?.kirigami?.root));
+if (fs.existsSync(__cache)) mountPath(php, __cache, '/project/.cache.db');
+
+
+export { render, sitemap };

package/src/prepros.php

@@ -0,0 +1,45 @@
+<?php
+
+ini_set('display_errors', 1);
+ini_set('log_errors', 1);
+ini_set('error_log', 'php://stderr');
+ini_set('html_errors', 0);
+ini_set('error_reporting', 32767);
+error_reporting(E_ALL);
+
+
+$argv = array_merge(['prepros.php'], json_decode(getenv('PREPROS_ARGS'), true));
+$config = json_decode(getenv('PREPROS_CONFIG'));
+
+
+try {
+
+    date_default_timezone_set($config->timezone);
+    if (!isset($argv[1])) STD::error("Invalid argument.");
+    include(__DIR__ . '/utils.inc.php');
+    PREPROS::loadConfig($config);
+    if($argv[1] == 'sitemap') {
+        if(!PREPROS::sitemap()) STD::error("Can't produce the sitemap.");
+        STD::succeed(['files' => PREPROS::getExportedFiles()]);
+    }
+    elseif (!$target = realpath($argv[1])) STD::error("Invalid target.");
+    else if (is_dir($target)) {
+        $prj = new PREPROS($config);
+        foreach (FS::dig($target . '/*.php') as $file) {
+            $parent = pathinfo(pathinfo($file, PATHINFO_DIRNAME), PATHINFO_BASENAME);
+            if (strpos($parent, '_') === 0) continue;
+            if (strpos(pathinfo($file, PATHINFO_FILENAME), '_') !== 0) continue;
+            PREPROS::render($file);
+        }
+    } elseif (preg_match('#^_(.*)\.php$#i', pathinfo($target, PATHINFO_BASENAME), $m)) {
+        PREPROS::render($target);
+    } else {
+        throw new Exception("Invalid target.");
+    }
+
+} catch(Exception $e) {
+    STD::error($e->getMessage());
+}
+
+
+STD::succeed(['files' => PREPROS::getExportedFiles()]);

package/src/utils/isbinary.js

@@ -0,0 +1,79 @@
+// Table de magic bytes compilée une seule fois au module load
+// Clé = premier octet, valeur = liste de signatures [octets, longueur à lire]
+const MAGIC_MAP = new Map([
+	[0x89, [[[0x89, 0x50, 0x4E, 0x47]]]],           // PNG
+	[0xFF, [[[0xFF, 0xD8, 0xFF]], [[0xFF, 0xFE]]]],  // JPEG, UTF-16 LE (text BOM)
+	[0x47, [[[0x47, 0x49, 0x46]]]],                  // GIF
+	[0x25, [[[0x25, 0x50, 0x44, 0x46]]]],             // PDF
+	[0x52, [[[0x52, 0x49, 0x46, 0x46]]]],             // WEBP/WAV (RIFF)
+	[0x77, [[[0x77, 0x4F, 0x46, 0x46]], [[0x77, 0x4F, 0x46, 0x32]]]],  // WOFF, WOFF2
+	[0x1F, [[[0x1F, 0x8B]]]],                       // GZIP
+	[0x50, [[[0x50, 0x4B, 0x03, 0x04]]]],             // ZIP
+	[0xEF, [[[0xEF, 0xBB, 0xBF]]]],                  // UTF-8 BOM (text!)
+	[0xFE, [[[0xFE, 0xFF]]]],                        // UTF-16 BE BOM (text!)
+	[0x00, [[[0x00, 0x00, 0xFE, 0xFF]]]],             // UTF-32 BE BOM (text!)
+]);
+
+// BOMs texte → jamais binaire, early exit immédiat
+const TEXT_BOMS = new Set([
+	'\xEF\xBB\xBF',   // UTF-8
+	'\xFF\xFE',        // UTF-16 LE
+	'\xFE\xFF',        // UTF-16 BE
+]);
+
+const SAMPLE_SIZE = 512; // 8 Ko c'est inutile pour un mount local
+
+/**
+ * Détection binaire en 3 passes avec early exit agressif.
+ * Optimisé pour être appelé sur des centaines de fichiers au démarrage.
+ *
+ * @param {Buffer} buf - Buffer du fichier (readFileSync)
+ * @returns {boolean}
+ */
+function isBinary(buf) {
+	const len = buf.length;
+	if (len === 0) return false;
+
+	const b0 = buf[0];
+
+	// Passe 1 — Magic bytes (O(1), max 4 comparaisons)
+	const candidates = MAGIC_MAP.get(b0);
+	if (candidates) {
+		for (const sigs of candidates) {
+			for (const sig of sigs) {
+				if (sig.every((b, i) => buf[i] === b)) {
+					// BOM texte → sortie immédiate "text"
+					if (b0 === 0xEF || b0 === 0xFE || (b0 === 0xFF && buf[1] === 0xFE)) return false;
+					if (b0 === 0x00 && buf[1] === 0x00) return false; // UTF-32
+					return true; // Binaire confirmé
+				}
+			}
+		}
+	}
+
+	const sample = Math.min(len, SAMPLE_SIZE);
+
+	// Passe 2 — Octet NUL (signal binaire quasi-certain, très fréquent dans les binaires)
+	// indexOf est natif C++ → beaucoup plus rapide qu'une boucle JS
+	if (buf.indexOf(0x00, 0, 'binary') !== -1 &&
+		buf.indexOf(0x00) < sample) return true;
+
+	// Passe 3 — Ratio statistique sur l'échantillon
+	let nonText = 0;
+	for (let i = 0; i < sample; i++) {
+		const b = buf[i];
+		if (b < 0x20) {
+			// Caractères de contrôle légitimes en texte
+			if (b !== 0x09 && b !== 0x0A && b !== 0x0D && b !== 0x0C && b !== 0x1B) {
+				nonText++;
+			}
+		} else if (b >= 0x80) {
+			nonText++;
+		}
+	}
+
+	return (nonText / sample) > 0.30;
+}
+
+
+export { isBinary as default }

package/src/utils/joinwith.js

@@ -0,0 +1,12 @@
+function joinWith(part1, part2, separator = '/', prefix = '') {
+	let join = '';
+	let separatorsFound = 0;
+	if (part1.endsWith(separator)) { separatorsFound += 1; }
+	if (part2.startsWith(separator)) { separatorsFound += 1; }
+	if (separatorsFound === 0) { join = separator; }
+	else if (separatorsFound === 2) { part1 = part1.substr(0, part1.length - separator.length); }
+	if (part1.startsWith(prefix)) { prefix = ''; }
+	return prefix + part1 + join + part2;
+}
+
+export { joinWith as default }