fazer-lang 2.1.2 → 2.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Fazer Corp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,241 +1,49 @@
-# Fazer Language Reference Manual
+# Fazer
 
-> **The Next-Generation Scripting Language for High-Performance Computing & Security.**
-> *Copyright © 2026 L'EMPRISE. All Rights Reserved.*
+**Fazer** — Le langage de script nouvelle génération par **L'EMPRISE**.
 
-[![npm version](https://img.shields.io/npm/v/fazer-lang.svg)](https://www.npmjs.com/package/fazer-lang)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+Conçu pour l'automatisation, la sécurité et le traitement de données, Fazer combine une syntaxe concise avec une bibliothèque standard "batteries included".
 
----
+## Installation
 
-## 1. Introduction
-
-**Fazer (fz)** is not just another scripting language. It is a precision tool engineered by **L'EMPRISE** for developers who demand **clarity**, **security**, and **efficiency**. 
-
-Unlike traditional languages that bury logic in verbose syntax, Fazer prioritizes the **Data Flow**. By utilizing the revolutionary Arrow Pipe Operator (`→>`), Fazer allows data to flow naturally from one operation to the next, mirroring the human thought process.
-
-### Why Fazer?
-
-*   **Superior Readability**: Logic flows left-to-right. No more nesting hell `func(func(func(x)))`.
-*   **Security First**: AES-256-GCM encryption is a first-class citizen, not an afterthought.
-*   **Batteries Included**: HTTP Server, FileSystem, System Execution, and JSON parsing are built-in. No external dependencies required for standard tasks.
-*   **Universal Compatibility**: Runs on any Node.js environment or compiles to a standalone, dependency-free Binary (EXE/Linux).
-
----
-
-## 2. Installation
-
-### Global Installation (Recommended)
-To access the `fazer` command globally on your system:
+Installez Fazer globalement via npm :
 
 ```bash
 npm install -g fazer-lang
 ```
 
-### Verification
-```bash
-fazer --version
-# Output: 2.1.0
-```
-
----
-
-## 3. The Core Philosophy: The Pipe (`→>`)
-
-In most languages, you write:
-```javascript
-// JavaScript / Python style
-print(sha256(readFile("data.txt")));
-```
-This requires reading "inside-out".
-
-**In Fazer, you write:**
-```fazer
-"data.txt" →> readText() →> sha256() →> print()
-```
-This is the **Pipeline Architecture**. The result of the left side is automatically injected as the *first argument* of the function on the right.
-
----
-
-## 4. Language Guide
-
-### Variables & Constants
-Fazer uses dynamic typing. Variables are declared implicitly.
-
-```fazer
-x = 10
-name = "L'EMPRISE"
-isActive = true
-```
-
-### Data Types
-*   **String**: `"Hello World"` (supports concatenation with `+`)
-*   **Number**: `42`, `3.14`
-*   **Boolean**: `true`, `false`
-*   **Object/Map**: `{"key": "value"}`
-*   **Null**: `null`
-
-### Control Flow: The Power of `case`
-Fazer replaces the archaic `if/else/switch` with a unified, powerful `case` structure.
-
-```fazer
-fn analyze(val) →
-  case val
-    0 → println("Zero detected") end
-    > 100 → println("High value detected") end
-    "admin" → println("Access Granted") end
-    else → println("Unknown value") end
-  end
-end
-```
-
-### Functions (`fn`)
-Functions are first-class citizens.
-
-```fazer
-fn multiply(a, b) →
-  return(a * b)
-end
-
-# Using with pipe
-5 →> multiply(10) →> println() # Output: 50
-```
-
----
-
-## 5. Standard Library Reference (StdLib)
-
-Fazer comes equipped with a professional-grade standard library.
-
-### 5.1. Input / Output & UI (`IO`)
+## Utilisation Rapide
 
-*   **`print(val)`**: Prints value to stdout (no newline).
-*   **`println(val)`**: Prints value with newline.
-*   **`ask(prompt)`**: Pauses execution and waits for user input. Returns the string entered.
-*   **`style(text, color)`**: Applies ANSI colors to text.
-    *   *Colors*: `"red"`, `"green"`, `"yellow"`, `"blue"`, `"magenta"`, `"cyan"`, `"white"`, `"gray"`.
-*   **`box(title, lines...)`**: Renders a professional ASCII interface box. Automatically handles alignment and ANSI codes.
-
-```fazer
-box("SYSTEM ALERT", "Access Restricted", style("L'EMPRISE Protocol", "red"))
-```
-
-### 5.2. Cryptography (`Crypto`)
-**Security Level: Military Grade (AES-256-GCM).**
-
-*   **`sha256(data)`**: Returns the SHA-256 hash of the data (hex string).
-*   **`encText(plainText, password)`**: Encrypts text using AES-256-GCM. Returns a secure JSON string containing IV, AuthTag, and Ciphertext.
-*   **`decText(encryptedJson, password)`**: Decrypts the JSON string. Throws error if password is wrong or integrity is compromised.
-
-```fazer
-pass = "super_secret"
-"My Secret Data" →> encText(pass) →> saveText("secret.enc")
-```
-
-### 5.3. File System (`FS`)
-Robust, synchronous file operations.
-
-*   **`readText(path)`**: Reads file as UTF-8 string.
-*   **`saveText(content, path)`**: Writes string to file (overwrites).
-*   **`readB64(path)`**: Reads file as Base64 string (useful for binaries).
-*   **`saveB64(content, path)`**: Writes Base64 string to file.
-*   **`exists(path)`**: Returns `true` if file/directory exists, `false` otherwise.
-*   **`ls(path)`**: Returns an array of file names in the directory.
-*   **`rm(path)`**: Recursively deletes a file or directory. **Handle with care.**
-*   **`mkdir(path)`**: Creates a directory (recursive).
-
-### 5.4. Networking & Web (`Net`)
-Create high-performance web servers instantly.
-
-*   **`server(port, handlerFunctionName)`**: Starts a blocking HTTP server.
-
-**Example Web Server:**
-```fazer
-fn handler(req) →
-  # req has .method, .url, .headers
-  println("Hit: " + req.url)
-  
-  return({
-    "status": 200,
-    "headers": { "Content-Type": "application/json" },
-    "body": json({ "message": "Welcome to Fazer API" })
-  })
-end
-
-server(3000, "handler")
+Lancer le REPL (mode interactif) :
+```bash
+fazer
 ```
 
-### 5.5. System & Utilities (`Sys`)
-
-*   **`exec(command)`**: Executes a shell command and returns the output (stdout).
-*   **`json(obj)`**: Serializes an object/array to a JSON string.
-*   **`parseJson(jsonString)`**: Parses a JSON string into an object.
-
----
-
-## 6. Advanced Usage: Building Standalone Executables
-
-You can compile your Fazer scripts into standalone executables (`.exe` for Windows, binary for Linux) that do not require Node.js or Fazer to be installed on the target machine.
-
-**Command:**
+Exécuter un script :
 ```bash
-# Requires 'pkg' installed via npm
-pkg fazer.js --targets node18-win-x64,node18-linux-x64 --output my_app
+fazer mon_script.fz
 ```
 
-This capability makes Fazer the ideal choice for deploying secure, self-contained tools to client environments.
-
----
-
-## 8. Fazer vs The World: A Technical Comparison
-
-Why choose Fazer when you have JavaScript, Python, or Go? Because Fazer is designed for a specific purpose: **High-level Orchestration with Low-level Power**.
-
-### 8.1. Fazer vs JavaScript / Node.js
-
-*   **The Problem with JS**: "Callback Hell" and "Promise Chaining". JavaScript forces you to write code "inside-out" or manage endless `.then()` chains.
-    *   *JS*: `process(parse(read(file)))`
-*   **The Fazer Solution**: Linear data flow. The pipe operator (`→>`) is not just sugar; it's the core of the language.
-    *   *Fazer*: `file →> read() →> parse() →> process()`
-*   **Ecosystem**: To get encryption, HTTP server, and file system operations in Node.js, you often need to install external packages or write boilerplate code using `fs`, `http`, and `crypto` modules. Fazer includes these batteries **natively**. `encText` and `server` are there from line 1.
-
-### 8.2. Fazer vs Python
-
-*   **Distribution**: Sharing a Python script is painful. The user needs Python installed, then `pip install -r requirements.txt`, and version conflicts are common.
-*   **Fazer's Edge**: Fazer compiles to a **single, standalone binary** (EXE for Windows, Bin for Linux). You give the file to the user, they double-click, and it runs. No installation, no dependencies, no friction.
-*   **Performance**: While Python interprets line-by-line, Fazer's lightweight runtime is optimized for rapid I/O and cryptographic operations, making it feel snappier for CLI tools.
-
-### 8.3. Fazer vs Bash / Shell
-
-*   **Cross-Platform Nightmare**: A Bash script written for Linux often fails on Windows (PowerShell/CMD) or macOS due to syntax differences (`ls` vs `dir`, `/` vs `\`).
-*   **Fazer's Universality**: Fazer abstracts the operating system. `ls()`, `rm()`, and `exec()` work identically on Windows, Linux, and macOS. Write once, control any system.
-*   **Safety**: Bash has no real error handling or types. A wrong variable expansion can delete your hard drive (`rm -rf /$VAR`). Fazer provides a structured, safe environment with scoped variables and error handling.
-
-### 8.4. Fazer vs C/C++
-
-*   **Development Speed**: Writing a secure HTTP server with AES encryption in C++ takes days and hundreds of lines of code. In Fazer, it takes **5 lines**.
-*   **Memory Safety**: No manual memory management, no buffer overflows, no segmentation faults. Fazer handles the dirty work so you can focus on the logic.
-
-### Summary Table
-
-| Feature | Fazer | JavaScript | Python | Bash |
-| :--- | :---: | :---: | :---: | :---: |
-| **Pipeline Logic** | ✅ Native (`→>`) | ❌ (Plugins needed) | ❌ | ✅ (Pipes `|`) |
-| **Distribution** | ✅ Single Binary | ❌ (Requires Runtime) | ❌ (Complex) | ✅ (Source only) |
-| **Cryptography** | ✅ Built-in AES-256 | ⚠️ Module required | ⚠️ Module required | ❌ External tools |
-| **Cross-Platform** | ✅ 100% | ✅ | ✅ | ❌ |
-| **Setup Time** | ⚡ Instant | 🐢 Slow (npm install) | 🐢 Slow (pip install) | ⚡ Instant |
+## Documentation
 
----
+La documentation complète est disponible dans le dossier [`docs/`](./docs/README.md).
 
-## 9. Copyright & Legal
+*   [Guide de Démarrage](./docs/getting-started.md)
+*   [Syntaxe du Langage](./docs/syntax.md)
+*   [Bibliothèque Standard (Stdlib)](./docs/stdlib.md)
+*   [Exemples](./docs/examples.md)
 
-**Fazer Language** is a proprietary technology developed by **L'EMPRISE**.
-Unauthorized reproduction of the core interpreter logic without attribution is prohibited.
+## Fonctionnalités Clés
 
-*   **Copyright**: © 2026 L'EMPRISE.
-*   **License**: MIT (Open Source for usage).
+*   **Pipe Operator (`->>`)** : Enchaînez les opérations proprement.
+*   **Pattern Matching (`case`)** : Contrôle de flux expressif.
+*   **Sécurité Intégrée** : Chiffrement AES-256-GCM et SHA256 natifs.
+*   **Réseau & Web** : Client HTTP `fetch`, serveur web `server`, et module `discord`.
+*   **Système de Fichiers** : Manipulation simple et puissante.
+*   **Automation** : Gestion du presse-papier (`clipboard`), menus interactifs, et persistance (`db`).
+*   **Extensible** : Système de modules `import`.
 
----
+## Copyright
 
-> *"Control the code, control the world."* — **L'EMPRISE**
+© 2024 **L'EMPRISE**. Tous droits réservés.
+Distribué sous licence MIT.

package/docs/README.md

@@ -0,0 +1,26 @@
+# Documentation Fazer
+
+Bienvenue dans la documentation officielle du langage **Fazer**.
+
+## Table des Matières
+
+1.  **[Guide de Démarrage](./getting-started.md)**
+    *   Installation
+    *   Votre premier script
+    *   Mode interactif (REPL)
+
+2.  **[Syntaxe du Langage](./syntax.md)**
+    *   Variables et Types
+    *   Opérateur Pipe (`->>`)
+    *   Contrôle de Flux (`case`)
+    *   Fonctions
+
+3.  **[Bibliothèque Standard (Stdlib)](./stdlib.md)**
+    *   E/S Console (`println`, `ask`...)
+    *   Système de Fichiers (`readText`, `writeText`...)
+    *   Chiffrement (`encText`, `sha256`...)
+    *   Réseau & Web (`server`, `fetch`, `discord`...)
+    *   Utilitaires (`json`, `exec`...)
+
+4.  **[Exemples](./examples.md)**
+    *   Scripts complets pour apprendre par l'exemple.

package/docs/examples.md

@@ -0,0 +1,60 @@
+# Exemples Fazer
+
+## 1. Hello World
+
+```fazer
+"Hello World" ->> println
+```
+
+## 2. Demander le nom
+
+```fazer
+"Quel est votre nom ? " ->> ask ->> println
+```
+
+## 3. Chiffrement de Fichier (Logique simplifiée)
+
+Ce script montre comment on pourrait structurer un outil de chiffrement.
+
+```fazer
+fn main () {
+  "1. Chiffrer" ->> println
+  "2. Déchiffrer" ->> println
+  "Choix : " ->> ask ->> case {
+    "1" : {
+      "Fichier à chiffrer : " ->> ask ->> enc_flow
+    }
+    "2" : {
+      "Fichier à déchiffrer : " ->> ask ->> dec_flow
+    }
+    _ : {
+      "Choix invalide" ->> println
+    }
+  }
+}
+
+fn enc_flow (path) {
+  path ->> exists ->> case {
+    true : {
+      "Mot de passe : " ->> ask ->> pass
+      path ->> readText ->> encText(pass) ->> saveText(path)
+      "Fichier chiffré !" ->> println
+    }
+    _ : { "Fichier introuvable" ->> println }
+  }
+}
+
+// Lancer le main
+main()
+```
+
+## 4. Serveur Web Simple
+
+```fazer
+fn handle_request (req) {
+  "<h1>Bienvenue sur Fazer Web</h1>" // Retourne le HTML
+}
+
+"Démarrage du serveur sur 8080..." ->> println
+8080 ->> server("handle_request")
+```

package/docs/getting-started.md

@@ -0,0 +1,46 @@
+# Guide de Démarrage
+
+## Installation
+
+La façon la plus simple d'installer Fazer est via NPM (Node Package Manager).
+
+```bash
+npm install -g fazer-lang
+```
+
+Vérifiez l'installation :
+
+```bash
+fazer --version
+```
+
+## Votre Premier Script
+
+Créez un fichier nommé `hello.fz` avec le contenu suivant :
+
+```fazer
+"Hello World!" ->> println
+```
+
+Exécutez-le via la ligne de commande :
+
+```bash
+fazer hello.fz
+```
+
+Vous devriez voir `Hello World!` s'afficher.
+
+## Le Mode Interactif (REPL)
+
+Si vous lancez `fazer` sans arguments, vous entrez dans le mode interactif. C'est idéal pour tester des petites lignes de code.
+
+```bash
+$ fazer
+Welcome to Fazer v2.2.1
+> 10 ->> println
+10
+> "test" ->> sha256 ->> println
+9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
+```
+
+Tapez `exit` ou faites `Ctrl+C` pour quitter.

package/docs/stdlib.md

@@ -0,0 +1,139 @@
+# Bibliothèque Standard (Stdlib)
+
+Fazer inclut une bibliothèque standard riche pour interagir avec le système, les fichiers, le réseau et plus encore.
+
+## Entrées / Sorties
+
+### `print(valeur)` / `println(valeur)`
+Affiche une valeur sur la sortie standard (console).
+
+### `input(message)`
+Affiche un message et attend une entrée utilisateur (retourne une chaîne).
+
+### `box(titre, contenu)`
+Affiche une boîte stylisée avec un titre et du contenu (texte ou liste).
+
+### `menu(options)`
+Affiche un menu interactif dans la console et retourne l'option choisie.
+```fazer
+choix := menu(["Option A", "Option B"])
+```
+
+### `style(texte, couleur)`
+Applique une couleur ANSI au texte pour l'affichage console.
+Couleurs : "red", "green", "blue", "yellow", "cyan", "magenta", "white", "bold", "dim".
+```fazer
+println(style("Succès !", "green"))
+```
+
+## Fichiers (File System)
+
+### `read(path)`
+Lit un fichier texte entier.
+
+### `write(path, content)`
+Écrit du contenu dans un fichier (écrase le fichier).
+
+### `exists(path)`
+Retourne `true` si le fichier ou dossier existe.
+
+### `readBytes(path)` / `writeBytes(path, b64)`
+Lecture/Écriture binaire (encodé en Base64).
+
+### `import(chemin)`
+Charge et exécute un autre script Fazer.
+```fazer
+import("utils.fz")
+```
+
+## Système & Exécution
+
+### `exec(cmd)`
+Exécute une commande shell et retourne la sortie (stdout) sous forme de chaîne.
+```fazer
+files := exec("ls -la")
+```
+
+### `notify(titre, message)`
+Affiche une notification système (Windows Toast).
+```fazer
+notify("Fazer", "Tâche terminée avec succès !")
+```
+
+### `clipboard`
+Objet global pour interagir avec le presse-papier système.
+*   `clipboard.read()` : Retourne le contenu texte du presse-papier.
+*   `clipboard.write(texte)` : Écrit du texte dans le presse-papier.
+
+### `sleep(ms)`
+Met le script en pause pour `ms` millisecondes.
+
+### `env(nom_var)`
+Lit une variable d'environnement.
+
+### `cwd()`
+Retourne le dossier de travail actuel.
+
+### `argv()`
+Retourne les arguments de la ligne de commande.
+
+## Réseau & Web
+
+### `fetch(url, options)`
+Effectue une requête HTTP. `options` est un objet (method, headers, body).
+Retourne `{ status, body, headers }`.
+
+### `server(port, handler)`
+Démarre un serveur HTTP simple.
+`handler` peut être une fonction qui prend `req` et retourne `res`, ou un objet de routage simple.
+```fazer
+fn handler(req) ->
+  "Hello from Fazer!"
+end
+server(8080, handler)
+```
+
+### `discord(token)`
+Crée un client Discord (Bot).
+*   `.on("message", fn)`
+*   `.send(channelId, content)`
+
+## Cryptographie
+
+### `sha256(texte)`
+Retourne le hash SHA-256 (hex).
+
+### `encrypt(texte, mot_de_passe)`
+Chiffre le texte avec AES-256-GCM (retourne Base64).
+
+### `decrypt(b64, mot_de_passe)`
+Déchiffre le texte.
+
+## JSON & Données
+
+### `json(obj)`
+Convertit un objet en chaîne JSON.
+
+### `parseJson(str)`
+Parse une chaîne JSON en objet.
+
+### `int(valeur)`
+Convertit une valeur en entier.
+
+### `float(valeur)`
+Convertit une valeur en nombre flottant.
+
+### `db(chemin_json)`
+Crée ou charge une base de données JSON persistante.
+Retourne un objet avec `.get(k)`, `.set(k, v)`, `.save()` et `.data()`.
+```fazer
+mydb := db("data.json")
+mydb.set("score", 100)
+mydb.save()
+```
+
+### `keys(obj)`
+Retourne les clés d'un objet JSON.
+
+### `get(obj, clé)`
+Récupère une valeur dans un objet/map.

package/docs/syntax.md

@@ -0,0 +1,86 @@
+# Syntaxe du Langage Fazer
+
+Fazer est un langage orienté flux. La plupart des opérations se font de gauche à droite via l'opérateur pipe.
+
+## Commentaires
+
+```fazer
+// Ceci est un commentaire sur une ligne
+```
+
+## Variables
+
+Il n'y a pas de mot-clé de déclaration explicite comme `var` ou `let` pour l'assignation simple dans le flux, mais vous pouvez nommer des valeurs dans des arguments de fonctions.
+
+Cependant, Fazer utilise principalement le passage de valeurs. Pour stocker des états globaux ou complexes, on utilise souvent des objets JSON ou la mémoire interne via `set`/`get`.
+
+```fazer
+// Exemple d'utilisation de set/get (mémoire clé-valeur)
+"ma_valeur" "cle" ->> set
+"cle" ->> get ->> println // Affiche "ma_valeur"
+```
+
+## Opérateur Pipe (`->>`)
+
+L'opérateur `->>` passe le résultat de l'expression de gauche comme **premier argument** de la fonction de droite.
+
+```fazer
+"Bonjour" ->> println
+// Équivalent à println("Bonjour") dans d'autres langages
+```
+
+Chaînage :
+
+```fazer
+"mot_de_passe" ->> sha256 ->> println
+```
+
+## Chaînes de Caractères et Nombres
+
+```fazer
+"Ceci est une chaîne"
+123
+12.34
+```
+
+## Fonctions (Définition)
+
+Fazer supporte la définition de fonctions nommées.
+
+```fazer
+fn ma_fonction (arg1) {
+  arg1 ->> println
+}
+
+"test" ->> ma_fonction
+```
+
+## Contrôle de Flux : `case`
+
+Fazer n'a pas de `if/else` traditionnel. Tout se fait via `case` (pattern matching).
+
+```fazer
+valeur ->> case {
+  "option1" : {
+    "C'est l'option 1" ->> println
+  }
+  "option2" : {
+    "C'est l'option 2" ->> println
+  }
+  _ : {
+    "Cas par défaut (wildcard)" ->> println
+  }
+}
+```
+
+### Conditionnelle (If-Else simulé)
+
+Pour faire un `if`, on matche souvent sur un booléen ou une valeur spécifique. Notez que Fazer évalue l'égalité stricte.
+
+```fazer
+// Exemple conceptuel
+variable ->> case {
+  "vrai" : { ... }
+  _ : { ... }
+}
+```