kimchilang 1.0.1

package/stdlib/object.km

@@ -0,0 +1,41 @@
+// KimchiLang Standard Library - Object Functions
+
+expose fn _describe() {
+  return "Object utilities: keys, values, entries, merge, etc."
+}
+
+expose fn keys(obj) {
+  return Object.keys(obj)
+}
+
+expose fn values(obj) {
+  return Object.values(obj)
+}
+
+expose fn entries(obj) {
+  return Object.entries(obj)
+}
+
+expose fn fromEntries(arr) {
+  return Object.fromEntries(arr)
+}
+
+expose fn has(obj, key) {
+  return Object.hasOwn(obj, key)
+}
+
+expose fn freeze(obj) {
+  return Object.freeze(obj)
+}
+
+expose fn isEmpty(obj) {
+  return Object.keys(obj).length == 0
+}
+
+expose fn size(obj) {
+  return Object.keys(obj).length
+}
+
+expose fn assign(target, source) {
+  return Object.assign(target, source)
+}

package/stdlib/promise.km

@@ -0,0 +1,33 @@
+// KimchiLang Standard Library - Promise Functions
+
+expose fn _describe() {
+  return "Promise/async utilities: all, race, resolve, reject, delay"
+}
+
+expose fn resolve(value) {
+  return Promise.resolve(value)
+}
+
+expose fn reject(reason) {
+  return Promise.reject(reason)
+}
+
+expose fn all(promises) {
+  return Promise.all(promises)
+}
+
+expose fn allSettled(promises) {
+  return Promise.allSettled(promises)
+}
+
+expose fn race(promises) {
+  return Promise.race(promises)
+}
+
+expose fn any(promises) {
+  return Promise.any(promises)
+}
+
+expose fn delay(ms) {
+  return new Promise((res) => setTimeout(res, ms))
+}

package/stdlib/string.km

@@ -0,0 +1,93 @@
+// KimchiLang Standard Library - String Functions
+
+expose fn _describe() {
+  return "String utilities: split, trim, replace, case conversion, etc."
+}
+
+expose fn split(str, separator) {
+  return str.split(separator)
+}
+
+expose fn trim(str) {
+  return str.trim()
+}
+
+expose fn trimStart(str) {
+  return str.trimStart()
+}
+
+expose fn trimEnd(str) {
+  return str.trimEnd()
+}
+
+expose fn toUpperCase(str) {
+  return str.toUpperCase()
+}
+
+expose fn toLowerCase(str) {
+  return str.toLowerCase()
+}
+
+expose fn startsWith(str, prefix) {
+  return str.startsWith(prefix)
+}
+
+expose fn endsWith(str, suffix) {
+  return str.endsWith(suffix)
+}
+
+expose fn includes(str, substring) {
+  return str.includes(substring)
+}
+
+expose fn indexOf(str, substring) {
+  return str.indexOf(substring)
+}
+
+expose fn replace(str, search, replacement) {
+  return str.replace(search, replacement)
+}
+
+expose fn replaceAll(str, search, replacement) {
+  return str.replaceAll(search, replacement)
+}
+
+expose fn slice(str, start, end) {
+  return str.slice(start, end)
+}
+
+expose fn charAt(str, index) {
+  return str.charAt(index)
+}
+
+expose fn padStart(str, length, padStr) {
+  return str.padStart(length, padStr)
+}
+
+expose fn padEnd(str, length, padStr) {
+  return str.padEnd(length, padStr)
+}
+
+expose fn repeat(str, count) {
+  return str.repeat(count)
+}
+
+expose fn length(str) {
+  return str.length
+}
+
+expose fn isEmpty(str) {
+  return str.length == 0
+}
+
+expose fn isBlank(str) {
+  return str.trim().length == 0
+}
+
+expose fn toChars(str) {
+  return str.split("")
+}
+
+expose fn toLines(str) {
+  return str.split("\n")
+}

package/stdlib/testing.md

@@ -0,0 +1,265 @@
+# KimchiLang Testing Framework
+
+KimchiLang has a built-in testing framework that makes it easy to write and run tests without any external dependencies.
+
+## Running Tests
+
+```bash
+kimchi test myfile.km
+```
+
+## Syntax
+
+### `test`
+
+Define a single test case:
+
+```kimchi
+test "test name" {
+  // test code here
+}
+```
+
+### `describe`
+
+Group related tests together:
+
+```kimchi
+describe "Group name" {
+  test "first test" {
+    // ...
+  }
+  
+  test "second test" {
+    // ...
+  }
+}
+```
+
+Describe blocks can be nested:
+
+```kimchi
+describe "Math operations" {
+  describe "Addition" {
+    test "adds positive numbers" {
+      expect(1 + 2).toBe(3)
+    }
+  }
+  
+  describe "Subtraction" {
+    test "subtracts numbers" {
+      expect(5 - 3).toBe(2)
+    }
+  }
+}
+```
+
+### `expect`
+
+Make assertions about values:
+
+```kimchi
+expect(actual).matcher(expected)
+```
+
+### `assert`
+
+Simple assertion with optional message:
+
+```kimchi
+assert condition, "Error message if condition is false"
+assert 1 + 1 == 2
+```
+
+## Matchers
+
+### `toBe(expected)`
+
+Strict equality check (`===`):
+
+```kimchi
+expect(5).toBe(5)
+expect("hello").toBe("hello")
+```
+
+### `toEqual(expected)`
+
+Deep equality check (compares objects/arrays by value):
+
+```kimchi
+expect({ a: 1 }).toEqual({ a: 1 })
+expect([1, 2, 3]).toEqual([1, 2, 3])
+```
+
+### `toContain(item)`
+
+Check if array or string contains an item:
+
+```kimchi
+expect([1, 2, 3]).toContain(2)
+expect("hello world").toContain("world")
+```
+
+### `toBeNull()`
+
+Check if value is null:
+
+```kimchi
+expect(null).toBeNull()
+```
+
+### `toBeTruthy()`
+
+Check if value is truthy:
+
+```kimchi
+expect(true).toBeTruthy()
+expect("hello").toBeTruthy()
+expect(1).toBeTruthy()
+```
+
+### `toBeFalsy()`
+
+Check if value is falsy:
+
+```kimchi
+expect(false).toBeFalsy()
+expect(null).toBeFalsy()
+expect(0).toBeFalsy()
+expect("").toBeFalsy()
+```
+
+### `toBeGreaterThan(n)`
+
+Check if value is greater than n:
+
+```kimchi
+expect(10).toBeGreaterThan(5)
+```
+
+### `toBeLessThan(n)`
+
+Check if value is less than n:
+
+```kimchi
+expect(3).toBeLessThan(7)
+```
+
+### `toHaveLength(n)`
+
+Check array or string length:
+
+```kimchi
+expect([1, 2, 3]).toHaveLength(3)
+expect("hello").toHaveLength(5)
+```
+
+### `toMatch(pattern)`
+
+Check if string matches a regex pattern:
+
+```kimchi
+expect("hello@example.com").toMatch(/\w+@\w+\.\w+/)
+```
+
+### `toThrow(message?)`
+
+Check if a function throws an error:
+
+```kimchi
+dec throwingFn = () => {
+  throw error("Something went wrong")
+}
+expect(throwingFn).toThrow()
+expect(throwingFn).toThrow("Something went wrong")
+```
+
+## Complete Example
+
+```kimchi
+// math.test.km
+
+fn add(a, b) {
+  return a + b
+}
+
+fn divide(a, b) {
+  if b == 0 {
+    throw error("Cannot divide by zero")
+  }
+  return a / b
+}
+
+describe "Math functions" {
+  describe "add" {
+    test "adds two positive numbers" {
+      expect(add(2, 3)).toBe(5)
+    }
+    
+    test "adds negative numbers" {
+      expect(add(-1, -2)).toBe(-3)
+    }
+    
+    test "adds zero" {
+      expect(add(5, 0)).toBe(5)
+    }
+  }
+  
+  describe "divide" {
+    test "divides two numbers" {
+      expect(divide(10, 2)).toBe(5)
+    }
+    
+    test "throws on division by zero" {
+      expect(() => divide(10, 0)).toThrow("Cannot divide by zero")
+    }
+  }
+}
+
+// Using assert for simple checks
+test "basic assertions" {
+  assert 1 + 1 == 2, "Basic math should work"
+  assert true
+}
+```
+
+Run with:
+
+```bash
+kimchi test math.test.km
+```
+
+Output:
+
+```
+Math functions
+  add
+    ✓ adds two positive numbers
+    ✓ adds negative numbers
+    ✓ adds zero
+  divide
+    ✓ divides two numbers
+    ✓ throws on division by zero
+✓ basic assertions
+
+6 tests, 6 passed, 0 failed
+```
+
+## Async Tests
+
+Tests automatically support async operations:
+
+```kimchi
+test "async operation" {
+  dec result = await fetchData()
+  expect(result.status).toBe(200)
+}
+```
+
+## Best Practices
+
+1. **One assertion per test** - Keep tests focused on a single behavior
+2. **Descriptive names** - Use clear, descriptive test names
+3. **Group related tests** - Use `describe` blocks to organize tests
+4. **Test edge cases** - Include tests for error conditions and boundary values
+5. **Keep tests independent** - Each test should be able to run in isolation