@utilix-tech/sdk 0.1.0

package/dist/chunk-XST6X3HT.js

@@ -0,0 +1,896 @@
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/tools/units.ts
+var units_exports = {};
+__export(units_exports, {
+  BASE_LABELS: () => BASE_LABELS,
+  BASE_PREFIXES: () => BASE_PREFIXES,
+  BYTE_UNITS: () => BYTE_UNITS,
+  COMMON_CURRENCIES: () => COMMON_CURRENCIES,
+  COMMON_LOCALES: () => COMMON_LOCALES,
+  COMMON_PERMISSIONS: () => COMMON_PERMISSIONS,
+  COMMON_RATIOS: () => COMMON_RATIOS,
+  COMMON_SIZES: () => COMMON_SIZES,
+  COMMON_VIEWPORTS: () => COMMON_VIEWPORTS,
+  autoFormat: () => autoFormat,
+  bumpVersion: () => bumpVersion,
+  calcAspectRatio: () => calcAspectRatio,
+  calcSubnet: () => calcSubnet,
+  compareSemver: () => compareSemver,
+  convert: () => convert,
+  convertBytes: () => convertBytes,
+  convertIp: () => convertIp,
+  coverBox: () => coverBox,
+  decimalToIp: () => decimalToIp,
+  decimalToIpCidr: () => decimalToIpCidr,
+  describePermissions: () => describePermissions,
+  fitIntoBox: () => fitIntoBox,
+  formatNumber: () => formatNumber,
+  formatValue: () => formatValue,
+  formatVwValue: () => formatVwValue,
+  formatWithSeparator: () => formatWithSeparator,
+  gcd: () => gcd,
+  ipFromBinary: () => ipFromBinary,
+  ipFromDecimal: () => ipFromDecimal,
+  ipFromHex: () => ipFromHex,
+  ipToBinary: () => ipToBinary,
+  ipToDecimal: () => ipToDecimal,
+  ipToDecimalCidr: () => ipToDecimalCidr,
+  ipToHex: () => ipToHex,
+  ipToOctal: () => ipToOctal,
+  isValid: () => isValid,
+  isValidCidr: () => isValidCidr,
+  isValidIp: () => isValidIp,
+  isValidIpv4: () => isValidIpv4,
+  octalToPermissions: () => octalToPermissions,
+  parseFileSize: () => parseFileSize,
+  parseInput: () => parseInput,
+  parseNumberString: () => parseNumberString,
+  parseSemver: () => parseSemver,
+  permissionsToChmod: () => permissionsToChmod,
+  permissionsToOctal: () => permissionsToOctal,
+  permissionsToSymbolic: () => permissionsToSymbolic,
+  ptToPx: () => ptToPx,
+  pxToAll: () => pxToAll,
+  pxToViewport: () => pxToViewport,
+  remToPx: () => remToPx,
+  satisfiesRange: () => satisfiesRange,
+  scaleByHeight: () => scaleByHeight,
+  scaleByWidth: () => scaleByWidth,
+  sortVersions: () => sortVersions,
+  splitSubnet: () => splitSubnet,
+  symbolicToPermissions: () => symbolicToPermissions,
+  viewportToPx: () => viewportToPx
+});
+function pxToAll(px, baseFontSize = 16, viewportWidth = 1440, viewportHeight = 900) {
+  return {
+    px,
+    rem: px / baseFontSize,
+    em: px / baseFontSize,
+    pt: px * 0.75,
+    vw: px / viewportWidth * 100,
+    vh: px / viewportHeight * 100
+  };
+}
+function remToPx(rem, baseFontSize = 16) {
+  return rem * baseFontSize;
+}
+function ptToPx(pt) {
+  return pt / 0.75;
+}
+function formatValue(value, unit, decimals = 4) {
+  return `${value.toFixed(decimals)}${unit}`;
+}
+var COMMON_SIZES = [
+  { px: 8, label: "8px \u2014 Extra small spacing / icon size" },
+  { px: 12, label: "12px \u2014 Small text / caption" },
+  { px: 14, label: "14px \u2014 Body small / secondary text" },
+  { px: 16, label: "16px \u2014 Base font size / body text" },
+  { px: 18, label: "18px \u2014 Body large / lead text" },
+  { px: 20, label: "20px \u2014 Subheading / large body" },
+  { px: 24, label: "24px \u2014 H4 / section title" },
+  { px: 32, label: "32px \u2014 H3 / card heading" },
+  { px: 48, label: "48px \u2014 H2 / page section heading" },
+  { px: 64, label: "64px \u2014 H1 / hero heading" }
+];
+function pxToViewport(px, viewportWidth = 1440, viewportHeight = 900) {
+  const vw = parseFloat((px / viewportWidth * 100).toFixed(4));
+  const vh = parseFloat((px / viewportHeight * 100).toFixed(4));
+  const vmin = parseFloat((px / Math.min(viewportWidth, viewportHeight) * 100).toFixed(4));
+  const vmax = parseFloat((px / Math.max(viewportWidth, viewportHeight) * 100).toFixed(4));
+  const percent = vw;
+  return { px, vw, vh, vmin, vmax, percent };
+}
+function viewportToPx(vw, viewportWidth = 1440) {
+  return parseFloat((vw / 100 * viewportWidth).toFixed(2));
+}
+var COMMON_VIEWPORTS = [
+  { label: "Mobile", width: 375, height: 812 },
+  { label: "Tablet", width: 768, height: 1024 },
+  { label: "Laptop", width: 1280, height: 800 },
+  { label: "Desktop", width: 1440, height: 900 },
+  { label: "Wide", width: 1920, height: 1080 },
+  { label: "4K", width: 3840, height: 2160 },
+  { label: "iPad Pro", width: 1024, height: 1366 },
+  { label: "Surface Pro", width: 912, height: 1368 }
+];
+function formatVwValue(value, decimals = 2) {
+  return `${value.toFixed(decimals)}vw`;
+}
+var BYTE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB", "KiB", "MiB", "GiB", "TiB"];
+var TO_BYTES = {
+  B: 1,
+  KB: 1e3,
+  MB: 1e3 ** 2,
+  GB: 1e3 ** 3,
+  TB: 1e3 ** 4,
+  PB: 1e3 ** 5,
+  KiB: 1024,
+  MiB: 1024 ** 2,
+  GiB: 1024 ** 3,
+  TiB: 1024 ** 4
+};
+function convertBytes(value, fromUnit) {
+  const bytes = value * TO_BYTES[fromUnit];
+  return BYTE_UNITS.reduce((acc, unit) => {
+    const converted = bytes / TO_BYTES[unit];
+    acc[unit] = {
+      value: converted,
+      unit,
+      formatted: `${converted.toFixed(2)} ${unit}`
+    };
+    return acc;
+  }, {});
+}
+var SI_UNITS = ["PB", "TB", "GB", "MB", "KB", "B"];
+function autoFormat(bytes) {
+  for (const unit of SI_UNITS) {
+    if (bytes >= TO_BYTES[unit]) {
+      const value = bytes / TO_BYTES[unit];
+      return `${value.toFixed(2)} ${unit}`;
+    }
+  }
+  return `${bytes.toFixed(2)} B`;
+}
+var UNIT_ALIASES = {
+  b: "B",
+  kb: "KB",
+  mb: "MB",
+  gb: "GB",
+  tb: "TB",
+  pb: "PB",
+  kib: "KiB",
+  mib: "MiB",
+  gib: "GiB",
+  tib: "TiB"
+};
+function parseFileSize(input) {
+  if (!input || input.trim() === "") return null;
+  const match = input.trim().match(/^([0-9]*\.?[0-9]+)\s*([a-zA-Z]+)$/);
+  if (!match) return null;
+  const numericValue = parseFloat(match[1]);
+  if (isNaN(numericValue)) return null;
+  const unitStr = match[2].toLowerCase();
+  const unit = UNIT_ALIASES[unitStr];
+  if (!unit) return null;
+  return numericValue * TO_BYTES[unit];
+}
+var BASE_PREFIXES = {
+  2: "0b",
+  8: "0o",
+  10: "",
+  16: "0x"
+};
+var BASE_LABELS = {
+  2: "Binary",
+  8: "Octal",
+  10: "Decimal",
+  16: "Hex"
+};
+function parseInput(input, fromBase) {
+  const trimmed = input.trim();
+  if (!trimmed) return { value: 0n, error: "Empty input" };
+  const clean = trimmed.replace(/^0b/i, "").replace(/^0o/i, "").replace(/^0x/i, "").replace(/[\s_]/g, "");
+  if (!clean) return { value: 0n, error: "Empty input" };
+  const validChars = {
+    2: /^[01]+$/,
+    8: /^[0-7]+$/,
+    10: /^-?\d+$/,
+    16: /^[0-9a-fA-F]+$/
+  };
+  if (!validChars[fromBase].test(clean)) {
+    return { value: 0n, error: `Invalid character for base ${fromBase}` };
+  }
+  try {
+    const value = BigInt(
+      fromBase === 10 ? clean : `0${fromBase === 2 ? "b" : fromBase === 8 ? "o" : "x"}${clean}`
+    );
+    return { value };
+  } catch {
+    return { value: 0n, error: "Parse error" };
+  }
+}
+function convert(input, fromBase) {
+  const { value, error } = parseInput(input, fromBase);
+  if (error && error !== "Empty input") {
+    return { binary: "", octal: "", decimal: "", hex: "", error };
+  }
+  if (error === "Empty input") {
+    return { binary: "", octal: "", decimal: "", hex: "" };
+  }
+  return {
+    binary: value.toString(2),
+    octal: value.toString(8),
+    decimal: value.toString(10),
+    hex: value.toString(16).toUpperCase()
+  };
+}
+function formatWithSeparator(value, groupSize = 4) {
+  if (value.length <= groupSize) return value;
+  const chunks = [];
+  let i = value.length;
+  while (i > 0) {
+    chunks.unshift(value.slice(Math.max(0, i - groupSize), i));
+    i -= groupSize;
+  }
+  return chunks.join(" ");
+}
+var COMMON_LOCALES = [
+  { locale: "en-US", label: "English (US)", example: "1,234.56" },
+  { locale: "en-GB", label: "English (UK)", example: "1,234.56" },
+  { locale: "de-DE", label: "German (Germany)", example: "1.234,56" },
+  { locale: "fr-FR", label: "French (France)", example: "1 234,56" },
+  { locale: "ja-JP", label: "Japanese (Japan)", example: "1,234.56" },
+  { locale: "zh-CN", label: "Chinese (Simplified)", example: "1,234.56" },
+  { locale: "zh-TW", label: "Chinese (Traditional)", example: "1,234.56" },
+  { locale: "ko-KR", label: "Korean (Korea)", example: "1,234.56" },
+  { locale: "es-ES", label: "Spanish (Spain)", example: "1.234,56" },
+  { locale: "es-MX", label: "Spanish (Mexico)", example: "1,234.56" },
+  { locale: "pt-BR", label: "Portuguese (Brazil)", example: "1.234,56" },
+  { locale: "pt-PT", label: "Portuguese (Portugal)", example: "1 234,56" },
+  { locale: "ru-RU", label: "Russian (Russia)", example: "1 234,56" },
+  { locale: "ar-SA", label: "Arabic (Saudi Arabia)", example: "\u0661\u066C\u0662\u0663\u0664\u066B\u0665\u0666" },
+  { locale: "hi-IN", label: "Hindi (India)", example: "1,234.56" },
+  { locale: "it-IT", label: "Italian (Italy)", example: "1.234,56" },
+  { locale: "nl-NL", label: "Dutch (Netherlands)", example: "1.234,56" },
+  { locale: "sv-SE", label: "Swedish (Sweden)", example: "1 234,56" },
+  { locale: "tr-TR", label: "Turkish (Turkey)", example: "1.234,56" },
+  { locale: "pl-PL", label: "Polish (Poland)", example: "1 234,56" }
+];
+var COMMON_CURRENCIES = [
+  { code: "USD", name: "US Dollar", symbol: "$" },
+  { code: "EUR", name: "Euro", symbol: "\u20AC" },
+  { code: "GBP", name: "British Pound", symbol: "\xA3" },
+  { code: "JPY", name: "Japanese Yen", symbol: "\xA5" },
+  { code: "CNY", name: "Chinese Yuan", symbol: "\xA5" },
+  { code: "KRW", name: "South Korean Won", symbol: "\u20A9" },
+  { code: "INR", name: "Indian Rupee", symbol: "\u20B9" },
+  { code: "CAD", name: "Canadian Dollar", symbol: "CA$" },
+  { code: "AUD", name: "Australian Dollar", symbol: "A$" },
+  { code: "CHF", name: "Swiss Franc", symbol: "CHF" },
+  { code: "BRL", name: "Brazilian Real", symbol: "R$" },
+  { code: "MXN", name: "Mexican Peso", symbol: "MX$" },
+  { code: "SEK", name: "Swedish Krona", symbol: "kr" },
+  { code: "NOK", name: "Norwegian Krone", symbol: "kr" },
+  { code: "DKK", name: "Danish Krone", symbol: "kr" },
+  { code: "RUB", name: "Russian Ruble", symbol: "\u20BD" },
+  { code: "TRY", name: "Turkish Lira", symbol: "\u20BA" },
+  { code: "SAR", name: "Saudi Riyal", symbol: "\uFDFC" },
+  { code: "AED", name: "UAE Dirham", symbol: "\u062F.\u0625" },
+  { code: "SGD", name: "Singapore Dollar", symbol: "S$" }
+];
+function formatNumber(value, options) {
+  if (!isFinite(value)) {
+    return { error: "Value must be a finite number" };
+  }
+  try {
+    const intlOptions = {};
+    if (options.style === "decimal") {
+      intlOptions.style = "decimal";
+    } else if (options.style === "currency") {
+      if (!options.currency) {
+        return { error: "Currency code is required for currency style" };
+      }
+      intlOptions.style = "currency";
+      intlOptions.currency = options.currency;
+    } else if (options.style === "percent") {
+      intlOptions.style = "percent";
+    } else if (options.style === "scientific") {
+      intlOptions.notation = "scientific";
+    } else if (options.style === "engineering") {
+      intlOptions.notation = "engineering";
+    } else if (options.style === "compact") {
+      intlOptions.notation = "compact";
+    }
+    if (options.minimumFractionDigits !== void 0) {
+      intlOptions.minimumFractionDigits = options.minimumFractionDigits;
+    }
+    if (options.maximumFractionDigits !== void 0) {
+      intlOptions.maximumFractionDigits = options.maximumFractionDigits;
+    }
+    if (options.useGrouping !== void 0) {
+      intlOptions.useGrouping = options.useGrouping;
+    }
+    return new Intl.NumberFormat(options.locale, intlOptions).format(value);
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : "Formatting failed" };
+  }
+}
+function parseNumberString(input) {
+  if (!input || typeof input !== "string") {
+    return { error: "Input must be a non-empty string" };
+  }
+  const trimmed = input.trim();
+  if (trimmed === "") {
+    return { error: "Input must be a non-empty string" };
+  }
+  const cleaned = trimmed.replace(/[,،٬]/g, "").replace(/\s/g, "").replace(/[٫]/g, ".");
+  const result = parseFloat(cleaned);
+  if (isNaN(result)) {
+    return { error: `Cannot parse "${input}" as a number` };
+  }
+  return result;
+}
+var COMMON_RATIOS = [
+  { ratio: "16:9", decimal: 16 / 9, description: "Widescreen HD, most monitors and TVs" },
+  { ratio: "4:3", decimal: 4 / 3, description: "Traditional TV, older monitors" },
+  { ratio: "1:1", decimal: 1, description: "Square, Instagram posts" },
+  { ratio: "21:9", decimal: 21 / 9, description: "Ultra-wide cinema" },
+  { ratio: "3:2", decimal: 3 / 2, description: "Photography (35mm film)" },
+  { ratio: "9:16", decimal: 9 / 16, description: "Portrait, mobile video" },
+  { ratio: "5:4", decimal: 5 / 4, description: "Old monitors, medium format" },
+  { ratio: "2:1", decimal: 2, description: "Univisium, dual-square" }
+];
+function gcd(a, b) {
+  a = Math.abs(Math.round(a));
+  b = Math.abs(Math.round(b));
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+function calcAspectRatio(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height)) {
+    return { error: "Width and height must be finite numbers" };
+  }
+  if (width <= 0 || height <= 0) {
+    return { error: "Width and height must be positive numbers" };
+  }
+  const g = gcd(width, height);
+  const rw = width / g;
+  const rh = height / g;
+  const ratio = `${rw}:${rh}`;
+  const decimal = width / height;
+  const percentage = height / width * 100;
+  const tolerance = 0.01;
+  const isCommon = COMMON_RATIOS.some((r) => Math.abs(r.decimal - decimal) < tolerance);
+  return { ratio, decimal, percentage, gcd: g, isCommon };
+}
+function scaleByWidth(dimensions, newWidth) {
+  const scale = newWidth / dimensions.width;
+  return {
+    width: newWidth,
+    height: Math.round(dimensions.height * scale)
+  };
+}
+function scaleByHeight(dimensions, newHeight) {
+  const scale = newHeight / dimensions.height;
+  return {
+    width: Math.round(dimensions.width * scale),
+    height: newHeight
+  };
+}
+function fitIntoBox(dimensions, box) {
+  const widthScale = box.width / dimensions.width;
+  const heightScale = box.height / dimensions.height;
+  const scale = Math.min(widthScale, heightScale);
+  return {
+    width: Math.round(dimensions.width * scale),
+    height: Math.round(dimensions.height * scale)
+  };
+}
+function coverBox(dimensions, box) {
+  const widthScale = box.width / dimensions.width;
+  const heightScale = box.height / dimensions.height;
+  const scale = Math.max(widthScale, heightScale);
+  return {
+    width: Math.round(dimensions.width * scale),
+    height: Math.round(dimensions.height * scale)
+  };
+}
+function parsePermBits(bits) {
+  return {
+    read: (bits & 4) !== 0,
+    write: (bits & 2) !== 0,
+    execute: (bits & 1) !== 0
+  };
+}
+function permToNum(p) {
+  return (p.read ? 4 : 0) + (p.write ? 2 : 0) + (p.execute ? 1 : 0);
+}
+function octalToPermissions(octal) {
+  const clean = octal.replace(/^0+/, "") || "0";
+  if (!/^\d+$/.test(clean)) return { error: "Invalid octal: must contain only digits" };
+  let num;
+  if (clean.length <= 3) {
+    if (!/^[0-7]+$/.test(clean)) return { error: "Invalid octal: digits must be 0-7" };
+    num = parseInt(clean, 8);
+    return {
+      owner: parsePermBits(num >> 6 & 7),
+      group: parsePermBits(num >> 3 & 7),
+      others: parsePermBits(num & 7)
+    };
+  } else if (clean.length === 4) {
+    if (!/^[0-7]+$/.test(clean)) return { error: "Invalid octal: digits must be 0-7" };
+    num = parseInt(clean, 8);
+    const special = num >> 9 & 7;
+    return {
+      owner: parsePermBits(num >> 6 & 7),
+      group: parsePermBits(num >> 3 & 7),
+      others: parsePermBits(num & 7),
+      setuid: (special & 4) !== 0,
+      setgid: (special & 2) !== 0,
+      sticky: (special & 1) !== 0
+    };
+  } else {
+    return { error: "Invalid octal: too many digits" };
+  }
+}
+function permissionsToOctal(perms) {
+  const owner = permToNum(perms.owner);
+  const group = permToNum(perms.group);
+  const others = permToNum(perms.others);
+  const setuid = perms.setuid ? 4 : 0;
+  const setgid = perms.setgid ? 2 : 0;
+  const sticky = perms.sticky ? 1 : 0;
+  const special = setuid + setgid + sticky;
+  if (special > 0) {
+    return `${special}${owner}${group}${others}`;
+  }
+  return `${owner}${group}${others}`;
+}
+function parsePermSymbol(sym) {
+  if (sym.length !== 3) return null;
+  const read = sym[0] === "r";
+  const write = sym[1] === "w";
+  const execute = sym[2] === "x" || sym[2] === "s" || sym[2] === "t";
+  if (sym[0] !== "r" && sym[0] !== "-") return null;
+  if (sym[1] !== "w" && sym[1] !== "-") return null;
+  if (sym[2] !== "x" && sym[2] !== "-" && sym[2] !== "s" && sym[2] !== "t" && sym[2] !== "S" && sym[2] !== "T")
+    return null;
+  return { read, write, execute };
+}
+function symbolicToPermissions(symbolic) {
+  const s = symbolic.length === 10 ? symbolic.slice(1) : symbolic;
+  if (s.length !== 9) return { error: "Invalid symbolic: must be 9 characters (e.g. rwxr-xr-x)" };
+  const ownerSym = s.slice(0, 3);
+  const groupSym = s.slice(3, 6);
+  const otherSym = s.slice(6, 9);
+  const owner = parsePermSymbol(ownerSym);
+  const group = parsePermSymbol(groupSym);
+  const others = parsePermSymbol(otherSym);
+  if (!owner) return { error: "Invalid owner permissions" };
+  if (!group) return { error: "Invalid group permissions" };
+  if (!others) return { error: "Invalid others permissions" };
+  const setuid = s[2] === "s" || s[2] === "S";
+  const setgid = s[5] === "s" || s[5] === "S";
+  const sticky = s[8] === "t" || s[8] === "T";
+  return { owner, group, others, setuid, setgid, sticky };
+}
+function permToSym(p, special, specialChar) {
+  const r = p.read ? "r" : "-";
+  const w = p.write ? "w" : "-";
+  let x;
+  if (special) {
+    x = p.execute ? specialChar ?? "s" : specialChar?.toUpperCase() ?? "S";
+  } else {
+    x = p.execute ? "x" : "-";
+  }
+  return r + w + x;
+}
+function permissionsToSymbolic(perms) {
+  const owner = permToSym(perms.owner, perms.setuid, "s");
+  const group = permToSym(perms.group, perms.setgid, "s");
+  const others = permToSym(perms.others, perms.sticky, "t");
+  return owner + group + others;
+}
+function permissionsToChmod(perms) {
+  return `chmod ${permissionsToOctal(perms)} file`;
+}
+function describePermissions(perms) {
+  function describe(p) {
+    const parts = [];
+    if (p.read) parts.push("read");
+    if (p.write) parts.push("write");
+    if (p.execute) parts.push("execute");
+    return parts.length ? parts.join(", ") : "no permissions";
+  }
+  const lines = [
+    `Owner: ${describe(perms.owner)}`,
+    `Group: ${describe(perms.group)}`,
+    `Others: ${describe(perms.others)}`
+  ];
+  if (perms.setuid) lines.push("Setuid bit is set");
+  if (perms.setgid) lines.push("Setgid bit is set");
+  if (perms.sticky) lines.push("Sticky bit is set");
+  return lines;
+}
+var COMMON_PERMISSIONS = [
+  {
+    octal: "755",
+    symbolic: "rwxr-xr-x",
+    description: "Owner full, group/others read+execute",
+    use: "Executable files, web directories"
+  },
+  {
+    octal: "644",
+    symbolic: "rw-r--r--",
+    description: "Owner read+write, group/others read",
+    use: "Regular files, web content"
+  },
+  {
+    octal: "600",
+    symbolic: "rw-------",
+    description: "Owner read+write only",
+    use: "Private keys, sensitive config files"
+  },
+  {
+    octal: "777",
+    symbolic: "rwxrwxrwx",
+    description: "Everyone full permissions",
+    use: "Temporary shared directories (use with caution)"
+  },
+  {
+    octal: "700",
+    symbolic: "rwx------",
+    description: "Owner full, nobody else",
+    use: "Private executables, secure directories"
+  },
+  {
+    octal: "664",
+    symbolic: "rw-rw-r--",
+    description: "Owner+group read+write, others read",
+    use: "Shared project files"
+  },
+  {
+    octal: "666",
+    symbolic: "rw-rw-rw-",
+    description: "Everyone read+write, no execute",
+    use: "Shared data files"
+  },
+  {
+    octal: "400",
+    symbolic: "r--------",
+    description: "Owner read only",
+    use: "Read-only files, SSH authorized_keys"
+  }
+];
+function isValidIpv4(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    if (!/^\d+$/.test(part)) return false;
+    const n = parseInt(part, 10);
+    return n >= 0 && n <= 255;
+  });
+}
+function ipToDecimal(ip) {
+  if (!isValidIpv4(ip)) throw new Error(`Invalid IPv4 address: ${ip}`);
+  const parts = ip.split(".").map(Number);
+  return (parts[0] << 24 >>> 0) + (parts[1] << 16 >>> 0) + (parts[2] << 8 >>> 0) + parts[3];
+}
+function decimalToIp(decimal) {
+  const d = decimal >>> 0;
+  return [
+    d >>> 24 & 255,
+    d >>> 16 & 255,
+    d >>> 8 & 255,
+    d & 255
+  ].join(".");
+}
+function ipToHex(ip) {
+  if (!isValidIpv4(ip)) throw new Error(`Invalid IPv4 address: ${ip}`);
+  const parts = ip.split(".").map(Number);
+  return "0x" + parts.map((p) => p.toString(16).toUpperCase().padStart(2, "0")).join("");
+}
+function ipToBinary(ip) {
+  if (!isValidIpv4(ip)) throw new Error(`Invalid IPv4 address: ${ip}`);
+  return ip.split(".").map((part) => parseInt(part, 10).toString(2).padStart(8, "0")).join(".");
+}
+function ipToOctal(ip) {
+  if (!isValidIpv4(ip)) throw new Error(`Invalid IPv4 address: ${ip}`);
+  return ip.split(".").map((part) => "0" + parseInt(part, 10).toString(8)).join(".");
+}
+function convertIp(ip) {
+  let cidrPrefix;
+  let rawIp = ip.trim();
+  const cidrMatch = rawIp.match(/^(.+?)(\/.+)$/);
+  if (cidrMatch) {
+    rawIp = cidrMatch[1];
+    cidrPrefix = cidrMatch[2];
+  }
+  if (!isValidIpv4(rawIp)) {
+    return { error: `Invalid IPv4 address: ${rawIp}` };
+  }
+  const decimal = ipToDecimal(rawIp);
+  const result = {
+    dotted: rawIp,
+    decimal,
+    hex: ipToHex(rawIp),
+    binary: ipToBinary(rawIp),
+    octal: ipToOctal(rawIp),
+    integer: decimal
+  };
+  if (cidrPrefix !== void 0) {
+    result.cidrPrefix = cidrPrefix;
+  }
+  return result;
+}
+function ipFromHex(hex) {
+  const cleaned = hex.trim().replace(/^0x/i, "");
+  if (!/^[0-9a-fA-F]{8}$/.test(cleaned)) {
+    return { error: `Invalid hex IP: ${hex}` };
+  }
+  const decimal = parseInt(cleaned, 16);
+  return decimalToIp(decimal);
+}
+function ipFromBinary(binary) {
+  const parts = binary.trim().split(".");
+  if (parts.length !== 4) {
+    return { error: `Invalid binary IP (expected 4 octets): ${binary}` };
+  }
+  if (!parts.every((p) => /^[01]{8}$/.test(p))) {
+    return { error: `Invalid binary IP (each octet must be 8 bits): ${binary}` };
+  }
+  const dotted = parts.map((p) => parseInt(p, 2).toString()).join(".");
+  return dotted;
+}
+function ipFromDecimal(decimal) {
+  return decimalToIp(decimal);
+}
+function isValidIp(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((p) => {
+    if (!/^\d+$/.test(p)) return false;
+    const n = parseInt(p, 10);
+    return n >= 0 && n <= 255;
+  });
+}
+function isValidCidr(cidr) {
+  const parts = cidr.split("/");
+  if (parts.length !== 2) return false;
+  if (!isValidIp(parts[0])) return false;
+  const prefix = parseInt(parts[1], 10);
+  return /^\d+$/.test(parts[1]) && prefix >= 0 && prefix <= 32;
+}
+function ipToDecimalCidr(ip) {
+  if (!isValidIp(ip)) return { error: `Invalid IP address: '${ip}'` };
+  const parts = ip.split(".").map(Number);
+  return (parts[0] << 24 | parts[1] << 16 | parts[2] << 8 | parts[3]) >>> 0;
+}
+function decimalToIpCidr(decimal) {
+  const d = decimal >>> 0;
+  return [
+    d >>> 24 & 255,
+    d >>> 16 & 255,
+    d >>> 8 & 255,
+    d & 255
+  ].join(".");
+}
+function getIpClass(firstOctet) {
+  if (firstOctet >= 1 && firstOctet <= 126) return "A";
+  if (firstOctet >= 128 && firstOctet <= 191) return "B";
+  if (firstOctet >= 192 && firstOctet <= 223) return "C";
+  if (firstOctet >= 224 && firstOctet <= 239) return "D";
+  if (firstOctet >= 240 && firstOctet <= 255) return "E";
+  return "unknown";
+}
+function checkPrivate(ipDec) {
+  const a = ipDec >>> 24 & 255;
+  const b = ipDec >>> 16 & 255;
+  if (a === 10) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 127) return true;
+  return false;
+}
+function calcSubnet(cidr) {
+  if (!isValidCidr(cidr)) return { error: `Invalid CIDR: '${cidr}'` };
+  const [ipStr, prefixStr] = cidr.split("/");
+  const prefix = parseInt(prefixStr, 10);
+  const ipDecResult = ipToDecimalCidr(ipStr);
+  if (typeof ipDecResult === "object") return ipDecResult;
+  const maskDec = prefix === 0 ? 0 : 4294967295 << 32 - prefix >>> 0;
+  const wildcardDec = ~maskDec >>> 0;
+  const networkDec = (ipDecResult & maskDec) >>> 0;
+  const broadcastDec = (networkDec | wildcardDec) >>> 0;
+  const totalHosts = prefix >= 31 ? Math.pow(2, 32 - prefix) : Math.pow(2, 32 - prefix) - 2;
+  const usableHosts = prefix >= 31 ? totalHosts : Math.max(0, totalHosts);
+  let firstHostDec;
+  let lastHostDec;
+  if (prefix >= 31) {
+    firstHostDec = networkDec;
+    lastHostDec = broadcastDec;
+  } else {
+    firstHostDec = networkDec + 1 >>> 0;
+    lastHostDec = broadcastDec - 1 >>> 0;
+  }
+  const firstOctet = networkDec >>> 24 & 255;
+  return {
+    networkAddress: decimalToIpCidr(networkDec),
+    broadcastAddress: decimalToIpCidr(broadcastDec),
+    subnetMask: decimalToIpCidr(maskDec),
+    wildcardMask: decimalToIpCidr(wildcardDec),
+    firstHost: decimalToIpCidr(firstHostDec),
+    lastHost: decimalToIpCidr(lastHostDec),
+    totalHosts,
+    usableHosts,
+    prefix,
+    ipClass: getIpClass(firstOctet),
+    isPrivate: checkPrivate(networkDec)
+  };
+}
+function splitSubnet(cidr, newPrefix) {
+  if (!isValidCidr(cidr)) return { error: `Invalid CIDR: '${cidr}'` };
+  const [, prefixStr] = cidr.split("/");
+  const prefix = parseInt(prefixStr, 10);
+  if (newPrefix <= prefix)
+    return { error: `New prefix ${newPrefix} must be greater than original prefix ${prefix}` };
+  if (newPrefix > 32) return { error: `New prefix must be <= 32` };
+  const base = calcSubnet(cidr);
+  if ("error" in base) return base;
+  const networkDecResult = ipToDecimalCidr(base.networkAddress);
+  if (typeof networkDecResult === "object") return networkDecResult;
+  const count = Math.pow(2, newPrefix - prefix);
+  const subnetSize = Math.pow(2, 32 - newPrefix);
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    const subnetIpDec = networkDecResult + i * subnetSize >>> 0;
+    const subnetCidr = `${decimalToIpCidr(subnetIpDec)}/${newPrefix}`;
+    const info = calcSubnet(subnetCidr);
+    if ("error" in info) return info;
+    results.push(info);
+  }
+  return results;
+}
+var SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9._-]+?))?(?:\+([a-zA-Z0-9._-]+))?$/;
+function parseSemver(version) {
+  const m = version.trim().match(SEMVER_RE);
+  if (!m) return { error: `Invalid semver: '${version}'` };
+  const result = {
+    major: parseInt(m[1], 10),
+    minor: parseInt(m[2], 10),
+    patch: parseInt(m[3], 10),
+    raw: version.trim()
+  };
+  if (m[4] !== void 0) result.prerelease = m[4];
+  if (m[5] !== void 0) result.build = m[5];
+  return result;
+}
+function isValid(version) {
+  return SEMVER_RE.test(version.trim());
+}
+function comparePrerelease(a, b) {
+  if (a === void 0 && b === void 0) return 0;
+  if (a === void 0) return 1;
+  if (b === void 0) return -1;
+  const aParts = a.split(".");
+  const bParts = b.split(".");
+  const len = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < len; i++) {
+    const ap = aParts[i];
+    const bp = bParts[i];
+    if (ap === void 0) return -1;
+    if (bp === void 0) return 1;
+    const aNum = parseInt(ap, 10);
+    const bNum = parseInt(bp, 10);
+    const aIsNum = !isNaN(aNum) && String(aNum) === ap;
+    const bIsNum = !isNaN(bNum) && String(bNum) === bp;
+    if (aIsNum && bIsNum) {
+      if (aNum < bNum) return -1;
+      if (aNum > bNum) return 1;
+    } else if (aIsNum) {
+      return -1;
+    } else if (bIsNum) {
+      return 1;
+    } else {
+      if (ap < bp) return -1;
+      if (ap > bp) return 1;
+    }
+  }
+  return 0;
+}
+function compareVersionObjects(a, b) {
+  if (a.major !== b.major) return a.major < b.major ? -1 : 1;
+  if (a.minor !== b.minor) return a.minor < b.minor ? -1 : 1;
+  if (a.patch !== b.patch) return a.patch < b.patch ? -1 : 1;
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  if ("error" in pa) return pa;
+  const pb = parseSemver(b);
+  if ("error" in pb) return pb;
+  return compareVersionObjects(pa, pb);
+}
+function satisfiesRange(version, range) {
+  const pv = parseSemver(version);
+  if ("error" in pv) return pv;
+  const trimmedRange = range.trim();
+  if (trimmedRange === "*" || trimmedRange === "") return true;
+  const andParts = trimmedRange.split(/\s+/);
+  for (const part of andParts) {
+    const result = satisfiesSingleRange(pv, part.trim());
+    if (typeof result === "object" && "error" in result) return result;
+    if (!result) return false;
+  }
+  return true;
+}
+function satisfiesSingleRange(pv, range) {
+  if (range === "*") return true;
+  const caretMatch = range.match(/^\^v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9._-]+))?$/);
+  if (caretMatch) {
+    const major = parseInt(caretMatch[1], 10);
+    const minor = parseInt(caretMatch[2], 10);
+    const patch = parseInt(caretMatch[3], 10);
+    const pre = caretMatch[4];
+    const lower = { major, minor, patch, prerelease: pre};
+    let upper;
+    if (major !== 0) {
+      upper = { major: major + 1, minor: 0, patch: 0, raw: "" };
+    } else if (minor !== 0) {
+      upper = { major: 0, minor: minor + 1, patch: 0, raw: "" };
+    } else {
+      upper = { major: 0, minor: 0, patch: patch + 1, raw: "" };
+    }
+    return compareVersionObjects(pv, lower) >= 0 && compareVersionObjects(pv, upper) < 0;
+  }
+  const tildeMatch = range.match(/^~v?(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9._-]+))?$/);
+  if (tildeMatch) {
+    const major = parseInt(tildeMatch[1], 10);
+    const minor = parseInt(tildeMatch[2], 10);
+    const patch = parseInt(tildeMatch[3], 10);
+    const pre = tildeMatch[4];
+    const lower = { major, minor, patch, prerelease: pre};
+    const upper = { major, minor: minor + 1, patch: 0};
+    return compareVersionObjects(pv, lower) >= 0 && compareVersionObjects(pv, upper) < 0;
+  }
+  const opMatch = range.match(/^(>=|<=|>|<|=)v?(.+)$/);
+  if (opMatch) {
+    const op = opMatch[1];
+    const parsed = parseSemver(opMatch[2]);
+    if ("error" in parsed) return parsed;
+    const cmp = compareVersionObjects(pv, parsed);
+    if (op === ">=") return cmp >= 0;
+    if (op === "<=") return cmp <= 0;
+    if (op === ">") return cmp > 0;
+    if (op === "<") return cmp < 0;
+    if (op === "=") return cmp === 0;
+  }
+  const plain = parseSemver(range);
+  if (!("error" in plain)) {
+    return compareVersionObjects(pv, plain) === 0;
+  }
+  return { error: `Unsupported range: '${range}'` };
+}
+function bumpVersion(version, bump) {
+  const pv = parseSemver(version);
+  if ("error" in pv) return pv;
+  if (bump === "major") return `${pv.major + 1}.0.0`;
+  if (bump === "minor") return `${pv.major}.${pv.minor + 1}.0`;
+  return `${pv.major}.${pv.minor}.${pv.patch + 1}`;
+}
+function sortVersions(versions, order = "asc") {
+  return [...versions].sort((a, b) => {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if ("error" in pa || "error" in pb) return 0;
+    const cmp = compareVersionObjects(pa, pb);
+    return order === "asc" ? cmp : -cmp;
+  });
+}
+
+export { BASE_LABELS, BASE_PREFIXES, BYTE_UNITS, COMMON_CURRENCIES, COMMON_LOCALES, COMMON_PERMISSIONS, COMMON_RATIOS, COMMON_SIZES, COMMON_VIEWPORTS, autoFormat, bumpVersion, calcAspectRatio, calcSubnet, compareSemver, convert, convertBytes, convertIp, coverBox, decimalToIp, decimalToIpCidr, describePermissions, fitIntoBox, formatNumber, formatValue, formatVwValue, formatWithSeparator, gcd, ipFromBinary, ipFromDecimal, ipFromHex, ipToBinary, ipToDecimal, ipToDecimalCidr, ipToHex, ipToOctal, isValid, isValidCidr, isValidIp, isValidIpv4, octalToPermissions, parseFileSize, parseInput, parseNumberString, parseSemver, permissionsToChmod, permissionsToOctal, permissionsToSymbolic, ptToPx, pxToAll, pxToViewport, remToPx, satisfiesRange, scaleByHeight, scaleByWidth, sortVersions, splitSubnet, symbolicToPermissions, units_exports, viewportToPx };