@rzl-zone/utils-js 3.13.1-beta.0 → 3.14.0-beta.0

package/dist/formatters-zd0Gs4Cs.cjs

@@ -0,0 +1,436 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.14.0-beta.0`
+*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
+* ========================================================================
+*/
+"use strict";
+const require_logger = require('./logger-CUacYy3D.cjs');
+const require_isNumber = require('./isNumber-BkzwAe50.cjs');
+const require_assertIsString = require('./assertIsString-CjE9kbQ_.cjs');
+const require_isFinite = require('./isFinite-B_hHbDpa.cjs');
+const require_safeStableStringify = require('./safeStableStringify-C5HHKUdn.cjs');
+const require_isEmptyString = require('./isEmptyString-O4TFe1Ao.cjs');
+const require_parsing = require('./parsing-DGjB8cwr.cjs');
+const require_hasOwnProp = require('./hasOwnProp-D9Tpgokd.cjs');
+const require_isInteger = require('./isInteger-dnc6W63Z.cjs');
+const require_normalizeSpaces = require('./normalizeSpaces-D0_Z4qnO.cjs');
+let libphonenumber_js_max = require("libphonenumber-js/max");
+let date_fns_locale = require("date-fns/locale");
+let date_fns = require("date-fns");
+const 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;
+};
+const formatCurrency = (value, options) => {
+	if (!require_logger.isString(value) && !require_isFinite.isFinite(value)) throw new TypeError(errorMsg$4(`First parameter (\`value\`) must be of type \`string\` or \`primitive-number\`, but received: \`${require_logger.getPreciseType(value)}\`, with value: \`${require_safeStableStringify.safeStableStringify(value, { keepUndefined: true })}\`.`));
+	if (!require_logger.isPlainObject(options)) options = {};
+	const decimal = options.decimal ?? false;
+	const totalDecimal = options.totalDecimal ?? 2;
+	const endDecimal = options.endDecimal ?? true;
+	const indianFormat = options.indianFormat ?? false;
+	const suffixCurrency = options.suffixCurrency ?? "";
+	const suffixDecimal = options.suffixDecimal ?? "";
+	const roundedDecimal = options.roundedDecimal ?? "round";
+	const negativeFormat = options.negativeFormat ?? "dash";
+	let separatorDecimals = options.separatorDecimals ?? ",";
+	let separator = options.separator ?? ".";
+	if (!require_logger.isString(separator) || !require_logger.isString(separatorDecimals) || !require_logger.isString(suffixCurrency) || !require_logger.isString(suffixDecimal)) throw new TypeError(errorMsg$4(`Parameter \`separator\`, \`separatorDecimals\`, \`suffixCurrency\` and \`suffixDecimal\` property of the \`options\` (second parameter) must be of type \`string\`, but received: ['separator': \`${require_logger.getPreciseType(separator)}\`, 'separatorDecimals': \`${require_logger.getPreciseType(separatorDecimals)}\`, 'suffixCurrency': \`${require_logger.getPreciseType(suffixCurrency)}\`, 'suffixDecimal': \`${require_logger.getPreciseType(suffixDecimal)}\`].`));
+	if (!require_logger.isBoolean(decimal) || !require_logger.isBoolean(endDecimal) || !require_logger.isBoolean(indianFormat)) throw new TypeError(errorMsg$4(`Parameter \`decimal\`, \`endDecimal\` and \`indianFormat\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['decimal': \`${require_logger.getPreciseType(decimal)}\`, 'endDecimal': \`${require_logger.getPreciseType(endDecimal)}\`, 'indianFormat': \`${require_logger.getPreciseType(indianFormat)}\`].`));
+	if (!require_isInteger.isInteger(totalDecimal)) throw new TypeError(errorMsg$4(`Parameter \`totalDecimal\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${require_logger.getPreciseType(totalDecimal)}\`, with value: \`${require_safeStableStringify.safeStableStringify(length, { keepUndefined: true })}\`.`));
+	if (!(roundedDecimal === false || roundedDecimal === "round" || roundedDecimal === "ceil" || roundedDecimal === "floor")) throw new TypeError(errorMsg$4(`Parameter \`roundedDecimal\` property of the \`options\` (second parameter) must be of type \`false\` or \`string\` must be one of "round" | "ceil" | "floor", but received: \`${require_logger.getPreciseType(roundedDecimal)}\`, with value: \`${require_safeStableStringify.safeStableStringify(roundedDecimal, { keepUndefined: true })}\`.`));
+	if (!(negativeFormat === "abs" || negativeFormat === "brackets" || negativeFormat === "dash" || require_logger.isPlainObject(negativeFormat))) throw new TypeError(errorMsg$4(`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: \`${require_logger.getPreciseType(negativeFormat)}\`, with value: \`${require_safeStableStringify.safeStableStringify(negativeFormat, { keepUndefined: true })}\`.`));
+	const rawNum = require_logger.isString(value) ? require_parsing.parseCurrencyString(value) : value;
+	if (require_logger.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({
+			numStr: integerPart,
+			separator
+		});
+	} else formattedInteger = (suffixCurrency.trim().length ? suffixCurrency : "") + integerPart?.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+	if (decimal && !require_safeStableStringify.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 (require_logger.isPlainObject(negativeFormat)) if (require_hasOwnProp.hasOwnProp(negativeFormat, "custom")) {
+			const formatCustomNegative = negativeFormat.custom;
+			if (!require_logger.isFunction(formatCustomNegative)) throw new TypeError(errorMsg$4(`Parameter \`negativeFormat.custom\` property of the \`options\` (second parameter) must be of type function: \`(formatted: string) => string\`, but received: \`${require_logger.getPreciseType(formatCustomNegative)}\`.`));
+			const result = formatCustomNegative(formattedInteger);
+			require_assertIsString.assertIsString(result, { message: ({ currentType, validType }) => errorMsg$4(`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 = !require_safeStableStringify.isUndefined(negativeFormat.space) ? negativeFormat.space : false;
+			require_logger.assertIsBoolean(formatSpaceNegative, { message: ({ currentType, validType }) => errorMsg$4(`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(errorMsg$4(`Parameter \`negativeFormat.style\` property of the \`options\` (second parameter) must be of type \`string\` must be of type "abs" | "brackets" | "dash", but received: \`${require_logger.getPreciseType(formatStyleNegative)}\`, with value: \`${require_safeStableStringify.safeStableStringify(formatStyleNegative, { keepUndefined: true })}\`.`));
+			switch (formatStyleNegative) {
+				case "dash":
+					formattedInteger = "-" + (formatSpaceNegative ? " " : "") + formattedInteger;
+					break;
+				case "brackets":
+					formattedInteger = formatSpaceNegative ? `( ${formattedInteger} )` : `(${formattedInteger})`;
+					break;
+				case "abs": break;
+			}
+		}
+	}
+	return formattedInteger;
+};
+const errorMsg$4 = (msg) => require_logger.createMessage("formatCurrency", msg);
+const formatNumber = (value, separator = ",") => {
+	if (!require_logger.isString(value) && !require_isFinite.isFinite(value)) throw new TypeError(errorMsg$3(`First parameter (\`value\`) must be of type \`string\` or \`primitive number\`, but received: \`${require_logger.getPreciseType(value)}\`.`));
+	if (!require_logger.isString(separator)) throw new TypeError(errorMsg$3(`Second parameter (\`separator\`) must be of type \`string\` or empty as \`undefined\`, but received: \`${require_logger.getPreciseType(separator)}\`.`));
+	separator = require_logger.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;
+};
+const errorMsg$3 = (msg) => require_logger.createMessage("formatNumber", msg);
+const parsingAsYouType = (value, defaultCountry) => {
+	let parsed;
+	try {
+		parsed = new libphonenumber_js_max.AsYouType(defaultCountry);
+		parsed.input(value);
+		return parsed;
+	} catch {
+		parsed?.reset();
+		return;
+	}
+};
+const isValidParseAsYouType = (parsedAsYouType) => {
+	return !!parsedAsYouType?.isValid() && !!parsedAsYouType.getNumber();
+};
+function formatPhoneNumber(value, options) {
+	if (require_logger.isNil(value)) return "";
+	if (!require_logger.isString(value) && !require_isNumber.isNumber(value)) throw new TypeError(errorMsg$2(`First parameter (\`value\`) must be of type \`string\`, \`number\`, \`null\` or \`undefined\`, but received: \`${require_logger.getPreciseType(value)}\`.`));
+	if (!require_logger.isPlainObject(options)) options = {};
+	const takeNumberOnly = options.takeNumberOnly ?? false;
+	const checkValidOnly = options.checkValidOnly ?? false;
+	const defaultCountry = options.defaultCountry ?? void 0;
+	const separator = options.separator ?? " ";
+	const prependPlusCountryCode = options.prependPlusCountryCode ?? true;
+	const outputFormat = options.outputFormat ?? "INTERNATIONAL";
+	const openingNumberCountry = options.openingNumberCountry ?? "";
+	const closingNumberCountry = options.closingNumberCountry ?? "";
+	if (!require_logger.isBoolean(takeNumberOnly) || !require_logger.isBoolean(checkValidOnly) || !require_logger.isBoolean(prependPlusCountryCode)) throw new TypeError(errorMsg$2(`Parameter \`takeNumberOnly\`, \`checkValidOnly\` and \`prependPlusCountryCode\` property of the \`options\` (second parameter) must be of type \`boolean\` or unset as \`undefined\` value, but received: ['takeNumberOnly': \`${require_logger.getPreciseType(takeNumberOnly)}\`, 'checkValidOnly': \`${require_logger.getPreciseType(checkValidOnly)}\`, 'prependPlusCountryCode': \`${require_logger.getPreciseType(prependPlusCountryCode)}\`].`));
+	if (!require_safeStableStringify.isUndefined(defaultCountry) && !(0, libphonenumber_js_max.isSupportedCountry)(defaultCountry)) throw new TypeError(errorMsg$2(`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: \`${require_logger.getPreciseType(defaultCountry)}\`, with value: \`${require_safeStableStringify.safeStableStringify(defaultCountry, { keepUndefined: true })}\`.\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(outputFormat)) throw new TypeError(errorMsg$2(`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: \`${require_logger.getPreciseType(outputFormat)}\`, with value: ${require_safeStableStringify.safeStableStringify(outputFormat, { keepUndefined: true })}.`));
+	if (!require_logger.isString(separator) || !require_logger.isString(openingNumberCountry) || !require_logger.isString(closingNumberCountry)) throw new TypeError(errorMsg$2(`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': \`${require_logger.getPreciseType(separator)}\`,'openingNumberCountry': \`${require_logger.getPreciseType(openingNumberCountry)}\`, 'closingNumberCountry': \`${require_logger.getPreciseType(closingNumberCountry)}\`].`));
+	if (!require_logger.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 intlNumb = parsedPhoneNumber.getNumber().format(outputFormat);
+	if (outputFormat === "INTERNATIONAL") {
+		const [cc, ...rest] = intlNumb.split(" ");
+		const countryCode = prependPlusCountryCode ? cc : cc?.replace(/^\++/, "");
+		const restWithSeparator = rest.join(separator);
+		if (!countryCode) return restWithSeparator;
+		if (require_logger.isNonEmptyString(openingNumberCountry) && require_logger.isNonEmptyString(closingNumberCountry)) return `${openingNumberCountry}${countryCode}${closingNumberCountry} ${restWithSeparator}`;
+		return `${countryCode} ${restWithSeparator}`;
+	}
+	if (outputFormat === "NATIONAL") return `${intlNumb.split(" ").join(separator)}`;
+	return intlNumb;
+}
+const errorMsg$2 = (msg) => require_logger.createMessage("formatPhoneNumber", msg);
+const 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;
+};
+const _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 = !require_safeStableStringify.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("");
+};
+const censorEmail = (email, options) => {
+	if (!require_logger.isNonEmptyString(email)) return "";
+	if (!require_logger.isPlainObject(options)) options = {};
+	const mode = options.mode ?? "fixed";
+	if (mode !== "random" && mode !== "fixed") throw new TypeError(require_logger.createMessage("censorEmail", `Parameter \`mode\` property of the \`options\` (second parameter) must be one of "fixed" or "random", but received: \`${require_logger.getPreciseType(mode)}\`, with value: \`${require_safeStableStringify.safeStableStringify(mode, { keepUndefined: true })}\`.`));
+	if (!/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)) return "";
+	const [local, domain] = email.split("@");
+	const domainParts = domain?.split(".");
+	if (!local || !domainParts || domainParts.length < 2) return "";
+	const [domainName, ...tldParts] = domainParts;
+	if (!domainName) return "";
+	const tld = tldParts.join(".");
+	const hashSeed = hashSeedGenerate(mode, email);
+	const localMinCensor = local.length < 4 ? 1 : 2;
+	const domainMinCensor = domainName.length < 4 ? 1 : 2;
+	return `${_censor(local, localMinCensor, .6, hashSeed)}@${_censor(domainName, domainMinCensor, .5, hashSeed)}.${tld.length <= 2 ? tld : _censor(tld, 1, .4, hashSeed)}`;
+};
+function chunkString(subject, limiter, options) {
+	if (require_logger.isNil(subject) || limiter <= 0) return subject;
+	require_assertIsString.assertIsString(subject, { message: ({ currentType, validType }) => errorMsg$1(`First parameter (\`subject\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	if (!require_isInteger.isInteger(limiter)) throw new TypeError(errorMsg$1(`Second parameter (\`limiter\`) must be of type \`integer-number\`, but received: \`${require_logger.getPreciseType(limiter)}\`, with value: \`${require_safeStableStringify.safeStableStringify(limiter, { keepUndefined: true })}\`.`));
+	if (!require_logger.isPlainObject(options)) options = {};
+	const separator = options.separator ?? " ";
+	const reCountAfterSpace = options.reCountAfterSpace ?? false;
+	require_assertIsString.assertIsString(separator, { message: ({ currentType, validType }) => errorMsg$1(`Parameter \`separator\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	require_logger.assertIsBoolean(reCountAfterSpace, { message: ({ currentType, validType }) => errorMsg$1(`Parameter \`reCountAfterSpace\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	subject = require_normalizeSpaces.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;
+		if (word) 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(" ");
+}
+const errorMsg$1 = (msg) => require_logger.createMessage("chunkString", msg);
+const truncateString = (text, options) => {
+	if (!require_logger.isNonEmptyString(text)) return "";
+	if (!require_logger.isPlainObject(options)) options = {};
+	const trim = options.trim ?? true;
+	const length = options.length ?? 10;
+	let ending = options.ending ?? "...";
+	if (!require_isInteger.isInteger(length)) throw new TypeError(errorMsg(`Parameter \`length\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${require_logger.getPreciseType(length)}\`, with value: \`${require_safeStableStringify.safeStableStringify(length, { keepUndefined: true })}\`.`));
+	if (length < 1) return "";
+	require_assertIsString.assertIsString(ending, { message: ({ currentType, validType }) => errorMsg(`Parameter \`ending\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	require_logger.assertIsBoolean(trim, { message: ({ currentType, validType }) => errorMsg(`Parameter \`trim\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`) });
+	if (require_isEmptyString.isEmptyString(ending)) ending = "...";
+	else ending = ending.trim();
+	const original = trim ? text.trim() : text;
+	if (original.length <= length) return original;
+	const sliced = original.slice(0, length);
+	return (trim ? sliced : sliced.trimEnd()) + ending;
+};
+const errorMsg = (msg) => require_logger.createMessage("truncateString", msg);
+const formatDateFns = (date, options = {}) => {
+	if (require_logger.isNil(date) || !(require_safeStableStringify.isDate(date) || require_logger.isNonEmptyString(date))) return null;
+	if (!require_logger.isPlainObject(options)) options = {};
+	const { inputFormat, locale = "en", inputLocale = "en", ...restOptions } = options;
+	const format = options.format ?? "dd MMM yyyy - HH:mm:ss";
+	let parsedDate;
+	try {
+		if (require_logger.isNonEmptyString(date) && inputFormat && inputLocale) {
+			const valueOfInputLocale = require_logger.isNonEmptyString(inputLocale) ? inputLocale === "id" ? date_fns_locale.id : date_fns_locale.enUS : inputLocale;
+			parsedDate = (0, date_fns.parse)(date, inputFormat, /* @__PURE__ */ new Date(), { locale: valueOfInputLocale });
+		} else parsedDate = new Date(date);
+		if (require_logger.isNaN(parsedDate.getTime())) return null;
+		const valueOfLocale = require_logger.isNonEmptyString(locale) ? locale === "id" ? date_fns_locale.id : date_fns_locale.enUS : locale;
+		return (0, date_fns.format)(parsedDate, format, {
+			...restOptions,
+			locale: valueOfLocale
+		});
+	} catch {
+		return null;
+	}
+};
+const formatDateIntl = (date, options) => {
+	if (require_logger.isNil(date) || !(require_safeStableStringify.isDate(date) || require_logger.isNonEmptyString(date))) return null;
+	const parsedDate = new Date(date);
+	if (require_logger.isNaN(parsedDate.getTime())) return null;
+	if (!require_logger.isPlainObject(options)) options = {};
+	const { locale = "en-US", ...restProps } = options;
+	try {
+		return new Intl.DateTimeFormat(require_logger.isNonEmptyString(locale) ? locale.trim() : "en-US", restProps).format(parsedDate);
+	} catch {
+		return null;
+	}
+};
+const formatDateTime = (date, format = "YYYY-MM-DD hh:mm:ss") => {
+	if (require_logger.isNil(format)) format = "YYYY-MM-DD hh:mm:ss";
+	if (!require_logger.isString(format)) return null;
+	if (require_logger.isNil(date) || !(require_safeStableStringify.isDate(date) || require_logger.isNonEmptyString(date))) return null;
+	try {
+		const parsedDate = new Date(date);
+		if (require_logger.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;
+	}
+};
+const getGMTOffset = (date) => {
+	try {
+		if (require_logger.isNil(date) || require_logger.isString(date) && require_isEmptyString.isEmptyString(date)) date = /* @__PURE__ */ new Date();
+		else if (!(require_safeStableStringify.isDate(date) || require_logger.isNonEmptyString(date))) return "0";
+		const parsedDate = new Date(date);
+		if (require_logger.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";
+	}
+};
+Object.defineProperty(exports, 'censorEmail', {
+  enumerable: true,
+  get: function () {
+    return censorEmail;
+  }
+});
+Object.defineProperty(exports, 'chunkString', {
+  enumerable: true,
+  get: function () {
+    return chunkString;
+  }
+});
+Object.defineProperty(exports, 'formatCurrency', {
+  enumerable: true,
+  get: function () {
+    return formatCurrency;
+  }
+});
+Object.defineProperty(exports, 'formatDateFns', {
+  enumerable: true,
+  get: function () {
+    return formatDateFns;
+  }
+});
+Object.defineProperty(exports, 'formatDateIntl', {
+  enumerable: true,
+  get: function () {
+    return formatDateIntl;
+  }
+});
+Object.defineProperty(exports, 'formatDateTime', {
+  enumerable: true,
+  get: function () {
+    return formatDateTime;
+  }
+});
+Object.defineProperty(exports, 'formatNumber', {
+  enumerable: true,
+  get: function () {
+    return formatNumber;
+  }
+});
+Object.defineProperty(exports, 'formatPhoneNumber', {
+  enumerable: true,
+  get: function () {
+    return formatPhoneNumber;
+  }
+});
+Object.defineProperty(exports, 'getGMTOffset', {
+  enumerable: true,
+  get: function () {
+    return getGMTOffset;
+  }
+});
+Object.defineProperty(exports, 'truncateString', {
+  enumerable: true,
+  get: function () {
+    return truncateString;
+  }
+});
+//# sourceMappingURL=formatters-zd0Gs4Cs.cjs.map