kadence-lang 0.2.0 → 0.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/kadence-lang.svg?style=flat-square)](https://www.npmjs.com/package/kadence-lang)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![Build Status](https://img.shields.io/badge/build-passing-brightgreen?style=flat-square)](https://github.com/kadence-lang/kadence-lang)
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen?style=flat-square)](https://github.com/Down2EarthGG/Kadence-lang)
 
 **A human-readable programming language that feels like poetry.**
 
@@ -135,22 +135,32 @@ Kadence ships with a comprehensive set of modules for common tasks.
 
 | Module | Core Functionality |
 | :--- | :--- |
-| `list` | `first`, `lastOf`, `shuffle`, `range`, `unique` |
-| `string` | `trimmed`, `repeated`, `toCamelCase`, `padStart`, `words` |
-| `math` | `clamp`, `randomFloat`, `toRadians`, `hypotenuse` |
-| `datetime` | `the time now`, `the date today`, `diffDays`, `toIso` |
-| `file` | `readFile`, `writeFile`, `copyDir`, `removeDir`, `stat` |
+| `array` | `flatten`, `zip`, `chunk`, `partition`, `take`, `drop`, `reverse`, `findIndex` |
+| `async` | `delay`, `timeout`, `retry`, `debounce`, `throttle`, `parallel`, `sequential`, `waterfall` |
+| `list` | `first`, `lastOf`, `shuffle`, `makeRange`, `unique`, `sort`, `sortBy` |
+| `string` | `trimmed`, `repeated`, `toCamelCase`, `padStart`, `words`, `lines`, `capitalized` |
+| `map` | `keys`, `values`, `entries`, `merge`, `pick`, `omit`, `mapValues`, `deepClone`, `fromPairs` |
+| `set` | `union`, `intersection`, `difference`, `isSubset`, `isSuperset`, `cartesianProduct` |
+| `format` | `currency`, `fileSize`, `ordinal`, `plural`, `titleCase`, `snakeCase`, `kebabCase` |
+| `validation` | `isEmail`, `isUrl`, `isNumeric`, `isAlpha`, `isInRange`, `isHexColor`, `isCreditCard` |
+| `math` | `clamp`, `randomFloat`, `hypotenuse`, `areaOfCircle`, `isEven`, `toRadians` |
+| `datetime` | `currentTime`, `today`, `year`, `month`, `day`, `toIso`, `addDays` |
+| `file` | `readFile`, `writeFile`, `copyDir`, `removeDir`, `stat`, `listDir`, `exists` |
 | `path` | `joinPaths`, `resolve`, `basename`, `dirname`, `extension` |
-| `env` | `getEnv`, `hasEnv` (Environment Variables) |
+| `env` | `getEnv`, `hasEnv` |
 | `process` | `args`, `exit`, `cwd` |
-| `system` | `platform`, `arch`, `totalMemory`, `freeMemory` |
-| `network` | `serve`, `fetchJson` (Simple HTTP Server) |
+| `system` | `platform`, `arch`, `totalMemory`, `freeMemory`, `cpus`, `homedir` |
+| `network` | `serve`, `fetchJson` |
 | `json` | `readJson`, `writeJson`, `format`, `parseSafe` |
-| `check` | `isNumber`, `isString`, `isEmail`, `between` |
+| `check` | `isNumber`, `isString`, `isEmail`, `between`, `coalesce` |
 | `test` | `suite`, `assertEquals`, `assertTrue`, `assertThrows` |
-| `color` | `randomHex`, `rgbToHex`, `hexToRgb` |
-| `html` | `div`, `span`, `p`, `img`, `link` (Browser only) |
-| `crypto` | `hash`, `randomBytes`, `uuid` |
+| `color` | `rgb`, `rgba`, `hex`, `randomHex` |
+| `html` | `tag`, `div`, `span`, `p`, `img`, `link`, `h1` |
+| `crypto` | `hash`, `randomBytes` |
+| `uuid` | `v4`, `validate` |
+| `random` | `float`, `integer`, `choice`, `shuffle` |
+| `stream` | `createReader`, `readAll`, `pipe` |
+| `url` | `parseUrl`, `buildUrl`, `getSearchParam` |
 
 *Usage Example:*
 ```kadence

package/icon.svg

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="utf-8"?>
+<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <!-- Premium Dark Gradient Background -->
+    <linearGradient id="bgGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#1a1a2e;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#16213e;stop-opacity:1" />
+    </linearGradient>
+    
+    <!-- Vibrant Accent Gradient (vertical) -->
+    <linearGradient id="accentGradient" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" style="stop-color:#06d6a0;stop-opacity:1" />
+      <stop offset="50%" style="stop-color:#118ab2;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#7b2cbf;stop-opacity:1" />
+    </linearGradient>
+    
+    <!-- Outer Glow Effect -->
+    <filter id="glow" x="-50%" y="-50%" width="200%" height="200%">
+      <feGaussianBlur stdDeviation="6" result="coloredBlur"/>
+      <feMerge>
+        <feMergeNode in="coloredBlur"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    
+    <!-- Subtle Drop Shadow -->
+    <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
+      <feDropShadow dx="0" dy="4" stdDeviation="10" flood-color="#000000" flood-opacity="0.3"/>
+    </filter>
+  </defs>
+
+  <!-- Background Container with Rounded Corners -->
+  <rect x="24" y="24" width="464" height="464" rx="96" fill="url(#bgGradient)" filter="url(#shadow)"/>
+  
+  <!-- Subtle Border Ring -->
+  <rect x="24" y="24" width="464" height="464" rx="96" fill="none" stroke="url(#accentGradient)" stroke-width="3" opacity="0.4"/>
+
+  <!-- Rebuilt, unified Kadence "K" -->
+  <g filter="url(#glow)">
+    <!-- Single sculpted K shape using negative space logic -->
+    <path
+      d="
+        M 120 116
+        L 160 116
+        L 160 220
+        L 230 160
+        Q 244 148 262 148
+        L 292 148
+        L 292 188
+        Q 276 188 266 196
+        L 200 252
+        L 270 320
+        Q 284 334 304 334
+        L 332 334
+        L 332 374
+        L 296 374
+        Q 270 374 252 356
+        L 180 286
+        L 160 304
+        L 160 396
+        L 120 396
+        Z
+      "
+      fill="url(#accentGradient)"
+    />
+
+    <!-- Accent rhythm bars to the right -->
+    <rect x="320" y="196" width="24" height="120" rx="12" fill="#06d6a0" opacity="0.9"/>
+    <rect x="360" y="161" width="24" height="190" rx="12" fill="#118ab2" opacity="0.85"/>
+    <rect x="400" y="216" width="24" height="80" rx="12" fill="#7b2cbf" opacity="0.8"/>
+  </g>
+  
+  <!-- Small accent dots for visual interest -->
+  <circle cx="420" cy="100" r="8" fill="#06d6a0" opacity="0.6"/>
+  <circle cx="100" cy="420" r="6" fill="#7b2cbf" opacity="0.5"/>
+</svg>

package/package.json

@@ -1,25 +1,27 @@
 {
   "name": "kadence-lang",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A human-readable programming language that feels like poetry",
+  "icon": "icon.svg",
   "main": "src/compiler.js",
   "bin": {
     "kadence": "./bin/kadence.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kadence-lang/kadence-lang.git"
+    "url": "git+https://github.com/Down2EarthGG/Kadence-lang.git"
   },
   "bugs": {
-    "url": "https://github.com/kadence-lang/kadence-lang/issues"
+    "url": "https://github.com/Down2EarthGG/Kadence-lang/issues"
   },
-  "homepage": "https://github.com/kadence-lang/kadence-lang#readme",
+  "homepage": "https://github.com/Down2EarthGG/Kadence-lang#readme",
   "files": [
     "src/",
     "bin/",
     "stdlib/",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "icon.svg"
   ],
   "engines": {
     "node": ">=14.0.0"

package/stdlib/REVIEW_NEW_LIBS.md

@@ -0,0 +1,92 @@
+# Review: New stdlib Libraries
+
+Summary of the new/untracked stdlib modules and fixes applied.
+
+---
+
+## 1. **array.kade** ✓
+
+Pure Kadence array utilities: `flatten`, `zip`, `chunk`, `partition`, `take`, `drop`, `reverse`, `findIndex`.
+
+- **Style**: Uses `list`, `add … to result`, `size of`, `increment`/`decrement` consistently.
+- **Note**: `flatten` treats any `elem` with `typeof "object"` and `elem.length` as nested array; that matches array-like values. Consider documenting that only one level of “array-like” is assumed if you want to avoid surprises with non-Array objects.
+
+---
+
+## 2. **async.kade** + **async-helpers.js** ✓
+
+Kadence wrapper over JS helpers: `delay`, `timeout`, `retry`, `debounce`, `throttle`, `parallel`, `race`, `sequential`, `waterfall`, `batch`.
+
+- **Pattern**: Same as other `.kade` + `-helpers.js` pairs: Kadence exports call `run require "./async-helpers.js"` and `run mod.<name> …`.
+- **async-helpers.js**: Clear, no extra dependencies; `batch` expects `processFn(batchItems)` to return an array of results.
+- **async.js**: Generated output; contains leftover `__kadence_*` and `fs` at the top. Prefer regenerating from `async.kade` or trimming the stub so only the actual exports remain.
+
+---
+
+## 3. **format.kade** + **format-helpers.js** ✓ (ordinal fixed)
+
+Formatting: `currency`, `formatNumber`, `percentage`, `fileSize`, `ordinal`, `plural`, `truncate`, `ellipsis`, `padNumber`, `phoneNumber`, `titleCase`, `snakeCase`, `kebabCase`.
+
+- **ordinal**: Logic was wrong for both remainder and 11/12/13. Updated to use `floor` for integer-like behavior and to treat 11–13 correctly (e.g. 11th, 12th, 13th, 21st, 22nd).
+- **format-helpers.js**: Only `currency` and `phoneNumber`; used via `require`. Fine as-is.
+- **titleCase**: Uses `split`/`join`/`uppercase`/`lowercase`; consistent with language reference.
+
+---
+
+## 4. **map.kade** + **map.js** + **object-helpers.js** ✓
+
+Map/object utilities: `keys`, `values`, `entries`, `hasKey`, `merge`, `pick`, `omit`, `mapValues`, `mapKeys`, `invert`, `isEmpty`, `fromPairs`.
+
+- **map.kade**: Delegates to `object-helpers.js` for everything except `isEmpty` (uses `Object.keys`) and `fromPairs` (inline loop). Good split.
+- **object-helpers.js**: Provides `pick`, `omit`, `deepClone`, `get`, `defaults`, plus key/values/entries/hasKey/merge/mapValues/mapKeys/invert. `map.kade` does not yet expose `deepClone`, `get`, or `defaults`; add wrappers in `map.kade` if you want them in the public API.
+- **fromPairs**: Uses `let result = {}` and `result[pair[0]] = pair[1]`. For consistency with LANGUAGE_REFERENCE (“Object: object { key: val }”), you could use `object {}` and `set … of result to …` if the compiler supports empty `object {}` and property set.
+
+---
+
+## 5. **set.kade** ✓
+
+Set operations on lists (no native Set): `union`, `intersection`, `difference`, `symmetricDifference`, `isSubset`, `isSuperset`, `areDisjoint`, `cartesianProduct`.
+
+- **Style**: Pure Kadence, no JS helpers; uses nested `for each` and equality. Readable.
+- **Cost**: O(n²) in many places (e.g. membership via linear search). Acceptable for small sets; for large sets consider a JS helper backed by `Set` and call it from a thin `.kade` wrapper (like async/format).
+
+---
+
+## 6. **validation.kade** ✓ (comparisons fixed)
+
+Validators: `isEmail`, `isUrl`, `isNumeric`, `isAlpha`, `isAlphanumeric`, `isInteger`, `isPositive`, `isNegative`, `isInRange`, `isLength`, `isEmpty`/`isNotEmpty`, `isHexColor`, `isIpAddress`, `isPhoneNumber`, `isCreditCard` (Luhn), `isStrongPassword`.
+
+- **Comparisons**: The compiler only supports `at least` / `at most` for ≥/≤ (see `CompareOp` in grammar). Replaced “more than or equals” / “less than or equals” with “at least” / “at most” in `isInRange`, `isLength`, `isPhoneNumber`, and the Luhn loop.
+- **Name clash**: Resolved by renaming string “blank” check from `isEmpty` to `isBlank`; `isNotEmpty` now calls `isBlank`.
+- **Luhn**: Logic for `isCreditCard` is correct; `(sum / 10) * 10 equals sum` is a valid way to express “sum divisible by 10” without a mod operator.
+
+---
+
+## 7. **object-helpers.js** (modified)
+
+Shared implementation for object/map operations. Used by **map.kade**; no issues found. Exports are consistent with what **map.kade** calls.
+
+---
+
+## 8. **.object.kade.js**
+
+Appears to be compiled output (e.g. from a file like `object.kade`). Typically such files are generated; consider adding them to `.gitignore` or generating them in a build step so they aren’t committed as source.
+
+---
+
+## Summary of changes made
+
+| File             | Change                                                                 |
+|------------------|------------------------------------------------------------------------|
+| **validation.kade** | Replaced “more than or equals” / “less than or equals” with “at least” / “at most” in four places so the code parses and runs. |
+| **format.kade**     | Reworked `ordinal` to use `floor` for tens/remainder and to handle 11–13 correctly (e.g. 11th, 21st). |
+
+---
+
+## Recommendations (implemented)
+
+1. **Consistency**: Use “at least” / “at most” everywhere; **validation.kade** and **test-reverse.kade** were updated.
+2. **validation.kade** `isEmpty`: Renamed to `isBlank`; `isNotEmpty` now calls `isBlank`.
+3. **map.kade**: Exposes `deepClone`, `get`, and `defaults` from **object-helpers.js**; **map.js** updated to match.
+4. **async.js / map.js**: Removed `__kadence_*` and `fs` stubs so the emitted JS is minimal.
+5. **.object.kade.js**: Added `stdlib/.object.kade.js` to **.gitignore** so generated output is not committed.

package/stdlib/array.js

@@ -0,0 +1,165 @@
+const fs = require("fs"); 
+
+function __kadence_echo(val) {
+    const s = String(val);
+    const low = s.toLowerCase();
+    if (typeof process !== 'undefined' && process.stdout && process.stdout.isTTY) {
+        if (low.includes('error')) console.log("\x1b[31m" + s + "\x1b[0m");
+        else if (low.includes('warning')) console.log("\x1b[33m" + s + "\x1b[0m");
+        else if (low.includes('success')) console.log("\x1b[32m" + s + "\x1b[0m");
+        else console.log(s);
+    } else {
+        console.log(s);
+    }
+}
+function __kadence_min(val) {
+    if (Array.isArray(val)) return Math.min(...val);
+    return val;
+}
+function __kadence_max(val) {
+    if (Array.isArray(val)) return Math.max(...val);
+    return val;
+}
+function __kadence_add(parent, child) {
+    if (Array.isArray(parent)) {
+        parent.push(child);
+        return parent;
+    }
+    if (typeof parent === 'object' && parent !== null && typeof parent.appendChild === 'function') {
+        parent.appendChild(child);
+        return parent;
+    }
+    throw new Error("Runtime Error: Cannot add item to " + typeof parent);
+}
+ 
+function flatten (nestedArray) { 
+  let result = []; 
+  for (let elem of nestedArray) { 
+  if (typeof elem === `object`  && elem.length ) { 
+  let flattened = flatten(elem); 
+  for (let subItem of flattened) { 
+  __kadence_add(result, subItem); 
+ }  
+ }   else { 
+  __kadence_add(result, elem); 
+ }   
+ } 
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.flatten = flatten;
+function zip (array1, array2) { 
+  let result = []; 
+  let len1 = array1.length; 
+  let len2 = array2.length; 
+  let minLen = 0; 
+  if (len1 < len2 ) { 
+  minLen = len1; 
+ }   else { 
+  minLen = len2; 
+ }  
+  let i = 0; 
+  while (i < minLen ) { 
+  let pair = []; 
+  __kadence_add(pair, array1[i]);
+  __kadence_add(pair, array2[i]);
+  __kadence_add(result, pair);
+  i++; 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.zip = zip;
+function chunk (array, chunkSize) { 
+  let result = []; 
+  let i = 0; 
+  let len = array.length; 
+  while (i < len ) { 
+  let currentChunk = []; 
+  let j = 0; 
+  while (j < chunkSize  && (i + j ) < len  ) { 
+  __kadence_add(currentChunk, array[i + j ]);
+  j++; 
+ }  
+  __kadence_add(result, currentChunk);
+  i = i + chunkSize ; 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.chunk = chunk;
+function partition (array, predicate) { 
+  let truthy = []; 
+  let falsy = []; 
+  for (let elem of array) { 
+  if (predicate(elem)) { 
+  __kadence_add(truthy, elem); 
+ }   else { 
+  __kadence_add(falsy, elem); 
+ }   
+ } 
+  let output = []; 
+  __kadence_add(output, truthy);
+  __kadence_add(output, falsy);
+  return output; 
+ }
+if (typeof exports !== 'undefined') exports.partition = partition;
+function take (array, count) { 
+  let result = []; 
+  let len = array.length; 
+  let actualCount = 0; 
+  if (count < len ) { 
+  actualCount = count; 
+ }   else { 
+  actualCount = len; 
+ }  
+  let i = 0; 
+  while (i < actualCount ) { 
+  __kadence_add(result, array[i]);
+  i++; 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.take = take;
+function drop (array, count) { 
+  let result = []; 
+  let len = array.length; 
+  let i = count; 
+  while (i < len ) { 
+  __kadence_add(result, array[i]);
+  i++; 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.drop = drop;
+function reverse (array) { 
+  let result = []; 
+  let i = (array.length) - 1 ; 
+  while (i >= 0 ) { 
+  __kadence_add(result, array[i]);
+  i--; 
+ }  
+  return result; 
+ }
+if (typeof exports !== 'undefined') exports.reverse = reverse;
+function findIndex (array, predicate) { 
+  let i = 0; 
+  let len = array.length; 
+  while (i < len ) { 
+  let elem = array[i]; 
+  if (predicate(elem)) { 
+  return i; 
+ }  
+  i++; 
+ }  
+  return 0 - 1 ; 
+ }
+if (typeof exports !== 'undefined') exports.findIndex = findIndex;
+function findFirst (array, predicate) { 
+  let idx = findIndex(array, predicate); 
+  if (idx >= 0 ) { 
+  return array[idx]; 
+ }  
+  return undefined; 
+ }
+if (typeof exports !== 'undefined') exports.findFirst = findFirst; 
+(async () => { 
+ 
+ })().catch(err => { if (err) console.error("\x1b[31mRuntime Error:\x1b[0m", err.stack || err.message); }); 

package/stdlib/array.kade

@@ -0,0 +1,137 @@
+note: Advanced array utilities for Kadence
+
+export function flatten nestedArray
+    let result = list
+    for each elem in nestedArray
+        if typeof elem equals "object" and elem.length
+            let flattened = run flatten elem
+            for each subItem in flattened
+                add subItem to result
+            end
+        else
+            add elem to result
+        end
+    end
+    return result
+end
+
+export function zip array1 array2
+    let result = list
+    let len1 = size of array1
+    let len2 = size of array2
+    let minLen = 0
+    if len1 less than len2
+        set minLen to len1
+    else
+        set minLen to len2
+    end
+    
+    let i = 0
+    while i less than minLen
+        let pair = list
+        add array1[i] to pair
+        add array2[i] to pair
+        add pair to result
+        increment i
+    end
+    return result
+end
+
+export function chunk array chunkSize
+    let result = list
+    let i = 0
+    let len = size of array
+    
+    while i less than len
+        let currentChunk = list
+        let j = 0
+        while j less than chunkSize and (i plus j) less than len
+            add array[i plus j] to currentChunk
+            increment j
+        end
+        add currentChunk to result
+        set i to i plus chunkSize
+    end
+    return result
+end
+
+export function partition array predicate
+    let truthy = list
+    let falsy = list
+    
+    for each elem in array
+        if run predicate elem
+            add elem to truthy
+        else
+            add elem to falsy
+        end
+    end
+    
+    let output = list
+    add truthy to output
+    add falsy to output
+    return output
+end
+
+export function take array count
+    let result = list
+    let len = size of array
+    let actualCount = 0
+    if count less than len
+        set actualCount to count
+    else
+        set actualCount to len
+    end
+    
+    let i = 0
+    while i less than actualCount
+        add array[i] to result
+        increment i
+    end
+    return result
+end
+
+export function drop array count
+    let result = list
+    let len = size of array
+    let i = count
+    
+    while i less than len
+        add array[i] to result
+        increment i
+    end
+    return result
+end
+
+export function reverse array
+    let result = list
+    let i = (size of array) minus 1
+    
+    while i at least 0
+        add array[i] to result
+        decrement i
+    end
+    return result
+end
+
+export function findIndex array predicate
+    let i = 0
+    let len = size of array
+    
+    while i less than len
+        let elem = array[i]
+        if run predicate elem
+            return i
+        end
+        increment i
+    end
+    return 0 minus 1
+end
+
+export function findFirst array predicate
+    let idx = run findIndex array predicate
+    if idx at least 0
+        return array[idx]
+    end
+    return undefined
+end

package/stdlib/async-helpers.js

@@ -0,0 +1,115 @@
+"use strict";
+
+function delay(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+}
+
+function timeout(promise, milliseconds) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error("Operation timed out"));
+        }, milliseconds);
+    });
+
+    return Promise.race([promise, timeoutPromise]);
+}
+
+async function retry(fn, maxAttempts, delayMs) {
+    let attempt = 0;
+
+    while (attempt < maxAttempts) {
+        try {
+            const result = await fn();
+            return result;
+        } catch (error) {
+            attempt++;
+            if (attempt < maxAttempts) {
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            } else {
+                throw error;
+            }
+        }
+    }
+}
+
+function debounce(fn, delayMs) {
+    let timeoutId = null;
+
+    return function (...args) {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+
+        timeoutId = setTimeout(() => {
+            fn(...args);
+        }, delayMs);
+    };
+}
+
+function throttle(fn, delayMs) {
+    let lastRun = 0;
+
+    return function (...args) {
+        const now = Date.now();
+
+        if (now - lastRun >= delayMs) {
+            fn(...args);
+            lastRun = now;
+        }
+    };
+}
+
+async function sequential(tasks) {
+    const results = [];
+
+    for (const task of tasks) {
+        const result = await task();
+        results.push(result);
+    }
+
+    return results;
+}
+
+async function waterfall(tasks, initialValue) {
+    let value = initialValue;
+
+    for (const task of tasks) {
+        value = await task(value);
+    }
+
+    return value;
+}
+
+async function batch(items, batchSize, processFn) {
+    const results = [];
+    let i = 0;
+    const len = items.length;
+
+    while (i < len) {
+        const batchItems = [];
+        let j = 0;
+
+        while (j < batchSize && (i + j) < len) {
+            batchItems.push(items[i + j]);
+            j++;
+        }
+
+        const batchResults = await processFn(batchItems);
+        for (const result of batchResults) {
+            results.push(result);
+        }
+
+        i += batchSize;
+    }
+
+    return results;
+}
+
+if (typeof module !== "undefined" && module.exports) {
+    module.exports = {
+        delay, timeout, retry, debounce, throttle,
+        sequential, waterfall, batch
+    };
+}