@splendidlabz/utils 1.11.3 → 1.11.4

package/dist/cjs/lib/index.cjs

@@ -0,0 +1,1178 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/index.js
+var lib_exports = {};
+__export(lib_exports, {
+  AuthManager: () => AuthManager,
+  DAYS: () => DAYS,
+  MONTHS: () => MONTHS,
+  RouteManager: () => RouteManager,
+  camelCaseKeys: () => camelCaseKeys,
+  compose: () => compose,
+  composeAsync: () => composeAsync,
+  concatMix: () => concatMix,
+  createMix: () => createMix,
+  createSSE: () => createSSE,
+  curry: () => curry,
+  debounce: () => debounce,
+  delay: () => delay,
+  extendObject: () => extendObject,
+  flattenArrayFields: () => flattenArrayFields,
+  flattenObject: () => flattenObject,
+  formDataToObject: () => formDataToObject,
+  getEnv: () => getEnv,
+  getNestedProperty: () => getNestedProperty,
+  getNestedProperty2: () => getNestedProperty2,
+  getNestedValue: () => getNestedValue,
+  getSymbol: () => getSymbol,
+  getSymbolValue: () => getSymbolValue,
+  getTimeInMs: () => getTimeInMs,
+  getType: () => getType,
+  isArray: () => isArray,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  isFunction: () => isFunction,
+  isHashedValue: () => isHashedValue,
+  isLastItem: () => isLastItem,
+  isObject: () => isObject,
+  joinWithConjunction: () => joinWithConjunction,
+  last: () => last,
+  lastArrayItem: () => lastArrayItem,
+  markdown: () => markdown,
+  mix: () => mix,
+  ms: () => ms,
+  normalizeObject: () => normalizeObject,
+  notEmpty: () => notEmpty,
+  notEqual: () => notEqual,
+  notObject: () => notObject,
+  objectForEach: () => objectForEach,
+  objectMap: () => objectMap,
+  omitEmpty: () => omitEmpty,
+  parseFullName: () => parseFullName,
+  parseJSON: () => parseJSON,
+  parseSSE: () => parseSSE,
+  pipe: () => pipe,
+  pipeAsync: () => pipeAsync,
+  plural: () => plural,
+  pluralize: () => pluralize,
+  reject: () => reject,
+  sanitize: () => sanitize,
+  sanitizeArray: () => sanitizeArray,
+  sanitizeObject: () => sanitizeObject,
+  shuffle: () => shuffle,
+  sizeOf: () => sizeOf,
+  sort: () => sort,
+  splitArray: () => splitArray,
+  splitObject: () => splitObject,
+  splitUnit: () => splitUnit,
+  stripNumbers: () => stripNumbers,
+  throttle: () => throttle,
+  timeout: () => timeout,
+  times: () => times,
+  toCamel: () => toCamel,
+  toDays: () => toDays,
+  toDegrees: () => toDegrees,
+  toHours: () => toHours,
+  toKebab: () => toKebab,
+  toLower: () => toLower,
+  toMinutes: () => toMinutes,
+  toPascal: () => toPascal,
+  toQueryString: () => toQueryString,
+  toRadians: () => toRadians,
+  toReadableTime: () => toReadableTime,
+  toSeconds: () => toSeconds,
+  toSentence: () => toSentence,
+  toSlug: () => toSlug,
+  toStyleString: () => toStyleString,
+  toTitle: () => toTitle,
+  toUpper: () => toUpper,
+  toWeeks: () => toWeeks,
+  treatMarkdownWhitespace: () => treatMarkdownWhitespace,
+  uniqueArray: () => uniqueArray,
+  wait: () => wait
+});
+module.exports = __toCommonJS(lib_exports);
+
+// src/lib/arrays/item-position.js
+function last(array, index) {
+  console.warn("last is deprecated. Use isLastItem instead.");
+  return index === array.length - 1;
+}
+function isLastItem(array, index) {
+  return index === array.length - 1;
+}
+function lastArrayItem(array) {
+  return array[array.length - 1];
+}
+
+// src/lib/arrays/join.js
+function joinWithConjunction(array, { conjunction = "and" } = {}) {
+  if (!array?.length) return "";
+  if (array.length === 1) return array[0];
+  if (array.length === 2) return `${array[0]} ${conjunction} ${array[1]}`;
+  const lastItem = lastArrayItem(array);
+  const rest = array.slice(0, -1);
+  return `${rest.join(", ")} ${conjunction} ${lastItem}`;
+}
+
+// src/lib/arrays/shuffle.js
+function shuffle(array) {
+  const clone = array.slice();
+  let currentIndex = array.length;
+  let temporaryValue;
+  let randomIndex;
+  while (currentIndex !== 0) {
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex -= 1;
+    temporaryValue = clone[currentIndex];
+    clone[currentIndex] = clone[randomIndex];
+    clone[randomIndex] = temporaryValue;
+  }
+  return clone;
+}
+
+// src/lib/objects/nested-property.js
+function getNestedProperty(object, pathArr) {
+  return pathArr.reduce(
+    (nestedObject, key) => nestedObject && nestedObject[key] !== "undefined" ? nestedObject[key] : void 0,
+    object
+  );
+}
+function getNestedProperty2(object, path) {
+  const pathArray = path.split(".");
+  return getNestedProperty(object, pathArray);
+}
+function getNestedValue(object, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/arrays/sort.js
+function sort(array, { props = null, reverse = false } = {}) {
+  const clone = array.slice();
+  if (props === null) {
+    return clone.sort((a, b) => {
+      const comparison = compareValues(a, b);
+      return reverse ? -comparison : comparison;
+    });
+  }
+  const properties = Array.isArray(props) ? props : [props];
+  return clone.sort((a, b) => {
+    for (const property of properties) {
+      const aValue = getNestedValue(a, property);
+      const bValue = getNestedValue(b, property);
+      if (aValue === bValue) continue;
+      if (aValue == null) return 1;
+      if (bValue == null) return -1;
+      const comparison = compareValues(aValue, bValue);
+      return reverse ? -comparison : comparison;
+    }
+    return 0;
+  });
+}
+function compareValues(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+  const aDate = new Date(a);
+  const bDate = new Date(b);
+  const aTime = aDate.getTime();
+  const bTime = bDate.getTime();
+  if (!isNaN(aTime) && !isNaN(bTime)) return aTime - bTime;
+  return String(a).localeCompare(String(b));
+}
+
+// src/lib/arrays/split-array.js
+function splitArray(array, predicate) {
+  const ret = {
+    picked: [],
+    omitted: []
+  };
+  array.forEach((item, index, arr) => {
+    if (predicate(item, index, arr)) ret.picked.push(item);
+    else ret.omitted.push(item);
+  });
+  ret.p = ret.picked;
+  ret.o = ret.omitted;
+  return ret;
+}
+
+// src/lib/arrays/unique.js
+function uniqueArray(array) {
+  return Array.from(new Set(array));
+}
+
+// src/lib/auth/route-manager.js
+function RouteManager(config) {
+  const { protectedRoutes, bypassRoutes } = config;
+  return {
+    isProtectedRoute(pathname) {
+      return isMatch(protectedRoutes, pathname);
+    },
+    isBypassRoute(pathname) {
+      return isMatch(bypassRoutes, pathname);
+    }
+  };
+}
+function AuthManager(config) {
+  return RouteManager(config);
+}
+function isMatch(routeConfig, pathname) {
+  const { is, startsWith, includes } = routeConfig;
+  const isExactMatch = is && is.some((u) => pathname === u);
+  const startsWithMatch = startsWith && startsWith.some((u) => pathname.startsWith(u));
+  const includesMatch = includes && includes.some((u) => pathname.includes(u));
+  return isExactMatch || startsWithMatch || includesMatch;
+}
+
+// src/lib/checks.js
+function isObject(x) {
+  return typeof x === "object" && !Array.isArray(x) && x !== null;
+}
+function isArray(x) {
+  return Array.isArray(x);
+}
+function notObject(x) {
+  return !isObject(x);
+}
+function getType(x) {
+  if (typeof x === "string") return "string";
+  if (typeof x === "number") {
+    if (Number.isInteger(x)) return "integer";
+    return "float";
+  }
+  if (typeof x === "boolean") return "boolean";
+  if (typeof x === "function") return "function";
+  if (typeof x === "undefined") return "undefined";
+  if (typeof x === "symbol") return "symbol";
+  if (typeof x === "bigint") return "bigint";
+  if (Array.isArray(x)) return "array";
+  if (typeof x === "object") return "object";
+  return "unknown";
+}
+function isFunction(x) {
+  return typeof x === "function";
+}
+
+// src/lib/date/days.js
+var DAYS = [
+  { short: "Sun", long: "Sunday", numeric: 1 },
+  { short: "Mon", long: "Monday", numeric: 2 },
+  { short: "Tue", long: "Tuesday", numeric: 3 },
+  { short: "Wed", long: "Wednesday", numeric: 4 },
+  { short: "Thu", long: "Thursday", numeric: 5 },
+  { short: "Fri", long: "Friday", numeric: 6 },
+  { short: "Sat", long: "Saturday", numeric: 7 }
+];
+
+// src/lib/date/months.js
+var MONTHS = [
+  {
+    long: "January",
+    short: "jan",
+    numeric: 1,
+    lastDay: { default: 31, leapYear: 31 }
+  },
+  {
+    long: "February",
+    short: "feb",
+    numeric: 2,
+    lastDay: { default: 28, leapYear: 29 }
+  },
+  {
+    long: "March",
+    short: "mar",
+    numeric: 3,
+    lastDay: { default: 31, leapYear: 31 }
+  },
+  {
+    long: "April",
+    short: "apr",
+    numeric: 4,
+    lastDay: { default: 30, leapYear: 30 }
+  },
+  {
+    long: "May",
+    short: "may",
+    numeric: 5,
+    lastDay: { default: 31, leapYear: 31 }
+  },
+  {
+    long: "June",
+    short: "jun",
+    numeric: 6,
+    lastDay: { default: 30, leapYear: 30 }
+  },
+  {
+    long: "July",
+    short: "jul",
+    numeric: 7,
+    lastDay: { default: 31, leapYear: 31 }
+  },
+  {
+    long: "August",
+    short: "aug",
+    numeric: 8,
+    lastDay: { default: 31, leapYear: 31 }
+  },
+  {
+    long: "September",
+    short: "sep",
+    numeric: 9,
+    lastDay: { default: 30, leapYear: 30 }
+  },
+  {
+    long: "October",
+    short: "oct",
+    numeric: 10,
+    lastDay: { default: 31, leapYear: 31 }
+  },
+  {
+    long: "November",
+    short: "nov",
+    numeric: 11,
+    lastDay: { default: 30, leapYear: 30 }
+  },
+  {
+    long: "December",
+    short: "dec",
+    numeric: 12,
+    lastDay: { default: 31, leapYear: 31 }
+  }
+];
+
+// src/lib/numbers/math.js
+function toDegrees(angle) {
+  return angle * (180 / Math.PI);
+}
+function toRadians(angle) {
+  return angle * (Math.PI / 180);
+}
+
+// src/lib/numbers/index.js
+function splitUnit(string) {
+  if (typeof string === "number") return [string, null];
+  const regex = /(-?\d*\.?\d+)\s*([a-z]+)/i;
+  const match = string.match(regex);
+  if (match) return [parseFloat(match[1]), match[2]];
+  return [parseFloat(string), null];
+}
+
+// src/lib/date/time.js
+function ms(arg) {
+  const [value, unit] = splitUnit(arg);
+  if (unit === "d") return getTimeInMs(value, "days");
+  if (unit === "day") return getTimeInMs(value, "days");
+  if (unit === "days") return getTimeInMs(value, "days");
+  if (unit === "h") return getTimeInMs(value, "hours");
+  if (unit === "hr") return getTimeInMs(value, "hours");
+  if (unit === "hour") return getTimeInMs(value, "hours");
+  if (unit === "hours") return getTimeInMs(value, "hours");
+  if (unit === "m") return getTimeInMs(value, "minutes");
+  if (unit === "min") return getTimeInMs(value, "minutes");
+  if (unit === "mins") return getTimeInMs(value, "minutes");
+  if (unit === "minute") return getTimeInMs(value, "minutes");
+  if (unit === "minutes") return getTimeInMs(value, "minutes");
+  if (unit === "s") return getTimeInMs(value, "seconds");
+  if (unit === "sec") return getTimeInMs(value, "seconds");
+  if (unit === "secs") return getTimeInMs(value, "seconds");
+  if (unit === "second") return getTimeInMs(value, "seconds");
+  if (unit === "seconds") return getTimeInMs(value, "seconds");
+  return value;
+}
+function getTimeInMs(value, unit = "ms") {
+  switch (unit) {
+    case "ms":
+      return value;
+    case "seconds":
+      return value * 1e3;
+    case "minutes":
+      return value * 1e3 * 60;
+    case "hours":
+      return value * 1e3 * 60 * 60;
+    case "days":
+      return value * 1e3 * 60 * 60 * 24;
+    case "weeks":
+      return value * 1e3 * 60 * 60 * 24 * 7;
+  }
+}
+function toWeeks(ms2) {
+  return ms2 / 1e3 / 60 / 60 / 24 / 7;
+}
+function toDays(ms2) {
+  return ms2 / 1e3 / 60 / 60 / 24;
+}
+function toHours(ms2) {
+  return ms2 / 1e3 / 60 / 60;
+}
+function toMinutes(ms2) {
+  return ms2 / 1e3 / 60;
+}
+function toSeconds(ms2) {
+  return ms2 / 1e3;
+}
+function toReadableTime(ms2) {
+  const weekMs = 1e3 * 60 * 60 * 24 * 7;
+  const dayMs = 1e3 * 60 * 60 * 24;
+  const hourMs = 1e3 * 60 * 60;
+  const minuteMs = 1e3 * 60;
+  const weeks = Math.floor(ms2 / weekMs);
+  const days = Math.floor(ms2 % weekMs / dayMs);
+  const hours = Math.floor(ms2 % dayMs / hourMs);
+  const minutes = Math.floor(ms2 % hourMs / minuteMs);
+  const seconds = Math.floor(ms2 % minuteMs / 1e3);
+  return { weeks, days, hours, minutes, seconds };
+}
+
+// src/lib/form/form-data.js
+function formDataToObject(formData) {
+  const obj = {};
+  for (let [key, value] of formData) {
+    if (typeof value === "string") value = value.trim();
+    if (key.includes("[]")) {
+      const arrayKey = key.replace("[]", "");
+      if (!obj[arrayKey]) obj[arrayKey] = [];
+      obj[arrayKey].push(value);
+    } else {
+      obj[key] = value;
+    }
+  }
+  return obj;
+}
+function flattenArrayFields(inputObject) {
+  const result = {};
+  for (const [key, value] of Object.entries(inputObject)) {
+    const match = key.match(/^(\w+)(?:\[(\d+)\])?(?:\[(\w+)\])?$/);
+    if (match) {
+      const [, baseKey, index, property] = match;
+      if (index !== void 0) {
+        if (!result[baseKey]) result[baseKey] = [];
+        const arrayIndex = parseInt(index);
+        if (!result[baseKey][arrayIndex]) result[baseKey][arrayIndex] = {};
+        if (property) {
+          result[baseKey][arrayIndex][property] = value;
+        } else {
+          result[baseKey][arrayIndex] = value;
+        }
+      } else if (property) {
+        if (!result[baseKey]) result[baseKey] = {};
+        result[baseKey][property] = value;
+      } else {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  for (const key in result) {
+    if (typeof result[key] === "object" && result[key] !== null) {
+      if (Object.keys(result[key]).every((k) => !isNaN(parseInt(k)))) {
+        result[key] = Object.values(result[key]).filter((item) => {
+          if (typeof item === "object") {
+            return Object.values(item).some((v) => v !== "");
+          }
+          return item !== "";
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// src/lib/form/sanitize.js
+function sanitize(value, options = {}) {
+  const { sanitizer, ...rest } = options;
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  if (typeof value === "string") return sanitizer(value, rest);
+  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest });
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        key,
+        sanitize(val, { sanitizer, ...rest })
+      ])
+    );
+  }
+  return value;
+}
+function sanitizeArray(arr, { sanitizer, ...rest }) {
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  return arr.map((item) => sanitize(item, { sanitizer, ...rest }));
+}
+function sanitizeObject(obj, { sanitizer, ...options } = {}) {
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  if (Array.isArray(obj)) return sanitizeArray(obj, { sanitizer, ...options });
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => [
+      key,
+      sanitize(value, { sanitizer, ...options })
+    ])
+  );
+}
+
+// src/lib/functions/debounce.js
+function debounce(callback, wait2, immediate = false) {
+  let timeout2;
+  return function() {
+    const context = this;
+    const args = arguments;
+    const callNow = immediate && !timeout2;
+    clearTimeout(timeout2);
+    timeout2 = setTimeout(later, wait2);
+    if (callNow) callback.apply(context, args);
+    function later() {
+      timeout2 = null;
+      if (!immediate) callback.apply(context, args);
+    }
+  };
+}
+
+// src/lib/functions/env.js
+function getEnv() {
+  if (typeof window === "object") return "browser";
+  if (typeof global === "object") return "node";
+}
+
+// src/lib/functions/functional.js
+function curry(fn) {
+  return function curried(...args) {
+    if (args.length >= fn.length) {
+      return fn.apply(this, args);
+    } else {
+      return function(...moreArgs) {
+        return curried.apply(this, args.concat(moreArgs));
+      };
+    }
+  };
+}
+function compose(...fns) {
+  return function(value) {
+    return fns.reduceRight((acc, fn) => fn(acc), value);
+  };
+}
+function composeAsync(...fns) {
+  return async function(value) {
+    return fns.reduceRight(async (acc, fn) => {
+      const result = await acc;
+      return await fn(result);
+    }, value);
+  };
+}
+function pipe(...fns) {
+  return function(value) {
+    return fns.reduce((acc, fn) => fn(acc), value);
+  };
+}
+function pipeAsync(...fns) {
+  return async function(value) {
+    return fns.reduce(async (acc, fn) => {
+      const result = await acc;
+      return await fn(result);
+    }, value);
+  };
+}
+function times(fn, n) {
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    result.push(fn(i));
+  }
+  return result;
+}
+
+// src/lib/functions/throttle.js
+function throttle(callback, wait2) {
+  let lastCall = 0;
+  return function(...args) {
+    const now = (/* @__PURE__ */ new Date()).getTime();
+    if (now - lastCall >= wait2) {
+      callback(...args);
+      lastCall = now;
+    }
+  };
+}
+
+// src/lib/functions/timeout.js
+function timeout(wait2, callback) {
+  setTimeout(callback, wait2);
+}
+function delay(ms2) {
+  return new Promise((resolve) => setTimeout(resolve, ms2));
+}
+function wait(ms2) {
+  return delay(ms2);
+}
+
+// src/lib/hash.js
+function isHashedValue(value, type = "sha256") {
+  if (typeof value !== "string") return null;
+  value = value.trim();
+  type = type.toLowerCase();
+  if (type === "sha256") {
+    return value.length === 64 && /^[a-fA-F0-9]{64}$/.test(value);
+  }
+  if (type === "sha1") {
+    return value.length === 40 && /^[a-fA-F0-9]{40}$/.test(value);
+  }
+  if (type === "md5") {
+    return value.length === 32 && /^[a-fA-F0-9]{32}$/.test(value);
+  }
+  return null;
+}
+
+// src/lib/objects/loop.js
+function objectForEach(object, callback) {
+  Object.entries(object).forEach(([key, value]) => {
+    callback({ key, value });
+  });
+}
+function objectMap(object, callback) {
+  return Object.entries(object).map(([key, value]) => {
+    return callback({ key, value });
+  });
+}
+
+// src/lib/strings/convert-case/convert-case.js
+function toKebab(string) {
+  if (!string) return "";
+  return string.split("").map((letter, index) => {
+    const previousLetter = string[index - 1] || "";
+    const currentLetter = letter;
+    if (isDigit(currentLetter) && !isDigit(previousLetter)) {
+      return `-${currentLetter}`;
+    }
+    if (!isCaps(currentLetter)) return currentLetter;
+    if (previousLetter === "") {
+      return `${currentLetter.toLowerCase()}`;
+    }
+    if (isCaps(previousLetter)) {
+      return `${currentLetter.toLowerCase()}`;
+    }
+    return `-${currentLetter.toLowerCase()}`;
+  }).join("").trim().replace(/[-_\s]+/g, "-");
+}
+function toCamel(string) {
+  return toKebab(string).split("-").map((word, index) => {
+    if (index === 0) return word;
+    return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
+  }).join("");
+}
+function toPascal(string) {
+  const camel = toCamel(string);
+  return camel.slice(0, 1).toUpperCase() + camel.slice(1);
+}
+function toTitle(string) {
+  return toKebab(string).split("-").map((word) => {
+    return word.slice(0, 1).toUpperCase() + word.slice(1);
+  }).join(" ");
+}
+function toSlug(string) {
+  return toKebab(string);
+}
+function toSentence(string) {
+  const interim = toKebab(string).replace(/-/g, " ");
+  return interim.slice(0, 1).toUpperCase() + interim.slice(1);
+}
+function toUpper(string) {
+  const interim = toKebab(string).replace(/-/g, " ");
+  return interim.toUpperCase();
+}
+function toLower(string) {
+  const interim = toKebab(string).replace(/-/g, " ");
+  return interim.toLowerCase();
+}
+function isCaps(char) {
+  return /\p{Lu}/u.test(char);
+}
+function isDigit(char) {
+  return /[0-9]/.test(char);
+}
+
+// src/lib/objects/camelcase-keys.js
+function camelCaseKeys(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  const result = {};
+  objectForEach(obj, ({ key, value }) => {
+    const camelCaseKey = toCamel(key);
+    result[camelCaseKey] = camelCaseKeys(value);
+  });
+  return result;
+}
+
+// src/lib/objects/empty.js
+function isEmpty(obj) {
+  if (typeof obj === "undefined") return true;
+  if (obj === null) return true;
+  if (Array.isArray(obj)) return obj.length === 0;
+  return Object.keys(obj).length === 0;
+}
+function notEmpty(obj) {
+  return !isEmpty(obj);
+}
+
+// src/lib/objects/equal.js
+var import_deep_eql = __toESM(require("deep-eql"), 1);
+function isEqual(a, b) {
+  return (0, import_deep_eql.default)(a, b);
+}
+function notEqual(a, b) {
+  return !isEqual(a, b);
+}
+
+// src/lib/objects/mix/mix.js
+var DEFAULT_OPTIONS = { array: "replace" };
+var mix = createMix();
+var concatMix = createMix({ array: "concat" });
+function createMix(userOptions = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...userOptions };
+  function _mix(...sources) {
+    const result = {};
+    for (const source of sources) {
+      if (source == null) continue;
+      merge(result, source, options);
+    }
+    return result;
+  }
+  return _mix;
+}
+function merge(output, input, options) {
+  const props = Object.keys(input);
+  for (const prop of props) {
+    if (prop === "__proto__") continue;
+    const descriptor = Object.getOwnPropertyDescriptor(input, prop);
+    const value = descriptor.value;
+    if (value) descriptor.value = cloneDescriptorValue(value);
+    if (!output[prop]) {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (typeof output[prop] !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (descriptor.value == null || typeof descriptor.value !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (objectType(descriptor.value) === "[object Array]") {
+      output[prop] = options.array === "replace" ? descriptor.value.slice() : output[prop].concat(descriptor.value);
+      continue;
+    }
+    merge(output[prop], descriptor.value, options);
+  }
+}
+function cloneDescriptorValue(value) {
+  if (objectType(value) === "[object Array]") {
+    const array = [];
+    for (let v of value) {
+      v = cloneDescriptorValue(v);
+      array.push(v);
+    }
+    return array;
+  }
+  if (objectType(value) === "[object Object]") {
+    const obj = {};
+    const props = Object.keys(value);
+    for (const prop of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, prop);
+      if (descriptor.value)
+        descriptor.value = cloneDescriptorValue(descriptor.value);
+      Object.defineProperty(obj, prop, descriptor);
+    }
+    return obj;
+  }
+  if (objectType(value) === "[object Date]") {
+    return new Date(value.getTime());
+  }
+  if (objectType(value) === "[object Map]") {
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of value) {
+      map.set(entry[0], cloneDescriptorValue(entry[1]));
+    }
+    return map;
+  }
+  if (objectType(value) === "[object Set]") {
+    const set = /* @__PURE__ */ new Set();
+    for (const entry of value.entries()) {
+      set.add(cloneDescriptorValue(entry[0]));
+    }
+    return set;
+  }
+  return value;
+}
+function objectType(value) {
+  return Object.prototype.toString.call(value);
+}
+
+// src/lib/objects/extend.js
+function extendObject(object) {
+  const orig = object;
+  const extended = mix({}, object);
+  extended.forEach = curry(objectForEach)(orig);
+  extended.map = curry(objectMap)(orig);
+  return { orig, extended };
+}
+
+// src/lib/objects/flatten.js
+function flattenObject(obj, { separator, prefix = "" }) {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newKey = prefix ? `${prefix}${separator}${key}` : key;
+    const isAnObject = isObject(value);
+    const hasNestedObject = isAnObject && Object.values(value).some(isObject);
+    if (hasNestedObject) {
+      Object.assign(acc, flattenObject(value, { separator, prefix: newKey }));
+    } else {
+      acc[newKey] = value;
+    }
+    return acc;
+  }, {});
+}
+
+// src/lib/objects/json.js
+function parseJSON(value, defaultValue = {}) {
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+// src/lib/objects/omit-empty.js
+function omitEmpty(obj, shallow = false) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (obj instanceof Date) return obj;
+  const result = Array.isArray(obj) ? [] : {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === void 0 || value === "" || typeof value === "object" && !(value instanceof Date) && Object.keys(value).length === 0) {
+      continue;
+    }
+    result[key] = shallow ? value : omitEmpty(value);
+  }
+  return result;
+}
+
+// src/lib/objects/normalize-object.js
+function normalizeObject(object) {
+  return pipe(omitEmpty, camelCaseKeys)(object);
+}
+
+// src/lib/objects/size.js
+function sizeOf(obj) {
+  let bytes = 0;
+  function size(obj2) {
+    if (obj2 !== null && obj2 !== void 0) {
+      switch (typeof obj2) {
+        case "number":
+          bytes += 8;
+          break;
+        case "string":
+          bytes += obj2.length * 2;
+          break;
+        case "boolean":
+          bytes += 4;
+          break;
+        case "object":
+          const objClass = Object.prototype.toString.call(obj2).slice(8, -1);
+          if (objClass === "Object" || objClass === "Array") {
+            for (const key in obj2) {
+              if (!obj2.hasOwnProperty(key)) continue;
+              size(obj2[key]);
+            }
+          } else bytes += obj2.toString().length * 2;
+          break;
+      }
+    }
+    return bytes;
+  }
+  function formatByteSize(bytes2) {
+    if (bytes2 < 1024) return bytes2 + " bytes";
+    else if (bytes2 < 1048576) return (bytes2 / 1024).toFixed(3) + " KiB";
+    else if (bytes2 < 1073741824) return (bytes2 / 1048576).toFixed(3) + " MiB";
+    else return (bytes2 / 1073741824).toFixed(3) + " GiB";
+  }
+  return formatByteSize(size(obj));
+}
+
+// src/lib/objects/split.js
+function splitObject(obj, keys) {
+  const picked = {};
+  const omitted = { ...obj };
+  keys.forEach((key) => {
+    if (key in obj) {
+      picked[key] = obj[key];
+      delete omitted[key];
+    }
+  });
+  return { picked, omitted, p: picked, o: omitted };
+}
+
+// src/lib/promises/reject.js
+var import_statuses = __toESM(require("statuses"), 1);
+function reject(props, { includeStack = true } = {}) {
+  const { status, statusText, body, message } = props;
+  const e = new Error();
+  const err = {
+    status,
+    statusText: statusText || status && (0, import_statuses.default)(status),
+    body,
+    message,
+    stack: includeStack && e.stack
+  };
+  return Promise.reject(omitEmpty(err));
+}
+
+// src/lib/sse.js
+function createSSE({ event, data, id, retry }) {
+  const eventString = event ? `event: ${event}
+` : "";
+  const idString = id ? `id: ${id}
+` : "";
+  const retryString = retry ? `retry: ${retry}
+` : "";
+  if (typeof data === "object") data = JSON.stringify(data);
+  const dataString = data ? `data: ${data}
+` : "";
+  return `${eventString}${dataString}${idString}${retryString}
+`;
+}
+function parseSSE(message) {
+  const lines = message.split("\n");
+  const result = {
+    event: "message",
+    // Default event type
+    data: "",
+    id: null,
+    retry: null
+  };
+  for (const line of lines) {
+    if (line.startsWith("data:")) {
+      const data = line.slice(5).trim();
+      result.data = parseJSON(data);
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      result.event = line.slice(6).trim();
+      continue;
+    }
+    if (line.startsWith("id:")) {
+      result.id = line.slice(3).trim();
+      continue;
+    }
+    if (line.startsWith("retry:")) {
+      result.retry = parseInt(line.slice(6).trim(), 10);
+      continue;
+    }
+  }
+  const ret = omitEmpty(result);
+  return ret.data ? ret : null;
+}
+
+// src/lib/strings/markdown.js
+var import_markdown_it = __toESM(require("markdown-it"), 1);
+var import_markdown_it_anchor = __toESM(require("markdown-it-anchor"), 1);
+var md = (0, import_markdown_it.default)({
+  html: true,
+  linkify: true,
+  typographer: true
+});
+md.use(import_markdown_it_anchor.default, {
+  permalink: false,
+  slugify: (s) => s.toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]/g, "")
+});
+function markdown(content, options = {}) {
+  const defaultOptions = { inline: false };
+  const opts = { ...defaultOptions, ...options };
+  const { content: treated } = treatMarkdownWhitespace(content, opts);
+  if (opts.inline) return md.renderInline(treated);
+  return md.render(treated);
+}
+function treatMarkdownWhitespace(content, { inline } = {}) {
+  if (!content) return { content: "", inline };
+  const lines = content.split("\n");
+  if (lines[0] !== "" && inline) return { content, inline: true };
+  const firstLineWithLeadingSpacesIndex = lines.findIndex(
+    (line) => line.match(/^\s+/)
+  );
+  const firstLineWithLeadingSpaces = lines[firstLineWithLeadingSpacesIndex];
+  const indentation = firstLineWithLeadingSpaces?.match(/^\s+/)?.[0]?.length ?? 0;
+  const retContent = lines.map((line, index) => {
+    if (index < firstLineWithLeadingSpacesIndex) return line + "\n";
+    return line.slice(indentation) + "\n";
+  }).join("");
+  return {
+    content: retContent,
+    inline
+  };
+}
+
+// src/lib/strings/name.js
+function parseFullName(name) {
+  const parts = name.trim().split(/\s+/);
+  if (parts.length === 1) {
+    return { firstName: parts[0], middleName: "", lastName: "" };
+  }
+  if (parts.length === 2) {
+    return { firstName: parts[0], middleName: "", lastName: parts[1] };
+  }
+  if (parts.length === 3) {
+    const firstName2 = parts.slice(0, 2).join(" ");
+    const lastName2 = parts[2];
+    return { firstName: firstName2, middleName: "", lastName: lastName2 };
+  }
+  const firstName = parts.slice(0, 2).join(" ");
+  const lastName = parts[parts.length - 1];
+  const middleName = parts.slice(2, -1).join(" ");
+  return { firstName, middleName, lastName };
+}
+
+// src/lib/strings/pluralize.js
+var import_pluralize = __toESM(require("pluralize"), 1);
+var pluralize = import_pluralize.default;
+
+// src/lib/strings/query-string.js
+function toQueryString(object) {
+  const searchParams = new URLSearchParams(object);
+  return searchParams.toString();
+}
+function plural(count, noun, suffix = "s") {
+  console.warn("plural is deprecated. Use pluralize instead");
+  return `${count} ${noun}${count !== 1 ? suffix : ""}`;
+}
+function stripNumbers(string) {
+  return string.replace(/\d*/, "");
+}
+
+// src/lib/style/index.js
+function toStyleString(style) {
+  if (!style) return null;
+  if (typeof style === "string") return style;
+  return Object.entries(style).map(([k, v]) => {
+    if (k.startsWith("--")) return `${k}:${v}`;
+    else return `${toKebab(k)}:${v}`;
+  }).join("; ").concat(";");
+}
+
+// src/lib/symbols/symbols.js
+function getSymbol(object, description) {
+  return Object.getOwnPropertySymbols(object).find(
+    (s) => s.description === description
+  );
+}
+function getSymbolValue(object, description) {
+  return object[getSymbol(object, description)];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthManager,
+  DAYS,
+  MONTHS,
+  RouteManager,
+  camelCaseKeys,
+  compose,
+  composeAsync,
+  concatMix,
+  createMix,
+  createSSE,
+  curry,
+  debounce,
+  delay,
+  extendObject,
+  flattenArrayFields,
+  flattenObject,
+  formDataToObject,
+  getEnv,
+  getNestedProperty,
+  getNestedProperty2,
+  getNestedValue,
+  getSymbol,
+  getSymbolValue,
+  getTimeInMs,
+  getType,
+  isArray,
+  isEmpty,
+  isEqual,
+  isFunction,
+  isHashedValue,
+  isLastItem,
+  isObject,
+  joinWithConjunction,
+  last,
+  lastArrayItem,
+  markdown,
+  mix,
+  ms,
+  normalizeObject,
+  notEmpty,
+  notEqual,
+  notObject,
+  objectForEach,
+  objectMap,
+  omitEmpty,
+  parseFullName,
+  parseJSON,
+  parseSSE,
+  pipe,
+  pipeAsync,
+  plural,
+  pluralize,
+  reject,
+  sanitize,
+  sanitizeArray,
+  sanitizeObject,
+  shuffle,
+  sizeOf,
+  sort,
+  splitArray,
+  splitObject,
+  splitUnit,
+  stripNumbers,
+  throttle,
+  timeout,
+  times,
+  toCamel,
+  toDays,
+  toDegrees,
+  toHours,
+  toKebab,
+  toLower,
+  toMinutes,
+  toPascal,
+  toQueryString,
+  toRadians,
+  toReadableTime,
+  toSeconds,
+  toSentence,
+  toSlug,
+  toStyleString,
+  toTitle,
+  toUpper,
+  toWeeks,
+  treatMarkdownWhitespace,
+  uniqueArray,
+  wait
+});