fazer-lang 2.1.0 → 2.1.2

package/README.md

@@ -1,137 +1,241 @@
-# Fazer Language (fz)
+# Fazer Language Reference Manual
 
-> **The Unique, High-Performance Scripting Language for the Modern Era.**
-> "Batteries included" logic, powerful pipes, and unbreakable security.
+> **The Next-Generation Scripting Language for High-Performance Computing & Security.**
+> *Copyright © 2026 L'EMPRISE. All Rights Reserved.*
 
 [![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)
 
-Fazer is a new interpreted language designed for **speed**, **readability**, and **power**. It combines the best of functional programming (pipes) with imperative simplicity.
+---
+
+## 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.
 
-## 🚀 Features
+### 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).
+
+---
 
-*   **Unique Syntax**: Use the Arrow Pipe `→>` to chain operations like a pro.
-*   **Batteries Included**: 
-    *   🔐 **Crypto**: AES-256-GCM, SHA256 built-in.
-    *   🌐 **HTTP Server**: Create web servers in 3 lines of code.
-    *   📂 **Filesystem**: Read, write, check existence, manipulate paths.
-    *   💻 **System**: Execute shell commands, handle JSON natively.
-*   **Visuals**: Built-in support for colored output (`style`) and UI boxes (`box`).
-*   **Portable**: Runs anywhere Node.js runs (or compiles to a standalone EXE).
+## 2. Installation
 
-## 📦 Installation
+### Global Installation (Recommended)
+To access the `fazer` command globally on your system:
 
 ```bash
 npm install -g fazer-lang
 ```
 
-## ⚡ Quick Start
+### Verification
+```bash
+fazer --version
+# Output: 2.1.0
+```
 
-Create a file `hello.fz`:
+---
 
-```fazer
-fn main() →
-  box("WELCOME", "Hello from Fazer!", style("Power is yours.", "cyan"))
-  
-  # Pipe magic
-  "secret message" →> sha256() →> println()
-end
+## 3. The Core Philosophy: The Pipe (`→>`)
 
-main()
+In most languages, you write:
+```javascript
+// JavaScript / Python style
+print(sha256(readFile("data.txt")));
 ```
+This requires reading "inside-out".
 
-Run it:
-```bash
-fazer run hello.fz
+**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.
+
+---
 
-## 📖 Ultra-Precise Documentation
+## 4. Language Guide
 
-### 1. The Pipe Operator (`→>`)
-The heart of Fazer. It passes the result of the left expression as the *first argument* to the function on the right.
+### Variables & Constants
+Fazer uses dynamic typing. Variables are declared implicitly.
 
 ```fazer
-# Standard
-println(sha256("text"))
-
-# Fazer Style
-"text" →> sha256() →> println()
+x = 10
+name = "L'EMPRISE"
+isActive = true
 ```
 
-### 2. Control Flow
+### 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.
 
-**Functions (`fn`)**
 ```fazer
-fn add(a, b) →
-  return(a + b)
+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
 ```
 
-**Pattern Matching (`case`)**
-Instead of boring `if/else`, use `case`:
+### Functions (`fn`)
+Functions are first-class citizens.
 
 ```fazer
-case x
-  10 → println("It is ten") end
-  > 10 → println("Greater than ten") end
-  else → println("Something else") end
+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`)
+
+*   **`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"))
 ```
 
-### 3. Built-in Modules (Standard Library)
+### 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.
 
-#### 🖥️ I/O & UI
-*   `println(x)`: Print to stdout with newline.
-*   `print(x)`: Print without newline.
-*   `ask(prompt)`: Read user input.
-*   `style(text, color)`: Colorize text (red, green, blue, cyan, yellow, etc.).
-*   `box(title, lines...)`: Draw a beautiful ASCII box (handles ANSI colors correctly!).
+```fazer
+pass = "super_secret"
+"My Secret Data" →> encText(pass) →> saveText("secret.enc")
+```
 
-#### 📂 File System
-*   `readText(path)` / `saveText(content, path)`
-*   `readB64(path)` / `saveB64(content, path)`
-*   `exists(path)`: Returns true/false.
-*   `ls(dir)`: List files.
-*   `rm(path)`: Delete file/dir (recursive).
-*   `mkdir(path)`: Create directory.
+### 5.3. File System (`FS`)
+Robust, synchronous file operations.
 
-#### 🔐 Cryptography (AES-256-GCM)
-*   `encText(text, pass)`: Encrypt text.
-*   `decText(b64, pass)`: Decrypt text.
-*   `sha256(data)`: Hash data.
+*   **`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).
 
-#### 🌐 Network & System (NEW!)
-*   `server(port, handlerFn)`: Start an HTTP server.
-*   `exec(cmd)`: Run a shell command (e.g., `exec("dir")`).
-*   `json(obj)`: Convert object to JSON string.
-*   `parseJson(str)`: Parse JSON string to object.
+### 5.4. Networking & Web (`Net`)
+Create high-performance web servers instantly.
 
-### 4. Example: Web Server
+*   **`server(port, handlerFunctionName)`**: Starts a blocking HTTP server.
 
+**Example Web Server:**
 ```fazer
-fn handleRequest(req) →
-  println("Request received: " + req.url)
+fn handler(req) →
+  # req has .method, .url, .headers
+  println("Hit: " + req.url)
+  
   return({
     "status": 200,
-    "headers": { "Content-Type": "text/plain" },
-    "body": "Hello from Fazer Server!"
+    "headers": { "Content-Type": "application/json" },
+    "body": json({ "message": "Welcome to Fazer API" })
   })
 end
 
-println("Starting server...")
-server(8080, "handleRequest")
+server(3000, "handler")
 ```
 
+### 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.
+
 ---
 
-## 🛠️ Distribution
+## 6. Advanced Usage: Building Standalone Executables
 
-To compile your script into a standalone executable:
+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:**
 ```bash
-pkg fazer.js --targets node18-win-x64 --output myapp.exe
+# Requires 'pkg' installed via npm
+pkg fazer.js --targets node18-win-x64,node18-linux-x64 --output my_app
 ```
 
-## 📜 License
+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 |
+
+---
+
+## 9. Copyright & Legal
+
+**Fazer Language** is a proprietary technology developed by **L'EMPRISE**.
+Unauthorized reproduction of the core interpreter logic without attribution is prohibited.
+
+*   **Copyright**: © 2026 L'EMPRISE.
+*   **License**: MIT (Open Source for usage).
+
+---
 
-MIT © Fazer Corp (2026)
+> *"Control the code, control the world."* — **L'EMPRISE**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fazer-lang",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "Fazer — A unique, high-performance scripting language with powerful pipe operators (→>) and batteries-included stdlib (crypto, http, fs, json).",
   "main": "fazer.js",
   "bin": {