@rzl-zone/utils-js 3.11.1 → 3.12.1-beta.0

package/dist/chunk-FJ4BQFVO.js

@@ -1,587 +0,0 @@
-/*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.11.1.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-import { normalizeSpaces } from './chunk-ZVWZEGQP.js';
-import { parseCurrencyString } from './chunk-2XSZ2ANI.js';
-import { isFinite } from './chunk-CCJ2MSN7.js';
-import { isInteger } from './chunk-WVSPXFTY.js';
-import { isEmptyString } from './chunk-ULQPCIA2.js';
-import { assertIsString } from './chunk-3T6VSWYX.js';
-import { safeStableStringify, isDate } from './chunk-AXDYWO67.js';
-import { isString, getPreciseType, assertIsPlainObject, hasOwnProp, isBoolean, isPlainObject, isNaN, isUndefined, isFunction, assertIsBoolean, isNil, isNumber, isNonEmptyString } from './chunk-MSUW5VHZ.js';
-import { isSupportedCountry, AsYouType } from 'libphonenumber-js/max';
-import { id, enUS } from 'date-fns/locale';
-import { parse, format } from 'date-fns';
-
-var formatIndianNumber = (numStr, separator) => {
-  const lastThree = numStr.slice(-3);
-  const rest = numStr.slice(0, -3);
-  if (!rest) return lastThree;
-  return rest.replace(/\B(?=(\d{2})+(?!\d))/g, separator) + separator + lastThree;
-};
-var formatCurrency = (value, options = {}) => {
-  if (!isString(value) && !isFinite(value)) {
-    throw new TypeError(
-      `First parameter (\`value\`) must be of type \`string\` or \`primitive-number\`, but received: \`${getPreciseType(
-        value
-      )}\`, with value: \`${safeStableStringify(value, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  const decimal = hasOwnProp(options, "decimal") ? options.decimal : false;
-  const totalDecimal = hasOwnProp(options, "totalDecimal") ? options.totalDecimal : 2;
-  const endDecimal = hasOwnProp(options, "endDecimal") ? options.endDecimal : true;
-  const indianFormat = hasOwnProp(options, "indianFormat") ? options.indianFormat : false;
-  const suffixCurrency = hasOwnProp(options, "suffixCurrency") ? options.suffixCurrency : "";
-  const suffixDecimal = hasOwnProp(options, "suffixDecimal") ? options.suffixDecimal : "";
-  const roundedDecimal = hasOwnProp(options, "roundedDecimal") ? options.roundedDecimal : "round";
-  const negativeFormat = hasOwnProp(options, "negativeFormat") ? options.negativeFormat : "dash";
-  let separatorDecimals = hasOwnProp(options, "separatorDecimals") ? options.separatorDecimals : ",";
-  let separator = hasOwnProp(options, "separator") ? options.separator : ".";
-  if (!isString(separator) || !isString(separatorDecimals) || !isString(suffixCurrency) || !isString(suffixDecimal)) {
-    throw new TypeError(
-      `Parameter \`separator\`, \`separatorDecimals\`, \`suffixCurrency\` and \`suffixDecimal\` property of the \`options\` (second parameter) must be of type \`string\`, but received: ['separator': \`${getPreciseType(
-        separator
-      )}\`, 'separatorDecimals': \`${getPreciseType(
-        separatorDecimals
-      )}\`, 'suffixCurrency': \`${getPreciseType(
-        suffixCurrency
-      )}\`, 'suffixDecimal': \`${getPreciseType(suffixDecimal)}\`].`
-    );
-  }
-  if (!isBoolean(decimal) || !isBoolean(endDecimal) || !isBoolean(indianFormat)) {
-    throw new TypeError(
-      `Parameter \`decimal\`, \`endDecimal\` and \`indianFormat\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['decimal': \`${getPreciseType(
-        decimal
-      )}\`, 'endDecimal': \`${getPreciseType(
-        endDecimal
-      )}\`, 'indianFormat': \`${getPreciseType(indianFormat)}\`].`
-    );
-  }
-  if (!isInteger(totalDecimal)) {
-    throw new TypeError(
-      `Parameter \`totalDecimal\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${getPreciseType(
-        totalDecimal
-      )}\`, with value: \`${safeStableStringify(length, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  if (!(roundedDecimal === false || roundedDecimal === "round" || roundedDecimal === "ceil" || roundedDecimal === "floor")) {
-    throw new TypeError(
-      `Parameter \`roundedDecimal\` property of the \`options\` (second parameter) must be of type \`false\` or \`string\` must be one of "round" | "ceil" | "floor", but received: \`${getPreciseType(
-        roundedDecimal
-      )}\`, with value: \`${safeStableStringify(roundedDecimal, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  if (!(negativeFormat === "abs" || negativeFormat === "brackets" || negativeFormat === "dash" || isPlainObject(negativeFormat))) {
-    throw new TypeError(
-      `Parameter \`negativeFormat\` property of the \`options\` (second parameter) must be of type \`string\` must be one of "abs" | "brackets" | "dash" or \`plain-object\` type, but received: \`${getPreciseType(
-        negativeFormat
-      )}\`, with value: \`${safeStableStringify(negativeFormat, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  const rawNum = isString(value) ? parseCurrencyString(value) : value;
-  if (isNaN(rawNum)) {
-    throw new TypeError(
-      `First parameter (\`value\`) could not be parsed into a valid \`number\`.`
-    );
-  }
-  let integerPart = "";
-  let decimalPartRaw = "";
-  let num = Math.abs(rawNum);
-  const factor = Math.pow(10, totalDecimal);
-  if (roundedDecimal) {
-    const scaled = num * factor;
-    switch (roundedDecimal) {
-      case "round":
-        num = Math.round(scaled) / factor;
-        break;
-      case "ceil":
-        num = Math.ceil(scaled) / factor;
-        break;
-      case "floor":
-        num = Math.floor(scaled) / factor;
-        break;
-    }
-  }
-  if (roundedDecimal) {
-    [integerPart, decimalPartRaw] = num.toFixed(totalDecimal).split(".");
-    decimalPartRaw = decimalPartRaw ?? "".padEnd(totalDecimal, "0");
-  } else {
-    const split = String(num).split(".");
-    integerPart = split[0];
-    decimalPartRaw = (split[1] || "").slice(0, totalDecimal).padEnd(totalDecimal, "0");
-  }
-  let formattedInteger;
-  if (indianFormat) {
-    separator = ",";
-    separatorDecimals = ".";
-    formattedInteger = (suffixCurrency.trim().length ? suffixCurrency : "") + formatIndianNumber(integerPart, separator);
-  } else {
-    formattedInteger = (suffixCurrency.trim().length ? suffixCurrency : "") + integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
-  }
-  if (decimal && !isUndefined(decimalPartRaw) && totalDecimal > 0) {
-    let formattedDecimal = separatorDecimals + decimalPartRaw;
-    if (endDecimal) formattedDecimal += suffixDecimal;
-    formattedInteger += formattedDecimal;
-  }
-  if (rawNum < 0) {
-    if (negativeFormat === "dash") {
-      formattedInteger = "-" + formattedInteger;
-    } else if (negativeFormat === "brackets") {
-      formattedInteger = "(" + formattedInteger + ")";
-    } else if (negativeFormat === "abs") ; else if (isPlainObject(negativeFormat)) {
-      if (hasOwnProp(negativeFormat, "custom")) {
-        const formatCustomNegative = negativeFormat.custom;
-        if (!isFunction(formatCustomNegative)) {
-          throw new TypeError(
-            `Parameter \`negativeFormat.custom\` property of the \`options\` (second parameter) must be of type function: \`(formatted: string) => string\`, but received: \`${getPreciseType(
-              formatCustomNegative
-            )}\`.`
-          );
-        }
-        const result = formatCustomNegative(formattedInteger);
-        assertIsString(result, {
-          message: ({ currentType, validType }) => `Parameter \`negativeFormat.custom\` property of the \`options\` (second parameter) expected return a \`${validType}\` type value, but received: \`${currentType}\`.`
-        });
-        formattedInteger = result;
-      } else {
-        const formatStyleNegative = negativeFormat.style || "dash";
-        const formatSpaceNegative = !isUndefined(negativeFormat.space) ? negativeFormat.space : false;
-        assertIsBoolean(formatSpaceNegative, {
-          message: ({ currentType, validType }) => `Parameter \`negativeFormat.space\` property of the \`options\` (second parameter) must be of type \`${validType} or undefined\`, but received: \`${currentType}\`.`
-        });
-        if (!(formatStyleNegative === "abs" || formatStyleNegative === "brackets" || formatStyleNegative === "dash")) {
-          throw new TypeError(
-            `Parameter \`negativeFormat.style\` property of the \`options\` (second parameter) must be of type \`string\` must be of type "abs" | "brackets" | "dash", but received: \`${getPreciseType(
-              formatStyleNegative
-            )}\`, with value: \`${safeStableStringify(formatStyleNegative, {
-              keepUndefined: true
-            })}\`.`
-          );
-        }
-        switch (formatStyleNegative) {
-          case "dash":
-            formattedInteger = "-" + (formatSpaceNegative ? " " : "") + formattedInteger;
-            break;
-          case "brackets":
-            formattedInteger = formatSpaceNegative ? `( ${formattedInteger} )` : `(${formattedInteger})`;
-            break;
-        }
-      }
-    }
-  }
-  return formattedInteger;
-};
-
-var formatNumber = (value, separator = ",") => {
-  if (!isString(value) && !isFinite(value)) {
-    throw new TypeError(
-      `First parameter (\`value\`) must be of type \`string\` or \`primitive number\`, but received: \`${getPreciseType(
-        value
-      )}\`.`
-    );
-  }
-  if (!isString(separator)) {
-    throw new TypeError(
-      `Second parameter (\`separator\`) must be of type \`string\` or empty as \`undefined\`, but received: \`${getPreciseType(
-        separator
-      )}\`.`
-    );
-  }
-  separator = isString(separator) ? separator : ",";
-  const decimalSeparator = separator === "." ? "," : separator === "," ? "." : ".";
-  const stringValue = value.toString().trim();
-  const lastDot = stringValue.lastIndexOf(".");
-  const lastComma = stringValue.lastIndexOf(",");
-  let actualDecimal = "";
-  if (lastDot > lastComma) {
-    actualDecimal = ".";
-  } else if (lastComma > lastDot) {
-    actualDecimal = ",";
-  }
-  let integerPart = stringValue;
-  let decimalPart = "";
-  if (actualDecimal) {
-    const parts = stringValue.split(actualDecimal);
-    integerPart = parts.slice(0, -1).join(actualDecimal);
-    decimalPart = parts.slice(-1)[0];
-  }
-  integerPart = integerPart.replace(/[^\d]/g, "");
-  const formattedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
-  return decimalPart ? `${formattedInteger}${decimalSeparator}${decimalPart}` : formattedInteger;
-};
-var parsingAsYouType = (value, defaultCountry) => {
-  let parsed;
-  try {
-    parsed = new AsYouType(defaultCountry);
-    parsed.input(value);
-    return parsed;
-  } catch {
-    parsed?.reset();
-    return void 0;
-  }
-};
-var isValidParseAsYouType = (parsedAsYouType) => {
-  const parsed = !!parsedAsYouType?.isValid() && !!parsedAsYouType.getNumber();
-  return parsed;
-};
-
-function formatPhoneNumber(value, options = {}) {
-  if (isNil(value)) return "";
-  if (!isString(value) && !isNumber(value)) {
-    throw new TypeError(
-      `First parameter (\`value\`) must be of type \`string\`, \`number\`, \`null\` or \`undefined\`, but received: \`${getPreciseType(
-        value
-      )}\`.`
-    );
-  }
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  const takeNumberOnly = hasOwnProp(options, "takeNumberOnly") ? options.takeNumberOnly : false;
-  const checkValidOnly = hasOwnProp(options, "checkValidOnly") ? options.checkValidOnly : false;
-  const defaultCountry = hasOwnProp(
-    options,
-    "defaultCountry"
-  ) ? options.defaultCountry : void 0;
-  const separator = hasOwnProp(options, "separator") ? options.separator : " ";
-  const prependPlusCountryCode = hasOwnProp(options, "prependPlusCountryCode") ? options.prependPlusCountryCode : true;
-  const outputFormat = hasOwnProp(options, "outputFormat") ? options.outputFormat : "INTERNATIONAL";
-  const openingNumberCountry = hasOwnProp(options, "openingNumberCountry") ? options.openingNumberCountry : "";
-  const closingNumberCountry = hasOwnProp(options, "closingNumberCountry") ? options.closingNumberCountry : "";
-  if (!isBoolean(takeNumberOnly) || !isBoolean(checkValidOnly) || !isBoolean(prependPlusCountryCode)) {
-    throw new TypeError(
-      `Parameter \`takeNumberOnly\`, \`checkValidOnly\` and \`prependPlusCountryCode\` property of the \`options\` (second parameter) must be of type \`boolean\` or unset as \`undefined\` value, but received: ['takeNumberOnly': \`${getPreciseType(
-        takeNumberOnly
-      )}\`, 'checkValidOnly': \`${getPreciseType(
-        checkValidOnly
-      )}\`, 'prependPlusCountryCode': \`${getPreciseType(prependPlusCountryCode)}\`].`
-    );
-  }
-  if (!isUndefined(defaultCountry) && !isSupportedCountry(defaultCountry)) {
-    throw new TypeError(
-      `Parameter \`defaultCountry\` property of the \`options\` (second parameter) must be of type \`string\` as \`CountryCode\` (ISO-3166-1 alpha-2) or unset as \`undefined\` value, but received: \`${getPreciseType(
-        defaultCountry
-      )}\`, with value: \`${safeStableStringify(defaultCountry, {
-        keepUndefined: true
-      })}\`.
-
-See: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements, for all ISO 3166-1 alpha-2 code.`
-    );
-  }
-  if (!["INTERNATIONAL", "NATIONAL", "RFC3966", "E.164"].includes(outputFormat)) {
-    throw new TypeError(
-      `Parameter \`outputFormat\` property of the \`options\` (second parameter) must be of type \`string\` as \`OutputFormat\` ("NATIONAL" | "INTERNATIONAL" | "E.164" | "RFC3966") or unset as \`undefined\` (default value to: \`INTERNATIONAL\`) value, but received: \`${getPreciseType(
-        outputFormat
-      )}\`, with value: ${safeStableStringify(outputFormat, { keepUndefined: true })}.`
-    );
-  }
-  if (!isString(separator) || !isString(openingNumberCountry) || !isString(closingNumberCountry)) {
-    throw new TypeError(
-      `Parameter \`separator\`, \`plusNumberCountry\`, \`openingNumberCountry\` and \`closingNumberCountry\` property of the \`options\` (second parameter) must be of type \`string\` or unset as \`undefined\` value, but received: ['separator': \`${getPreciseType(
-        separator
-      )}\`,'openingNumberCountry': \`${getPreciseType(
-        openingNumberCountry
-      )}\`, 'closingNumberCountry': \`${getPreciseType(closingNumberCountry)}\`].`
-    );
-  }
-  if (!isString(value)) value = String(value);
-  const parsedPhoneNumber = parsingAsYouType(value, defaultCountry);
-  const validPhoneNumber = isValidParseAsYouType(parsedPhoneNumber);
-  if (checkValidOnly) return validPhoneNumber;
-  if (!validPhoneNumber) return "";
-  if (takeNumberOnly) {
-    return parsedPhoneNumber.getNumber().formatNational().replace(/\D/g, "");
-  }
-  const num = parsedPhoneNumber.getNumber();
-  const intlNumb = num.format(outputFormat);
-  if (outputFormat === "INTERNATIONAL") {
-    const [cc, ...rest] = intlNumb.split(" ");
-    const countryCode = prependPlusCountryCode ? cc : cc.replace(/^\++/, "");
-    const restWithSeparator = rest.join(separator);
-    if (isNonEmptyString(openingNumberCountry) && isNonEmptyString(closingNumberCountry)) {
-      return `${openingNumberCountry}${countryCode}${closingNumberCountry} ${restWithSeparator}`;
-    }
-    return `${countryCode} ${restWithSeparator}`;
-  }
-  if (outputFormat === "NATIONAL") {
-    const restWithSeparator = intlNumb.split(" ").join(separator);
-    return `${restWithSeparator}`;
-  }
-  return intlNumb;
-}
-
-var hashSeedGenerate = (mode, email) => {
-  const generateSeed = () => {
-    let hash = 0;
-    for (let i = 0; i < email.length; i++) {
-      hash = (hash << 5) - hash + email.charCodeAt(i);
-      hash |= 0;
-    }
-    return Math.abs(hash);
-  };
-  return mode === "fixed" ? generateSeed() : void 0;
-};
-var _censor = (str, minCensor, maxPercentage, hashSeed) => {
-  if (str.length <= minCensor) return "*".repeat(str.length);
-  const strArr = str.split("");
-  const totalCensor = Math.max(minCensor, Math.ceil(str.length * maxPercentage));
-  const indexes = /* @__PURE__ */ new Set();
-  let i = 0;
-  while (indexes.size < totalCensor) {
-    const idx = !isUndefined(hashSeed) ? (hashSeed + str.length + i * 31) % str.length : Math.floor(Math.random() * str.length);
-    indexes.add(idx);
-    i++;
-  }
-  for (const index of indexes) {
-    strArr[index] = "*";
-  }
-  return strArr.join("");
-};
-
-var censorEmail = (email, options = {}) => {
-  if (!isNonEmptyString(email)) return "";
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  const mode = hasOwnProp(options, "mode") ? options.mode : "fixed";
-  if (mode !== "random" && mode !== "fixed") {
-    throw new TypeError(
-      `Parameter \`mode\` property of the \`options\` (second parameter) must be one of "fixed" or "random", but received: \`${getPreciseType(
-        mode
-      )}\`, with value: \`${safeStableStringify(mode, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-  if (!emailRegex.test(email)) return "";
-  const [local, domain] = email.split("@");
-  const domainParts = domain.split(".");
-  if (domainParts.length < 2) return "";
-  const [domainName, ...tldParts] = domainParts;
-  const tld = tldParts.join(".");
-  const hashSeed = hashSeedGenerate(mode, email);
-  const localMinCensor = local.length < 4 ? 1 : 2;
-  const domainMinCensor = domainName.length < 4 ? 1 : 2;
-  const censoredLocal = _censor(local, localMinCensor, 0.6, hashSeed);
-  const censoredDomain = _censor(domainName, domainMinCensor, 0.5, hashSeed);
-  const censoredTLD = tld.length <= 2 ? tld : _censor(tld, 1, 0.4, hashSeed);
-  return `${censoredLocal}@${censoredDomain}.${censoredTLD}`;
-};
-
-function chunkString(subject, limiter, options = {}) {
-  if (isNil(subject) || limiter <= 0) return subject;
-  assertIsString(subject, {
-    message: ({ currentType, validType }) => `First parameter (\`subject\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  if (!isInteger(limiter)) {
-    throw new TypeError(
-      `Second parameter (\`limiter\`) must be of type \`integer-number\`, but received: \`${getPreciseType(
-        limiter
-      )}\`, with value: \`${safeStableStringify(limiter, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType }) => `Third parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  const separator = hasOwnProp(options, "separator") ? options.separator : " ";
-  const reCountAfterSpace = hasOwnProp(options, "reCountAfterSpace") ? options.reCountAfterSpace : false;
-  assertIsString(separator, {
-    message: ({ currentType, validType }) => `Parameter \`separator\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  assertIsBoolean(reCountAfterSpace, {
-    message: ({ currentType, validType }) => `Parameter \`reCountAfterSpace\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  subject = normalizeSpaces(subject);
-  if (!reCountAfterSpace) {
-    let result = "";
-    let currentCount = 0;
-    for (let i = 0; i < subject.length; i++) {
-      const char = subject[i];
-      if (currentCount === limiter) {
-        result += separator;
-        currentCount = 0;
-      }
-      result += char;
-      currentCount++;
-    }
-    return result;
-  }
-  const words = subject.split(" ");
-  const finalSegments = [];
-  let currentGroup = [];
-  let wordsInCurrentGroupCount = 0;
-  for (let i = 0; i < words.length; i++) {
-    const word = words[i];
-    let processedWord = "";
-    let charCountInWord = 0;
-    for (let j = 0; j < word.length; j++) {
-      processedWord += word[j];
-      charCountInWord++;
-      if (charCountInWord === limiter && j < word.length - 1) {
-        processedWord += separator;
-        charCountInWord = 0;
-      }
-    }
-    currentGroup.push(processedWord);
-    wordsInCurrentGroupCount++;
-    if (wordsInCurrentGroupCount === limiter || i === words.length - 1) {
-      finalSegments.push(currentGroup.join(separator));
-      currentGroup = [];
-      wordsInCurrentGroupCount = 0;
-    }
-  }
-  return finalSegments.join(" ");
-}
-
-var truncateString = (text, options = {}) => {
-  if (!isNonEmptyString(text)) return "";
-  assertIsPlainObject(options, {
-    message: ({ currentType, validType }) => `Seconds parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  const trim = hasOwnProp(options, "trim") ? options.trim : true;
-  const length2 = hasOwnProp(options, "length") ? options.length : 10;
-  let ending = hasOwnProp(options, "ending") ? options.ending : "...";
-  if (!isInteger(length2)) {
-    throw new TypeError(
-      `Parameter \`length\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${getPreciseType(
-        length2
-      )}\`, with value: \`${safeStableStringify(length2, {
-        keepUndefined: true
-      })}\`.`
-    );
-  }
-  if (length2 < 1) return "";
-  assertIsString(ending, {
-    message: ({ currentType, validType }) => `Parameter \`ending\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  assertIsBoolean(trim, {
-    message: ({ currentType, validType }) => `Parameter \`trim\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
-  });
-  if (isEmptyString(ending)) {
-    ending = "...";
-  } else {
-    ending = ending.trim();
-  }
-  const original = trim ? text.trim() : text;
-  const originalTrimmedLength = original.length;
-  if (originalTrimmedLength <= length2) return original;
-  const sliced = original.slice(0, length2);
-  const cleanSliced = trim ? sliced : sliced.trimEnd();
-  return cleanSliced + ending;
-};
-var formatDateFns = (date, options = {}) => {
-  if (isNil(date) || !(isDate(date) || isNonEmptyString(date))) return null;
-  if (!isPlainObject(options)) {
-    options = {};
-  }
-  const { inputFormat, locale = "en", inputLocale = "en", ...restOptions } = options;
-  const format$1 = hasOwnProp(options, "format") && isNonEmptyString(options.format) ? options.format : "dd MMM yyyy - HH:mm:ss";
-  let parsedDate;
-  try {
-    if (isNonEmptyString(date) && inputFormat && inputLocale) {
-      const valueOfInputLocale = isNonEmptyString(inputLocale) ? inputLocale === "id" ? id : enUS : inputLocale;
-      parsedDate = parse(date, inputFormat, /* @__PURE__ */ new Date(), {
-        locale: valueOfInputLocale
-      });
-    } else {
-      parsedDate = new Date(date);
-    }
-    if (isNaN(parsedDate.getTime())) return null;
-    const valueOfLocale = isNonEmptyString(locale) ? locale === "id" ? id : enUS : locale;
-    return format(parsedDate, format$1, {
-      ...restOptions,
-      locale: valueOfLocale
-    });
-  } catch {
-    return null;
-  }
-};
-
-var formatDateIntl = (date, options) => {
-  if (isNil(date) || !(isDate(date) || isNonEmptyString(date))) return null;
-  const parsedDate = new Date(date);
-  if (isNaN(parsedDate.getTime())) return null;
-  if (!isPlainObject(options)) {
-    options = {};
-  }
-  const { locale = "en-US", ...restProps } = options;
-  try {
-    return new Intl.DateTimeFormat(
-      isNonEmptyString(locale) ? locale.trim() : "en-US",
-      restProps
-    ).format(parsedDate);
-  } catch {
-    return null;
-  }
-};
-
-var formatDateTime = (date, format) => {
-  if (isNil(format)) {
-    format = "YYYY-MM-DD hh:mm:ss";
-  }
-  if (!isString(format)) return null;
-  if (isNil(date) || !(isDate(date) || isNonEmptyString(date))) {
-    return null;
-  }
-  try {
-    const parsedDate = new Date(date);
-    if (isNaN(parsedDate.getTime())) return null;
-    const pad2 = (n) => n.toString().padStart(2, "0");
-    const map = {
-      YYYY: parsedDate.getFullYear().toString(),
-      MM: pad2(parsedDate.getMonth() + 1),
-      DD: pad2(parsedDate.getDate()),
-      hh: pad2(parsedDate.getHours()),
-      mm: pad2(parsedDate.getMinutes()),
-      ss: pad2(parsedDate.getSeconds())
-    };
-    const result = Object.entries(map).reduce(
-      (prev, [key, value]) => prev.split(key).join(value),
-      format
-    );
-    return !result.includes("NaN") ? result : null;
-  } catch {
-    return null;
-  }
-};
-
-var getGMTOffset = (date) => {
-  try {
-    if (isNil(date) || isString(date) && isEmptyString(date)) {
-      date = /* @__PURE__ */ new Date();
-    } else if (!(isDate(date) || isNonEmptyString(date))) {
-      return "0";
-    }
-    const parsedDate = new Date(date);
-    if (isNaN(parsedDate.getTime())) return "0";
-    const padZero = (num) => num.toString().padStart(2, "0");
-    let offset = parsedDate.getTimezoneOffset();
-    const sign = offset < 0 ? "+" : "-";
-    offset = Math.abs(offset);
-    return `${sign}${padZero(Math.floor(offset / 60))}${padZero(offset % 60)}`;
-  } catch {
-    return "0";
-  }
-};
-
-export { censorEmail, chunkString, formatCurrency, formatDateFns, formatDateIntl, formatDateTime, formatNumber, formatPhoneNumber, getGMTOffset, truncateString };

package/dist/chunk-GIKL4PUF.cjs

@@ -1,106 +0,0 @@
-/*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.11.1.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-'use strict';
-
-var chunkDAPAK2W3_cjs = require('./chunk-DAPAK2W3.cjs');
-var chunkSYHPSOUU_cjs = require('./chunk-SYHPSOUU.cjs');
-
-var isRegExp = (value) => {
-  return value instanceof RegExp;
-};
-
-function isArrayBuffer(value) {
-  return value instanceof ArrayBuffer;
-}
-
-function baseDeepEqual(value, other, customizer, seen = /* @__PURE__ */ new WeakMap()) {
-  if (value === other) return true;
-  if (value !== value && other !== other) return true;
-  if (!chunkSYHPSOUU_cjs.isObjectOrArray(value) || !chunkSYHPSOUU_cjs.isObjectOrArray(other)) {
-    return false;
-  }
-  if (seen.get(value) === other) return true;
-  seen.set(value, other);
-  const callCustomizer = (v, o, key, valObj, othObj) => {
-    if (customizer) {
-      const result = customizer(v, o, key, valObj, othObj, seen);
-      if (!chunkSYHPSOUU_cjs.isUndefined(result)) return result;
-    }
-    return baseDeepEqual(v, o, customizer, seen);
-  };
-  if (chunkDAPAK2W3_cjs.isDate(value) && chunkDAPAK2W3_cjs.isDate(other)) return value.getTime() === other.getTime();
-  if (isRegExp(value) && isRegExp(other))
-    return value.source === other.source && value.flags === other.flags;
-  if (chunkSYHPSOUU_cjs.isError(value) && chunkSYHPSOUU_cjs.isError(other))
-    return value.name === other.name && value.message === other.message;
-  if (ArrayBuffer.isView(value) && ArrayBuffer.isView(other)) {
-    const v = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    const o = new Uint8Array(other.buffer, other.byteOffset, other.byteLength);
-    if (v.length !== o.length) return false;
-    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;
-    return true;
-  }
-  if (isArrayBuffer(value) && isArrayBuffer(other)) {
-    if (value.byteLength !== other.byteLength) return false;
-    const v = new Uint8Array(value), o = new Uint8Array(other);
-    for (let i = 0; i < v.length; i++) if (v[i] !== o[i]) return false;
-    return true;
-  }
-  if (chunkDAPAK2W3_cjs.isMap(value) && chunkDAPAK2W3_cjs.isMap(other)) {
-    if (value.size !== other.size) return false;
-    for (const [k, v] of value) {
-      if (!other.has(k)) return false;
-      if (!baseDeepEqual(v, other.get(k), customizer, seen)) return false;
-    }
-    return true;
-  }
-  if (chunkSYHPSOUU_cjs.isSet(value) && chunkSYHPSOUU_cjs.isSet(other)) {
-    if (value.size !== other.size) return false;
-    for (const v of value) {
-      let matched = false;
-      for (const o of other) {
-        if (baseDeepEqual(v, o, customizer, seen)) {
-          matched = true;
-          break;
-        }
-      }
-      if (!matched) return false;
-    }
-    return true;
-  }
-  if (chunkSYHPSOUU_cjs.isArray(value) && chunkSYHPSOUU_cjs.isArray(other)) {
-    if (value.length !== other.length) return false;
-    for (let i = 0; i < value.length; i++) {
-      if (!callCustomizer(value[i], other[i], i, value, other)) return false;
-    }
-    return true;
-  }
-  if (Object.getPrototypeOf(value) !== Object.getPrototypeOf(other)) {
-    return false;
-  }
-  const vKeys = Reflect.ownKeys(value);
-  const oKeys = Reflect.ownKeys(other);
-  if (vKeys.length !== oKeys.length) return false;
-  for (const key of vKeys) {
-    const vVal = value[key];
-    const oVal = other[key];
-    if (!callCustomizer(vVal, oVal, key, value, other)) return false;
-  }
-  return true;
-}
-
-function isEqual(value, other) {
-  return baseDeepEqual(value, other, void 0, /* @__PURE__ */ new WeakMap());
-}
-
-exports.baseDeepEqual = baseDeepEqual;
-exports.isArrayBuffer = isArrayBuffer;
-exports.isEqual = isEqual;
-exports.isRegExp = isRegExp;