@rzl-zone/utils-js 3.7.1 → 3.9.0

package/dist/chunk-NJ24M6ZH.cjs

@@ -0,0 +1,308 @@
+/*!
+ * ====================================================
+ * Rzl Utils-JS.
+ * ----------------------------------------------------
+ * Version: 3.9.0.
+ * Author: Rizalvin Dwiky.
+ * Repository: https://github.com/rzl-zone/utils-js.
+ * ====================================================
+ */
+'use strict';
+
+var chunkDVMHRLKP_cjs = require('./chunk-DVMHRLKP.cjs');
+var chunkH44QVAZL_cjs = require('./chunk-H44QVAZL.cjs');
+var chunk7C7TQC5J_cjs = require('./chunk-7C7TQC5J.cjs');
+
+function getRandomItem(array) {
+  if (!chunk7C7TQC5J_cjs.isNonEmptyArray(array)) return void 0;
+  const randomIndex = Math.floor(Math.random() * (array.length || 0));
+  return array[randomIndex];
+}
+
+var randomInt = (min, max) => {
+  if (!chunkDVMHRLKP_cjs.isInteger(min) || !chunkDVMHRLKP_cjs.isInteger(max)) {
+    throw new TypeError(
+      `First parameter (\`min\`) and second parameter (\`max\`) must be of type \`integer-number\`${minValueNote(
+        min,
+        max
+      )}value, but received: ['min': \`${chunk7C7TQC5J_cjs.getPreciseType(
+        min
+      )}\` - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(min, {
+        keepUndefined: true
+      })})\`, 'max': \`${chunk7C7TQC5J_cjs.getPreciseType(max)}\` - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(
+        max,
+        {
+          keepUndefined: true
+        }
+      )}\`)].`
+    );
+  }
+  if (min > max) {
+    throw new RangeError(
+      `First parameter (\`min\`) must be less than or equal to second parameter (\`max\`), but received: ['min': ${formatValue(
+        min
+      )} - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(min, {
+        keepUndefined: true
+      })})\`, 'max': ${formatValue(max)} - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(max, {
+        keepUndefined: true
+      })})\`].`
+    );
+  }
+  min = Math.max(1, min);
+  max = Math.min(Number.MAX_SAFE_INTEGER, max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+var formatValue = (value) => {
+  return chunk7C7TQC5J_cjs.isNumber(value, { includeNaN: true }) ? value === Number.MIN_VALUE ? "`Number.MIN_VALUE`" : `${value}` : `\`${chunk7C7TQC5J_cjs.getPreciseType(value)}\``;
+};
+var minValueNote = (...values) => {
+  return values.some((v) => chunk7C7TQC5J_cjs.isNumber(v, { includeNaN: true }) && v === Number.MIN_VALUE) ? " and can't be `Number.MIN_VALUE` " : " ";
+};
+
+var randomIntByLength = (options) => {
+  if (!chunk7C7TQC5J_cjs.isPlainObject(options)) {
+    options = {};
+  }
+  const { minLength = 1, maxLength = 16, avoidZero = false } = options;
+  chunk7C7TQC5J_cjs.assertIsBoolean(avoidZero, {
+    message({ currentType, validType }) {
+      return `Parameters \`avoidZero\` must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  if (!chunkDVMHRLKP_cjs.isInteger(minLength) || !chunkDVMHRLKP_cjs.isInteger(maxLength)) {
+    throw new TypeError(
+      `Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${chunk7C7TQC5J_cjs.getPreciseType(
+        minLength
+      )}\` - (with value: ${chunkH44QVAZL_cjs.safeStableStringify(minLength, {
+        keepUndefined: true
+      })}), 'maxLength': \`${chunk7C7TQC5J_cjs.getPreciseType(
+        maxLength
+      )}\` - (with value: ${chunkH44QVAZL_cjs.safeStableStringify(maxLength, {
+        keepUndefined: true
+      })})].`
+    );
+  }
+  if (minLength < 1 || maxLength > 16 || minLength > maxLength) {
+    throw new RangeError(
+      `Invalid range at parameters \`minLength\` must be \u2265 1, \`maxLength\` must be \u2264 16, and \`minLength\` \u2264 \`maxLength\`, but received: ['minLength': \`${minLength}\`, 'maxLength': \`${maxLength}\`].`
+    );
+  }
+  const randomLength = minLength === maxLength ? minLength : randomInt(minLength, maxLength);
+  const minValue = 10 ** (randomLength - 1);
+  const maxValue = 10 ** randomLength - 1;
+  let result = randomInt(minValue, maxValue);
+  if (avoidZero && result === 0) {
+    result = minValue;
+  }
+  return result;
+};
+
+var randomStr = (options) => {
+  if (!chunk7C7TQC5J_cjs.isPlainObject(options)) {
+    options = {};
+  }
+  const {
+    minLength = 40,
+    maxLength = 40,
+    type = "string",
+    avoidWhiteSpace = true
+  } = options;
+  chunk7C7TQC5J_cjs.assertIsBoolean(avoidWhiteSpace, {
+    message({ currentType, validType }) {
+      return `Parameters \`avoidWhiteSpace\` property of the \`options\` (first-parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  if (!chunkDVMHRLKP_cjs.isInteger(minLength) || !chunkDVMHRLKP_cjs.isInteger(maxLength)) {
+    throw new TypeError(
+      `Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${chunk7C7TQC5J_cjs.getPreciseType(
+        minLength
+      )}\` - (with value: ${chunkH44QVAZL_cjs.safeStableStringify(minLength, {
+        keepUndefined: true
+      })}), 'maxLength': \`${chunk7C7TQC5J_cjs.getPreciseType(
+        maxLength
+      )}\` - (with value: ${chunkH44QVAZL_cjs.safeStableStringify(maxLength, {
+        keepUndefined: true
+      })})].`
+    );
+  }
+  if (minLength < 1 || maxLength > 5e3 || minLength > maxLength) {
+    throw new RangeError(
+      `Invalid range at parameters \`minLength\` must be \u2265 1, \`maxLength\` must be \u2264 5000, and \`minLength\` \u2264 \`maxLength\`, but received: ['minLength': \`${minLength}\`, 'maxLength': \`${maxLength}\`].`
+    );
+  }
+  if (type !== "string" && type !== "number") {
+    throw new TypeError(
+      `Parameter \`type\` must be of type \`string\` with value one of "string" | "number", but received: \`${chunk7C7TQC5J_cjs.getPreciseType(
+        type
+      )}\`, with value: ${chunkH44QVAZL_cjs.safeStableStringify(type, {
+        keepUndefined: true
+      })}.`
+    );
+  }
+  const length = randomInt(minLength, maxLength);
+  const cleanCharacters = (charSet) => {
+    return avoidWhiteSpace ? charSet.replace(/\s|\n|\t/g, "") : charSet;
+  };
+  const defaultNumberSet = "0123456789";
+  const defaultStringSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const baseCharSet = type === "number" ? (!chunk7C7TQC5J_cjs.isNaN(Number(options.replaceGenInt)) ? options.replaceGenInt : void 0) ?? defaultNumberSet : (options.replaceGenStr ? options.replaceGenStr : void 0) ?? defaultStringSet;
+  const characterSet = cleanCharacters(baseCharSet) + (options.addChar || "");
+  if (!characterSet.length) {
+    const errCharSet = () => {
+      if (type === "number") {
+        if (avoidWhiteSpace) {
+          return `If \`avoidWhiteSpace\` is true, and \`replaceGenInt\` cant be empty-string value, ensure \`replaceGenInt\` has valid characters and non-nan string number.`;
+        }
+        return `Ensure \`replaceGenInt\` has valid characters and not a NaN number string while convert to number.`;
+      }
+      return `Ensure \`replaceGenStr\` has valid characters and non empty string.`;
+    };
+    throw new Error(`Character set is empty. ${errCharSet()}`);
+  }
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += characterSet.charAt(Math.floor(Math.random() * characterSet.length));
+  }
+  return result;
+};
+
+function randomUUID(options = {}) {
+  if (!chunk7C7TQC5J_cjs.isPlainObject(options)) {
+    throw new TypeError(
+      `First parameter (\`options\`) must be a plain object with optional properties \`version\` and \`monotonic\`, but received: \`${chunk7C7TQC5J_cjs.getPreciseType(
+        options
+      )}\` - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(options, { keepUndefined: true })}\`).`
+    );
+  }
+  const { version = "v4", monotonic = false } = options;
+  if (!chunk7C7TQC5J_cjs.isNonEmptyString(version)) {
+    throw new TypeError(
+      `Parameter \`version\` property of the \`options\` (first parameter) must be a \`string\` of either "v4" or "v7", but received type: \`${chunk7C7TQC5J_cjs.getPreciseType(
+        version
+      )}\` - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(version, { keepUndefined: true })}\`).`
+    );
+  }
+  if (version !== "v4" && version !== "v7") {
+    throw new RangeError(
+      `Unsupported UUID version. Allowed values are "v4" or "v7". (received: \`${chunkH44QVAZL_cjs.safeStableStringify(
+        version,
+        {
+          keepUndefined: true
+        }
+      )}\`).`
+    );
+  }
+  if (!chunk7C7TQC5J_cjs.isBoolean(monotonic)) {
+    throw new TypeError(
+      `Parameter \`monotonic\` property of the \`options\` (first parameter) must be a \`boolean\` when provided, but received type: \`${chunk7C7TQC5J_cjs.getPreciseType(
+        monotonic
+      )}\` - (with value: \`${chunkH44QVAZL_cjs.safeStableStringify(monotonic, {
+        keepUndefined: true
+      })}\`).`
+    );
+  }
+  if (monotonic && version !== "v7") {
+    throw new TypeError(
+      `Parameter \`monotonic\` property of the \`options\` (first parameter) is only supported for version "v7". Received: version=${chunkH44QVAZL_cjs.safeStableStringify(
+        version,
+        { keepUndefined: true }
+      )}.`
+    );
+  }
+  if (version === "v4") {
+    return generateUUIDv4();
+  }
+  return generateUUIDv7({ monotonic });
+}
+function hasCryptoGetRandomValues() {
+  return typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function";
+}
+function hasCryptoRandomUUID() {
+  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function";
+}
+function getRandomBytes(len) {
+  if (hasCryptoGetRandomValues()) {
+    return crypto.getRandomValues(new Uint8Array(len));
+  }
+  const arr = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    arr[i] = Math.floor(Math.random() * 256);
+  }
+  return arr;
+}
+var byteToHex = (() => {
+  const arr = [];
+  for (let i = 0; i < 256; ++i) {
+    arr.push((i + 256).toString(16).substring(1));
+  }
+  return arr;
+})();
+function generateUUIDv4() {
+  if (hasCryptoRandomUUID()) {
+    return crypto.randomUUID();
+  }
+  if (hasCryptoGetRandomValues()) {
+    const rnd = crypto.getRandomValues(new Uint8Array(16));
+    rnd[6] = rnd[6] & 15 | 64;
+    rnd[8] = rnd[8] & 63 | 128;
+    return byteToHex[rnd[0]] + byteToHex[rnd[1]] + byteToHex[rnd[2]] + byteToHex[rnd[3]] + "-" + byteToHex[rnd[4]] + byteToHex[rnd[5]] + "-" + byteToHex[rnd[6]] + byteToHex[rnd[7]] + "-" + byteToHex[rnd[8]] + byteToHex[rnd[9]] + "-" + byteToHex[rnd[10]] + byteToHex[rnd[11]] + byteToHex[rnd[12]] + byteToHex[rnd[13]] + byteToHex[rnd[14]] + byteToHex[rnd[15]];
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var monotonicState = {
+  lastTimestampMs: -1,
+  lastRand: null
+};
+function incrementUint8ArrayBigEndian(arr) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (arr[i] === 255) {
+      arr[i] = 0;
+      continue;
+    }
+    arr[i] = arr[i] + 1 & 255;
+    return false;
+  }
+  return true;
+}
+function generateUUIDv7({ monotonic = false } = {}) {
+  const nowMs = Date.now();
+  const tsHex = BigInt(nowMs).toString(16).padStart(12, "0");
+  let rand = getRandomBytes(10);
+  if (monotonic) {
+    if (monotonicState.lastTimestampMs === nowMs && monotonicState.lastRand) {
+      const copy = new Uint8Array(monotonicState.lastRand);
+      const overflow = incrementUint8ArrayBigEndian(copy);
+      if (overflow) {
+        throw new RangeError(
+          "Monotonic UUID sequence overflow: too many UUIDs generated within the same millisecond."
+        );
+      }
+      rand = copy;
+      monotonicState.lastRand = copy;
+    } else {
+      const fresh = getRandomBytes(10);
+      monotonicState.lastRand = new Uint8Array(fresh);
+      monotonicState.lastTimestampMs = nowMs;
+      rand = fresh;
+    }
+  }
+  rand[0] = rand[0] & 15 | 112;
+  rand[2] = rand[2] & 63 | 128;
+  const randHex = Array.from(rand, (b) => byteToHex[b]).join("");
+  const part1 = tsHex.slice(0, 8);
+  const part2 = tsHex.slice(8, 12);
+  const part3 = randHex.slice(0, 4);
+  const part4 = randHex.slice(4, 8);
+  const part5 = randHex.slice(8, 20);
+  return [part1, part2, part3, part4, part5].join("-");
+}
+
+exports.getRandomItem = getRandomItem;
+exports.randomInt = randomInt;
+exports.randomIntByLength = randomIntByLength;
+exports.randomStr = randomStr;
+exports.randomUUID = randomUUID;

package/dist/chunk-OCTHWEZK.cjs

@@ -0,0 +1,249 @@
+/*!
+ * ====================================================
+ * Rzl Utils-JS.
+ * ----------------------------------------------------
+ * Version: 3.9.0.
+ * Author: Rizalvin Dwiky.
+ * Repository: https://github.com/rzl-zone/utils-js.
+ * ====================================================
+ */
+'use strict';
+
+var chunk6AMDHVS2_cjs = require('./chunk-6AMDHVS2.cjs');
+var chunkIX6PF5ZP_cjs = require('./chunk-IX6PF5ZP.cjs');
+var chunkFWWPEL7J_cjs = require('./chunk-FWWPEL7J.cjs');
+var chunkH44QVAZL_cjs = require('./chunk-H44QVAZL.cjs');
+var chunk7C7TQC5J_cjs = require('./chunk-7C7TQC5J.cjs');
+
+var NormalizePathnameError = class _NormalizePathnameError extends Error {
+  /** * ***The original error that triggered this normalization failure.***
+   *
+   * **Always available for backward compatibility.**
+   */
+  originalError;
+  constructor(message, originalError) {
+    super(message, chunk7C7TQC5J_cjs.isFunction(Error) ? { cause: originalError } : void 0);
+    this.name = "NormalizePathnameError";
+    this.originalError = originalError;
+    if (chunk7C7TQC5J_cjs.isFunction(Error.captureStackTrace)) {
+      Error.captureStackTrace(this, _NormalizePathnameError);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+  /** * ***Safe JSON representation for logging or IPC.*** */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      stack: this.stack,
+      originalError: {
+        name: this.originalError.name,
+        message: this.originalError.message,
+        stack: this.originalError.stack
+      }
+    };
+  }
+};
+
+function normalizePathname(pathname, options = {
+  defaultPath: "/",
+  keepNullable: false
+}) {
+  chunk7C7TQC5J_cjs.assertIsPlainObject(options, {
+    message({ currentType, validType }) {
+      return `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  const {
+    defaultPath = "/",
+    keepNullable = false,
+    keepTrailingSlash = false,
+    localhostDomain = false,
+    ignoreDomainExtensions = void 0
+  } = options;
+  if (!chunk7C7TQC5J_cjs.isNonEmptyString(defaultPath)) {
+    throw new TypeError(
+      `Parameter \`defaultPath\` property of the \`options\` (second parameter) must be of type \`string\` and not empty-string, but received: \`${chunk7C7TQC5J_cjs.getPreciseType(
+        defaultPath
+      )}\`, with value: \`${chunkH44QVAZL_cjs.safeStableStringify(defaultPath, {
+        keepUndefined: true
+      })}\`.`
+    );
+  }
+  chunk7C7TQC5J_cjs.assertIsBoolean(keepNullable, {
+    message({ currentType, validType }) {
+      return `Parameter \`keepNullable\` property of the \`options\` (second parameter)  must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  chunk7C7TQC5J_cjs.assertIsBoolean(keepTrailingSlash, {
+    message({ currentType, validType }) {
+      return `Parameter \`keepTrailingSlash\` property of the \`options\` (second parameter)  must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  chunk7C7TQC5J_cjs.assertIsBoolean(localhostDomain, {
+    message({ currentType, validType }) {
+      return `Parameter \`localhostDomain\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  let ignoreDomainExtsSet;
+  if (!chunk7C7TQC5J_cjs.isUndefined(ignoreDomainExtensions)) {
+    if (!chunk7C7TQC5J_cjs.isSet(ignoreDomainExtensions) && !chunk7C7TQC5J_cjs.isArray(ignoreDomainExtensions)) {
+      throw new TypeError(
+        `Parameter \`ignoreDomainExtensions\` must be of type a \`Set<string>\` or \`string[]\`, but received: \`${chunk7C7TQC5J_cjs.getPreciseType(
+          ignoreDomainExtensions
+        )}\`.`
+      );
+    }
+    ignoreDomainExtsSet = chunk7C7TQC5J_cjs.isSet(ignoreDomainExtensions) ? ignoreDomainExtensions : new Set(ignoreDomainExtensions);
+    let idx = 0;
+    for (const ext of ignoreDomainExtsSet) {
+      if (!chunk7C7TQC5J_cjs.isNonEmptyString(ext)) {
+        throw new TypeError(
+          `Parameter \`ignoreDomainExtensions[${idx}]\` must be a \`string\` and \`non-empty string\`, but received: \`${chunkH44QVAZL_cjs.safeStableStringify(
+            ext,
+            { keepUndefined: true }
+          )}\`.`
+        );
+      }
+      if (!ext.startsWith(".")) {
+        throw new TypeError(
+          `Parameter \`ignoreDomainExtensions[${idx}]\` must start with a dot (.), but received: ${chunkH44QVAZL_cjs.safeStableStringify(
+            ext,
+            { keepUndefined: true }
+          )}`
+        );
+      }
+      idx++;
+    }
+  }
+  try {
+    if (keepNullable && (chunk7C7TQC5J_cjs.isNil(pathname) || !chunk7C7TQC5J_cjs.isString(pathname))) {
+      if (chunk7C7TQC5J_cjs.isNull(pathname)) return null;
+      return void 0;
+    }
+    let currentPathName = chunk7C7TQC5J_cjs.isNonEmptyString(pathname) ? pathname : defaultPath;
+    currentPathName = chunkIX6PF5ZP_cjs.removeSpaces(currentPathName, { trimOnly: true }).replace(
+      /\s+/g,
+      ""
+    );
+    currentPathName = stripLeadingDomain(currentPathName, {
+      keepTrailingSlash,
+      localhostDomain,
+      ignoreDomainExtensions: ignoreDomainExtsSet
+    });
+    let _pathName = currentPathName;
+    let search = "";
+    let hash = "";
+    const searchIndex = currentPathName.indexOf("?");
+    const hashIndex = currentPathName.indexOf("#");
+    if (searchIndex !== -1) {
+      search = currentPathName.slice(
+        searchIndex,
+        hashIndex !== -1 ? hashIndex : void 0
+      );
+    }
+    if (hashIndex !== -1) {
+      hash = currentPathName.slice(hashIndex);
+    }
+    const endIndex = Math.min(
+      searchIndex !== -1 ? searchIndex : currentPathName.length,
+      hashIndex !== -1 ? hashIndex : currentPathName.length
+    );
+    _pathName = currentPathName.slice(0, endIndex);
+    _pathName = "/" + _pathName.replace(/^\/+/, "").replace(/\/{2,}/g, "/");
+    if (!keepTrailingSlash && _pathName !== "/") {
+      _pathName = _pathName.replace(/\/+$/, "");
+    }
+    _pathName = decodeUnicodeSequences(_pathName);
+    search = decodeUnicodeSequences(search);
+    hash = decodeUnicodeSequences(hash);
+    return _pathName + search + hash;
+  } catch (error) {
+    throwError(error);
+  }
+}
+var decodeUnicodeSequences = (str) => {
+  return str.replace(/(?:%(?:[0-9A-F]{2})){2,}/gi, (match) => {
+    try {
+      const decoded = decodeURIComponent(match);
+      if (/^[\u0000-\u007F]+$/.test(decoded)) return match;
+      return decoded;
+    } catch {
+      return match;
+    }
+  });
+};
+var stripLeadingDomain = (path, options) => {
+  let currentPath = path;
+  const { ignoreDomainExtensions, localhostDomain } = options;
+  if (/^https?:\/\//i.test(currentPath)) {
+    try {
+      const url = new URL(currentPath);
+      currentPath = url.pathname.replace(/^\/+/, "").replace(/\/{2,}/g, "/") + url.search + url.hash;
+      return ensureLeadingSlash(currentPath);
+    } catch (error) {
+      throwError(error);
+    }
+  }
+  if (currentPath.startsWith("/")) {
+    currentPath = currentPath.replace(/\/{2,}/g, "/").slice(1);
+  }
+  const segments = currentPath.split("/");
+  const firstPart = segments[0];
+  const domainPart = firstPart.split(":")[0];
+  const isDomain = chunk6AMDHVS2_cjs.isValidDomain(domainPart, {
+    subdomain: true,
+    allowUnicode: true,
+    wildcard: true,
+    allowLocalhost: localhostDomain,
+    allowPort: true,
+    allowProtocol: true,
+    topLevel: false
+  });
+  let hasIgnoredExtension = false;
+  if (ignoreDomainExtensions) {
+    for (const ext of ignoreDomainExtensions) {
+      if (firstPart.endsWith(ext)) {
+        hasIgnoredExtension = true;
+        break;
+      }
+    }
+  }
+  if (isDomain && !hasIgnoredExtension) {
+    segments.shift();
+  }
+  return ensureLeadingSlash(segments.join("/"));
+};
+var ensureLeadingSlash = (path) => {
+  if (!path.startsWith("/")) path = "/" + path;
+  return path;
+};
+var throwError = (error) => {
+  const err = chunk7C7TQC5J_cjs.isError(error) ? error : new Error("Unknown error from function `normalizePathname()`.");
+  throw new NormalizePathnameError(
+    `Failed to normalize pathname in function \`normalizePathname()\`: ${err.message}`,
+    err
+  );
+};
+
+var formatEnvPort = (envVar, options = {}) => {
+  if (!chunk7C7TQC5J_cjs.isNonEmptyString(envVar)) return "";
+  chunk7C7TQC5J_cjs.assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const prefixColon = chunk7C7TQC5J_cjs.hasOwnProp(options, "prefixColon") ? options.prefixColon : false;
+  if (!chunk7C7TQC5J_cjs.isBoolean(prefixColon)) {
+    throw new TypeError(
+      `Parameter \`prefixColon\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: \`${chunk7C7TQC5J_cjs.getPreciseType(
+        prefixColon
+      )}\`.`
+    );
+  }
+  const digitsOnly = envVar.replace(/\D+/g, "");
+  if (chunkFWWPEL7J_cjs.isEmptyString(digitsOnly)) return "";
+  return prefixColon ? `:${digitsOnly}` : digitsOnly;
+};
+
+exports.formatEnvPort = formatEnvPort;
+exports.normalizePathname = normalizePathname;

package/dist/chunk-ONZFBJVW.js

@@ -2,7 +2,7 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================

package/dist/{chunk-FI76UZRF.js → chunk-OSSFLQDD.js}

@@ -2,21 +2,20 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
-import { isString, resolveErrorMessageAssertions } from './chunk-3KTD3QDI.js';
+import { isString, resolveErrorMessageAssertions } from './chunk-J4TT33ZX.js';
 
 var assertIsString = (value, options = {}) => {
   if (isString(value)) return;
-  const errorMessage = resolveErrorMessageAssertions({
+  resolveErrorMessageAssertions({
     value,
     options,
     requiredValidType: "string"
   });
-  throw new TypeError(errorMessage);
 };
 
 export { assertIsString };

package/dist/{chunk-7WBMA2VE.cjs → chunk-OYFUBKEG.cjs}

@@ -2,23 +2,22 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
 'use strict';
 
-var chunkF3WBQKRI_cjs = require('./chunk-F3WBQKRI.cjs');
+var chunk7C7TQC5J_cjs = require('./chunk-7C7TQC5J.cjs');
 
 function assertIsArray(value, options) {
-  if (chunkF3WBQKRI_cjs.isArray(value)) return;
-  const errorMessage = chunkF3WBQKRI_cjs.resolveErrorMessageAssertions({
+  if (chunk7C7TQC5J_cjs.isArray(value)) return;
+  chunk7C7TQC5J_cjs.resolveErrorMessageAssertions({
     value,
     options,
     requiredValidType: "array"
   });
-  throw new TypeError(errorMessage);
 }
 
 exports.assertIsArray = assertIsArray;

package/dist/{chunk-B4SDEBN7.cjs → chunk-PWKOFPAH.cjs}

@@ -2,17 +2,17 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
  */
 'use strict';
 
-var chunkF3WBQKRI_cjs = require('./chunk-F3WBQKRI.cjs');
+var chunk7C7TQC5J_cjs = require('./chunk-7C7TQC5J.cjs');
 
 function isFinite(value) {
-  return chunkF3WBQKRI_cjs.isNumber(value) && Number.isFinite(value);
+  return chunk7C7TQC5J_cjs.isNumber(value) && Number.isFinite(value);
 }
 
 exports.isFinite = isFinite;

package/dist/{chunk-2CQI36UD.cjs → chunk-QGTFQ7RO.cjs}

@@ -2,7 +2,7 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================
@@ -10,8 +10,8 @@
 'use strict';
 
 var chunkDVMHRLKP_cjs = require('./chunk-DVMHRLKP.cjs');
-var chunkYC7AK3KX_cjs = require('./chunk-YC7AK3KX.cjs');
-var chunkF3WBQKRI_cjs = require('./chunk-F3WBQKRI.cjs');
+var chunkH44QVAZL_cjs = require('./chunk-H44QVAZL.cjs');
+var chunk7C7TQC5J_cjs = require('./chunk-7C7TQC5J.cjs');
 
 var CustomPromise = class extends Promise {
   _value;
@@ -74,12 +74,14 @@ var AbortError = class extends Error {
 var delay = (milliSeconds = 1e3, signal) => {
   if (!chunkDVMHRLKP_cjs.isInteger(milliSeconds) || milliSeconds <= 0) {
     throw new TypeError(
-      `First parameter (\`milliSeconds\`) must be of type \`number\` and value must be a \`non-zero\`, \`non-NaN\`, \`non-negative\`, and \`integer-number\`, but received: \`${chunkF3WBQKRI_cjs.getPreciseType(
+      `First parameter (\`milliSeconds\`) must be of type \`number\` and value must be a \`non-zero\`, \`non-NaN\`, \`non-negative\`, and \`integer-number\`, but received: \`${chunk7C7TQC5J_cjs.getPreciseType(
         milliSeconds
-      )}\`, with value: \`${chunkYC7AK3KX_cjs.safeStableStringify(milliSeconds)}\`.`
+      )}\`, with value: \`${chunkH44QVAZL_cjs.safeStableStringify(milliSeconds, {
+        keepUndefined: true
+      })}\`.`
     );
   }
-  if (chunkF3WBQKRI_cjs.isNull(signal) || signal && !(signal instanceof AbortSignal)) {
+  if (chunk7C7TQC5J_cjs.isNull(signal) || signal && !(signal instanceof AbortSignal)) {
     throw new TypeError(
       "Second parameter (`signal`) must be an `instance of AbortSignal` if provided."
     );

package/dist/chunk-QNKGP5DY.js

@@ -2,7 +2,7 @@
  * ====================================================
  * Rzl Utils-JS.
  * ----------------------------------------------------
- * Version: 3.7.1.
+ * Version: 3.9.0.
  * Author: Rizalvin Dwiky.
  * Repository: https://github.com/rzl-zone/utils-js.
  * ====================================================