fazer-lang 2.1.2 → 2.2.1

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,62 @@
-# Fazer Language Reference Manual
+# Fazer
 
-> **The Next-Generation Scripting Language for High-Performance Computing & Security.**
-> *Copyright © 2026 L'EMPRISE. All Rights Reserved.*
+**Fazer** is a powerful, concise scripting language designed for automation, security, and data processing. It features a unique syntax with pipe operators (`→>`), pattern matching (`case`), and a batteries-included standard library.
 
-[![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)
+## 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:
+Install Fazer globally using 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
-```
-
----
+## Usage
 
-## 5. Standard Library Reference (StdLib)
+Run the REPL (interactive mode):
 
-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"))
+```bash
+fazer
 ```
 
-### 5.2. Cryptography (`Crypto`)
-**Security Level: Military Grade (AES-256-GCM).**
+Run a script:
 
-*   **`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")
+```bash
+fazer my_script.fz
 ```
 
-### 5.3. File System (`FS`)
-Robust, synchronous file operations.
+## Features
 
-*   **`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).
+- **Pipe Operator**: Chain functions easily: `readText("in.txt") →> encText(pass) →> writeText("out.enc")`
+- **Pattern Matching**: Expressive control flow with `case`
+- **Batteries Included**: Built-in modules for:
+  - File System (`readText`, `writeText`, `ls`, `exists`)
+  - Cryptography (`aes-256-gcm`, `sha256`)
+  - Networking (`fetch`, `server`, `discord`)
+  - JSON (`json`, `parseJson`)
+  - System (`exec`, `env`, `argv`)
+- **Single File**: The runtime is compact and efficient.
 
-### 5.4. Networking & Web (`Net`)
-Create high-performance web servers instantly.
+## Example
 
-*   **`server(port, handlerFunctionName)`**: Starts a blocking HTTP server.
-
-**Example Web Server:**
 ```fazer
-fn handler(req) →
-  # req has .method, .url, .headers
-  println("Hit: " + req.url)
+fn main() →
+  println(style("Welcome to Fazer", "cyan"))
+  
+  files := ls(".")
+  println("Found " + len(files) + " files.")
   
-  return({
-    "status": 200,
-    "headers": { "Content-Type": "application/json" },
-    "body": json({ "message": "Welcome to Fazer API" })
-  })
+  case exists("secret.txt")
+    true →
+      content := readText("secret.txt")
+      println("Secret content: " + content)
+    end
+    else → end
+  end
 end
 
-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.
-
----
-
-## 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:**
-```bash
-# Requires 'pkg' installed via npm
-pkg fazer.js --targets node18-win-x64,node18-linux-x64 --output my_app
+main()
 ```
 
-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).
-
----
+## License
 
-> *"Control the code, control the world."* — **L'EMPRISE**
+MIT