speexjs-core 0.7.0

package/dist/string/index.d.ts

@@ -0,0 +1,234 @@
+/**
+ * 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;
+/**
+ * Computes the Levenshtein distance between two strings.
+ * Uses iterative DP with O(min(m,n)) space.
+ */
+declare function levenshtein(a: string, b: string): number;
+/**
+ * Performs a simple fuzzy match: checks if all characters of query
+ * appear in str in order (case-insensitive).
+ */
+declare function fuzzyMatch(str: string, query: string): boolean;
+/**
+ * Masks parts of a string, useful for data compliance (PDPA/GDPR).
+ *
+ * @example maskString('08123456789') // "0812****789"
+ * @example maskString('hello@email.com') // "h***@e***.com"
+ * @example maskString('1234567890', { start: 0, end: 4, char: '#' }) // "####567890"
+ */
+declare function maskString(str: string, options?: {
+    start?: number;
+    end?: number;
+    char?: string;
+}): string;
+/**
+ * Converts a number to Indonesian words (terbilang).
+ *
+ * @example terbilang(1500000) // "satu juta lima ratus ribu"
+ * @example terbilang(2024)    // "dua ribu dua puluh empat"
+ * @example terbilang(11)      // "sebelas"
+ * @example terbilang(100)     // "seratus"
+ */
+declare function terbilang(value: number): string;
+/**
+ * Formats a number as Indonesian Rupiah string.
+ *
+ * @example formatRupiah(1500000) // "Rp1.500.000"
+ * @example formatRupiah(1500000, { notation: 'compact' }) // "Rp1,5 jt"
+ */
+declare function formatRupiah(value: number, options?: {
+    notation?: 'standard' | 'compact';
+}): string;
+/**
+ * Formats a byte count into a human-readable string.
+ *
+ * @example formatBytes(1024) // "1 KB"
+ * @example formatBytes(1536) // "1.5 KB"
+ * @example formatBytes(1048576) // "1 MB"
+ * @example formatBytes(0) // "0 B"
+ */
+declare function formatBytes(bytes: number, options?: {
+    decimals?: number;
+}): string;
+/**
+ * Generates a random alphanumeric string of the specified length.
+ *
+ * @example randomString() // "a3F8k2..."
+ * @example randomString(8) // "X7j2K9mQ"
+ */
+declare function randomString(length?: number): string;
+/**
+ * Returns a random boolean value.
+ *
+ * @example randomBoolean() // true or false
+ */
+declare function randomBoolean(): boolean;
+/**
+ * Basic English pluralization helper. Adds 's' or 'es' based on simple rules.
+ *
+ * @example pluralize(1, 'apple') // "apple"
+ * @example pluralize(3, 'apple') // "apples"
+ * @example pluralize(0, 'box')   // "boxes"
+ * @example pluralize(1, 'box')   // "box"
+ */
+declare function pluralize(count: number, singular: string): string;
+/**
+ * Removes all HTML tags from a string, including script and style content.
+ *
+ * @example stripHtml('<p>Hello <b>world</b></p>') // "Hello world"
+ * @example stripHtml('<script>alert("x")</script>hi') // "hi"
+ */
+declare function stripHtml(str: string): string;
+/**
+ * Truncates a string by word count, appending a suffix when truncated.
+ *
+ * @example truncateWords('hello world foo bar', 2) // "hello world..."
+ * @example truncateWords('hello world foo bar', 2, '…') // "hello world…"
+ */
+declare function truncateWords(str: string, count: number, suffix?: string): string;
+/**
+ * Checks if a string is a palindrome, ignoring case, spaces, and punctuation.
+ *
+ * @example isPalindrome('A man, a plan, a canal: Panama') // true
+ * @example isPalindrome('race a car') // false
+ */
+declare function isPalindrome(str: string): boolean;
+/**
+ * Checks if two strings are anagrams, ignoring case and spaces.
+ *
+ * @example isAnagram('listen', 'silent') // true
+ * @example isAnagram('hello', 'world') // false
+ */
+declare function isAnagram(str1: string, str2: string): boolean;
+/**
+ * Computes the Dice coefficient similarity between two strings (0-1).
+ *
+ * @example similarity('hello', 'hallo') // 0.666...
+ * @example similarity('abc', 'xyz') // 0
+ */
+declare function similarity(a: string, b: string): number;
+/**
+ * Removes common leading whitespace from each line in a multi-line string.
+ *
+ * @example dedent('  hello\n  world') // "hello\nworld"
+ * @example dedent('    foo\n      bar') // "foo\n  bar"
+ */
+declare function dedent(str: string): string;
+/**
+ * Counts the number of words in a string, handling multiple spaces and punctuation.
+ *
+ * @example wordCount('hello world') // 2
+ * @example wordCount('  hello   world! ') // 2
+ */
+declare function wordCount(str: string): number;
+/**
+ * Swaps the case of each character in a string (upper to lower, lower to upper).
+ *
+ * @example swapCase('Hello World') // "hELLO wORLD"
+ * @example swapCase('ABC123') // "abc123"
+ */
+declare function swapCase(str: string): string;
+/**
+ * Converts a string to COBOL / SCREAMING_SNAKE_CASE.
+ *
+ * @example toCobolCase('helloWorld') // "HELLO_WORLD"
+ * @example toCobolCase('getUserByID') // "GET_USER_BY_ID"
+ */
+declare function toCobolCase(str: string): string;
+/**
+ * Counts character frequency in a string.
+ *
+ * @example charCount('hello') // { h: 1, e: 1, l: 2, o: 1 }
+ * @example charCount('aabb') // { a: 2, b: 2 }
+ */
+declare function charCount(str: string): Record<string, number>;
+
+export { camelCase, capitalize, charCount, countOccurrences, dedent, escapeHtml, formatBytes, formatRupiah, fuzzyMatch, isAnagram, isPalindrome, kebabCase, levenshtein, maskString, nanoid, pad, padEnd, padStart, pascalCase, pluralize, randomBoolean, randomString, reverse, similarity, slugify, snakeCase, stripHtml, swapCase, template, terbilang, toCobolCase, trim, trimEnd, trimStart, truncate, truncateWords, unescapeHtml, uuid, wordCount, words };

package/dist/string/index.js

@@ -0,0 +1,411 @@
+// src/math/index.ts
+function formatCurrency(value, options) {
+  const locale = options?.locale ?? "id-ID";
+  const currency = options?.currency ?? "IDR";
+  const notation = options?.notation ?? "standard";
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      notation,
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 2
+    }).format(value);
+  } catch {
+    return `${currency} ${value.toLocaleString(locale)}`;
+  }
+}
+
+// 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) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return `{{${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;
+  const bytes = new Uint8Array(size);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    throw new Error("Crypto API unavailable. Cannot generate secure random ID.");
+  }
+  let result = "";
+  for (let i = 0; i < size; i++) {
+    result += alphabet[bytes[i] % len];
+  }
+  return result;
+}
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "`": "&#96;",
+  "/": "&#x2F;"
+};
+var HTML_UNESCAPE_MAP = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#96;": "`",
+  "&#x2F;": "/"
+};
+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|#96|#x2F);/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;
+}
+function levenshtein(a, b) {
+  const an = a.length;
+  const bn = b.length;
+  if (an === 0) return bn;
+  if (bn === 0) return an;
+  if (an < bn) return levenshtein(b, a);
+  let prev = new Uint32Array(bn + 1);
+  let curr = new Uint32Array(bn + 1);
+  for (let j = 0; j <= bn; j++) prev[j] = j;
+  for (let i = 1; i <= an; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= bn; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(
+        prev[j] + 1,
+        curr[j - 1] + 1,
+        prev[j - 1] + cost
+      );
+    }
+    ;
+    [prev, curr] = [curr, prev];
+  }
+  return prev[bn];
+}
+function fuzzyMatch(str, query) {
+  if (query.length === 0) return true;
+  if (str.length === 0) return false;
+  const sl = str.toLowerCase();
+  const ql = query.toLowerCase();
+  let si = 0;
+  for (let qi = 0; qi < ql.length; qi++) {
+    si = sl.indexOf(ql[qi], si);
+    if (si === -1) return false;
+    si++;
+  }
+  return true;
+}
+function maskString(str, options) {
+  if (str.length === 0) return str;
+  const maskChar = options?.char ?? "*";
+  const start = options?.start ?? Math.ceil(str.length * 0.25);
+  const end = options?.end ?? Math.floor(str.length * 0.75);
+  if (start >= end || start < 0) return str;
+  const clampedStart = Math.max(0, start);
+  const clampedEnd = Math.min(str.length, end);
+  return str.slice(0, clampedStart) + maskChar.repeat(clampedEnd - clampedStart) + str.slice(clampedEnd);
+}
+var SATUAN = ["", "satu", "dua", "tiga", "empat", "lima", "enam", "tujuh", "delapan", "sembilan"];
+var BELASAN = ["sepuluh", "sebelas", "dua belas", "tiga belas", "empat belas", "lima belas", "enam belas", "tujuh belas", "delapan belas", "sembilan belas"];
+var PULUHAN = ["", "", "dua puluh", "tiga puluh", "empat puluh", "lima puluh", "enam puluh", "tujuh puluh", "delapan puluh", "sembilan puluh"];
+function _terbilang(n) {
+  if (n < 0) return "minus " + _terbilang(-n);
+  if (n === 0) return "nol";
+  if (n < 10) return SATUAN[n];
+  if (n < 20) return n === 10 ? "sepuluh" : n === 11 ? "sebelas" : BELASAN[n - 10];
+  if (n < 100) {
+    const pul = Math.floor(n / 10);
+    const sat = n % 10;
+    return PULUHAN[pul] + (sat > 0 ? " " + SATUAN[sat] : "");
+  }
+  if (n < 1e3) {
+    const ratus = Math.floor(n / 100);
+    const sis2 = n % 100;
+    const ratusStr = ratus === 1 ? "seratus" : SATUAN[ratus] + " ratus";
+    return ratusStr + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  if (n < 1e6) {
+    const rib = Math.floor(n / 1e3);
+    const sis2 = n % 1e3;
+    const ribStr = rib === 1 ? "seribu" : _terbilang(rib) + " ribu";
+    return ribStr + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  if (n < 1e9) {
+    const jut = Math.floor(n / 1e6);
+    const sis2 = n % 1e6;
+    return _terbilang(jut) + " juta" + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  if (n < 1e12) {
+    const mil = Math.floor(n / 1e9);
+    const sis2 = n % 1e9;
+    return _terbilang(mil) + " miliar" + (sis2 > 0 ? " " + _terbilang(sis2) : "");
+  }
+  const tril = Math.floor(n / 1e12);
+  const sis = n % 1e12;
+  return _terbilang(tril) + " triliun" + (sis > 0 ? " " + _terbilang(sis) : "");
+}
+function terbilang(value) {
+  if (!Number.isFinite(value)) throw new RangeError("Input must be a finite number");
+  if (value > Number.MAX_SAFE_INTEGER) throw new RangeError("Input terlalu besar");
+  return _terbilang(Math.floor(Math.abs(value)));
+}
+function formatRupiah(value, options) {
+  return formatCurrency(value, { locale: "id-ID", currency: "IDR", notation: options?.notation });
+}
+function formatBytes(bytes, options) {
+  if (bytes === 0) return "0 B";
+  if (!Number.isFinite(bytes) || bytes < 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB", "EB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const dm = options?.decimals ?? (i === 0 ? 0 : 1);
+  const index = Math.min(i, sizes.length - 1);
+  return parseFloat((bytes / Math.pow(k, index)).toFixed(dm)) + " " + sizes[index];
+}
+function randomString(length = 16) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const bytes = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    throw new Error("Crypto API unavailable. Cannot generate secure random string.");
+  }
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars[bytes[i] % chars.length];
+  }
+  return result;
+}
+function randomBoolean() {
+  return Math.random() >= 0.5;
+}
+function pluralize(count, singular) {
+  if (count === 1) return singular;
+  const last = singular[singular.length - 1];
+  const lastTwo = singular.slice(-2);
+  if (last === "s" || last === "x" || last === "z" || lastTwo === "ch" || lastTwo === "sh") {
+    return singular + "es";
+  }
+  if (last === "y" && singular.length > 2 && !"aeiou".includes(singular[singular.length - 2])) {
+    return singular.slice(0, -1) + "ies";
+  }
+  return singular + "s";
+}
+function stripHtml(str) {
+  return str.replace(/<[^>]*>/g, "");
+}
+function truncateWords(str, count, suffix = "...") {
+  const words2 = str.split(/\s+/).filter(Boolean);
+  if (words2.length <= count) return str;
+  return words2.slice(0, count).join(" ") + suffix;
+}
+function isPalindrome(str) {
+  const cleaned = str.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+  if (cleaned.length <= 1) return true;
+  let left = 0;
+  let right = cleaned.length - 1;
+  while (left < right) {
+    if (cleaned[left] !== cleaned[right]) return false;
+    left++;
+    right--;
+  }
+  return true;
+}
+function isAnagram(str1, str2) {
+  const clean = (s) => s.replace(/\s/g, "").toLowerCase().split("").sort().join("");
+  return clean(str1) === clean(str2);
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+  const bigrams = /* @__PURE__ */ new Map();
+  for (let i = 0; i < a.length - 1; i++) {
+    const bg = a.slice(i, i + 2);
+    bigrams.set(bg, (bigrams.get(bg) ?? 0) + 1);
+  }
+  let intersection = 0;
+  for (let i = 0; i < b.length - 1; i++) {
+    const bg = b.slice(i, i + 2);
+    const count = bigrams.get(bg) ?? 0;
+    if (count > 0) {
+      bigrams.set(bg, count - 1);
+      intersection++;
+    }
+  }
+  return 2 * intersection / (a.length + b.length - 2);
+}
+function dedent(str) {
+  const lines = str.split("\n");
+  if (lines.length === 0) return str;
+  const indent = lines.reduce((min, line) => {
+    if (line.trim().length === 0) return min;
+    const leading = line.match(/^[ \t]*/)?.[0]?.length ?? 0;
+    return min === null ? leading : Math.min(min, leading);
+  }, null);
+  if (indent === null || indent === 0) return str;
+  return lines.map((line) => line.slice(indent)).join("\n");
+}
+function wordCount(str) {
+  const match = str.match(/[a-zA-Z0-9]+(?:['\u2019][a-zA-Z]+)?/g);
+  return match ? match.length : 0;
+}
+function swapCase(str) {
+  let result = "";
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    if (ch >= "a" && ch <= "z") {
+      result += ch.toUpperCase();
+    } else if (ch >= "A" && ch <= "Z") {
+      result += ch.toLowerCase();
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+function toCobolCase(str) {
+  const words2 = splitWords(str);
+  return words2.map((w) => w.toUpperCase()).join("_");
+}
+function charCount(str) {
+  const result = {};
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i];
+    result[ch] = (result[ch] ?? 0) + 1;
+  }
+  return result;
+}
+export {
+  camelCase,
+  capitalize,
+  charCount,
+  countOccurrences,
+  dedent,
+  escapeHtml,
+  formatBytes,
+  formatRupiah,
+  fuzzyMatch,
+  isAnagram,
+  isPalindrome,
+  kebabCase,
+  levenshtein,
+  maskString,
+  nanoid,
+  pad,
+  padEnd,
+  padStart,
+  pascalCase,
+  pluralize,
+  randomBoolean,
+  randomString,
+  reverse,
+  similarity,
+  slugify,
+  snakeCase,
+  stripHtml,
+  swapCase,
+  template,
+  terbilang,
+  toCobolCase,
+  trim,
+  trimEnd,
+  trimStart,
+  truncate,
+  truncateWords,
+  unescapeHtml,
+  uuid,
+  wordCount,
+  words
+};
+//# sourceMappingURL=index.js.map