@kirigami/php-prepros 1.0.0

package/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @kirigami/php-prepros
+ *
+ * PHP preprocessor for the Kirigami static site generator.
+ * Runs PHP files through a WebAssembly PHP runtime to produce
+ * ready-to-deploy HTML pages.
+ *
+ * Requires a `kirigami.yaml` configuration file at the project root.
+ *
+ * @example
+ * ```js
+ * import { render, sitemap } from '@kirigami/php-prepros';
+ *
+ * // Compile a single page
+ * const result = await render('src/index.php');
+ *
+ * // Compile every page in the source directory
+ * const result = await render('src/');
+ *
+ * // Generate sitemap.xml
+ * const sitemap = await sitemap();
+ * ```
+ */
+
+
+// ---------------------------------------------------------------------------
+// Return types
+// ---------------------------------------------------------------------------
+
+/**
+ * Returned by every prepros operation.
+ */
+export interface PreprosResult {
+  /** `true` when the operation completed without errors. */
+  success: boolean;
+
+  /**
+   * Paths of every file written to disk by this operation (relative to the
+   * project root).  Includes the compiled HTML page(s) and any side-effect
+   * files such as `.cache.db` or resized images produced by `IMG::save()`.
+   */
+  files: string[];
+
+  /** Human-readable error message.  Only present when `success` is `false`. */
+  error?: string;
+
+  /**
+   * Raw PHP stdout / stderr, useful for debugging.
+   * Only present when response parsing fails.
+   */
+  response?: string;
+}
+
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Compile one PHP source file **or** an entire directory tree.
+ *
+ * - **Single file** — `_index.php` → `index.html` (leading underscore is
+ *   stripped from the output filename).
+ * - **Directory** — every `_*.php` file found recursively is compiled.
+ *   Files inside directories whose name starts with `_` are skipped.
+ *
+ * The PHPDOC block at the top of each source file drives the page:
+ *
+ * ```php
+ * <?php
+ * /**
+ *  * @name     index
+ *  * @title    My Page Title
+ *  * @abstract Short description used as <meta name="description">
+ *  * @articles _articles.yaml   ← auto-parsed and injected as $articles
+ *  * @data     _data.json        ← auto-parsed and injected as $data
+ *  *\/
+ * ?>
+ * ```
+ *
+ * Any `@tag filename` annotation whose extension is `.yaml`, `.yml`,
+ * `.json`, or `.md` is automatically loaded and made available as a PHP
+ * variable with the same name as the tag.  Remote URLs are supported when
+ * `network: true` is set in `kirigami.yaml`.
+ *
+ * @param file Path to a `.php` source file or a directory, relative to the
+ *             project root.  Defaults to `.` (the entire source tree).
+ *
+ * @returns A {@link PreprosResult} describing what was written.
+ *
+ * @throws When the `kirigami.yaml` config is missing or malformed.
+ * @throws When `kirigami.root` does not exist on disk.
+ */
+export function render(file?: string): Promise<PreprosResult>;
+
+
+/**
+ * Generate a `sitemap.xml` at the source root.
+ *
+ * Scans every `_index.php` found in the source tree and produces a
+ * standard Sitemaps 0.9 XML document.  Priority is calculated from depth
+ * (root = 1.0, each extra level −0.1).  `changefreq` is set to `weekly`.
+ *
+ * The base URL is taken from `kirigami.baseurl` in `kirigami.yaml`.
+ *
+ * @returns A {@link PreprosResult} with `files` containing the path to the
+ *          generated `sitemap.xml`.
+ */
+export function sitemap(dir?: string): Promise<PreprosResult>;

package/index.js

@@ -0,0 +1 @@
+export { render, sitemap } from "./src/prepros.js";

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@kirigami/php-prepros",
+  "version": "1.0.0",
+  "description": "PHP preprocessor for the Kirigami static site generator. Compile PHP page templates to clean, deployable HTML — with zero server dependency.",
+  "keywords": [
+    "kirigami",
+    "php",
+    "preprocessor",
+    "static-site-generator",
+    "ssg",
+    "wasm",
+    "php-wasm",
+    "markdown",
+    "yaml",
+    "github-pages",
+    "pages"
+  ],
+  "license": "MIT",
+  "author": "Maxime Larrivée-Roy",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "src/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.10.0",
+    "npm": ">=10.2.3"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@kirigami/php-wasm": "8.5.7-1",
+    "js-yaml": "^4.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/php-kirigami/kirigami"
+  },
+  "homepage": "https://github.com/php-kirigami/kirigami/#readme",
+  "bugs": {
+    "url": "https://github.com/php-kirigami/kirigami/issues"
+  }
+}

package/src/libraries/cache.class.php

@@ -0,0 +1,101 @@
+<?php
+
+// SYS::requireExtension('sqlite3');
+
+
+class CACHE
+{
+    const DB_TIMEOUT = 10000;
+
+
+    private static function db(): SQLite3
+    {
+        static $db = null;
+        if($db !== null) return $db;
+
+        if(!empty($_SERVER['NODE_PROJECT'])) $root = $_SERVER['NODE_PROJECT'] . '/';
+        elseif(!empty(PREPROS::$config->root)) $root = rtrim(PREPROS::$config->root, '/') . '/';
+        else throw new Exception("Can't find project root.");
+        
+        if(!is_file(($dbfile = self::getPath()))) $create = true;
+        if(!$db = new SQLite3($dbfile)) throw new Exception("Can't open .cache.db.");
+        
+        $db->busyTimeout(static::DB_TIMEOUT);
+        if(!empty($create) && !$db->exec('
+            CREATE TABLE "data" (
+                "key"        TEXT(128) NOT NULL,
+                "val"        TEXT      DEFAULT NULL,
+                "inserted_at" INTEGER  NOT NULL DEFAULT 0,
+                "ttl"        INTEGER  NOT NULL DEFAULT 0,
+                PRIMARY KEY ("key")
+            );
+            CREATE UNIQUE INDEX "key" ON "data" ("key");
+        ')) throw new Exception("Can't create .cache.db.");
+        return $db;
+    }
+
+
+    private static function getPath() {
+        return '/project/.cache.db';
+    }
+
+
+    public static function get(string $key): mixed
+    {
+        static $query = null;
+        if(!$query) $query = self::db()->prepare(
+            "SELECT val FROM data
+             WHERE key = ?
+               AND (ttl = 0 OR inserted_at + ttl >= :now)"
+        );
+        $query->bindValue(1, $key, SQLITE3_TEXT);
+        $query->bindValue(':now', time(), SQLITE3_INTEGER);
+        $result = $query->execute();
+        $query->reset();
+        if(!$result) return null;
+        $row = $result->fetchArray(SQLITE3_ASSOC);
+        $result->finalize();
+        if($row === false) return null;
+        return unserialize($row['val']);
+    }
+
+
+    public static function set(string $key, mixed $val, int $ttl = 0): bool
+    {
+        static $query = null;
+        if(!$query) $query = self::db()->prepare(
+            "INSERT OR REPLACE INTO data(key, val, inserted_at, ttl)
+             VALUES(?, ?, ?, ?)"
+        );
+        $query->bindValue(1, $key,           SQLITE3_TEXT);
+        $query->bindValue(2, serialize($val), SQLITE3_TEXT);
+        $query->bindValue(3, time(),          SQLITE3_INTEGER);
+        $query->bindValue(4, $ttl,            SQLITE3_INTEGER);
+        $success = (bool)@$query->execute();
+        $query->reset();
+        PREPROS::exportFile(self::getPath());
+        return $success;
+    }
+
+
+    public static function purge(): bool
+    {
+        PREPROS::exportFile(self::getPath());
+        return (bool)self::db()->exec(
+            "DELETE FROM data WHERE ttl > 0 AND inserted_at + ttl < " . time()
+        );
+    }
+
+
+    public static function delete(string $key): bool
+    {
+        static $query = null;
+        if(!$query) $query = self::db()->prepare("DELETE FROM data WHERE key = ?");
+        $query->bindValue(1, $key, SQLITE3_TEXT);
+        $success = (bool)@$query->execute();
+        $query->reset();
+        PREPROS::exportFile(self::getPath());
+        return $success;
+    }
+
+}

package/src/libraries/fs.class.php

@@ -0,0 +1,133 @@
+<?php
+
+
+class FS
+{
+
+
+	public static function dig(string $path): iterable
+	{
+		$patt = pathinfo($path, PATHINFO_BASENAME);
+		$path = pathinfo($path, PATHINFO_DIRNAME);
+		if ($path = realpath($path)) {
+			$path .= '/';
+			foreach (glob($path . $patt) as $file) {
+				if (!is_dir($file)) yield $file;
+			}
+			foreach (glob($path . '*', GLOB_ONLYDIR) as $dir) {
+				foreach (call_user_func(__METHOD__, $dir . '/' . $patt) as $file) yield $file;
+			}
+		}
+	}
+
+
+	public static function getRelativePath(string $from, string $to): string
+	{
+		$from     = is_dir($from) ? rtrim($from, '\/') . '/' : $from;
+		$to       = is_dir($to)   ? rtrim($to, '\/') . '/'   : $to;
+		$from     = str_replace('\\', '/', $from);
+		$to       = str_replace('\\', '/', $to);
+		$from     = explode('/', $from);
+		$to       = explode('/', $to);
+		$relPath  = $to;
+
+		foreach ($from as $depth => $dir) {
+			if ($dir === $to[$depth]) {
+				array_shift($relPath);
+			} else {
+				$remaining = count($from) - $depth;
+				if ($remaining > 1) {
+					$padLength = (count($relPath) + $remaining - 1) * -1;
+					$relPath = array_pad($relPath, $padLength, '..');
+					break;
+				} else {
+					$relPath[0] = './' . $relPath[0];
+				}
+			}
+		}
+		return $relPath ? implode('/', $relPath) : './';
+	}
+
+
+	public static function phpFileInfo(string $file): object|bool
+	{
+		static $files = [];
+		if (!$file = realpath($file)) return false;
+		if (!isset($files[$file])) {
+			$tokens = token_get_all(file_get_contents($file));
+			foreach ($tokens as $tok) {
+				if (!is_array($tok)) continue;
+				if ($tok[0] == T_DOC_COMMENT) {
+					$block = $tok[1];
+					break;
+				}
+			}
+			if (empty($block)) return new stdClass;
+			if (!preg_match_all('#@([a-z0-9]+)[\s\t]+([^\n]+)#msi', $block, $m)) $files[$file] = new stdClass;
+			else {
+				$info = [];
+				foreach ($m[1] as $k => $v) $info[trim($v)] = trim($m[2][$k]);
+				$files[$file] = (object)$info;
+			}
+		}
+		return $files[$file];
+	}
+
+
+	public static function rmdir(string $dir, bool $removeSelf = true): bool
+	{
+		if (!file_exists($dir)) return true;
+		if (is_file($dir) || is_link($dir)) return @unlink($dir);
+		$items = @scandir($dir);
+		if ($items === false) return false;
+		foreach ($items as $item) {
+			if ($item === '.' || $item === '..') continue;
+			$path = $dir . DIRECTORY_SEPARATOR . $item;
+			if (is_dir($path) && !is_link($path)) {
+				if (!call_user_func(__METHOD__, $path, true)) return false;
+			} else {
+				if (!@unlink($path)) return false;
+			}
+		}
+		return $removeSelf ? @rmdir($dir) : true;
+	}
+
+
+	public static function pathJoin(string ...$parts): string
+	{
+		if (empty($parts)) return '';
+		$isAbsolute = str_starts_with($parts[0], '/');
+		$hasTrailingSlash = str_ends_with(end($parts), '/');
+
+		$prefix = '';
+		$isUrl = (bool) preg_match('#^[a-zA-Z][a-zA-Z0-9+\-.]*://#', $parts[0]);
+		if ($isUrl) {
+			preg_match('#^([a-zA-Z][a-zA-Z0-9+\-.]*://[^/]*)(.*)$#', $parts[0], $m);
+			$prefix   = $m[1];
+			$parts[0] = $m[2] ?? '';
+		}
+
+		$merged = implode('/', $parts);
+		$merged = preg_replace('#/+#', '/', $merged);
+
+		$segments = explode('/', $merged);
+		$resolved = [];
+		foreach ($segments as $seg) {
+			if ($seg === '' || $seg === '.') {
+				continue;
+			}
+			if ($seg === '..') {
+				if (!empty($resolved)) {
+					array_pop($resolved);
+				}
+			} else {
+				$resolved[] = $seg;
+			}
+		}
+
+		$path = implode('/', $resolved);
+		if ($isAbsolute || $isUrl) $path = '/' . $path;
+		if ($hasTrailingSlash && !str_ends_with($path, '/')) $path .= '/';
+		return $prefix . $path;
+	}
+}

package/src/libraries/html.class.php

@@ -0,0 +1,176 @@
+<?php
+
+/**
+ * HtmlFormatter — formateur HTML pour Kirigami
+ * Utilise Dom\HTMLDocument (PHP 8.4, moteur Lexbor) pour parser,
+ * puis re-sérialise avec indentation.
+ * Les blocs <script> et <style> sont indentés au bon niveau mais non reformatés.
+ */
+class HTML
+{
+    private const INDENT = 4;
+
+    // Attributs booléens HTML5 — écrits sans valeur
+    private const BOOLEAN_ATTRS = [
+        'allowfullscreen', 'async', 'autofocus', 'autoplay', 'checked',
+        'controls', 'default', 'defer', 'disabled', 'formnovalidate',
+        'hidden', 'ismap', 'loop', 'multiple', 'muted', 'nomodule',
+        'noopener', 'noreferrer', 'novalidate', 'open', 'playsinline',
+        'readonly', 'required', 'reversed', 'selected', 'webkit-playsinline',
+    ];
+
+    // Éléments inline — leur présence dans un parent n'empêche pas le rendu inline
+    private const INLINE = [
+        'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'button', 'cite',
+        'code', 'dfn', 'em', 'i', 'img', 'input', 'kbd', 'label', 'map',
+        'mark', 'object', 'output', 'q', 's', 'samp', 'select', 'small',
+        'span', 'strong', 'sub', 'sup', 'textarea', 'time', 'tt', 'u', 'var',
+    ];
+
+    private const RAW  = ['script', 'style'];
+    private const VOID = [
+        'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+        'link', 'meta', 'source', 'track', 'wbr',
+    ];
+
+    public static function format(string $html): string
+    {
+        $dom = Dom\HTMLDocument::createFromString($html, LIBXML_NOERROR);
+
+        $output = '';
+        foreach ($dom->childNodes as $node) {
+            $output .= static::renderNode($node, 0);
+        }
+
+        $output = preg_replace('/\n{3,}/', "\n\n", $output);
+
+        return rtrim($output) . "\n";
+    }
+
+    private static function renderNode(Dom\Node $node, int $depth): string
+    {
+        return match ($node->nodeType) {
+            XML_TEXT_NODE          => static::renderText($node, $depth),
+            XML_COMMENT_NODE       => static::renderComment($node, $depth),
+            XML_DOCUMENT_TYPE_NODE => static::renderDoctype(),
+            default                => static::renderElement($node, $depth),
+        };
+    }
+
+    private static function renderElement(Dom\Node $node, int $depth): string
+    {
+        $tag    = strtolower($node->nodeName);
+        $pad    = str_repeat(' ', $depth * self::INDENT);
+        $attrs  = static::renderAttrs($node);
+        $isVoid = in_array($tag, self::VOID, true);
+        $isRaw  = in_array($tag, self::RAW,  true);
+
+        if ($isVoid) {
+            return "{$pad}<{$tag}{$attrs}>\n";
+        }
+
+        if ($isRaw) {
+            $inner = trim($node->innerHTML, "\n\r");
+            if (trim($inner) === '') {
+                return "{$pad}<{$tag}{$attrs}></{$tag}>\n";
+            }
+            $childPad = str_repeat(' ', ($depth + 1) * self::INDENT);
+            $lines    = explode("\n", $inner);
+
+            // Calcule le niveau d'indentation minimal existant (ignore les lignes vides)
+            $minIndent = PHP_INT_MAX;
+            foreach ($lines as $line) {
+                if (trim($line) === '') continue;
+                $minIndent = min($minIndent, strlen($line) - strlen(ltrim($line)));
+            }
+            $minIndent = $minIndent === PHP_INT_MAX ? 0 : $minIndent;
+
+            // Dédente puis ré-indente au bon niveau
+            $indented = implode("\n", array_map(
+                static fn(string $line) => trim($line) !== ''
+                    ? $childPad . substr($line, $minIndent)
+                    : '',
+                $lines
+            ));
+            return "{$pad}<{$tag}{$attrs}>\n" . rtrim($indented) . "\n{$pad}</{$tag}>\n";
+        }
+
+        $children = iterator_to_array($node->childNodes);
+
+        if (empty($children)) {
+            return "{$pad}<{$tag}{$attrs}></{$tag}>\n";
+        }
+
+        // Si tous les enfants sont inline, on utilise innerHTML tel quel — pas de reconstruction
+        if (static::hasOnlyInlineChildren($node)) {
+            $inner = trim($node->innerHTML);
+            return "{$pad}<{$tag}{$attrs}>{$inner}</{$tag}>\n";
+        }
+
+        $inner = '';
+        foreach ($children as $child) {
+            $inner .= static::renderNode($child, $depth + 1);
+        }
+
+        return "{$pad}<{$tag}{$attrs}>\n{$inner}{$pad}</{$tag}>\n";
+    }
+
+    // Vérifie que tous les descendants directs sont inline (texte, void inline, éléments inline)
+    // Les éléments inline eux-mêmes ne doivent pas contenir d'éléments block
+    private static function hasOnlyInlineChildren(Dom\Node $node): bool
+    {
+        foreach ($node->childNodes as $child) {
+            if ($child->nodeType === XML_TEXT_NODE) {
+                continue;
+            }
+            if ($child->nodeType !== XML_ELEMENT_NODE) {
+                return false;
+            }
+            if (!in_array(strtolower($child->nodeName), self::INLINE, true)) {
+                return false;
+            }
+            // Récursif : l'élément inline ne doit pas contenir d'éléments block
+            if (!static::hasOnlyInlineChildren($child)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static function renderText(Dom\Node $node, int $depth): string
+    {
+        $text = trim($node->nodeValue);
+        if ($text === '') {
+            return '';
+        }
+        $pad = str_repeat(' ', $depth * self::INDENT);
+        return $pad . htmlspecialchars($text, ENT_QUOTES | ENT_HTML5, 'UTF-8') . "\n";
+    }
+
+    private static function renderComment(Dom\Node $node, int $depth): string
+    {
+        $pad = str_repeat(' ', $depth * self::INDENT);
+        return "{$pad}<!--{$node->nodeValue}-->\n";
+    }
+
+    private static function renderDoctype(): string
+    {
+        return "<!DOCTYPE html>\n";
+    }
+
+    private static function renderAttrs(Dom\Node $node): string
+    {
+        $out = '';
+        if (!$node->hasAttributes()) {
+            return $out;
+        }
+        foreach ($node->attributes as $attr) {
+            if (in_array($attr->name, self::BOOLEAN_ATTRS, true)) {
+                $out .= ' ' . $attr->name;
+            } else {
+                $out .= ' ' . $attr->name . '="' . htmlspecialchars($attr->value, ENT_QUOTES | ENT_HTML5, 'UTF-8') . '"';
+            }
+        }
+        return $out;
+    }
+}

package/src/libraries/img.class.php

@@ -0,0 +1,122 @@
+<?php
+
+
+class IMG
+{
+
+	private GdImage|null $im = null;
+	private array|null $info = null;
+
+
+	public function __construct(string $file)
+	{
+		if (!is_file($file) || !is_readable($file)) throw new Exception("Source file unreadable.");
+
+		$this->info = @getimagesize($file);
+		if (!$this->info) throw new Exception("Invalid image file.");
+
+		[$srcW, $srcH, $type] = $this->info;
+		if ($srcW <= 0 || $srcH <= 0) throw new Exception("Invalid image file.");
+
+		$this->im = match ($type) {
+			IMAGETYPE_JPEG => @imagecreatefromjpeg($file),
+			IMAGETYPE_PNG  => @imagecreatefrompng($file),
+			IMAGETYPE_GIF  => @imagecreatefromgif($file),
+			IMAGETYPE_WEBP => (function_exists('imagecreatefromwebp') ? @imagecreatefromwebp($file) : null),
+			default => throw new Exception("Image format not supported."),
+		};
+	}
+
+
+	public function __get(string $name)
+	{
+		switch (strtolower($name)) {
+			case "w":
+			case "width":
+				return imagesx($this->im);
+			case "h":
+			case "height":
+				return imagesy($this->im);
+		}
+	}
+
+
+	private function setNew(GdImage $im) {
+		$this->im = $im;
+		return $this;
+	}
+
+
+	public function resize(int $width, int $height = 0, bool $cover = false)
+	{
+		$srcRatio = $this->width / $this->height;
+
+		if (!$height) {
+			$height = $this->height * $width / $this->width;
+			$dstRatio = $srcRatio;
+		} else {
+			$dstRatio = $width / $height;
+		}
+
+		if ($cover) { // ===> Cover
+			if ($srcRatio > $dstRatio) {
+				$cropH = $this->height;
+				$cropW = (int) round($this->height * $dstRatio);
+			} else {
+				$cropW = $this->width;
+				$cropH = (int) round($this->width / $dstRatio);
+			}
+
+			$srcX = (int) max(0, floor(($this->width - $cropW) / 2));
+			$srcY = (int) max(0, floor(($this->height - $cropH) / 2));
+			$outW = $width;
+			$outH = $height;
+			$dst = $this->prepare($outW, $outH);
+			$ok = imagecopyresampled($dst, $this->im, 0, 0, $srcX, $srcY, $outW, $outH, $cropW, $cropH);
+		} else { // ===> Contain
+			$scale = min($width / $this->width, $height / $this->height);
+			$outW = (int) max(1, round($this->width * $scale));
+			$outH = (int) max(1, round($this->height * $scale));
+			$dst = $this->prepare($outW, $outH);
+			$ok = imagecopyresampled($dst, $this->im, 0, 0, 0, 0, $outW, $outH, $this->width, $this->height);
+		}
+
+		if (!$ok) throw new Exception("Can't resample source image.");
+
+		return $this->setNew($dst);
+	}
+
+
+	private function prepare(int $x, int $y): GdImage
+	{
+		$img = imagecreatetruecolor($x, $y);
+		$hasAlpha = in_array($this->info[2], [IMAGETYPE_PNG, IMAGETYPE_WEBP, IMAGETYPE_GIF], true);
+		if ($hasAlpha) {
+			imagealphablending($img, false);
+			imagesavealpha($img, true);
+			$transparent = imagecolorallocatealpha($img, 0, 0, 0, 127);
+			imagefilledrectangle($img, 0, 0, imagesx($img), imagesy($img), $transparent);
+		} else {
+			$white = imagecolorallocate($img, 255, 255, 255);
+			imagefilledrectangle($img, 0, 0, imagesx($img), imagesy($img), $white);
+		}
+		return $img;
+	}
+
+
+	public function save(string $dest): self
+	{
+		$ext = strtolower(pathinfo($dest, PATHINFO_EXTENSION));
+		$dir = pathinfo($dest, PATHINFO_DIRNAME);
+		if (!is_dir($dir) && !@mkdir($dir, 0777, true)) throw new Exception("Invalid destination.");
+		match ($ext) {
+			'jpg', 'jpeg' => imagejpeg($this->im, $dest, 85),
+			'png'         => imagepng($this->im, $dest, 6),
+			'gif'         => imagegif($this->im, $dest),
+			'webp'        => (function_exists('imagewebp') ? imagewebp($this->im, $dest, 85) : false),
+			default       => throw new Exception("Invalid output file type.")
+		};
+		PREPROS::exportFile(realpath($dest));
+		return $this;
+	}
+}