superjs-core 0.1.0

package/dist/path/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Joins path segments with the proper separator.
+ *
+ * @param segments - Path segments to join.
+ * @returns The joined path.
+ */
+declare function join(...segments: string[]): string;
+/**
+ * Resolves path segments to an absolute path.
+ *
+ * @param segments - Path segments to resolve.
+ * @returns The resolved absolute path.
+ */
+declare function resolve(...segments: string[]): string;
+/**
+ * Returns the filename from a path.
+ *
+ * @param p - The path.
+ * @param ext - Optional extension to strip.
+ * @returns The filename.
+ */
+declare function basename(p: string, ext?: string): string;
+/**
+ * Returns the directory portion of a path.
+ *
+ * @param p - The path.
+ * @returns The directory path.
+ */
+declare function dirname(p: string): string;
+/**
+ * Returns the file extension from a path.
+ *
+ * @param p - The path.
+ * @returns The extension including the dot, or empty string.
+ */
+declare function extname(p: string): string;
+/**
+ * Normalizes a path, resolving '..' and '.' segments.
+ *
+ * @param p - The path to normalize.
+ * @returns The normalized path.
+ */
+declare function normalize(p: string): string;
+/**
+ * Checks if a path is absolute.
+ *
+ * @param p - The path to check.
+ * @returns Whether the path is absolute.
+ */
+declare function isAbsolute(p: string): boolean;
+/**
+ * Computes the relative path from `from` to `to`.
+ *
+ * @param from - The base path.
+ * @param to - The target path.
+ * @returns The relative path.
+ */
+declare function relative(from: string, to: string): string;
+interface ParsedPath {
+    root: string;
+    dir: string;
+    base: string;
+    name: string;
+    ext: string;
+}
+/**
+ * Parses a path into its components.
+ *
+ * @param p - The path to parse.
+ * @returns An object with root, dir, base, name, and ext.
+ */
+declare function parse(p: string): ParsedPath;
+/**
+ * Formats a parsed path object back into a path string.
+ *
+ * @param parsed - The parsed path components.
+ * @returns The formatted path string.
+ */
+declare function format(parsed: Partial<ParsedPath>): string;
+
+export { type ParsedPath, basename, dirname, extname, format, isAbsolute, join, normalize, parse, relative, resolve };

package/dist/path/index.js

@@ -0,0 +1,134 @@
+// src/path/index.ts
+var SEP = "/";
+function join(...segments) {
+  const parts = [];
+  for (const seg of segments) {
+    if (seg === "") continue;
+    const split = seg.split(/[\\/]/);
+    for (const part of split) {
+      if (part === "" || part === ".") continue;
+      if (part === "..") {
+        if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+          parts.pop();
+        } else {
+          parts.push("..");
+        }
+      } else {
+        parts.push(part);
+      }
+    }
+  }
+  if (parts.length === 0) return ".";
+  const result = parts.join(SEP);
+  if (segments.length > 0 && segments[0].startsWith("/")) {
+    return SEP + result;
+  }
+  return result;
+}
+function resolve(...segments) {
+  let resolved = "";
+  let isAbs = false;
+  for (const seg of segments) {
+    if (seg.startsWith("/")) {
+      resolved = seg;
+      isAbs = true;
+    } else if (isAbs) {
+      resolved = join(resolved, seg);
+    } else {
+      resolved = resolved ? join(resolved, seg) : seg;
+    }
+  }
+  if (!isAbs) {
+    resolved = join(SEP, resolved);
+  }
+  return normalize(resolved);
+}
+function basename(p, ext) {
+  const normalized = p.replace(/[\\/]+$/, "");
+  const idx = normalized.lastIndexOf(SEP);
+  let base = idx === -1 ? normalized : normalized.slice(idx + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, -ext.length);
+  }
+  return base;
+}
+function dirname(p) {
+  if (p === SEP) return SEP;
+  const normalized = p.replace(/[\\/]+$/, "");
+  if (normalized === "") return ".";
+  const idx = normalized.lastIndexOf(SEP);
+  if (idx === -1) return ".";
+  if (idx === 0) return SEP;
+  return normalized.slice(0, idx);
+}
+function extname(p) {
+  const base = basename(p);
+  const idx = base.lastIndexOf(".");
+  if (idx === -1 || idx === 0) return "";
+  return base.slice(idx);
+}
+function normalize(p) {
+  const parts = p.split(/[\\/]+/);
+  const stack = [];
+  let isAbs = p.startsWith("/");
+  for (const part of parts) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+      } else if (!isAbs) {
+        stack.push("..");
+      }
+    } else {
+      stack.push(part);
+    }
+  }
+  const result = stack.join(SEP);
+  if (isAbs) return SEP + result;
+  if (result === "") return ".";
+  return result;
+}
+function isAbsolute(p) {
+  return p.startsWith("/");
+}
+function relative(from, to) {
+  const fromParts = normalize(from).split(SEP);
+  const toParts = normalize(to).split(SEP);
+  let i = 0;
+  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+    i++;
+  }
+  const up = fromParts.slice(i).map(() => "..");
+  const down = toParts.slice(i);
+  const result = [...up, ...down].join(SEP);
+  return result || ".";
+}
+function parse(p) {
+  const root = p.startsWith(SEP) ? SEP : "";
+  const base = basename(p);
+  const ext = extname(base);
+  const name = ext ? base.slice(0, -ext.length) : base;
+  const dir = root ? dirname(p) : dirname(p) === "." ? "" : dirname(p);
+  return { root, dir, base, name, ext };
+}
+function format(parsed) {
+  const { root = "", dir = "", base = "", name = "", ext = "" } = parsed;
+  const baseName = base || name + ext;
+  if (dir) {
+    return dir + SEP + baseName;
+  }
+  return root + baseName;
+}
+export {
+  basename,
+  dirname,
+  extname,
+  format,
+  isAbsolute,
+  join,
+  normalize,
+  parse,
+  relative,
+  resolve
+};
+//# sourceMappingURL=index.js.map

package/dist/path/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/path/index.ts"],"sourcesContent":["const SEP = '/'\n\n/**\n * Joins path segments with the proper separator.\n *\n * @param segments - Path segments to join.\n * @returns The joined path.\n */\nexport function join(...segments: string[]): string {\n  const parts: string[] = []\n  for (const seg of segments) {\n    if (seg === '') continue\n    const split = seg.split(/[\\\\/]/)\n    for (const part of split) {\n      if (part === '' || part === '.') continue\n      if (part === '..') {\n        if (parts.length > 0 && parts[parts.length - 1] !== '..') {\n          parts.pop()\n        } else {\n          parts.push('..')\n        }\n      } else {\n        parts.push(part)\n      }\n    }\n  }\n  if (parts.length === 0) return '.'\n  const result = parts.join(SEP)\n  if (segments.length > 0 && segments[0]!.startsWith('/')) {\n    return SEP + result\n  }\n  return result\n}\n\n/**\n * Resolves path segments to an absolute path.\n *\n * @param segments - Path segments to resolve.\n * @returns The resolved absolute path.\n */\nexport function resolve(...segments: string[]): string {\n  let resolved = ''\n  let isAbs = false\n\n  for (const seg of segments) {\n    if (seg.startsWith('/')) {\n      resolved = seg\n      isAbs = true\n    } else if (isAbs) {\n      resolved = join(resolved, seg)\n    } else {\n      resolved = resolved ? join(resolved, seg) : seg\n    }\n  }\n\n  if (!isAbs) {\n    resolved = join(SEP, resolved)\n  }\n\n  return normalize(resolved)\n}\n\n/**\n * Returns the filename from a path.\n *\n * @param p - The path.\n * @param ext - Optional extension to strip.\n * @returns The filename.\n */\nexport function basename(p: string, ext?: string): string {\n  const normalized = p.replace(/[\\\\/]+$/, '')\n  const idx = normalized.lastIndexOf(SEP)\n  let base = idx === -1 ? normalized : normalized.slice(idx + 1)\n  if (ext && base.endsWith(ext)) {\n    base = base.slice(0, -ext.length)\n  }\n  return base\n}\n\n/**\n * Returns the directory portion of a path.\n *\n * @param p - The path.\n * @returns The directory path.\n */\nexport function dirname(p: string): string {\n  if (p === SEP) return SEP\n  const normalized = p.replace(/[\\\\/]+$/, '')\n  if (normalized === '') return '.'\n  const idx = normalized.lastIndexOf(SEP)\n  if (idx === -1) return '.'\n  if (idx === 0) return SEP\n  return normalized.slice(0, idx)\n}\n\n/**\n * Returns the file extension from a path.\n *\n * @param p - The path.\n * @returns The extension including the dot, or empty string.\n */\nexport function extname(p: string): string {\n  const base = basename(p)\n  const idx = base.lastIndexOf('.')\n  if (idx === -1 || idx === 0) return ''\n  return base.slice(idx)\n}\n\n/**\n * Normalizes a path, resolving '..' and '.' segments.\n *\n * @param p - The path to normalize.\n * @returns The normalized path.\n */\nexport function normalize(p: string): string {\n  const parts = p.split(/[\\\\/]+/)\n  const stack: string[] = []\n  let isAbs = p.startsWith('/')\n\n  for (const part of parts) {\n    if (part === '' || part === '.') continue\n    if (part === '..') {\n      if (stack.length > 0 && stack[stack.length - 1] !== '..') {\n        stack.pop()\n      } else if (!isAbs) {\n        stack.push('..')\n      }\n    } else {\n      stack.push(part)\n    }\n  }\n\n  const result = stack.join(SEP)\n  if (isAbs) return SEP + result\n  if (result === '') return '.'\n  return result\n}\n\n/**\n * Checks if a path is absolute.\n *\n * @param p - The path to check.\n * @returns Whether the path is absolute.\n */\nexport function isAbsolute(p: string): boolean {\n  return p.startsWith('/')\n}\n\n/**\n * Computes the relative path from `from` to `to`.\n *\n * @param from - The base path.\n * @param to - The target path.\n * @returns The relative path.\n */\nexport function relative(from: string, to: string): string {\n  const fromParts = normalize(from).split(SEP)\n  const toParts = normalize(to).split(SEP)\n\n  let i = 0\n  while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {\n    i++\n  }\n\n  const up = fromParts.slice(i).map(() => '..')\n  const down = toParts.slice(i)\n  const result = [...up, ...down].join(SEP)\n\n  return result || '.'\n}\n\nexport interface ParsedPath {\n  root: string\n  dir: string\n  base: string\n  name: string\n  ext: string\n}\n\n/**\n * Parses a path into its components.\n *\n * @param p - The path to parse.\n * @returns An object with root, dir, base, name, and ext.\n */\nexport function parse(p: string): ParsedPath {\n  const root = p.startsWith(SEP) ? SEP : ''\n  const base = basename(p)\n  const ext = extname(base)\n  const name = ext ? base.slice(0, -ext.length) : base\n  const dir = root ? dirname(p) : (dirname(p) === '.' ? '' : dirname(p))\n\n  return { root, dir, base, name, ext }\n}\n\n/**\n * Formats a parsed path object back into a path string.\n *\n * @param parsed - The parsed path components.\n * @returns The formatted path string.\n */\nexport function format(parsed: Partial<ParsedPath>): string {\n  const { root = '', dir = '', base = '', name = '', ext = '' } = parsed\n  const baseName = base || name + ext\n  if (dir) {\n    return dir + SEP + baseName\n  }\n  return root + baseName\n}\n"],"mappings":"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","names":[]}

package/dist/string/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Capitalizes the first character and lowercases the rest.
+ */
+declare function capitalize(str: string): string;
+/**
+ * Converts a string to camelCase.
+ */
+declare function camelCase(str: string): string;
+/**
+ * Converts a string to kebab-case.
+ */
+declare function kebabCase(str: string): string;
+/**
+ * Converts a string to snake_case.
+ */
+declare function snakeCase(str: string): string;
+/**
+ * Converts a string to PascalCase.
+ */
+declare function pascalCase(str: string): string;
+/**
+ * Truncates a string to the specified length, appending a suffix (default "...").
+ */
+declare function truncate(str: string, maxLength: number, suffix?: string): string;
+/**
+ * Simple string interpolation using {{key}} syntax.
+ *
+ * @example template("Hello {{name}}", { name: "world" }) // => "Hello world"
+ */
+declare function template(str: string, data: Record<string, string | number>): string;
+/**
+ * Generates a UUID v4 string.
+ * Uses crypto.randomUUID when available, falls back to manual implementation.
+ */
+declare function uuid(): string;
+/**
+ * Generates a short random ID with configurable length and alphabet.
+ *
+ * @default size = 21, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-"
+ */
+declare function nanoid(size?: number, alphabet?: string): string;
+/**
+ * Escapes HTML special characters (&, <, >, ", ').
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Unescapes common HTML entities.
+ */
+declare function unescapeHtml(str: string): string;
+/**
+ * Removes whitespace from both ends of a string.
+ */
+declare function trim(str: string): string;
+/**
+ * Removes whitespace from the start of a string.
+ */
+declare function trimStart(str: string): string;
+/**
+ * Removes whitespace from the end of a string.
+ */
+declare function trimEnd(str: string): string;
+/**
+ * Pads a string to the given length by adding characters to both sides.
+ */
+declare function pad(str: string, length: number, char?: string): string;
+/**
+ * Pads the start of a string to the given length.
+ */
+declare function padStart(str: string, length: number, char?: string): string;
+/**
+ * Pads the end of a string to the given length.
+ */
+declare function padEnd(str: string, length: number, char?: string): string;
+/**
+ * Reverses a string.
+ */
+declare function reverse(str: string): string;
+/**
+ * Splits a string into words.
+ */
+declare function words(str: string): string[];
+/**
+ * Converts a string to a URL-friendly slug.
+ */
+declare function slugify(str: string): string;
+/**
+ * Counts occurrences of a substring in a string.
+ */
+declare function countOccurrences(str: string, substring: string): number;
+
+export { camelCase, capitalize, countOccurrences, escapeHtml, kebabCase, nanoid, pad, padEnd, padStart, pascalCase, reverse, slugify, snakeCase, template, trim, trimEnd, trimStart, truncate, unescapeHtml, uuid, words };

package/dist/string/index.js

@@ -0,0 +1,146 @@
+// src/string/index.ts
+var WORD_SPLIT_RE = /[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\b)|\d+/g;
+function splitWords(str) {
+  return str.match(WORD_SPLIT_RE) ?? [];
+}
+function capitalize(str) {
+  if (str.length === 0) return str;
+  return str[0].toUpperCase() + str.slice(1).toLowerCase();
+}
+function camelCase(str) {
+  const words2 = splitWords(str);
+  if (words2.length === 0) return "";
+  const [firstWord, ...rest] = words2;
+  return firstWord.toLowerCase() + rest.map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function kebabCase(str) {
+  return splitWords(str).map((w) => w.toLowerCase()).join("-");
+}
+function snakeCase(str) {
+  return splitWords(str).map((w) => w.toLowerCase()).join("_");
+}
+function pascalCase(str) {
+  return splitWords(str).map((w) => w[0].toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, Math.max(0, maxLength - suffix.length)) + suffix;
+}
+function template(str, data) {
+  return str.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+    const value = data[key];
+    return value !== void 0 ? String(value) : `{{${key}}}`;
+  });
+}
+function uuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const hex = "0123456789abcdef";
+  const chars = [];
+  for (let i = 0; i < 36; i++) {
+    if (i === 8 || i === 13 || i === 18 || i === 23) {
+      chars.push("-");
+    } else if (i === 14) {
+      chars.push("4");
+    } else if (i === 19) {
+      chars.push(hex[Math.floor(Math.random() * 4) + 8]);
+    } else {
+      chars.push(hex[Math.floor(Math.random() * 16)]);
+    }
+  }
+  return chars.join("");
+}
+function nanoid(size = 21, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-") {
+  const len = alphabet.length;
+  let result = "";
+  for (let i = 0; i < size; i++) {
+    result += alphabet[Math.floor(Math.random() * len)];
+  }
+  return result;
+}
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var HTML_UNESCAPE_MAP = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'"
+};
+function escapeHtml(str) {
+  return str.replace(/[&<>"']/g, (ch) => HTML_ESCAPE_MAP[ch] ?? ch);
+}
+function unescapeHtml(str) {
+  return str.replace(/&(?:amp|lt|gt|quot|#39|#x27);/g, (entity) => HTML_UNESCAPE_MAP[entity] ?? entity);
+}
+function trim(str) {
+  return str.trim();
+}
+function trimStart(str) {
+  return str.trimStart();
+}
+function trimEnd(str) {
+  return str.trimEnd();
+}
+function pad(str, length, char = " ") {
+  const totalPadding = Math.max(0, length - str.length);
+  const leftPad = Math.floor(totalPadding / 2);
+  const rightPad = totalPadding - leftPad;
+  return char.repeat(leftPad) + str + char.repeat(rightPad);
+}
+function padStart(str, length, char = " ") {
+  return str.padStart(length, char);
+}
+function padEnd(str, length, char = " ") {
+  return str.padEnd(length, char);
+}
+function reverse(str) {
+  return str.split("").reverse().join("");
+}
+function words(str) {
+  return splitWords(str);
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function countOccurrences(str, substring) {
+  if (substring.length === 0 || str.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = str.indexOf(substring, pos)) !== -1) {
+    count++;
+    pos += substring.length;
+  }
+  return count;
+}
+export {
+  camelCase,
+  capitalize,
+  countOccurrences,
+  escapeHtml,
+  kebabCase,
+  nanoid,
+  pad,
+  padEnd,
+  padStart,
+  pascalCase,
+  reverse,
+  slugify,
+  snakeCase,
+  template,
+  trim,
+  trimEnd,
+  trimStart,
+  truncate,
+  unescapeHtml,
+  uuid,
+  words
+};
+//# sourceMappingURL=index.js.map

package/dist/string/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/string/index.ts"],"sourcesContent":["const WORD_SPLIT_RE = /[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\\d|\\b)|\\d+/g\n\nfunction splitWords(str: string): string[] {\n  return str.match(WORD_SPLIT_RE) ?? []\n}\n\n/**\n * Capitalizes the first character and lowercases the rest.\n */\nexport function capitalize(str: string): string {\n  if (str.length === 0) return str\n  return str[0]!.toUpperCase() + str.slice(1).toLowerCase()\n}\n\n/**\n * Converts a string to camelCase.\n */\nexport function camelCase(str: string): string {\n  const words = splitWords(str)\n  if (words.length === 0) return ''\n  const [firstWord, ...rest] = words\n  return firstWord!.toLowerCase() + rest.map(w => w[0]!.toUpperCase() + w.slice(1).toLowerCase()).join('')\n}\n\n/**\n * Converts a string to kebab-case.\n */\nexport function kebabCase(str: string): string {\n  return splitWords(str).map(w => w.toLowerCase()).join('-')\n}\n\n/**\n * Converts a string to snake_case.\n */\nexport function snakeCase(str: string): string {\n  return splitWords(str).map(w => w.toLowerCase()).join('_')\n}\n\n/**\n * Converts a string to PascalCase.\n */\nexport function pascalCase(str: string): string {\n  return splitWords(str).map(w => w[0]!.toUpperCase() + w.slice(1).toLowerCase()).join('')\n}\n\n/**\n * Truncates a string to the specified length, appending a suffix (default \"...\").\n */\nexport function truncate(str: string, maxLength: number, suffix = '...'): string {\n  if (str.length <= maxLength) return str\n  return str.slice(0, Math.max(0, maxLength - suffix.length)) + suffix\n}\n\n/**\n * Simple string interpolation using {{key}} syntax.\n *\n * @example template(\"Hello {{name}}\", { name: \"world\" }) // => \"Hello world\"\n */\nexport function template(str: string, data: Record<string, string | number>): string {\n  return str.replace(/\\{\\{(\\w+)\\}\\}/g, (_, key: string) => {\n    const value = data[key]\n    return value !== undefined ? String(value) : `{{${key}}}`\n  })\n}\n\n/**\n * Generates a UUID v4 string.\n * Uses crypto.randomUUID when available, falls back to manual implementation.\n */\nexport function uuid(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return crypto.randomUUID()\n  }\n  const hex = '0123456789abcdef'\n  const chars: string[] = []\n  for (let i = 0; i < 36; i++) {\n    if (i === 8 || i === 13 || i === 18 || i === 23) {\n      chars.push('-')\n    } else if (i === 14) {\n      chars.push('4')\n    } else if (i === 19) {\n      chars.push(hex[Math.floor(Math.random() * 4) + 8]!)\n    } else {\n      chars.push(hex[Math.floor(Math.random() * 16)]!)\n    }\n  }\n  return chars.join('')\n}\n\n/**\n * Generates a short random ID with configurable length and alphabet.\n *\n * @default size = 21, alphabet = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-\"\n */\nexport function nanoid(size = 21, alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-'): string {\n  const len = alphabet.length\n  let result = ''\n  for (let i = 0; i < size; i++) {\n    result += alphabet[Math.floor(Math.random() * len)]!\n  }\n  return result\n}\n\nconst HTML_ESCAPE_MAP: Record<string, string> = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;',\n}\n\nconst HTML_UNESCAPE_MAP: Record<string, string> = {\n  '&amp;': '&',\n  '&lt;': '<',\n  '&gt;': '>',\n  '&quot;': '\"',\n  '&#39;': \"'\",\n  '&#x27;': \"'\",\n}\n\n/**\n * Escapes HTML special characters (&, <, >, \", ').\n */\nexport function escapeHtml(str: string): string {\n  return str.replace(/[&<>\"']/g, ch => HTML_ESCAPE_MAP[ch] ?? ch)\n}\n\n/**\n * Unescapes common HTML entities.\n */\nexport function unescapeHtml(str: string): string {\n  return str.replace(/&(?:amp|lt|gt|quot|#39|#x27);/g, entity => HTML_UNESCAPE_MAP[entity] ?? entity)\n}\n\n/**\n * Removes whitespace from both ends of a string.\n */\nexport function trim(str: string): string {\n  return str.trim()\n}\n\n/**\n * Removes whitespace from the start of a string.\n */\nexport function trimStart(str: string): string {\n  return str.trimStart()\n}\n\n/**\n * Removes whitespace from the end of a string.\n */\nexport function trimEnd(str: string): string {\n  return str.trimEnd()\n}\n\n/**\n * Pads a string to the given length by adding characters to both sides.\n */\nexport function pad(str: string, length: number, char = ' '): string {\n  const totalPadding = Math.max(0, length - str.length)\n  const leftPad = Math.floor(totalPadding / 2)\n  const rightPad = totalPadding - leftPad\n  return char.repeat(leftPad) + str + char.repeat(rightPad)\n}\n\n/**\n * Pads the start of a string to the given length.\n */\nexport function padStart(str: string, length: number, char = ' '): string {\n  return str.padStart(length, char)\n}\n\n/**\n * Pads the end of a string to the given length.\n */\nexport function padEnd(str: string, length: number, char = ' '): string {\n  return str.padEnd(length, char)\n}\n\n/**\n * Reverses a string.\n */\nexport function reverse(str: string): string {\n  return str.split('').reverse().join('')\n}\n\n/**\n * Splits a string into words.\n */\nexport function words(str: string): string[] {\n  return splitWords(str)\n}\n\n/**\n * Converts a string to a URL-friendly slug.\n */\nexport function slugify(str: string): string {\n  return str\n    .toLowerCase()\n    .replace(/[^\\w\\s-]/g, '')\n    .replace(/[\\s_]+/g, '-')\n    .replace(/-+/g, '-')\n    .replace(/^-+/, '')\n    .replace(/-+$/, '')\n}\n\n/**\n * Counts occurrences of a substring in a string.\n */\nexport function countOccurrences(str: string, substring: string): number {\n  if (substring.length === 0 || str.length === 0) return 0\n  let count = 0\n  let pos = 0\n  while ((pos = str.indexOf(substring, pos)) !== -1) {\n    count++\n    pos += substring.length\n  }\n  return count\n}\n"],"mappings":"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","names":["words"]}

package/dist/type/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Checks if a value is a string.
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Checks if a value is a number (not NaN, not Infinity).
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is a boolean.
+ */
+declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if a value is a plain object (not null, not array, typeof 'object').
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a value is an array.
+ */
+declare function isArray(value: unknown): value is unknown[];
+/**
+ * Checks if a value is a function.
+ */
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Checks if a value is a Date.
+ */
+declare function isDate(value: unknown): value is Date;
+/**
+ * Checks if a value is a RegExp.
+ */
+declare function isRegExp(value: unknown): value is RegExp;
+/**
+ * Checks if a value is a Map.
+ */
+declare function isMap(value: unknown): value is Map<unknown, unknown>;
+/**
+ * Checks if a value is a Set.
+ */
+declare function isSet(value: unknown): value is Set<unknown>;
+/**
+ * Checks if a value is a Promise.
+ */
+declare function isPromise(value: unknown): value is Promise<unknown>;
+/**
+ * Checks if a value is null.
+ */
+declare function isNull(value: unknown): value is null;
+/**
+ * Checks if a value is undefined.
+ */
+declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Checks if a value is null or undefined.
+ */
+declare function isNil(value: unknown): value is null | undefined;
+/**
+ * Checks if a value is empty.
+ * Works for strings, arrays, objects, Map, and Set.
+ */
+declare function isEmpty(value: unknown): boolean;
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * Throws if the value is null or undefined.
+ */
+declare function assertDefined<T>(value: T, message?: string): asserts value is NonNullable<T>;
+/**
+ * Asserts that a value matches a type guard. Throws if it doesn't.
+ */
+declare function assertType<T>(value: unknown, guard: (v: unknown) => v is T, message?: string): asserts value is T;
+/**
+ * Wraps a value in an array if it is not already one.
+ */
+declare function ensureArray<T>(value: T | T[]): T[];
+/**
+ * Alias for ensureArray.
+ */
+declare function castArray<T>(value: T | T[]): T[];
+/**
+ * Returns a string representation of the value's type.
+ *
+ * Possible values: "string", "number", "boolean", "array", "object", "function",
+ * "date", "regexp", "map", "set", "promise", "null", "undefined", "nan", "infinity"
+ */
+declare function getType(value: unknown): string;
+
+export { assertDefined, assertType, castArray, ensureArray, getType, isArray, isBoolean, isDate, isEmpty, isFunction, isMap, isNil, isNull, isNumber, isObject, isPromise, isRegExp, isSet, isString, isUndefined };

package/dist/type/index.js

@@ -0,0 +1,109 @@
+// src/type/index.ts
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isDate(value) {
+  return value instanceof Date && !Number.isNaN(value.getTime());
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isNull(value) {
+  return value === null;
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isNil(value) {
+  return value === null || value === void 0;
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (value instanceof Map || value instanceof Set) return value.size === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function assertDefined(value, message) {
+  if (value === null || value === void 0) {
+    throw new Error(message ?? "Expected value to be defined");
+  }
+}
+function assertType(value, guard, message) {
+  if (!guard(value)) {
+    throw new Error(message ?? "Value does not match expected type");
+  }
+}
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function castArray(value) {
+  return ensureArray(value);
+}
+function getType(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return "string";
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "function") return "function";
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) return "nan";
+    if (!Number.isFinite(value)) return "infinity";
+    return "number";
+  }
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  if (value instanceof Promise) return "promise";
+  return "object";
+}
+export {
+  assertDefined,
+  assertType,
+  castArray,
+  ensureArray,
+  getType,
+  isArray,
+  isBoolean,
+  isDate,
+  isEmpty,
+  isFunction,
+  isMap,
+  isNil,
+  isNull,
+  isNumber,
+  isObject,
+  isPromise,
+  isRegExp,
+  isSet,
+  isString,
+  isUndefined
+};
+//# sourceMappingURL=index.js.map