@visulima/humanizer 2.0.5 → 3.0.0-alpha.10

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

@@ -0,0 +1,210 @@
+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

@@ -0,0 +1,250 @@
+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 };

package/dist/packem_shared/parseDuration-qO1Y4eiu.js

@@ -0,0 +1,111 @@
+import { durationLanguage, englishUnitMap } from '../language/en.js';
+import validateDurationLanguage from '../language/util/validate-duration-language.js';
+
+const STANDARD_UNIT_MEASURES = {
+  d: 864e5,
+  h: 36e5,
+  m: 6e4,
+  mo: 2629746e3,
+  ms: 1,
+  s: 1e3,
+  w: 6048e5,
+  y: 31556952e3
+};
+const ESCAPE_REGEX = /[-/\\^$*+?.()|[\]{}]/g;
+const ISO_FORMAT = /^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/i;
+const COLON_FORMAT = /^(?:(\d+):)?(?:(\d+):)?(\d+)$/;
+const NUMERIC_STRING_REGEX = /^[+-]?\d+(?:\.\d+)?$/;
+const SIGN_PREFIX_REGEX = /^[-+]/;
+const parseDuration = (value, options) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const { defaultUnit = "ms", language = durationLanguage } = options ?? {};
+  validateDurationLanguage(language);
+  const decimalSeparator = language.decimal ?? ".";
+  const groupSeparator = language.groupSeparator ?? ",";
+  const placeholderSeparator = language.placeholderSeparator ?? "_";
+  const escapedDecimal = decimalSeparator.replaceAll(ESCAPE_REGEX, String.raw`\$&`);
+  const escapedGroup = groupSeparator.replaceAll(ESCAPE_REGEX, String.raw`\$&`);
+  const escapedPlaceholder = placeholderSeparator.replaceAll(ESCAPE_REGEX, String.raw`\$&`);
+  const currentUnitMap = language.unitMap ?? englishUnitMap;
+  let processedValue = value.replaceAll(new RegExp(String.raw`(\d)[${escapedPlaceholder}${escapedGroup}](\d)`, "g"), "$1$2");
+  if (decimalSeparator !== ".") {
+    processedValue = processedValue.replace(escapedDecimal, ".");
+  }
+  if (NUMERIC_STRING_REGEX.test(value)) {
+    const numberOnly = Number.parseFloat(processedValue.trim());
+    if (!Number.isNaN(numberOnly)) {
+      const unitKey = currentUnitMap[defaultUnit];
+      if (unitKey !== void 0) {
+        return numberOnly * STANDARD_UNIT_MEASURES[unitKey];
+      }
+    }
+    return void 0;
+  }
+  const isoMatch = ISO_FORMAT.exec(value);
+  if (isoMatch) {
+    const hours = Number.parseInt(isoMatch[1] ?? "0", 10);
+    const minutes = Number.parseInt(isoMatch[2] ?? "0", 10);
+    const seconds = Number.parseInt(isoMatch[3] ?? "0", 10);
+    return hours * 36e5 + minutes * 6e4 + seconds * 1e3;
+  }
+  const colonMatch = COLON_FORMAT.exec(value);
+  if (colonMatch) {
+    let hours = 0;
+    let minutes = 0;
+    if (colonMatch[2] !== void 0) {
+      hours = Number.parseInt(colonMatch[1] ?? "0", 10);
+      minutes = Number.parseInt(colonMatch[2], 10);
+    } else if (colonMatch[1] !== void 0) {
+      minutes = Number.parseInt(colonMatch[1], 10);
+    }
+    const seconds = Number.parseInt(colonMatch[3] ?? "0", 10);
+    return hours * 36e5 + minutes * 6e4 + seconds * 1e3;
+  }
+  const currentUnitMapKeys = Object.keys(currentUnitMap);
+  const regexKeys = currentUnitMapKeys.toSorted((a, b) => b.length - a.length).map((k) => k.replaceAll(ESCAPE_REGEX, String.raw`\$&`)).join("|");
+  const durationRegex = new RegExp(String.raw`(-?\d*\.?\d+)\s*(${regexKeys})`, "gi");
+  let totalMs = 0;
+  let match;
+  let unitsFound = false;
+  let firstMatchIndex = -1;
+  let lastMatchEndIndex = 0;
+  durationRegex.lastIndex = 0;
+  while ((match = durationRegex.exec(processedValue)) !== null) {
+    if (!unitsFound) {
+      firstMatchIndex = match.index;
+    }
+    unitsFound = true;
+    const numberString = match[1];
+    const unitString = match[2];
+    if (!numberString || !unitString) {
+      continue;
+    }
+    const trimmedNumberString = numberString.trim();
+    const sign = trimmedNumberString.startsWith("-") ? -1 : 1;
+    const absNumberString = trimmedNumberString.replace(SIGN_PREFIX_REGEX, "");
+    const parsedNumber = Number.parseFloat(absNumberString);
+    const unitKey = currentUnitMap[unitString.toLowerCase()];
+    if (unitKey === void 0) {
+      continue;
+    }
+    const unitValue = STANDARD_UNIT_MEASURES[unitKey];
+    if (Number.isNaN(parsedNumber)) {
+      return void 0;
+    }
+    totalMs += sign * parsedNumber * unitValue;
+    lastMatchEndIndex = durationRegex.lastIndex;
+  }
+  const leadingText = processedValue.slice(0, firstMatchIndex).trim();
+  const trailingText = processedValue.slice(lastMatchEndIndex).trim();
+  if (unitsFound && (leadingText.length > 0 || trailingText.length > 0)) {
+    return void 0;
+  }
+  if (!unitsFound) {
+    return void 0;
+  }
+  return totalMs;
+};
+
+export { parseDuration as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/humanizer",
-  "version": "2.0.5",
+  "version": "3.0.0-alpha.10",
   "description": "Humanizer is a library for humanizing data in a human-readable form.",
   "keywords": [
     "visulima",
@@ -36,7 +36,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/visulima/visulima.git",
-    "directory": "packages/humanizer"
+    "directory": "packages/data-manipulation/humanizer"
   },
   "funding": [
     {
@@ -70,7 +70,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=20.19 <=25.x"
+    "node": ">=22.13 <=25.x"
   },
   "publishConfig": {
     "access": "public",

package/dist/packem_shared/duration-B8tBhwXw.js

@@ -1 +0,0 @@
-var x=Object.defineProperty;var b=(o,n)=>x(o,"name",{value:n,configurable:!0});import{durationLanguage as M}from"../language/en.js";import P from"../language/util/validate-duration-language.js";var w=Object.defineProperty,g=b((o,n)=>w(o,"name",{value:n,configurable:!0}),"g");const N=g((o,n)=>{n=n||-1;const e=new RegExp(`^-?\\d+(?:.\\d{0,${String(n)}})?`).exec(o.toString());return e===null?o:Number.parseFloat(e[0])},"toFixed"),v=g(({unitCount:o,unitName:n},e,l)=>{let{spacer:f}=l;const{maxDecimalPoints:s}=l;let r=".";l.decimal!==void 0?r=l.decimal:e.decimal!==void 0&&(r=e.decimal);let t;"digitReplacements"in l?t=l.digitReplacements:"_digitReplacements"in e&&(t=e._digitReplacements);let i,m=o;s!==void 0&&(m=N(o,s));const c=m.toString();if(!e._hideCountIf2||o!==2)if(t){i="";for(const d of c)i+=d==="."?r:t[d]}else i=c.replace(".",r);else i="";const u=e[n];let a=u;return typeof u=="function"&&(a=u(o)),e._hideCountIf2&&o===2&&(f=""),e._numberFirst?a+f+i:i+f+a},"renderPiece"),C=g((o,n)=>{const{units:e}=n;if(e.length===0)return[];const{unitMeasures:l}=n,f=n.largest??Number.POSITIVE_INFINITY,s={};let r,t,i,m=o;for(t=0;t<e.length;t++){r=e[t];const u=l[r];i=t===e.length-1?m/u:Math.floor(m/u),s[r]=i,m-=i*u}if(n.round){let u=f;for(t=0;t<e.length;t++)if(r=e[t],i=s[r],i!==0&&(u--,u===0)){for(let a=t+1;a<e.length;a++){const d=e[a],h=s[d];s[r]+=h*l[d]/l[r],s[d]=0}break}for(t=e.length-1;t>=0;t--){if(r=e[t],i=s[r],i===0)continue;const a=Math.round(i);if(s[r]=a,t===0)break;const d=e[t-1],h=l[d],p=Math.floor(a*l[r]/h);if(p)s[d]+=p,s[r]=0;else break}}const c=[];for(t=0;t<e.length&&c.length<f;t++){if(r=e[t],i=s[r],i&&!n.round&&c.length===f-1){let u,a=0;for(u=t+1,e.length;u<e.length;u++){const d=e[u];a+=s[d]*(n.unitMeasures[d]/n.unitMeasures[r])}i+=a,n.maxDecimalPoints!==void 0&&(i=N(i,n.maxDecimalPoints))}i&&c.push({unitCount:i,unitName:r})}return c},"getPieces"),I=g((o,n,e)=>{const{language:l,units:f}=n;if(o.length===0){const u=f.at(-1);return v({unitCount:0,unitName:u},l,n)}const{conjunction:s,serialComma:r}=n;let t=", ";n.delimiter!==void 0?t=n.delimiter:l.delimiter!==void 0&&(t=l.delimiter);let i="";n.timeAdverb&&e!==0&&(i=l.future??"",e<0&&(i=l.past??""));const m=[];for(const u of o){const a=u;m.push(v(a,l,n))}let c;return!s||o.length===1?c=m.join(t):o.length===2?c=m.join(s):c=m.slice(0,-1).join(t)+(r?",":"")+s+m.at(-1),i&&(c=i.replace("%s",c)),c},"formatPieces"),R=g((o,n)=>{if(Number.isNaN(o))throw new TypeError("Expected a valid number");if(typeof o!="number")throw new TypeError("Expected a number for milliseconds input");const e={conjunction:"",language:M,round:!1,serialComma:!0,spacer:" ",timeAdverb:!1,unitMeasures:{d:864e5,h:36e5,m:6e4,mo:2629746e3,ms:1,s:1e3,w:6048e5,y:31556952e3},units:["w","d","h","m","s"],...n};P(e.language);const l=Math.abs(o),f=C(l,e);return I(f,e,o)},"duration");export{R as default};

package/dist/packem_shared/parseBytes-Da87aeh8.js

@@ -1 +0,0 @@
-var M=Object.defineProperty;var B=(e,t)=>M(e,"name",{value:t,configurable:!0});var d=Object.defineProperty,n=B((e,t)=>d(e,"name",{value:t,configurable:!0}),"i");const E={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"}]},w=n((e,t)=>{const r=new Intl.NumberFormat(t).format(11111).replaceAll(new RegExp("\\p{Number}","gu"),""),o=new Intl.NumberFormat(t).format(1.1).replaceAll(new RegExp("\\p{Number}","gu"),"");return Number.parseFloat(e.replaceAll(new RegExp(`\\${r}`,"g"),"").replace(new RegExp(`\\${o}`),"."))},"parseLocalizedNumber"),f=n(e=>{if(e===2)return 1024;if(e===10)return 1e3;throw new TypeError("Unsupported base.")},"fromBase"),N=n((e,t)=>{const r={base:2,locale:"en-US",units:"metric",...t};if(typeof e!="string"||e.length===0)throw new TypeError("Value is not a string or is empty.");if(e.length>100)throw new TypeError("Value exceeds the maximum length of 100 characters.");const o=/^(?<value>-?(?:\d+(([.,])\d+)*)?[.,]?\d+) *(?<type>bytes?|b|kb|kib|mb|mib|gb|gib|tb|tib|pb|pib|eb|eib|zb|zib|yb|yib|(kilo|kibi|mega|mebi|giga|gibi|tera|tebi|peta|pebi|exa|exbi|zetta|zebi|yotta|yobi)?bytes)?$/i.exec(e)?.groups;if(!o)return Number.NaN;const a=w(o.value,r.locale),i=(o.type??"Bytes").toUpperCase().replace(/^KIBI/,"KILO").replace(/^MIBI/,"MEGA").replace(/^GIBI/,"GIGA").replace(/^TEBI/,"TERA").replace(/^PEBI/,"PETA").replace(/^EXBI/,"EXA").replace(/^ZEBI/,"ZETTA").replace(/^YIBI/,"YOTTA").replace(/^(.)IB$/,"$1B"),l=E[r.units].findIndex(g=>g.short[0].toUpperCase()===i[0]),b=f(r.base);return a*b**l},"parseBytes"),P=n((e,t)=>{if(typeof e!="number"||!Number.isFinite(e))throw new TypeError("Bytesize is not a number.");const{base:r,decimals:o,locale:a,long:i,unit:l,units:b,...g}={base:2,decimals:0,locale:"en-US",long:!1,units:"metric",...t},p=f(r),I=Math.abs(e),m=t?.space??!0?" ":"",s=E[b],c=s.findIndex(h=>h.short===l);if(e===0){const h=Math.min(0,Math.max(c,s.length-1));return"0"+m+s[h][i?"long":"short"]}const y=c===-1?Math.min(Math.floor(Math.log(I)/Math.log(p)),s.length-1):c,T=s[y][i?"long":"short"],x=e/p**y,u=o<0?void 0:o;return new Intl.NumberFormat(a,{maximumFractionDigits:u,minimumFractionDigits:u,...g}).format(x)+m+T},"formatBytes");export{P as formatBytes,N as parseBytes};

package/dist/packem_shared/parseDuration-Bo02kq8G.js

@@ -1 +0,0 @@
-var U=Object.defineProperty;var x=(t,s)=>U(t,"name",{value:s,configurable:!0});import{durationLanguage as k,englishUnitMap as D}from"../language/en.js";import P from"../language/util/validate-duration-language.js";var T=Object.defineProperty,_=x((t,s)=>T(t,"name",{value:s,configurable:!0}),"h");const I={d:864e5,h:36e5,m:6e4,mo:2629746e3,ms:1,s:1e3,w:6048e5,y:31556952e3},p=/[-/\\^$*+?.()|[\]{}]/g,C=/^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/i,G=/^(?:(\d+):)?(?:(\d+):)?(\d+)$/,H=/^[+-]?\d+(?:\.\d+)?$/,B=_((t,s)=>{if(typeof t!="string"||t.length===0)return;const{defaultUnit:w="ms",language:l=k}=s??{};P(l);const g=l.decimal??".",S=l.groupSeparator??",",v=l.placeholderSeparator??"_",A=g.replaceAll(p,String.raw`\$&`),y=S.replaceAll(p,String.raw`\$&`),j=v.replaceAll(p,String.raw`\$&`),d=l.unitMap??D;let i=t.replaceAll(new RegExp(`(\\d)[${j}${y}](\\d)`,"g"),"$1$2");if(g!=="."&&(i=i.replace(A,".")),H.test(t)){const e=Number.parseFloat(i.trim());if(!Number.isNaN(e)){const r=d[w];if(r!==void 0)return e*I[r]}return}const o=C.exec(t);if(o){const e=Number.parseInt(o[1]??"0",10),r=Number.parseInt(o[2]??"0",10),n=Number.parseInt(o[3]??"0",10);return e*36e5+r*6e4+n*1e3}const a=G.exec(t);if(a){let e=0,r=0,n=0;return a[2]!==void 0?(e=Number.parseInt(a[1]??"0",10),r=Number.parseInt(a[2],10)):a[1]!==void 0&&(r=Number.parseInt(a[1],10)),n=Number.parseInt(a[3]??"0",10),e*36e5+r*6e4+n*1e3}const M=Object.keys(d).toSorted((e,r)=>r.length-e.length).map(e=>e.replaceAll(p,String.raw`\$&`)).join("|"),m=new RegExp(`(-?\\d*\\.?\\d+)\\s*(${M})`,"gi");let f=0,u,c=!1,N=-1,b=0;for(m.lastIndex=0;(u=m.exec(i))!==null;){c||(N=u.index),c=!0;const e=u[1],r=u[2];if(!e||!r)continue;const n=e.trim(),L=n.startsWith("-")?-1:1,O=n.replace(/^[-+]/,""),$=Number.parseFloat(O),h=d[r.toLowerCase()];if(h===void 0)continue;const R=I[h];if(Number.isNaN($))return;f+=L*$*R,b=m.lastIndex}const E=i.slice(0,N).trim(),F=i.slice(b).trim();if(!(c&&(E.length>0||F.length>0))&&c)return f},"parseDuration");export{B as default};