@utilix-tech/sdk 0.1.0

package/dist/tools/misc.cjs

@@ -0,0 +1,1082 @@
+'use strict';
+
+// src/tools/misc.ts
+var NAMED_HTML_ENTITIES = {
+  34: """,
+  38: "&",
+  39: "'",
+  60: "<",
+  62: ">",
+  160: " ",
+  161: "¡",
+  162: "¢",
+  163: "£",
+  164: "¤",
+  165: "¥",
+  166: "¦",
+  167: "§",
+  168: "¨",
+  169: "©",
+  170: "ª",
+  171: "«",
+  172: "¬",
+  173: "­",
+  174: "®",
+  175: "¯",
+  176: "°",
+  177: "±",
+  178: "²",
+  179: "³",
+  180: "´",
+  181: "µ",
+  182: "¶",
+  183: "·",
+  184: "¸",
+  185: "¹",
+  186: "º",
+  187: "»",
+  188: "¼",
+  189: "½",
+  190: "¾",
+  191: "¿",
+  215: "×",
+  247: "÷",
+  8364: "€",
+  8482: "™",
+  8220: "“",
+  8221: "”",
+  8216: "‘",
+  8217: "’",
+  8230: "…",
+  8211: "–",
+  8212: "—",
+  8592: "←",
+  8593: "↑",
+  8594: "→",
+  8595: "↓",
+  8596: "↔",
+  8660: "⇔",
+  9824: "♠",
+  9827: "♣",
+  9829: "♥",
+  9830: "♦"
+};
+var UNICODE_NAMES = {
+  0: "NULL",
+  7: "BELL",
+  8: "BACKSPACE",
+  9: "HORIZONTAL TABULATION",
+  10: "LINE FEED",
+  13: "CARRIAGE RETURN",
+  27: "ESCAPE",
+  32: "SPACE",
+  33: "EXCLAMATION MARK",
+  34: "QUOTATION MARK",
+  35: "NUMBER SIGN",
+  36: "DOLLAR SIGN",
+  37: "PERCENT SIGN",
+  38: "AMPERSAND",
+  39: "APOSTROPHE",
+  40: "LEFT PARENTHESIS",
+  41: "RIGHT PARENTHESIS",
+  42: "ASTERISK",
+  43: "PLUS SIGN",
+  44: "COMMA",
+  45: "HYPHEN-MINUS",
+  46: "FULL STOP",
+  47: "SOLIDUS",
+  48: "DIGIT ZERO",
+  49: "DIGIT ONE",
+  50: "DIGIT TWO",
+  51: "DIGIT THREE",
+  52: "DIGIT FOUR",
+  53: "DIGIT FIVE",
+  54: "DIGIT SIX",
+  55: "DIGIT SEVEN",
+  56: "DIGIT EIGHT",
+  57: "DIGIT NINE",
+  58: "COLON",
+  59: "SEMICOLON",
+  60: "LESS-THAN SIGN",
+  61: "EQUALS SIGN",
+  62: "GREATER-THAN SIGN",
+  63: "QUESTION MARK",
+  64: "COMMERCIAL AT",
+  65: "LATIN CAPITAL LETTER A",
+  66: "LATIN CAPITAL LETTER B",
+  67: "LATIN CAPITAL LETTER C",
+  68: "LATIN CAPITAL LETTER D",
+  69: "LATIN CAPITAL LETTER E",
+  70: "LATIN CAPITAL LETTER F",
+  71: "LATIN CAPITAL LETTER G",
+  72: "LATIN CAPITAL LETTER H",
+  73: "LATIN CAPITAL LETTER I",
+  74: "LATIN CAPITAL LETTER J",
+  75: "LATIN CAPITAL LETTER K",
+  76: "LATIN CAPITAL LETTER L",
+  77: "LATIN CAPITAL LETTER M",
+  78: "LATIN CAPITAL LETTER N",
+  79: "LATIN CAPITAL LETTER O",
+  80: "LATIN CAPITAL LETTER P",
+  81: "LATIN CAPITAL LETTER Q",
+  82: "LATIN CAPITAL LETTER R",
+  83: "LATIN CAPITAL LETTER S",
+  84: "LATIN CAPITAL LETTER T",
+  85: "LATIN CAPITAL LETTER U",
+  86: "LATIN CAPITAL LETTER V",
+  87: "LATIN CAPITAL LETTER W",
+  88: "LATIN CAPITAL LETTER X",
+  89: "LATIN CAPITAL LETTER Y",
+  90: "LATIN CAPITAL LETTER Z",
+  91: "LEFT SQUARE BRACKET",
+  92: "REVERSE SOLIDUS",
+  93: "RIGHT SQUARE BRACKET",
+  94: "CIRCUMFLEX ACCENT",
+  95: "LOW LINE",
+  96: "GRAVE ACCENT",
+  97: "LATIN SMALL LETTER A",
+  98: "LATIN SMALL LETTER B",
+  99: "LATIN SMALL LETTER C",
+  100: "LATIN SMALL LETTER D",
+  101: "LATIN SMALL LETTER E",
+  102: "LATIN SMALL LETTER F",
+  103: "LATIN SMALL LETTER G",
+  104: "LATIN SMALL LETTER H",
+  105: "LATIN SMALL LETTER I",
+  106: "LATIN SMALL LETTER J",
+  107: "LATIN SMALL LETTER K",
+  108: "LATIN SMALL LETTER L",
+  109: "LATIN SMALL LETTER M",
+  110: "LATIN SMALL LETTER N",
+  111: "LATIN SMALL LETTER O",
+  112: "LATIN SMALL LETTER P",
+  113: "LATIN SMALL LETTER Q",
+  114: "LATIN SMALL LETTER R",
+  115: "LATIN SMALL LETTER S",
+  116: "LATIN SMALL LETTER T",
+  117: "LATIN SMALL LETTER U",
+  118: "LATIN SMALL LETTER V",
+  119: "LATIN SMALL LETTER W",
+  120: "LATIN SMALL LETTER X",
+  121: "LATIN SMALL LETTER Y",
+  122: "LATIN SMALL LETTER Z",
+  123: "LEFT CURLY BRACKET",
+  124: "VERTICAL LINE",
+  125: "RIGHT CURLY BRACKET",
+  126: "TILDE",
+  160: "NO-BREAK SPACE",
+  169: "COPYRIGHT SIGN",
+  174: "REGISTERED SIGN",
+  176: "DEGREE SIGN",
+  181: "MICRO SIGN",
+  183: "MIDDLE DOT",
+  215: "MULTIPLICATION SIGN",
+  247: "DIVISION SIGN",
+  233: "LATIN SMALL LETTER E WITH ACUTE",
+  224: "LATIN SMALL LETTER A WITH GRAVE",
+  226: "LATIN SMALL LETTER A WITH CIRCUMFLEX",
+  231: "LATIN SMALL LETTER C WITH CEDILLA",
+  232: "LATIN SMALL LETTER E WITH GRAVE",
+  234: "LATIN SMALL LETTER E WITH CIRCUMFLEX",
+  235: "LATIN SMALL LETTER E WITH DIAERESIS",
+  238: "LATIN SMALL LETTER I WITH CIRCUMFLEX",
+  239: "LATIN SMALL LETTER I WITH DIAERESIS",
+  244: "LATIN SMALL LETTER O WITH CIRCUMFLEX",
+  249: "LATIN SMALL LETTER U WITH GRAVE",
+  251: "LATIN SMALL LETTER U WITH CIRCUMFLEX",
+  252: "LATIN SMALL LETTER U WITH DIAERESIS",
+  257: "LATIN SMALL LETTER A WITH MACRON",
+  948: "GREEK SMALL LETTER DELTA",
+  960: "GREEK SMALL LETTER PI",
+  928: "GREEK CAPITAL LETTER PI",
+  916: "GREEK CAPITAL LETTER DELTA",
+  8364: "EURO SIGN",
+  8482: "TRADE MARK SIGN",
+  8592: "LEFTWARDS ARROW",
+  8593: "UPWARDS ARROW",
+  8594: "RIGHTWARDS ARROW",
+  8595: "DOWNWARDS ARROW",
+  8203: "ZERO WIDTH SPACE",
+  8204: "ZERO WIDTH NON-JOINER",
+  8205: "ZERO WIDTH JOINER",
+  8206: "LEFT-TO-RIGHT MARK",
+  8207: "RIGHT-TO-LEFT MARK",
+  65279: "ZERO WIDTH NO-BREAK SPACE",
+  128512: "GRINNING FACE",
+  128513: "GRINNING FACE WITH SMILING EYES",
+  128514: "FACE WITH TEARS OF JOY",
+  128515: "SMILING FACE WITH OPEN MOUTH",
+  128516: "SMILING FACE WITH OPEN MOUTH AND SMILING EYES",
+  128517: "SMILING FACE WITH OPEN MOUTH AND COLD SWEAT",
+  128518: "SMILING FACE WITH OPEN MOUTH AND TIGHTLY CLOSED EYES",
+  128519: "WINKING FACE",
+  128520: "SMILING FACE WITH SMILING EYES",
+  128521: "FACE SAVOURING DELICIOUS FOOD",
+  128522: "RELIEVED FACE",
+  128523: "SMILING FACE WITH HEART-SHAPED EYES",
+  128525: "SMILING FACE WITH HEART-EYES",
+  128526: "SMILING FACE WITH SUNGLASSES",
+  128527: "SMIRKING FACE",
+  128528: "NEUTRAL FACE",
+  9829: "BLACK HEART SUIT",
+  9824: "BLACK SPADE SUIT",
+  9827: "BLACK CLUB SUIT",
+  9830: "BLACK DIAMOND SUIT",
+  9733: "BLACK STAR",
+  9734: "WHITE STAR",
+  9654: "BLACK RIGHT-POINTING TRIANGLE",
+  9664: "BLACK LEFT-POINTING TRIANGLE",
+  9650: "BLACK UP-POINTING TRIANGLE",
+  9660: "BLACK DOWN-POINTING TRIANGLE",
+  128: "PADDING CHARACTER"
+};
+function _getCategory(cp) {
+  if (cp < 32 || cp === 127) return "Control";
+  if (cp === 32 || cp === 160 || cp === 8203 || cp === 9) return "Space";
+  if (cp >= 48 && cp <= 57) return "Digit";
+  if (cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122) return "Letter";
+  if (cp >= 128 && cp <= 591) return "Letter";
+  if (cp >= 880 && cp <= 1023) return "Letter";
+  if (cp >= 1024 && cp <= 1279) return "Letter";
+  if (cp >= 19968 && cp <= 40959) return "Letter";
+  if (cp >= 44032 && cp <= 55215) return "Letter";
+  if (cp >= 128512 && cp <= 128591) return "Emoji";
+  if (cp >= 127744 && cp <= 128511) return "Emoji";
+  if (cp >= 128640 && cp <= 128767) return "Emoji";
+  if (cp >= 128768 && cp <= 129791) return "Emoji";
+  if (cp >= 9728 && cp <= 10175) return "Emoji";
+  if (cp >= 9986 && cp <= 10160) return "Emoji";
+  if (cp === 33 || cp === 34 || cp === 39 || cp === 40 || cp === 41 || cp === 44 || cp === 45 || cp === 46 || cp === 58 || cp === 59 || cp === 63 || cp === 91 || cp === 93 || cp === 123 || cp === 125 || cp >= 8192 && cp <= 8303) return "Punctuation";
+  if (cp === 36 || cp === 37 || cp === 38 || cp === 42 || cp === 43 || cp === 60 || cp === 61 || cp === 62 || cp === 64 || cp === 94 || cp === 96 || cp === 124 || cp === 126 || cp >= 8352 && cp <= 8399 || cp >= 8448 && cp <= 8527 || cp >= 8704 && cp <= 8959) return "Symbol";
+  return "Other";
+}
+function _getUtf8Bytes(cp) {
+  const bytes = [];
+  if (cp < 128) {
+    bytes.push(cp);
+  } else if (cp < 2048) {
+    bytes.push(192 | cp >> 6);
+    bytes.push(128 | cp & 63);
+  } else if (cp < 65536) {
+    bytes.push(224 | cp >> 12);
+    bytes.push(128 | cp >> 6 & 63);
+    bytes.push(128 | cp & 63);
+  } else {
+    bytes.push(240 | cp >> 18);
+    bytes.push(128 | cp >> 12 & 63);
+    bytes.push(128 | cp >> 6 & 63);
+    bytes.push(128 | cp & 63);
+  }
+  return bytes.map((b) => b.toString(16).toUpperCase().padStart(2, "0")).join(" ");
+}
+function _getUtf16(cp) {
+  if (cp < 65536) {
+    return cp.toString(16).toUpperCase().padStart(4, "0");
+  }
+  const adjusted = cp - 65536;
+  const high = 55296 + (adjusted >> 10);
+  const low = 56320 + (adjusted & 1023);
+  return `${high.toString(16).toUpperCase().padStart(4, "0")} ${low.toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function _getHex(cp) {
+  const hex = cp.toString(16).toUpperCase().padStart(4, "0");
+  return `U+${hex}`;
+}
+function analyzeString(input) {
+  const results = [];
+  const codePoints = [...input];
+  for (const char of codePoints) {
+    const cp = char.codePointAt(0);
+    const hexStr = cp.toString(16).toUpperCase().padStart(4, "0");
+    const htmlEntity = NAMED_HTML_ENTITIES[cp] ?? `&#${cp};`;
+    results.push({
+      char,
+      codePoint: cp,
+      hex: _getHex(cp),
+      htmlEntity,
+      htmlHex: `&#x${hexStr};`,
+      utf8Bytes: _getUtf8Bytes(cp),
+      utf16: _getUtf16(cp),
+      name: UNICODE_NAMES[cp],
+      category: _getCategory(cp)
+    });
+  }
+  return results;
+}
+function toUnicodeEscape(input) {
+  const parts = [];
+  for (const char of [...input]) {
+    const cp = char.codePointAt(0);
+    if (cp > 65535) {
+      parts.push(`\\u{${cp.toString(16).toUpperCase()}}`);
+    } else {
+      parts.push(`\\u${cp.toString(16).toUpperCase().padStart(4, "0")}`);
+    }
+  }
+  return parts.join("");
+}
+function fromUnicodeEscape(input) {
+  try {
+    let result = input;
+    result = result.replace(/\\u\{([0-9A-Fa-f]+)\}/g, (_match, hex) => {
+      const cp = parseInt(hex, 16);
+      if (cp > 1114111) throw new Error(`Invalid code point: U+${hex.toUpperCase()}`);
+      return String.fromCodePoint(cp);
+    });
+    result = result.replace(/\\u([0-9A-Fa-f]{4})/g, (_match, hex) => {
+      return String.fromCharCode(parseInt(hex, 16));
+    });
+    return result;
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : "Invalid Unicode escape sequence" };
+  }
+}
+function codePointToChar(codePoint) {
+  return String.fromCodePoint(codePoint);
+}
+function charToCodePoint(char) {
+  return char.codePointAt(0);
+}
+function generateSvgFavicon(config) {
+  const { bgColor, textColor, shape, fontSize, fontWeight, size } = config;
+  const raw = config.text.trim();
+  const label = raw.length === 0 ? "?" : raw.slice(0, 2);
+  let bgElement;
+  if (shape === "circle") {
+    const r = size / 2;
+    bgElement = `<circle cx="${r}" cy="${r}" r="${r}" fill="${bgColor}"/>`;
+  } else if (shape === "square") {
+    bgElement = `<rect width="${size}" height="${size}" rx="0" fill="${bgColor}"/>`;
+  } else {
+    const rx = size * 0.2;
+    bgElement = `<rect width="${size}" height="${size}" rx="${rx}" fill="${bgColor}"/>`;
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">${bgElement}<text x="50%" y="50%" dominant-baseline="central" text-anchor="middle" fill="${textColor}" font-size="${fontSize}" font-weight="${fontWeight}" font-family="sans-serif">${label}</text></svg>`;
+}
+function svgToDataUrl(svg) {
+  return `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+}
+var DEFAULT_CONFIG = {
+  text: "A",
+  bgColor: "#6366f1",
+  textColor: "#ffffff",
+  shape: "rounded",
+  fontSize: 56,
+  fontWeight: "bold",
+  size: 64
+};
+var COLOR_PRESETS = [
+  { name: "GitHub Dark", bg: "#24292e", text: "#ffffff" },
+  { name: "VS Code Blue", bg: "#0066b8", text: "#ffffff" },
+  { name: "Vercel Black", bg: "#000000", text: "#ffffff" },
+  { name: "Stripe Purple", bg: "#635bff", text: "#ffffff" },
+  { name: "Tailwind Teal", bg: "#0ea5e9", text: "#ffffff" },
+  { name: "Firebase Orange", bg: "#ff6d00", text: "#ffffff" }
+];
+function analyzeSvg(svg) {
+  const trimmed = svg.trim();
+  if (!trimmed) {
+    return { error: "Empty input" };
+  }
+  if (!trimmed.includes("<svg")) {
+    return { error: "No <svg> element found" };
+  }
+  const widthMatch = trimmed.match(/<svg[^>]*\swidth=["']([^"']*)["']/i);
+  const heightMatch = trimmed.match(/<svg[^>]*\sheight=["']([^"']*)["']/i);
+  const viewBoxMatch = trimmed.match(/<svg[^>]*\sviewBox=["']([^"']*)["']/i);
+  const tagMatches = trimmed.matchAll(/<([a-zA-Z][a-zA-Z0-9:-]*)/g);
+  const allTags = [];
+  for (const m of tagMatches) {
+    allTags.push(m[1].toLowerCase());
+  }
+  const usedElements = [...new Set(allTags)];
+  const animationTags = ["animate", "animatetransform", "animatemotion", "set"];
+  const hasAnimation = animationTags.some((t) => usedElements.includes(t)) || /style[^>]*>[^<]*animation/i.test(trimmed);
+  const hasScript = usedElements.includes("script") || /\son\w+\s*=/i.test(trimmed);
+  const hasExternalRef = /xlink:href\s*=\s*["'](https?:|\/\/)/i.test(trimmed) || /href\s*=\s*["'](https?:|\/\/)/i.test(trimmed);
+  return {
+    width: widthMatch ? widthMatch[1] : null,
+    height: heightMatch ? heightMatch[1] : null,
+    viewBox: viewBoxMatch ? viewBoxMatch[1] : null,
+    elementCount: allTags.length,
+    hasAnimation,
+    hasScript,
+    hasExternalRef,
+    usedElements
+  };
+}
+function sanitizeSvg(svg) {
+  let result = svg;
+  result = result.replace(/<script[\s\S]*?<\/script>/gi, "");
+  result = result.replace(/\s+on\w+\s*=\s*["'][^"']*["']/gi, "");
+  result = result.replace(/\s+on\w+\s*=\s*[^\s>]*/gi, "");
+  result = result.replace(/javascript:[^"'\s]*/gi, "");
+  return result;
+}
+function optimizeSvg(svg) {
+  let result = svg;
+  result = result.replace(/<!--[\s\S]*?-->/g, "");
+  result = result.replace(/<g\s*>\s*<\/g>/gi, "");
+  result = result.replace(/<g\/>/gi, "");
+  result = result.replace(/<defs\s*>\s*<\/defs>/gi, "");
+  result = result.replace(/\n\s*\n/g, "\n");
+  return result.trim();
+}
+function formatSvg(svg) {
+  const lines = svg.replace(/></g, ">\n<").replace(/^\s+|\s+$/gm, "").split("\n").filter((l) => l.trim().length > 0);
+  let indent = 0;
+  const result = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const isClosing = /^<\//.test(trimmed);
+    const isSelfClosing = /\/>$/.test(trimmed) || /^<!/.test(trimmed);
+    const isOpening = /^<[^/!]/.test(trimmed) && !isSelfClosing;
+    if (isClosing) {
+      indent = Math.max(0, indent - 1);
+    }
+    result.push("  ".repeat(indent) + trimmed);
+    if (isOpening) {
+      indent++;
+    }
+  }
+  return result.join("\n");
+}
+function minifySvg(svg) {
+  return svg.replace(/>\s+</g, "><").replace(/\s{2,}/g, " ").trim();
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / Math.pow(1024, i);
+  if (i === 0) return `${bytes} B`;
+  return `${value.toFixed(1)} ${units[i]}`;
+}
+function calcSavings(originalBytes, compressedBytes) {
+  const savedBytes = originalBytes - compressedBytes;
+  const savedPercent = originalBytes === 0 ? 0 : Math.round(savedBytes / originalBytes * 1e4) / 100;
+  return { savedBytes, savedPercent };
+}
+function detectFormatFromDataUrl(dataUrl) {
+  const match = dataUrl.match(/^data:(image\/(?:jpeg|png|webp|gif));base64,/);
+  if (!match) return null;
+  return match[1];
+}
+function detectFormatFromFilename(filename) {
+  const lower = filename.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".gif")) return "image/gif";
+  return null;
+}
+function getDefaultQuality(format) {
+  if (format === "image/jpeg" || format === "image/webp") return 0.8;
+  return 1;
+}
+function getSupportedOutputFormats() {
+  return ["image/jpeg", "image/png", "image/webp"];
+}
+function formatLabel(format) {
+  const labels = {
+    "image/jpeg": "JPEG",
+    "image/png": "PNG",
+    "image/webp": "WebP",
+    "image/gif": "GIF"
+  };
+  return labels[format];
+}
+function calcResizeDimensions(width, height, maxWidth, maxHeight) {
+  if (!maxWidth && !maxHeight) {
+    return { width, height, changed: false };
+  }
+  let newWidth = width;
+  let newHeight = height;
+  if (maxWidth && newWidth > maxWidth) {
+    newHeight = Math.round(newHeight * maxWidth / newWidth);
+    newWidth = maxWidth;
+  }
+  if (maxHeight && newHeight > maxHeight) {
+    newWidth = Math.round(newWidth * maxHeight / newHeight);
+    newHeight = maxHeight;
+  }
+  const changed = newWidth !== width || newHeight !== height;
+  return { width: newWidth, height: newHeight, changed };
+}
+var FORMAT_EXTENSIONS = {
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp"
+};
+var FORMAT_LABELS = {
+  "image/jpeg": "JPEG",
+  "image/png": "PNG",
+  "image/webp": "WebP"
+};
+function getConversionWarnings(from, to) {
+  const warnings = [];
+  if (from === "image/png" && to === "image/jpeg") {
+    warnings.push("Transparency will be lost (replaced with white background)");
+  }
+  if (from === "image/jpeg" && to === "image/png") {
+    warnings.push("File size may increase (PNG is lossless)");
+  }
+  if (from === "image/webp" && to === "image/jpeg") {
+    warnings.push("Transparency will be lost if the WebP image has an alpha channel");
+  }
+  if (to === "image/jpeg") {
+    warnings.push("JPEG uses lossy compression \u2014 some quality may be reduced");
+  }
+  return warnings;
+}
+function getSupportedFormats() {
+  return ["image/jpeg", "image/png", "image/webp"];
+}
+function getDownloadFilename(originalName, outputFormat) {
+  const newExt = FORMAT_EXTENSIONS[outputFormat];
+  const withoutExt = originalName.replace(/\.(jpe?g|png|webp|gif|bmp|tiff?|avif|ico)$/i, "");
+  if (withoutExt === originalName) {
+    return originalName + newExt;
+  }
+  return withoutExt + newExt;
+}
+var _ONES = [
+  "",
+  "one",
+  "two",
+  "three",
+  "four",
+  "five",
+  "six",
+  "seven",
+  "eight",
+  "nine",
+  "ten",
+  "eleven",
+  "twelve",
+  "thirteen",
+  "fourteen",
+  "fifteen",
+  "sixteen",
+  "seventeen",
+  "eighteen",
+  "nineteen"
+];
+var _TENS = [
+  "",
+  "",
+  "twenty",
+  "thirty",
+  "forty",
+  "fifty",
+  "sixty",
+  "seventy",
+  "eighty",
+  "ninety"
+];
+var _SCALES = [
+  "",
+  "thousand",
+  "million",
+  "billion",
+  "trillion",
+  "quadrillion"
+];
+function _convertHundreds(n) {
+  if (n === 0) return "";
+  if (n < 20) return _ONES[n];
+  if (n < 100) {
+    const ten = _TENS[Math.floor(n / 10)];
+    const one = _ONES[n % 10];
+    return one ? `${ten}-${one}` : ten;
+  }
+  const hundred = _ONES[Math.floor(n / 100)];
+  const rest = _convertHundreds(n % 100);
+  return rest ? `${hundred} hundred ${rest}` : `${hundred} hundred`;
+}
+function numberToWords(n) {
+  if (!isFinite(n) || isNaN(n)) {
+    return { error: "Input must be a finite number" };
+  }
+  const MAX = 999999999999999;
+  if (Math.abs(Math.trunc(n)) > MAX) {
+    return { error: `Number out of range (max \xB1${MAX})` };
+  }
+  if (n === 0) return "zero";
+  const isNegative = n < 0;
+  const absVal = Math.abs(n);
+  const decimalIndex = absVal.toString().indexOf(".");
+  let intPart = Math.trunc(absVal);
+  let decimalWords = "";
+  if (decimalIndex !== -1) {
+    const decStr = absVal.toString().slice(decimalIndex + 1);
+    const decDigits = decStr.split("").map(Number);
+    decimalWords = " point " + decDigits.map((d) => _ONES[d] || "zero").join(" ");
+  }
+  if (intPart === 0 && decimalWords) {
+    const prefix2 = isNegative ? "negative " : "";
+    return `${prefix2}zero${decimalWords}`;
+  }
+  let result = "";
+  let scaleIndex = 0;
+  while (intPart > 0) {
+    const chunk = intPart % 1e3;
+    if (chunk !== 0) {
+      const chunkWords = _convertHundreds(chunk);
+      const scale = _SCALES[scaleIndex];
+      result = scale ? `${chunkWords} ${scale}${result ? " " + result : ""}` : chunkWords;
+    }
+    intPart = Math.floor(intPart / 1e3);
+    scaleIndex++;
+  }
+  const prefix = isNegative ? "negative " : "";
+  return `${prefix}${result}${decimalWords}`;
+}
+function numberToOrdinal(n) {
+  if (!Number.isInteger(n) || !isFinite(n)) {
+    return { error: "Input must be a finite integer" };
+  }
+  const abs = Math.abs(n);
+  const lastTwo = abs % 100;
+  const lastOne = abs % 10;
+  let suffix;
+  if (lastTwo >= 11 && lastTwo <= 13) {
+    suffix = "th";
+  } else if (lastOne === 1) {
+    suffix = "st";
+  } else if (lastOne === 2) {
+    suffix = "nd";
+  } else if (lastOne === 3) {
+    suffix = "rd";
+  } else {
+    suffix = "th";
+  }
+  return `${n}${suffix}`;
+}
+var _ORDINAL_ONES = [
+  "",
+  "first",
+  "second",
+  "third",
+  "fourth",
+  "fifth",
+  "sixth",
+  "seventh",
+  "eighth",
+  "ninth",
+  "tenth",
+  "eleventh",
+  "twelfth",
+  "thirteenth",
+  "fourteenth",
+  "fifteenth",
+  "sixteenth",
+  "seventeenth",
+  "eighteenth",
+  "nineteenth"
+];
+var _ORDINAL_TENS = [
+  "",
+  "",
+  "twentieth",
+  "thirtieth",
+  "fortieth",
+  "fiftieth",
+  "sixtieth",
+  "seventieth",
+  "eightieth",
+  "ninetieth"
+];
+function _convertOrdinalHundreds(n) {
+  if (n < 20) return _ORDINAL_ONES[n];
+  if (n < 100) {
+    const tenIndex = Math.floor(n / 10);
+    const one = n % 10;
+    if (one === 0) return _ORDINAL_TENS[tenIndex];
+    return `${_TENS[tenIndex]}-${_ORDINAL_ONES[one]}`;
+  }
+  const hundred = _ONES[Math.floor(n / 100)];
+  const rest = n % 100;
+  if (rest === 0) return `${hundred} hundredth`;
+  return `${hundred} hundred ${_convertOrdinalHundreds(rest)}`;
+}
+function ordinalWords(n) {
+  if (!Number.isInteger(n) || !isFinite(n) || n < 0) {
+    return { error: "Input must be a non-negative finite integer" };
+  }
+  if (n === 0) return "zeroth";
+  const MAX = 999999999999999;
+  if (n > MAX) return { error: `Number out of range (max ${MAX})` };
+  const wordsResult = numberToWords(n);
+  if (typeof wordsResult !== "string") return wordsResult;
+  if (n <= 999) {
+    return _convertOrdinalHundreds(n);
+  }
+  const lastChunk = n % 1e3;
+  if (lastChunk === 0) {
+    const words = wordsResult;
+    const parts = words.split(" ");
+    const lastWord = parts[parts.length - 1];
+    const ordinalScale = {
+      thousand: "thousandth",
+      million: "millionth",
+      billion: "billionth",
+      trillion: "trillionth",
+      quadrillion: "quadrillionth"
+    };
+    if (ordinalScale[lastWord]) {
+      parts[parts.length - 1] = ordinalScale[lastWord];
+      return parts.join(" ");
+    }
+    return words + "th";
+  }
+  const lastChunkCardinal = _convertHundreds(lastChunk);
+  const lastChunkOrdinal = _convertOrdinalHundreds(lastChunk);
+  const idx = wordsResult.lastIndexOf(lastChunkCardinal);
+  if (idx !== -1) {
+    return wordsResult.slice(0, idx) + lastChunkOrdinal;
+  }
+  return wordsResult + "th";
+}
+var _ROMAN_VALUES = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function numberToRoman(n) {
+  if (!Number.isInteger(n) || n < 1 || n > 3999) {
+    return { error: "Input must be an integer between 1 and 3999" };
+  }
+  let result = "";
+  let remaining = n;
+  for (const [value, numeral] of _ROMAN_VALUES) {
+    while (remaining >= value) {
+      result += numeral;
+      remaining -= value;
+    }
+  }
+  return result;
+}
+var _ROMAN_MAP = {
+  I: 1,
+  V: 5,
+  X: 10,
+  L: 50,
+  C: 100,
+  D: 500,
+  M: 1e3
+};
+function romanToNumber(roman) {
+  if (!roman || !/^[IVXLCDM]+$/i.test(roman)) {
+    return { error: `Invalid Roman numeral: ${roman}` };
+  }
+  const upper = roman.toUpperCase();
+  let result = 0;
+  for (let i = 0; i < upper.length; i++) {
+    const curr = _ROMAN_MAP[upper[i]];
+    const next = _ROMAN_MAP[upper[i + 1]];
+    if (curr === void 0) return { error: `Invalid Roman numeral character: ${upper[i]}` };
+    if (next && curr < next) {
+      result -= curr;
+    } else {
+      result += curr;
+    }
+  }
+  const roundTrip = numberToRoman(result);
+  if (typeof roundTrip !== "string" || roundTrip !== upper) {
+    return { error: `Invalid Roman numeral: ${roman}` };
+  }
+  return result;
+}
+var DATA_TYPES = [
+  { value: "name", label: "Full Name", example: "John Smith" },
+  { value: "email", label: "Email Address", example: "john.smith@gmail.com" },
+  { value: "uuid", label: "UUID", example: "550e8400-e29b-41d4-a716-446655440000" },
+  { value: "phone", label: "Phone Number", example: "(555) 123-4567" },
+  { value: "date", label: "Date", example: "2024-03-15" },
+  { value: "number", label: "Number", example: "742" },
+  { value: "boolean", label: "Boolean", example: "true" },
+  { value: "color", label: "Hex Color", example: "#a3f2c1" },
+  { value: "url", label: "URL", example: "https://www.example.com/page" },
+  { value: "ipv4", label: "IPv4 Address", example: "192.168.1.1" },
+  { value: "sentence", label: "Sentence", example: "The quick brown fox jumps over the lazy dog" },
+  { value: "paragraph", label: "Paragraph", example: "Multiple sentences forming a paragraph." }
+];
+var _FIRST_NAMES = [
+  "James",
+  "Mary",
+  "John",
+  "Patricia",
+  "Robert",
+  "Jennifer",
+  "Michael",
+  "Linda",
+  "William",
+  "Barbara",
+  "David",
+  "Elizabeth",
+  "Richard",
+  "Susan",
+  "Joseph",
+  "Jessica",
+  "Thomas",
+  "Sarah",
+  "Charles",
+  "Karen",
+  "Christopher",
+  "Lisa",
+  "Daniel",
+  "Nancy",
+  "Matthew",
+  "Betty",
+  "Anthony",
+  "Margaret",
+  "Mark",
+  "Sandra"
+];
+var _LAST_NAMES = [
+  "Smith",
+  "Johnson",
+  "Williams",
+  "Brown",
+  "Jones",
+  "Garcia",
+  "Miller",
+  "Davis",
+  "Rodriguez",
+  "Martinez",
+  "Hernandez",
+  "Lopez",
+  "Gonzalez",
+  "Wilson",
+  "Anderson",
+  "Thomas",
+  "Taylor",
+  "Moore",
+  "Jackson",
+  "Martin",
+  "Lee",
+  "Perez",
+  "Thompson",
+  "White",
+  "Harris",
+  "Sanchez",
+  "Clark",
+  "Ramirez",
+  "Lewis",
+  "Robinson"
+];
+var _EMAIL_DOMAINS = ["gmail.com", "yahoo.com", "outlook.com", "hotmail.com", "icloud.com"];
+var _URL_DOMAINS = ["example", "mysite", "testdomain", "webservice", "apphost", "platform"];
+var _URL_TLDS = ["com", "net", "org", "io", "dev"];
+var _URL_PATHS = ["home", "about", "contact", "products", "services", "blog", "news", "help", "docs", "api"];
+var _WORDS = [
+  "the",
+  "quick",
+  "brown",
+  "fox",
+  "jumps",
+  "over",
+  "lazy",
+  "dog",
+  "bright",
+  "sun",
+  "shines",
+  "every",
+  "day",
+  "blue",
+  "sky",
+  "above",
+  "green",
+  "trees",
+  "grow",
+  "tall",
+  "small",
+  "birds",
+  "sing",
+  "sweet",
+  "songs",
+  "fresh",
+  "wind",
+  "blows",
+  "cold",
+  "rain",
+  "falls",
+  "soft",
+  "light",
+  "glows",
+  "deep",
+  "ocean",
+  "waves",
+  "crash",
+  "rocky",
+  "shore",
+  "people",
+  "walk",
+  "through",
+  "quiet",
+  "streets",
+  "busy",
+  "city",
+  "moves",
+  "fast",
+  "time"
+];
+function _rand(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function _pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function _hexByte() {
+  return Math.floor(Math.random() * 256).toString(16).padStart(2, "0");
+}
+function _generateName() {
+  return `${_pick(_FIRST_NAMES)} ${_pick(_LAST_NAMES)}`;
+}
+function _generateEmail() {
+  const first = _pick(_FIRST_NAMES).toLowerCase();
+  const last = _pick(_LAST_NAMES).toLowerCase();
+  const domain = _pick(_EMAIL_DOMAINS);
+  const sep = _pick([".", "_", ""]);
+  return `${first}${sep}${last}@${domain}`;
+}
+function _generateUUID() {
+  const s4 = () => Math.floor(Math.random() * 65536).toString(16).padStart(4, "0");
+  const s8 = () => Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
+  const y = (Math.floor(Math.random() * 4) + 8).toString(16);
+  return `${s8()}-${s4()}-4${s4().slice(1)}-${y}${s4().slice(1)}-${s4()}${s8().slice(0, 8)}`;
+}
+function _generatePhone() {
+  const area = _rand(200, 999);
+  const prefix = _rand(200, 999);
+  const line = _rand(1e3, 9999);
+  return `(${area}) ${prefix}-${line}`;
+}
+function _generateDate(format = "iso") {
+  const year = _rand(1970, 2030);
+  const month = _rand(1, 12);
+  const day = _rand(1, 28);
+  const mm = String(month).padStart(2, "0");
+  const dd = String(day).padStart(2, "0");
+  if (format === "us") return `${mm}/${dd}/${year}`;
+  if (format === "eu") return `${dd}/${mm}/${year}`;
+  return `${year}-${mm}-${dd}`;
+}
+function _generateNumber(min = 0, max = 1e3) {
+  return String(_rand(min, max));
+}
+function _generateBoolean() {
+  return Math.random() < 0.5 ? "true" : "false";
+}
+function _generateColor() {
+  return `#${_hexByte()}${_hexByte()}${_hexByte()}`;
+}
+function _generateURL() {
+  const domain = _pick(_URL_DOMAINS);
+  const tld = _pick(_URL_TLDS);
+  const path = _pick(_URL_PATHS);
+  return `https://www.${domain}.${tld}/${path}`;
+}
+function _generateIPv4() {
+  return `${_rand(0, 255)}.${_rand(0, 255)}.${_rand(0, 255)}.${_rand(0, 255)}`;
+}
+function _generateSentenceText() {
+  const length = _rand(6, 12);
+  const words = [];
+  for (let i = 0; i < length; i++) {
+    words.push(_pick(_WORDS));
+  }
+  const sentence = words.join(" ");
+  return sentence.charAt(0).toUpperCase() + sentence.slice(1) + ".";
+}
+function _generateParagraph() {
+  const count = _rand(3, 5);
+  const sentences = [];
+  for (let i = 0; i < count; i++) {
+    sentences.push(_generateSentenceText());
+  }
+  return sentences.join(" ");
+}
+function generateSingle(type, options) {
+  switch (type) {
+    case "name":
+      return _generateName();
+    case "email":
+      return _generateEmail();
+    case "uuid":
+      return _generateUUID();
+    case "phone":
+      return _generatePhone();
+    case "date":
+      return _generateDate(options?.dateFormat ?? "iso");
+    case "number":
+      return _generateNumber(options?.min ?? 0, options?.max ?? 1e3);
+    case "boolean":
+      return _generateBoolean();
+    case "color":
+      return _generateColor();
+    case "url":
+      return _generateURL();
+    case "ipv4":
+      return _generateIPv4();
+    case "sentence":
+      return _generateSentenceText();
+    case "paragraph":
+      return _generateParagraph();
+  }
+}
+function generateData(config) {
+  const count = Math.min(Math.max(config.count, 1), 100);
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    results.push(generateSingle(config.type, config.options));
+  }
+  return results;
+}
+
+exports.COLOR_PRESETS = COLOR_PRESETS;
+exports.DATA_TYPES = DATA_TYPES;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.FORMAT_EXTENSIONS = FORMAT_EXTENSIONS;
+exports.FORMAT_LABELS = FORMAT_LABELS;
+exports.analyzeString = analyzeString;
+exports.analyzeSvg = analyzeSvg;
+exports.calcResizeDimensions = calcResizeDimensions;
+exports.calcSavings = calcSavings;
+exports.charToCodePoint = charToCodePoint;
+exports.codePointToChar = codePointToChar;
+exports.detectFormatFromDataUrl = detectFormatFromDataUrl;
+exports.detectFormatFromFilename = detectFormatFromFilename;
+exports.formatBytes = formatBytes;
+exports.formatLabel = formatLabel;
+exports.formatSvg = formatSvg;
+exports.fromUnicodeEscape = fromUnicodeEscape;
+exports.generateData = generateData;
+exports.generateSingle = generateSingle;
+exports.generateSvgFavicon = generateSvgFavicon;
+exports.getConversionWarnings = getConversionWarnings;
+exports.getDefaultQuality = getDefaultQuality;
+exports.getDownloadFilename = getDownloadFilename;
+exports.getSupportedFormats = getSupportedFormats;
+exports.getSupportedOutputFormats = getSupportedOutputFormats;
+exports.minifySvg = minifySvg;
+exports.numberToOrdinal = numberToOrdinal;
+exports.numberToRoman = numberToRoman;
+exports.numberToWords = numberToWords;
+exports.optimizeSvg = optimizeSvg;
+exports.ordinalWords = ordinalWords;
+exports.romanToNumber = romanToNumber;
+exports.sanitizeSvg = sanitizeSvg;
+exports.svgToDataUrl = svgToDataUrl;
+exports.toUnicodeEscape = toUnicodeEscape;