@talosjs/utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Talos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,507 @@
+# @talosjs/utils
+
+General-purpose utility functions including unique ID generation with nanoid, type guards, and common helper methods.
+
+![Browser](https://img.shields.io/badge/Browser-Compatible-green?style=flat-square&logo=googlechrome)
+![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)
+![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)
+
+## Features
+
+✅ **ID Generation** - Generate unique IDs using nanoid with configurable length
+
+✅ **String Case Conversion** - Convert between camelCase, kebab-case, snake_case, and PascalCase
+
+✅ **String Utilities** - `trim`, `splitToWords`, `capitalizeWord` for common string operations
+
+✅ **Value Parsing** - `parseString` to convert string values to boolean, number, or string types
+
+✅ **Time Formatting** - `secondsToHMS`, `secondsToMS`, and `millisecondsToHMS` for duration display
+
+✅ **Number Formatting** - `formatRelativeNumber` for human-readable numbers with K, M, B suffixes
+
+✅ **Data Conversion** - `dataURLtoFile` to convert data URLs to File objects
+
+✅ **Environment Variables** - `parseEnvVars` to parse .env file content into key-value pairs
+
+✅ **Async Utilities** - `sleep` function for async/await workflows
+
+✅ **Zero Config** - Simple, pure functions with no configuration needed
+
+## Installation
+
+```bash
+bun add @talosjs/utils
+```
+
+## Usage
+
+### Unique ID Generation
+
+```typescript
+import { random } from '@talosjs/utils';
+
+// Generate a unique ID (default length: 21)
+const id = random();
+console.log(id); // "V1StGXR8_Z5jdHi6B-myT"
+
+// Generate with custom length
+const shortId = random(10);
+console.log(shortId); // "V1StGXR8_Z"
+```
+
+### String Case Conversion
+
+```typescript
+import {
+  toCamelCase,
+  toKebabCase,
+  toSnakeCase,
+  toPascalCase,
+  capitalizeWord
+} from '@talosjs/utils';
+
+// Convert to camelCase
+toCamelCase('hello world');        // "helloWorld"
+toCamelCase('hello-world');        // "helloWorld"
+toCamelCase('hello_world');        // "helloWorld"
+
+// Convert to kebab-case
+toKebabCase('helloWorld');         // "hello-world"
+toKebabCase('HelloWorld');         // "hello-world"
+toKebabCase('hello_world');        // "hello-world"
+
+// Convert to snake_case
+toSnakeCase('helloWorld');         // "hello_world"
+toSnakeCase('HelloWorld');         // "hello_world"
+toSnakeCase('hello-world');        // "hello_world"
+
+// Convert to PascalCase
+toPascalCase('hello world');       // "HelloWorld"
+toPascalCase('hello-world');       // "HelloWorld"
+toPascalCase('hello_world');       // "HelloWorld"
+
+// Capitalize first letter
+capitalizeWord('hello');           // "Hello"
+capitalizeWord('hello world');     // "Hello world"
+```
+
+### Time Formatting
+
+```typescript
+import {
+  secondsToHMS,
+  secondsToMS,
+  millisecondsToHMS
+} from '@talosjs/utils';
+
+// Seconds to Hours:Minutes:Seconds
+secondsToHMS(3661);     // "1:01:01"
+secondsToHMS(125);      // "0:02:05"
+
+// Seconds to Minutes:Seconds
+secondsToMS(125);       // "2:05"
+secondsToMS(65);        // "1:05"
+
+// Milliseconds to Hours:Minutes:Seconds
+millisecondsToHMS(3661000);  // "1:01:01"
+millisecondsToHMS(125000);   // "0:02:05"
+```
+
+### Number Formatting
+
+```typescript
+import { formatRelativeNumber } from '@talosjs/utils';
+
+// Format large numbers with suffixes
+formatRelativeNumber(1000);        // "1K"
+formatRelativeNumber(1500);        // "1.5K"
+formatRelativeNumber(1000000);     // "1M"
+formatRelativeNumber(1500000);     // "1.5M"
+formatRelativeNumber(1000000000);  // "1B"
+formatRelativeNumber(999);         // "999"
+```
+
+### Async Sleep
+
+```typescript
+import { sleep } from '@talosjs/utils';
+
+async function example() {
+  console.log('Starting...');
+  
+  // Wait for 2 seconds
+  await sleep(2000);
+  
+  console.log('2 seconds later...');
+}
+```
+
+### String Utilities
+
+```typescript
+import { trim, splitToWords, parseString } from '@talosjs/utils';
+
+// Trim whitespace and normalize
+trim('  hello   world  ');  // "hello world"
+
+// Split string into words
+splitToWords('helloWorld');    // ["hello", "World"]
+splitToWords('hello-world');   // ["hello", "world"]
+splitToWords('hello_world');   // ["hello", "world"]
+
+// Parse string values
+parseString('true');    // true (boolean)
+parseString('false');   // false (boolean)
+parseString('123');     // 123 (number)
+parseString('hello');   // "hello" (string)
+```
+
+### Data URL Conversion
+
+```typescript
+import { dataURLtoFile } from '@talosjs/utils';
+
+// Convert a data URL to a File object
+const dataUrl = 'data:image/png;base64,iVBORw0KGgo...';
+const file = dataURLtoFile(dataUrl, 'image.png');
+
+console.log(file.name); // "image.png"
+console.log(file.type); // "image/png"
+```
+
+### Environment Variable Parsing
+
+```typescript
+import { parseEnvVars } from '@talosjs/utils';
+
+// Parse environment variable content
+const envContent = `
+DATABASE_URL=postgresql://localhost:5432/mydb
+API_KEY=secret-key-123
+DEBUG=true
+PORT=3000
+`;
+
+const vars = parseEnvVars(envContent);
+// {
+//   DATABASE_URL: 'postgresql://localhost:5432/mydb',
+//   API_KEY: 'secret-key-123',
+//   DEBUG: 'true',
+//   PORT: '3000'
+// }
+```
+
+## API Reference
+
+### Functions
+
+#### `random(size?: number): string`
+
+Generates a unique ID using nanoid.
+
+**Parameters:**
+- `size` - Optional length of the ID (default: 21)
+
+**Returns:** A unique string ID
+
+**Example:**
+```typescript
+const id = random();      // "V1StGXR8_Z5jdHi6B-myT"
+const short = random(8);  // "V1StGXR8"
+```
+
+---
+
+#### `toCamelCase(str: string): string`
+
+Converts a string to camelCase.
+
+**Parameters:**
+- `str` - The input string
+
+**Returns:** camelCase formatted string
+
+---
+
+#### `toKebabCase(str: string): string`
+
+Converts a string to kebab-case.
+
+**Parameters:**
+- `str` - The input string
+
+**Returns:** kebab-case formatted string
+
+---
+
+#### `toSnakeCase(str: string): string`
+
+Converts a string to snake_case.
+
+**Parameters:**
+- `str` - The input string
+
+**Returns:** snake_case formatted string
+
+---
+
+#### `toPascalCase(str: string): string`
+
+Converts a string to PascalCase.
+
+**Parameters:**
+- `str` - The input string
+
+**Returns:** PascalCase formatted string
+
+---
+
+#### `capitalizeWord(str: string): string`
+
+Capitalizes the first letter of a string.
+
+**Parameters:**
+- `str` - The input string
+
+**Returns:** String with first letter capitalized
+
+---
+
+#### `splitToWords(str: string): string[]`
+
+Splits a string into an array of words.
+
+**Parameters:**
+- `str` - The input string (camelCase, kebab-case, snake_case, or space-separated)
+
+**Returns:** Array of words
+
+---
+
+#### `trim(str: string): string`
+
+Trims whitespace and normalizes internal spacing.
+
+**Parameters:**
+- `str` - The input string
+
+**Returns:** Trimmed and normalized string
+
+---
+
+#### `secondsToHMS(seconds: number): string`
+
+Converts seconds to H:MM:SS format.
+
+**Parameters:**
+- `seconds` - Number of seconds
+
+**Returns:** Formatted time string
+
+---
+
+#### `secondsToMS(seconds: number): string`
+
+Converts seconds to M:SS format.
+
+**Parameters:**
+- `seconds` - Number of seconds
+
+**Returns:** Formatted time string
+
+---
+
+#### `millisecondsToHMS(milliseconds: number): string`
+
+Converts milliseconds to H:MM:SS format.
+
+**Parameters:**
+- `milliseconds` - Number of milliseconds
+
+**Returns:** Formatted time string
+
+---
+
+#### `formatRelativeNumber(num: number): string`
+
+Formats a number with K, M, or B suffix.
+
+**Parameters:**
+- `num` - The number to format
+
+**Returns:** Formatted number string with suffix
+
+---
+
+#### `sleep(ms: number): Promise<void>`
+
+Pauses execution for the specified duration.
+
+**Parameters:**
+- `ms` - Duration in milliseconds
+
+**Returns:** Promise that resolves after the duration
+
+---
+
+#### `dataURLtoFile(dataUrl: string, filename: string): File`
+
+Converts a data URL to a File object.
+
+**Parameters:**
+- `dataUrl` - The data URL string
+- `filename` - Name for the resulting file
+
+**Returns:** File object
+
+---
+
+#### `parseString(value: string): string | number | boolean`
+
+Parses a string value to its appropriate type.
+
+**Parameters:**
+- `value` - The string to parse
+
+**Returns:** Parsed value (boolean, number, or string)
+
+---
+
+#### `parseEnvVars(content: string): Record<string, string>`
+
+Parses environment variable content.
+
+**Parameters:**
+- `content` - Raw environment variable content
+
+**Returns:** Object with key-value pairs
+
+## Advanced Usage
+
+### Building File Names
+
+```typescript
+import { toKebabCase, random } from '@talosjs/utils';
+
+function generateFileName(title: string, extension: string): string {
+  const slug = toKebabCase(title);
+  const uniqueId = random(8);
+  return `${slug}-${uniqueId}.${extension}`;
+}
+
+const fileName = generateFileName('My Awesome Photo', 'jpg');
+// "my-awesome-photo-V1StGXR8.jpg"
+```
+
+### Formatting Display Values
+
+```typescript
+import { formatRelativeNumber, capitalizeWord } from '@talosjs/utils';
+
+interface SocialStats {
+  followers: number;
+  likes: number;
+  views: number;
+}
+
+function formatStats(stats: SocialStats): Record<string, string> {
+  return {
+    followers: formatRelativeNumber(stats.followers),
+    likes: formatRelativeNumber(stats.likes),
+    views: formatRelativeNumber(stats.views)
+  };
+}
+
+const stats = formatStats({
+  followers: 15600,
+  likes: 1200000,
+  views: 45000
+});
+// { followers: "15.6K", likes: "1.2M", views: "45K" }
+```
+
+### Video Duration Display
+
+```typescript
+import { secondsToHMS, secondsToMS } from '@talosjs/utils';
+
+function formatDuration(seconds: number): string {
+  // Use H:MM:SS for videos over an hour, otherwise M:SS
+  return seconds >= 3600 
+    ? secondsToHMS(seconds)
+    : secondsToMS(seconds);
+}
+
+console.log(formatDuration(90));    // "1:30"
+console.log(formatDuration(3700));  // "1:01:40"
+```
+
+### Retry with Delay
+
+```typescript
+import { sleep } from '@talosjs/utils';
+
+async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3,
+  baseDelay: number = 1000
+): Promise<T> {
+  let lastError: Error;
+  
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+      const delay = baseDelay * Math.pow(2, attempt);
+      console.log(`Attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+      await sleep(delay);
+    }
+  }
+  
+  throw lastError!;
+}
+```
+
+### API Route Slug Generation
+
+```typescript
+import { toKebabCase } from '@talosjs/utils';
+
+function generateApiSlug(resourceName: string, action: string): string {
+  const resource = toKebabCase(resourceName);
+  const actionSlug = toKebabCase(action);
+  return `/api/${resource}/${actionSlug}`;
+}
+
+generateApiSlug('UserProfile', 'getById');  // "/api/user-profile/get-by-id"
+generateApiSlug('BlogPost', 'create');       // "/api/blog-post/create"
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `bun install`
+3. Run tests: `bun run test`
+4. Build the project: `bun run build`
+
+### Guidelines
+
+- Write tests for new features
+- Follow the existing code style
+- Update documentation for API changes
+- Ensure all tests pass before submitting PR
+
+---
+
+Made with ❤️ by the Talos team

package/dist/shared/chunk-0cyfbpyn.js

@@ -0,0 +1,12 @@
+// src/trim.ts
+var trim = (text, char = " ") => {
+  if ([".", "[", "]", "(", ")", "+", "*", "^", "$", "?", "/", "\\"].includes(char)) {
+    char = `\\${char}`;
+  }
+  const reg = new RegExp(`^${char}+|${char}+$`, "g");
+  return text.replace(reg, "");
+};
+
+export { trim };
+
+//# debugId=74E146E016CFD63764756E2164756E21

package/dist/shared/chunk-0cyfbpyn.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/trim.ts"],
+  "sourcesContent": [
+    "export const trim = (text: string, char = \" \"): string => {\n  if ([\".\", \"[\", \"]\", \"(\", \")\", \"+\", \"*\", \"^\", \"$\", \"?\", \"/\", \"\\\\\"].includes(char)) {\n    char = `\\\\${char}`;\n  }\n\n  const reg = new RegExp(`^${char}+|${char}+$`, \"g\");\n  return text.replace(reg, \"\");\n};\n"
+  ],
+  "mappings": ";AAAO,IAAM,OAAO,CAAC,MAAc,OAAO,QAAgB;AAAA,EACxD,IAAI,CAAC,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,EAAE,SAAS,IAAI,GAAG;AAAA,IAChF,OAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAM,MAAM,IAAI,OAAO,IAAI,SAAS,UAAU,GAAG;AAAA,EACjD,OAAO,KAAK,QAAQ,KAAK,EAAE;AAAA;",
+  "debugId": "74E146E016CFD63764756E2164756E21",
+  "names": []
+}

package/dist/shared/chunk-1bb2xts4.js

@@ -0,0 +1,41 @@
+import {
+  trim
+} from "./chunk-0cyfbpyn.js";
+
+// src/parseString.ts
+var parseString = (text) => {
+  if (/^[0-9]+$/.test(text)) {
+    return Number.parseInt(text, 10);
+  }
+  if (/^[0-9]+[.][0-9]+$/.test(text)) {
+    return Number.parseFloat(text);
+  }
+  if (/^true$/i.test(text)) {
+    return true;
+  }
+  if (/^false$/i.test(text)) {
+    return false;
+  }
+  if (/^null$/i.test(text)) {
+    return null;
+  }
+  if (/^\[/.test(text) && /]$/.test(text)) {
+    const trimmedText = trim(text, "\\[|\\]");
+    let values = trimmedText.split(/, */);
+    values = values.map((value) => parseString(value));
+    return values;
+  }
+  try {
+    const result = JSON.parse(text);
+    if (result === Number.POSITIVE_INFINITY || result === Number.NEGATIVE_INFINITY) {
+      return text;
+    }
+    return result;
+  } catch {
+    return text;
+  }
+};
+
+export { parseString };
+
+//# debugId=C944B8C7F6A7E3BA64756E2164756E21

package/dist/shared/chunk-1bb2xts4.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/parseString.ts"],
+  "sourcesContent": [
+    "import { trim } from \"./trim\";\n\nexport const parseString = <T = unknown>(text: string): T => {\n  if (/^[0-9]+$/.test(text)) {\n    return Number.parseInt(text, 10) as T;\n  }\n\n  if (/^[0-9]+[.][0-9]+$/.test(text)) {\n    return Number.parseFloat(text) as T;\n  }\n\n  if (/^true$/i.test(text)) {\n    return true as T;\n  }\n\n  if (/^false$/i.test(text)) {\n    return false as T;\n  }\n\n  if (/^null$/i.test(text)) {\n    return null as T;\n  }\n\n  if (/^\\[/.test(text) && /]$/.test(text)) {\n    const trimmedText = trim(text, \"\\\\[|\\\\]\");\n\n    let values: unknown[] = trimmedText.split(/, */);\n\n    values = values.map((value) => parseString(value as string));\n\n    return values as T;\n  }\n\n  try {\n    const result = JSON.parse(text);\n\n    if (result === Number.POSITIVE_INFINITY || result === Number.NEGATIVE_INFINITY) {\n      return text as T;\n    }\n\n    return result;\n  } catch {\n    return text as T;\n  }\n};\n"
+  ],
+  "mappings": ";;;;;AAEO,IAAM,cAAc,CAAc,SAAoB;AAAA,EAC3D,IAAI,WAAW,KAAK,IAAI,GAAG;AAAA,IACzB,OAAO,OAAO,SAAS,MAAM,EAAE;AAAA,EACjC;AAAA,EAEA,IAAI,oBAAoB,KAAK,IAAI,GAAG;AAAA,IAClC,OAAO,OAAO,WAAW,IAAI;AAAA,EAC/B;AAAA,EAEA,IAAI,UAAU,KAAK,IAAI,GAAG;AAAA,IACxB,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,WAAW,KAAK,IAAI,GAAG;AAAA,IACzB,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,UAAU,KAAK,IAAI,GAAG;AAAA,IACxB,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,MAAM,KAAK,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG;AAAA,IACvC,MAAM,cAAc,KAAK,MAAM,SAAS;AAAA,IAExC,IAAI,SAAoB,YAAY,MAAM,KAAK;AAAA,IAE/C,SAAS,OAAO,IAAI,CAAC,UAAU,YAAY,KAAe,CAAC;AAAA,IAE3D,OAAO;AAAA,EACT;AAAA,EAEA,IAAI;AAAA,IACF,MAAM,SAAS,KAAK,MAAM,IAAI;AAAA,IAE9B,IAAI,WAAW,OAAO,qBAAqB,WAAW,OAAO,mBAAmB;AAAA,MAC9E,OAAO;AAAA,IACT;AAAA,IAEA,OAAO;AAAA,IACP,MAAM;AAAA,IACN,OAAO;AAAA;AAAA;",
+  "debugId": "C944B8C7F6A7E3BA64756E2164756E21",
+  "names": []
+}

package/dist/shared/chunk-8vzcyn6r.js

@@ -0,0 +1,6 @@
+// src/capitalize.ts
+var capitalize = (word) => word ? word[0]?.toUpperCase() + word.slice(1).toLowerCase() : word;
+
+export { capitalize };
+
+//# debugId=C6F0AA69E342290364756E2164756E21

package/dist/shared/chunk-8vzcyn6r.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/capitalize.ts"],
+  "sourcesContent": [
+    "export const capitalize = (word: string): string =>\n  word ? word[0]?.toUpperCase() + word.slice(1).toLowerCase() : word;\n"
+  ],
+  "mappings": ";AAAO,IAAM,aAAa,CAAC,SACzB,OAAO,KAAK,IAAI,YAAY,IAAI,KAAK,MAAM,CAAC,EAAE,YAAY,IAAI;",
+  "debugId": "C6F0AA69E342290364756E2164756E21",
+  "names": []
+}

package/dist/shared/chunk-bxbywxsz.js

@@ -0,0 +1,17 @@
+import {
+  splitToWords
+} from "./chunk-m001sqs5.js";
+import {
+  capitalize
+} from "./chunk-8vzcyn6r.js";
+
+// src/toCamelCase.ts
+var toCamelCase = (input) => {
+  input = input.trim();
+  const [first = "", ...rest] = splitToWords(input);
+  return [first.toLowerCase(), ...rest.map(capitalize)].join("");
+};
+
+export { toCamelCase };
+
+//# debugId=C8508DAA4F5D5DA764756E2164756E21

package/dist/shared/chunk-bxbywxsz.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/toCamelCase.ts"],
+  "sourcesContent": [
+    "import { capitalize } from \"./capitalize\";\nimport { splitToWords } from \"./splitToWords\";\n\nexport const toCamelCase = (input: string): string => {\n  input = input.trim();\n  const [first = \"\", ...rest] = splitToWords(input);\n  return [first.toLowerCase(), ...rest.map(capitalize)].join(\"\");\n};\n"
+  ],
+  "mappings": ";;;;;;;;AAGO,IAAM,cAAc,CAAC,UAA0B;AAAA,EACpD,QAAQ,MAAM,KAAK;AAAA,EACnB,OAAO,QAAQ,OAAO,QAAQ,aAAa,KAAK;AAAA,EAChD,OAAO,CAAC,MAAM,YAAY,GAAG,GAAG,KAAK,IAAI,UAAU,CAAC,EAAE,KAAK,EAAE;AAAA;",
+  "debugId": "C8508DAA4F5D5DA764756E2164756E21",
+  "names": []
+}

package/dist/shared/chunk-m001sqs5.js

@@ -0,0 +1,15 @@
+// src/splitToWords.ts
+var CAPITALIZED_WORD_WITH_DIGITS_REGEXP = /\p{Lu}\p{Ll}+\p{N}+/u;
+var CAPITALIZED_WORD_REGEXP = /\p{Lu}\p{Ll}+/u;
+var ACRONYM_WITH_DIGITS_REGEXP = /\p{Lu}+\p{N}+/u;
+var ACRONYM_REGEXP = /\p{Lu}+(?=(\p{Lu}\p{Ll})|\P{L}|\b)/u;
+var LOWERCASED_WORD_WITH_DIGITS_REGEXP = /\p{Ll}+\p{N}+/u;
+var LOWERCASED_WORD_REGEXP = /(\p{Ll}+)/u;
+var ANY_LETTERS = /\p{L}+/u;
+var DIGITS_REGEXP = /\p{N}+/u;
+var WORD_OR_NUMBER_REGEXP = new RegExp(`${CAPITALIZED_WORD_WITH_DIGITS_REGEXP.source}|${CAPITALIZED_WORD_REGEXP.source}|${ACRONYM_WITH_DIGITS_REGEXP.source}|${ACRONYM_REGEXP.source}|${LOWERCASED_WORD_WITH_DIGITS_REGEXP.source}|${LOWERCASED_WORD_REGEXP.source}|${ANY_LETTERS.source}|${DIGITS_REGEXP.source}`, "gu");
+var splitToWords = (input) => input.match(WORD_OR_NUMBER_REGEXP) ?? [];
+
+export { splitToWords };
+
+//# debugId=149E83B9717308EC64756E2164756E21

package/dist/shared/chunk-m001sqs5.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["src/splitToWords.ts"],
+  "sourcesContent": [
+    "const CAPITALIZED_WORD_WITH_DIGITS_REGEXP = /\\p{Lu}\\p{Ll}+\\p{N}+/u; // e.g. Apple123\nconst CAPITALIZED_WORD_REGEXP = /\\p{Lu}\\p{Ll}+/u; // e.g. Apple\nconst ACRONYM_WITH_DIGITS_REGEXP = /\\p{Lu}+\\p{N}+/u; // e.g. ID1, URL2\nconst ACRONYM_REGEXP = /\\p{Lu}+(?=(\\p{Lu}\\p{Ll})|\\P{L}|\\b)/u; // e.g. ID, URL, handles an acronym followed by a capitalized word e.g. HTMLElement\nconst LOWERCASED_WORD_WITH_DIGITS_REGEXP = /\\p{Ll}+\\p{N}+/u; // e.g. v1, abc123\nconst LOWERCASED_WORD_REGEXP = /(\\p{Ll}+)/u; // e.g. apple\nconst ANY_LETTERS = /\\p{L}+/u; // will match any sequence of letters, including in languages without a concept of upper/lower case\nconst DIGITS_REGEXP = /\\p{N}+/u; // e.g. 123\n\nconst WORD_OR_NUMBER_REGEXP = new RegExp(\n  `${CAPITALIZED_WORD_WITH_DIGITS_REGEXP.source}|${CAPITALIZED_WORD_REGEXP.source}|${ACRONYM_WITH_DIGITS_REGEXP.source}|${ACRONYM_REGEXP.source}|${LOWERCASED_WORD_WITH_DIGITS_REGEXP.source}|${LOWERCASED_WORD_REGEXP.source}|${ANY_LETTERS.source}|${DIGITS_REGEXP.source}`,\n  \"gu\",\n);\n\nexport const splitToWords = (input: string): string[] => input.match(WORD_OR_NUMBER_REGEXP) ?? [];\n"
+  ],
+  "mappings": ";AAAA,IAAM,sCAAsC;AAC5C,IAAM,0BAA0B;AAChC,IAAM,6BAA6B;AACnC,IAAM,iBAAiB;AACvB,IAAM,qCAAqC;AAC3C,IAAM,yBAAyB;AAC/B,IAAM,cAAc;AACpB,IAAM,gBAAgB;AAEtB,IAAM,wBAAwB,IAAI,OAChC,GAAG,oCAAoC,UAAU,wBAAwB,UAAU,2BAA2B,UAAU,eAAe,UAAU,mCAAmC,UAAU,uBAAuB,UAAU,YAAY,UAAU,cAAc,UACnQ,IACF;AAEO,IAAM,eAAe,CAAC,UAA4B,MAAM,MAAM,qBAAqB,KAAK,CAAC;",
+  "debugId": "149E83B9717308EC64756E2164756E21",
+  "names": []
+}

package/dist/src/capitalize.d.ts

@@ -0,0 +1,2 @@
+declare const capitalize: (word: string) => string;
+export { capitalize };