refactor(packages/stdlib): refactor template function, fresh collections get function

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/CODEOWNERS

@@ -0,0 +1 @@
+*  @robonen

.github/workflows/ci.yaml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  - pull_request
+
+env:
+  NODE_VERSION: 22.x
+
+jobs:
+  code-quality:
+    name: Code quality checks
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          run_install: false
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Test
+        run: pnpm all:build && pnpm all:test

.gitignore

@@ -17,6 +17,7 @@ node_modules
 .nuxt
 .nitro
 .cache
+cache
 out
 build
 dist

README.md

@@ -0,0 +1,3 @@
+<div>
+    <img src="https://bage.robonen.ru/github?profile=robonen&project=tools&description=My%20most%20frequently%20used%20web%20tools">
+</div>

apps/vhs/.gitignore

@@ -0,0 +1,2 @@
+bin/**
+!bin/.gitkeep

apps/vhs/README.md

@@ -0,0 +1 @@
+# @robonen/vhs

apps/vhs/jsr.json

@@ -0,0 +1,5 @@
+{
+  "name": "@robonen/vhs",
+  "version": "0.0.0",
+  "exports": "./src/index.ts"
+}

apps/vhs/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@robonen/vhs",
+  "private": true,
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "description": "",
+  "keywords": [],
+  "author": "Robonen Andrew <robonenandrew@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robonen/tools.git",
+    "directory": "./apps/vhs"
+  },
+  "packageManager": "pnpm@9.15.4",
+  "engines": {
+    "bun": ">=1.1.27"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "bun run src/index.ts"
+  },
+  "devDependencies": {
+    "@robonen/tsconfig": "workspace:*",
+    "@types/bun": "^1.1.17"
+  }
+}

apps/vhs/src/index.ts

@@ -0,0 +1,36 @@
+import { version } from '../package.json';
+import { resolve } from 'path';
+import { $, Glob } from 'bun';
+
+async function ffmpegMergeAndTranscodeAvi(files: Set<string>) {
+  const ffmpeg = resolve('bin/ffmpeg');
+  const output = resolve('output.mp4');
+  const input = Array.from(files).toSorted((a, b) => a.localeCompare(b)).join('|');
+
+  const shell = $`${ffmpeg} -i "concat:${input}" -stats -c:v libx264 -crf 23 -preset veryfast -c:a aac ${output}`;
+
+  for await (const line of shell.lines()) {
+    console.log(line);
+  }
+}
+
+const path = Bun.argv[2];
+
+if (!path) {
+  console.error('Please provide a path to a file or directory');
+  process.exit(1);
+}
+
+console.info(`Welcome to VHS v${version} 📼`);
+console.info(`Scanning ${path}...`);
+
+const glob = new Glob(resolve(path));
+const files = new Set<string>();
+
+for await (const file of glob.scan({ followSymlinks: false })) {
+  files.add(file);
+}
+
+console.info(`Found ${files.size} files`);
+
+console.info(await ffmpegMergeAndTranscodeAvi(files));

apps/vhs/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@robonen/tsconfig/tsconfig.json"
+}

cli.ts

@@ -3,10 +3,10 @@ import { defineCommand, runMain } from 'citty';
 import { resolve } from 'pathe';
 import { splitByCase } from 'scule';
 
-const PACKAGE_MANAGER = 'pnpm@8.15.6';
+const PACKAGE_MANAGER = 'pnpm@9.11.0';
-const NODE_VERSION = '>=18.0.0';
+const NODE_VERSION = '>=20.17.0';
-const VITE_VERSION = '^5.2.8';
+const VITE_VERSION = '^5.4.8';
-const VITE_DTS_VERSION = '^3.8.1';
+const VITE_DTS_VERSION = '^4.2.2';
 const PATHE_VERSION = '^1.1.2'
 const DEFAULT_DIR = 'packages';
 
@@ -14,7 +14,7 @@ const generatePackageJson = (name: string, path: string, hasVite: boolean) => {
     const data = {
         name,
         private: true,
-        version: '1.0.0',
+        version: '0.0.0',
         license: 'UNLICENSED',
         description: '',
         keywords: [],
@@ -61,6 +61,16 @@ const generatePackageJson = (name: string, path: string, hasVite: boolean) => {
     return JSON.stringify(data, null, 2);
 };
 
+const generateJsrJson = (name: string) => {
+    const data = {
+        name,
+        version: '0.0.0',
+        exports: './src/index.ts',
+    };
+
+    return JSON.stringify(data, null, 2);
+};
+
 const generateViteConfig = () => `import { defineConfig } from 'vite';
 import dts from 'vite-plugin-dts';
 import { resolve } from 'pathe';
@@ -72,7 +82,10 @@ export default defineConfig({
     },
   },
   plugins: [
-    dts({ insertTypesEntry: true }),
+    dts({
+      insertTypesEntry: true,
+      exclude: '**/*.test.ts',
+    }),
   ],
 });
 `;
@@ -120,6 +133,7 @@ const createCommand = defineCommand({
         await mkdir(resolvedPath, { recursive: true });
         
         writeFile(`${resolvedPath}/package.json`, generatePackageJson(args.name, path, hasVite));
+        writeFile(`${resolvedPath}/jsr.json`, generateJsrJson(args.name));
         writeFile(`${resolvedPath}/tsconfig.json`, generateTsConfig());
         writeFile(`${resolvedPath}/README.md`, generateReadme(args.name));
 

docs/.vitepress/config.ts

@@ -2,10 +2,10 @@ import { defineConfig } from 'vitepress';
 
 export default defineConfig({
   lang: 'ru-RU',
-  title: "Tools",
+  title: "Toolkit",
-  description: "A set of tools and utilities for web development",
+  description: "A collection of typescript and javascript development tools",
   rewrites: {
-    'packages/:pkg/README.md': 'packages/:pkg/index.md'
+    'packages/:pkg/README.md': 'packages/:pkg/index.md',
   },
   themeConfig: {
     sidebar: [
@@ -13,6 +13,8 @@ export default defineConfig({
         text: 'Пакеты',
         items: [
           { text: '@robonen/tsconfig', link: '/packages/tsconfig/' },
+          { text: '@robonen/renovate', link: '/packages/renovate/' },
+          { text: '@robonen/stdlib', link: '/packages/stdlib/' },
         ],
       },
     ],

docs/index.md

@@ -0,0 +1,14 @@
+---
+# https://vitepress.dev/reference/default-theme-home-page
+layout: home
+
+hero:
+  name: Toolkit 
+  tagline: A collection of typescript and javascript development tools
+  actions:
+    - theme: brand
+      text: Get Started
+      link: /
+    - theme: alt
+      text: View on GitHub
+      link: /

package.json

@@ -15,20 +15,22 @@
     "type": "git",
     "url": "git+https://github.com/robonen/tools.git"
   },
-  "packageManager": "pnpm@8.15.6",
+  "packageManager": "pnpm@9.15.4",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.13.0"
   },
   "type": "module",
   "devDependencies": {
-    "@types/node": "^20.12.6",
+    "@types/node": "^22.10.7",
     "citty": "^0.1.6",
-    "jiti": "^1.21.0",
+    "jiti": "^2.4.2",
-    "pathe": "^1.1.2",
+    "pathe": "^2.0.2",
     "scule": "^1.3.0",
-    "vitepress": "^1.1.0"
+    "vitepress": "^1.5.0"
   },
   "scripts": {
+    "all:build": "pnpm -r build",
+    "all:test": "pnpm -r test",
     "create": "jiti ./cli.ts",
     "docs:dev": "vitepress dev .",
     "docs:build": "vitepress build .",

packages/platform/README.md

@@ -0,0 +1 @@
+# @robonen/platform

packages/platform/build.config.ts

@@ -0,0 +1,16 @@
+import { defineBuildConfig } from 'unbuild';
+
+export default defineBuildConfig({
+  entries: [
+    'src/browsers',
+    'src/multi',
+  ],
+  clean: true,
+  declaration: true,
+  rollup: {
+    emitCJS: true,
+    esbuild: {
+      // minify: true,
+    },
+  },
+});

packages/platform/jsr.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://jsr.io/schema/config-file.v1.json",
+  "name": "@robonen/platform",
+  "license": "Apache-2.0",
+  "version": "0.0.2",
+  "exports": "./src/index.ts"
+}

packages/platform/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@robonen/platform",
+  "version": "0.0.3",
+  "license": "Apache-2.0",
+  "description": "Platform dependent utilities for javascript development",
+  "keywords": [
+    "javascript",
+    "typescript",
+    "browser",
+    "platform",
+    "node",
+    "bun",
+    "deno"
+  ],
+  "author": "Robonen Andrew <robonenandrew@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robonen/tools.git",
+    "directory": "packages/platform"
+  },
+  "packageManager": "pnpm@9.15.4",
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./browsers": {
+      "import": "./dist/browsers.mjs",
+      "require": "./dist/browsers.cjs",
+      "types": "./dist/browsers.d.ts"
+    },
+    "./multi": {
+      "import": "./dist/multi.mjs",
+      "require": "./dist/multi.cjs",
+      "types": "./dist/multi.d.ts"
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "dev": "vitest dev",
+    "build": "unbuild"
+  },
+  "devDependencies": {
+    "@robonen/tsconfig": "workspace:*",
+    "jsdom": "catalog:",
+    "unbuild": "catalog:",
+    "vitest": "catalog:"
+  }
+}

packages/platform/src/browsers/focusGuard/index.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { focusGuard, createGuardAttrs } from '.';
+
+describe('focusGuard', () => {
+  beforeEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  it('initialize with the correct default namespace', () => {
+    const guard = focusGuard();
+    
+    expect(guard.selector).toBe('data-focus-guard');
+  });
+
+  it('create focus guards in the DOM', () => {
+    const guard = focusGuard();
+    guard.createGuard();
+
+    const guards = document.querySelectorAll(`[${guard.selector}]`);
+    expect(guards.length).toBe(2);
+
+    guards.forEach((element) => {
+      expect(element.tagName).toBe('SPAN');
+      expect(element.getAttribute('tabindex')).toBe('0');
+    });
+  });
+
+  it('remove focus guards from the DOM correctly', () => {
+    const guard = focusGuard();
+    guard.createGuard();
+    guard.removeGuard();
+
+    const guards = document.querySelectorAll(`[${guard.selector}]`);
+    
+    expect(guards.length).toBe(0);
+  });
+
+  it('reuse the same guards when calling createGuard multiple times', () => {
+    const guard = focusGuard();
+    guard.createGuard();
+    guard.createGuard();
+
+    guard.removeGuard();
+    const guards = document.querySelectorAll(`[${guard.selector}]`);
+
+    expect(guards.length).toBe(0);
+  });
+
+  it('allow custom namespaces', () => {
+    const namespace = 'custom-guard';
+    const guard = focusGuard(namespace);
+    guard.createGuard();
+
+    expect(guard.selector).toBe(`data-${namespace}`);
+
+    const guards = document.querySelectorAll(`[${guard.selector}]`);
+    expect(guards.length).toBe(2);
+  });
+
+  it('createGuardAttrs should create a valid guard element', () => {
+    const namespace = 'custom-guard';
+    const element = createGuardAttrs(namespace);
+
+    expect(element.tagName).toBe('SPAN');
+    expect(element.getAttribute(namespace)).toBe('');
+    expect(element.getAttribute('tabindex')).toBe('0');
+    expect(element.getAttribute('style')).toBe('outline: none; opacity: 0; pointer-events: none; position: fixed;');
+  });
+});

packages/platform/src/browsers/focusGuard/index.ts

@@ -0,0 +1,50 @@
+/**
+ * @name focusGuard
+ * @category Browsers
+ * @description Adds a pair of focus guards at the boundaries of the DOM tree to ensure consistent focus behavior
+ * 
+ * @param {string} namespace - The namespace to use for the guard attributes
+ * @returns {Object} - An object containing the selector, createGuard, and removeGuard functions
+ * 
+ * @example
+ * const guard = focusGuard();
+ * guard.createGuard();
+ * guard.removeGuard();
+ * 
+ * @example
+ * const guard = focusGuard('focus-guard');
+ * guard.createGuard();
+ * guard.removeGuard();
+ * 
+ * @since 0.0.3
+ */
+export function focusGuard(namespace: string = 'focus-guard') {
+  const guardAttr = `data-${namespace}`;
+
+  const createGuard = () => {
+    const edges = document.querySelectorAll(`[${guardAttr}]`);
+
+    document.body.insertAdjacentElement('afterbegin', edges[0] ?? createGuardAttrs(guardAttr));
+    document.body.insertAdjacentElement('beforeend', edges[1] ?? createGuardAttrs(guardAttr));
+  };
+
+  const removeGuard = () => {
+    document.querySelectorAll(`[${guardAttr}]`).forEach((element) => element.remove());
+  };
+
+  return {
+    selector: guardAttr,
+    createGuard,
+    removeGuard,
+  };
+}
+
+export function createGuardAttrs(namespace: string) {
+  const element = document.createElement('span');
+
+  element.setAttribute(namespace, '');
+  element.setAttribute('tabindex', '0');
+  element.setAttribute('style', 'outline: none; opacity: 0; pointer-events: none; position: fixed;');
+
+  return element;
+}

packages/platform/src/browsers/index.ts

@@ -0,0 +1 @@
+export * from './focusGuard';

packages/platform/src/multi/debounce/index.ts

@@ -0,0 +1,47 @@
+export interface DebounceOptions {
+    /**
+     * Call the function on the leading edge of the timeout, instead of waiting for the trailing edge
+     */
+    readonly immediate?: boolean;
+
+    /**
+     * Call the function on the trailing edge with the last used arguments.
+     * Result of call is from previous call
+     */
+    readonly trailing?: boolean;
+}
+
+const DEFAULT_DEBOUNCE_OPTIONS: DebounceOptions = {
+    trailing: true,
+}
+
+export function debounce<FnArguments extends unknown[], FnReturn>(
+    fn: (...args: FnArguments) => PromiseLike<FnReturn> | FnReturn,
+    timeout: number = 20,
+    options: DebounceOptions = {},
+) {
+    options = {
+        ...DEFAULT_DEBOUNCE_OPTIONS,
+        ...options,
+    };
+
+    if (!Number.isFinite(timeout) || timeout <= 0)
+        throw new TypeError('Debounce timeout must be a positive number');
+
+    // Last result for leading edge
+    let leadingValue: PromiseLike<FnReturn> | FnReturn;
+    
+    // Debounce timeout id
+    let timeoutId: NodeJS.Timeout;
+
+    // Promises to be resolved when debounce is finished
+    let resolveList: Array<(value: unknown) => void> = [];
+
+    // State of currently resolving promise
+    let currentResolve: Promise<FnReturn>;
+
+    // Trailing call information
+    let trailingArgs: unknown[];
+
+
+}

packages/platform/src/multi/global/index.ts

@@ -0,0 +1,28 @@
+// TODO: tests
+
+/**
+ * @name _global
+ * @category Multi
+ * @description Global object that works in any environment
+ *
+ * @since 0.0.1
+ */
+export const _global =
+  typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof window !== 'undefined'
+      ? window
+      : typeof global !== 'undefined'
+        ? global
+        : typeof self !== 'undefined'
+          ? self
+          : undefined;
+
+/**
+ * @name isClient
+ * @category Multi
+ * @description Check if the current environment is the client
+ * 
+ * @since 0.0.1
+ */
+export const isClient = typeof window !== 'undefined' && typeof document !== 'undefined';

packages/platform/src/multi/index.ts

@@ -0,0 +1,2 @@
+export * from './global';
+// export * from './debounce';

packages/platform/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "@robonen/tsconfig/tsconfig.json",
+  "compilerOptions": {
+    "lib": ["DOM"]
+  }
+}

packages/platform/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'jsdom',
+  },
+});

packages/renovate/README.md

@@ -0,0 +1 @@
+# @robonen/renovate

packages/renovate/default.json

@@ -0,0 +1,36 @@
+{
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "extends": [
+        "config:base",
+        "group:allNonMajor",
+        ":semanticCommitTypeAll(chore)"
+    ],
+    "assigneesFromCodeOwners": true,
+    "rangeStrategy": "bump",
+    "npm": {
+        "commitMessageTopic": "{{prettyDepType}} {{depName}}"
+    },
+    "packageRules": [
+        {
+            "matchUpdateTypes": [
+                "minor",
+                "patch",
+                "pin",
+                "digest"
+            ],
+            "autoApprove": true,
+            "automerge": true,
+            "automergeSchedule": [
+                "after 1am and before 2am"
+            ],
+            "schedule": [
+                "after 2am and before 3am"
+            ]
+        },
+        {
+            "enabled": false,
+            "matchPackageNames": ["php"],
+            "matchUpdateTypes": ["patch"]
+        }
+    ]
+}

packages/renovate/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@robonen/renovate",
+  "version": "0.0.1",
+  "private": true,
+  "license": "UNLICENSED",
+  "description": "Base configuration for renovate bot",
+  "keywords": [
+    "renovate",
+    "bot",
+    "configuration",
+    "tools"
+  ],
+  "author": "Robonen Andrew <robonenandrew@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/robonen/tools.git",
+    "directory": "packages/renovate"
+  },
+  "packageManager": "pnpm@9.15.4",
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "files": [
+    "default.json"
+  ],
+  "scripts": {
+    "test": "renovate-config-validator ./default.json"
+  },
+  "devDependencies": {
+    "renovate": "^39.115.2"
+  }
+}

packages/stdlib/build.config.ts

@@ -0,0 +1,9 @@
+import { defineBuildConfig } from 'unbuild';
+
+export default defineBuildConfig({
+  rollup: {
+    esbuild: {
+        // minify: true,
+    },
+  },
+});

packages/stdlib/jsr.json

@@ -0,0 +1,6 @@
+{
+    "$schema": "https://jsr.io/schema/config-file.v1.json",
+    "name": "@robonen/stdlib",
+    "version": "0.0.4",
+    "exports": "./src/index.ts"
+}

packages/stdlib/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@robonen/stdlib",
-  "version": "0.0.1",
+  "version": "0.0.4",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
-  "description": "",
+  "description": "A collection of tools, utilities, and helpers for TypeScript",
   "keywords": [
     "stdlib",
     "utils",
@@ -18,37 +18,34 @@
     "url": "git+https://github.com/robonen/tools.git",
     "directory": "packages/stdlib"
   },
-  "packageManager": "pnpm@8.15.6",
+  "packageManager": "pnpm@9.15.4",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.13.0"
   },
   "type": "module",
   "files": [
     "dist"
   ],
-  "main": "./dist/stdlib.umd.js",
+  "main": "./dist/index.cjs",
-  "module": "./dist/stdlib.js",
+  "module": "./dist/index.mjs",
-  "types": "./dist/stdlib.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/stdlib.js",
+      "import": "./dist/index.mjs",
-      "require": "./dist/stdlib.umd.js",
+      "require": "./dist/index.cjs",
-      "types": "./dist/stdlib.d.ts"
+      "types": "./dist/index.d.ts"
     }
   },
   "scripts": {
-    "test": "vitest",
+    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "dev": "vitest dev",
-    "test:bench": "vitest bench",
+    "build": "unbuild"
-    "dev": "vite",
-    "build": "vite build"
   },
   "devDependencies": {
     "@robonen/tsconfig": "workspace:*",
-    "@vitest/coverage-v8": "^1.4.0",
+    "@vitest/coverage-v8": "catalog:",
-    "pathe": "^1.1.2",
+    "pathe": "catalog:",
-    "vite": "^5.2.8",
+    "unbuild": "catalog:",
-    "vite-plugin-dts": "^3.8.1",
+    "vitest": "catalog:"
-    "vitest": "^1.4.0"
   }
 }

packages/stdlib/src/arrays/cluster/index.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { cluster } from '.';
+
+describe('cluster', () => {
+  it('cluster an array into subarrays of a specific size', () => {
+    const result = cluster([1, 2, 3, 4, 5, 6, 7, 8], 3);
+
+    expect(result).toEqual([[1, 2, 3], [4, 5, 6], [7, 8]]);
+  });
+
+  it('handle arrays that are not perfectly divisible by the size', () => {
+    const result = cluster([1, 2, 3, 4, 5], 2);
+
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it('return an array with each element in its own subarray if size is 1', () => {
+    const result = cluster([1, 2, 3, 4], 1);
+
+    expect(result).toEqual([[1], [2], [3], [4]]);
+  });
+
+  it('return an array with a single subarray if size is greater than the array length', () => {
+    const result = cluster([1, 2, 3], 5);
+
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  it('return an empty array if size is less than or equal to 0', () => {
+    const result = cluster([1, 2, 3, 4], -1);
+
+    expect(result).toEqual([]);
+  });
+
+  it('return an empty array if the input array is empty', () => {
+    const result = cluster([], 3);
+    
+    expect(result).toEqual([]);
+  });
+});

packages/stdlib/src/arrays/cluster/index.ts

@@ -0,0 +1,24 @@
+/**
+ * @name cluster
+ * @category Arrays
+ * @description Cluster an array into subarrays of a specific size
+ * 
+ * @param {Value[]} arr The array to cluster
+ * @param {number} size The size of each cluster
+ * @returns {Value[][]} The clustered array
+ * 
+ * @example
+ * cluster([1, 2, 3, 4, 5, 6, 7, 8], 3) // => [[1, 2, 3], [4, 5, 6], [7, 8]]
+ * 
+ * @example
+ * cluster([1, 2, 3, 4], -1) // => []
+ * 
+ * @since 0.0.3
+ */
+export function cluster<Value>(arr: Value[], size: number): Value[][] {
+  if (size <= 0) return [];
+
+  const clusterLength = Math.ceil(arr.length / size);
+
+  return Array.from({ length: clusterLength }, (_, i) => arr.slice(i * size, i * size + size));
+}

packages/stdlib/src/arrays/first/index.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { first } from '.';
+
+describe('first', () => {
+  it('return the first element of a non-empty array', () => {
+    expect(first([1, 2, 3])).toBe(1);
+    expect(first(['a', 'b', 'c'])).toBe('a');
+  });
+
+  it('return undefined for an empty array without a default value', () => {
+    expect(first([])).toBeUndefined();
+  });
+
+  it('return the default value for an empty array with a default value', () => {
+    expect(first([], 42)).toBe(42);
+    expect(first([], 'default')).toBe('default');
+  });
+
+  it('return the first element even if a default value is provided', () => {
+    expect(first([1, 2, 3], 42)).toBe(1);
+    expect(first(['a', 'b', 'c'], 'default')).toBe('a');
+  });
+});

packages/stdlib/src/arrays/first/index.ts

@@ -0,0 +1,20 @@
+/**
+ * @name first
+ * @category Arrays
+ * @description Returns the first element of an array
+ * 
+ * @param {Value[]} arr The array to get the first element from
+ * @param {Value} [defaultValue] The default value to return if the array is empty
+ * @returns {Value | undefined} The first element of the array, or the default value if the array is empty
+ * 
+ * @example
+ * first([1, 2, 3]); // => 1
+ * 
+ * @example
+ * first([]); // => undefined
+ * 
+ * @since 0.0.3
+ */
+export function first<Value>(arr: Value[], defaultValue?: Value) {
+    return arr[0] ?? defaultValue;
+}

packages/stdlib/src/arrays/index.ts

@@ -0,0 +1,5 @@
+export * from './cluster';
+export * from './first';
+export * from './last';
+export * from './sum';
+export * from './unique';

packages/stdlib/src/arrays/last/index.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { last } from '.';
+
+describe('last', () => {
+  it('return the last element of a non-empty array', () => {
+    expect(last([1, 2, 3, 4, 5])).toBe(5);
+    expect(last(['a', 'b', 'c'])).toBe('c');
+  });
+
+  it('return undefined if the array is empty and no default value is provided', () => {
+    expect(last([])).toBeUndefined();
+  });
+
+  it('return the default value for an empty array with a default value', () => {
+    expect(last([], 42)).toBe(42);
+    expect(last([], 'default')).toBe('default');
+  });
+
+  it('return the first element even if a default value is provided', () => {
+    expect(last([1, 2, 3], 42)).toBe(3);
+    expect(last(['a', 'b', 'c'], 'default')).toBe('c');
+  });
+});

packages/stdlib/src/arrays/last/index.ts

@@ -0,0 +1,20 @@
+/**
+ * @name last
+ * @section Arrays
+ * @description Gets the last element of an array
+ * 
+ * @param {Value[]} arr The array to get the last element of
+ * @param {Value} [defaultValue] The default value to return if the array is empty
+ * @returns {Value | undefined} The last element of the array, or the default value if the array is empty
+ * 
+ * @example
+ * last([1, 2, 3, 4, 5]); // => 5
+ * 
+ * @example
+ * last([], 3); // => 3
+ * 
+ * @since 0.0.3
+ */
+export function last<Value>(arr: Value[], defaultValue?: Value) {
+  return arr[arr.length - 1] ?? defaultValue;
+}

packages/stdlib/src/arrays/sum/index.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { sum } from '.';
+
+describe('sum', () => {
+  it('return the sum of all elements in a number array', () => {
+    const result = sum([1, 2, 3, 4, 5]);
+
+    expect(result).toBe(15);
+  });
+
+  it('return 0 for an empty array', () => {
+    const result = sum([]);
+
+    expect(result).toBe(0);
+  });
+
+  it('return the sum of all elements using a getValue function', () => {
+    const result = sum([{ value: 1 }, { value: 2 }, { value: 3 }], (item) => item.value);
+
+    expect(result).toBe(6);
+  });
+
+  it('handle arrays with negative numbers', () => {
+    const result = sum([-1, -2, -3, -4, -5]);
+
+    expect(result).toBe(-15);
+  });
+
+  it('handle arrays with mixed positive and negative numbers', () => {
+    const result = sum([1, -2, 3, -4, 5]);
+
+    expect(result).toBe(3);
+  });
+
+  it('handle arrays with floating point numbers', () => {
+    const result = sum([1.5, 2.5, 3.5]);
+
+    expect(result).toBe(7.5);
+  });
+
+  it('handle arrays with a getValue function returning floating point numbers', () => {
+    const result = sum([{ value: 1.5 }, { value: 2.5 }, { value: 3.5 }], (item) => item.value);
+    
+    expect(result).toBe(7.5);
+  });
+});

packages/stdlib/src/arrays/sum/index.ts

@@ -0,0 +1,26 @@
+/**
+ * @name sum
+ * @category Arrays
+ * @description Returns the sum of all the elements in an array
+ * 
+ * @param {Value[]} array - The array to sum
+ * @param {(item: Value) => number} [getValue] - A function that returns the value to sum from each element in the array
+ * @returns {number} The sum of all the elements in the array
+ * 
+ * @example
+ * sum([1, 2, 3, 4, 5]) // => 15
+ * 
+ * sum([{ value: 1 }, { value: 2 }, { value: 3 }], (item) => item.value) // => 6
+ * 
+ * @since 0.0.3
+ */
+export function sum<Value extends number>(array: Value[]): number;
+export function sum<Value>(array: Value[], getValue: (item: Value) => number): number;
+export function sum<Value>(array: Value[], getValue?: (item: Value) => number): number {
+  // This check is necessary because the overload without the getValue argument
+  // makes tree-shaking based on argument types possible
+  if (!getValue)
+    return array.reduce((acc, item) => acc + (item as number), 0);
+
+  return array.reduce((acc, item) => acc + getValue(item), 0);
+}

packages/stdlib/src/arrays/unique/index.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { unique } from '.';
+
+describe('unique', () => {
+  it('return an array with unique numbers', () => {
+    const result = unique([1, 2, 3, 3, 4, 5, 5, 6]);
+
+    expect(result).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  it('return an array with unique objects based on id', () => {
+    const result = unique(
+      [{ id: 1 }, { id: 2 }, { id: 1 }],
+      (item) => item.id,
+    );
+
+    expect(result).toEqual([{ id: 1 }, { id: 2 }]);
+  });
+
+  it('return the same array if all elements are unique', () => {
+    const result = unique([1, 2, 3, 4, 5]);
+
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it('handle arrays with different types of values', () => {
+    const result = unique([1, '1', 2, '2', 2, 3, '3']);
+
+    expect(result).toEqual([1, '1', 2, '2', 3, '3']);
+  });
+
+  it('handle arrays with symbols', () => {
+    const sym1 = Symbol('a');
+    const sym2 = Symbol('b');
+    const result = unique([sym1, sym2, sym1]);
+    
+    expect(result).toEqual([sym1, sym2]);
+  });
+
+  it('return an empty array when given an empty array', () => {
+    const result = unique([]);
+
+    expect(result).toEqual([]);
+  });
+});

packages/stdlib/src/arrays/unique/index.ts

@@ -0,0 +1,33 @@
+export type UniqueKey = string | number | symbol;
+export type Extractor<Value, Key extends UniqueKey> = (value: Value) => Key;
+
+/**
+ * @name unique
+ * @category Arrays
+ * @description Returns a new array with unique values from the original array
+ * 
+ * @param {Value[]} array - The array to filter
+ * @param {Function} [extractor] - The function to extract the value to compare
+ * @returns {Value[]} - The new array with unique values
+ * 
+ * @example
+ * unique([1, 2, 3, 3, 4, 5, 5, 6]) //=> [1, 2, 3, 4, 5, 6]
+ * 
+ * @example
+ * unique([{ id: 1 }, { id: 2 }, { id: 1 }], (a, b) => a.id === b.id) //=> [{ id: 1 }, { id: 2 }]
+ * 
+ * @since 0.0.3
+ */
+export function unique<Value, Key extends UniqueKey>(
+  array: Value[],
+  extractor?: Extractor<Value, Key>,
+) {
+  const values = new Map<Key, Value>();
+
+  for (const value of array) {
+    const key = extractor ? extractor(value) : value as any;
+    values.set(key, value);
+  }
+
+  return Array.from(values.values());
+}

packages/stdlib/src/async/index.ts

@@ -0,0 +1,2 @@
+export * from './sleep';
+export * from './tryIt';

packages/stdlib/src/async/pool/index.ts

@@ -0,0 +1,3 @@
+export type AsyncPoolOptions = {
+  concurrency?: number;
+}

packages/stdlib/src/async/sleep/index.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { sleep } from '.';
+
+describe('sleep', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+  });
+
+  it('delay execution by the specified amount of time', async () => {
+    const start = performance.now();
+    const delay = 100;
+
+    await sleep(delay);
+
+    const end = performance.now();
+
+    expect(end - start).toBeGreaterThan(delay - 5);
+  });
+});

packages/stdlib/src/async/sleep/index.ts

@@ -0,0 +1,19 @@
+/**
+ * @name sleep
+ * @category Async
+ * @description Delays the execution of the current function by the specified amount of time
+ * 
+ * @param {number} ms - The amount of time to delay the execution of the current function
+ * @returns {Promise<void>} - A promise that resolves after the specified amount of time
+ * 
+ * @example
+ * await sleep(1000);
+ * 
+ * @example
+ * sleep(1000).then(() => {
+ *  console.log('Hello, World!');
+ * });
+ */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

packages/stdlib/src/async/tryIt/index.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { tryIt } from '.';
+
+describe('tryIt', () => {
+  it('handle synchronous functions without errors', () => {
+    const syncFn = (x: number) => x * 2;
+    const wrappedSyncFn = tryIt(syncFn);
+
+    const [error, result] = wrappedSyncFn(2);
+
+    expect(error).toBeUndefined();
+    expect(result).toBe(4);
+  });
+
+  it('handle synchronous functions with errors', () => {
+    const syncFn = (): void => { throw new Error('Test error') };
+    const wrappedSyncFn = tryIt(syncFn);
+
+    const [error, result] = wrappedSyncFn();
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error?.message).toBe('Test error');
+    expect(result).toBeUndefined();
+  });
+
+  it('handle asynchronous functions without errors', async () => {
+    const asyncFn = async (x: number) => x * 2;
+    const wrappedAsyncFn = tryIt(asyncFn);
+
+    const [error, result] = await wrappedAsyncFn(2);
+
+    expect(error).toBeUndefined();
+    expect(result).toBe(4);
+  });
+
+  it('handle asynchronous functions with errors', async () => {
+    const asyncFn = async () => { throw new Error('Test error') };
+    const wrappedAsyncFn = tryIt(asyncFn);
+
+    const [error, result] = await wrappedAsyncFn();
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error?.message).toBe('Test error');
+    expect(result).toBeUndefined();
+  });
+
+  it('handle promise-based functions without errors', async () => {
+    const promiseFn = (x: number) => Promise.resolve(x * 2);
+    const wrappedPromiseFn = tryIt(promiseFn);
+
+    const [error, result] = await wrappedPromiseFn(2);
+
+    expect(error).toBeUndefined();
+    expect(result).toBe(4);
+  });
+
+  it('handle promise-based functions with errors', async () => {
+    const promiseFn = () => Promise.reject(new Error('Test error'));
+    const wrappedPromiseFn = tryIt(promiseFn);
+
+    const [error, result] = await wrappedPromiseFn();
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error?.message).toBe('Test error');
+    expect(result).toBeUndefined();
+  });
+});

packages/stdlib/src/async/tryIt/index.ts

@@ -0,0 +1,41 @@
+import { isPromise } from '../../types';
+
+export type TryItReturn<Return> = Return extends Promise<any>
+  ? Promise<[Error, undefined] | [undefined, Awaited<Return>]>
+  : [Error, undefined] | [undefined, Return];
+
+/**
+ * @name tryIt
+ * @category Async
+ * @description Wraps promise-based code in a try/catch block without forking the control flow
+ * 
+ * @param {Function} fn - The function to try
+ * @returns {Function} - The function that will return a tuple with the error and the result
+ * 
+ * @example
+ * const wrappedFetch = tryIt(fetch);
+ * const [error, result] = await wrappedFetch('https://jsonplaceholder.typicode.com/todos/1');
+ * 
+ * @example
+ * const [error, result] = await tryIt(fetch)('https://jsonplaceholder.typicode.com/todos/1');
+ * 
+ * @since 0.0.3
+ */
+export function tryIt<Args extends any[], Return>(
+  fn: (...args: Args) => Return,
+) {
+  return (...args: Args): TryItReturn<Return> => {
+    try {
+      const result = fn(...args);
+
+      if (isPromise(result))
+        return result
+          .then((value) => [undefined, value])
+          .catch((error) => [error, undefined]) as TryItReturn<Return>;
+
+      return [undefined, result] as TryItReturn<Return>;
+    } catch (error) {
+      return [error, undefined] as TryItReturn<Return>;
+    }
+  };
+}

packages/stdlib/src/bits/flags/index.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { flagsGenerator } from '.';
+
+describe('flagsGenerator', () => {
+  it('generate unique flags', () => {
+    const generateFlag = flagsGenerator();
+
+    const flag1 = generateFlag();
+    const flag2 = generateFlag();
+    const flag3 = generateFlag();
+
+    expect(flag1).toBe(1);
+    expect(flag2).toBe(2);
+    expect(flag3).toBe(4);
+  });
+
+  it('throw an error if more than 31 flags are created', () => {
+    const generateFlag = flagsGenerator();
+
+    for (let i = 0; i < 31; i++) {
+      generateFlag();
+    }
+
+    expect(() => generateFlag()).toThrow(new RangeError('Cannot create more than 31 flags'));
+  });
+});

packages/stdlib/src/bits/flags/index.ts

@@ -0,0 +1,22 @@
+/**
+ * @name flagsGenerator
+ * @category Bits
+ * @description Create a function that generates unique flags
+ * 
+ * @returns {Function} A function that generates unique flags
+ * @throws {RangeError} If more than 31 flags are created
+ *
+ * @since 0.0.2
+ */
+export function flagsGenerator() {
+    let lastFlag = 0;
+
+    return () => {
+      // 31 flags is the maximum number of flags that can be created
+      // (without zero) because of the 32-bit integer limit in bitwise operations
+      if (lastFlag & 0x40000000)
+        throw new RangeError('Cannot create more than 31 flags');
+
+      return (lastFlag = lastFlag === 0 ? 1 : lastFlag << 1);
+    };
+}

packages/stdlib/src/bits/helpers/index.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from 'vitest';
+import { and, or, not, has, is, unset, toggle } from '.';
+
+
+describe('flagsAnd', () => {
+  it('no effect on zero flags', () => {
+    const result = and();
+
+    expect(result).toBe(-1);
+  });
+
+  it('source flag is returned if no flags are provided', () => {
+    const result = and(0b1010);
+
+    expect(result).toBe(0b1010);
+  });
+  
+  it('perform bitwise AND operation on flags', () => {
+    const result = and(0b1111, 0b1010, 0b1100);
+
+    expect(result).toBe(0b1000);
+  });
+});
+
+describe('flagsOr', () => {
+  it('no effect on zero flags', () => {
+    const result = or();
+
+    expect(result).toBe(0);
+  });
+
+  it('source flag is returned if no flags are provided', () => {
+      const result = or(0b1010);
+  
+      expect(result).toBe(0b1010);
+  });
+
+  it('perform bitwise OR operation on flags', () => {
+      const result = or(0b1111, 0b1010, 0b1100);
+  
+      expect(result).toBe(0b1111);
+  });
+});
+
+describe('flagsNot', () => {
+  it('perform bitwise NOT operation on a flag', () => {
+    const result = not(0b101);
+
+    expect(result).toBe(-0b110);
+  });
+});
+
+describe('flagsHas', () => {
+  it('check if a flag has a specific bit set', () => {
+    const result = has(0b1010, 0b1000);
+
+    expect(result).toBe(true);
+  });
+
+  it('check if a flag has a specific bit unset', () => {
+      const result = has(0b1010, 0b0100);
+  
+      expect(result).toBe(false);
+  });
+});
+
+describe('flagsIs', () => {
+  it('check if a flag is set', () => {
+    const result = is(0b1010);
+
+    expect(result).toBe(true);
+  });
+
+  it('check if a flag is unset', () => {
+      const result = is(0);
+  
+      expect(result).toBe(false);
+  });
+});
+
+describe('flagsUnset', () => {
+  it('unset a flag', () => {
+    const result = unset(0b1010, 0b1000);
+
+    expect(result).toBe(0b0010);
+  });
+});
+
+describe('flagsToggle', () => {
+  it('toggle a flag', () => {
+    const result = toggle(0b1010, 0b1000);
+
+    expect(result).toBe(0b0010);
+  });
+});

packages/stdlib/src/bits/helpers/index.ts

@@ -0,0 +1,100 @@
+/**
+ * @name and
+ * @category Bits
+ * @description Function to combine multiple flags using the AND operator
+ * 
+ * @param {number[]} flags - The flags to combine
+ * @returns {number} The combined flags
+ *
+ * @since 0.0.2
+ */
+export function and(...flags: number[]) {
+  return flags.reduce((acc, flag) => acc & flag, -1);
+}
+
+/**
+* @name or
+* @category Bits
+* @description Function to combine multiple flags using the OR operator
+* 
+* @param {number[]} flags - The flags to combine
+* @returns {number} The combined flags
+*
+* @since 0.0.2
+*/
+export function or(...flags: number[]) {
+  return flags.reduce((acc, flag) => acc | flag, 0);
+}
+
+/**
+* @name not
+* @category Bits
+* @description Function to combine multiple flags using the XOR operator
+* 
+* @param {number} flag - The flag to apply the NOT operator to
+* @returns {number} The result of the NOT operator
+*
+* @since 0.0.2
+*/
+export function not(flag: number) {
+  return ~flag;
+}
+
+/**
+* @name has
+* @category Bits
+* @description Function to make sure a flag has a specific bit set
+* 
+* @param {number} flag - The flag to check
+* @param {number} other - Flag to check
+* @returns {boolean} Whether the flag has the bit set
+*
+* @since 0.0.2
+*/
+export function has(flag: number, other: number) {
+  return (flag & other) === other;
+}
+
+/**
+* @name is
+* @category Bits
+* @description Function to check if a flag is set
+* 
+* @param {number} flag - The flag to check
+* @returns {boolean} Whether the flag is set
+*
+* @since 0.0.2
+*/
+export function is(flag: number) {
+  return flag !== 0;
+}
+
+/**
+* @name unset
+* @category Bits
+* @description Function to unset a flag
+* 
+* @param {number} flag - Source flag
+* @param {number} other - Flag to unset
+* @returns {number} The new flag
+*
+* @since 0.0.2
+*/
+export function unset(flag: number, other: number) {
+  return flag & ~other;
+}
+
+/**
+* @name toggle
+* @category Bits
+* @description Function to toggle (xor) a flag
+* 
+* @param {number} flag - Source flag
+* @param {number} other - Flag to toggle
+* @returns {number} The new flag
+*
+* @since 0.0.2
+*/
+export function toggle(flag: number, other: number) {
+  return flag ^ other;
+}

packages/stdlib/src/bits/index.ts

@@ -0,0 +1 @@
+export * from './flags';

packages/stdlib/src/bits/vector/index.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { BitVector } from '.';
+
+describe('BitVector', () => {
+  it('initialize with the correct size', () => {
+    const size = 16;
+    const expectedSize = Math.ceil(size / 8);
+    const bitVector = new BitVector(size);
+
+    expect(bitVector.length).toBe(expectedSize);
+  });
+
+  it('set and get bits correctly', () => {
+    const bitVector = new BitVector(16);
+    bitVector.setBit(5);
+    
+    expect(bitVector.getBit(5)).toBe(true);
+    expect(bitVector.getBit(4)).toBe(false);
+  });
+
+  it('get out of bounds bits correctly', () => {
+    const bitVector = new BitVector(16);
+
+    expect(bitVector.getBit(155)).toBe(false);
+  });
+
+  it('clear bits correctly', () => {
+    const bitVector = new BitVector(16);
+    bitVector.setBit(5);
+
+    expect(bitVector.getBit(5)).toBe(true);
+
+    bitVector.clearBit(5);
+
+    expect(bitVector.getBit(5)).toBe(false);
+  });
+
+  it('find the previous bit correctly', () => {
+    const bitVector = new BitVector(100);
+    const indices = [99, 88, 66, 65, 64, 63, 15, 14, 1, 0];
+    const result = [];
+    indices.forEach(index => bitVector.setBit(index));
+    
+    for (let i = bitVector.previousBit(100); i !== -1; i = bitVector.previousBit(i)) {
+      result.push(i);
+    }
+
+    expect(result).toEqual(indices);
+  });
+
+  it('return -1 when no previous bit is found', () => {
+    const bitVector = new BitVector(16);
+
+    expect(bitVector.previousBit(0)).toBe(-1);
+  });
+
+  it('throw RangeError when previousBit is called with an unreachable value', () => {
+    const bitVector = new BitVector(16);
+    bitVector.setBit(5);
+
+    expect(() => bitVector.previousBit(24)).toThrow(new RangeError('Unreachable value'));
+  });
+});

packages/stdlib/src/bits/vector/index.ts

@@ -0,0 +1,61 @@
+export interface BitVector {
+  getBit(index: number): boolean;
+  setBit(index: number): void;
+  clearBit(index: number): void;
+  previousBit(index: number): number;
+}
+
+/**
+ * @name BitVector
+ * @category Bits
+ * @description A bit vector is a vector of bits that can be used to store a collection of bits
+ * 
+ * @since 0.0.3
+ */
+export class BitVector extends Uint8Array implements BitVector {
+  constructor(size: number) {
+    super(Math.ceil(size / 8));
+  }
+
+  getBit(index: number) {
+    const value = this[index >> 3]! & (1 << (index & 7));
+    return value !== 0;
+  }
+
+  setBit(index: number) {
+    this[index >> 3]! |= 1 << (index & 7);
+  }
+
+  clearBit(index: number): void {
+    this[index >> 3]! &= ~(1 << (index & 7));
+  }
+
+  previousBit(index: number): number {
+    while (index !== ((index >> 3) << 3)) {
+      --index;
+
+      if (this.getBit(index)) {
+        return index;
+      }
+    }
+
+    let byteIndex = (index >> 3) - 1;
+
+    while (byteIndex >= 0 && this[byteIndex] === 0)
+      --byteIndex;
+
+    if (byteIndex < 0)
+      return -1;
+
+    index = (byteIndex << 3) + 7;
+
+    while (index >= (byteIndex << 3)) {
+      if (this.getBit(index))
+        return index;
+
+      --index;
+    }
+
+    throw new RangeError('Unreachable value');
+  }
+}

packages/stdlib/src/collections/get/index.ts

@@ -0,0 +1,35 @@
+import { type Collection, type Path } from '../../types';
+
+export type ExtractFromObject<O extends Record<PropertyKey, unknown>, K> =
+  K extends keyof O
+    ? O[K]
+    : K extends keyof NonNullable<O>
+      ? NonNullable<O>[K]
+      : never;
+
+export type ExtractFromArray<A extends readonly any[], K> =
+  any[] extends A
+    ? A extends readonly (infer T)[]
+      ? T | undefined
+      : undefined
+    : K extends keyof A
+      ? A[K]
+      : undefined;
+
+export type ExtractFromCollection<O, K> =
+  K extends []
+  ? O
+  : K extends [infer Key, ...infer Rest]
+    ? O extends Record<PropertyKey, unknown>
+      ? ExtractFromCollection<ExtractFromObject<O, Key>, Rest>
+      : O extends readonly any[]
+        ? ExtractFromCollection<ExtractFromArray<O, Key>, Rest>
+        : never
+    : never;
+
+type Get<O, K> = ExtractFromCollection<O, Path<K>>;
+
+
+export function get<O extends Collection, K extends string>(obj: O, path: K) {
+  return path.split('.').reduce((acc, key) => (acc as any)?.[key], obj) as Get<O, K> | undefined;
+}

packages/stdlib/src/collections/index.ts

@@ -0,0 +1 @@
+export * from './get';

packages/stdlib/src/index.ts

@@ -1,2 +1,10 @@
-export * from './text';
+export * from './arrays';
+export * from './async';
+export * from './bits';
 export * from './math';
+export * from './objects';
+export * from './patterns';
+export * from './structs';
+export * from './text';
+export * from './types';
+export * from './utils'

packages/stdlib/src/math/basic/clamp/index.test.ts

@@ -43,4 +43,39 @@ describe('clamp', () => {
     // negative range and value
     expect(clamp(-10, -100, -5)).toBe(-10);
   });
+
+  it('handle NaN and Infinity', () => {
+    // value is NaN
+    expect(clamp(NaN, 0, 100)).toBe(NaN);
+
+    // min is NaN
+    expect(clamp(50, NaN, 100)).toBe(NaN);
+
+    // max is NaN
+    expect(clamp(50, 0, NaN)).toBe(NaN);
+
+    // value is Infinity
+    expect(clamp(Infinity, 0, 100)).toBe(100);
+
+    // min is Infinity
+    expect(clamp(50, Infinity, 100)).toBe(100);
+
+    // max is Infinity
+    expect(clamp(50, 0, Infinity)).toBe(50);
+
+    // min and max are Infinity
+    expect(clamp(50, Infinity, Infinity)).toBe(Infinity);
+
+    // value is -Infinity
+    expect(clamp(-Infinity, 0, 100)).toBe(0);
+
+    // min is -Infinity
+    expect(clamp(50, -Infinity, 100)).toBe(50);
+
+    // max is -Infinity
+    expect(clamp(50, 0, -Infinity)).toBe(-Infinity);
+
+    // min and max are -Infinity
+    expect(clamp(50, -Infinity, -Infinity)).toBe(-Infinity);
+  });
 });

packages/stdlib/src/math/basic/clamp/index.ts

@@ -0,0 +1,15 @@
+/**
+ * @name clamp
+ * @category Math
+ * @description Clamps a number between a minimum and maximum value
+ * 
+ * @param {number} value The number to clamp
+ * @param {number} min Minimum value
+ * @param {number} max Maximum value
+ * @returns {number} The clamped number
+ *
+ * @since 0.0.1
+ */
+export function clamp(value: number, min: number, max: number) {
+  return Math.min(Math.max(value, min), max);
+}

packages/stdlib/src/math/basic/lerp/index.test.ts

@@ -0,0 +1,61 @@
+import {describe, it, expect} from 'vitest';
+import {inverseLerp, lerp} from '.';
+
+describe('lerp', () => {
+  it('interpolates between two values', () => {
+    const result = lerp(0, 10, 0.5);
+    expect(result).toBe(5);
+  });
+
+  it('returns start value when t is 0', () => {
+    const result = lerp(0, 10, 0);
+    expect(result).toBe(0);
+  });
+
+  it('returns end value when t is 1', () => {
+    const result = lerp(0, 10, 1);
+    expect(result).toBe(10);
+  });
+
+  it('handles negative interpolation values', () => {
+    const result = lerp(0, 10, -0.5);
+    expect(result).toBe(-5);
+  });
+
+  it('handles interpolation values greater than 1', () => {
+    const result = lerp(0, 10, 1.5);
+    expect(result).toBe(15);
+  });
+});
+
+describe('inverseLerp', () => {
+  it('returns 0 when value is start', () => {
+    const result = inverseLerp(0, 10, 0);
+    expect(result).toBe(0);
+  });
+
+  it('returns 1 when value is end', () => {
+    const result = inverseLerp(0, 10, 10);
+    expect(result).toBe(1);
+  });
+
+  it('interpolates correctly between two values', () => {
+    const result = inverseLerp(0, 10, 5);
+    expect(result).toBe(0.5);
+  });
+
+  it('handles values less than start', () => {
+    const result = inverseLerp(0, 10, -5);
+    expect(result).toBe(-0.5);
+  });
+
+  it('handles values greater than end', () => {
+    const result = inverseLerp(0, 10, 15);
+    expect(result).toBe(1.5);
+  });
+
+  it('handles same start and end values', () => {
+    const result = inverseLerp(10, 10, 10);
+    expect(result).toBe(0);
+  });
+});

packages/stdlib/src/math/basic/lerp/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @name lerp
+ * @category Math
+ * @description Linearly interpolates between two values
+ *
+ * @param {number} start The start value
+ * @param {number} end The end value
+ * @param {number} t The interpolation value
+ * @returns {number} The interpolated value
+ *
+ * @since 0.0.2
+ */
+export function lerp(start: number, end: number, t: number) {
+  return start + t * (end - start);
+}
+
+/**
+ * @name inverseLerp
+ * @category Math
+ * @description Inverse linear interpolation between two values
+ *
+ * @param {number} start The start value
+ * @param {number} end The end value
+ * @param {number} value The value to interpolate
+ * @returns {number} The interpolated value
+ *
+ * @since 0.0.2
+ */
+export function inverseLerp(start: number, end: number, value: number) {
+  return start === end ? 0 : (value - start) / (end - start);
+}

packages/stdlib/src/math/basic/remap/index.test.ts

@@ -0,0 +1,46 @@
+import {describe, expect, it} from 'vitest';
+import {remap} from '.';
+
+describe('remap', () => {
+  it('map values from one range to another', () => {
+    // value at midpoint
+    expect(remap(5, 0, 10, 0, 100)).toBe(50);
+
+    // value at min
+    expect(remap(0, 0, 10, 0, 100)).toBe(0);
+
+    // value at max
+    expect(remap(10, 0, 10, 0, 100)).toBe(100);
+
+    // value outside range (below)
+    expect(remap(-5, 0, 10, 0, 100)).toBe(0);
+
+    // value outside range (above)
+    expect(remap(15, 0, 10, 0, 100)).toBe(100);
+
+    // value at midpoint of negative range
+    expect(remap(75, 50, 100, -50, 50)).toBe(0);
+
+    // value at midpoint of negative range
+    expect(remap(-25, -50, 0, 0, 100)).toBe(50);
+  });
+
+  it('handle floating-point numbers correctly', () => {
+    // floating-point value
+    expect(remap(3.5, 0, 10, 0, 100)).toBe(35);
+
+    // positive floating-point ranges
+    expect(remap(1.25, 0, 2.5, 0, 100)).toBe(50);
+
+    // negative floating-point value
+    expect(remap(-2.5, -5, 0, 0, 100)).toBe(50);
+
+    // negative floating-point ranges
+    expect(remap(-1.25, -2.5, 0, 0, 100)).toBe(50);
+  });
+
+  it('handle edge cases', () => {
+    // input range is zero (should return output min)
+    expect(remap(5, 0, 0, 0, 100)).toBe(0);
+  });
+});

packages/stdlib/src/math/basic/remap/index.ts

@@ -0,0 +1,25 @@
+import { clamp } from '../clamp';
+import {inverseLerp, lerp} from '../lerp';
+
+/**
+ * @name remap
+ * @category Math
+ * @description Map a value from one range to another
+ * 
+ * @param {number} value The value to map
+ * @param {number} in_min The minimum value of the input range
+ * @param {number} in_max The maximum value of the input range
+ * @param {number} out_min The minimum value of the output range
+ * @param {number} out_max The maximum value of the output range
+ * @returns {number} The mapped value
+ *
+ * @since 0.0.1
+ */
+export function remap(value: number, in_min: number, in_max: number, out_min: number, out_max: number) {
+  if (in_min === in_max)
+    return out_min;
+
+  const clampedValue = clamp(value, in_min, in_max);
+
+  return lerp(out_min, out_max, inverseLerp(in_min, in_max, clampedValue));
+}

packages/stdlib/src/math/bigint/clampBigInt/index.test.ts

@@ -0,0 +1,35 @@
+import {describe, it, expect} from 'vitest';
+import {clampBigInt} from '.';
+
+describe('clampBigInt', () => {
+  it('clamp a value within the given range', () => {
+    // value < min
+    expect(clampBigInt(-10n, 0n, 100n)).toBe(0n);
+
+    // value > max
+    expect(clampBigInt(200n, 0n, 100n)).toBe(100n);
+
+    // value within range
+    expect(clampBigInt(50n, 0n, 100n)).toBe(50n);
+
+    // value at min
+    expect(clampBigInt(0n, 0n, 100n)).toBe(0n);
+
+    // value at max
+    expect(clampBigInt(100n, 0n, 100n)).toBe(100n);
+
+    // value at midpoint
+    expect(clampBigInt(50n, 100n, 100n)).toBe(100n);
+  });
+
+  it('handle edge cases', () => {
+    // all values are the same
+    expect(clampBigInt(5n, 5n, 5n)).toBe(5n);
+
+    // min > max
+    expect(clampBigInt(10n, 100n, 50n)).toBe(50n);
+
+    // negative range and value
+    expect(clampBigInt(-10n, -100n, -5n)).toBe(-10n);
+  });
+});

packages/stdlib/src/math/bigint/clampBigInt/index.ts

@@ -0,0 +1,18 @@
+import {minBigInt} from '../minBigInt';
+import {maxBigInt} from '../maxBigInt';
+
+/**
+ * @name clampBigInt
+ * @category Math
+ * @description Clamps a bigint between a minimum and maximum value
+ *
+ * @param {bigint} value The number to clamp
+ * @param {bigint} min Minimum value
+ * @param {bigint} max Maximum value
+ * @returns {bigint} The clamped number
+ *
+ * @since 0.0.2
+ */
+export function clampBigInt(value: bigint, min: bigint, max: bigint) {
+  return minBigInt(maxBigInt(value, min), max);
+}

packages/stdlib/src/math/bigint/lerpBigInt/index.test.ts

@@ -0,0 +1,83 @@
+import {describe, it, expect} from 'vitest';
+import {inverseLerpBigInt, lerpBigInt} from '.';
+
+const MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+
+describe('lerpBigInt', () => {
+  it('interpolates between two bigint values', () => {
+    const result = lerpBigInt(0n, 10n, 0.5);
+    expect(result).toBe(5n);
+  });
+
+  it('returns start value when t is 0', () => {
+    const result = lerpBigInt(0n, 10n, 0);
+    expect(result).toBe(0n);
+  });
+
+  it('returns end value when t is 1', () => {
+    const result = lerpBigInt(0n, 10n, 1);
+    expect(result).toBe(10n);
+  });
+
+  it('handles negative interpolation values', () => {
+    const result = lerpBigInt(0n, 10n, -0.5);
+    expect(result).toBe(-5n);
+  });
+
+  it('handles interpolation values greater than 1', () => {
+    const result = lerpBigInt(0n, 10n, 1.5);
+    expect(result).toBe(15n);
+  });
+});
+
+describe('inverseLerpBigInt', () => {
+  it('returns 0 when value is start', () => {
+    const result = inverseLerpBigInt(0n, 10n, 0n);
+    expect(result).toBe(0);
+  });
+
+  it('returns 1 when value is end', () => {
+    const result = inverseLerpBigInt(0n, 10n, 10n);
+    expect(result).toBe(1);
+  });
+
+  it('interpolates correctly between two bigint values', () => {
+    const result = inverseLerpBigInt(0n, 10n, 5n);
+    expect(result).toBe(0.5);
+  });
+
+  it('handles values less than start', () => {
+    const result = inverseLerpBigInt(0n, 10n, -5n);
+    expect(result).toBe(-0.5);
+  });
+
+  it('handles values greater than end', () => {
+    const result = inverseLerpBigInt(0n, 10n, 15n);
+    expect(result).toBe(1.5);
+  });
+
+  it('handles same start and end values', () => {
+    const result = inverseLerpBigInt(10n, 10n, 10n);
+    expect(result).toBe(0);
+  });
+
+  it('handles the maximum safe integer correctly', () => {
+    const result = inverseLerpBigInt(0n, MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+    expect(result).toBe(1);
+  });
+
+  it('handles values just above the maximum safe integer correctly', () => {
+    const result = inverseLerpBigInt(0n, MAX_SAFE_INTEGER, 0n);
+    expect(result).toBe(0);
+  });
+
+  it('handles values just below the maximum safe integer correctly', () => {
+    const result = inverseLerpBigInt(0n, MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+    expect(result).toBe(1);
+  });
+
+  it('handles values just above the maximum safe integer correctly', () => {
+    const result = inverseLerpBigInt(0n, 2n ** 128n, 2n ** 127n);
+    expect(result).toBe(0.5);
+  });
+});

packages/stdlib/src/math/bigint/lerpBigInt/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @name lerpBigInt
+ * @category Math
+ * @description Linearly interpolates between bigint values
+ *
+ * @param {bigint} start The start value
+ * @param {bigint} end The end value
+ * @param {number} t The interpolation value
+ * @returns {bigint} The interpolated value
+ *
+ * @since 0.0.2
+ */
+export function lerpBigInt(start: bigint, end: bigint, t: number) {
+  return start + ((end - start) * BigInt(t * 10000)) / 10000n;
+}
+
+/**
+ * @name inverseLerpBigInt
+ * @category Math
+ * @description Inverse linear interpolation between two bigint values
+ *
+ * @param {bigint} start The start value
+ * @param {bigint} end The end value
+ * @param {bigint} value The value to interpolate
+ * @returns {number} The interpolated value
+ *
+ * @since 0.0.2
+ */
+export function inverseLerpBigInt(start: bigint, end: bigint, value: bigint) {
+  return start === end ? 0 : Number((value - start) * 10000n / (end - start)) / 10000;
+}

packages/stdlib/src/math/bigint/maxBigInt/index.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { maxBigInt } from '.';
+
+describe('maxBigInt', () => {
+  it('returns -Infinity when no values are provided', () => {
+    expect(() => maxBigInt()).toThrow(new TypeError('maxBigInt requires at least one argument'));
+  });
+
+  it('returns the largest value from a list of positive bigints', () => {
+    const result = maxBigInt(10n, 20n, 5n, 15n);
+    expect(result).toBe(20n);
+  });
+
+  it('returns the largest value from a list of negative bigints', () => {
+    const result = maxBigInt(-10n, -20n, -5n, -15n);
+    expect(result).toBe(-5n);
+  });
+
+  it('returns the largest value from a list of mixed positive and negative bigints', () => {
+    const result = maxBigInt(10n, -20n, 5n, -15n);
+    expect(result).toBe(10n);
+  });
+
+  it('returns the value itself when only one bigint is provided', () => {
+    const result = maxBigInt(10n);
+    expect(result).toBe(10n);
+  });
+
+  it('returns the largest value when all values are the same', () => {
+    const result = maxBigInt(10n, 10n, 10n);
+    expect(result).toBe(10n);
+  });
+
+  it('handles a large number of bigints', () => {
+    const values = Array.from({ length: 1000 }, (_, i) => BigInt(i));
+    const result = maxBigInt(...values);
+    expect(result).toBe(999n);
+  });
+});

packages/stdlib/src/math/bigint/maxBigInt/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @name maxBigInt
+ * @category Math
+ * @description Like `Math.max` but for BigInts
+ *
+ * @param {...bigint} values The values to compare
+ * @returns {bigint} The largest value
+ * @throws {TypeError} If no arguments are provided
+ *
+ * @since 0.0.2
+ */
+export function maxBigInt(...values: bigint[]) {
+  if (!values.length)
+    throw new TypeError('maxBigInt requires at least one argument');
+
+  return values.reduce((acc, val) => val > acc ? val : acc);
+}

packages/stdlib/src/math/bigint/minBigInt/index.test.ts

@@ -0,0 +1,39 @@
+import {describe, it, expect} from 'vitest';
+import {minBigInt} from '.';
+
+describe('minBigInt', () => {
+  it('returns Infinity when no values are provided', () => {
+    expect(() => minBigInt()).toThrow(new TypeError('minBigInt requires at least one argument'));
+  });
+
+  it('returns the smallest value from a list of positive bigints', () => {
+    const result = minBigInt(10n, 20n, 5n, 15n);
+    expect(result).toBe(5n);
+  });
+
+  it('returns the smallest value from a list of negative bigints', () => {
+    const result = minBigInt(-10n, -20n, -5n, -15n);
+    expect(result).toBe(-20n);
+  });
+
+  it('returns the smallest value from a list of mixed positive and negative bigints', () => {
+    const result = minBigInt(10n, -20n, 5n, -15n);
+    expect(result).toBe(-20n);
+  });
+
+  it('returns the value itself when only one bigint is provided', () => {
+    const result = minBigInt(10n);
+    expect(result).toBe(10n);
+  });
+
+  it('returns the smallest value when all values are the same', () => {
+    const result = minBigInt(10n, 10n, 10n);
+    expect(result).toBe(10n);
+  });
+
+  it('handles a large number of bigints', () => {
+    const values = Array.from({length: 1000}, (_, i) => BigInt(i));
+    const result = minBigInt(...values);
+    expect(result).toBe(0n);
+  });
+});

packages/stdlib/src/math/bigint/minBigInt/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @name minBigInt
+ * @category Math
+ * @description Like `Math.min` but for BigInts
+ *
+ * @param {...bigint} values The values to compare
+ * @returns {bigint} The smallest value
+ * @throws {TypeError} If no arguments are provided
+ *
+ * @since 0.0.2
+ */
+export function minBigInt(...values: bigint[]) {
+  if (!values.length)
+    throw new TypeError('minBigInt requires at least one argument');
+
+  return values.reduce((acc, val) => val < acc ? val : acc);
+}

packages/stdlib/src/math/bigint/remapBigInt/index.test.ts

@@ -0,0 +1,32 @@
+import {describe, expect, it} from 'vitest';
+import {remapBigInt} from '.';
+
+describe('remapBigInt', () => {
+  it('map values from one range to another', () => {
+    // value at midpoint
+    expect(remapBigInt(5n, 0n, 10n, 0n, 100n)).toBe(50n);
+
+    // value at min
+    expect(remapBigInt(0n, 0n, 10n, 0n, 100n)).toBe(0n);
+
+    // value at max
+    expect(remapBigInt(10n, 0n, 10n, 0n, 100n)).toBe(100n);
+
+    // value outside range (below)
+    expect(remapBigInt(-5n, 0n, 10n, 0n, 100n)).toBe(0n);
+
+    // value outside range (above)
+    expect(remapBigInt(15n, 0n, 10n, 0n, 100n)).toBe(100n);
+
+    // value at midpoint of negative range
+    expect(remapBigInt(75n, 50n, 100n, -50n, 50n)).toBe(0n);
+
+    // value at midpoint of negative range
+    expect(remapBigInt(-25n, -50n, 0n, 0n, 100n)).toBe(50n);
+  });
+
+  it('handle edge cases', () => {
+    // input range is zero (should return output min)
+    expect(remapBigInt(5n, 0n, 0n, 0n, 100n)).toBe(0n);
+  });
+});

packages/stdlib/src/math/bigint/remapBigInt/index.ts

@@ -0,0 +1,25 @@
+import { clampBigInt } from '../clampBigInt';
+import {inverseLerpBigInt, lerpBigInt} from '../lerpBigInt';
+
+/**
+ * @name remapBigInt
+ * @category Math
+ * @description Map a bigint value from one range to another
+ * 
+ * @param {bigint} value The value to map
+ * @param {bigint} in_min The minimum value of the input range
+ * @param {bigint} in_max The maximum value of the input range
+ * @param {bigint} out_min The minimum value of the output range
+ * @param {bigint} out_max The maximum value of the output range
+ * @returns {bigint} The mapped value
+ *
+ * @since 0.0.1
+ */
+export function remapBigInt(value: bigint, in_min: bigint, in_max: bigint, out_min: bigint, out_max: bigint) {
+  if (in_min === in_max)
+    return out_min;
+
+  const clampedValue = clampBigInt(value, in_min, in_max);
+
+  return lerpBigInt(out_min, out_max, inverseLerpBigInt(in_min, in_max, clampedValue));
+}

packages/stdlib/src/math/clamp/index.ts

@@ -1,16 +0,0 @@
-/**
- * Clamps a number between a minimum and maximum value
- * 
- * @param {number} value The number to clamp
- * @param {number} min Minimum value
- * @param {number} max Maximum value
- * @returns {number} The clamped number
- */
-export function clamp(value: number, min: number, max: number): number {
-  // The clamp function takes a value, a minimum, and a maximum as parameters.
-  // It ensures that the value falls within the range defined by the minimum and maximum values.
-  // If the value is less than the minimum, it returns the minimum value.
-  // If the value is greater than the maximum, it returns the maximum value.
-  // Otherwise, it returns the original value.
-  return Math.min(Math.max(value, min), max);
-}

packages/stdlib/src/math/index.ts

@@ -1,2 +1,9 @@
-export * from './clamp';
+export * from './basic/clamp';
-export * from './mapRange';
+export * from './basic/lerp';
+export * from './basic/remap';
+
+export * from './bigint/clampBigInt';
+export * from './bigint/lerpBigInt';
+export * from './bigint/maxBigInt';
+export * from './bigint/minBigInt';
+export * from './bigint/remapBigInt';

packages/stdlib/src/math/mapRange/index.test.ts

@@ -1,46 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { mapRange } from './index';
-
-describe('mapRange', () => {
-    it('map values from one range to another', () => {
-        // value at midpoint
-        expect(mapRange(5, 0, 10, 0, 100)).toBe(50);
-    
-        // value at min
-        expect(mapRange(0, 0, 10, 0, 100)).toBe(0);
-    
-        // value at max
-        expect(mapRange(10, 0, 10, 0, 100)).toBe(100);
-    
-        // value outside range (below)
-        expect(mapRange(-5, 0, 10, 0, 100)).toBe(0);
-    
-        // value outside range (above)
-        expect(mapRange(15, 0, 10, 0, 100)).toBe(100);
-    
-        // value at midpoint of negative range
-        expect(mapRange(75, 50, 100, -50, 50)).toBe(0);
-    
-        // value at midpoint of negative range
-        expect(mapRange(-25, -50, 0, 0, 100)).toBe(50);
-      });
-    
-      it('handle floating-point numbers correctly', () => {
-        // floating-point value
-        expect(mapRange(3.5, 0, 10, 0, 100)).toBe(35);
-    
-        // positive floating-point ranges
-        expect(mapRange(1.25, 0, 2.5, 0, 100)).toBe(50);
-    
-        // negative floating-point value
-        expect(mapRange(-2.5, -5, 0, 0, 100)).toBe(50);
-
-        // negative floating-point ranges
-        expect(mapRange(-1.25, -2.5, 0, 0, 100)).toBe(50);
-      });
-    
-      it('handle edge cases', () => {
-        // input range is zero (should return output min)
-        expect(mapRange(5, 0, 0, 0, 100)).toBe(0);
-      });
-});

packages/stdlib/src/math/mapRange/index.ts

@@ -1,23 +0,0 @@
-import { clamp } from "../clamp";
-
-/**
- * Map a value from one range to another
- * 
- * @param {number} value The value to map
- * @param {number} in_min The minimum value of the input range
- * @param {number} in_max The maximum value of the input range
- * @param {number} out_min The minimum value of the output range
- * @param {number} out_max The maximum value of the output range
- * @returns {number} The mapped value
- */
-export function mapRange(value: number, in_min: number, in_max: number, out_min: number, out_max: number): number {
-  // Zero input range means invalid input, so return lowest output range value
-  if (in_min === in_max)
-    return out_min;
-  
-  // To ensure the value is within the input range, clamp it
-  const clampedValue = clamp(value, in_min, in_max);
-
-  // Finally, map the value from the input range to the output range
-  return (clampedValue - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}

packages/stdlib/src/objects/index.ts

@@ -0,0 +1,2 @@
+export * from './omit';
+export * from './pick';

packages/stdlib/src/objects/omit/index.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect } from 'vitest';
+import { omit } from '.';
+
+describe('omit', () => {
+  it('omit a single key from the object', () => {
+    const result = omit({ a: 1, b: 2, c: 3 }, 'a');
+
+    expect(result).toEqual({ b: 2, c: 3 });
+  });
+
+  it('omit multiple keys from the object', () => {
+    const result = omit({ a: 1, b: 2, c: 3 }, ['a', 'b']);
+
+    expect(result).toEqual({ c: 3 });
+  });
+
+  it('return the same object if no keys are omitted', () => {
+    const result = omit({ a: 1, b: 2, c: 3 }, []);
+
+    expect(result).toEqual({ a: 1, b: 2, c: 3 });
+  });
+
+  it('not modify the original object', () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = omit(obj, 'a');
+
+    expect(obj).toEqual({ a: 1, b: 2, c: 3 });
+    expect(result).toEqual({ b: 2, c: 3 });
+  });
+
+  it('handle an empty object', () => {
+    const result = omit({}, 'a' as any);
+
+    expect(result).toEqual({});
+  });
+
+  it('handle non-existent keys gracefully', () => {
+    const result = omit({ a: 1, b: 2, c: 3 } as Record<string, number>, 'd');
+
+    expect(result).toEqual({ a: 1, b: 2, c: 3 });
+  });
+
+  it('handle null gracefully', () => {
+    const emptyTarget = omit(null as any, 'a');
+    const emptyKeys = omit({ a: 1 }, null as any);
+
+    expect(emptyTarget).toEqual({});
+    expect(emptyKeys).toEqual({ a: 1 });
+  });
+});

packages/stdlib/src/objects/omit/index.ts

@@ -0,0 +1,38 @@
+import { isArray, type Arrayable } from '../../types';
+
+/**
+ * @name omit
+ * @category Objects
+ * @description Returns a new object with the specified keys omitted
+ * 
+ * @param {object} target - The object to omit keys from
+ * @param {Arrayable<keyof Target>} keys - The keys to omit
+ * @returns {Omit<Target, Key>} The new object with the specified keys omitted
+ * 
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, 'a') // => { b: 2, c: 3 }
+ * 
+ * @example
+ * omit({ a: 1, b: 2, c: 3 }, ['a', 'b']) // => { c: 3 }
+ * 
+ * @since 0.0.3
+ */
+export function omit<Target extends object, Key extends keyof Target>(
+  target: Target,
+  keys: Arrayable<Key>
+): Omit<Target, Key> {
+  const result = { ...target };
+
+  if (!target || !keys)
+    return result;
+
+  if (isArray(keys)) {
+    for (const key of keys) {
+      delete result[key];
+    }
+  } else {
+    delete result[keys];
+  }
+
+  return result;
+}

packages/stdlib/src/objects/pick/index.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { pick } from '.';
+
+describe('pick', () => {
+  it('pick a single key', () => {
+    const result = pick({ a: 1, b: 2, c: 3 }, 'a');
+
+    expect(result).toEqual({ a: 1 });
+  });
+
+  it('pick multiple keys', () => {
+    const result = pick({ a: 1, b: 2, c: 3 }, ['a', 'b']);
+
+    expect(result).toEqual({ a: 1, b: 2 });
+  });
+
+  it('return an empty object when no keys are provided', () => {
+    const result = pick({ a: 1, b: 2 }, []);
+
+    expect(result).toEqual({});
+  });
+
+  it('handle non-existent keys by setting them to undefined', () => {
+    const result = pick({ a: 1, b: 2 }, ['a', 'c'] as any);
+
+    expect(result).toEqual({ a: 1, c: undefined });
+  });
+
+  it('return an empty object if target is null or undefined', () => {
+    const emptyTarget = pick(null as any, 'a');
+    const emptyKeys = pick({ a: 1 }, null as any);
+
+    expect(emptyTarget).toEqual({});
+    expect(emptyKeys).toEqual({});
+  });
+});

packages/stdlib/src/objects/pick/index.ts

@@ -0,0 +1,38 @@
+import { isArray, type Arrayable } from '../../types';
+
+/**
+ * @name pick
+ * @category Objects
+ * @description Returns a partial copy of an object containing only the keys specified
+ * 
+ * @param {object} target - The object to pick keys from
+ * @param {Arrayable<keyof Target>} keys - The keys to pick
+ * @returns {Pick<Target, Key>} The new object with the specified keys picked
+ * 
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, 'a') // => { a: 1 }
+ * 
+ * @example
+ * pick({ a: 1, b: 2, c: 3 }, ['a', 'b']) // => { a: 1, b: 2 }
+ * 
+ * @since 0.0.3
+ */
+export function pick<Target extends object, Key extends keyof Target>(
+  target: Target,
+  keys: Arrayable<Key>
+): Pick<Target, Key> {
+  const result = {} as Pick<Target, Key>;
+
+  if (!target || !keys)
+    return result;
+
+  if (isArray(keys)) {
+    for (const key of keys) {
+      result[key] = target[key];
+    }
+  } else {
+    result[keys] = target[keys];
+  }
+
+  return result;
+}

packages/stdlib/src/patterns/behavioral/pubsub/index.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { PubSub } from '.';
+
+describe('pubsub', () => {
+  const event3 = Symbol('event3');
+
+  let eventBus: PubSub<{
+    event1: (arg: string) => void;
+    event2: () => void;
+    [event3]: () => void;
+  }>;
+
+  beforeEach(() => {
+    eventBus = new PubSub();
+  });
+
+  it('add a listener and emit an event', () => {
+    const listener = vi.fn();
+
+    eventBus.on('event1', listener);
+    eventBus.emit('event1', 'Hello');
+
+    expect(listener).toHaveBeenCalledWith('Hello');
+  });
+
+  it('add multiple listeners and emit an event', () => {
+    const listener1 = vi.fn();
+    const listener2 = vi.fn();
+
+    eventBus.on('event1', listener1);
+    eventBus.on('event1', listener2);
+    eventBus.emit('event1', 'Hello');
+
+    expect(listener1).toHaveBeenCalledWith('Hello');
+    expect(listener2).toHaveBeenCalledWith('Hello');
+  });
+
+  it('emit symbol event', () => {
+    const listener = vi.fn();
+
+    eventBus.on(event3, listener);
+    eventBus.emit(event3);
+
+    expect(listener).toHaveBeenCalled();
+  });
+
+  it('add a one-time listener and emit an event', () => {
+    const listener = vi.fn();
+
+    eventBus.once('event1', listener);
+    eventBus.emit('event1', 'Hello');
+    eventBus.emit('event1', 'World');
+
+    expect(listener).toHaveBeenCalledWith('Hello');
+    expect(listener).not.toHaveBeenCalledWith('World');
+  });
+
+  it('add once listener and emit multiple events', () => {
+    const listener = vi.fn();
+
+    eventBus.once('event1', listener);
+    eventBus.emit('event1', 'Hello');
+    eventBus.emit('event1', 'World');
+    eventBus.emit('event1', '!');
+
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(listener).toHaveBeenCalledWith('Hello');
+  });
+
+  it('remove a listener', () => {
+    const listener = vi.fn();
+
+    eventBus.on('event1', listener);
+    eventBus.off('event1', listener);
+    eventBus.emit('event1', 'Hello');
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it('clear all listeners for an event', () => {
+    const listener1 = vi.fn();
+    const listener2 = vi.fn();
+
+    eventBus.on('event1', listener1);
+    eventBus.on('event1', listener2);
+    eventBus.clear('event1');
+    eventBus.emit('event1', 'Hello');
+
+    expect(listener1).not.toHaveBeenCalled();
+    expect(listener2).not.toHaveBeenCalled();
+  });
+
+  it('return true when emitting an event with listeners', () => {
+    const listener = vi.fn();
+
+    eventBus.on('event1', listener);
+    const result = eventBus.emit('event1', 'Hello');
+
+    expect(result).toBe(true);
+  });
+
+  it('return false when emitting an event without listeners', () => {
+    const result = eventBus.emit('event1', 'Hello');
+
+    expect(result).toBe(false);
+  });
+
+  it('calls listener only once when the same function is registered multiple times', () => {
+    const listener = vi.fn();
+
+    eventBus.on('event1', listener);
+    eventBus.on('event1', listener);
+    eventBus.on('event1', listener);
+    eventBus.emit('event1', 'Hello');
+
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+});

packages/stdlib/src/patterns/behavioral/pubsub/index.ts

@@ -0,0 +1,117 @@
+import type { AnyFunction } from '../../../types';
+
+export type Subscriber = AnyFunction;
+export type EventsRecord = Record<string | symbol, Subscriber>;
+
+/**
+ * @name PubSub
+ * @category Patterns
+ * @description Simple PubSub implementation
+ *
+ * @since 0.0.2
+ * 
+ * @template {EventsRecord} Events
+ */
+export class PubSub<Events extends EventsRecord> {
+  /**
+   * Events map
+   * 
+   * @private
+   * @type {Map<keyof Events, Set<Events[keyof Events]>>}
+   */
+  private events: Map<keyof Events, Set<Events[keyof Events]>>;
+
+  /**
+   * Creates an instance of PubSub
+   */
+  constructor() {
+    this.events = new Map();
+  }
+
+  /**
+   * Subscribe to an event
+   * 
+   * @template {keyof Events} K
+   * @param {K} event Name of the event
+   * @param {Events[K]} listener Listener function
+   * @returns {this}
+   */
+  public on<K extends keyof Events>(event: K, listener: Events[K]) {
+    const listeners = this.events.get(event);
+
+    if (listeners)
+      listeners.add(listener);
+    else
+      this.events.set(event, new Set([listener]));
+
+    return this;
+  }
+
+  /**
+   * Unsubscribe from an event
+   * 
+   * @template {keyof Events} K
+   * @param {K} event Name of the event
+   * @param {Events[K]} listener Listener function
+   * @returns {this}
+   */
+  public off<K extends keyof Events>(event: K, listener: Events[K]) {
+    const listeners = this.events.get(event);
+
+    if (listeners)
+      listeners.delete(listener);
+
+    return this;
+  }
+
+  /**
+   * Subscribe to an event only once
+   * 
+   * @template {keyof Events} K
+   * @param {K} event Name of the event
+   * @param {Events[K]} listener Listener function
+   * @returns {this}
+   */
+  public once<K extends keyof Events>(event: K, listener: Events[K]) {
+    const onceListener = (...args: Parameters<Events[K]>) => {
+        this.off(event, onceListener as Events[K]);
+        listener(...args);
+    };
+
+    this.on(event, onceListener as Events[K]);
+
+    return this;
+  }
+
+  /**
+   * Emit an event
+   * 
+   * @template {keyof Events} K
+   * @param {K} event Name of the event
+   * @param {...Parameters<Events[K]>} args Arguments for the listener
+   * @returns {boolean}
+   */
+  public emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) {
+    const listeners = this.events.get(event);
+
+    if (!listeners)
+      return false;
+
+    listeners.forEach((listener) => listener(...args));
+
+    return true;
+  }
+
+  /**
+   * Clear all listeners for an event
+   * 
+   * @template {keyof Events} K
+   * @param {K} event Name of the event
+   * @returns {this}
+   */
+  public clear<K extends keyof Events>(event: K) {
+    this.events.delete(event);
+
+    return this;
+  }
+}

packages/stdlib/src/patterns/index.ts

@@ -0,0 +1 @@
+export * from './behavioral/pubsub';

packages/stdlib/src/structs/index.ts

@@ -0,0 +1 @@
+export * from './stack';

packages/stdlib/src/structs/stack/index.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { Stack } from '.';
+
+describe('stack', () => {
+  describe('constructor', () => {
+    it('create an empty stack if no initial values are provided', () => {
+      const stack = new Stack<number>();
+
+      expect(stack.length).toBe(0);
+      expect(stack.isEmpty).toBe(true);
+    });
+
+    it('create a stack with the provided initial values', () => {
+      const initialValues = [1, 2, 3];
+      const stack = new Stack(initialValues);
+
+      expect(stack.length).toBe(initialValues.length);
+      expect(stack.peek()).toBe(initialValues.at(-1));
+    });
+
+    it('create a stack with the provided initial value', () => {
+      const initialValue = 1;
+      const stack = new Stack(initialValue);
+
+      expect(stack.length).toBe(1);
+      expect(stack.peek()).toBe(initialValue);
+    });
+
+    it('create a stack with the provided options', () => {
+      const options = { maxSize: 5 };
+      const stack = new Stack<number>(undefined, options);
+
+      expect(stack.length).toBe(0);
+      expect(stack.isFull).toBe(false);
+    });
+  });
+
+  describe('push', () => {
+    it('push an element onto the stack', () => {
+      const stack = new Stack<number>();
+      stack.push(1);
+
+      expect(stack.length).toBe(1);
+      expect(stack.peek()).toBe(1);
+    });
+
+    it('throw an error if the stack is full', () => {
+      const options = { maxSize: 1 };
+      const stack = new Stack<number>(undefined, options);
+      stack.push(1);
+
+      expect(() => stack.push(2)).toThrow(new RangeError('Stack is full'));
+    });
+  });
+
+  describe('pop', () => {
+    it('pop an element from the stack', () => {
+      const stack = new Stack<number>([1, 2, 3]);
+      const poppedElement = stack.pop();
+
+      expect(poppedElement).toBe(3);
+      expect(stack.length).toBe(2);
+    });
+
+    it('return undefined if the stack is empty', () => {
+      const stack = new Stack<number>();
+      const poppedElement = stack.pop();
+
+      expect(poppedElement).toBeUndefined();
+    });
+  });
+
+  describe('peek', () => {
+    it('return the top element of the stack', () => {
+      const stack = new Stack<number>([1, 2, 3]);
+      const topElement = stack.peek();
+
+      expect(topElement).toBe(3);
+      expect(stack.length).toBe(3);
+    });
+
+    it('return undefined if the stack is empty', () => {
+      const stack = new Stack<number>();
+      const topElement = stack.peek();
+
+      expect(topElement).toBeUndefined();
+    });
+  });
+
+  describe('clear', () => {
+    it('clear the stack', () => {
+      const stack = new Stack<number>([1, 2, 3]);
+      stack.clear();
+
+      expect(stack.length).toBe(0);
+      expect(stack.isEmpty).toBe(true);
+    });
+  });
+
+  describe('iteration', () => {
+    it('iterate over the stack in LIFO order', () => {
+      const stack = new Stack<number>([1, 2, 3]);
+      const elements = [...stack];
+
+      expect(elements).toEqual([3, 2, 1]);
+    });
+
+    it('iterate over the stack asynchronously in LIFO order', async () => {
+      const stack = new Stack<number>([1, 2, 3]);
+      const elements: number[] = [];
+
+      for await (const element of stack) {
+        elements.push(element);
+      }
+      
+      expect(elements).toEqual([3, 2, 1]);
+    });
+  });
+});

packages/stdlib/src/structs/stack/index.ts

@@ -0,0 +1,152 @@
+import { last } from '../../arrays';
+import { isArray } from '../../types';
+
+export type StackOptions = {
+    maxSize?: number;
+};
+
+/**
+ * @name Stack
+ * @category Data Structures
+ * @description Represents a stack data structure
+ *
+ * @since 0.0.2
+ *
+ * @template T The type of elements stored in the stack
+ */
+export class Stack<T> implements Iterable<T>, AsyncIterable<T> {
+    /**
+     * The maximum number of elements that the stack can hold
+     * 
+     * @private
+     * @type {number}
+     */
+    private readonly maxSize: number;
+
+    /**
+     * The stack data structure
+     * 
+     * @private
+     * @type {T[]}
+     */
+    private readonly stack: T[];
+
+    /**
+     * Creates an instance of Stack
+     * 
+     * @param {(T[] | T)} [initialValues] The initial values to add to the stack
+     * @param {StackOptions} [options] The options for the stack
+     * @memberof Stack
+     */
+    constructor(initialValues?: T[] | T, options?: StackOptions) {
+        this.maxSize = options?.maxSize ?? Infinity;
+        this.stack = isArray(initialValues) ? initialValues : initialValues ? [initialValues] : [];
+    }
+    
+    /**
+     * Gets the number of elements in the stack
+     * @returns {number} The number of elements in the stack
+     */
+    public get length() {
+        return this.stack.length;
+    }
+
+    /**
+     * Checks if the stack is empty
+     * @returns {boolean} `true` if the stack is empty, `false` otherwise
+     */
+    public get isEmpty() {
+        return this.stack.length === 0;
+    }
+
+    /**
+     * Checks if the stack is full
+     * @returns {boolean} `true` if the stack is full, `false` otherwise
+     */
+    public get isFull() {
+        return this.stack.length === this.maxSize;
+    }
+
+    /**
+     * Pushes an element onto the stack
+     * @param {T} element The element to push onto the stack
+     * @returns {this}
+     * @throws {RangeError} If the stack is full
+     */
+    public push(element: T) {
+        if (this.isFull)
+            throw new RangeError('Stack is full');
+        
+        this.stack.push(element);
+
+        return this;
+    }
+
+    /**
+     * Pops an element from the stack
+     * @returns {T | undefined} The element popped from the stack
+     */
+    public pop() {
+        return this.stack.pop();
+    }
+
+    /**
+     * Peeks at the top element of the stack
+     * @returns {T | undefined} The top element of the stack
+     */
+    public peek() {
+        if (this.isEmpty)
+            return undefined;
+        
+        return last(this.stack);
+    }
+
+    /**
+     * Clears the stack
+     * 
+     * @returns {this}
+     */
+    public clear() {
+        this.stack.length = 0;
+
+        return this;
+    }
+
+    /**
+     * Converts the stack to an array
+     * 
+     * @returns {T[]}
+     */
+    public toArray() {
+        return this.stack.toReversed();
+    }
+
+    /**
+     * Returns a string representation of the stack
+     * 
+     * @returns {string}
+     */
+    public toString() {
+        return this.toArray().toString();
+    }
+
+    /**
+     * Returns an iterator for the stack
+     * 
+     * @returns {IterableIterator<T>}
+     */
+    public [Symbol.iterator]() {
+        return this.toArray()[Symbol.iterator]();
+    }
+
+    /**
+     * Returns an async iterator for the stack
+     * 
+     * @returns {AsyncIterableIterator<T>}
+     */
+    public async *[Symbol.asyncIterator]() {
+        for (const element of this.toArray()) {
+            yield element;
+        }
+    }
+}

packages/stdlib/src/text/index.ts

@@ -1,2 +1,4 @@
 export * from './levenshtein-distance';
 export * from './trigram-distance';
+// TODO: Template is not implemented yet
+// export * from './template';

packages/stdlib/src/text/levenshtein-distance/index.ts

@@ -1,15 +1,17 @@
 /**
- * Calculate the Levenshtein distance between two strings
+ * @name levenshteinDistance
+ * @category Text
+ * @description Calculate the Levenshtein distance between two strings
  * 
  * @param {string} left First string
  * @param {string} right Second string
  * @returns {number} The Levenshtein distance between the two strings
+ *
+ * @since 0.0.1
  */
 export function levenshteinDistance(left: string, right: string): number {
-    // If the strings are equal, the distance is 0
     if (left === right) return 0;
 
-    // If either string is empty, the distance is the length of the other string
     if (left.length === 0) return right.length;
     if (right.length === 0) return left.length;
 

packages/stdlib/src/text/template/index.test-d.ts

@@ -0,0 +1,105 @@
+import { describe, expectTypeOf, it } from 'vitest';
+import type { ClearPlaceholder, ExtractPlaceholders } from "./index";
+
+describe.skip('template', () => {
+  describe('ClearPlaceholder', () => {
+    it('ignores strings without braces', () => {
+      type actual = ClearPlaceholder<'name'>;
+      type expected = 'name';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('removes all balanced braces from placeholders', () => {
+      type actual1 = ClearPlaceholder<'{name}'>;
+      type actual2 = ClearPlaceholder<'{{name}}'>;
+      type actual3 = ClearPlaceholder<'{{{name}}}'>;
+      type expected = 'name';
+
+      expectTypeOf<actual1>().toEqualTypeOf<expected>();
+      expectTypeOf<actual2>().toEqualTypeOf<expected>();
+      expectTypeOf<actual3>().toEqualTypeOf<expected>();
+    });
+
+    it('removes all unbalanced braces from placeholders', () => {
+      type actual1 = ClearPlaceholder<'{name}}'>;
+      type actual2 = ClearPlaceholder<'{{name}}}'>;
+      type expected = 'name';
+
+      expectTypeOf<actual1>().toEqualTypeOf<expected>();
+      expectTypeOf<actual2>().toEqualTypeOf<expected>();
+    });
+  });
+
+  describe('ExtractPlaceholders', () => {
+    it('string without placeholders', () => {
+      type actual = ExtractPlaceholders<'Hello name, how are?'>;
+      type expected = never;
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with one idexed placeholder', () => {
+      type actual = ExtractPlaceholders<'Hello {0}, how are you?'>;
+      type expected = '0';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with two indexed placeholders', () => {
+      type actual = ExtractPlaceholders<'Hello {0}, my name is {1}'>;
+      type expected = '0' | '1';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with one key placeholder', () => {
+      type actual = ExtractPlaceholders<'Hello {name}, how are you?'>;
+      type expected = 'name';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with two key placeholders', () => {
+      type actual = ExtractPlaceholders<'Hello {name}, my name is {managers.0.name}'>;
+      type expected = 'name' | 'managers.0.name';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with mixed placeholders', () => {
+      type actual = ExtractPlaceholders<'Hello {0}, how are you? My name is {1.name}'>;
+      type expected = '0' | '1.name';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with nested placeholder and balanced braces', () => {
+      type actual = ExtractPlaceholders<'Hello {{name}}, how are you?'>;
+      type expected = 'name';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with nested placeholder and unbalanced braces', () => {
+      type actual = ExtractPlaceholders<'Hello {{{name}, how are you?'>;
+      type expected = 'name';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with nested placeholders and balanced braces', () => {
+      type actual = ExtractPlaceholders<'Hello {{{name}{positions}}}, how are you?'>;
+      type expected = 'name' | 'positions';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+
+    it('string with nested placeholders and unbalanced braces', () => {
+      type actual = ExtractPlaceholders<'Hello {{{name}{positions}, how are you?'>;
+      type expected = 'name' | 'positions';
+
+      expectTypeOf<actual>().toEqualTypeOf<expected>();
+    });
+  });
+});

packages/stdlib/src/text/template/index.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+import { templateObject } from '.';
+
+describe.skip('templateObject', () => {
+  it('replace template placeholders with corresponding values from args', () => {
+    const template = 'Hello, {names.0}!';
+    const args = { names: ['John'] };
+    const result = templateObject(template, args);
+    expect(result).toBe('Hello, John!');
+  });
+
+  it('replace template placeholders with corresponding values from args', () => {
+    const template = 'Hello, {name}!';
+    const args = { name: 'John' };
+    const result = templateObject(template, args);
+    expect(result).toBe('Hello, John!');
+  });
+
+  it('replace template placeholders with fallback value if corresponding value is undefined', () => {
+    const template = 'Hello, {name}!';
+    const args = { age: 25 };
+    const fallback = 'Guest';
+    const result = templateObject(template, args, fallback);
+    expect(result).toBe('Hello, Guest!');
+  });
+
+  it(' replace template placeholders with fallback value returned by fallback function if corresponding value is undefined', () => {
+    const template = 'Hello, {name}!';
+    const args = { age: 25 };
+    const fallback = (key: string) => `Unknown ${key}`;
+    const result = templateObject(template, args, fallback);
+    expect(result).toBe('Hello, Unknown name!');
+  });
+
+  it('replace template placeholders with nested values from args', () => {
+      const result = templateObject('Hello {{user.name}, your address {user.addresses.0.street}', {
+        user: {
+         name: 'John Doe',
+         addresses: [
+           { street: '123 Main St', city: 'Springfield'},
+           { street: '456 Elm St', city: 'Shelbyville'}
+         ]
+       }
+     });
+
+      expect(result).toBe('Hello {John Doe, your address 123 Main St');
+  });
+});

packages/stdlib/src/text/template/index.ts

@@ -0,0 +1,73 @@
+import { get } from '../../collections';
+import { isFunction, type Path, type PathToType, type Stringable, type Trim, type UnionToIntersection } from '../../types';
+
+/**
+ * Type of a value that will be used to replace a placeholder in a template.
+ */
+export type TemplateValue = Stringable | string;
+
+/**
+ * Type of a fallback value when a template key is not found.
+ */
+export type TemplateFallback = string | ((key: string) => string);
+
+/**
+ * Type of a template string with placeholders.
+ */
+const TEMPLATE_PLACEHOLDER = /\{\s*([^{}]+?)\s*\}/gm;
+
+/**
+ * Removes the placeholder syntax from a template string.
+ * 
+ * @example
+ * type Base = ClearPlaceholder<'{user.name}'>; // 'user.name'
+ * type Unbalanced = ClearPlaceholder<'{user.name'>; // 'user.name'
+ * type Spaces = ClearPlaceholder<'{ user.name }'>; // 'user.name'
+ */
+export type ClearPlaceholder<In extends string> =
+  In extends `${string}{${infer Template}`
+    ? ClearPlaceholder<Template>
+    : In extends `${infer Template}}${string}`
+      ? ClearPlaceholder<Template>
+      : Trim<In>;
+
+/**
+ * Extracts all placeholders from a template string.
+ * 
+ * @example
+ * type Base = ExtractPlaceholders<'Hello {user.name}, {user.addresses.0.street}'>; // 'user.name' | 'user.addresses.0.street'
+ */
+export type ExtractPlaceholders<In extends string> =
+  In extends `${infer Before}}${infer After}`
+    ? Before extends `${string}{${infer Placeholder}`
+      ? ClearPlaceholder<Placeholder> | ExtractPlaceholders<After>
+      : ExtractPlaceholders<After>
+    : never;
+
+/**
+ * Generates a type for a template string with placeholders.
+ * 
+ * @example
+ * type Base = GenerateTypes<'Hello {user.name}, your address {user.addresses.0.street}'>; // { user: { name: string; addresses: { 0: { street: string; }; }; }; }
+ * type WithTarget = GenerateTypes<'Hello {user.age}', number>; // { user: { age: number; }; }
+ */
+export type GenerateTypes<T extends string, Target = string> = UnionToIntersection<PathToType<Path<T>, Target>>;
+
+export function templateObject<
+  T extends string,
+  A extends GenerateTypes<ExtractPlaceholders<T>, TemplateValue>
+>(template: T, args: A, fallback?: TemplateFallback) {
+    return template.replace(TEMPLATE_PLACEHOLDER, (_, key) => {    
+        const value = get(args, key)?.toString();
+        return value !== undefined ? value : (isFunction(fallback) ? fallback(key) : '');
+    });
+}
+
+templateObject('Hello {user.name}, your address {user.addresses.0.city}', {
+  user: {
+    name: 'John',
+    addresses: [
+      { city: 'Kolpa' },
+    ],
+  },
+});

packages/stdlib/src/text/trigram-distance/index.ts

@@ -1,10 +1,14 @@
 export type Trigrams = Map<string, number>;
 
 /**
- * Extracts trigrams from a text and returns a map of trigram to count
+ * @name trigramProfile
+ * @category Text
+ * @description Extracts trigrams from a text and returns a map of trigram to count
  * 
  * @param {string} text The text to extract trigrams
  * @returns {Trigrams} A map of trigram to count
+ *
+ * @since 0.0.1
  */
 export function trigramProfile(text: string): Trigrams {
     text = '\n\n' + text + '\n\n';
@@ -21,13 +25,17 @@ export function trigramProfile(text: string): Trigrams {
 }
 
 /**
- * Calculates the trigram distance between two strings
+ * @name trigramDistance
+ * @category Text
+ * @description Calculates the trigram distance between two strings
  * 
  * @param {Trigrams} left First text trigram profile
  * @param {Trigrams} right Second text trigram profile
  * @returns {number} The trigram distance between the two strings
+ *
+ * @since 0.0.1
  */
-export function trigramDistance(left: Trigrams, right: Trigrams) {
+export function trigramDistance(left: Trigrams, right: Trigrams): number {
     let distance = -4;
     let total = -4;
 

packages/stdlib/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './js';
+export * from './ts';

packages/stdlib/src/types/js/casts.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { toString } from './casts';
+
+describe('casts', () => {
+  describe('toString', () => {
+    it('correct string representation of a value', () => {
+      // Primitives
+      expect(toString(true)).toBe('[object Boolean]');
+      expect(toString(() => {})).toBe('[object Function]');
+      expect(toString(5)).toBe('[object Number]');
+      expect(toString(BigInt(5))).toBe('[object BigInt]');
+      expect(toString('hello')).toBe('[object String]');
+      expect(toString(Symbol('foo'))).toBe('[object Symbol]');
+
+      // Complex
+      expect(toString([])).toBe('[object Array]');
+      expect(toString({})).toBe('[object Object]');
+      expect(toString(undefined)).toBe('[object Undefined]');
+      expect(toString(null)).toBe('[object Null]');
+      expect(toString(/abc/)).toBe('[object RegExp]');
+      expect(toString(new Date())).toBe('[object Date]');
+      expect(toString(new Error())).toBe('[object Error]');
+      expect(toString(new Promise(() => {}))).toBe('[object Promise]');
+      expect(toString(new Map())).toBe('[object Map]');
+      expect(toString(new Set())).toBe('[object Set]');
+      expect(toString(new WeakMap())).toBe('[object WeakMap]');
+      expect(toString(new WeakSet())).toBe('[object WeakSet]');
+    });
+  });
+});