IncludeCPP 3.8.9__py3-none-any.whl → 4.0.0__py3-none-any.whl

includecpp/core/cssl/CSSL_DOCUMENTATION_NEW.md

@@ -0,0 +1,1348 @@
+# CSSL - C-Style Scripting Language
+
+> Version 3.9.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion, BruteInjection, and Python Interop.
+
+---
+
+## Table of Contents
+
+1. [Quick Start](#quick-start)
+2. [Syntax Basics](#syntax-basics)
+3. [Data Types](#data-types)
+4. [Variables & Globals](#variables--globals)
+5. [Operators](#operators)
+6. [Control Flow](#control-flow)
+7. [Functions](#functions)
+8. [Classes & OOP](#classes--oop)
+9. [Container Types](#container-types)
+10. [Built-in Functions](#built-in-functions)
+11. [CodeInfusion](#codeinfusion)
+12. [BruteInjection](#bruteinjection)
+13. [Value Capture](#value-capture)
+14. [Module System](#module-system)
+15. [Error Handling](#error-handling)
+16. [Quick Reference](#quick-reference)
+
+---
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install includecpp
+```
+
+### Python Usage
+
+```python
+from includecpp import CSSL
+
+# Execute CSSL code
+CSSL.run('''
+    printl("Hello CSSL!");
+''')
+
+# With parameters and return value
+result = CSSL.run('''
+    string name = parameter.get(0);
+    printl("Hello " + name);
+    parameter.return(true);
+''', "World")
+
+print(result)  # True
+```
+
+### CLI Execution
+
+```bash
+# Execute CSSL file
+python -m includecpp cssl exec myfile.cssl
+
+# Create module from Python file
+python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
+```
+
+### First Script
+
+```cssl
+// Variables
+string name = "CSSL";
+int version = 3;
+
+// Output
+printl("Welcome to " + name);
+
+// Function
+void greet(string msg) {
+    printl(msg);
+}
+
+greet("Hello World!");
+```
+
+---
+
+## Syntax Basics
+
+### Comments
+
+```cssl
+// Single-line comment (C-style)
+# Single-line comment (Python-style)
+```
+
+### Semicolons
+
+Semicolons are optional but recommended for clarity.
+
+```cssl
+printl("Hello")    // Works
+printl("Hello");   // Also works (recommended)
+```
+
+### Output Functions
+
+```cssl
+printl("Text");              // Print with newline
+print("No newline");         // Print without newline
+debug("Debug info");         // Print with [DEBUG] prefix
+error("Error message");      // Print with [ERROR] prefix
+warn("Warning");             // Print with [WARN] prefix
+log("INFO", "Message");      // Print with custom prefix
+```
+
+---
+
+## Data Types
+
+### Primitive Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| `int` | Integer | `int x = 42;` |
+| `float` | Floating point | `float f = 3.14;` |
+| `string` | Text string | `string s = "Hello";` |
+| `bool` | Boolean | `bool b = true;` |
+| `dynamic` | Any type (flexible) | `dynamic x = "text";` |
+| `void` | No return value | `void func() { }` |
+| `null` | Absence of value | `dynamic x = null;` |
+
+### Generic Container Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| `stack<T>` | LIFO stack | `stack<string> names;` |
+| `vector<T>` | Dynamic array | `vector<int> nums;` |
+| `array<T>` | Standard array | `array<float> values;` |
+| `map<K,V>` | Ordered key-value | `map<string, int> ages;` |
+| `list` | Python-like list | `list items = [1, 2, 3];` |
+| `dict` | Dictionary | `dict data = {"a": 1};` |
+| `datastruct<T>` | Universal container | `datastruct<string> data;` |
+| `iterator<T>` | Programmable iterator | `iterator<int> it;` |
+| `shuffled<T>` | Multi-value returns | `shuffled<string> results;` |
+| `combo<T>` | Filter/search space | `combo<string> search;` |
+
+### Type Conversion
+
+```cssl
+int("42");        // String to int: 42
+float("3.14");    // String to float: 3.14
+str(42);          // Int to string: "42"
+bool(1);          // Int to bool: true
+int("ff", 16);    // Hex to int: 255
+```
+
+### Type Checking
+
+```cssl
+typeof(42);           // "int"
+typeof("hello");      // "str"
+isinstance(42, "int"); // true
+isint(42);            // true
+isstr("hello");       // true
+isnull(null);         // true
+```
+
+---
+
+## Variables & Globals
+
+### Local Variables
+
+```cssl
+string name = "Alice";
+int count = 10;
+float price = 19.99;
+bool active = true;
+```
+
+### Global Variables
+
+```cssl
+// Declaration with 'global' keyword
+global myGlobal = "visible everywhere";
+
+// Access with '@' prefix
+printl(@myGlobal);
+
+// Alternative: r@ syntax
+r@anotherGlobal = "also global";
+printl(@anotherGlobal);
+```
+
+### Shared Objects ($)
+
+Access Python objects shared via `CSSL.share()`:
+
+```cssl
+// Access shared Python object
+$counter.value = 100;
+$counter.increment();
+
+// Delete shared object
+delete("counter");
+```
+
+### Captured References (%)
+
+Capture value at registration time:
+
+```cssl
+string version = "1.0";
+savedVersion <<== { %version; }
+version = "2.0";
+printl(savedVersion);  // Still "1.0"
+```
+
+---
+
+## Operators
+
+### Arithmetic
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `+` | Addition / Concatenation | `a + b` |
+| `-` | Subtraction | `a - b` |
+| `*` | Multiplication | `a * b` |
+| `/` | Division | `a / b` |
+| `%` | Modulo | `a % b` |
+
+### Comparison
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `==` | Equal | `a == b` |
+| `!=` | Not equal | `a != b` |
+| `<` | Less than | `a < b` |
+| `>` | Greater than | `a > b` |
+| `<=` | Less or equal | `a <= b` |
+| `>=` | Greater or equal | `a >= b` |
+
+### Logical
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `&&` | AND | `a && b` |
+| `\|\|` | OR | `a \|\| b` |
+| `!` | NOT | `!a` |
+| `and` | AND (keyword) | `a and b` |
+| `or` | OR (keyword) | `a or b` |
+| `not` | NOT (keyword) | `not a` |
+
+### Increment/Decrement (in for-loops)
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `++` | Increment | `i++` |
+| `--` | Decrement | `i--` |
+| `+=` | Add assign | `i += 1` |
+| `-=` | Subtract assign | `i -= 1` |
+
+---
+
+## Control Flow
+
+### If / Else If / Else
+
+```cssl
+if (x < 5) {
+    printl("Small");
+} else if (x < 15) {
+    printl("Medium");
+} else {
+    printl("Large");
+}
+
+// elif also works
+if (x < 5) {
+    printl("Small");
+} elif (x < 15) {
+    printl("Medium");
+}
+```
+
+### Switch / Case
+
+```cssl
+switch (day) {
+    case 1:
+        printl("Monday");
+        break;
+    case 2:
+        printl("Tuesday");
+        break;
+    default:
+        printl("Other");
+}
+```
+
+### While Loop
+
+```cssl
+int i = 0;
+while (i < 5) {
+    printl(i);
+    i = i + 1;
+}
+```
+
+### For Loop (Python-Style)
+
+```cssl
+// Range-based
+for (i in range(5)) {
+    printl(i);  // 0, 1, 2, 3, 4
+}
+
+// With start and end
+for (i in range(10, 15)) {
+    printl(i);  // 10, 11, 12, 13, 14
+}
+
+// With step
+for (i in range(0, 10, 2)) {
+    printl(i);  // 0, 2, 4, 6, 8
+}
+```
+
+### For Loop (C-Style)
+
+```cssl
+for (int i = 0; i < 10; i++) {
+    printl(i);
+}
+
+for (int i = 10; i > 0; i--) {
+    printl(i);
+}
+```
+
+### Foreach
+
+```cssl
+stack<string> names;
+names.push("Alice");
+names.push("Bob");
+
+// Syntax 1
+foreach (name in names) {
+    printl(name);
+}
+
+// Syntax 2
+foreach names as name {
+    printl(name);
+}
+```
+
+### Break & Continue
+
+```cssl
+for (i in range(10)) {
+    if (i == 5) break;     // Exit loop
+    if (i == 3) continue;  // Skip iteration
+    printl(i);
+}
+```
+
+---
+
+## Functions
+
+### Basic Syntax
+
+```cssl
+// Without return
+void sayHello() {
+    printl("Hello!");
+}
+
+// With return
+string getName() {
+    return "CSSL";
+}
+
+// With parameters
+int add(int a, int b) {
+    return a + b;
+}
+```
+
+### Define Functions
+
+```cssl
+// Simple function without type
+define greet() {
+    printl("Hello!");
+}
+
+// With parameters
+define greet(string name) {
+    printl("Hello " + name);
+}
+```
+
+### Function Modifiers
+
+| Modifier | Description |
+|----------|-------------|
+| `undefined` | Silently ignore errors |
+| `closed` | Block external CodeInfusion |
+| `private` | Block all CodeInfusion |
+| `virtual` | Import-cycle safe |
+| `meta` | Source function (must return) |
+| `super` | Force execution (no exceptions) |
+| `open` | Accept any parameters |
+| `shuffled` | Return multiple values |
+
+```cssl
+// Ignore errors
+undefined void mayFail() {
+    riskyOperation();
+}
+
+// Protected from injection
+closed void protected() {
+    printl("Protected");
+}
+
+// Multiple returns
+shuffled string getNames() {
+    return "Alice", "Bob", "Charlie";
+}
+
+a, b, c = getNames();
+```
+
+### Non-Null Functions (*)
+
+Functions that must never return null:
+
+```cssl
+// Non-null function
+define *alwaysReturns() {
+    return "Always a value";
+}
+
+// Non-null assertion on value
+this->name = *$System.os;  // Error if null
+```
+
+### Type Exclusion Filter (*[type])
+
+Functions that must NOT return a specific type:
+
+```cssl
+// Must NOT return string
+shuffled *[string] getNumbers() {
+    return 1, 2, 3;  // OK
+    // return "text";  // Error!
+}
+
+// Must NOT return null
+define *[null] getValue() {
+    return 42;  // OK
+}
+```
+
+### Open Parameters
+
+```cssl
+open define flexibleFunc(open Params) {
+    string name = OpenFind<string>(0);
+    int num = OpenFind<int>(0);
+    printl(name + " " + num);
+}
+
+flexibleFunc("Hello", 123, true);
+```
+
+---
+
+## Classes & OOP
+
+### Class Definition
+
+```cssl
+class Person {
+    string name;
+    int age;
+
+    // Constructor
+    void Person(string n, int a) {
+        this->name = n;
+        this->age = a;
+    }
+
+    void greet() {
+        printl("Hello, I'm " + this->name);
+    }
+
+    string getName() {
+        return this->name;
+    }
+}
+```
+
+### Creating Instances
+
+```cssl
+Person p = new Person("Alice", 30);
+p.greet();
+printl(p.name);
+```
+
+### Constructor with `constr` Keyword
+
+```cssl
+class Vehicle {
+    string brand;
+
+    constr Initialize(string b) {
+        this->brand = b;
+    }
+
+    constr SetupDefaults() {
+        printl("Vehicle ready");
+    }
+}
+
+Vehicle v = new Vehicle("Toyota");
+```
+
+### Class Inheritance
+
+```cssl
+class Animal {
+    string name;
+
+    void Animal(string n) {
+        this->name = n;
+    }
+
+    void speak() {
+        printl("Sound");
+    }
+}
+
+class Dog : extends Animal {
+    void Dog(string n) {
+        this->name = n;
+    }
+
+    void speak() {
+        printl("Woof! I'm " + this->name);
+    }
+}
+
+Dog d = new Dog("Buddy");
+d.speak();  // "Woof! I'm Buddy"
+```
+
+### super() and super::method()
+
+```cssl
+class Child : extends Parent {
+    constr ChildInit(string name) {
+        super(name);  // Call parent constructor
+    }
+
+    void speak() {
+        super::speak();  // Call parent method
+        printl("Child speaking");
+    }
+}
+```
+
+### Append Mode (++)
+
+Extend constructors/functions while keeping original code:
+
+```cssl
+// Original function
+define BaseFunc() {
+    printl("Base functionality");
+}
+
+// Append to BaseFunc
+define ExtendedFunc() &BaseFunc ++ {
+    printl("Extended functionality");
+}
+
+ExtendedFunc();
+// Output:
+// Base functionality
+// Extended functionality
+```
+
+```cssl
+class MyClass {
+    constr MyClassConstructor() {
+        printl("MyClass constructor");
+        this->value = 10;
+    }
+}
+
+class BetterClass :: extends MyClass {
+    constr BetterConstructor() &MyClass::MyClassConstructor ++ {
+        printl("BetterClass - added code");
+        this->extra = 20;
+    }
+}
+```
+
+### Non-Null Class
+
+```cssl
+class *MyClass {
+    // All methods must return non-null
+    string getValue() {
+        return "Value";
+    }
+}
+```
+
+---
+
+## Container Types
+
+### stack\<T\> - LIFO Stack
+
+```cssl
+stack<string> names;
+names.push("Alice");
+names.push("Bob");
+
+printl(names.pop());     // "Bob"
+printl(names.peek());    // "Alice" (doesn't remove)
+printl(names.size());    // 1
+printl(names.isEmpty()); // false
+```
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `push(value)` | Add to top |
+| `pop()` | Remove and return top |
+| `peek()` | View top without removing |
+| `size()` / `length()` | Element count |
+| `isEmpty()` / `is_empty()` | Check if empty |
+| `contains(value)` | Check if contains |
+| `indexOf(value)` | Find index (-1 if not found) |
+| `toArray()` | Convert to list |
+| `swap()` | Swap top two elements |
+| `dup()` | Duplicate top element |
+
+### vector\<T\> - Dynamic Array
+
+```cssl
+vector<int> nums;
+nums.push(10);
+nums.push(20);
+
+printl(nums.at(0));     // 10
+printl(nums.front());   // 10
+printl(nums.back());    // 20
+```
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `push(value)` / `push_back(value)` | Add to end |
+| `push_front(value)` | Add to front |
+| `pop_back()` | Remove from end |
+| `pop_front()` | Remove from front |
+| `at(index)` | Get element |
+| `set(index, value)` | Set element |
+| `front()` | Get first |
+| `back()` | Get last |
+| `size()` / `length()` | Element count |
+| `empty()` / `isEmpty()` | Check if empty |
+| `contains(value)` | Check if contains |
+| `indexOf(value)` | Find first index |
+| `lastIndexOf(value)` | Find last index |
+| `slice(start, end)` | Get sub-vector |
+| `join(separator)` | Join to string |
+| `map(func)` | Apply function |
+| `filter(predicate)` | Filter elements |
+| `forEach(func)` | Execute for each |
+| `every(predicate)` | Check all match |
+| `some(predicate)` | Check any match |
+| `reduce(func, initial)` | Reduce to value |
+| `toArray()` | Convert to list |
+
+### map\<K,V\> - Ordered Key-Value
+
+```cssl
+map<string, int> ages;
+ages.insert("Alice", 30);
+ages.insert("Bob", 25);
+
+printl(ages.find("Alice"));   // 30
+printl(ages.contains("Bob")); // true
+ages.erase("Bob");
+```
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `insert(key, value)` | Insert/update pair |
+| `find(key)` | Get value (null if not found) |
+| `at(key)` | Get value (throws if not found) |
+| `erase(key)` | Remove key |
+| `contains(key)` | Check if key exists |
+| `count(key)` | Count (0 or 1) |
+| `size()` | Pair count |
+| `empty()` | Check if empty |
+| `begin()` | First key-value tuple |
+| `end()` | Last key-value tuple |
+| `lower_bound(key)` | First key >= given |
+| `upper_bound(key)` | First key > given |
+
+### datastruct\<T\> - Universal Container
+
+Primary target for BruteInjection operations.
+
+```cssl
+datastruct<string> data;
+data.add("item1");
+data.add("item2");
+
+printl(data.content());  // All elements
+```
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `content()` | Get all elements |
+| `add(value)` | Add element |
+| `remove_where(predicate)` | Remove matching |
+| `find_where(predicate)` | Find first matching |
+| `convert(type)` | Convert first element |
+
+### shuffled\<T\> - Multiple Returns
+
+```cssl
+shuffled string getInfo() {
+    return "Alice", "Bob", "Charlie";
+}
+
+a, b, c = getInfo();
+printl(a);  // "Alice"
+```
+
+---
+
+## Built-in Functions
+
+### String Operations
+
+```cssl
+string s = "Hello World";
+
+// Case
+upper(s);              // "HELLO WORLD"
+lower(s);              // "hello world"
+capitalize(s);         // "Hello world"
+title(s);              // "Hello World"
+
+// Trim
+trim("  text  ");      // "text"
+ltrim("  text");       // "text"
+rtrim("text  ");       // "text"
+
+// Search
+contains(s, "World");  // true
+startswith(s, "Hello"); // true
+endswith(s, "World");  // true
+indexof(s, "o");       // 4
+lastindexof(s, "o");   // 7
+
+// Manipulation
+replace(s, "World", "CSSL");  // "Hello CSSL"
+substr(s, 0, 5);              // "Hello"
+split(s, " ");                // ["Hello", "World"]
+join("-", ["a", "b"]);        // "a-b"
+repeat("ab", 3);              // "ababab"
+reverse(s);                   // "dlroW olleH"
+
+// Padding
+padleft("42", 5, "0");   // "00042"
+padright("42", 5, ".");  // "42..."
+center("hi", 6, "-");    // "--hi--"
+zfill("42", 5);          // "00042"
+
+// Character
+len(s);                  // 11
+chars("abc");            // ["a", "b", "c"]
+ord("A");                // 65
+chr(65);                 // "A"
+
+// Checks
+isalpha("abc");          // true
+isdigit("123");          // true
+isalnum("abc123");       // true
+isspace("  ");           // true
+```
+
+### Array/List Operations
+
+```cssl
+stack<int> arr = [1, 2, 3, 4, 5];
+
+// Add/Remove
+push(arr, 6);            // Add to end
+pop(arr);                // Remove last
+shift(arr);              // Remove first
+unshift(arr, 0);         // Add to front
+
+// Access
+first(arr);              // First element
+last(arr);               // Last element
+slice(arr, 1, 3);        // [2, 3]
+
+// Transform
+sort(arr);               // Sort ascending
+rsort(arr);              // Sort descending
+reversed(arr);           // Reverse copy
+shuffle(arr);            // Random order
+unique(arr);             // Remove duplicates
+flatten([[1,2],[3,4]]);  // [1, 2, 3, 4]
+
+// Search
+find(arr, x => x > 3);   // First matching
+findindex(arr, x => x > 3);
+every(arr, x => x > 0);  // All match?
+some(arr, x => x > 3);   // Any match?
+count(arr, 2);           // Count of 2
+
+// Functional
+map(arr, x => x * 2);    // [2, 4, 6, 8, 10]
+filter(arr, x => x > 2); // [3, 4, 5]
+reduce(arr, (a,b) => a+b, 0); // 15
+
+// Utilities
+range(5);                // [0, 1, 2, 3, 4]
+range(1, 5);             // [1, 2, 3, 4]
+range(0, 10, 2);         // [0, 2, 4, 6, 8]
+enumerate(arr);          // [(0,1), (1,2), ...]
+zip([1,2], ["a","b"]);   // [(1,"a"), (2,"b")]
+take(arr, 3);            // First 3 elements
+drop(arr, 2);            // Skip first 2
+chunk(arr, 2);           // [[1,2], [3,4], [5]]
+sample(arr, 2);          // 2 random elements
+```
+
+### Dictionary Operations
+
+```cssl
+dict d = {"name": "Alice", "age": 30};
+
+keys(d);                 // ["name", "age"]
+values(d);               // ["Alice", 30]
+items(d);                // [("name","Alice"), ...]
+haskey(d, "name");       // true
+getkey(d, "name");       // "Alice"
+getkey(d, "x", "default"); // "default"
+setkey(d, "city", "NYC"); // Add key
+delkey(d, "age");        // Remove key
+merge(d1, d2);           // Merge dicts
+update(d, {"new": 1});   // Update in place
+fromkeys(["a","b"], 0);  // {"a": 0, "b": 0}
+invert({"a": 1});        // {1: "a"}
+pick(d, "name");         // {"name": "Alice"}
+omit(d, "age");          // {"name": "Alice"}
+```
+
+### Math Functions
+
+```cssl
+abs(-5);                 // 5
+min(3, 1, 2);            // 1
+max(3, 1, 2);            // 3
+sum([1, 2, 3]);          // 6
+avg([1, 2, 3, 4, 5]);    // 3.0
+
+round(3.14159, 2);       // 3.14
+floor(3.9);              // 3
+ceil(3.1);               // 4
+
+pow(2, 3);               // 8
+sqrt(16);                // 4
+mod(7, 3);               // 1
+
+sin(0);                  // 0.0
+cos(0);                  // 1.0
+tan(0);                  // 0.0
+asin(1);                 // 1.5708
+acos(0);                 // 1.5708
+atan(1);                 // 0.7854
+atan2(1, 1);             // 0.7854
+
+log(e());                // 1.0
+log10(100);              // 2.0
+exp(1);                  // 2.71828
+
+pi();                    // 3.14159...
+e();                     // 2.71828...
+radians(180);            // 3.14159
+degrees(3.14159);        // 180
+
+random();                // 0.0 to 1.0
+randint(1, 6);           // 1 to 6
+```
+
+### Date/Time Functions
+
+```cssl
+now();                   // Unix timestamp (float)
+timestamp();             // Unix timestamp (int)
+date();                  // "2025-12-30"
+date("%d/%m/%Y");        // "30/12/2025"
+time();                  // "14:30:45"
+datetime();              // "2025-12-30 14:30:45"
+strftime("%Y-%m-%d", ts);
+
+sleep(1.5);              // Wait 1.5 seconds
+delay(500);              // Wait 500 milliseconds
+```
+
+### File I/O Functions
+
+```cssl
+// Read
+string content = read("file.txt");
+string line5 = readline(5, "file.txt");
+stack<string> lines = readlines("file.txt");
+
+// Write
+write("file.txt", "Hello");
+writeline(3, "New line", "file.txt");
+appendfile("file.txt", "\nMore");
+
+// Path operations
+basename("/path/to/file.txt");  // "file.txt"
+dirname("/path/to/file.txt");   // "/path/to"
+joinpath("/path", "file.txt");  // "/path/file.txt"
+abspath("./file.txt");
+normpath("/path/../other");
+
+// Checks
+pathexists("file.txt");  // true/false
+isfile("file.txt");      // true/false
+isdir("folder");         // true/false
+filesize("file.txt");    // bytes
+
+// Directory
+listdir("./");           // ["file1", "file2"]
+makedirs("new/folder");
+removefile("file.txt");
+removedir("folder");
+copyfile("src", "dst");
+movefile("old", "new");
+```
+
+### JSON Functions (json:: namespace)
+
+```cssl
+// File operations
+json data = json::read("config.json");
+json::write("output.json", data);
+
+// Parse/Stringify
+json obj = json::parse('{"name": "Alice"}');
+string str = json::stringify(obj);
+string pretty = json::pretty(obj);
+
+// Path operations
+json::get(data, "user.name");
+json::get(data, "user.age", 0);  // with default
+json::set(data, "user.name", "Bob");
+json::has(data, "user.email");
+
+// Object operations
+json::keys(obj);         // ["name"]
+json::values(obj);       // ["Alice"]
+json::merge(obj1, obj2); // Deep merge
+```
+
+### Instance Functions (instance:: namespace)
+
+```cssl
+@module = include("lib.cssl-mod");
+
+instance::getMethods(@module);   // Method names
+instance::getClasses(@module);   // Class names
+instance::getVars(@module);      // Variable names
+instance::getAll(@module);       // Categorized dict
+
+instance::call(@module, "methodName", arg1);
+instance::has(@module, "attribute");
+instance::type(@module);         // Type name
+
+isavailable("sharedName");       // Check if exists
+```
+
+### Regex Functions
+
+```cssl
+match("\\d+", "abc123");         // Match at start
+search("\\d+", "abc123");        // Search anywhere
+findall("\\d+", "a1b2c3");       // ["1", "2", "3"]
+sub("\\d", "X", "a1b2");         // "aXbX"
+sub("\\d", "X", "a1b2", 1);      // "aXb2" (count=1)
+```
+
+### Hash Functions
+
+```cssl
+md5("hello");            // 32 hex chars
+sha1("hello");           // 40 hex chars
+sha256("hello");         // 64 hex chars
+```
+
+### System Functions
+
+```cssl
+exit(0);                 // Exit with code
+input("Enter name: ");   // Read user input
+
+env("PATH");             // Get env variable
+setenv("MY_VAR", "val"); // Set env variable
+
+copy(obj);               // Shallow copy
+deepcopy(obj);           // Deep copy
+
+clear();                 // Clear console
+
+pyimport("os");          // Import Python module
+include("lib.cssl-mod"); // Import CSSL module
+payload("helper.cssl-pl"); // Load payload
+
+isLinux();               // Platform checks
+isWindows();
+isMac();
+```
+
+### Filter Functions (filter:: namespace)
+
+```cssl
+// Register custom filter
+filter::register("custom", "handler", callback);
+filter::unregister("custom", "handler");
+filter::list();          // All registered filters
+filter::exists("custom", "handler");
+```
+
+---
+
+## CodeInfusion
+
+Modify functions at runtime.
+
+### <<== (Replace)
+
+```cssl
+void original() {
+    printl("Original");
+}
+
+original() <<== {
+    printl("Replaced");
+}
+
+original();  // "Replaced"
+```
+
+### +<<== (Add Before)
+
+```cssl
+void base() {
+    printl("Base");
+}
+
+base() +<<== {
+    printl("Added");
+}
+
+base();
+// Output:
+// Added
+// Base
+```
+
+### -<<== (Remove)
+
+```cssl
+void withExtra() {
+    printl("Important");
+    printl("Unimportant");
+}
+
+withExtra() -<<== {
+    printl("Unimportant");
+}
+
+withExtra();  // Only "Important"
+```
+
+### Exit Injection
+
+```cssl
+exit() <<== {
+    printl("Cleanup...");
+}
+
+exit();  // Executes injection
+```
+
+---
+
+## BruteInjection
+
+Transfer data between containers.
+
+### +<== (Copy)
+
+```cssl
+stack<string> source;
+source.push("A");
+source.push("B");
+
+datastruct<string> target;
+target +<== source;  // Copy A, B (source unchanged)
+```
+
+### -<== (Move)
+
+```cssl
+stack<string> src;
+src.push("Data");
+
+datastruct<string> dst;
+dst -<== src;  // src is empty after
+```
+
+### ==> (Replace)
+
+```cssl
+stack<string> data;
+data.push("New");
+
+datastruct<string> container;
+container ==> data;  // Replace container content
+```
+
+### ==>- (Remove Matching)
+
+```cssl
+stack<string> names;
+names.push("Alice");
+names.push("Bob");
+names.push("Alice");
+
+stack<string> toRemove;
+toRemove.push("Alice");
+
+names ==>- toRemove;
+printl(names);  // ["Bob"]
+```
+
+### Filter Syntax
+
+```cssl
+target +<== [type::filter=value] source;
+
+// String filters
+result +<== [string::where="Apple"] fruits;
+result +<== [string::not="Banana"] fruits;
+result +<== [string::contains="App"] fruits;
+result +<== [string::length=5] fruits;
+result +<== [string::cut=3] version;
+result +<== [string::cutAfter="."] version;
+
+// Other filters
+result +<== [integer::where=42] numbers;
+result +<== [json::key="name"] objects;
+```
+
+---
+
+## Value Capture
+
+Capture values at registration time with `%`:
+
+```cssl
+string version = "1.0.0";
+savedVersion <<== { %version; }
+
+version = "2.0.0";
+printl(savedVersion);  // "1.0.0" (captured value)
+```
+
+### Capturing Functions
+
+```cssl
+originalExit <<== { %exit(); }
+
+exit() <<== {
+    printl("Custom cleanup");
+    originalExit();
+}
+```
+
+---
+
+## Module System
+
+### Import CSSL Module
+
+```cssl
+@Math = include("mathlib.cssl-mod");
+int result = @Math.add(5, 3);
+```
+
+### Import Python Module
+
+```cssl
+@os = pyimport("os");
+string cwd = @os.getcwd();
+
+@datetime = pyimport("datetime");
+@datetime.datetime.now();
+```
+
+### Load Payload
+
+```cssl
+payload("helpers.cssl-pl");
+```
+
+### Create Module (CLI)
+
+```bash
+python -m includecpp cssl makemodule mylib.py -o mylib.cssl-mod
+```
+
+---
+
+## Error Handling
+
+### Try / Catch
+
+```cssl
+try {
+    riskyOperation();
+} catch (error) {
+    printl("Error: " + error);
+}
+
+try {
+    operation();
+} catch (error) {
+    printl("Error");
+} finally {
+    printl("Always runs");
+}
+```
+
+### Undefined Functions
+
+```cssl
+undefined void safeOperation() {
+    dangerousCode();  // Errors ignored
+}
+```
+
+### Assert
+
+```cssl
+assert(x > 0, "x must be positive");
+```
+
+---
+
+## Quick Reference
+
+### Keywords
+
+| Keyword | Description |
+|---------|-------------|
+| `void` | No return value |
+| `return` | Return value |
+| `global` | Declare global |
+| `if` / `else` / `elif` | Conditionals |
+| `switch` / `case` / `default` | Switch statement |
+| `for` / `foreach` / `while` | Loops |
+| `break` / `continue` | Loop control |
+| `try` / `catch` / `finally` | Error handling |
+| `class` / `new` / `this` | OOP |
+| `extends` / `overwrites` | Inheritance |
+| `constr` | Constructor |
+| `define` | Function definition |
+| `undefined` | Ignore errors |
+| `closed` / `private` | Injection protection |
+| `virtual` | Import-safe |
+| `meta` / `super` | Special function types |
+| `shuffled` | Multiple returns |
+| `open` | Any parameters |
+| `include` / `get` | Import modules |
+
+### Injection Operators
+
+| Operator | Type | Description |
+|----------|------|-------------|
+| `<<==` | CodeInfusion | Replace function |
+| `+<<==` | CodeInfusion | Add code before |
+| `-<<==` | CodeInfusion | Remove code |
+| `<==` | ValueCapture | Capture/assign |
+| `+<==` | BruteInjection | Copy data |
+| `-<==` | BruteInjection | Move data |
+| `==>` | BruteInjection | Replace data |
+| `==>-` | BruteInjection | Remove matching |
+| `++` | AppendMode | Append to parent |
+
+### Special Syntax
+
+| Syntax | Description |
+|--------|-------------|
+| `@name` | Global variable |
+| `$name` | Shared Python object |
+| `%name` | Captured value |
+| `this->` | Class member access |
+| `super::method()` | Parent method call |
+| `json::func()` | Namespace function |
+| `&ClassName::member` | Class member reference |
+| `&FunctionName ++` | Append to function |
+| `*func()` | Non-null function |
+| `*[type]func()` | Type exclusion filter |
+
+---
+
+*CSSL v3.9.0 - Developed as part of IncludeCPP*