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

package/dist/formatters-lAYgA11L.cjs

@@ -0,0 +1,427 @@
+/*!
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  Version: `3.12.1-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_assertIsBoolean = require('./assertIsBoolean-DozdtbNi.cjs');
+const require_assertIsString = require('./assertIsString-Bvk7bUL7.cjs');
+const require_isFinite = require('./isFinite-sFkps2TY.cjs');
+const require_safeStableStringify = require('./safeStableStringify-Cc62pfRp.cjs');
+const require_isEmptyString = require('./isEmptyString-CCK3bP74.cjs');
+const require_parsing = require('./parsing-lRoxn1Nz.cjs');
+const require_isInteger = require('./isInteger-FTCthMre.cjs');
+const require_normalizeSpaces = require('./normalizeSpaces-DQHR3Tlr.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_assertIsBoolean.isString(value) && !require_isFinite.isFinite(value)) throw new TypeError(`First parameter (\`value\`) must be of type \`string\` or \`primitive-number\`, but received: \`${require_assertIsBoolean.getPreciseType(value)}\`, with value: \`${require_safeStableStringify.safeStableStringify(value, { keepUndefined: true })}\`.`);
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const decimal = require_assertIsBoolean.hasOwnProp(options, "decimal") ? options.decimal : false;
+	const totalDecimal = require_assertIsBoolean.hasOwnProp(options, "totalDecimal") ? options.totalDecimal : 2;
+	const endDecimal = require_assertIsBoolean.hasOwnProp(options, "endDecimal") ? options.endDecimal : true;
+	const indianFormat = require_assertIsBoolean.hasOwnProp(options, "indianFormat") ? options.indianFormat : false;
+	const suffixCurrency = require_assertIsBoolean.hasOwnProp(options, "suffixCurrency") ? options.suffixCurrency : "";
+	const suffixDecimal = require_assertIsBoolean.hasOwnProp(options, "suffixDecimal") ? options.suffixDecimal : "";
+	const roundedDecimal = require_assertIsBoolean.hasOwnProp(options, "roundedDecimal") ? options.roundedDecimal : "round";
+	const negativeFormat = require_assertIsBoolean.hasOwnProp(options, "negativeFormat") ? options.negativeFormat : "dash";
+	let separatorDecimals = require_assertIsBoolean.hasOwnProp(options, "separatorDecimals") ? options.separatorDecimals : ",";
+	let separator = require_assertIsBoolean.hasOwnProp(options, "separator") ? options.separator : ".";
+	if (!require_assertIsBoolean.isString(separator) || !require_assertIsBoolean.isString(separatorDecimals) || !require_assertIsBoolean.isString(suffixCurrency) || !require_assertIsBoolean.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': \`${require_assertIsBoolean.getPreciseType(separator)}\`, 'separatorDecimals': \`${require_assertIsBoolean.getPreciseType(separatorDecimals)}\`, 'suffixCurrency': \`${require_assertIsBoolean.getPreciseType(suffixCurrency)}\`, 'suffixDecimal': \`${require_assertIsBoolean.getPreciseType(suffixDecimal)}\`].`);
+	if (!require_assertIsBoolean.isBoolean(decimal) || !require_assertIsBoolean.isBoolean(endDecimal) || !require_assertIsBoolean.isBoolean(indianFormat)) throw new TypeError(`Parameter \`decimal\`, \`endDecimal\` and \`indianFormat\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: ['decimal': \`${require_assertIsBoolean.getPreciseType(decimal)}\`, 'endDecimal': \`${require_assertIsBoolean.getPreciseType(endDecimal)}\`, 'indianFormat': \`${require_assertIsBoolean.getPreciseType(indianFormat)}\`].`);
+	if (!require_isInteger.isInteger(totalDecimal)) throw new TypeError(`Parameter \`totalDecimal\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${require_assertIsBoolean.getPreciseType(totalDecimal)}\`, with value: \`${require_safeStableStringify.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: \`${require_assertIsBoolean.getPreciseType(roundedDecimal)}\`, with value: \`${require_safeStableStringify.safeStableStringify(roundedDecimal, { keepUndefined: true })}\`.`);
+	if (!(negativeFormat === "abs" || negativeFormat === "brackets" || negativeFormat === "dash" || require_assertIsBoolean.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: \`${require_assertIsBoolean.getPreciseType(negativeFormat)}\`, with value: \`${require_safeStableStringify.safeStableStringify(negativeFormat, { keepUndefined: true })}\`.`);
+	const rawNum = require_assertIsBoolean.isString(value) ? require_parsing.parseCurrencyString(value) : value;
+	if (require_assertIsBoolean.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_assertIsBoolean.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_assertIsBoolean.isPlainObject(negativeFormat)) if (require_assertIsBoolean.hasOwnProp(negativeFormat, "custom")) {
+			const formatCustomNegative = negativeFormat.custom;
+			if (!require_assertIsBoolean.isFunction(formatCustomNegative)) throw new TypeError(`Parameter \`negativeFormat.custom\` property of the \`options\` (second parameter) must be of type function: \`(formatted: string) => string\`, but received: \`${require_assertIsBoolean.getPreciseType(formatCustomNegative)}\`.`);
+			const result = formatCustomNegative(formattedInteger);
+			require_assertIsString.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 = !require_assertIsBoolean.isUndefined(negativeFormat.space) ? negativeFormat.space : false;
+			require_assertIsBoolean.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: \`${require_assertIsBoolean.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 formatNumber = (value, separator = ",") => {
+	if (!require_assertIsBoolean.isString(value) && !require_isFinite.isFinite(value)) throw new TypeError(`First parameter (\`value\`) must be of type \`string\` or \`primitive number\`, but received: \`${require_assertIsBoolean.getPreciseType(value)}\`.`);
+	if (!require_assertIsBoolean.isString(separator)) throw new TypeError(`Second parameter (\`separator\`) must be of type \`string\` or empty as \`undefined\`, but received: \`${require_assertIsBoolean.getPreciseType(separator)}\`.`);
+	separator = require_assertIsBoolean.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 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_assertIsBoolean.isNil(value)) return "";
+	if (!require_assertIsBoolean.isString(value) && !require_assertIsBoolean.isNumber(value)) throw new TypeError(`First parameter (\`value\`) must be of type \`string\`, \`number\`, \`null\` or \`undefined\`, but received: \`${require_assertIsBoolean.getPreciseType(value)}\`.`);
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const takeNumberOnly = require_assertIsBoolean.hasOwnProp(options, "takeNumberOnly") ? options.takeNumberOnly : false;
+	const checkValidOnly = require_assertIsBoolean.hasOwnProp(options, "checkValidOnly") ? options.checkValidOnly : false;
+	const defaultCountry = require_assertIsBoolean.hasOwnProp(options, "defaultCountry") ? options.defaultCountry : void 0;
+	const separator = require_assertIsBoolean.hasOwnProp(options, "separator") ? options.separator : " ";
+	const prependPlusCountryCode = require_assertIsBoolean.hasOwnProp(options, "prependPlusCountryCode") ? options.prependPlusCountryCode : true;
+	const outputFormat = require_assertIsBoolean.hasOwnProp(options, "outputFormat") ? options.outputFormat : "INTERNATIONAL";
+	const openingNumberCountry = require_assertIsBoolean.hasOwnProp(options, "openingNumberCountry") ? options.openingNumberCountry : "";
+	const closingNumberCountry = require_assertIsBoolean.hasOwnProp(options, "closingNumberCountry") ? options.closingNumberCountry : "";
+	if (!require_assertIsBoolean.isBoolean(takeNumberOnly) || !require_assertIsBoolean.isBoolean(checkValidOnly) || !require_assertIsBoolean.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': \`${require_assertIsBoolean.getPreciseType(takeNumberOnly)}\`, 'checkValidOnly': \`${require_assertIsBoolean.getPreciseType(checkValidOnly)}\`, 'prependPlusCountryCode': \`${require_assertIsBoolean.getPreciseType(prependPlusCountryCode)}\`].`);
+	if (!require_assertIsBoolean.isUndefined(defaultCountry) && !(0, libphonenumber_js_max.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: \`${require_assertIsBoolean.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(`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_assertIsBoolean.getPreciseType(outputFormat)}\`, with value: ${require_safeStableStringify.safeStableStringify(outputFormat, { keepUndefined: true })}.`);
+	if (!require_assertIsBoolean.isString(separator) || !require_assertIsBoolean.isString(openingNumberCountry) || !require_assertIsBoolean.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': \`${require_assertIsBoolean.getPreciseType(separator)}\`,'openingNumberCountry': \`${require_assertIsBoolean.getPreciseType(openingNumberCountry)}\`, 'closingNumberCountry': \`${require_assertIsBoolean.getPreciseType(closingNumberCountry)}\`].`);
+	if (!require_assertIsBoolean.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 (require_assertIsBoolean.isNonEmptyString(openingNumberCountry) && require_assertIsBoolean.isNonEmptyString(closingNumberCountry)) return `${openingNumberCountry}${countryCode}${closingNumberCountry} ${restWithSeparator}`;
+		return `${countryCode} ${restWithSeparator}`;
+	}
+	if (outputFormat === "NATIONAL") return `${intlNumb.split(" ").join(separator)}`;
+	return intlNumb;
+}
+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_assertIsBoolean.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_assertIsBoolean.isNonEmptyString(email)) return "";
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const mode = require_assertIsBoolean.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: \`${require_assertIsBoolean.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 (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;
+	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_assertIsBoolean.isNil(subject) || limiter <= 0) return subject;
+	require_assertIsString.assertIsString(subject, { message: ({ currentType, validType }) => `First parameter (\`subject\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	if (!require_isInteger.isInteger(limiter)) throw new TypeError(`Second parameter (\`limiter\`) must be of type \`integer-number\`, but received: \`${require_assertIsBoolean.getPreciseType(limiter)}\`, with value: \`${require_safeStableStringify.safeStableStringify(limiter, { keepUndefined: true })}\`.`);
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Third parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const separator = require_assertIsBoolean.hasOwnProp(options, "separator") ? options.separator : " ";
+	const reCountAfterSpace = require_assertIsBoolean.hasOwnProp(options, "reCountAfterSpace") ? options.reCountAfterSpace : false;
+	require_assertIsString.assertIsString(separator, { message: ({ currentType, validType }) => `Parameter \`separator\` property of the \`options\` (third parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	require_assertIsBoolean.assertIsBoolean(reCountAfterSpace, { message: ({ currentType, validType }) => `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;
+		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 truncateString = (text, options = {}) => {
+	if (!require_assertIsBoolean.isNonEmptyString(text)) return "";
+	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Seconds parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	const trim = require_assertIsBoolean.hasOwnProp(options, "trim") ? options.trim : true;
+	const length = require_assertIsBoolean.hasOwnProp(options, "length") ? options.length : 10;
+	let ending = require_assertIsBoolean.hasOwnProp(options, "ending") ? options.ending : "...";
+	if (!require_isInteger.isInteger(length)) throw new TypeError(`Parameter \`length\` property of the \`options\` (second parameter) must be of type \`integer-number\`, but received: \`${require_assertIsBoolean.getPreciseType(length)}\`, with value: \`${require_safeStableStringify.safeStableStringify(length, { keepUndefined: true })}\`.`);
+	if (length < 1) return "";
+	require_assertIsString.assertIsString(ending, { message: ({ currentType, validType }) => `Parameter \`ending\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
+	require_assertIsBoolean.assertIsBoolean(trim, { message: ({ currentType, validType }) => `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 formatDateFns = (date, options = {}) => {
+	if (require_assertIsBoolean.isNil(date) || !(require_safeStableStringify.isDate(date) || require_assertIsBoolean.isNonEmptyString(date))) return null;
+	if (!require_assertIsBoolean.isPlainObject(options)) options = {};
+	const { inputFormat, locale = "en", inputLocale = "en", ...restOptions } = options;
+	const format = require_assertIsBoolean.hasOwnProp(options, "format") && require_assertIsBoolean.isNonEmptyString(options.format) ? options.format : "dd MMM yyyy - HH:mm:ss";
+	let parsedDate;
+	try {
+		if (require_assertIsBoolean.isNonEmptyString(date) && inputFormat && inputLocale) {
+			const valueOfInputLocale = require_assertIsBoolean.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_assertIsBoolean.isNaN(parsedDate.getTime())) return null;
+		const valueOfLocale = require_assertIsBoolean.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_assertIsBoolean.isNil(date) || !(require_safeStableStringify.isDate(date) || require_assertIsBoolean.isNonEmptyString(date))) return null;
+	const parsedDate = new Date(date);
+	if (require_assertIsBoolean.isNaN(parsedDate.getTime())) return null;
+	if (!require_assertIsBoolean.isPlainObject(options)) options = {};
+	const { locale = "en-US", ...restProps } = options;
+	try {
+		return new Intl.DateTimeFormat(require_assertIsBoolean.isNonEmptyString(locale) ? locale.trim() : "en-US", restProps).format(parsedDate);
+	} catch {
+		return null;
+	}
+};
+const formatDateTime = (date, format) => {
+	if (require_assertIsBoolean.isNil(format)) format = "YYYY-MM-DD hh:mm:ss";
+	if (!require_assertIsBoolean.isString(format)) return null;
+	if (require_assertIsBoolean.isNil(date) || !(require_safeStableStringify.isDate(date) || require_assertIsBoolean.isNonEmptyString(date))) return null;
+	try {
+		const parsedDate = new Date(date);
+		if (require_assertIsBoolean.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_assertIsBoolean.isNil(date) || require_assertIsBoolean.isString(date) && require_isEmptyString.isEmptyString(date)) date = /* @__PURE__ */ new Date();
+		else if (!(require_safeStableStringify.isDate(date) || require_assertIsBoolean.isNonEmptyString(date))) return "0";
+		const parsedDate = new Date(date);
+		if (require_assertIsBoolean.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-lAYgA11L.cjs.map