@kcvabeysinghe/chsl 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chethana
+
+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/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

package/README.md

@@ -0,0 +1,139 @@
+# CHSL (Chethana's Human-readable Simple Language)
+
+![npm](https://img.shields.io/npm/v/chsl?color=red&logo=npm)
+![npm downloads](https://img.shields.io/npm/dt/chsl?logo=npm)
+![PyPI](https://img.shields.io/pypi/v/chsl?color=blue&logo=python)
+![PyPI downloads](https://img.shields.io/pypi/dm/chsl?logo=python)
+![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)
+
+**The configuration language designed for humans, not parsers.**
+
+CHSL is a lightweight, strictly-typed, and highly readable configuration language. It was built from the ground up to be as simple and predictable as possible for humans to read and write.
+
+## Why use CHSL?
+
+1. **No quotes, no syntax headaches** — just write your values naturally and CHSL figures out the type automatically.
+2. **Comments that actually work** — document your config files properly with `NOTE:` so future you knows why something is set.
+3. **Secrets done right** — pull API keys and passwords directly from the operating system with `COPY_ENV`. If the secret is missing, it crashes immediately before anything goes wrong.
+4. **Write once, reuse anywhere** — the `COPY` system lets you define a value once and reference it everywhere. Change it in one place, it updates everywhere.
+5. **Readable multi-line text** — write long text blocks with numbered lines instead of cramming everything into one unreadable line.
+6. **Protect special strings with PIN** — passwords, zip codes, and ID numbers that look like numbers stay exactly as you wrote them.
+7. **Split big configs into smaller files** — use `LOAD` to break massive configuration files into clean, logical chunks.
+8. **Never lose track of nesting** — the `0Group0` bracket system makes it visually impossible to lose track of which scope you're in, no matter how deep.
+9. **Short or long arrays, your choice** — write quick inline arrays with `ARE` or detailed bullet lists with `#` depending on what's more readable.
+10. **Built-in safety** — circular file dependencies and directory traversal attacks are blocked at the language level, not the application level.
+
+---
+
+## Features & Syntax
+
+### 1. Variables and Data Types
+No quotes are required. CHSL automatically understands text, numbers, booleans (YES/NO), and empty values.
+
+```text
+NOTE: This is a comment.
+server_name = Oxide Main Server
+is_active = YES
+api_token = EMPTY
+```
+
+### 2. The PIN System (Strict Text)
+Keep leading zeros on passwords, phone numbers, or ZIP codes by using `PIN`.
+
+```text
+admin_password = PIN 0042
+```
+*(Parsed as the exact string `"0042"`, not the number `42`)*
+
+### 3. Arrays in CHSL (Two Ways)
+CHSL provides two ways to write lists, designed for different situations.
+
+**Method A: Smart Lists (The `#` bullet points)**
+* **Best for:** Long lists, or strings that naturally contain spaces and commas.
+```text
+allowed_ports =
+#8080
+#8081
+#PIN 0021
+```
+
+**Method B: Inline Arrays (The `ARE` keyword)**
+* **Best for:** Short, simple data on a single line.
+* **Note:** Commas strictly separate items. If your text naturally contains spaces or commas, use Method A (`#` bullet lists) instead. If you use `Smith_John` to avoid spaces, it will be parsed literally as `"Smith_John"`.
+```text
+0Users0
+name ARE Alice, Bob, Charlie
+age ARE 30, EMPTY, 25
+```
+
+### 4. Explicit Multi-line Text (Paragraphs)
+Write multi-line text naturally using explicit, numbered lines.
+
+```text
+welcome_message = LINE
+1 = Hello there!
+2 = Welcome to the server.
+```
+
+### 5. Infinite, Explicit Nesting
+CHSL uses numbered headers to change the current group scope. You don't need closing tags; declaring a new group automatically shifts the level.
+
+```text
+0Network0
+bind_ip = 192.168.1.1
+
+  1Access1
+  block_guest = YES
+
+0Database0
+port = 5432
+```
+
+### 6. DRY Configs (The COPY System)
+Don't repeat yourself. CHSL allows you to copy values from other keys in the file.
+
+```text
+active_port = 8080
+backup_port = COPY active_port
+```
+
+### 7. Native OS Secrets
+Never hardcode API keys in your config files again. CHSL securely pulls secrets directly from the operating system environment.
+
+```text
+stripe_api_key = COPY_ENV STRIPE_SECRET_KEY
+```
+
+### 8. Modularity (File Loading)
+Split massive configuration files into smaller chunks. Circular dependency detection and directory traversal protection are built-in automatically.
+
+```text
+LOAD weapons.chsl
+```
+
+---
+
+## Usage
+CHSL provides perfect compatibility across **Python** and **JavaScript (Node.js)**.
+
+### Python (Install via PyPI)
+```bash
+pip install chsl
+```
+```python
+from chsl import parse_chsl_file, write_chsl_file
+
+config = parse_chsl_file("settings.chsl")
+write_chsl_file(config, "new_settings.chsl")
+```
+
+### JavaScript / Node.js (Install via npm)
+```bash
+npm install chsl
+```
+```javascript
+const CHSL = require('chsl');
+
+const config = CHSL.parseCHSLFile('settings.chsl');
+CHSL.writeCHSLFile(config, 'new_settings.chsl');
+```

package/chsl.js

@@ -0,0 +1,258 @@
+const fs = require('fs');
+const path = require('path');
+
+// ==========================================
+// PHASE 1: THE CHSL READER (Parser)
+// ==========================================
+function parseCHSL(text, currentDir = ".", _visited = new Set()) {
+    const lines = text.split('\n');
+    const config = {};
+    const scopePath = { "-1": config };
+    let currentLevel = -1;
+    
+    let state = "NORMAL";
+    let currentKey = null;
+    let currentList = [];
+    let currentLines = [];
+    let expectedLine = 1;
+
+    // Absolute path for security with trailing separator
+    let baseDir = path.resolve(currentDir);
+    if (!baseDir.endsWith(path.sep)) baseDir += path.sep;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const actualLineNum = i + 1;
+
+        // Ignore empty lines and comments
+        if (!line || line.startsWith("NOTE:")) continue;
+
+        // Handle Multi-line Bullet Lists (#)
+        if (state === "IN_LIST") {
+            if (line.startsWith("#")) {
+                const itemVal = line.substring(1).trim();
+                if (itemVal === "YES") currentList.push(true);
+                else if (itemVal === "NO") currentList.push(false);
+                else if (itemVal === "EMPTY") currentList.push(null);
+                else if (itemVal.startsWith("PIN ")) currentList.push(itemVal.substring(4).trim());
+                else {
+                    if (/^-?\d+(\.\d+)?$/.test(itemVal)) currentList.push(Number(itemVal));
+                    else currentList.push(itemVal);
+                }
+                continue;
+            } else {
+                scopePath[currentLevel][currentKey] = currentList;
+                state = "NORMAL";
+            }
+        }
+
+        // Handle Explicit Multi-line Text (LINE)
+        if (state === "IN_LINE") {
+            const match = line.match(/^(\d+)\s*=\s*(.*)/);
+            if (match) {
+                const num = parseInt(match[1], 10);
+                if (num !== expectedLine) throw new SyntaxError(`CHSL ERROR (Line ${actualLineNum}): Expected '${expectedLine} =', got '${num} ='`);
+                currentLines.push(match[2].trim());
+                expectedLine++;
+                continue;
+            } else {
+                scopePath[currentLevel][currentKey] = currentLines.join('\n');
+                state = "NORMAL";
+            }
+        }
+
+        // Handle File Loading (LOAD)
+        if (line.startsWith("LOAD ")) {
+            const filename = line.substring(5).trim();
+            const filepath = path.resolve(baseDir, filename);
+            
+            // Security: Prevent directory traversal
+            if (!filepath.startsWith(baseDir)) {
+                throw new Error(`CHSL SECURITY ERROR (Line ${actualLineNum}): Cannot LOAD files outside the current directory!`);
+            }
+            // Security: Prevent circular dependencies
+            if (_visited.has(filepath)) {
+                throw new Error(`CHSL ERROR (Line ${actualLineNum}): Circular LOAD detected for '${filename}'`);
+            }
+            if (!fs.existsSync(filepath)) {
+                throw new Error(`CHSL ERROR (Line ${actualLineNum}): LOAD failed for '${filename}'`);
+            }
+            
+            const newVisited = new Set(_visited);
+            newVisited.add(filepath);
+            
+            const loadedText = fs.readFileSync(filepath, 'utf8');
+            Object.assign(scopePath[currentLevel], parseCHSL(loadedText, path.dirname(filepath), newVisited));
+            continue;
+        }
+
+        // Handle Explicit Nesting Scopes (e.g., 0Group0)
+        const groupMatch = line.match(/^(\d+)([a-zA-Z0-9_]+)(\d+)$/);
+        if (groupMatch) {
+            const levelStart = parseInt(groupMatch[1], 10);
+            const name = groupMatch[2];
+            const levelEnd = parseInt(groupMatch[3], 10);
+
+            if (levelStart !== levelEnd) throw new SyntaxError(`CHSL ERROR (Line ${actualLineNum}): Group numbers do not match!`);
+            if (levelStart > currentLevel + 1) throw new SyntaxError(`CHSL ERROR (Line ${actualLineNum}): Skipped a group depth!`);
+
+            const newScope = {};
+            scopePath[levelStart - 1][name] = newScope;
+            scopePath[levelStart] = newScope;
+            currentLevel = levelStart;
+            continue;
+        }
+
+        // Handle Inline Arrays (ARE) - Anchored strictly to prevent false positives
+        const areMatch = line.match(/^([^\s=]+)\s+ARE\s+(.*)/);
+        if (areMatch) {
+            const key = areMatch[1];
+            const valPart = areMatch[2];
+            const rawVals = valPart.split(",");
+            const parsedList = [];
+            
+            for (let rv of rawVals) {
+                let v = rv.trim();
+                if (v === "YES") parsedList.push(true);
+                else if (v === "NO") parsedList.push(false);
+                else if (v === "EMPTY") parsedList.push(null);
+                else if (v.startsWith("PIN ")) parsedList.push(v.substring(4).trim());
+                else {
+                    if (/^-?\d+(\.\d+)?$/.test(v)) parsedList.push(Number(v));
+                    else parsedList.push(v);
+                }
+            }
+            scopePath[currentLevel][key] = parsedList;
+            continue;
+        }
+
+        // Handle Standard Key-Value Pairs (=)
+        if (line.includes("=")) {
+            const splitIdx = line.indexOf("=");
+            const key = line.substring(0, splitIdx).trim();
+            const val = line.substring(splitIdx + 1).trim();
+
+            if (val === "") {
+                state = "IN_LIST";
+                currentKey = key;
+                currentList = [];
+                continue;
+            }
+            if (val === "LINE") {
+                state = "IN_LINE";
+                currentKey = key;
+                currentLines = [];
+                expectedLine = 1;
+                continue;
+            }
+
+            let finalVal = null;
+            if (val === "YES") finalVal = true;
+            else if (val === "NO") finalVal = false;
+            else if (val === "EMPTY") finalVal = null;
+            else if (val.startsWith("PIN ")) finalVal = val.substring(4).trim();
+            else if (val.startsWith("COPY_ENV ")) {
+                const envVar = val.substring(9).trim();
+                if (!(envVar in process.env)) throw new Error(`CHSL ERROR (Line ${actualLineNum}): Missing Required OS Secret '${envVar}'!`);
+                finalVal = process.env[envVar];
+            } else if (val.startsWith("COPY ")) {
+                const refKey = val.substring(5).trim();
+                let found = false;
+                for (let lvl = currentLevel; lvl >= -1; lvl--) {
+                    if (scopePath[lvl] && refKey in scopePath[lvl]) {
+                        finalVal = scopePath[lvl][refKey];
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) throw new Error(`CHSL ERROR (Line ${actualLineNum}): Tried to COPY '${refKey}', but it doesn't exist!`);
+            } else {
+                if (/^-?\d+(\.\d+)?$/.test(val)) finalVal = Number(val);
+                else finalVal = val;
+            }
+
+            scopePath[currentLevel][key] = finalVal;
+            continue;
+        }
+
+        throw new SyntaxError(`CHSL ERROR (Line ${actualLineNum}): Unrecognized syntax -> '${line}'`);
+    }
+
+    // Flush remaining state at end of file
+    if (state === "IN_LIST") scopePath[currentLevel][currentKey] = currentList;
+    else if (state === "IN_LINE") scopePath[currentLevel][currentKey] = currentLines.join('\n');
+
+    return config;
+}
+
+function parseCHSLFile(filepath) {
+    const absolutePath = path.resolve(filepath);
+    return parseCHSL(fs.readFileSync(absolutePath, 'utf8'), path.dirname(absolutePath));
+}
+
+// ==========================================
+// PHASE 2: THE CHSL WRITER (Serializer)
+// ==========================================
+function dumpCHSL(configDict, level = 0) {
+    const lines = [];
+    for (const [key, value] of Object.entries(configDict)) {
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            lines.push(`\n${level}${key}${level}`);
+            lines.push(...dumpCHSL(value, level + 1));
+            
+        } else if (Array.isArray(value)) {
+            // Smart Array Serializer: Choose 'ARE' if safe, otherwise fallback to '#'
+            const isSafeForAre = value.every(i => typeof i !== 'object' && !(typeof i === 'string' && (i.includes('\n') || i.includes(','))));
+            
+            if (isSafeForAre && value.length > 0) {
+                const areItems = value.map(item => {
+                    if (typeof item === 'boolean') return item ? "YES" : "NO";
+                    if (item === null) return "EMPTY";
+                    if (typeof item === 'number') return `${item}`;
+                    if (typeof item === 'string' && /^-?\d+(\.\d+)?$/.test(item)) return `PIN ${item}`;
+                    return `${item}`;
+                });
+                lines.push(`${key} ARE ${areItems.join(', ')}`);
+            } else {
+                lines.push(`${key} =`);
+                for (const item of value) {
+                    if (typeof item === 'boolean') lines.push(item ? "#YES" : "#NO");
+                    else if (item === null) lines.push("#EMPTY");
+                    else if (typeof item === 'number') lines.push(`#${item}`);
+                    else if (typeof item === 'string' && /^-?\d+(\.\d+)?$/.test(item)) lines.push(`#PIN ${item}`);
+                    else lines.push(`#${item}`);
+                }
+            }
+            
+        } else if (typeof value === 'boolean') {
+            lines.push(`${key} = ${value ? 'YES' : 'NO'}`);
+            
+        } else if (value === null) {
+            lines.push(`${key} = EMPTY`);
+            
+        } else if (typeof value === 'number') {
+            lines.push(`${key} = ${value}`);
+            
+        } else if (typeof value === 'string') {
+            if (value.includes('\n')) {
+                lines.push(`${key} = LINE`);
+                const textLines = value.split('\n');
+                for (let i = 0; i < textLines.length; i++) lines.push(`${i + 1} = ${textLines[i]}`);
+            } else if (/^-?\d+(\.\d+)?$/.test(value)) {
+                lines.push(`${key} = PIN ${value}`);
+            } else {
+                lines.push(`${key} = ${value}`);
+            }
+        }
+    }
+    return lines;
+}
+
+function writeCHSLFile(configDict, filename = "output.chsl") {
+    const lines = ["NOTE: Automatically generated by the CHSL Engine\n", ...dumpCHSL(configDict)];
+    const finalText = lines.join('\n');
+    fs.writeFileSync(filename, finalText, 'utf8');
+    return finalText;
+}
+
+module.exports = { parseCHSL, parseCHSLFile, dumpCHSL, writeCHSLFile };

package/chsl.py

@@ -0,0 +1,273 @@
+import os
+import re
+
+# ==========================================
+# PHASE 1: THE CHSL READER (Parser)
+# ==========================================
+def parse_chsl(text, current_dir=".", _visited=None):
+    if _visited is None:
+        _visited = set()
+        
+    lines = text.split('\n')
+    config = {}
+    scope_path = {-1: config}
+    current_level = -1
+    
+    state = "NORMAL"
+    current_key = None
+    current_list = []
+    current_lines = []
+    expected_line = 1
+    
+    # Absolute path for security with trailing separator
+    base_dir = os.path.abspath(current_dir)
+    if not base_dir.endswith(os.sep):
+        base_dir += os.sep
+    
+    for line_idx, raw_line in enumerate(lines):
+        line = raw_line.strip()
+        actual_line_num = line_idx + 1
+        
+        # Ignore empty lines and comments
+        if not line or line.startswith("NOTE:"):
+            continue
+            
+        # Handle Multi-line Bullet Lists (#)
+        if state == "IN_LIST":
+            if line.startswith("#"):
+                item_val = line[1:].strip()
+                if item_val == "YES":
+                    current_list.append(True)
+                elif item_val == "NO":
+                    current_list.append(False)
+                elif item_val == "EMPTY":
+                    current_list.append(None)
+                elif item_val.startswith("PIN "):
+                    current_list.append(item_val[4:].strip())
+                else:
+                    try:
+                        parsed_num = float(item_val) if "." in item_val else int(item_val)
+                        current_list.append(parsed_num)
+                    except ValueError:
+                        current_list.append(item_val)
+                continue
+            else:
+                scope_path[current_level][current_key] = current_list
+                state = "NORMAL"
+
+        # Handle Explicit Multi-line Text (LINE)
+        if state == "IN_LINE":
+            match = re.match(r"^(\d+)\s*=\s*(.*)", line)
+            if match:
+                num = int(match.group(1))
+                if num != expected_line:
+                    raise SyntaxError(f"CHSL ERROR (Line {actual_line_num}): Expected '{expected_line} =', got '{num} ='")
+                current_lines.append(match.group(2).strip())
+                expected_line += 1
+                continue
+            else:
+                scope_path[current_level][current_key] = "\n".join(current_lines)
+                state = "NORMAL"
+
+        # Handle File Loading (LOAD)
+        if line.startswith("LOAD "):
+            filename = line[5:].strip()
+            filepath = os.path.abspath(os.path.join(base_dir, filename))
+            
+            # Security: Prevent directory traversal
+            if not filepath.startswith(base_dir):
+                raise PermissionError(f"CHSL SECURITY ERROR (Line {actual_line_num}): Cannot LOAD files outside directory!")
+            
+            # Security: Prevent circular dependencies
+            if filepath in _visited:
+                raise RecursionError(f"CHSL ERROR (Line {actual_line_num}): Circular LOAD detected for '{filename}'")
+                
+            if not os.path.exists(filepath):
+                raise FileNotFoundError(f"CHSL ERROR (Line {actual_line_num}): LOAD failed. File '{filename}' not found.")
+            
+            _new_visited = _visited.copy()
+            _new_visited.add(filepath)
+            
+            with open(filepath, 'r') as f:
+                loaded_config = parse_chsl(f.read(), os.path.dirname(filepath), _new_visited)
+                
+            scope_path[current_level].update(loaded_config)
+            continue 
+            
+        # Handle Explicit Nesting Scopes (e.g., 0Group0)
+        group_match = re.match(r"^(\d+)([a-zA-Z0-9_]+)(\d+)$", line)
+        if group_match:
+            level_start = int(group_match.group(1))
+            name = group_match.group(2)
+            level_end = int(group_match.group(3))
+            
+            if level_start != level_end:
+                raise SyntaxError(f"CHSL ERROR (Line {actual_line_num}): Group numbers do not match!")
+            if level_start > current_level + 1:
+                raise SyntaxError(f"CHSL ERROR (Line {actual_line_num}): Skipped a group depth!")
+            
+            new_scope = {}
+            scope_path[level_start - 1][name] = new_scope
+            scope_path[level_start] = new_scope
+            current_level = level_start
+            continue
+
+        # Handle Inline Arrays (ARE) - Anchored strictly to prevent false positives
+        are_match = re.match(r"^([^\s=]+)\s+ARE\s+(.*)", line)
+        if are_match:
+            key = are_match.group(1)
+            raw_vals = are_match.group(2).split(",")
+            parsed_list = []
+            
+            for rv in raw_vals:
+                v = rv.strip()
+                if v == "YES": parsed_list.append(True)
+                elif v == "NO": parsed_list.append(False)
+                elif v == "EMPTY": parsed_list.append(None)
+                elif v.startswith("PIN "): parsed_list.append(v[4:].strip())
+                else:
+                    try:
+                        parsed_list.append(float(v) if "." in v else int(v))
+                    except ValueError:
+                        parsed_list.append(v)
+            
+            scope_path[current_level][key] = parsed_list
+            continue
+            
+        # Handle Standard Key-Value Pairs (=)
+        if "=" in line:
+            key_part, val_part = line.split("=", 1)
+            key = key_part.strip()
+            val = val_part.strip()
+            
+            if val == "":
+                state = "IN_LIST"
+                current_key = key
+                current_list = []
+                continue
+                
+            if val == "LINE":
+                state = "IN_LINE"
+                current_key = key
+                current_lines = []
+                expected_line = 1
+                continue
+                
+            final_val = None
+            if val == "YES":
+                final_val = True
+            elif val == "NO":
+                final_val = False
+            elif val == "EMPTY":
+                final_val = None
+            elif val.startswith("PIN "):
+                final_val = val[4:].strip() 
+            elif val.startswith("COPY_ENV "):
+                env_var = val[9:].strip()
+                if env_var not in os.environ:
+                    raise EnvironmentError(f"CHSL ERROR (Line {actual_line_num}): Missing Required OS Secret '{env_var}'!")
+                final_val = os.environ[env_var]
+            elif val.startswith("COPY "):
+                ref_key = val[5:].strip()
+                found = False
+                for lvl in range(current_level, -2, -1):
+                    if ref_key in scope_path[lvl]:
+                        final_val = scope_path[lvl][ref_key]
+                        found = True
+                        break
+                if not found:
+                    raise NameError(f"CHSL ERROR (Line {actual_line_num}): Tried to COPY '{ref_key}', but it doesn't exist!")
+            else:
+                try:
+                    final_val = float(val) if "." in val else int(val)
+                except ValueError:
+                    final_val = val
+                    
+            scope_path[current_level][key] = final_val
+            continue
+            
+        raise SyntaxError(f"CHSL ERROR (Line {actual_line_num}): Unrecognized syntax -> '{line}'")
+        
+    # Flush remaining state at end of file
+    if state == "IN_LIST":
+        scope_path[current_level][current_key] = current_list
+    elif state == "IN_LINE":
+        scope_path[current_level][current_key] = "\n".join(current_lines)
+        
+    return config
+
+def parse_chsl_file(filepath):
+    abs_path = os.path.abspath(filepath)
+    with open(abs_path, 'r') as f:
+        return parse_chsl(f.read(), os.path.dirname(abs_path))
+
+# ==========================================
+# PHASE 2: THE CHSL WRITER (Serializer)
+# ==========================================
+def dump_chsl(config_dict, level=0):
+    lines = []
+    for key, value in config_dict.items():
+        if isinstance(value, dict):
+            lines.append(f"\n{level}{key}{level}")
+            lines.extend(dump_chsl(value, level + 1))
+            
+        elif isinstance(value, list):
+            # Smart Array Serializer: Choose 'ARE' if safe, otherwise fallback to '#'
+            is_safe_for_are = all(not isinstance(i, (dict, list)) and (not isinstance(i, str) or ("\n" not in i and "," not in i)) for i in value)
+            
+            if is_safe_for_are and len(value) > 0:
+                are_items = []
+                for item in value:
+                    if isinstance(item, bool):
+                        are_items.append("YES" if item else "NO")
+                    elif item is None:
+                        are_items.append("EMPTY")
+                    elif isinstance(item, (int, float)):
+                        are_items.append(str(item))
+                    elif isinstance(item, str) and re.match(r"^-?\d+(\.\d+)?$", item):
+                        are_items.append(f"PIN {item}")
+                    else:
+                        are_items.append(str(item))
+                lines.append(f"{key} ARE {', '.join(are_items)}")
+            else:
+                lines.append(f"{key} =")
+                for item in value:
+                    if isinstance(item, bool):
+                        lines.append(f"#YES" if item else f"#NO")
+                    elif item is None:
+                        lines.append(f"#EMPTY")
+                    elif isinstance(item, (int, float)):
+                        lines.append(f"#{item}")
+                    elif isinstance(item, str) and re.match(r"^-?\d+(\.\d+)?$", item):
+                        lines.append(f"#PIN {item}")
+                    else:
+                        lines.append(f"#{item}")
+                        
+        elif isinstance(value, bool):
+            lines.append(f"{key} = {'YES' if value else 'NO'}")
+            
+        elif value is None:
+            lines.append(f"{key} = EMPTY")
+            
+        elif isinstance(value, (int, float)):
+            lines.append(f"{key} = {value}")
+            
+        elif isinstance(value, str):
+            if "\n" in value:
+                lines.append(f"{key} = LINE")
+                for i, text_line in enumerate(value.split("\n"), 1):
+                    lines.append(f"{i} = {text_line}")
+            elif re.match(r"^-?\d+(\.\d+)?$", value):
+                lines.append(f"{key} = PIN {value}")
+            else:
+                lines.append(f"{key} = {value}")
+                
+    return lines
+
+def write_chsl_file(config_dict, filename="output.chsl"):
+    lines = ["NOTE: Automatically generated by the CHSL Engine\n"]
+    lines.extend(dump_chsl(config_dict))
+    final_text = "\n".join(lines)
+    with open(filename, "w") as f:
+        f.write(final_text)
+    return final_text

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@kcvabeysinghe/chsl",
+  "version": "1.0.0",
+  "description": "Chethana's Human-readable Simple Language parser and serializer.",
+  "main": "chsl.js",
+  "scripts": {
+    "test": "echo \"No tests yet\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kcvabeysinghe/chsl"
+  },
+  "keywords": [
+    "chsl",
+    "configuration",
+    "parser",
+    "settings"
+  ],
+  "author": "Chethana",
+  "license": "MIT"
+}

package/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chsl"
+version = "1.0.0"
+authors = [
+  { name="Chethana" }
+]
+description = "Chethana's Human-readable Simple Language parser and serializer."
+readme = "README.md"
+requires-python = ">=3.6"
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]