@regardio/js 0.4.2 → 0.5.0

package/README.md

@@ -3,7 +3,7 @@
 > **TypeScript utilities for Regardio applications**
 
 A collection of lightweight, tree-shakeable utility functions for common tasks
-like HTTP handling, internationalization, time formatting, and validation.
+like text manipulation, HTTP handling, internationalization, time formatting, and validation.
 
 ## ⚠️ Pre-release Notice
 
@@ -18,7 +18,7 @@ like HTTP handling, internationalization, time formatting, and validation.
 We created `@regardio/js` to:
 
 - **Share battle-tested utilities** — These functions power real Regardio projects and have been refined through actual use
-- **Reduce boilerplate** — Common patterns like cookie handling, language detection, and time formatting in one place
+- **Reduce boilerplate** — Common patterns like text formatting, cookie handling, language detection, and time formatting in one place
 - **Stay framework-agnostic** — Works with any JavaScript/TypeScript project (React, Node, Deno, etc.)
 - **Enable tree-shaking** — Import only what you need; unused utilities won't bloat your bundle
 
@@ -28,92 +28,71 @@ We created `@regardio/js` to:
 pnpm add @regardio/js
 ```
 
-## Documentation
-
-See the [docs](./docs) folder for detailed documentation on each module.
-
 ## Modules
 
-### async/delay
+### @regardio/js/text
 
-Promise-based delay utility.
+String manipulation and formatting utilities.
 
 ```ts
-import { delay } from '@regardio/js/async/delay';
-
-await delay(1000); // Wait 1 second
-```
-
-### browser/base64
-
-URL-safe base64 to Uint8Array conversion (useful for Web Push).
-
-```ts
-import { urlBase64ToUint8Array } from '@regardio/js/browser/base64';
-
-const bytes = urlBase64ToUint8Array(vapidPublicKey);
-```
-
-### format/bytes
-
-Human-readable byte formatting.
-
-```ts
-import { formatBytes } from '@regardio/js/format/bytes';
-
+import {
+  typographicQuotes,
+  truncateText,
+  splitIntoSentences,
+  formatBytes,
+  parseAuthorString,
+} from '@regardio/js/text';
+
+typographicQuotes('"Hello"', 'de'); // „Hello"
+truncateText('Hello world', 8); // "Hello..."
 formatBytes(1500000); // "1.5 MB"
+parseAuthorString('John <john@example.com>'); // { name: 'John', email: 'john@example.com' }
 ```
 
-### format/measure
+### @regardio/js/time
 
-Performance measurement with logging.
+Date, time, and async utilities.
 
 ```ts
-import { measure } from '@regardio/js/format/measure';
+import {
+  timeAgo,
+  friendlyDuration,
+  oneWeekFromNow,
+  delay,
+  measure,
+} from '@regardio/js/time';
 
-const result = await measure('fetchData', async () => {
-  return await fetch('/api/data');
-});
-// Logs: "fetchData took 123ms"
+timeAgo(new Date('2024-01-01')); // "3 months ago"
+friendlyDuration(150, 'en', true); // { key: 'common:duration.hoursAndMinutesShort', vars: {...} }
+await delay(1000); // Wait 1 second
+await measure('fetchData', () => fetch('/api')); // Logs timing
 ```
 
-### http/cookie
+### @regardio/js/http
 
-Browser cookie get/set helpers.
+HTTP, cookie, and routing utilities.
 
 ```ts
-import { getCookieValue, setCookieValue } from '@regardio/js/http/cookie';
+import {
+  getCookieValue,
+  setCookieValue,
+  createDomain,
+  getCleanUrl,
+  isRouteActive,
+} from '@regardio/js/http';
 
 setCookieValue('theme', 'dark', { path: '/', secure: true });
 const theme = getCookieValue('theme');
-```
-
-### http/domain
-
-Domain extraction from requests (proxy-aware).
-
-```ts
-import { createDomain } from '@regardio/js/http/domain';
-
 const domain = createDomain(request); // "https://example.com"
+isRouteActive('/account', '/account/settings', false); // true
 ```
 
-### http/request-helpers
+### @regardio/js/intl
 
-URL cleaning utilities.
+Server-side language detection for i18n.
 
 ```ts
-import { getCleanUrl } from '@regardio/js/http/request-helpers';
-
-getCleanUrl(request); // URL without search params
-```
-
-### intl/language-detector
-
-Server-side language detection for i18n (works with Lingui).
-
-```ts
-import { LanguageDetector } from '@regardio/js/intl/language-detector';
+import { LanguageDetector } from '@regardio/js/intl';
 
 const detector = new LanguageDetector({
   supportedLanguages: ['en', 'de'],
@@ -123,66 +102,38 @@ const detector = new LanguageDetector({
 const locale = await detector.detect(request);
 ```
 
-### intl/locale
+### @regardio/js/assert
 
-Client locale extraction from Accept-Language header.
+Runtime assertion and validation utilities.
 
 ```ts
-import { getClientLocales } from '@regardio/js/intl/locale';
-
-const locales = getClientLocales(request); // ['en-US', 'de']
-```
-
-### time/time
-
-Time formatting utilities.
-
-```ts
-import { timeAgo, friendlyDuration, oneWeekFromNow } from '@regardio/js/time/time';
-
-timeAgo(new Date('2024-01-01')); // "3 months ago"
-friendlyDuration(150, 'en', true); // { key: 'common:duration.hoursAndMinutesShort', vars: {...} }
-const expires = oneWeekFromNow();
-```
-
-### validation/invariant
-
-Runtime assertion utilities.
-
-```ts
-import { invariant, invariantResponse } from '@regardio/js/validation/invariant';
+import { invariant, invariantResponse, verifyAccept } from '@regardio/js/assert';
 
 invariant(user, 'User not found'); // Throws Error if falsy
-invariantResponse(user, 'User not found', { status: 404 }); // Throws Response if falsy
+invariantResponse(user, 'User not found', { status: 404 }); // Throws Response
+verifyAccept('image/png', 'image/*'); // true
 ```
 
-### validation/verify-file-accept
+### @regardio/js/encoding
 
-MIME type validation for file uploads.
+Binary encoding utilities.
 
 ```ts
-import { verifyAccept } from '@regardio/js/validation/verify-file-accept';
+import { urlBase64ToUint8Array } from '@regardio/js/encoding';
 
-verifyAccept('image/png', 'image/*'); // true
-verifyAccept('video/mp4', 'image/*'); // false
+const bytes = urlBase64ToUint8Array(vapidPublicKey);
 ```
 
 ## Module Overview
 
 | Module | Description |
 |--------|-------------|
-| `async/delay` | Promise-based delay utility |
-| `browser/base64` | URL-safe base64 to Uint8Array conversion |
-| `format/bytes` | Human-readable byte formatting |
-| `format/measure` | Performance measurement with logging |
-| `http/cookie` | Browser cookie get/set helpers |
-| `http/domain` | Domain extraction from requests (proxy-aware) |
-| `http/request-helpers` | URL cleaning utilities |
-| `intl/language-detector` | Server-side language detection for i18n |
-| `intl/locale` | Client locale extraction from headers |
-| `time/time` | Time formatting and date utilities |
-| `validation/invariant` | Runtime assertion utilities |
-| `validation/verify-file-accept` | MIME type validation for file uploads |
+| `@regardio/js/text` | String manipulation, formatting, author parsing |
+| `@regardio/js/time` | Time formatting, delays, performance measurement |
+| `@regardio/js/http` | Cookies, domain extraction, route matching |
+| `@regardio/js/intl` | Server-side language detection for i18n |
+| `@regardio/js/assert` | Runtime assertions and MIME validation |
+| `@regardio/js/encoding` | Base64 and binary conversions |
 
 ## Contributing
 

package/dist/{validation/invariant.d.ts → assert/index.d.ts}

@@ -31,4 +31,13 @@ declare function invariant(condition: unknown, message: string | (() => string))
  */
 declare function invariantResponse(condition: unknown, message: string | (() => string), responseInit?: ResponseInit): asserts condition;
 
-export { invariant, invariantResponse };
+/**
+ * Check if a mime type matches the set given in accept
+ *
+ * @param type the mime type to test, ex image/png
+ * @param accept the mime types to accept, ex audio/*,video/*,image/png
+ * @returns true if the mime is accepted, false otherwise
+ */
+declare function verifyAccept(type: string, accept: string): boolean;
+
+export { invariant, invariantResponse, verifyAccept };

package/dist/{validation/invariant.js → assert/index.js}

@@ -1,4 +1,4 @@
-// src/validation/invariant.ts
+// src/assert/invariant.ts
 function invariant(condition, message) {
   if (!condition) {
     throw new Error(typeof message === "function" ? message() : message);
@@ -13,4 +13,10 @@ function invariantResponse(condition, message, responseInit) {
   }
 }
 
-export { invariant, invariantResponse };
+// src/assert/verify-file-accept.ts
+function verifyAccept(type, accept) {
+  const allowed = accept.split(",").map((x) => x.trim());
+  return allowed.includes(type) || allowed.includes(`${type.split("/")[0]}/*`);
+}
+
+export { invariant, invariantResponse, verifyAccept };

package/dist/{browser/base64.js → encoding/index.js}

@@ -1,4 +1,4 @@
-// src/browser/base64.ts
+// src/encoding/base64.ts
 var urlBase64ToUint8Array = (base64String) => {
   const padding = "=".repeat((4 - base64String.length % 4) % 4);
   const base64 = (base64String + padding).replace(/-/g, "+").replace(/_/g, "/");

package/dist/http/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Helper function to set cookies in a more controlled way
+ * @param name - The name of the cookie
+ * @param value - The value to set
+ * @param options - Cookie options
+ */
+declare function setCookieValue(name: string, value: string, options?: {
+    expires?: Date;
+    path?: string;
+    sameSite?: string;
+    secure?: boolean;
+    domain?: string;
+}): void;
+/**
+ * Get a cookie value by name
+ * @param name - The name of the cookie to get
+ * @returns The cookie value or null if not found
+ */
+declare function getCookieValue(name: string): string | null;
+
+/**
+ * Helper utility used to extract the domain from the request even if it's
+ * behind a proxy. This is useful for sitemaps and other things.
+ * @param request Request object
+ * @returns Current domain
+ */
+declare const createDomain: (request: Request) => string;
+
+/**
+ * @name isRouteActive
+ * @description A function to check if a route is active. This is used to
+ * @param end
+ * @param path
+ * @param currentPath
+ */
+declare function isRouteActive(path: string, currentPath: string, end?: boolean | ((path: string) => boolean) | undefined): boolean;
+/**
+ * @name checkIfRouteIsActive
+ * @description A function to check if a route is active. This is used to
+ * highlight the active link in the navigation.
+ * @param targetLink - The link to check against
+ * @param currentRoute - the current route
+ * @param depth - how far down should segments be matched?
+ */
+declare function checkIfRouteIsActive(targetLink: string, currentRoute: string, depth?: number): boolean;
+
+declare function getCleanUrl(request: Request): string;
+
+export { checkIfRouteIsActive, createDomain, getCleanUrl, getCookieValue, isRouteActive, setCookieValue };

package/dist/http/index.js

@@ -0,0 +1,126 @@
+// src/http/cookie.ts
+function setCookieValue(name, value, options = {}) {
+  if (typeof window === "undefined") {
+    console.warn("Cannot set cookie on server side");
+    return;
+  }
+  let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (options.expires) {
+    cookieString += `; expires=${options.expires.toUTCString()}`;
+  }
+  if (options.path) {
+    cookieString += `; path=${options.path}`;
+  }
+  if (options.sameSite) {
+    cookieString += `; SameSite=${options.sameSite}`;
+  }
+  if (options.secure) {
+    cookieString += "; Secure";
+  }
+  if (options.domain) {
+    cookieString += `; domain=${options.domain}`;
+  }
+  try {
+    document.cookie = cookieString;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Failed to set cookie '${name}':`, error.message);
+    } else {
+      console.error(`Failed to set cookie '${name}': Unknown error`);
+    }
+  }
+}
+function getCookieValue(name) {
+  if (typeof window === "undefined") {
+    console.warn("Cannot get cookie on server side");
+    return null;
+  }
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) {
+    const cookieValue = parts.pop()?.split(";").shift();
+    return cookieValue ? decodeURIComponent(cookieValue) : null;
+  }
+  return null;
+}
+
+// src/http/domain.ts
+var createDomain = (request) => {
+  const headers = request.headers;
+  const maybeProto = headers.get("x-forwarded-proto");
+  const maybeHost = headers.get("host");
+  const url = new URL(request.url);
+  if (maybeProto) {
+    return `${maybeProto}://${maybeHost ?? url.host}`;
+  }
+  if (url.hostname === "localhost") {
+    return `http://${url.host}`;
+  }
+  return `https://${url.host}`;
+};
+
+// src/http/is-route-active.ts
+var ROOT_PATH = "/";
+function isRouteActive(path, currentPath, end) {
+  if (path === currentPath) {
+    return true;
+  }
+  if (typeof end === "function") {
+    return !end(currentPath);
+  }
+  const defaultEnd = end ?? true;
+  const oneLevelDeep = 1;
+  const threeLevelsDeep = 3;
+  const depth = defaultEnd ? oneLevelDeep : threeLevelsDeep;
+  return checkIfRouteIsActive(path, currentPath, depth);
+}
+function checkIfRouteIsActive(targetLink, currentRoute, depth = 1) {
+  const currentRoutePath = currentRoute.split("?")[0] ?? "";
+  if (!isRoot(currentRoutePath) && isRoot(targetLink)) {
+    return false;
+  }
+  if (!currentRoutePath.includes(targetLink)) {
+    return false;
+  }
+  const isSameRoute = targetLink === currentRoutePath;
+  if (isSameRoute) {
+    return true;
+  }
+  return hasMatchingSegments(targetLink, currentRoutePath, depth);
+}
+function splitIntoSegments(href) {
+  return href.split("/").filter(Boolean);
+}
+function hasMatchingSegments(targetLink, currentRoute, depth) {
+  const segments = splitIntoSegments(targetLink);
+  const matchingSegments = numberOfMatchingSegments(currentRoute, segments);
+  if (targetLink === currentRoute) {
+    return true;
+  }
+  return matchingSegments > segments.length - (depth - 1);
+}
+function numberOfMatchingSegments(href, segments) {
+  let count = 0;
+  for (const segment of splitIntoSegments(href)) {
+    if (segments.includes(segment)) {
+      count += 1;
+    } else {
+      return count;
+    }
+  }
+  return count;
+}
+function isRoot(path) {
+  return path === ROOT_PATH;
+}
+
+// src/http/request-helpers.ts
+function getCleanUrl(request) {
+  const url = new URL(request.url);
+  url.searchParams.forEach((_, key) => {
+    url.searchParams.delete(key);
+  });
+  return url.toString();
+}
+
+export { checkIfRouteIsActive, createDomain, getCleanUrl, getCookieValue, isRouteActive, setCookieValue };

package/dist/text/index.d.ts

@@ -0,0 +1,46 @@
+declare function formatBytes(bytes: number, decimals?: number): string;
+
+/**
+ * Replace straight quotes with typographically correct quotes for the given locale.
+ *
+ * @param text - The text containing straight quotes
+ * @param locale - The locale to use for quote style (e.g., 'en', 'de', 'fr')
+ * @returns Text with typographic quotes
+ *
+ * @example
+ * typographicQuotes('"Hello"', 'en') // → '"Hello"'
+ * typographicQuotes('"Hello"', 'de') // → '„Hello"'
+ * typographicQuotes('"Hello"', 'fr') // → '« Hello »'
+ */
+declare function typographicQuotes(text: string, locale: string): string;
+declare function toBoolean(value: string | boolean | null | undefined): boolean;
+/**
+ * Replace ­ HTML entity with Unicode soft hyphen
+ */
+declare function replaceShyInString(input: string): string;
+/**
+ * Split text into sentences
+ */
+declare function splitIntoSentences(text: string): string[];
+/**
+ * Split text into words
+ */
+declare function splitIntoWords(text: string): string[];
+/**
+ * Truncate text to a maximum length
+ */
+declare function truncateText(text: string, maxLength: number, suffix?: string): string;
+/**
+ * Author info parsed from a string like "Name <email> (url)"
+ */
+type AuthorInfo = {
+    name?: string;
+    email?: string;
+    url?: string;
+};
+/**
+ * Parse an author string in the format "Name <email> (url)"
+ */
+declare function parseAuthorString(input: string): AuthorInfo;
+
+export { type AuthorInfo, formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };

package/dist/text/index.js

@@ -0,0 +1,109 @@
+// src/text/bytes.ts
+function formatBytes(bytes, decimals = 2) {
+  if (!+bytes) {
+    return "0 Bytes";
+  }
+  const k = 1e3;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}
+
+// src/text/text.ts
+var quoteStyles = {
+  cs: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
+  // Danish, Norwegian - » « › ‹
+  da: { close: "\xAB", closeSingle: "\u203A", open: "\xBB", openSingle: "\u2039" },
+  // German (Germany, Austria) - „ " ‚ '
+  de: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
+  // German (Switzerland) - « » ‹ ›
+  "de-ch": { close: "\xBB", closeSingle: "\u203A", open: "\xAB", openSingle: "\u2039" },
+  // English (US, UK, etc.) - " " ' '
+  en: { close: "\u201D", closeSingle: "\u2019", open: "\u201C", openSingle: "\u2018" },
+  // Spanish, Italian, Portuguese - « » " "
+  es: { close: "\xBB", closeSingle: "\u201D", open: "\xAB", openSingle: "\u201C" },
+  fi: { close: "\u201D", closeSingle: "\u2019", open: "\u201D", openSingle: "\u2019" },
+  // French - « » ‹ › (with spaces)
+  fr: { close: " \xBB", closeSingle: " \u203A", open: "\xAB ", openSingle: "\u2039 " },
+  hu: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
+  it: { close: "\xBB", closeSingle: "\u201D", open: "\xAB", openSingle: "\u201C" },
+  // Japanese - 「 」 『 』
+  ja: { close: "\u300D", closeSingle: "\u300F", open: "\u300C", openSingle: "\u300E" },
+  // Dutch - ' ' ' '
+  nl: { close: "\u2019", closeSingle: "\u2019", open: "\u2018", openSingle: "\u2018" },
+  no: { close: "\xAB", closeSingle: "\u203A", open: "\xBB", openSingle: "\u2039" },
+  // Polish, Czech, Hungarian - „ " ‚ '
+  pl: { close: "\u201D", closeSingle: "\u2019", open: "\u201E", openSingle: "\u201A" },
+  pt: { close: "\xBB", closeSingle: "\u201D", open: "\xAB", openSingle: "\u201C" },
+  // Russian - « » ‚ '
+  ru: { close: "\xBB", closeSingle: "\u2019", open: "\xAB", openSingle: "\u201A" },
+  // Swedish, Finnish - " " ' '
+  sv: { close: "\u201D", closeSingle: "\u2019", open: "\u201D", openSingle: "\u2019" },
+  // Chinese - 「 」 『 』
+  zh: { close: "\u300D", closeSingle: "\u300F", open: "\u300C", openSingle: "\u300E" }
+};
+function getQuoteStyle(locale) {
+  const normalized = locale.toLowerCase();
+  const exactMatch = quoteStyles[normalized];
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const baseLanguage = normalized.split("-")[0];
+  if (baseLanguage) {
+    const baseMatch = quoteStyles[baseLanguage];
+    if (baseMatch) {
+      return baseMatch;
+    }
+  }
+  return quoteStyles.en;
+}
+function typographicQuotes(text, locale) {
+  const style = getQuoteStyle(locale);
+  let result = text.replace(/"([^"]*)"/g, `${style.open}$1${style.close}`);
+  result = result.replace(/'([^']*)'/g, `${style.openSingle}$1${style.closeSingle}`);
+  return result;
+}
+function toBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  return value === "true" || value === "1";
+}
+function replaceShyInString(input) {
+  return input.replace(/&shy;/g, "\xAD");
+}
+function splitIntoSentences(text) {
+  return text.split(/(?<=[.!?])\s+/);
+}
+function splitIntoWords(text) {
+  return text.split(/\s+/);
+}
+function truncateText(text, maxLength, suffix = "...") {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - suffix.length) + suffix;
+}
+var authorRegex = /^(.*?)\s*(?:<([^>]+)>)?\s*(?:\(([^)]+)\))?$/;
+function parseAuthorString(input) {
+  const match = input.match(authorRegex);
+  if (match) {
+    const [, name, email, url] = match;
+    const result = {};
+    if (email) {
+      result.email = email;
+    }
+    const trimmedName = name?.trim();
+    if (trimmedName) {
+      result.name = trimmedName;
+    }
+    if (url) {
+      result.url = url;
+    }
+    return result;
+  }
+  return {};
+}
+
+export { formatBytes, parseAuthorString, replaceShyInString, splitIntoSentences, splitIntoWords, toBoolean, truncateText, typographicQuotes };

package/dist/time/{time.d.ts → index.d.ts}

@@ -1,3 +1,11 @@
+/** Delays using a promise
+ * @param ms Milisecods of delay
+ * @return Promise
+ */
+declare function delay(ms: number): Promise<unknown>;
+
+declare function measure<Result>(key: string, callback: () => Result | Promise<Result>): Promise<Result>;
+
 declare function timeAgo(input: Date | string): string;
 declare const oneWeekFromNow: () => Date;
 declare const oneDayFromNow: () => Date;
@@ -37,4 +45,4 @@ declare function friendlyDuration(minutes: number | null, locale: string, short?
 } | null;
 declare const dateTimeInUnix: (date: number) => number;
 
-export { dateTimeInUnix, friendlyDuration, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };
+export { dateTimeInUnix, delay, friendlyDuration, measure, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };

package/dist/time/{time.js → index.js}

@@ -1,3 +1,25 @@
+// src/time/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    return setTimeout(resolve, ms);
+  });
+}
+
+// src/time/measure.ts
+async function measure(key, callback) {
+  const start = Date.now();
+  try {
+    let result = callback();
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    return result;
+  } finally {
+    const end = Date.now();
+    console.log(`${key} took ${end - start}ms`);
+  }
+}
+
 // src/time/time.ts
 function timeAgo(input) {
   const date = new Date(input);
@@ -132,4 +154,4 @@ var dateTimeInUnix = (date) => {
   return Math.floor(date / 1e3);
 };
 
-export { dateTimeInUnix, friendlyDuration, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };
+export { dateTimeInUnix, delay, friendlyDuration, measure, oneDayFromNow, oneMinuteFromNow, oneWeekFromNow, timeAgo };

package/package.json

@@ -10,56 +10,36 @@
   },
   "description": "Regardio JavaScript utilities",
   "devDependencies": {
-    "@regardio/dev": "1.10.1",
+    "@regardio/dev": "1.10.2",
     "@total-typescript/ts-reset": "0.6.1",
     "@types/node": "25.0.3",
     "tsup": "8.5.1",
     "vitest": "4.0.16"
   },
   "exports": {
-    "./async/delay": {
-      "import": "./dist/async/delay.js",
-      "types": "./dist/async/delay.d.ts"
+    "./assert": {
+      "import": "./dist/assert/index.js",
+      "types": "./dist/assert/index.d.ts"
     },
-    "./browser/base64": {
-      "import": "./dist/browser/base64.js",
-      "types": "./dist/browser/base64.d.ts"
+    "./encoding": {
+      "import": "./dist/encoding/index.js",
+      "types": "./dist/encoding/index.d.ts"
     },
-    "./format/bytes": {
-      "import": "./dist/format/bytes.js",
-      "types": "./dist/format/bytes.d.ts"
+    "./http": {
+      "import": "./dist/http/index.js",
+      "types": "./dist/http/index.d.ts"
     },
-    "./format/measure": {
-      "import": "./dist/format/measure.js",
-      "types": "./dist/format/measure.d.ts"
+    "./intl": {
+      "import": "./dist/intl/index.js",
+      "types": "./dist/intl/index.d.ts"
     },
-    "./http/cookie": {
-      "import": "./dist/http/cookie.js",
-      "types": "./dist/http/cookie.d.ts"
+    "./text": {
+      "import": "./dist/text/index.js",
+      "types": "./dist/text/index.d.ts"
     },
-    "./http/domain": {
-      "import": "./dist/http/domain.js",
-      "types": "./dist/http/domain.d.ts"
-    },
-    "./http/request-helpers": {
-      "import": "./dist/http/request-helpers.js",
-      "types": "./dist/http/request-helpers.d.ts"
-    },
-    "./intl/language-detector": {
-      "import": "./dist/intl/language-detector.js",
-      "types": "./dist/intl/language-detector.d.ts"
-    },
-    "./time/time": {
-      "import": "./dist/time/time.js",
-      "types": "./dist/time/time.d.ts"
-    },
-    "./validation/invariant": {
-      "import": "./dist/validation/invariant.js",
-      "types": "./dist/validation/invariant.d.ts"
-    },
-    "./validation/verify-file-accept": {
-      "import": "./dist/validation/verify-file-accept.js",
-      "types": "./dist/validation/verify-file-accept.d.ts"
+    "./time": {
+      "import": "./dist/time/index.js",
+      "types": "./dist/time/index.d.ts"
     }
   },
   "files": ["dist"],
@@ -105,5 +85,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.4.2"
+  "version": "0.5.0"
 }

package/dist/async/delay.d.ts

@@ -1,7 +0,0 @@
-/** Delays using a promise
- * @param ms Milisecods of delay
- * @return Promise
- */
-declare function delay(ms: number): Promise<unknown>;
-
-export { delay };

package/dist/async/delay.js

@@ -1,8 +0,0 @@
-// src/async/delay.ts
-function delay(ms) {
-  return new Promise((resolve) => {
-    return setTimeout(resolve, ms);
-  });
-}
-
-export { delay };

package/dist/format/bytes.d.ts

@@ -1,3 +0,0 @@
-declare function formatBytes(bytes: number, decimals?: number): string;
-
-export { formatBytes };

package/dist/format/bytes.js

@@ -1,13 +0,0 @@
-// src/format/bytes.ts
-function formatBytes(bytes, decimals = 2) {
-  if (!+bytes) {
-    return "0 Bytes";
-  }
-  const k = 1e3;
-  const dm = decimals < 0 ? 0 : decimals;
-  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
-}
-
-export { formatBytes };

package/dist/format/measure.d.ts

@@ -1,3 +0,0 @@
-declare function measure<Result>(key: string, callback: () => Result | Promise<Result>): Promise<Result>;
-
-export { measure };

package/dist/format/measure.js

@@ -1,16 +0,0 @@
-// src/format/measure.ts
-async function measure(key, callback) {
-  const start = Date.now();
-  try {
-    let result = callback();
-    if (result instanceof Promise) {
-      result = await result;
-    }
-    return result;
-  } finally {
-    const end = Date.now();
-    console.log(`${key} took ${end - start}ms`);
-  }
-}
-
-export { measure };

package/dist/http/cookie.d.ts

@@ -1,21 +0,0 @@
-/**
- * Helper function to set cookies in a more controlled way
- * @param name - The name of the cookie
- * @param value - The value to set
- * @param options - Cookie options
- */
-declare function setCookieValue(name: string, value: string, options?: {
-    expires?: Date;
-    path?: string;
-    sameSite?: string;
-    secure?: boolean;
-    domain?: string;
-}): void;
-/**
- * Get a cookie value by name
- * @param name - The name of the cookie to get
- * @returns The cookie value or null if not found
- */
-declare function getCookieValue(name: string): string | null;
-
-export { getCookieValue, setCookieValue };

package/dist/http/cookie.js

@@ -1,47 +0,0 @@
-// src/http/cookie.ts
-function setCookieValue(name, value, options = {}) {
-  if (typeof window === "undefined") {
-    console.warn("Cannot set cookie on server side");
-    return;
-  }
-  let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-  if (options.expires) {
-    cookieString += `; expires=${options.expires.toUTCString()}`;
-  }
-  if (options.path) {
-    cookieString += `; path=${options.path}`;
-  }
-  if (options.sameSite) {
-    cookieString += `; SameSite=${options.sameSite}`;
-  }
-  if (options.secure) {
-    cookieString += "; Secure";
-  }
-  if (options.domain) {
-    cookieString += `; domain=${options.domain}`;
-  }
-  try {
-    document.cookie = cookieString;
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(`Failed to set cookie '${name}':`, error.message);
-    } else {
-      console.error(`Failed to set cookie '${name}': Unknown error`);
-    }
-  }
-}
-function getCookieValue(name) {
-  if (typeof window === "undefined") {
-    console.warn("Cannot get cookie on server side");
-    return null;
-  }
-  const value = `; ${document.cookie}`;
-  const parts = value.split(`; ${name}=`);
-  if (parts.length === 2) {
-    const cookieValue = parts.pop()?.split(";").shift();
-    return cookieValue ? decodeURIComponent(cookieValue) : null;
-  }
-  return null;
-}
-
-export { getCookieValue, setCookieValue };

package/dist/http/domain.d.ts

@@ -1,9 +0,0 @@
-/**
- * Helper utility used to extract the domain from the request even if it's
- * behind a proxy. This is useful for sitemaps and other things.
- * @param request Request object
- * @returns Current domain
- */
-declare const createDomain: (request: Request) => string;
-
-export { createDomain };

package/dist/http/domain.js

@@ -1,16 +0,0 @@
-// src/http/domain.ts
-var createDomain = (request) => {
-  const headers = request.headers;
-  const maybeProto = headers.get("x-forwarded-proto");
-  const maybeHost = headers.get("host");
-  const url = new URL(request.url);
-  if (maybeProto) {
-    return `${maybeProto}://${maybeHost ?? url.host}`;
-  }
-  if (url.hostname === "localhost") {
-    return `http://${url.host}`;
-  }
-  return `https://${url.host}`;
-};
-
-export { createDomain };

package/dist/http/request-helpers.d.ts

@@ -1,3 +0,0 @@
-declare function getCleanUrl(request: Request): string;
-
-export { getCleanUrl };

package/dist/http/request-helpers.js

@@ -1,10 +0,0 @@
-// src/http/request-helpers.ts
-function getCleanUrl(request) {
-  const url = new URL(request.url);
-  url.searchParams.forEach((_, key) => {
-    url.searchParams.delete(key);
-  });
-  return url.toString();
-}
-
-export { getCleanUrl };

package/dist/validation/verify-file-accept.d.ts

@@ -1,10 +0,0 @@
-/**
- * Check if a mime type matches the set given in accept
- *
- * @param type the mime type to test, ex image/png
- * @param accept the mime types to accept, ex audio/*,video/*,image/png
- * @returns true if the mime is accepted, false otherwise
- */
-declare function verifyAccept(type: string, accept: string): boolean;
-
-export { verifyAccept };

package/dist/validation/verify-file-accept.js

@@ -1,7 +0,0 @@
-// src/validation/verify-file-accept.ts
-function verifyAccept(type, accept) {
-  const allowed = accept.split(",").map((x) => x.trim());
-  return allowed.includes(type) || allowed.includes(`${type.split("/")[0]}/*`);
-}
-
-export { verifyAccept };