From abd2d112d801d8101e99449600724089836e5168 Mon Sep 17 00:00:00 2001
From: multipleof4 <planetrenox@protonmail.com>
Date: Tue, 23 Sep 2025 15:14:58 -0700
Subject: [PATCH] Revert: Update index.html

---
 index.html | 187 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 109 insertions(+), 78 deletions(-)
diff --git a/index.html b/index.html
index 24df735..850ebab 100644
--- a/index.html
+++ b/index.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Hi: A Symbolic Syntax for JavaScript</title>
+    <title>Hi: A Symbolic Programming Language</title>
     
     <!-- Tailwind CSS -->
     <script src="https://cdn.tailwindcss.com"></script>
@@ -84,11 +84,11 @@
     
     <script>
         const markdownContent = `
-# A Symbolic Syntax for JavaScript
+# A corely symbolic language
 
-**Hi** is a symbolic frontend for JavaScript, designed for code golfing and improved AI interaction. It transpiles to standard JS, providing full access to its powerful engine and the entire NPM ecosystem, but with a syntax that prioritizes symbols over keywords.
+**Hi** is a programming language inspired by JavaScript, designed with a symbolic core to be more universal, AI-friendly, and conducive to code golfing. The syntax prioritizes symbols over keywords.
 
-The underscore \`_\` is the global output function, transpiling to \`console.log\`.
+The underscore \`_\` is the global output function.
 
 \`\`\`javascript
 _("Hi world")
@@ -96,9 +96,9 @@ _("Hi world")
 
 ## Declaration and Assignment
 
-Variable lifecycle is split into two distinct symbolic operations, providing a more concise alternative to \`let\`/\`const\` and subsequent assignment.
+Variable lifecycle is split into two distinct symbolic operations.
 
-- \`:\` **Declaration**: Binds a name in the current scope (like \`let\`).
+- \`:\` **Declaration**: Binds a name in the current scope.
 - \`=\` **Assignment**: Reassigns the value of an existing name.
 
 \`\`\`javascript
@@ -108,10 +108,10 @@ version = 1.1 // Assignment
 
 ## The Block: Unifying Objects and Functions
 
-The **Block** (\`{}\`) is Hi's foundational structure, unifying data objects and executable functions into a single concept. It is a sequence of expressions that can be invoked with \`()\`.
+The **Block** (\`{}\`) is Hi's foundational structure, unifying data objects and executable functions. It is a sequence of expressions that can be invoked with \`()\`.
 
 ### As a Data Structure (Object)
-A block can hold \`key: value\` pairs, transpiling to a standard JavaScript object. A \`#\` prefix denotes a private property.
+A block can hold \`key: value\` pairs. A \`#\` prefix denotes a private property.
 
 \`\`\`javascript
 player: {
@@ -124,7 +124,7 @@ _(player.hp)   // -0 (null) because #hp is private
 \`\`\`
 
 ### As Executable Code (Function)
-Invoking a block with \`()\` executes its expressions. The value of the last expression is implicitly returned. This transpiles to a JavaScript function.
+Invoking a block with \`()\` executes its expressions. The value of the last expression is implicitly returned.
 
 \`\`\`javascript
 // Simple invocation
@@ -137,7 +137,7 @@ _(add(2, 3)) // Prints 5
 \`\`\`
 
 ### As a Hybrid (Factory/Class)
-A block containing both data and logic acts as a natural factory. The context symbol \`@\` (representing JS \`this\`) can be used to return the newly created instance.
+A block can contain both data and logic. When invoked, its internal declarations are re-initialized, making it a natural factory. The context symbol \`@\` can be used to return the newly created instance.
 
 \`\`\`javascript
 createPlayer: (name) {
@@ -167,7 +167,7 @@ point: { x: 10, y: 20 }
 
 ## Arrow Expressions
 
-To maintain familiarity and leverage powerful JS idioms, Hi directly adopts the arrow function syntax. It serves as a shorthand for a Block that immediately returns an expression.
+For concise single-expression functions, Hi provides the \`=>\` arrow syntax, inspired by JavaScript. It serves as a shorthand for a Block that immediately returns an expression, making it ideal for callbacks and functional patterns.
 
 It's a direct replacement for \`(params) { ^ expression }\`.
 
@@ -178,7 +178,7 @@ add: (a, b) { ^ a + b }
 // Equivalent Arrow Expression
 add: (a, b) => a + b
 
-// Directly uses JS array methods
+// Useful for functional helpers
 numbers: [1, 2, 3]
 doubled: numbers.map((n) => n * 2)
 _(doubled) // [2, 4, 6]
@@ -186,17 +186,17 @@ _(doubled) // [2, 4, 6]
 
 ## Booleans and Equality
 
-Hi dispenses with boolean keywords in favor of canonical numeric values, which map directly to JavaScript's truthiness model.
+Hi dispenses with boolean keywords in favor of canonical numeric values for truthiness.
 
-- \`0\` is **falsy** (transpiles to \`false\`).
-- \`!0\` is **truthy** (transpiles to \`true\`).
+- \`0\` is **falsy** (the canonical false).
+- \`!0\` is **truthy** (the canonical true, representing a logical NOT 0).
 - \`-0\` represents null/undefined values.
-- All other non-zero numbers, and any non-empty string, block, or array are "truthy", consistent with JS behavior.
-- The \`==\` operator performs strict equality comparison (transpiles to JavaScript's \`===\`).
+- All other numbers, and any non-empty string, block, or array are "truthy".
+- The \`==\` operator performs strict equality comparison (equivalent to JavaScript's \`===\`).
 
 ## Conditional Expressions
 
-Hi uses a single ternary-like expression for all conditional logic, which transpiles to JS \`if/else\` statements or ternary operators.
+Hi uses a single ternary-like expression for all conditional logic. The simplest form acts like a standard \`if\` statement.
 
 \`\`\`javascript
 // A simple 'if' to execute code conditionally
@@ -204,22 +204,22 @@ status: "active"
 (status == "active") ? { _("User is active.") }
 \`\`\`
 
-You can provide an \`else\` branch using the colon (\`:\`) symbol.
+You can provide an \`else\` branch using the colon (\`:\`) symbol to choose between two actions.
 
 \`\`\`javascript
-// if / else
+// if / else for choosing an action
 isOnline: !0
 (isOnline == !0) ? { _("Online") } : { _("Offline") } // Prints "Online"
 \`\`\`
 
-This structure is an *expression* that always evaluates to a value, allowing the result to be directly assigned.
+This structure is powerful because it's an *expression* that always evaluates to a value. The value of the executed block becomes the value of the entire expression, allowing you to assign the result directly to a variable.
 
 \`\`\`javascript
 // if / else returning a value
 result: (1 > 2) ? { "A" } : { "B" } // result is "B"
 \`\`\`
 
-Expressions can be chained for \`if / else if / else\` logic.
+Expressions can be chained to create \`if / else if / else\` logic.
 
 \`\`\`javascript
 // if / else if / else
@@ -235,10 +235,8 @@ If a condition is false and no \`else\` branch is provided, the expression evalu
 
 ## Data Structures
 
-Hi provides a concise syntax for working with JavaScript's native data structures.
-
 ### Arrays
-Hi arrays are JavaScript arrays. They are 0-indexed lists supporting all standard JS Array methods.
+Arrays are 0-indexed lists of values. They support random access via \`[]\` and are iterable.
 
 \`\`\`javascript
 primes: [2, 3, 5, 7]
@@ -248,7 +246,7 @@ _(primes)     // Mutation: [1, 3, 5, 7]
 \`\`\`
 
 ### Strings
-Hi strings are JavaScript strings. They are immutable sequences of characters supporting all standard JS String methods.
+Strings are sequences of characters. They are immutable but support random access and iteration.
 
 \`\`\`javascript
 greeting: "Hi"
@@ -257,18 +255,18 @@ _(greeting[1]) // "i"
 
 ## Destructuring
 
-Destructuring provides an expressive way to extract data. The extraction operator \`->\` offers a clearer, more tool-friendly alternative to JavaScript's syntax.
+Destructuring provides an expressive way to extract data from Blocks and Arrays. The extraction operator \`->\` is used to unpack values, mirroring its use in module imports.
 
-- \`source -> { pattern }\`: Extracts properties from an Object.
+- \`source -> { pattern }\`: Extracts properties from a Block.
 - \`source -> [ pattern ]\`: Extracts elements from an Array.
-- \`prop -> alias\`: Used within the pattern for aliasing.
+- \`prop -> alias\`: The same operator is used within the pattern for aliasing.
 
 \`\`\`javascript
 // Setup
 user: { name: "Zeta", role: "Admin", id: 101 }
 coords: [10, -5, 8]
 
-// Extract 'name' and 'role'
+// Extract 'name' and 'role' from the user block
 user -> { name, role }
 _(name) // "Zeta"
 
@@ -276,16 +274,17 @@ _(name) // "Zeta"
 user -> { id -> userID }
 _(userID) // 101
 
-// Extract array elements
+// Extract first two elements from the array
 coords -> [x, y]
 _(y) // -5
 \`\`\`
 
 ## Repetition
 
-Hi unifies iteration with a single syntax: \`(source -> pattern) * { ... }\`. This transpiles to the most appropriate JavaScript loop (\`for...of\`, \`for...in\`, etc.) based on the source type.
+Repetition is handled by a unified iteration protocol: \`(source -> pattern) * { ... }\`. This single, concise syntax adapts to iterate over any collection type.
 
 ### Iterating Collections
+The \`->\` operator extracts elements from a source into a pattern.
 
 \`\`\`javascript
 // Iterate over an Array's values
@@ -297,6 +296,9 @@ Hi unifies iteration with a single syntax: \`(source -> pattern) * { ... }\`. Th
 // Iterate over a Block's key-value pairs
 ({ id: 1 } -> [k, v]) * { _(k + " is " + v) }
 
+// Iterate over a String's characters
+("Hi" -> char) * { _(char) }
+
 // Destructure directly in the loop signature
 users: [{ name: "Orion" }]
 (users -> { name }) * { _("User: " + name) }
@@ -306,16 +308,17 @@ users: [{ name: "Orion" }]
 The \`..\` operator creates an iterable numeric range for concise, traditional loops.
 
 \`\`\`javascript
+// A range from 0 up to (but not including) 3
 (0..3 -> i) * {
   _("Iteration: " + i) // Prints 0, 1, 2
 }
 \`\`\`
 
 ### Loop Control
-Control flow symbols map directly to their JS counterparts.
-- \`><\`: **Break** (\`break\`).
-- \`>>\`: **Continue** (\`continue\`).
-- \`^\`: **Return** (\`return\`). Exits the parent function.
+Control flow within loops is managed by distinct symbols:
+- \`><\`: **Break**. Immediately terminates the loop.
+- \`>>\`: **Continue**. Skips to the next iteration.
+- \`^\`: **Return**. Exits the parent block, not just the loop.
 
 \`\`\`javascript
 (0..10 -> i) * {
@@ -328,7 +331,7 @@ Control flow symbols map directly to their JS counterparts.
 
 ## Imports
 
-Hi streamlines JavaScript's module system with the \`+\` and \`->\` operators. This syntax improves tooling by placing the module source first, enabling immediate, context-aware autocompletion for the members being imported.
+Modules are imported using the \`+\` and \`->\` operators. This allows for destructuring and aliasing of imported members. Placing the module source first allows development tools to provide immediate, context-aware autocompletion for the members being imported—a direct ergonomic improvement over JavaScript's syntax.
 
 \`\`\`javascript
 // Import 'block1' and 'block2' (as 'alias2') from a module
@@ -340,10 +343,11 @@ alias2("some value")
 
 ## Context Reference: @
 
-The \`@\` symbol is a direct, one-character replacement for \`this\` in JavaScript, providing a reference to the current execution context.
+The \`@\` symbol provides a reference to the current execution context, similar to \`this\` in JavaScript. This allows a Block to refer to the object it was called on, making methods portable and reusable.
 
 \`\`\`javascript
 // This block is a portable method.
+// It relies on '@' to get the context.
 loggable: {
   logId: { _("ID is: " + @id) }
 }
@@ -357,24 +361,32 @@ item.log() // Prints "ID is: abc-789" (@ is 'item')
 
 ## Expression Blocks and Fluent Chaining
 
-Hi adopts an expression-oriented design. Every **Block** is an expression that yields a value, transpiling to a JS IIFE or function body.
+Hi adopts an expression-oriented design, similar to Rust. Every **Block** is an expression that yields a value.
 
 - The value of the *last expression* in a Block is implicitly returned.
 - To return early or explicitly, use the return symbol \`^\`.
 
+This makes code more concise by eliminating the need for explicit \`return\` keywords in most cases.
+
 \`\`\`javascript
 // The last expression, \`a + b\`, is returned.
 add: (a, b) {
-  _("adding...")
-  a + b
+  _("adding...") // Side-effect
+  a + b         // Return value
 }
 
 result: add(2, 3) // result is 5
+
+// An early, explicit return
+check: (n) {
+  (n < 0) ? { ^ "Negative" }
+  "Positive"
+}
 \`\`\`
 
 ### Fluent Chaining
 
-To enable fluent method chaining (e.g., \`obj.method1().method2()\`), if the last expression in a block produces no value (like an assignment), the block returns its own context (\`@\`) by default. This transpiles to returning \`this\`.
+To enable fluent method chaining, Hi adds one special rule: if the last expression in a block produces no value (e.g., an assignment), the block returns its own context (\`@\`) by default. This allows subsequent method calls on the same object.
 
 \`\`\`javascript
 calculator: {
@@ -384,49 +396,67 @@ calculator: {
   get: { ^ total }               // Explicitly returns the final value
 }
 
+// .add() and .sub() return the calculator, allowing the chain
 result: calculator.add(10).sub(4).get()
+
 _(result) // Prints 6
 \`\`\`
 
-## Direct JavaScript Interoperability
+## Core Language Blueprint
 
-Hi does not create its own standard library or aliases for built-in methods. Instead, it provides **direct access** to the complete JavaScript standard library. All properties (\`.length\`) and methods (\`.toUpperCase()\`, \`.map()\`) are used with their standard JavaScript names.
+To create the initial Hi-to-JS transpiler, the following primitives and built-in functionalities must be defined. This serves as the blueprint for the core standard library.
 
-This ensures zero learning curve for existing JS functionality and guarantees full compatibility.
+### Built-in Definitions Table
 
-### Common JavaScript Built-ins
-
-| Type | Name / Property / Method | Example |
-| :--- | :--- | :--- |
-| **Global** | \`_\` | \`_("hello") // console.log\` |
-| **Global** | \`Math\` | \`_(Math.PI)\` |
-| **Global** | \`Object\` | \`Object.keys({a:1}) // ["a"]\` |
-| | | |
-| **Number** | \`.toFixed(digits)\` | \`n: 3.14159; _(n.toFixed(2)) // "3.14"\` |
-| **Number** | \`.toString()\` | \`age: 21; _(age.toString())\` |
-| | | |
-| **String** | \`.length\` | \`"hi".length // 2\` |
-| **String** | \`.toUpperCase()\` | \`"hi".toUpperCase() // "HI"\` |
-| **String** | \`.toLowerCase()\` | \`"HI".toLowerCase() // "hi"\` |
-| **String** | \`.trim()\` | \`" hi ".trim() // "hi"\` |
-| **String** | \`.split(separator)\` | \`"a-b-c".split("-") // ["a","b","c"]\` |
-| **String** | \`.slice(start, end)\`| \`"hello".slice(1,3) // "el"\` |
-| **String** | \`.includes(substr)\`| \`"hi".includes("i") // !0 (true)\` |
-| **String** | \`.replaceAll(find,r)\` | \`"hi hi".replaceAll("i","o") // "ho ho"\` |
-| | | |
-| **Array** | \`.length\` | \`[1,2].length // 2\` |
-| **Array** | \`.push(value)\` | \`a:[1]; a.push(2) // a is now [1,2]\` |
-| **Array** | \`.pop()\` | \`a:[1,2]; a.pop() // returns 2\` |
-| **Array** | \`.forEach(fn)\` | \`[1,2].forEach((n)=>{_(n)})\` |
-| **Array** | \`.map(fn)\` | \`[1,2].map((n)=>n*2) // [2,4]\` |
-| **Array** | \`.filter(fn)\` | \`[1,2,3].filter((n)=>n>1) // [2,3]\` |
-| **Array** | \`.reduce(fn, init)\`| \`[1,2,3].reduce((a,c)=>a+c, 0) // 6\` |
-| **Array** | \`.find(fn)\` | \`[1,2].find((n)=>n>1) // 2\` |
-| **Array** | \`.includes(value)\` | \`[1,2].includes(2) // !0 (true)\` |
-| **Array** | \`.join(separator)\` | \`["a","b"].join("-") // "a-b"\` |
-| **Array** | \`.sort()\` | \`[3,1,2].sort() // [1,2,3]\` |
-| | | |
-| **Object** | \`.hasOwnProperty(key)\` | \`{a:1}.hasOwnProperty("a") // !0 (true)\` |
+| Type | Name / Symbol | Description | Example |
+| :--- | :--- | :--- | :--- |
+| **Global** | \`_\` | The global output function. Transpiles to \`console.log\`. | \`_("hello")\` |
+| **Global** | \`Math\` | A global block containing mathematical constants and functions. | \`_(Math.PI)\` |
+| | | | |
+| **Number** | \`.str()\` | Converts the number to its string representation. | \`age: 21; _(age.str())\` |
+| **Number** | \`.fix(d)\` | Formats a number using fixed-point notation. | \`n: 3.14159; _(n.fix(2)) // "3.14"\` |
+| | | | |
+| **String** | \`.len\` | **Property**: Returns the number of characters in the string. | \`"hi".len // 2\` |
+| **String** | \`.num()\` | Parses the string, returning a number. | \`"42".num() // 42\` |
+| **String** | \`.upper()\` | Returns the string converted to uppercase. | \`"hi".upper() // "HI"\` |
+| **String** | \`.lower()\` | Returns the string converted to lowercase. | \`"HI".lower() // "hi"\` |
+| **String** | \`.trim()\` | Removes whitespace from both ends of a string. | \`" hi ".trim() // "hi"\` |
+| **String** | \`.split(d)\` | Divides a string into an ordered list of substrings. | \`"a-b-c".split("-") // ["a","b","c"]\` |
+| **String** | \`.slice(s,e)\`| Extracts a section of a string and returns it as a new string. | \`"hello".slice(1,3) // "el"\` |
+| **String** | \`.has(sub)\`| Determines whether a string contains a given substring. | \`"hi".has("i") // !0 (true)\` |
+| **String** | \`.replace(f,r)\` | Replaces the first occurrence of a substring. | \`"hi hi".replace("i","o") // "ho hi"\` |
+| **String** | \`.replaceAll(f,r)\` | Replaces all occurrences of a substring. | \`"hi hi".replaceAll("i","o") // "ho ho"\` |
+| | | | |
+| **Array** | \`.len\` | **Property**: Returns the number of elements in the array. | \`[1,2].len // 2\` |
+| **Array** | \`.add(v)\` | Adds one or more elements to the end of an array. | \`a:[1]; a.add(2) // a is now [1,2]\` |
+| **Array** | \`.pop()\` | Removes the last element from an array and returns it. | \`a:[1,2]; a.pop() // returns 2\` |
+| **Array** | \`.pre(v)\` | Adds one or more elements to the beginning of an array. | \`a:[2]; a.pre(1) // a is now [1,2]\` |
+| **Array** | \`.shift()\` | Removes the first element from an array and returns it. | \`a:[1,2]; a.shift() // returns 1\` |
+| **Array** | \`.each(fn)\` | Executes a provided function once for each array element. | \`[1,2].each((n)=>{_(n)})\` |
+| **Array** | \`.map(fn)\` | Creates a new array with the results of calling a function on every element. | \`[1,2].map((n)=>n*2) // [2,4]\` |
+| **Array** | \`.filter(fn)\` | Creates a new array with all elements that pass the test implemented by the provided function. | \`[1,2,3].filter((n)=>n>1) // [2,3]\` |
+| **Array** | \`.reduce(fn,iv)\`| Executes a reducer function on each element, resulting in a single output value. | \`[1,2,3].reduce((a,c)=>a+c, 0) // 6\` |
+| **Array** | \`.find(fn)\` | Returns the first element in the array that satisfies the provided testing function. | \`[1,2].find((n)=>n>1) // 2\` |
+| **Array** | \`.has(v)\` | Determines whether an array includes a certain value. | \`[1,2].has(2) // !0 (true)\` |
+| **Array** | \`.join(d)\` | Joins all elements of an array into a string. | \`["a","b"].join("-") // "a-b"\` |
+| **Array** | \`.slice(s,e)\`| Returns a shallow copy of a portion of an array into a new array object. | \`[1,2,3].slice(1) // [2,3]\` |
+| **Array** | \`.reverse()\`| Reverses an array in place. | \`a:[1,2]; a.reverse() // a is [2,1]\` |
+| **Array** | \`.sort(fn)\` | Sorts the elements of an array in place. | \`[3,1,2].sort() // [1,2,3]\` |
+| | | | |
+| **Block** | \`.keys()\` | Returns an array of a given block's own property names. | \`{a:1}.keys() // ["a"]\` |
+| **Block** | \`.values()\` | Returns an array of a given block's own property values. | \`{a:1}.values() // [1]\` |
+| **Block** | \`.has(key)\` | Checks if a block has a specified property as its own. | \`{a:1}.has("a") // !0 (true)\` |
+| | | | |
+| **Math** | \`.PI\` | **Property**: Ratio of a circle's circumference to its diameter. | \`Math.PI // 3.14159...\` |
+| **Math** | \`.abs(n)\` | Returns the absolute value of a number. | \`Math.abs(-5) // 5\` |
+| **Math** | \`.floor(n)\` | Returns the largest integer less than or equal to a number. | \`Math.floor(5.9) // 5\` |
+| **Math** | \`.ceil(n)\` | Returns the smallest integer greater than or equal to a number. | \`Math.ceil(5.1) // 6\` |
+| **Math** | \`.round(n)\` | Returns the value of a number rounded to the nearest integer. | \`Math.round(5.5) // 6\` |
+| **Math** | \`.max(a,b,..)\`| Returns the largest of the given numbers. | \`Math.max(1,5,2) // 5\` |
+| **Math** | \`.min(a,b,..)\`| Returns the smallest of the given numbers. | \`Math.min(1,5,2) // 1\` |
+| **Math** | \`.pow(b,e)\` | Returns base to the exponent power. | \`Math.pow(2,3) // 8\` |
+| **Math** | \`.sqrt(n)\` | Returns the square root of a number. | \`Math.sqrt(9) // 3\` |
+| **Math** | \`.rand()\` | Returns a pseudo-random number between 0 and 1. | \`Math.rand() // e.g., 0.123...\` |
 
 
 ---
@@ -455,3 +485,4 @@ This ensures zero learning curve for existing JS functionality and guarantees fu
     </script>
 </body>
 </html>
+
