@rzl-zone/utils-js 3.3.1 → 3.5.0

package/dist/chunk-YKPSRP5G.js

@@ -1 +1,552 @@
-import{normalizeSpaces as e}from"./chunk-T2T7K3KR.js";import{parseCurrencyString as t}from"./chunk-IRFL4MAX.js";import{isFinite as r}from"./chunk-3IBQ5MOM.js";import{isInteger as o}from"./chunk-WVSPXFTY.js";import{isEmptyString as n}from"./chunk-W2WNBUDE.js";import{assertIsString as a}from"./chunk-SBKGWRS5.js";import{safeStableStringify as i,isDate as s}from"./chunk-PET42Z7W.js";import{isString as u,getPreciseType as p,assertIsPlainObject as l,hasOwnProp as m,isBoolean as c,isPlainObject as d,isNaN as f,isUndefined as y,isFunction as h,assertIsBoolean as b,isNil as g,isNumber as $,isNonEmptyString as v}from"./chunk-CMW2TBOQ.js";import{isSupportedCountry as T,AsYouType as w}from"libphonenumber-js/max";import{id as N,enUS as C}from"date-fns/locale";import{parse as D,format as E}from"date-fns";var k=(e,n={})=>{if(!u(e)&&!r(e))throw new TypeError(`First parameter (\`value\`) must be of type \`string\` or \`primitive-number\`, but received: \`${p(e)}\`, with value: \`${i(e)}\`.`);l(n,{message:({currentType:e,validType:t})=>`Second parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const s=!!m(n,"decimal")&&n.decimal,g=m(n,"totalDecimal")?n.totalDecimal:2,$=!m(n,"endDecimal")||n.endDecimal,v=!!m(n,"indianFormat")&&n.indianFormat,T=m(n,"suffixCurrency")?n.suffixCurrency:"",w=m(n,"suffixDecimal")?n.suffixDecimal:"",N=m(n,"roundedDecimal")?n.roundedDecimal:"round",C=m(n,"negativeFormat")?n.negativeFormat:"dash";let D=m(n,"separatorDecimals")?n.separatorDecimals:",",E=m(n,"separator")?n.separator:".";if(!(u(E)&&u(D)&&u(T)&&u(w)))throw new TypeError(`Parameter \`separator\`, \`separatorDecimals\`, \`suffixCurrency\` and \`suffixDecimal\` property of the \`options\` (second parameter) must be of type \`string\`, but received: ['separator': \`${p(E)}\`, 'separatorDecimals': \`${p(D)}\`, 'suffixCurrency': \`${p(T)}\`, 'suffixDecimal': \`${p(w)}\`].`);if(!c(s)||!c($)||!c(v))throw new TypeError(`Parameter \`decimal\`, \`endDecimal\` and \`indianFormat\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['decimal': \`${p(s)}\`, 'endDecimal': \`${p($)}\`, 'indianFormat': \`${p(v)}\`].`);if(!o(g))throw new TypeError(`Parameter \`totalDecimal\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${p(g)}\`, with value: \`${i(length)}\`.`);if(!1!==N&&"round"!==N&&"ceil"!==N&&"floor"!==N)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: \`${p(N)}\`, with value: \`${i(N)}\`.`);if("abs"!==C&&"brackets"!==C&&"dash"!==C&&!d(C))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: \`${p(C)}\`, with value: \`${i(C)}\`.`);const k=u(e)?t(e):e;if(f(k))throw new TypeError("First parameter (`value`) could not be parsed into a valid `number`.");let F="",S="",O=Math.abs(k);const M=Math.pow(10,g);if(N){const e=O*M;switch(N){case"round":O=Math.round(e)/M;break;case"ceil":O=Math.ceil(e)/M;break;case"floor":O=Math.floor(e)/M}}if(N)[F,S]=O.toFixed(g).split("."),S=S??"".padEnd(g,"0");else{const e=String(O).split(".");F=e[0],S=(e[1]||"").slice(0,g).padEnd(g,"0")}let P;if(v?(E=",",D=".",P=(T.trim().length?T:"")+((e,t)=>{const r=e.slice(-3),o=e.slice(0,-3);return o?o.replace(/\B(?=(\d{2})+(?!\d))/g,t)+t+r:r})(F,E)):P=(T.trim().length?T:"")+F.replace(/\B(?=(\d{3})+(?!\d))/g,E),s&&!y(S)&&g>0){let e=D+S;$&&(e+=w),P+=e}if(k<0)if("dash"===C)P="-"+P;else if("brackets"===C)P="("+P+")";else if("abs"===C);else if(d(C))if(m(C,"custom")){const e=C.custom;if(!h(e))throw new TypeError(`Parameter \`negativeFormat.custom\` property of the \`options\` (second parameter) must be of type function: \`(formatted: string) => string\`, but received: \`${p(e)}\`.`);const t=e(P);a(t,{message:({currentType:e,validType:t})=>`Parameter \`negativeFormat.custom\` property of the \`options\` (second parameter) expected return a \`${t}\` type value, but received: \`${e}\`.`}),P=t}else{const e=C.style||"dash",t=!y(C.space)&&C.space;if(b(t,{message:({currentType:e,validType:t})=>`Parameter \`negativeFormat.space\` property of the \`options\` (second parameter) must be of type \`${t} or undefined\`, but received: \`${e}\`.`}),"abs"!==e&&"brackets"!==e&&"dash"!==e)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: \`${p(e)}\`, with value: \`${i(e)}\`.`);switch(e){case"dash":P="-"+(t?" ":"")+P;break;case"brackets":P=t?`( ${P} )`:`(${P})`}}return P},F=(e,t=",")=>{if(!u(e)&&!r(e))throw new TypeError(`First parameter (\`value\`) must be of type \`string\` or \`primitive number\`, but received: \`${p(e)}\`.`);if(!u(t))throw new TypeError(`Second parameter (\`separator\`) must be of type \`string\` or empty as \`undefined\`, but received: \`${p(t)}\`.`);const o="."===(t=u(t)?t:",")?",":".",n=e.toString().trim(),a=n.lastIndexOf("."),i=n.lastIndexOf(",");let s="";a>i?s=".":i>a&&(s=",");let l=n,m="";if(s){const e=n.split(s);l=e.slice(0,-1).join(s),m=e.slice(-1)[0]}l=l.replace(/[^\d]/g,"");const c=l.replace(/\B(?=(\d{3})+(?!\d))/g,t);return m?`${c}${o}${m}`:c};function S(e,t={}){if(g(e))return"";if(!u(e)&&!$(e))throw new TypeError(`First parameter (\`value\`) must be of type \`string\`, \`number\`, \`null\` or \`undefined\`, but received: \`${p(e)}\`.`);l(t,{message:({currentType:e,validType:t})=>`Second parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const r=!!m(t,"takeNumberOnly")&&t.takeNumberOnly,o=!!m(t,"checkValidOnly")&&t.checkValidOnly,n=m(t,"defaultCountry")?t.defaultCountry:void 0,a=m(t,"separator")?t.separator:" ",s=!m(t,"prependPlusCountryCode")||t.prependPlusCountryCode,d=m(t,"outputFormat")?t.outputFormat:"INTERNATIONAL",f=m(t,"openingNumberCountry")?t.openingNumberCountry:"",h=m(t,"closingNumberCountry")?t.closingNumberCountry:"";if(!c(r)||!c(o)||!c(s))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': \`${p(r)}\`, 'checkValidOnly': \`${p(o)}\`, 'prependPlusCountryCode': \`${p(s)}\`].`);if(!y(n)&&!T(n))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: \`${p(n)}\`, with value: \`${i(n,{keepUndefined:!0})}\`.\n\nSee: 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(d))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: \`${p(d)}\`, with value: ${i(d,{keepUndefined:!0})}.`);if(!u(a)||!u(f)||!u(h))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': \`${p(a)}\`,'openingNumberCountry': \`${p(f)}\`, 'closingNumberCountry': \`${p(h)}\`].`);u(e)||(e=String(e));const b=((e,t)=>{let r;try{return r=new w(t),r.input(e),r}catch{return void r?.reset()}})(e,n),N=(C=b,!!C?.isValid()&&!!C.getNumber());var C;if(o)return N;if(!N)return"";if(r)return b.getNumber().formatNational().replace(/\D/g,"");const D=b.getNumber().format(d);if("INTERNATIONAL"===d){const[e,...t]=D.split(" "),r=s?e:e.replace(/^\++/,""),o=t.join(a);return v(f)&&v(h)?`${f}${r}${h} ${o}`:`${r} ${o}`}if("NATIONAL"===d){return`${D.split(" ").join(a)}`}return D}var O=(e,t,r,o)=>{if(e.length<=t)return"*".repeat(e.length);const n=e.split(""),a=Math.max(t,Math.ceil(e.length*r)),i=new Set;let s=0;for(;i.size<a;){const t=y(o)?Math.floor(Math.random()*e.length):(o+e.length+31*s)%e.length;i.add(t),s++}for(const e of i)n[e]="*";return n.join("")},M=(e,t={})=>{if(!v(e))return"";l(t,{message:({currentType:e,validType:t})=>`Second parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const r=m(t,"mode")?t.mode:"fixed";if("random"!==r&&"fixed"!==r)throw new TypeError(`Parameter \`mode\` property of the \`options\` (second parameter) must be one of "fixed" or "random", but received: \`${p(r)}\`, with value: \`${i(r)}\`.`);if(!/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(e))return"";const[o,n]=e.split("@"),a=n.split(".");if(a.length<2)return"";const[s,...u]=a,c=u.join("."),d=((e,t)=>"fixed"===e?(()=>{let e=0;for(let r=0;r<t.length;r++)e=(e<<5)-e+t.charCodeAt(r),e|=0;return Math.abs(e)})():void 0)(r,e),f=o.length<4?1:2,y=s.length<4?1:2;return`${O(o,f,.6,d)}@${O(s,y,.5,d)}.${c.length<=2?c:O(c,1,.4,d)}`};function P(t,r,n={}){if(g(t)||r<=0)return t;if(a(t,{message:({currentType:e,validType:t})=>`First parameter (\`subject\`) must be of type \`${t}\`, but received: \`${e}\`.`}),!o(r))throw new TypeError(`Second parameter (\`limiter\`) must be of type \`integer-number\`, but received: \`${p(r)}\`, with value: \`${i(r)}\`.`);l(n,{message:({currentType:e,validType:t})=>`Third parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const s=m(n,"separator")?n.separator:" ",u=!!m(n,"reCountAfterSpace")&&n.reCountAfterSpace;if(a(s,{message:({currentType:e,validType:t})=>`Parameter \`separator\` property of the \`options\` (third parameter) must be of type \`${t}\`, but received: \`${e}\`.`}),b(u,{message:({currentType:e,validType:t})=>`Parameter \`reCountAfterSpace\` property of the \`options\` (third parameter) must be of type \`${t}\`, but received: \`${e}\`.`}),t=e(t),!u){let e="",o=0;for(let n=0;n<t.length;n++){o===r&&(e+=s,o=0),e+=t[n],o++}return e}const c=t.split(" "),d=[];let f=[],y=0;for(let e=0;e<c.length;e++){const t=c[e];let o="",n=0;for(let e=0;e<t.length;e++)o+=t[e],n++,n===r&&e<t.length-1&&(o+=s,n=0);f.push(o),y++,y!==r&&e!==c.length-1||(d.push(f.join(s)),f=[],y=0)}return d.join(" ")}var A=(e,t={})=>{if(!v(e))return"";l(t,{message:({currentType:e,validType:t})=>`Seconds parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const r=!m(t,"trim")||t.trim,s=m(t,"length")?t.length:10;let u=m(t,"ending")?t.ending:"...";if(!o(s))throw new TypeError(`Parameter \`length\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${p(s)}\`, with value: \`${i(s)}\`.`);if(s<1)return"";a(u,{message:({currentType:e,validType:t})=>`Parameter \`ending\` property of the \`options\` (second parameter) must be of type \`${t}\`, but received: \`${e}\`.`}),b(r,{message:({currentType:e,validType:t})=>`Parameter \`trim\` property of the \`options\` (second parameter) must be of type \`${t}\`, but received: \`${e}\`.`}),u=n(u)?"...":u.trim();const c=r?e.trim():e;if(c.length<=s)return c;const d=c.slice(0,s);return(r?d:d.trimEnd())+u},I=(e,t={})=>{if(g(e)||!s(e)&&!v(e))return null;d(t)||(t={});const{inputFormat:r,locale:o="en",inputLocale:n="en",...a}=t,i=m(t,"format")&&v(t.format)?t.format:"dd MMM yyyy - HH:mm:ss";let u;try{if(v(e)&&r&&n){const t=v(n)?"id"===n?N:C:n;u=D(e,r,new Date,{locale:t})}else u=new Date(e);if(f(u.getTime()))return null;const t=v(o)?"id"===o?N:C:o;return E(u,i,{...a,locale:t})}catch{return null}},j=(e,t)=>{if(g(e)||!s(e)&&!v(e))return null;const r=new Date(e);if(f(r.getTime()))return null;d(t)||(t={});const{locale:o="en-US",...n}=t;try{return new Intl.DateTimeFormat(v(o)?o.trim():"en-US",n).format(r)}catch{return null}},x=(e,t)=>{if(g(t)&&(t="YYYY-MM-DD hh:mm:ss"),!u(t))return null;if(g(e)||!s(e)&&!v(e))return null;try{const r=new Date(e);if(f(r.getTime()))return null;const o=e=>e.toString().padStart(2,"0"),n={YYYY:r.getFullYear().toString(),MM:o(r.getMonth()+1),DD:o(r.getDate()),hh:o(r.getHours()),mm:o(r.getMinutes()),ss:o(r.getSeconds())},a=Object.entries(n).reduce((e,[t,r])=>e.split(t).join(r),t);return a.includes("NaN")?null:a}catch{return null}},L=e=>{try{if(g(e)||u(e)&&n(e))e=new Date;else if(!s(e)&&!v(e))return"0";const t=new Date(e);if(f(t.getTime()))return"0";const r=e=>e.toString().padStart(2,"0");let o=t.getTimezoneOffset();const a=o<0?"+":"-";return o=Math.abs(o),`${a}${r(Math.floor(o/60))}${r(o%60)}`}catch{return"0"}};export{M as censorEmail,P as chunkString,k as formatCurrency,I as formatDateFns,j as formatDateIntl,x as formatDateTime,F as formatNumber,S as formatPhoneNumber,L as getGMTOffset,A as truncateString};
+import { normalizeSpaces } from './chunk-T2T7K3KR.js';
+import { parseCurrencyString } from './chunk-IRFL4MAX.js';
+import { isFinite } from './chunk-3IBQ5MOM.js';
+import { isInteger } from './chunk-WVSPXFTY.js';
+import { isEmptyString } from './chunk-W2WNBUDE.js';
+import { assertIsString } from './chunk-SBKGWRS5.js';
+import { safeStableStringify, isDate } from './chunk-PET42Z7W.js';
+import { isString, getPreciseType, assertIsPlainObject, hasOwnProp, isBoolean, isPlainObject, isNaN, isUndefined, isFunction, assertIsBoolean, isNil, isNumber, isNonEmptyString } from './chunk-CMW2TBOQ.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)}\`.`
+    );
+  }
+  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)}\`.`
+    );
+  }
+  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)}\`.`
+    );
+  }
+  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)}\`.`
+    );
+  }
+  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)}\`.`
+          );
+        }
+        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)}\`.`
+    );
+  }
+  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)}\`.`
+    );
+  }
+  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)}\`.`
+    );
+  }
+  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-YWHHVDT4.js

@@ -1 +1,4 @@
-var r=()=>{};export{r as noop};
+var noop = () => {
+};
+
+export { noop };

package/dist/chunk-ZETAZZLD.cjs

@@ -1 +1,27 @@
-"use strict";var e=require("./chunk-PZQ6I4JJ.cjs");exports.isEmptyArray=t=>!e.isArray(t)||0===t.length,exports.isEmptyObject=function(t,r={}){if(!e.isObject(t))return!0;e.assertIsPlainObject(r,{message:({currentType:e,validType:t})=>`Second parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const s=!!e.hasOwnProp(r,"checkSymbols")&&r.checkSymbols;e.assertIsBoolean(s,{message:({currentType:e,validType:t})=>`Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${t}\`, but received: \`${e}\`.`});const c=0===Object.keys(t).length;return s?c&&0===Object.getOwnPropertySymbols(t).length:c};
+'use strict';
+
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+var isEmptyArray = (value) => {
+  if (!chunkPZQ6I4JJ_cjs.isArray(value)) return true;
+  return value.length === 0;
+};
+function isEmptyObject(value, options = {}) {
+  if (!chunkPZQ6I4JJ_cjs.isObject(value)) {
+    return true;
+  }
+  chunkPZQ6I4JJ_cjs.assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const checkSymbols = chunkPZQ6I4JJ_cjs.hasOwnProp(options, "checkSymbols") ? options.checkSymbols : false;
+  chunkPZQ6I4JJ_cjs.assertIsBoolean(checkSymbols, {
+    message: ({ currentType, validType }) => `Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const hasNoKeys = Object.keys(value).length === 0;
+  if (checkSymbols) {
+    return hasNoKeys && Object.getOwnPropertySymbols(value).length === 0;
+  }
+  return hasNoKeys;
+}
+
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyObject = isEmptyObject;