@rzl-zone/utils-js 3.4.0 → 3.5.0

package/dist/chunk-2WA36TC5.cjs

@@ -0,0 +1,176 @@
+'use strict';
+
+var chunk6JFZL7YE_cjs = require('./chunk-6JFZL7YE.cjs');
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+var clsx = require('clsx');
+var tailwindMergeV3 = require('tailwind-merge-v3');
+var tailwindMergeV4 = require('tailwind-merge-v4');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var clsx__default = /*#__PURE__*/_interopDefault(clsx);
+var validatorPropsTwMerge = (options) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(options)) options = {};
+  let { config, prefix, extend, override, cacheSize, experimentalParseClassName } = options;
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(config)) config = {};
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(extend)) extend = {};
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(override)) override = {};
+  if (!chunkPZQ6I4JJ_cjs.isNumber(cacheSize)) cacheSize = void 0;
+  if (!chunkPZQ6I4JJ_cjs.isNonEmptyString(prefix)) prefix = void 0;
+  if (!chunkPZQ6I4JJ_cjs.isFunction(experimentalParseClassName)) experimentalParseClassName = void 0;
+  const theme = chunkPZQ6I4JJ_cjs.hasOwnProp(extend, "theme") ? extend.theme : {};
+  const classGroups = chunkPZQ6I4JJ_cjs.hasOwnProp(extend, "classGroups") ? extend.classGroups : {};
+  const conflictingClassGroupModifiers = chunkPZQ6I4JJ_cjs.hasOwnProp(
+    extend,
+    "conflictingClassGroupModifiers"
+  ) ? extend.conflictingClassGroupModifiers : {};
+  const conflictingClassGroups = chunkPZQ6I4JJ_cjs.hasOwnProp(extend, "conflictingClassGroups") ? extend.conflictingClassGroups : {};
+  const orderSensitiveModifiers = chunkPZQ6I4JJ_cjs.hasOwnProp(extend, "orderSensitiveModifiers") && chunkPZQ6I4JJ_cjs.isNonEmptyArray(extend.orderSensitiveModifiers) ? extend.orderSensitiveModifiers : [];
+  return {
+    config,
+    override,
+    cacheSize,
+    prefix,
+    experimentalParseClassName,
+    theme,
+    classGroups,
+    conflictingClassGroupModifiers,
+    conflictingClassGroups,
+    orderSensitiveModifiers
+  };
+};
+var defaultConfig = tailwindMergeV3.getDefaultConfig();
+var twMergeDefaultV3 = (options = {}) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(options)) options = {};
+  const {
+    cacheSize,
+    classGroups,
+    config,
+    conflictingClassGroupModifiers,
+    conflictingClassGroups,
+    override,
+    prefix,
+    theme,
+    experimentalParseClassName
+  } = validatorPropsTwMerge(options);
+  return tailwindMergeV3.extendTailwindMerge({
+    prefix: prefix ?? config.prefix,
+    cacheSize: cacheSize || defaultConfig.cacheSize,
+    experimentalParseClassName,
+    override,
+    extend: {
+      conflictingClassGroupModifiers: {
+        ...defaultConfig.conflictingClassGroupModifiers,
+        ...conflictingClassGroupModifiers
+      },
+      theme: { ...defaultConfig.theme, ...theme },
+      conflictingClassGroups: {
+        ...defaultConfig.conflictingClassGroups,
+        ...conflictingClassGroups
+      },
+      classGroups: {
+        ...defaultConfig.classGroups,
+        ...classGroups,
+        "text-shadow": ["", "-sm", "-md", "-lg", "-xl", "-xxl", "-none", "-default"].map(
+          (size) => `text-shadow${size}`
+        ),
+        "font-size": Object.keys({
+          ...config.theme?.fontSize || {},
+          ...config.theme?.extend?.fontSize || {}
+        }).map((size) => `text-${size}`)
+      }
+    }
+  });
+};
+var defaultConfig2 = tailwindMergeV4.getDefaultConfig();
+var twMergeDefaultV4 = (options = {}) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(options)) options = {};
+  const {
+    cacheSize,
+    classGroups,
+    config,
+    conflictingClassGroupModifiers,
+    conflictingClassGroups,
+    orderSensitiveModifiers,
+    override,
+    prefix,
+    theme,
+    experimentalParseClassName
+  } = validatorPropsTwMerge(options);
+  return tailwindMergeV4.extendTailwindMerge({
+    prefix: prefix || config.prefix,
+    cacheSize: cacheSize || defaultConfig2.cacheSize,
+    experimentalParseClassName,
+    override,
+    extend: {
+      conflictingClassGroupModifiers: {
+        ...defaultConfig2.conflictingClassGroupModifiers,
+        ...conflictingClassGroupModifiers
+      },
+      theme: { ...defaultConfig2.theme, ...theme },
+      conflictingClassGroups: {
+        ...defaultConfig2.conflictingClassGroups,
+        ...conflictingClassGroups
+      },
+      orderSensitiveModifiers: [
+        ...defaultConfig2.orderSensitiveModifiers,
+        ...orderSensitiveModifiers
+      ],
+      classGroups: {
+        ...defaultConfig2.classGroups,
+        ...classGroups,
+        "text-shadow": ["", "-sm", "-md", "-lg", "-xl", "-xxl", "-none", "-default"].map(
+          (size) => `text-shadow${size}`
+        ),
+        "font-size": Object.keys({
+          ...config.theme?.fontSize || {},
+          ...config.theme?.extend?.fontSize || {}
+        }).map((size) => `text-${size}`)
+      }
+    }
+  });
+};
+var defaultTwMergeV3 = twMergeDefaultV3();
+var defaultTwMergeV4 = twMergeDefaultV4();
+var cnV3 = (...classes) => {
+  return defaultTwMergeV3(clsx__default.default(...classes));
+};
+var cnV4 = (...classes) => {
+  return defaultTwMergeV4(clsx__default.default(...classes));
+};
+var customCnV3 = (customTwMergeV3, ...classes) => {
+  if (!chunkPZQ6I4JJ_cjs.isFunction(customTwMergeV3)) {
+    throw new TypeError(
+      `first Parameter (\`customTwMergeV3\`) must be of type \`function\`, but received: \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        customTwMergeV3
+      )}\`.`
+    );
+  }
+  return customTwMergeV3(clsx__default.default(...classes));
+};
+var customCnV4 = (customTwMergeV4, ...classes) => {
+  if (!chunkPZQ6I4JJ_cjs.isFunction(customTwMergeV4)) {
+    throw new TypeError(
+      `first Parameter (\`customTwMergeV4\`) must be of type \`function\`, but received: \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        customTwMergeV4
+      )}\`.`
+    );
+  }
+  return customTwMergeV4(clsx__default.default(...classes));
+};
+var shouldForwardProp = (props) => {
+  chunk6JFZL7YE_cjs.assertIsArray(props, {
+    message: ({ currentType, validType }) => `First parameter (\`props\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  return (propName) => {
+    return !props.map((p) => p.toString()).includes(propName.toString());
+  };
+};
+
+exports.cnV3 = cnV3;
+exports.cnV4 = cnV4;
+exports.customCnV3 = customCnV3;
+exports.customCnV4 = customCnV4;
+exports.shouldForwardProp = shouldForwardProp;
+exports.twMergeDefaultV3 = twMergeDefaultV3;
+exports.twMergeDefaultV4 = twMergeDefaultV4;

package/dist/chunk-3IBQ5MOM.js

@@ -1 +1,6 @@
-import{isNumber as r}from"./chunk-CMW2TBOQ.js";function i(i){return r(i)&&Number.isFinite(i)}export{i as isFinite};
+import { isNumber } from './chunk-CMW2TBOQ.js';
+function isFinite(value) {
+  return isNumber(value) && Number.isFinite(value);
+}
+
+export { isFinite };

package/dist/chunk-3VA554KW.js

@@ -1 +1,23 @@
-import{isBigInt as r}from"./chunk-QNKGP5DY.js";import{resolveErrorMessageAssertions as e,hasOwnProp as o,isNumber as i}from"./chunk-CMW2TBOQ.js";var n=(o,i={})=>{if(r(o))return;const n=e({value:o,options:i,requiredValidType:"big int"});throw new TypeError(n)},t=(r,n={})=>{const t=o(n,"includeNaN")?n.includeNaN:void 0;if(i(r,{includeNaN:t}))return;const u=e({value:r,options:n,requiredValidType:"number"});throw new TypeError(u)};export{n as assertIsBigInt,t as assertIsNumber};
+import { isBigInt } from './chunk-QNKGP5DY.js';
+import { resolveErrorMessageAssertions, hasOwnProp, isNumber } from './chunk-CMW2TBOQ.js';
+var assertIsBigInt = (value, options = {}) => {
+  if (isBigInt(value)) return;
+  const errorMessage = resolveErrorMessageAssertions({
+    value,
+    options,
+    requiredValidType: "big int"
+  });
+  throw new TypeError(errorMessage);
+};
+var assertIsNumber = (value, options = {}) => {
+  const includeNaN = hasOwnProp(options, "includeNaN") ? options.includeNaN : void 0;
+  if (isNumber(value, { includeNaN })) return;
+  const errorMessage = resolveErrorMessageAssertions({
+    value,
+    options,
+    requiredValidType: "number"
+  });
+  throw new TypeError(errorMessage);
+};
+
+export { assertIsBigInt, assertIsNumber };

package/dist/chunk-5757UBXJ.cjs

@@ -1 +1,144 @@
-"use strict";var e=require("./chunk-DVMHRLKP.cjs"),t=require("./chunk-T7PU2V7X.cjs"),r=require("./chunk-PZQ6I4JJ.cjs");var n=(n,s)=>{if(!e.isInteger(n)||!e.isInteger(s))throw new TypeError(`First parameter (\`min\`) and second parameter (\`max\`) must be of type \`integer-number\`${i(n,s)}value, but received: ['min': \`${r.getPreciseType(n)}\` - (with value: \`${t.safeStableStringify(n)})\`, 'max': \`${r.getPreciseType(s)}\` - (with value: \`${t.safeStableStringify(s)}\`)].`);if(n>s)throw new RangeError(`First parameter (\`min\`) must be less than or equal to second parameter (\`max\`), but received: ['min': ${a(n)}, 'max': ${a(s)}].`);return n=Math.max(1,n),s=Math.min(Number.MAX_SAFE_INTEGER,s),Math.floor(Math.random()*(s-n+1))+n},a=e=>r.isNumber(e,{includeNaN:!0})?e===Number.MIN_VALUE?"`Number.MIN_VALUE`":`${e}`:`\`${r.getPreciseType(e)}\``,i=(...e)=>e.some(e=>r.isNumber(e,{includeNaN:!0})&&e===Number.MIN_VALUE)?" and can't be `Number.MIN_VALUE` ":" ";exports.getRandomItem=function(e){if(!r.isNonEmptyArray(e))return;return e[Math.floor(Math.random()*(e.length||0))]},exports.randomInt=n,exports.randomIntByLength=a=>{r.isPlainObject(a)||(a={});const{minLength:i=1,maxLength:s=16,avoidZero:m=!1}=a;if(r.assertIsBoolean(m,{message:({currentType:e,validType:t})=>`Parameters \`avoidZero\` must be of type \`${t}\`, but received: \`${e}\`.`}),!e.isInteger(i)||!e.isInteger(s))throw new TypeError(`Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${r.getPreciseType(i)}\` - (with value: ${t.safeStableStringify(i)}), 'maxLength': \`${r.getPreciseType(s)}\` - (with value: ${t.safeStableStringify(s)})].`);if(i<1||s>16||i>s)throw new RangeError(`Invalid range at parameters \`minLength\` must be ≥ 1, \`maxLength\` must be ≤ 16, and \`minLength\` ≤ \`maxLength\`, but received: ['minLength': \`${i}\`, 'maxLength': \`${s}\`].`);const o=i===s?i:n(i,s),h=10**(o-1);let u=n(h,10**o-1);return m&&0===u&&(u=h),u},exports.randomStr=a=>{r.isPlainObject(a)||(a={});const{minLength:i=40,maxLength:s=40,type:m="string",avoidWhiteSpace:o=!0}=a;if(r.assertIsBoolean(o,{message:({currentType:e,validType:t})=>`Parameters \`avoidWhiteSpace\` property of the \`options\` (first-parameter) must be of type \`${t}\`, but received: \`${e}\`.`}),!e.isInteger(i)||!e.isInteger(s))throw new TypeError(`Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${r.getPreciseType(i)}\` - (with value: ${t.safeStableStringify(i)}), 'maxLength': \`${r.getPreciseType(s)}\` - (with value: ${t.safeStableStringify(s)})].`);if(i<1||s>5e3||i>s)throw new RangeError(`Invalid range at parameters \`minLength\` must be ≥ 1, \`maxLength\` must be ≤ 5000, and \`minLength\` ≤ \`maxLength\`, but received: ['minLength': \`${i}\`, 'maxLength': \`${s}\`].`);if("string"!==m&&"number"!==m)throw new TypeError(`Parameter \`type\` must be of type \`string\` with value one of "string" | "number", but received: \`${r.getPreciseType(m)}\`, with value: ${t.safeStableStringify(m)}.`);const h=n(i,s),u="number"===m?(r.isNaN(Number(a.replaceGenInt))?void 0:a.replaceGenInt)??"0123456789":(a.replaceGenStr?a.replaceGenStr:void 0)??"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",g=(c=u,(o?c.replace(/\s|\n|\t/g,""):c)+(a.addChar||""));var c;if(!g.length){throw new Error(`Character set is empty. ${(()=>"number"===m?o?"If `avoidWhiteSpace` is true, and `replaceGenInt` cant be empty-string value, ensure `replaceGenInt` has valid characters and non-nan string number.":"Ensure `replaceGenInt` has valid characters and not a NaN number string while convert to number.":"Ensure `replaceGenStr` has valid characters and non empty string.")()}`)}let p="";for(let e=0;e<h;e++)p+=g.charAt(Math.floor(Math.random()*g.length));return p};
+'use strict';
+
+var chunkDVMHRLKP_cjs = require('./chunk-DVMHRLKP.cjs');
+var chunkT7PU2V7X_cjs = require('./chunk-T7PU2V7X.cjs');
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+function getRandomItem(array) {
+  if (!chunkPZQ6I4JJ_cjs.isNonEmptyArray(array)) return void 0;
+  const randomIndex = Math.floor(Math.random() * (array.length || 0));
+  return array[randomIndex];
+}
+var randomInt = (min, max) => {
+  if (!chunkDVMHRLKP_cjs.isInteger(min) || !chunkDVMHRLKP_cjs.isInteger(max)) {
+    throw new TypeError(
+      `First parameter (\`min\`) and second parameter (\`max\`) must be of type \`integer-number\`${minValueNote(
+        min,
+        max
+      )}value, but received: ['min': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        min
+      )}\` - (with value: \`${chunkT7PU2V7X_cjs.safeStableStringify(min)})\`, 'max': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        max
+      )}\` - (with value: \`${chunkT7PU2V7X_cjs.safeStableStringify(max)}\`)].`
+    );
+  }
+  if (min > max) {
+    throw new RangeError(
+      `First parameter (\`min\`) must be less than or equal to second parameter (\`max\`), but received: ['min': ${formatValue(
+        min
+      )}, 'max': ${formatValue(max)}].`
+    );
+  }
+  min = Math.max(1, min);
+  max = Math.min(Number.MAX_SAFE_INTEGER, max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+var formatValue = (value) => {
+  return chunkPZQ6I4JJ_cjs.isNumber(value, { includeNaN: true }) ? value === Number.MIN_VALUE ? "`Number.MIN_VALUE`" : `${value}` : `\`${chunkPZQ6I4JJ_cjs.getPreciseType(value)}\``;
+};
+var minValueNote = (...values) => {
+  return values.some((v) => chunkPZQ6I4JJ_cjs.isNumber(v, { includeNaN: true }) && v === Number.MIN_VALUE) ? " and can't be `Number.MIN_VALUE` " : " ";
+};
+var randomIntByLength = (options) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(options)) {
+    options = {};
+  }
+  const { minLength = 1, maxLength = 16, avoidZero = false } = options;
+  chunkPZQ6I4JJ_cjs.assertIsBoolean(avoidZero, {
+    message({ currentType, validType }) {
+      return `Parameters \`avoidZero\` must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  if (!chunkDVMHRLKP_cjs.isInteger(minLength) || !chunkDVMHRLKP_cjs.isInteger(maxLength)) {
+    throw new TypeError(
+      `Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        minLength
+      )}\` - (with value: ${chunkT7PU2V7X_cjs.safeStableStringify(
+        minLength
+      )}), 'maxLength': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        maxLength
+      )}\` - (with value: ${chunkT7PU2V7X_cjs.safeStableStringify(maxLength)})].`
+    );
+  }
+  if (minLength < 1 || maxLength > 16 || minLength > maxLength) {
+    throw new RangeError(
+      `Invalid range at parameters \`minLength\` must be \u2265 1, \`maxLength\` must be \u2264 16, and \`minLength\` \u2264 \`maxLength\`, but received: ['minLength': \`${minLength}\`, 'maxLength': \`${maxLength}\`].`
+    );
+  }
+  const randomLength = minLength === maxLength ? minLength : randomInt(minLength, maxLength);
+  const minValue = 10 ** (randomLength - 1);
+  const maxValue = 10 ** randomLength - 1;
+  let result = randomInt(minValue, maxValue);
+  if (avoidZero && result === 0) {
+    result = minValue;
+  }
+  return result;
+};
+var randomStr = (options) => {
+  if (!chunkPZQ6I4JJ_cjs.isPlainObject(options)) {
+    options = {};
+  }
+  const {
+    minLength = 40,
+    maxLength = 40,
+    type = "string",
+    avoidWhiteSpace = true
+  } = options;
+  chunkPZQ6I4JJ_cjs.assertIsBoolean(avoidWhiteSpace, {
+    message({ currentType, validType }) {
+      return `Parameters \`avoidWhiteSpace\` property of the \`options\` (first-parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  if (!chunkDVMHRLKP_cjs.isInteger(minLength) || !chunkDVMHRLKP_cjs.isInteger(maxLength)) {
+    throw new TypeError(
+      `Parameters \`minLength\` and \`maxLength\` must be of type \`integer-number\`, but received: ['minLength': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        minLength
+      )}\` - (with value: ${chunkT7PU2V7X_cjs.safeStableStringify(
+        minLength
+      )}), 'maxLength': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        maxLength
+      )}\` - (with value: ${chunkT7PU2V7X_cjs.safeStableStringify(maxLength)})].`
+    );
+  }
+  if (minLength < 1 || maxLength > 5e3 || minLength > maxLength) {
+    throw new RangeError(
+      `Invalid range at parameters \`minLength\` must be \u2265 1, \`maxLength\` must be \u2264 5000, and \`minLength\` \u2264 \`maxLength\`, but received: ['minLength': \`${minLength}\`, 'maxLength': \`${maxLength}\`].`
+    );
+  }
+  if (type !== "string" && type !== "number") {
+    throw new TypeError(
+      `Parameter \`type\` must be of type \`string\` with value one of "string" | "number", but received: \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        type
+      )}\`, with value: ${chunkT7PU2V7X_cjs.safeStableStringify(type)}.`
+    );
+  }
+  const length = randomInt(minLength, maxLength);
+  const cleanCharacters = (charSet) => {
+    return avoidWhiteSpace ? charSet.replace(/\s|\n|\t/g, "") : charSet;
+  };
+  const defaultNumberSet = "0123456789";
+  const defaultStringSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const baseCharSet = type === "number" ? (!chunkPZQ6I4JJ_cjs.isNaN(Number(options.replaceGenInt)) ? options.replaceGenInt : void 0) ?? defaultNumberSet : (options.replaceGenStr ? options.replaceGenStr : void 0) ?? defaultStringSet;
+  const characterSet = cleanCharacters(baseCharSet) + (options.addChar || "");
+  if (!characterSet.length) {
+    const errCharSet = () => {
+      if (type === "number") {
+        if (avoidWhiteSpace) {
+          return `If \`avoidWhiteSpace\` is true, and \`replaceGenInt\` cant be empty-string value, ensure \`replaceGenInt\` has valid characters and non-nan string number.`;
+        }
+        return `Ensure \`replaceGenInt\` has valid characters and not a NaN number string while convert to number.`;
+      }
+      return `Ensure \`replaceGenStr\` has valid characters and non empty string.`;
+    };
+    throw new Error(`Character set is empty. ${errCharSet()}`);
+  }
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += characterSet.charAt(Math.floor(Math.random() * characterSet.length));
+  }
+  return result;
+};
+
+exports.getRandomItem = getRandomItem;
+exports.randomInt = randomInt;
+exports.randomIntByLength = randomIntByLength;
+exports.randomStr = randomStr;

package/dist/chunk-5IGC6PBH.js

@@ -1 +1,22 @@
-import{isEmptyValue as t}from"./chunk-GQR4R5WY.js";var r=(r,o={})=>!t(r,o),o=new Set(["[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]","[object BigInt64Array]","[object BigUint64Array]"]);function e(t){return null!=t&&"object"==typeof t&&o.has(Object.prototype.toString.call(t))}export{r as isNonEmptyValue,e as isTypedArray};
+import { isEmptyValue } from './chunk-GQR4R5WY.js';
+var isNonEmptyValue = (value, options = {}) => {
+  return !isEmptyValue(value, options);
+};
+var typedArrayTags = /* @__PURE__ */ new Set([
+  "[object Int8Array]",
+  "[object Uint8Array]",
+  "[object Uint8ClampedArray]",
+  "[object Int16Array]",
+  "[object Uint16Array]",
+  "[object Int32Array]",
+  "[object Uint32Array]",
+  "[object Float32Array]",
+  "[object Float64Array]",
+  "[object BigInt64Array]",
+  "[object BigUint64Array]"
+]);
+function isTypedArray(value) {
+  return value != null && typeof value === "object" && typedArrayTags.has(Object.prototype.toString.call(value));
+}
+
+export { isNonEmptyValue, isTypedArray };

package/dist/chunk-5KJFVIQT.cjs

@@ -1 +1,55 @@
-"use strict";var e=require("./chunk-PZQ6I4JJ.cjs");exports.parseCurrencyString=l=>{if(!e.isNonEmptyString(l))return 0;let c=l.trim().replace(/\u00A0/g,"").replace(/\u202F/g,""),r=!1;/^\(.*\)$/.test(c)&&(r=!0,c=c.slice(1,-1).trim()),c=c.replace(/^[-\s]+/,e=>e.includes("-")?"-":"").replace(/[\s.,-]+$/,""),r=r||/^-/.test(c)||/^[^\d]*-/.test(c);let s=c.replace(/[^0-9.,'\s]/g,"").replace(/[\s']/g,"");const t=s.match(/,\d{2}/g);if(t&&t.length>1)s=s.replace(/,/g,"");else{const e=(s.match(/\./g)||[]).length,l=(s.match(/,/g)||[]).length;if(e>1&&0===l)s=s.replace(/\./g,"");else if(l>1&&0===e)s=s.replace(/,/g,"");else{const e=s.lastIndexOf(","),l=s.lastIndexOf(".");if(e>l)s=s.replace(/\./g,"").replace(",",".");else if(l>e)s=s.replace(/,/g,"");else if(e>l){const l=s.slice(0,e).replace(/,/g,"").replace(/\./g,""),c=s.slice(e+1);s=l+"."+c}else if(l>e){const e=s.slice(0,l).replace(/\./g,"").replace(/,/g,""),c=s.slice(l+1);s=e+"."+c}else-1!==e?s=s.replace(/,/g,""):-1!==l&&(s=s.replace(/\./g,""))}}const a=parseFloat(s)||0;return r?-a:a};
+'use strict';
+
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+var parseCurrencyString = (input) => {
+  if (!chunkPZQ6I4JJ_cjs.isNonEmptyString(input)) return 0;
+  let trimmed = input.trim().replace(/\u00A0/g, "").replace(/\u202F/g, "");
+  let isNegative = false;
+  if (/^\(.*\)$/.test(trimmed)) {
+    isNegative = true;
+    trimmed = trimmed.slice(1, -1).trim();
+  }
+  trimmed = trimmed.replace(/^[-\s]+/, (match) => match.includes("-") ? "-" : "").replace(/[\s.,-]+$/, "");
+  isNegative = isNegative || /^-/.test(trimmed) || /^[^\d]*-/.test(trimmed);
+  const cleaned = trimmed.replace(/[^0-9.,'\s]/g, "");
+  let cleanedNoSpace = cleaned.replace(/[\s']/g, "");
+  const indianMatches = cleanedNoSpace.match(/,\d{2}/g);
+  const isIndianStyle = indianMatches && indianMatches.length > 1;
+  if (isIndianStyle) {
+    cleanedNoSpace = cleanedNoSpace.replace(/,/g, "");
+  } else {
+    const dotCount = (cleanedNoSpace.match(/\./g) || []).length;
+    const commaCount = (cleanedNoSpace.match(/,/g) || []).length;
+    if (dotCount > 1 && commaCount === 0) {
+      cleanedNoSpace = cleanedNoSpace.replace(/\./g, "");
+    } else if (commaCount > 1 && dotCount === 0) {
+      cleanedNoSpace = cleanedNoSpace.replace(/,/g, "");
+    } else {
+      const lastComma = cleanedNoSpace.lastIndexOf(",");
+      const lastDot = cleanedNoSpace.lastIndexOf(".");
+      if (lastComma > lastDot) {
+        cleanedNoSpace = cleanedNoSpace.replace(/\./g, "").replace(",", ".");
+      } else if (lastDot > lastComma) {
+        cleanedNoSpace = cleanedNoSpace.replace(/,/g, "");
+      } else {
+        if (lastComma > lastDot) {
+          const beforeDecimal = cleanedNoSpace.slice(0, lastComma).replace(/,/g, "").replace(/\./g, "");
+          const afterDecimal = cleanedNoSpace.slice(lastComma + 1);
+          cleanedNoSpace = beforeDecimal + "." + afterDecimal;
+        } else if (lastDot > lastComma) {
+          const beforeDecimal = cleanedNoSpace.slice(0, lastDot).replace(/\./g, "").replace(/,/g, "");
+          const afterDecimal = cleanedNoSpace.slice(lastDot + 1);
+          cleanedNoSpace = beforeDecimal + "." + afterDecimal;
+        } else if (lastComma !== -1) {
+          cleanedNoSpace = cleanedNoSpace.replace(/,/g, "");
+        } else if (lastDot !== -1) {
+          cleanedNoSpace = cleanedNoSpace.replace(/\./g, "");
+        }
+      }
+    }
+  }
+  const num = parseFloat(cleanedNoSpace) || 0;
+  return isNegative ? -num : num;
+};
+
+exports.parseCurrencyString = parseCurrencyString;

package/dist/chunk-6JFCSH7J.js

@@ -1 +1,24 @@
-import{isArray as e,isObject as t,assertIsPlainObject as r,hasOwnProp as o,assertIsBoolean as c}from"./chunk-CMW2TBOQ.js";var n=t=>!e(t)||0===t.length;function s(e,n={}){if(!t(e))return!0;r(n,{message:({currentType:e,validType:t})=>`Second parameter (\`options\`) must be of type \`${t}\`, but received: \`${e}\`.`});const s=!!o(n,"checkSymbols")&&n.checkSymbols;c(s,{message:({currentType:e,validType:t})=>`Parameter \`checkSymbols\` property of the \`options\` (second parameter) must be of type \`${t}\`, but received: \`${e}\`.`});const p=0===Object.keys(e).length;return s?p&&0===Object.getOwnPropertySymbols(e).length:p}export{n as isEmptyArray,s as isEmptyObject};
+import { isArray, isObject, assertIsPlainObject, hasOwnProp, assertIsBoolean } from './chunk-CMW2TBOQ.js';
+var isEmptyArray = (value) => {
+  if (!isArray(value)) return true;
+  return value.length === 0;
+};
+function isEmptyObject(value, options = {}) {
+  if (!isObject(value)) {
+    return true;
+  }
+  assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const checkSymbols = hasOwnProp(options, "checkSymbols") ? options.checkSymbols : false;
+  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;
+}
+
+export { isEmptyArray, isEmptyObject };

package/dist/chunk-6JFZL7YE.cjs

@@ -1 +1,14 @@
-"use strict";var r=require("./chunk-PZQ6I4JJ.cjs");exports.assertIsArray=function(e,s){if(r.isArray(e))return;const o=r.resolveErrorMessageAssertions({value:e,options:s,requiredValidType:"array"});throw new TypeError(o)};
+'use strict';
+
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+function assertIsArray(value, options) {
+  if (chunkPZQ6I4JJ_cjs.isArray(value)) return;
+  const errorMessage = chunkPZQ6I4JJ_cjs.resolveErrorMessageAssertions({
+    value,
+    options,
+    requiredValidType: "array"
+  });
+  throw new TypeError(errorMessage);
+}
+
+exports.assertIsArray = assertIsArray;