@rzl-zone/utils-js 3.3.1 → 3.5.0

package/dist/chunk-SBFNXGTJ.js

@@ -1 +1,207 @@
-import{isURL as r}from"./chunk-ONZFBJVW.js";import{normalizeString as e}from"./chunk-IZPBKKPO.js";import{toStringArrayUnRecursive as t}from"./chunk-OI5XKNZO.js";import{isEmptyValue as n}from"./chunk-GQR4R5WY.js";import{isInteger as o}from"./chunk-WVSPXFTY.js";import{normalizePathname as a}from"./chunk-GGEADHZO.js";import{isEmptyString as i}from"./chunk-W2WNBUDE.js";import{assertIsArray as s}from"./chunk-CKTLUNWX.js";import{safeStableStringify as u}from"./chunk-PET42Z7W.js";import{isString as m,getPreciseType as c,isUndefined as p,isNonEmptyString as f,isFunction as l,isNumber as h,isError as y,isArray as b,isNil as d,isNull as w,isPlainObject as v,isBoolean as g,isNonEmptyArray as $}from"./chunk-CMW2TBOQ.js";var T=(o,a,b)=>{if(m(o)){if(i(o))throw new TypeError("First parameter (`baseUrl`) cannot be an empty-string.");o=e(o)}else if(!r(o))throw new TypeError(`First parameter (\`baseUrl\`) must be of type an URL instance or a \`string\` and a non empty-string, but received: \`${c(o)}\`, with current value: \`${u(o)}\`.`);if(!p(b)&&(s(b,{message:({currentType:r,validType:e})=>`Third parameter (\`removeParams\`) must be of type \`${e} of strings\`, but received: \`${r}\`.`}),!b.every(r=>f(r))))throw new TypeError("Third parameter (`removeParams`) must be of type `array` and contains `string` only and non empty-string.");try{if(!p(a)&&!l(a[Symbol.iterator]))throw new TypeError(`Second parameter (\`queryParams\`) must be iterable (like URLSearchParams.entries() or an array of [[string, string | number]...]), but received: \`${c(a)}\`, with value: \`${u(a)}\`.`);const r=new URL(o);if(!p(a)){const e=Object.fromEntries(a);if(!n(e)){const n=new URLSearchParams(r.search);for(const[r,t]of Object.entries(e)){if(!f(t)&&!h(t,{includeNaN:!0}))throw new TypeError(`Second parameter (\`queryParams\`) must be iterable (like URLSearchParams.entries() or an array of [[string, string | number]...]), but received: \`${c(a)}\`, with value: \`${u(a)}\`.`);n.set(r,String(t))}b?.length&&t(b).map(r=>{n.delete(r)}),r.search=n.toString()}}return b?.forEach(e=>r.searchParams.delete(e)),r}catch(r){if(y(r))throw r;throw new Error("Failed to construct a valid URL in `constructURL()`, Error:"+r)}},E=r=>{if(!f(r))return null;let e;try{e=decodeURIComponent(r)}catch{return null}const t=e.match(/https?:\/\/.*?(?=https?:\/\/|\s|$)/g);if(!t)return null;const n=t.map(r=>r.replace(/[.,;:!?)]*$/,"")).filter(r=>{try{const e=new URL(r);return"http:"===e.protocol||"https:"===e.protocol}catch{return!1}});return n.length?n:null},P=(r,e="/")=>{if(!f(e))throw new TypeError(`Second parameter (\`defaultValue\`) must be of type \`string\` and not an \`empty-string\`, but received: \`${c(e)}\`, with value: \`${u(e)}\`.`);if(b(r)){if(!r.every(r=>m(r)))throw new TypeError(`First parameter (\`result\`) must be of type \`string\` or \`array of string\`, but received: \`${c(r)}\`, with value: \`${u(r)}\`.`);for(const e of r){const r=a(e);if("/"!==r)return r}return a(e)}if(m(r)){const t=a(r);return"/"!==t?t:a(e)}if(!d(r))throw new TypeError(`First parameter (\`result\`) must be of type \`string\`, \`array-string\`, \`null\` or \`undefined\`, but received: \`${c(r)}\`.`);return a(e)},j=(r,e=null,t={})=>{const n=[];m(r)||b(r)||n.push(`First parameter (\`url\`) must be of type \`string\` or \`array-string\`, but received: \`${c(r)}\`.`),m(e)||b(e)||w(e)||n.push(`Second parameter (\`base\`) must be of type \`string\`, \`array-string\` or \`null\`, but received: \`${c(e)}\`.`),v(t)||n.push(`Second parameter (\`options\`) must be of type \`plain-object\`, but received: \`${c(t)}\`.`);const{levels:i=1,removeDuplicates:s=!0}=t;if((!o(i)||o(i)&&i<0)&&n.push(`Parameter \`levels\` property of the \`options\` (second parameter) must be of type \`integer-number\` and minimum is \`0\`, but received: \`${c(i)}\`, with value: \`${u(i)}\`.`),g(s)||n.push(`Parameter \`removeDuplicates\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: \`${c(s)}\`.`),$(n))throw new TypeError(`Invalid parameter(s) in \`getPrefixPathname\` function:\n- ${n.join("\n- ")}`);function p(r){return`/${a(r).split("/").filter(Boolean).slice(0,i).join("/")}`}function l(r){if(e){if(r=a(r),b(e)){for(const t of e)if(r.startsWith(a(t)))return p(r)}else if(f(e)&&r.startsWith(a(e)))return p(r);return null}return p(r)}if(b(r)){const e=r.map(l).filter(r=>!w(r)),t=s?[...new Set(e)]:e;return 1===t.length?t[0]:t}return l(r)};export{T as constructURL,E as extractURLs,P as getFirstPrefixPathname,j as getPrefixPathname};
+import { isURL } from './chunk-ONZFBJVW.js';
+import { normalizeString } from './chunk-IZPBKKPO.js';
+import { toStringArrayUnRecursive } from './chunk-OI5XKNZO.js';
+import { isEmptyValue } from './chunk-GQR4R5WY.js';
+import { isInteger } from './chunk-WVSPXFTY.js';
+import { normalizePathname } from './chunk-GGEADHZO.js';
+import { isEmptyString } from './chunk-W2WNBUDE.js';
+import { assertIsArray } from './chunk-CKTLUNWX.js';
+import { safeStableStringify } from './chunk-PET42Z7W.js';
+import { isString, getPreciseType, isUndefined, isNonEmptyString, isFunction, isNumber, isError, isArray, isNil, isNull, isPlainObject, isBoolean, isNonEmptyArray } from './chunk-CMW2TBOQ.js';
+var constructURL = (baseUrl, queryParams, removeParams) => {
+  if (isString(baseUrl)) {
+    if (isEmptyString(baseUrl)) {
+      throw new TypeError(`First parameter (\`baseUrl\`) cannot be an empty-string.`);
+    }
+    baseUrl = normalizeString(baseUrl);
+  } else if (!isURL(baseUrl)) {
+    throw new TypeError(
+      `First parameter (\`baseUrl\`) must be of type an URL instance or a \`string\` and a non empty-string, but received: \`${getPreciseType(
+        baseUrl
+      )}\`, with current value: \`${safeStableStringify(baseUrl)}\`.`
+    );
+  }
+  if (!isUndefined(removeParams)) {
+    assertIsArray(removeParams, {
+      message: ({ currentType, validType }) => `Third parameter (\`removeParams\`) must be of type \`${validType} of strings\`, but received: \`${currentType}\`.`
+    });
+    if (!removeParams.every((param) => isNonEmptyString(param))) {
+      throw new TypeError(
+        `Third parameter (\`removeParams\`) must be of type \`array\` and contains \`string\` only and non empty-string.`
+      );
+    }
+  }
+  try {
+    if (!isUndefined(queryParams) && !isFunction(queryParams[Symbol.iterator])) {
+      throw new TypeError(
+        `Second parameter (\`queryParams\`) must be iterable (like URLSearchParams.entries() or an array of [[string, string | number]...]), but received: \`${getPreciseType(
+          queryParams
+        )}\`, with value: \`${safeStableStringify(queryParams)}\`.`
+      );
+    }
+    const urlInstance = new URL(baseUrl);
+    if (!isUndefined(queryParams)) {
+      const paramObject = Object.fromEntries(queryParams);
+      if (!isEmptyValue(paramObject)) {
+        const mergedParams = new URLSearchParams(urlInstance.search);
+        for (const [key, value] of Object.entries(paramObject)) {
+          if (!isNonEmptyString(value) && !isNumber(value, { includeNaN: true })) {
+            throw new TypeError(
+              `Second parameter (\`queryParams\`) must be iterable (like URLSearchParams.entries() or an array of [[string, string | number]...]), but received: \`${getPreciseType(
+                queryParams
+              )}\`, with value: \`${safeStableStringify(queryParams)}\`.`
+            );
+          }
+          mergedParams.set(key, String(value));
+        }
+        if (removeParams?.length) {
+          toStringArrayUnRecursive(removeParams).map((paramKey) => {
+            mergedParams.delete(paramKey);
+          });
+        }
+        urlInstance.search = mergedParams.toString();
+      }
+    }
+    removeParams?.forEach((param) => urlInstance.searchParams.delete(param));
+    return urlInstance;
+  } catch (error) {
+    if (isError(error)) throw error;
+    throw new Error(
+      "Failed to construct a valid URL in `constructURL()`, Error:" + error
+    );
+  }
+};
+var extractURLs = (url) => {
+  if (!isNonEmptyString(url)) return null;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(url);
+  } catch {
+    return null;
+  }
+  const urlPattern = /https?:\/\/.*?(?=https?:\/\/|\s|$)/g;
+  const matches = decoded.match(urlPattern);
+  if (!matches) return null;
+  const cleaned = matches.map((url2) => url2.replace(/[.,;:!?)]*$/, "")).filter((url2) => {
+    try {
+      const u = new URL(url2);
+      return u.protocol === "http:" || u.protocol === "https:";
+    } catch {
+      return false;
+    }
+  });
+  return cleaned.length ? cleaned : null;
+};
+var getFirstPrefixPathname = (result, defaultValue = "/") => {
+  if (!isNonEmptyString(defaultValue)) {
+    throw new TypeError(
+      `Second parameter (\`defaultValue\`) must be of type \`string\` and not an \`empty-string\`, but received: \`${getPreciseType(
+        defaultValue
+      )}\`, with value: \`${safeStableStringify(defaultValue)}\`.`
+    );
+  }
+  if (isArray(result)) {
+    if (!result.every((item) => isString(item))) {
+      throw new TypeError(
+        `First parameter (\`result\`) must be of type \`string\` or \`array of string\`, but received: \`${getPreciseType(
+          result
+        )}\`, with value: \`${safeStableStringify(result)}\`.`
+      );
+    }
+    for (const item of result) {
+      const normalized = normalizePathname(item);
+      if (normalized !== "/") {
+        return normalized;
+      }
+    }
+    return normalizePathname(defaultValue);
+  }
+  if (isString(result)) {
+    const normalized = normalizePathname(result);
+    return normalized !== "/" ? normalized : normalizePathname(defaultValue);
+  }
+  if (!isNil(result)) {
+    throw new TypeError(
+      `First parameter (\`result\`) must be of type \`string\`, \`array-string\`, \`null\` or \`undefined\`, but received: \`${getPreciseType(
+        result
+      )}\`.`
+    );
+  }
+  return normalizePathname(defaultValue);
+};
+var getPrefixPathname = (url, base = null, options = {}) => {
+  const errors = [];
+  if (!isString(url) && !isArray(url)) {
+    errors.push(
+      `First parameter (\`url\`) must be of type \`string\` or \`array-string\`, but received: \`${getPreciseType(
+        url
+      )}\`.`
+    );
+  }
+  if (!isString(base) && !isArray(base) && !isNull(base)) {
+    errors.push(
+      `Second parameter (\`base\`) must be of type \`string\`, \`array-string\` or \`null\`, but received: \`${getPreciseType(
+        base
+      )}\`.`
+    );
+  }
+  if (!isPlainObject(options)) {
+    errors.push(
+      `Second parameter (\`options\`) must be of type \`plain-object\`, but received: \`${getPreciseType(
+        options
+      )}\`.`
+    );
+  }
+  const { levels = 1, removeDuplicates = true } = options;
+  if (!isInteger(levels) || isInteger(levels) && levels < 0) {
+    errors.push(
+      `Parameter \`levels\` property of the \`options\` (second parameter) must be of type \`integer-number\` and minimum is \`0\`, but received: \`${getPreciseType(
+        levels
+      )}\`, with value: \`${safeStableStringify(levels)}\`.`
+    );
+  }
+  if (!isBoolean(removeDuplicates)) {
+    errors.push(
+      `Parameter \`removeDuplicates\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: \`${getPreciseType(
+        removeDuplicates
+      )}\`.`
+    );
+  }
+  if (isNonEmptyArray(errors)) {
+    throw new TypeError(
+      `Invalid parameter(s) in \`getPrefixPathname\` function:
+- ${errors.join("\n- ")}`
+    );
+  }
+  function getLevel(singleUrl) {
+    const parts = normalizePathname(singleUrl).split("/").filter(Boolean);
+    return `/${parts.slice(0, levels).join("/")}`;
+  }
+  function processUrl(singleUrl) {
+    if (base) {
+      singleUrl = normalizePathname(singleUrl);
+      if (isArray(base)) {
+        for (const b of base) {
+          if (singleUrl.startsWith(normalizePathname(b))) {
+            return getLevel(singleUrl);
+          }
+        }
+      } else if (isNonEmptyString(base) && singleUrl.startsWith(normalizePathname(base))) {
+        return getLevel(singleUrl);
+      }
+      return null;
+    }
+    return getLevel(singleUrl);
+  }
+  if (isArray(url)) {
+    const result = url.map(processUrl).filter((r) => !isNull(r));
+    const uniqueResult = removeDuplicates ? [...new Set(result)] : result;
+    if (uniqueResult.length === 1) {
+      return uniqueResult[0];
+    }
+    return uniqueResult;
+  }
+  return processUrl(url);
+};
+
+export { constructURL, extractURLs, getFirstPrefixPathname, getPrefixPathname };

package/dist/chunk-SBKGWRS5.js

@@ -1 +1,12 @@
-import{isString as r,resolveErrorMessageAssertions as e}from"./chunk-CMW2TBOQ.js";var o=(o,t={})=>{if(r(o))return;const i=e({value:o,options:t,requiredValidType:"string"});throw new TypeError(i)};export{o as assertIsString};
+import { isString, resolveErrorMessageAssertions } from './chunk-CMW2TBOQ.js';
+var assertIsString = (value, options = {}) => {
+  if (isString(value)) return;
+  const errorMessage = resolveErrorMessageAssertions({
+    value,
+    options,
+    requiredValidType: "string"
+  });
+  throw new TypeError(errorMessage);
+};
+
+export { assertIsString };

package/dist/chunk-SIM77PU4.js

@@ -1 +1,46 @@
-import{isServer as e}from"./chunk-L5RDAVVH.js";import{assertIsString as t}from"./chunk-SBKGWRS5.js";import{isPlainObject as o,hasOwnProp as s,isNonEmptyString as r,isNumber as i}from"./chunk-CMW2TBOQ.js";var n=(o="on_processing")=>{if(e())return;t(o,{message:({validType:e,currentType:t})=>`First parameter \`className\` must be of type \`${e}\`, but received: \`${t}\`.`});const{documentElement:s}=document;s&&!s.classList.contains(o)&&s.classList.add(o)},m=(o="on_processing")=>{if(e())return;t(o,{message:({validType:e,currentType:t})=>`First parameter \`className\` must be of type \`${e}\`, but received: \`${t}\`.`});const{documentElement:s}=document;s&&s.classList.contains(o)&&s.classList.remove(o)},c=()=>{if(e())return;const t=document.activeElement;t instanceof HTMLElement&&t.blur()},a=t=>{if(e())return;o(t)||(t={});const n=s(t,"behavior")&&r(t.behavior)&&["auto","instant","smooth"].includes(t.behavior)?t.behavior:"smooth";let m=s(t,"timeout")&&i(t.timeout)&&t.timeout>=1?t.timeout:1;m=m>2147483647?2147483647:m,setTimeout(()=>window.scrollTo({top:0,left:0,behavior:n}),m)};export{n as disableUserInteraction,m as enableUserInteraction,c as removeElementFocus,a as scrollToTop};
+import { isServer } from './chunk-L5RDAVVH.js';
+import { assertIsString } from './chunk-SBKGWRS5.js';
+import { isPlainObject, hasOwnProp, isNonEmptyString, isNumber } from './chunk-CMW2TBOQ.js';
+var disableUserInteraction = (className = "on_processing") => {
+  if (isServer()) return;
+  assertIsString(className, {
+    message({ validType, currentType }) {
+      return `First parameter \`className\` must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  const { documentElement } = document;
+  if (documentElement && !documentElement.classList.contains(className)) {
+    documentElement.classList.add(className);
+  }
+};
+var enableUserInteraction = (className = "on_processing") => {
+  if (isServer()) return;
+  assertIsString(className, {
+    message({ validType, currentType }) {
+      return `First parameter \`className\` must be of type \`${validType}\`, but received: \`${currentType}\`.`;
+    }
+  });
+  const { documentElement } = document;
+  if (documentElement && documentElement.classList.contains(className)) {
+    documentElement.classList.remove(className);
+  }
+};
+var removeElementFocus = () => {
+  if (isServer()) return;
+  const activeElement = document.activeElement;
+  if (activeElement instanceof HTMLElement) {
+    activeElement.blur();
+  }
+};
+var scrollToTop = (options) => {
+  if (isServer()) return;
+  if (!isPlainObject(options)) {
+    options = {};
+  }
+  const behavior = hasOwnProp(options, "behavior") && isNonEmptyString(options.behavior) && ["auto", "instant", "smooth"].includes(options.behavior) ? options.behavior : "smooth";
+  let timeout = hasOwnProp(options, "timeout") && isNumber(options.timeout) && options.timeout >= 1 ? options.timeout : 1;
+  timeout = timeout > 2147483647 ? 2147483647 : timeout;
+  setTimeout(() => window.scrollTo({ top: 0, left: 0, behavior }), timeout);
+};
+
+export { disableUserInteraction, enableUserInteraction, removeElementFocus, scrollToTop };

package/dist/chunk-T2T7K3KR.js

@@ -1 +1,18 @@
-import{isNonEmptyString as r,isPlainObject as t}from"./chunk-CMW2TBOQ.js";var i=(i,m={withTrim:!0,trimOnly:!1})=>{if(!r(i))return"";t(m)||(m={});const{trimOnly:n=!1,withTrim:e=!0}=m;return n?i.trim():(e&&(i=i.trim()),i.replace(/\s+/g," "))};export{i as normalizeSpaces};
+import { isNonEmptyString, isPlainObject } from './chunk-CMW2TBOQ.js';
+var normalizeSpaces = (value, options = {
+  withTrim: true,
+  trimOnly: false
+}) => {
+  if (!isNonEmptyString(value)) return "";
+  if (!isPlainObject(options)) {
+    options = {};
+  }
+  const { trimOnly = false, withTrim = true } = options;
+  if (trimOnly) return value.trim();
+  if (withTrim) {
+    value = value.trim();
+  }
+  return value.replace(/\s+/g, " ");
+};
+
+export { normalizeSpaces };

package/dist/chunk-T7PU2V7X.cjs

@@ -1 +1,111 @@
-"use strict";var e=require("./chunk-UDA26MCU.cjs"),r=require("./chunk-PZQ6I4JJ.cjs");function t(e){return"[object Map]"===Object.prototype.toString.call(e)||e instanceof Map}var n=(e,t={})=>{r.assertIsPlainObject(t,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const n=!(!r.isPlainObject(t)||!r.isBoolean(t.skipInvalidDate))&&t.skipInvalidDate,i=e instanceof Date;return n?i:i&&!r.isNaN(e.getTime())};exports.isDate=n,exports.isMap=t,exports.safeStableStringify=(i,s={})=>{r.assertIsPlainObject(s,{message:({currentType:e,validType:r})=>`Second parameter (\`options\`) must be of type \`${r}\`, but received: \`${e}\`.`});const o=!!r.hasOwnProp(s,"pretty")&&s.pretty,a=!r.hasOwnProp(s,"sortKeys")||s.sortKeys,u=!!r.hasOwnProp(s,"sortArray")&&s.sortArray,c=!!r.hasOwnProp(s,"keepUndefined")&&s.keepUndefined;if(!(r.isBoolean(a)&&r.isBoolean(u)&&r.isBoolean(o)&&r.isBoolean(c)))throw new TypeError(`Parameters \`sortKeys\`, \`sortArray\`, \`keepUndefined\` and \`pretty\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: "['sortKeys': \`${r.getPreciseType(a)}\`, 'sortArray': \`${r.getPreciseType(u)}\`, 'keepUndefined': \`${r.getPreciseType(c)}\`, 'pretty': \`${r.getPreciseType(o)}\`]".`);if(r.isUndefined(i))return c?"undefined":"null";const p=new WeakSet,f=e=>r.isNull(e)||!r.isObjectOrArray(e)&&!r.isFunction(e),l=i=>{if(r.isNumberObject(i)){const e=i.valueOf();return r.isNaN(e)||r.isInfinityNumber(e)?null:e}if(r.isStringObject(i))return i.valueOf();if(r.isBooleanObject(i))return i.valueOf();if(!r.isFunction(i)&&!r.isSymbol(i)){if(e.isBigInt(i))return i.toString();if(r.isNaN(i)||r.isInfinityNumber(i))return null;if(r.isUndefined(i))return c?void 0:null;if(r.isObjectOrArray(i)){if(p.has(i))return"[Circular]";if(p.add(i),n(i))return i.toISOString();if(t(i))return{map:Array.from(i.entries()).map(([e,r])=>[e,l(r)])};if(r.isSet(i))return{set:Array.from(i.values()).map(l)};if(r.isArray(i)){const e=i.map(l);if(u){const t=[],n=[];for(const r of e)f(r)?t.push(r):n.push(r);return t.sort((e,t)=>r.isNumber(e)&&r.isNumber(t)?e-t:String(e).localeCompare(String(t))),[...t,...n]}return e}const e=Object.keys(i);a&&e.sort((e,t)=>{const n=Number(e),i=Number(t);return r.isNaN(n)||r.isNaN(i)?e.localeCompare(t):n-i});const s={};if(r.isObject(i))for(const t of e){const e=l(i[t]);r.isUndefined(e)||(s[t]=e)}return s}return i}};try{return JSON.stringify(l(i),null,o?2:0)}catch(e){return console.warn("Error in safeStableStringify:",e),"{}"}};
+'use strict';
+
+var chunkUDA26MCU_cjs = require('./chunk-UDA26MCU.cjs');
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+function isMap(value) {
+  return Object.prototype.toString.call(value) === "[object Map]" || value instanceof Map;
+}
+var isDate = (value, options = {}) => {
+  chunkPZQ6I4JJ_cjs.assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const skipInvalidDate = chunkPZQ6I4JJ_cjs.isPlainObject(options) && chunkPZQ6I4JJ_cjs.isBoolean(options.skipInvalidDate) ? options.skipInvalidDate : false;
+  const instanceDate = value instanceof Date;
+  if (skipInvalidDate) return instanceDate;
+  return instanceDate && !chunkPZQ6I4JJ_cjs.isNaN(value.getTime());
+};
+var safeStableStringify = (value, options = {}) => {
+  chunkPZQ6I4JJ_cjs.assertIsPlainObject(options, {
+    message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`
+  });
+  const pretty = chunkPZQ6I4JJ_cjs.hasOwnProp(options, "pretty") ? options.pretty : false;
+  const sortKeys = chunkPZQ6I4JJ_cjs.hasOwnProp(options, "sortKeys") ? options.sortKeys : true;
+  const sortArray = chunkPZQ6I4JJ_cjs.hasOwnProp(options, "sortArray") ? options.sortArray : false;
+  const keepUndefined = chunkPZQ6I4JJ_cjs.hasOwnProp(options, "keepUndefined") ? options.keepUndefined : false;
+  if (!chunkPZQ6I4JJ_cjs.isBoolean(sortKeys) || !chunkPZQ6I4JJ_cjs.isBoolean(sortArray) || !chunkPZQ6I4JJ_cjs.isBoolean(pretty) || !chunkPZQ6I4JJ_cjs.isBoolean(keepUndefined)) {
+    throw new TypeError(
+      `Parameters \`sortKeys\`, \`sortArray\`, \`keepUndefined\` and \`pretty\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: "['sortKeys': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        sortKeys
+      )}\`, 'sortArray': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        sortArray
+      )}\`, 'keepUndefined': \`${chunkPZQ6I4JJ_cjs.getPreciseType(
+        keepUndefined
+      )}\`, 'pretty': \`${chunkPZQ6I4JJ_cjs.getPreciseType(pretty)}\`]".`
+    );
+  }
+  if (chunkPZQ6I4JJ_cjs.isUndefined(value)) {
+    return keepUndefined ? "undefined" : "null";
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const isPrimitive = (val) => chunkPZQ6I4JJ_cjs.isNull(val) || !chunkPZQ6I4JJ_cjs.isObjectOrArray(val) && !chunkPZQ6I4JJ_cjs.isFunction(val);
+  const deepProcess = (val) => {
+    if (chunkPZQ6I4JJ_cjs.isNumberObject(val)) {
+      const valOf = val.valueOf();
+      return chunkPZQ6I4JJ_cjs.isNaN(valOf) || chunkPZQ6I4JJ_cjs.isInfinityNumber(valOf) ? null : valOf;
+    }
+    if (chunkPZQ6I4JJ_cjs.isStringObject(val)) return val.valueOf();
+    if (chunkPZQ6I4JJ_cjs.isBooleanObject(val)) return val.valueOf();
+    if (chunkPZQ6I4JJ_cjs.isFunction(val) || chunkPZQ6I4JJ_cjs.isSymbol(val)) return void 0;
+    if (chunkUDA26MCU_cjs.isBigInt(val)) return val.toString();
+    if (chunkPZQ6I4JJ_cjs.isNaN(val) || chunkPZQ6I4JJ_cjs.isInfinityNumber(val)) return null;
+    if (chunkPZQ6I4JJ_cjs.isUndefined(val)) {
+      return keepUndefined ? void 0 : null;
+    }
+    if (chunkPZQ6I4JJ_cjs.isObjectOrArray(val)) {
+      if (seen.has(val)) return "[Circular]";
+      seen.add(val);
+      if (isDate(val)) return val.toISOString();
+      if (isMap(val)) {
+        return {
+          map: Array.from(val.entries()).map(([k, v]) => [k, deepProcess(v)])
+        };
+      }
+      if (chunkPZQ6I4JJ_cjs.isSet(val)) return { set: Array.from(val.values()).map(deepProcess) };
+      if (chunkPZQ6I4JJ_cjs.isArray(val)) {
+        const processedArr = val.map(deepProcess);
+        if (sortArray) {
+          const primitives = [];
+          const nonPrimitives = [];
+          for (const item of processedArr) {
+            if (isPrimitive(item)) primitives.push(item);
+            else nonPrimitives.push(item);
+          }
+          primitives.sort((a, b) => {
+            if (chunkPZQ6I4JJ_cjs.isNumber(a) && chunkPZQ6I4JJ_cjs.isNumber(b)) return a - b;
+            return String(a).localeCompare(String(b));
+          });
+          return [...primitives, ...nonPrimitives];
+        }
+        return processedArr;
+      }
+      const keys = Object.keys(val);
+      if (sortKeys) {
+        keys.sort((a, b) => {
+          const na = Number(a);
+          const nb = Number(b);
+          if (!chunkPZQ6I4JJ_cjs.isNaN(na) && !chunkPZQ6I4JJ_cjs.isNaN(nb)) return na - nb;
+          return a.localeCompare(b);
+        });
+      }
+      const result = {};
+      if (chunkPZQ6I4JJ_cjs.isObject(val)) {
+        for (const k of keys) {
+          const v = deepProcess(val[k]);
+          if (!chunkPZQ6I4JJ_cjs.isUndefined(v)) result[k] = v;
+        }
+      }
+      return result;
+    }
+    return val;
+  };
+  try {
+    return JSON.stringify(deepProcess(value), null, pretty ? 2 : 0);
+  } catch (err) {
+    console.warn("Error in safeStableStringify:", err);
+    return "{}";
+  }
+};
+
+exports.isDate = isDate;
+exports.isMap = isMap;
+exports.safeStableStringify = safeStableStringify;

package/dist/chunk-UDA26MCU.cjs

@@ -1 +1,6 @@
-"use strict";exports.isBigInt=t=>"bigint"==typeof t;
+'use strict';
+var isBigInt = (value) => {
+  return typeof value === "bigint";
+};
+
+exports.isBigInt = isBigInt;

package/dist/chunk-V45XJKHW.cjs

@@ -1 +1,8 @@
-"use strict";var i=require("./chunk-PZQ6I4JJ.cjs");exports.isFinite=function(e){return i.isNumber(e)&&Number.isFinite(e)};
+'use strict';
+
+var chunkPZQ6I4JJ_cjs = require('./chunk-PZQ6I4JJ.cjs');
+function isFinite(value) {
+  return chunkPZQ6I4JJ_cjs.isNumber(value) && Number.isFinite(value);
+}
+
+exports.isFinite = isFinite;

package/dist/chunk-VJDDGRIK.cjs

@@ -1 +1,6 @@
-"use strict";exports.isServer=()=>"undefined"==typeof window||"undefined"==typeof document;
+'use strict';
+var isServer = () => {
+  return typeof window === "undefined" || typeof document === "undefined";
+};
+
+exports.isServer = isServer;

package/dist/chunk-W2WNBUDE.js

@@ -1 +1,6 @@
-import{isNonEmptyString as r}from"./chunk-CMW2TBOQ.js";var o=(o,m={})=>!r(o,m);export{o as isEmptyString};
+import { isNonEmptyString } from './chunk-CMW2TBOQ.js';
+var isEmptyString = (value, options = {}) => {
+  return !isNonEmptyString(value, options);
+};
+
+export { isEmptyString };

package/dist/chunk-WVSPXFTY.js

@@ -1 +1,5 @@
-function e(e){return"number"==typeof e&&Number.isInteger(e)}export{e as isInteger};
+function isInteger(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+
+export { isInteger };