@visulima/humanizer 3.0.0-alpha.10 → 3.0.0-alpha.12

package/package.json

@@ -1,38 +1,36 @@
 {
   "name": "@visulima/humanizer",
-  "version": "3.0.0-alpha.10",
+  "version": "3.0.0-alpha.12",
   "description": "Humanizer is a library for humanizing data in a human-readable form.",
   "keywords": [
-    "visulima",
-    "humanizer",
-    "humanize",
-    "human-readable",
-    "human",
-    "time",
-    "ms",
     "bytes",
-    "filesize",
-    "filesize-humanizer",
-    "time-humanizer",
-    "ms-humanizer",
     "bytes-humanizer",
-    "millisecond",
-    "second",
+    "days",
     "duration",
+    "filesize",
+    "filesize-humanizer",
     "hours",
+    "human",
+    "human-readable",
+    "humanize",
+    "humanizer",
+    "millisecond",
     "minutes",
-    "seconds",
-    "days",
-    "years",
     "months",
+    "ms",
+    "ms-humanizer",
     "range",
+    "second",
+    "seconds",
+    "string",
     "text",
-    "string"
+    "time",
+    "time-humanizer",
+    "visulima",
+    "years"
   ],
   "homepage": "https://visulima.io",
-  "bugs": {
-    "url": "https://github.com/visulima/visulima/issues"
-  },
+  "bugs": "https://github.com/visulima/visulima/issues",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/visulima/visulima.git",
@@ -70,7 +68,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "publishConfig": {
     "access": "public",

package/dist/bytes.d.ts

@@ -1,131 +0,0 @@
-import type { FormateByteOptions, ParseByteOptions } from "./types.d.ts";
-declare const BYTE_SIZES: {
-    readonly iec: readonly [{
-        readonly long: "Bytes";
-        readonly short: "B";
-    }, {
-        readonly long: "Kibibytes";
-        readonly short: "KiB";
-    }, {
-        readonly long: "Mebibytes";
-        readonly short: "MiB";
-    }, {
-        readonly long: "Gibibytes";
-        readonly short: "GiB";
-    }, {
-        readonly long: "Tebibytes";
-        readonly short: "TiB";
-    }, {
-        readonly long: "Pebibytes";
-        readonly short: "PiB";
-    }, {
-        readonly long: "Exbibytes";
-        readonly short: "EiB";
-    }, {
-        readonly long: "Zebibytes";
-        readonly short: "ZiB";
-    }, {
-        readonly long: "Yobibytes";
-        readonly short: "YiB";
-    }];
-    readonly iec_octet: readonly [{
-        readonly long: "Octets";
-        readonly short: "o";
-    }, {
-        readonly long: "Kibioctets";
-        readonly short: "Kio";
-    }, {
-        readonly long: "Mebioctets";
-        readonly short: "Mio";
-    }, {
-        readonly long: "Gibioctets";
-        readonly short: "Gio";
-    }, {
-        readonly long: "Tebioctets";
-        readonly short: "Tio";
-    }, {
-        readonly long: "Pebioctets";
-        readonly short: "Pio";
-    }, {
-        readonly long: "Exbioctets";
-        readonly short: "Eio";
-    }, {
-        readonly long: "Zebioctets";
-        readonly short: "Zio";
-    }, {
-        readonly long: "Yobioctets";
-        readonly short: "Yio";
-    }];
-    readonly metric: readonly [{
-        readonly long: "Bytes";
-        readonly short: "Bytes";
-    }, {
-        readonly long: "Kilobytes";
-        readonly short: "KB";
-    }, {
-        readonly long: "Megabytes";
-        readonly short: "MB";
-    }, {
-        readonly long: "Gigabytes";
-        readonly short: "GB";
-    }, {
-        readonly long: "Terabytes";
-        readonly short: "TB";
-    }, {
-        readonly long: "Petabytes";
-        readonly short: "PB";
-    }, {
-        readonly long: "Exabytes";
-        readonly short: "EB";
-    }, {
-        readonly long: "Zettabytes";
-        readonly short: "ZB";
-    }, {
-        readonly long: "Yottabytes";
-        readonly short: "YB";
-    }];
-    readonly metric_octet: readonly [{
-        readonly long: "Octets";
-        readonly short: "o";
-    }, {
-        readonly long: "Kilo-octets";
-        readonly short: "ko";
-    }, {
-        readonly long: "Mega-octets";
-        readonly short: "Mo";
-    }, {
-        readonly long: "Giga-octets";
-        readonly short: "Go";
-    }, {
-        readonly long: "Tera-octets";
-        readonly short: "To";
-    }, {
-        readonly long: "Peta-octets";
-        readonly short: "Po";
-    }, {
-        readonly long: "Exa-octets";
-        readonly short: "Eo";
-    }, {
-        readonly long: "Zetta-octets";
-        readonly short: "Zo";
-    }, {
-        readonly long: "Yotta-octets";
-        readonly short: "Yo";
-    }];
-};
-type ByteSize = (typeof BYTE_SIZES)["iec_octet"][number]["short"] | (typeof BYTE_SIZES)["iec"][number]["short"] | (typeof BYTE_SIZES)["metric_octet"][number]["short"] | (typeof BYTE_SIZES)["metric"][number]["short"];
-/**
- * Parse the given bytesize string and return bytes.
- * @param value The string to parse
- * @param options Options for the conversion from string to bytes
- * @throws Error if `value` is not a non-empty string or a number
- */
-export declare const parseBytes: (value: string, options?: ParseByteOptions) => number;
-/**
- * Formats the given bytes into a human-readable string.
- * Per default, it will use the closest unit to the given value.
- * @param bytes The bytes to format
- * @param options Options for the conversion from bytes to string
- */
-export declare const formatBytes: (bytes: number, options?: FormateByteOptions<ByteSize>) => string;
-export {};

package/dist/duration.d.ts

@@ -1,3 +0,0 @@
-import type { DurationOptions } from "./types.d.ts";
-declare const duration: (milliseconds: number, options?: DurationOptions) => string;
-export default duration;

package/dist/packem_shared/duration-Br8Mr-Lj.js

@@ -1,210 +0,0 @@
-import { durationLanguage } from '../language/en.js';
-import validateDurationLanguage from '../language/util/validate-duration-language.js';
-
-const toFixed = (number_, fixed) => {
-  fixed = fixed || -1;
-  const matches = new RegExp(String.raw`^-?\d+(?:.\d{0,${String(fixed)}})?`).exec(number_.toString());
-  if (matches === null) {
-    return number_;
-  }
-  return Number.parseFloat(matches[0]);
-};
-const renderPiece = ({ unitCount, unitName }, language, options) => {
-  let { spacer } = options;
-  const { maxDecimalPoints } = options;
-  let decimal = ".";
-  if (options.decimal !== void 0) {
-    decimal = options.decimal;
-  } else if (language.decimal !== void 0) {
-    decimal = language.decimal;
-  }
-  let digitReplacements;
-  if ("digitReplacements" in options) {
-    digitReplacements = options.digitReplacements;
-  } else if ("_digitReplacements" in language) {
-    digitReplacements = language._digitReplacements;
-  }
-  let formattedCount;
-  let normalizedUnitCount = unitCount;
-  if (maxDecimalPoints !== void 0) {
-    normalizedUnitCount = toFixed(unitCount, maxDecimalPoints);
-  }
-  const countString = normalizedUnitCount.toString();
-  if (!language._hideCountIf2 || unitCount !== 2) {
-    if (digitReplacements) {
-      formattedCount = "";
-      for (const char of countString) {
-        formattedCount += char === "." ? decimal : digitReplacements[char];
-      }
-    } else {
-      formattedCount = countString.replace(".", decimal);
-    }
-  } else {
-    formattedCount = "";
-  }
-  const languageWord = language[unitName];
-  let word = languageWord;
-  if (typeof languageWord === "function") {
-    word = languageWord(unitCount);
-  }
-  if (language._hideCountIf2 && unitCount === 2) {
-    spacer = "";
-  }
-  if (language._numberFirst) {
-    return word + spacer + formattedCount;
-  }
-  return formattedCount + spacer + word;
-};
-const getPieces = (ms, options) => {
-  const { units } = options;
-  if (units.length === 0) {
-    return [];
-  }
-  const { unitMeasures } = options;
-  const largest = options.largest ?? Number.POSITIVE_INFINITY;
-  const unitCounts = {};
-  let unitName;
-  let index;
-  let unitCount;
-  let msRemaining = ms;
-  for (index = 0; index < units.length; index++) {
-    unitName = units[index];
-    const unitMs = unitMeasures[unitName];
-    const isLast = index === units.length - 1;
-    unitCount = isLast ? msRemaining / unitMs : Math.floor(msRemaining / unitMs);
-    unitCounts[unitName] = unitCount;
-    msRemaining -= unitCount * unitMs;
-  }
-  if (options.round) {
-    let unitsRemainingBeforeRound = largest;
-    for (index = 0; index < units.length; index++) {
-      unitName = units[index];
-      unitCount = unitCounts[unitName];
-      if (unitCount === 0) {
-        continue;
-      }
-      unitsRemainingBeforeRound--;
-      if (unitsRemainingBeforeRound === 0) {
-        for (let index_ = index + 1; index_ < units.length; index_++) {
-          const smallerUnitName = units[index_];
-          const smallerUnitCount = unitCounts[smallerUnitName];
-          unitCounts[unitName] = (unitCounts[unitName] ?? 0) + smallerUnitCount * unitMeasures[smallerUnitName] / unitMeasures[unitName];
-          unitCounts[smallerUnitName] = 0;
-        }
-        break;
-      }
-    }
-    for (index = units.length - 1; index >= 0; index--) {
-      unitName = units[index];
-      unitCount = unitCounts[unitName];
-      if (unitCount === 0) {
-        continue;
-      }
-      const rounded = Math.round(unitCount);
-      unitCounts[unitName] = rounded;
-      if (index === 0) {
-        break;
-      }
-      const previousUnitName = units[index - 1];
-      const previousUnitMs = unitMeasures[previousUnitName];
-      const amountOfPreviousUnit = Math.floor(rounded * unitMeasures[unitName] / previousUnitMs);
-      if (amountOfPreviousUnit) {
-        unitCounts[previousUnitName] = (unitCounts[previousUnitName] ?? 0) + amountOfPreviousUnit;
-        unitCounts[unitName] = 0;
-      } else {
-        break;
-      }
-    }
-  }
-  const result = [];
-  for (index = 0; index < units.length && result.length < largest; index++) {
-    unitName = units[index];
-    unitCount = unitCounts[unitName];
-    if (unitCount && !options.round && result.length === largest - 1) {
-      let index_;
-      let remainder = 0;
-      for (index_ = index + 1, units.length; index_ < units.length; index_++) {
-        const remainderUnitName = units[index_];
-        remainder += unitCounts[remainderUnitName] * (options.unitMeasures[remainderUnitName] / options.unitMeasures[unitName]);
-      }
-      unitCount += remainder;
-      if (options.maxDecimalPoints !== void 0) {
-        unitCount = toFixed(unitCount, options.maxDecimalPoints);
-      }
-    }
-    if (unitCount) {
-      result.push({ unitCount, unitName });
-    }
-  }
-  return result;
-};
-const formatPieces = (pieces, options, ms) => {
-  const { language, units } = options;
-  if (pieces.length === 0) {
-    const smallestUnitName = units.at(-1);
-    return renderPiece({ unitCount: 0, unitName: smallestUnitName }, language, options);
-  }
-  const { conjunction, serialComma } = options;
-  let delimiter = ", ";
-  if (options.delimiter !== void 0) {
-    delimiter = options.delimiter;
-  } else if (language.delimiter !== void 0) {
-    delimiter = language.delimiter;
-  }
-  let adverb = "";
-  if (options.timeAdverb && ms !== 0) {
-    adverb = language.future ?? "";
-    if (ms < 0) {
-      adverb = language.past ?? "";
-    }
-  }
-  const renderedPieces = pieces.map((piece) => renderPiece(piece, language, options));
-  let result;
-  if (!conjunction || pieces.length === 1) {
-    result = renderedPieces.join(delimiter);
-  } else if (pieces.length === 2) {
-    result = renderedPieces.join(conjunction);
-  } else {
-    result = renderedPieces.slice(0, -1).join(delimiter) + (serialComma ? "," : "") + conjunction + (renderedPieces.at(-1) ?? "");
-  }
-  if (adverb) {
-    result = adverb.replace("%s", result);
-  }
-  return result;
-};
-const duration = (milliseconds, options) => {
-  if (Number.isNaN(milliseconds)) {
-    throw new TypeError("Expected a valid number");
-  }
-  if (typeof milliseconds !== "number") {
-    throw new TypeError("Expected a number for milliseconds input");
-  }
-  const config = {
-    conjunction: "",
-    language: durationLanguage,
-    round: false,
-    serialComma: true,
-    spacer: " ",
-    timeAdverb: false,
-    unitMeasures: {
-      d: 864e5,
-      h: 36e5,
-      m: 6e4,
-      mo: 2629746e3,
-      // 365.2425 / 12 = 30.436875 days
-      ms: 1,
-      s: 1e3,
-      w: 6048e5,
-      y: 31556952e3
-      // 365 + 1/4 - 1/100 + 1/400 (actual leap day rules) = 365.2425 days
-    },
-    units: ["w", "d", "h", "m", "s"],
-    ...options
-  };
-  validateDurationLanguage(config.language);
-  const absTime = Math.abs(milliseconds);
-  const pieces = getPieces(absTime, config);
-  return formatPieces(pieces, config, milliseconds);
-};
-
-export { duration as default };

package/dist/packem_shared/parseBytes-BkjYV2ut.js

@@ -1,250 +0,0 @@
-const PARSE_BYTES_REGEX = /^(?<value>-?\d+(?:[.,]\d+)*) *(?<type>[a-z]+)?$/i;
-const KIBI_REGEX = /^KIBI/;
-const MIBI_REGEX = /^MIBI/;
-const GIBI_REGEX = /^GIBI/;
-const TEBI_REGEX = /^TEBI/;
-const PEBI_REGEX = /^PEBI/;
-const EXBI_REGEX = /^EXBI/;
-const ZEBI_REGEX = /^ZEBI/;
-const YIBI_REGEX = /^YIBI/;
-const IB_SUFFIX_REGEX = /^(.)IB$/;
-const BYTE_SIZES = {
-  iec: [
-    {
-      long: "Bytes",
-      short: "B"
-    },
-    {
-      long: "Kibibytes",
-      short: "KiB"
-    },
-    {
-      long: "Mebibytes",
-      short: "MiB"
-    },
-    {
-      long: "Gibibytes",
-      short: "GiB"
-    },
-    {
-      long: "Tebibytes",
-      short: "TiB"
-    },
-    {
-      long: "Pebibytes",
-      short: "PiB"
-    },
-    {
-      long: "Exbibytes",
-      short: "EiB"
-    },
-    {
-      long: "Zebibytes",
-      short: "ZiB"
-    },
-    {
-      long: "Yobibytes",
-      short: "YiB"
-    }
-  ],
-  iec_octet: [
-    {
-      long: "Octets",
-      short: "o"
-    },
-    {
-      long: "Kibioctets",
-      short: "Kio"
-    },
-    {
-      long: "Mebioctets",
-      short: "Mio"
-    },
-    {
-      long: "Gibioctets",
-      short: "Gio"
-    },
-    {
-      long: "Tebioctets",
-      short: "Tio"
-    },
-    {
-      long: "Pebioctets",
-      short: "Pio"
-    },
-    {
-      long: "Exbioctets",
-      short: "Eio"
-    },
-    {
-      long: "Zebioctets",
-      short: "Zio"
-    },
-    {
-      long: "Yobioctets",
-      short: "Yio"
-    }
-  ],
-  metric: [
-    {
-      long: "Bytes",
-      short: "Bytes"
-    },
-    {
-      long: "Kilobytes",
-      short: "KB"
-    },
-    {
-      long: "Megabytes",
-      short: "MB"
-    },
-    {
-      long: "Gigabytes",
-      short: "GB"
-    },
-    {
-      long: "Terabytes",
-      short: "TB"
-    },
-    {
-      long: "Petabytes",
-      short: "PB"
-    },
-    {
-      long: "Exabytes",
-      short: "EB"
-    },
-    {
-      long: "Zettabytes",
-      short: "ZB"
-    },
-    {
-      long: "Yottabytes",
-      short: "YB"
-    }
-  ],
-  metric_octet: [
-    {
-      long: "Octets",
-      short: "o"
-    },
-    {
-      long: "Kilo-octets",
-      short: "ko"
-    },
-    {
-      long: "Mega-octets",
-      short: "Mo"
-    },
-    {
-      long: "Giga-octets",
-      short: "Go"
-    },
-    {
-      long: "Tera-octets",
-      short: "To"
-    },
-    {
-      long: "Peta-octets",
-      short: "Po"
-    },
-    {
-      long: "Exa-octets",
-      short: "Eo"
-    },
-    {
-      long: "Zetta-octets",
-      short: "Zo"
-    },
-    {
-      long: "Yotta-octets",
-      short: "Yo"
-    }
-  ]
-};
-const parseLocalizedNumber = (stringNumber, locale) => {
-  const thousandSeparator = new Intl.NumberFormat(locale).format(11111).replaceAll(new RegExp("\\p{Number}", "gu"), "");
-  const decimalSeparator = new Intl.NumberFormat(locale).format(1.1).replaceAll(new RegExp("\\p{Number}", "gu"), "");
-  return Number.parseFloat(stringNumber.replaceAll(new RegExp(`\\${thousandSeparator}`, "g"), "").replace(new RegExp(`\\${decimalSeparator}`), "."));
-};
-const fromBase = (base) => {
-  switch (base) {
-    case 2: {
-      return 1024;
-    }
-    case 10: {
-      return 1e3;
-    }
-    default: {
-      throw new Error("Unsupported base.");
-    }
-  }
-};
-const parseBytes = (value, options) => {
-  const config = {
-    base: 2,
-    locale: "en-US",
-    units: "metric",
-    ...options
-  };
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError("Value is not a string or is empty.");
-  }
-  if (value.length > 100) {
-    throw new TypeError("Value exceeds the maximum length of 100 characters.");
-  }
-  const match = PARSE_BYTES_REGEX.exec(value);
-  const groups = match?.groups;
-  if (!groups) {
-    return Number.NaN;
-  }
-  const localizedNumber = parseLocalizedNumber(groups.value, config.locale);
-  const type = (groups.type ?? "Bytes").toUpperCase().replace(KIBI_REGEX, "KILO").replace(MIBI_REGEX, "MEGA").replace(GIBI_REGEX, "GIGA").replace(TEBI_REGEX, "TERA").replace(PEBI_REGEX, "PETA").replace(EXBI_REGEX, "EXA").replace(ZEBI_REGEX, "ZETTA").replace(YIBI_REGEX, "YOTTA").replace(IB_SUFFIX_REGEX, "$1B");
-  const level = BYTE_SIZES[config.units].findIndex((unit) => unit.short[0].toUpperCase() === type[0]);
-  const base = fromBase(config.base);
-  return localizedNumber * base ** level;
-};
-const formatBytes = (bytes, options) => {
-  if (typeof bytes !== "number" || !Number.isFinite(bytes)) {
-    throw new TypeError("Bytesize is not a number.");
-  }
-  const {
-    base: givenBase,
-    decimals,
-    locale,
-    long,
-    unit: requestedUnit,
-    units,
-    ...l10nOptions
-  } = {
-    base: 2,
-    decimals: 0,
-    locale: "en-US",
-    long: false,
-    units: "metric",
-    ...options
-  };
-  const base = fromBase(givenBase);
-  const absoluteBytes = Math.abs(bytes);
-  const space = options?.space ?? true ? " " : "";
-  const referenceTable = BYTE_SIZES[units];
-  const requestedUnitIndex = referenceTable.findIndex((unit2) => unit2.short === requestedUnit);
-  if (bytes === 0) {
-    const level2 = Math.min(0, Math.max(requestedUnitIndex, referenceTable.length - 1));
-    return "0" + space + referenceTable[level2][long ? "long" : "short"];
-  }
-  const level = requestedUnitIndex === -1 ? Math.min(Math.floor(Math.log(absoluteBytes) / Math.log(base)), referenceTable.length - 1) : requestedUnitIndex;
-  const unit = referenceTable[level][long ? "long" : "short"];
-  const value = bytes / base ** level;
-  const fractionDigits = decimals < 0 ? void 0 : decimals;
-  const formattedValue = new Intl.NumberFormat(locale, {
-    // @ts-expect-error - should be overridden by the options
-    maximumFractionDigits: fractionDigits,
-    // @ts-expect-error - should be overridden by the options
-    minimumFractionDigits: fractionDigits,
-    ...l10nOptions
-  }).format(value);
-  return formattedValue + space + unit;
-};
-
-export { formatBytes, parseBytes };