@zairakai/js-utils 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2906 @@
+"use strict";
+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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiResponseSchema: () => ApiResponseSchema,
+  DateSchema: () => DateSchema,
+  EmailSchema: () => EmailSchema,
+  EnhancedArray: () => EnhancedArray,
+  EnhancedMap: () => EnhancedMap,
+  NumberHelper: () => NumberHelper,
+  Numberable: () => Numberable,
+  Obj: () => Obj,
+  Objectable: () => Objectable,
+  PaginatedResponseSchema: () => PaginatedResponseSchema,
+  PaginationSchema: () => PaginationSchema,
+  PhoneSchema: () => PhoneSchema,
+  Str: () => Str,
+  Stringable: () => Stringable,
+  UrlSchema: () => UrlSchema,
+  ValidationInstance: () => ValidationInstance,
+  Validator: () => Validator,
+  arrayAdd: () => arrayAdd,
+  arrayCollapse: () => arrayCollapse,
+  arrayDivide: () => arrayDivide,
+  arrayDot: () => arrayDot,
+  arrayExcept: () => arrayExcept,
+  arrayFirst: () => arrayFirst,
+  arrayFlatten: () => arrayFlatten,
+  arrayGet: () => arrayGet,
+  arrayGroupBy: () => arrayGroupBy,
+  arrayHas: () => arrayHas,
+  arrayOnly: () => arrayOnly,
+  arrayPluck: () => arrayPluck,
+  arrayUnique: () => arrayUnique,
+  arrayWhere: () => arrayWhere,
+  array_chunk: () => array_chunk,
+  array_column: () => array_column,
+  array_count_values: () => array_count_values,
+  array_diff: () => array_diff,
+  array_filter: () => array_filter,
+  array_flip: () => array_flip,
+  array_intersect: () => array_intersect,
+  array_key_exists: () => array_key_exists,
+  array_keys: () => array_keys,
+  array_map: () => array_map,
+  array_merge: () => array_merge,
+  array_pop: () => array_pop,
+  array_product: () => array_product,
+  array_push: () => array_push,
+  array_rand: () => array_rand,
+  array_reduce: () => array_reduce,
+  array_reverse: () => array_reverse,
+  array_search: () => array_search,
+  array_shift: () => array_shift,
+  array_slice: () => array_slice,
+  array_splice: () => array_splice,
+  array_sum: () => array_sum,
+  array_unique: () => array_unique,
+  array_unshift: () => array_unshift,
+  blank: () => blank,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  collect: () => collect,
+  collectMap: () => collectMap,
+  data_get: () => data_get,
+  data_set: () => data_set,
+  dayjs: () => dayjs,
+  diff: () => diff,
+  filled: () => filled,
+  fromNow: () => fromNow,
+  isArray: () => isArray,
+  isBase64: () => isBase64,
+  isBetweenDates: () => isBetweenDates,
+  isBlank: () => isBlank,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isEqual: () => isEqual,
+  isEven: () => isEven,
+  isFalse: () => isFalse,
+  isFloat: () => isFloat,
+  isFunction: () => isFunction,
+  isFuture: () => isFuture,
+  isInteger: () => isInteger,
+  isIp: () => isIp,
+  isJson: () => isJson,
+  isMacAddress: () => isMacAddress,
+  isNotEmpty: () => isNotEmpty,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isNumeric: () => isNumeric,
+  isObject: () => isObject,
+  isOdd: () => isOdd,
+  isPast: () => isPast,
+  isPresent: () => isPresent,
+  isRecord: () => isRecord,
+  isSet: () => isSet,
+  isString: () => isString,
+  isToday: () => isToday,
+  isTrue: () => isTrue,
+  isUndefined: () => isUndefined,
+  isUrl: () => isUrl,
+  isUuid: () => isUuid,
+  kebabCase: () => kebabCase,
+  mapToObject: () => mapToObject,
+  normalizeString: () => normalizeString,
+  now: () => now,
+  num: () => num,
+  numberFormat: () => numberFormat,
+  obj: () => obj,
+  objectToMap: () => objectToMap,
+  optional: () => optional,
+  php_array: () => php_array,
+  pipe: () => pipe,
+  range: () => range,
+  retry: () => retry,
+  rsort: () => rsort,
+  safeValidateSchema: () => safeValidateSchema,
+  shuffle: () => shuffle,
+  slugify: () => slugify,
+  snakeCase: () => snakeCase,
+  sort: () => sort,
+  str: () => str,
+  strContainsAll: () => strContainsAll,
+  strContainsAny: () => strContainsAny,
+  strFinish: () => strFinish,
+  strLimit: () => strLimit,
+  strMask: () => strMask,
+  strPadBoth: () => strPadBoth,
+  strPadLeft: () => strPadLeft,
+  strPadRight: () => strPadRight,
+  strRemove: () => strRemove,
+  strReverse: () => strReverse,
+  strStart: () => strStart,
+  strWordCount: () => strWordCount,
+  strWords: () => strWords,
+  studlyCase: () => studlyCase,
+  tap: () => tap,
+  throw_if: () => throw_if,
+  throw_unless: () => throw_unless,
+  titleCase: () => titleCase,
+  today: () => today,
+  tomorrow: () => tomorrow,
+  uasort: () => uasort,
+  uksort: () => uksort,
+  usort: () => usort,
+  validateSchema: () => validateSchema,
+  validator: () => validator,
+  value: () => value,
+  when: () => when,
+  yesterday: () => yesterday
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/validators.ts
+var isTrue = (value2) => true === value2;
+var isFalse = (value2) => false === value2;
+var isNull = (value2) => null === value2;
+var isUndefined = (value2) => void 0 === value2;
+var isSet = (value2) => void 0 !== value2 && null !== value2;
+var isArray = (value2) => Array.isArray(value2);
+var isObject = (value2) => "object" === typeof value2 && null !== value2 && !Array.isArray(value2);
+var isString = (value2) => "string" === typeof value2;
+var isNumber = (value2) => "number" === typeof value2 && !isNaN(value2);
+var isInteger = (value2) => Number.isInteger(value2);
+var isFloat = (value2) => "number" === typeof value2 && !isNaN(value2) && !Number.isInteger(value2);
+var isBoolean = (value2) => "boolean" === typeof value2;
+var isFunction = (value2) => "function" === typeof value2;
+var isDate = (value2) => value2 instanceof Date && !isNaN(value2.getTime());
+var isNumeric = (value2) => {
+  if ("number" === typeof value2) {
+    return !isNaN(value2) && isFinite(value2);
+  }
+  if ("string" === typeof value2) {
+    const num2 = Number(value2.trim());
+    return "" !== value2.trim() && !isNaN(num2) && isFinite(num2);
+  }
+  return false;
+};
+var isEmail = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(value2);
+};
+var isUrl = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  try {
+    new URL(value2);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isEmpty = (value2) => {
+  if (isNull(value2) || isUndefined(value2)) {
+    return true;
+  }
+  if (isString(value2)) {
+    return 0 === value2.trim().length;
+  }
+  if (isArray(value2)) {
+    return 0 === value2.length;
+  }
+  if (isObject(value2)) {
+    return 0 === Object.keys(value2).length;
+  }
+  if (isNumber(value2)) {
+    return 0 === value2;
+  }
+  if (isBoolean(value2)) {
+    return isFalse(value2);
+  }
+  return false;
+};
+var isNotEmpty = (value2) => !isEmpty(value2);
+var isBlank = (value2) => {
+  if (value2 == null) {
+    return true;
+  }
+  if ("string" === typeof value2) {
+    return "" === value2.trim();
+  }
+  return isEmpty(value2);
+};
+var isPresent = (value2) => !isBlank(value2);
+var filled = (value2) => isPresent(value2);
+var blank = (value2) => isBlank(value2);
+var isEven = (value2) => {
+  return isNumber(value2) && 0 === value2 % 2;
+};
+var isOdd = (value2) => {
+  return isNumber(value2) && 0 !== value2 % 2;
+};
+var isJson = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  try {
+    JSON.parse(value2);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isBase64 = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  const base64Pattern = /^[A-Za-z0-9+/]*={0,2}$/;
+  if (0 !== value2.length % 4) {
+    return false;
+  }
+  return base64Pattern.test(value2);
+};
+var isMacAddress = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  const macPattern = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;
+  return macPattern.test(value2);
+};
+var isUuid = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value2);
+};
+var isIp = (value2) => {
+  if ("string" !== typeof value2) {
+    return false;
+  }
+  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+  if (ipv4.test(value2)) {
+    return value2.split(".").every((part) => {
+      const n = Number(part);
+      return n >= 0 && n <= 255 && String(n) === part;
+    });
+  }
+  const ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|(([0-9a-fA-F]{1,4}:){0,7}:)|(:[0-9a-fA-F]{1,4}){1,7}|(([0-9a-fA-F]{1,4}:){1,7}:)|(([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4})|::1)$/;
+  return ipv6.test(value2);
+};
+
+// src/formatters.ts
+var capitalize = (value2) => {
+  if (value2 == null) {
+    return "";
+  }
+  const stringValue = String(value2);
+  return stringValue.charAt(0).toUpperCase() + stringValue.slice(1).toLowerCase();
+};
+var slugify = (text) => {
+  if (!text) {
+    return "";
+  }
+  return text.toString().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/--+/g, "-");
+};
+var strLimit = (value2, size) => {
+  if (!value2) {
+    return "";
+  }
+  const stringValue = String(value2);
+  return stringValue.length <= size ? stringValue : `${stringValue.slice(0, size)}\u2026`;
+};
+var normalizeString = (value2) => {
+  if (!value2) {
+    return value2;
+  }
+  return value2.trim().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+};
+var strContainsAll = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.every((needle) => haystack.includes(needle));
+};
+var strContainsAny = (haystack, needles) => {
+  if (!haystack || !Array.isArray(needles)) {
+    return false;
+  }
+  return needles.some((needle) => haystack.includes(needle));
+};
+var strFinish = (value2, cap) => {
+  if (!value2) {
+    return cap;
+  }
+  if (!cap) {
+    return value2;
+  }
+  return value2.endsWith(cap) ? value2 : value2 + cap;
+};
+var strStart = (value2, prefix) => {
+  if (!value2) {
+    return prefix;
+  }
+  if (!prefix) {
+    return value2;
+  }
+  return value2.startsWith(prefix) ? value2 : prefix + value2;
+};
+var strPadBoth = (str2, length, pad = " ") => {
+  if (str2.length >= length) {
+    return str2;
+  }
+  const totalPad = length - str2.length;
+  const leftPad = Math.floor(totalPad / 2);
+  const rightPad = totalPad - leftPad;
+  return pad.repeat(leftPad) + str2 + pad.repeat(rightPad);
+};
+var strPadLeft = (str2, length, pad = " ") => {
+  return str2.padStart(length, pad);
+};
+var strPadRight = (str2, length, pad = " ") => {
+  return str2.padEnd(length, pad);
+};
+var strReverse = (value2) => {
+  return value2.split("").reverse().join("");
+};
+var strRemove = (search, subject, caseSensitive = true) => {
+  if (!search || !subject) {
+    return subject;
+  }
+  const flags = caseSensitive ? "g" : "gi";
+  return subject.replace(new RegExp(search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags), "");
+};
+var strMask = (str2, character, index, length) => {
+  if (!str2) {
+    return str2;
+  }
+  const start = Math.max(0, index);
+  const end = length !== void 0 ? start + length : str2.length;
+  return str2.substring(0, start) + character.repeat(end - start) + str2.substring(end);
+};
+var strWordCount = (str2, characters) => {
+  if (!str2) {
+    return 0;
+  }
+  const pattern = characters ? new RegExp(`[${characters}\\s]+`) : /\s+/;
+  return str2.trim().split(pattern).filter((word) => 0 < word.length).length;
+};
+var strWords = (value2, words = 100, end = "...") => {
+  if (!value2) {
+    return "";
+  }
+  const wordArray = value2.trim().split(/\s+/);
+  if (wordArray.length <= words) {
+    return value2;
+  }
+  return wordArray.slice(0, words).join(" ") + end;
+};
+var camelCase = (value2) => {
+  const studly = studlyCase(value2);
+  return studly.charAt(0).toLowerCase() + studly.slice(1);
+};
+var snakeCase = (value2) => {
+  return value2.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+};
+var kebabCase = (value2) => {
+  return value2.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+};
+var studlyCase = (value2) => {
+  return value2.replace(/[_-]/g, " ").replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase()).replace(/\s+/g, "");
+};
+var titleCase = (value2) => {
+  return value2.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+  });
+};
+var numberFormat = (value2, decimals = 2, locale = "en-US") => {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(value2);
+};
+
+// src/arrays.ts
+var arrayAdd = (array, key, value2) => {
+  const result = Array.isArray(array) ? Object.fromEntries(array.map((v, i) => [i, v])) : { ...array };
+  result[key] = value2;
+  return result;
+};
+var arrayCollapse = (array) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.reduce((flat, item) => {
+    if (Array.isArray(item)) {
+      return flat.concat(item);
+    }
+    return flat.concat([item]);
+  }, []);
+};
+var arrayDivide = (array) => {
+  if (!Array.isArray(array)) {
+    return [[], []];
+  }
+  const keys = array.map((_, index) => index.toString());
+  const values = [...array];
+  return [keys, values];
+};
+var arrayDot = (array, prepend = "") => {
+  const result = {};
+  for (const [key, value2] of Object.entries(array)) {
+    const newKey = prepend ? `${prepend}.${key}` : key;
+    if (value2 && "object" === typeof value2 && !Array.isArray(value2)) {
+      Object.assign(result, arrayDot(value2, newKey));
+    } else {
+      result[newKey] = value2;
+    }
+  }
+  return result;
+};
+var arrayExcept = (array, keys) => {
+  if (!Array.isArray(array) || !Array.isArray(keys)) {
+    return array;
+  }
+  return array.filter((_, index) => !keys.includes(index.toString()));
+};
+var arrayFirst = (array, callback, defaultValue) => {
+  if (!Array.isArray(array)) {
+    return defaultValue;
+  }
+  if (!callback) {
+    return 0 < array.length ? array[0] : defaultValue;
+  }
+  for (let i = 0; i < array.length; i++) {
+    if (callback(array[i], i)) {
+      return array[i];
+    }
+  }
+  return defaultValue;
+};
+var arrayFlatten = (array, depth = Infinity) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const flatten = (arr, currentDepth) => {
+    const result = [];
+    for (const item of arr) {
+      if (Array.isArray(item) && 0 < currentDepth) {
+        result.push(...flatten(item, currentDepth - 1));
+      } else {
+        result.push(item);
+      }
+    }
+    return result;
+  };
+  return flatten(array, depth);
+};
+var arrayGet = (array, key, defaultValue) => {
+  if (!array || "object" !== typeof array) {
+    return defaultValue;
+  }
+  const keys = key.split(".");
+  let current = array;
+  for (const k of keys) {
+    if (null === current || current === void 0 || "object" !== typeof current || !(k in current)) {
+      return defaultValue;
+    }
+    current = current[k];
+  }
+  return current;
+};
+var arrayHas = (array, keys) => {
+  if (!array || "object" !== typeof array) {
+    return false;
+  }
+  const keyArray = Array.isArray(keys) ? keys : [keys];
+  return keyArray.every((key) => {
+    const keyParts = key.split(".");
+    let current = array;
+    for (const part of keyParts) {
+      if (null === current || current === void 0 || "object" !== typeof current || !(part in current)) {
+        return false;
+      }
+      current = current[part];
+    }
+    return true;
+  });
+};
+var arrayOnly = (array, keys) => {
+  if (!Array.isArray(array) || !Array.isArray(keys)) {
+    return [];
+  }
+  return array.filter((_, index) => keys.includes(index.toString()));
+};
+var arrayWhere = (array, callback) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.filter(callback);
+};
+var arrayPluck = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  return array.map((item) => item && "object" === typeof item ? item[key] : void 0).filter((value2) => value2 !== void 0);
+};
+var arrayGroupBy = (array, keyOrFn) => {
+  if (!Array.isArray(array)) {
+    return {};
+  }
+  return array.reduce(
+    (groups, item) => {
+      const key = "function" === typeof keyOrFn ? String(keyOrFn(item)) : String(item && "object" === typeof item ? item[keyOrFn] : item);
+      if (!groups[key]) {
+        groups[key] = [];
+      }
+      groups[key].push(item);
+      return groups;
+    },
+    {}
+  );
+};
+var arrayUnique = (array, key) => {
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  if (!key) {
+    return [...new Set(array)];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return array.filter((item) => {
+    const value2 = item && "object" === typeof item ? item[key] : item;
+    if (seen.has(value2)) {
+      return false;
+    }
+    seen.add(value2);
+    return true;
+  });
+};
+
+// src/equals.ts
+var isEqual = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a && b && "object" === typeof a && "object" === typeof b) {
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    if (Array.isArray(a)) {
+      if (a.length !== b.length) {
+        return false;
+      }
+      for (let i = 0; i < a.length; i++) {
+        if (!isEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const [key, val] of a) {
+        if (!b.has(key) || !isEqual(val, b.get(key))) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size) {
+        return false;
+      }
+      for (const val of a) {
+        if (!b.has(val)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (a.constructor === RegExp) {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    if (a.valueOf !== Object.prototype.valueOf) {
+      return a.valueOf() === b.valueOf();
+    }
+    if (a.toString !== Object.prototype.toString) {
+      return a.toString() === b.toString();
+    }
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+      return false;
+    }
+    const bObj = b;
+    const aObj = a;
+    for (const key of keys) {
+      if (!Object.prototype.hasOwnProperty.call(bObj, key)) {
+        return false;
+      }
+      if (!isEqual(aObj[key], bObj[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+};
+var diff = (original, current) => {
+  const result = {};
+  if (isEqual(original, current)) {
+    return result;
+  }
+  if (!original || !current || "object" !== typeof original || "object" !== typeof current) {
+    return current || {};
+  }
+  const originalObj = original;
+  const currentObj = current;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(originalObj), ...Object.keys(currentObj)]);
+  for (const key of keys) {
+    if (!isEqual(originalObj[key], currentObj[key])) {
+      if (originalObj[key] && currentObj[key] && "object" === typeof originalObj[key] && "object" === typeof currentObj[key] && !Array.isArray(originalObj[key])) {
+        result[key] = diff(originalObj[key], currentObj[key]);
+      } else {
+        result[key] = currentObj[key];
+      }
+    }
+  }
+  return result;
+};
+
+// src/collections.ts
+var EnhancedArray = class _EnhancedArray extends Array {
+  /**
+   * Create a new EnhancedArray instance.
+   *
+   * @param {...T[]} items The items to initialize the collection with
+   */
+  constructor(...items) {
+    super(...items);
+    Object.setPrototypeOf(this, _EnhancedArray.prototype);
+    this.originalItems = structuredClone(items);
+  }
+  /**
+   * Determine if the collection has been modified since initialization or last sync.
+   *
+   * @returns {boolean} True if modified, false otherwise
+   */
+  isDirty() {
+    return !isEqual(this.originalItems, Array.from(this));
+  }
+  /**
+   * Determine if the collection is clean (not modified).
+   *
+   * @returns {boolean} True if not modified, false otherwise
+   */
+  isClean() {
+    return !this.isDirty();
+  }
+  /**
+   * Sync the original items with current items to mark the collection as clean.
+   *
+   * @returns {this} The collection instance
+   */
+  syncOriginal() {
+    this.originalItems = structuredClone(Array.from(this));
+    return this;
+  }
+  /**
+   * Compare with another array or collection for equality.
+   *
+   * @param {T[] | EnhancedArray<T>} other The array or collection to compare with
+   * @returns {boolean} True if equivalent, false otherwise
+   */
+  isEquivalent(other) {
+    return isEqual(Array.from(this), Array.from(other));
+  }
+  /**
+   * Create an EnhancedArray from an iterable or array-like object.
+   *
+   * @param {Iterable<T> | ArrayLike<T>} items The items to convert
+   * @returns {EnhancedArray<T>} A new EnhancedArray instance
+   */
+  static from(items) {
+    return new _EnhancedArray(...Array.from(items));
+  }
+  /**
+   * Create an EnhancedArray from a variable number of arguments.
+   *
+   * @param {...T[]} items The items to include
+   * @returns {EnhancedArray<T>} A new EnhancedArray instance
+   */
+  static of(...items) {
+    return new _EnhancedArray(...items);
+  }
+  // Laravel Collection inspired methods
+  /**
+   * Create a new collection instance from the current items.
+   *
+   * @returns {EnhancedArray<T>} A new EnhancedArray instance
+   */
+  collect() {
+    return new _EnhancedArray(...this);
+  }
+  /**
+   * Pluck an array of values from an array of objects.
+   *
+   * @param {K} key The key to pluck
+   * @returns {EnhancedArray<T[K]>} A new collection of plucked values
+   */
+  pluck(key) {
+    return new _EnhancedArray(
+      ...this.map((item) => item && "object" === typeof item ? item[key] : void 0).filter(
+        (val) => val !== void 0
+      )
+    );
+  }
+  /**
+   * Group the collection's items by a given key or callback.
+   *
+   * @param {K | Callback<T, string | number>} key The key or callback to group by
+   * @returns {Record<string, EnhancedArray<T>>} A record of grouped collections
+   */
+  groupBy(key) {
+    const groups = {};
+    for (let i = 0; i < this.length; i++) {
+      const item = this[i];
+      const groupKey = "function" === typeof key ? String(key(item, i)) : String(item && "object" === typeof item ? item[key] : item);
+      if (!groups[groupKey]) {
+        groups[groupKey] = new _EnhancedArray();
+      }
+      groups[groupKey].push(item);
+    }
+    return groups;
+  }
+  /**
+   * Return only unique items from the collection.
+   *
+   * @param {K} [key] Optional key to determine uniqueness for objects
+   * @returns {EnhancedArray<T>} A new collection of unique items
+   */
+  unique(key) {
+    if (!key) {
+      return new _EnhancedArray(...new Set(this));
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return new _EnhancedArray(
+      ...this.filter((item) => {
+        const value2 = item && "object" === typeof item ? item[key] : item;
+        if (seen.has(value2)) {
+          return false;
+        }
+        seen.add(value2);
+        return true;
+      })
+    );
+  }
+  /**
+   * Chunk the collection into smaller collections of a given size.
+   *
+   * @param {number} size The size of each chunk
+   * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+   */
+  chunk(size) {
+    const chunks = new _EnhancedArray();
+    for (let i = 0; i < this.length; i += size) {
+      chunks.push(new _EnhancedArray(...this.slice(i, i + size)));
+    }
+    return chunks;
+  }
+  // Advanced manipulation methods
+  /**
+   * Flatten a multi-dimensional collection into a single level.
+   *
+   * @param {number} [depth=Infinity] The depth to flatten to
+   * @returns {EnhancedArray<unknown>} A new flattened collection
+   */
+  deepFlatten(depth = Infinity) {
+    const flatten = (arr, currentDepth) => {
+      const result = [];
+      for (const item of arr) {
+        if (Array.isArray(item) && 0 < currentDepth) {
+          result.push(...flatten(item, currentDepth - 1));
+        } else {
+          result.push(item);
+        }
+      }
+      return result;
+    };
+    return new _EnhancedArray(...flatten(this, depth));
+  }
+  /**
+   * Rotate the collection by a given number of positions.
+   *
+   * @param {number} [positions=1] The number of positions to rotate
+   * @returns {EnhancedArray<T>} A new rotated collection
+   */
+  rotate(positions = 1) {
+    if (0 === this.length) {
+      return new _EnhancedArray();
+    }
+    const count = this.length;
+    positions = positions % count;
+    if (0 === positions) {
+      return this.collect();
+    }
+    if (0 > positions) {
+      positions = count + positions;
+    }
+    return new _EnhancedArray(...this.slice(positions), ...this.slice(0, positions));
+  }
+  /**
+   * Chunk the collection as long as the given predicate returns true.
+   *
+   * @param {Predicate<T>} predicate The predicate to check
+   * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+   */
+  chunkWhile(predicate) {
+    const chunks = new _EnhancedArray();
+    let currentChunk = new _EnhancedArray();
+    for (let i = 0; i < this.length; i++) {
+      const item = this[i];
+      if (0 < currentChunk.length && !predicate(item, i)) {
+        chunks.push(currentChunk);
+        currentChunk = new _EnhancedArray();
+      }
+      currentChunk.push(item);
+    }
+    if (0 < currentChunk.length) {
+      chunks.push(currentChunk);
+    }
+    return chunks;
+  }
+  /**
+   * Transpose the collection (swap rows and columns).
+   *
+   * @returns {EnhancedArray<EnhancedArray<unknown>>} A new transposed collection
+   */
+  transpose() {
+    if (0 === this.length) {
+      return new _EnhancedArray();
+    }
+    const maxLength = Math.max(...this.map((row) => Array.isArray(row) ? row.length : 1));
+    const result = new _EnhancedArray();
+    for (let i = 0; i < maxLength; i++) {
+      const column = new _EnhancedArray(
+        ...this.map((row) => {
+          if (Array.isArray(row)) {
+            return row[i] ?? null;
+          }
+          return 0 === i ? row : null;
+        })
+      );
+      result.push(column);
+    }
+    return result;
+  }
+  // Validation methods
+  /**
+   * Check if the collection is sorted.
+   *
+   * @param {Function} [compareFn] Optional comparison function
+   * @returns {boolean} True if sorted, false otherwise
+   */
+  isSorted(compareFn) {
+    if (1 >= this.length) {
+      return true;
+    }
+    for (let i = 1; i < this.length; i++) {
+      const prev = this[i - 1];
+      const current = this[i];
+      if (compareFn) {
+        if (0 < compareFn(prev, current)) {
+          return false;
+        }
+      } else {
+        if (prev > current) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if the collection contains duplicate items.
+   *
+   * @param {K} [key] Optional key to check for uniqueness in objects
+   * @returns {boolean} True if duplicates found, false otherwise
+   */
+  hasDuplicates(key) {
+    if (key) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of this) {
+        const value2 = item && "object" === typeof item ? item[key] : item;
+        if (seen.has(value2)) {
+          return true;
+        }
+        seen.add(value2);
+      }
+      return false;
+    }
+    return this.length !== new Set(this).size;
+  }
+  // Statistical methods
+  /**
+   * Calculate the median value of the collection.
+   *
+   * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+   * @returns {number | null} The median value or null if collection is empty
+   */
+  median(accessor) {
+    if (0 === this.length) {
+      return null;
+    }
+    const values = accessor ? this.map(accessor) : this;
+    const sorted = [...values].sort((a, b) => a - b);
+    const count = sorted.length;
+    if (0 === count % 2) {
+      return (sorted[count / 2 - 1] + sorted[count / 2]) / 2;
+    }
+    return sorted[Math.floor(count / 2)];
+  }
+  /**
+   * Calculate the mode (most frequent values) of the collection.
+   *
+   * @param {Callback<T, unknown>} [accessor] Optional accessor for the values
+   * @returns {EnhancedArray<unknown>} A collection of mode values
+   */
+  mode(accessor) {
+    if (0 === this.length) {
+      return new _EnhancedArray();
+    }
+    const frequencies = this.frequencies(accessor);
+    const maxFrequency = Math.max(...Object.values(frequencies));
+    return new _EnhancedArray(...Object.keys(frequencies).filter((key) => frequencies[key] === maxFrequency));
+  }
+  /**
+   * Calculate the standard deviation of the collection.
+   *
+   * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+   * @returns {number} The standard deviation
+   */
+  standardDeviation(accessor) {
+    if (0 === this.length) {
+      return 0;
+    }
+    const values = accessor ? this.map(accessor) : this;
+    const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
+    const sumSquaredDifferences = values.reduce(
+      (sum, val) => sum + Math.pow(val - mean, 2),
+      0
+    );
+    return Math.sqrt(sumSquaredDifferences / values.length);
+  }
+  /**
+   * Calculate a specific percentile of the collection.
+   *
+   * @param {number} percentile The percentile to calculate (0-100)
+   * @param {Callback<T, number>} [accessor] Optional accessor for non-numeric items
+   * @returns {number | null} The percentile value or null if collection is empty
+   */
+  percentile(percentile, accessor) {
+    if (0 === this.length) {
+      return null;
+    }
+    const values = accessor ? this.map(accessor) : this;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = percentile / 100 * (sorted.length - 1);
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    if (lower === upper) {
+      return sorted[lower];
+    }
+    const weight = index - lower;
+    return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+  }
+  /**
+   * Calculate the frequencies of items in the collection.
+   *
+   * @param {Callback<T, unknown>} [accessor] Optional accessor for the values
+   * @returns {Record<string, number>} A record of values and their frequencies
+   */
+  frequencies(accessor) {
+    const frequencies = {};
+    for (let i = 0; i < this.length; i++) {
+      const item = this[i];
+      const key = accessor ? String(accessor(item, i)) : String(item);
+      frequencies[key] = (frequencies[key] || 0) + 1;
+    }
+    return frequencies;
+  }
+  // Advanced operations
+  /**
+   * Calculate the Cartesian product of the collection and other arrays.
+   *
+   * @param {...U[][]} arrays The arrays to calculate the product with
+   * @returns {EnhancedArray<[T, ...U[]]>} A collection of product combinations
+   */
+  cartesian(...arrays) {
+    const result = new _EnhancedArray();
+    const allArrays = [this, ...arrays];
+    function* cartesianProduct(arrays2, index = 0, current = []) {
+      if (index === arrays2.length) {
+        yield [...current];
+        return;
+      }
+      for (const item of arrays2[index]) {
+        yield* cartesianProduct(arrays2, index + 1, [...current, item]);
+      }
+    }
+    for (const combination of cartesianProduct(allArrays)) {
+      result.push(combination);
+    }
+    return result;
+  }
+  /**
+   * Interleave the collection with other arrays.
+   *
+   * @param {...U[][]} arrays The arrays to interleave with
+   * @returns {EnhancedArray<T | U>} A new interleaved collection
+   */
+  interleave(...arrays) {
+    const result = new _EnhancedArray();
+    const allArrays = [this, ...arrays];
+    const maxLength = Math.max(...allArrays.map((arr) => arr.length));
+    for (let i = 0; i < maxLength; i++) {
+      for (const array of allArrays) {
+        if (i < array.length) {
+          result.push(array[i]);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get a sliding window of items from the collection.
+   *
+   * @param {number} [size=2] The size of the window
+   * @param {number} [step=1] The step between windows
+   * @returns {EnhancedArray<EnhancedArray<T>>} A collection of window collections
+   */
+  sliding(size = 2, step = 1) {
+    if (0 >= size || 0 >= step) {
+      return new _EnhancedArray();
+    }
+    const windows = new _EnhancedArray();
+    for (let i = 0; i <= this.length - size; i += step) {
+      windows.push(new _EnhancedArray(...this.slice(i, i + size)));
+    }
+    return windows;
+  }
+  // Navigation macros
+  /**
+   * Get the item at the given index.
+   *
+   * @param {number} index The index to retrieve
+   * @returns {T | undefined} The item at the index or undefined
+   */
+  at(index) {
+    return this[index];
+  }
+  /**
+   * Get the item before the given item.
+   *
+   * @param {T} item The item to search for
+   * @returns {T | undefined} The item before or undefined
+   */
+  before(item) {
+    const index = this.indexOf(item);
+    return 0 < index ? this[index - 1] : void 0;
+  }
+  /**
+   * Get the item after the given item.
+   *
+   * @param {T} item The item to search for
+   * @returns {T | undefined} The item after or undefined
+   */
+  after(item) {
+    const index = this.indexOf(item);
+    return 0 <= index && index < this.length - 1 ? this[index + 1] : void 0;
+  }
+  // Transformation macros
+  /**
+   * Chunk the collection by a given key or callback when its value changes.
+   *
+   * @param {K | Callback<T, unknown>} key The key or callback to chunk by
+   * @returns {EnhancedArray<EnhancedArray<T>>} A collection of chunked collections
+   */
+  chunkBy(key) {
+    if (0 === this.length) {
+      return new _EnhancedArray();
+    }
+    const chunks = new _EnhancedArray();
+    let currentChunk = new _EnhancedArray();
+    let lastValue = null;
+    for (let i = 0; i < this.length; i++) {
+      const item = this[i];
+      const currentValue = "function" === typeof key ? key(item, i) : item && "object" === typeof item ? item[key] : item;
+      if (0 === i || currentValue === lastValue) {
+        currentChunk.push(item);
+      } else {
+        chunks.push(currentChunk);
+        currentChunk = new _EnhancedArray(item);
+      }
+      lastValue = currentValue;
+    }
+    if (0 < currentChunk.length) {
+      chunks.push(currentChunk);
+    }
+    return chunks;
+  }
+  /**
+   * Map and filter the collection simultaneously.
+   * Items for which the callback returns null or undefined are removed.
+   *
+   * @param {Function} callback The callback to map items
+   * @returns {EnhancedArray<U>} A new mapped and filtered collection
+   */
+  filterMap(callback) {
+    const result = new _EnhancedArray();
+    for (let i = 0; i < this.length; i++) {
+      const mapped = callback(this[i], i);
+      if (null !== mapped && mapped !== void 0) {
+        result.push(mapped);
+      }
+    }
+    return result;
+  }
+  /**
+   * Extract a subset of properties from each item in the collection.
+   *
+   * @param {K[]} keys The keys to extract
+   * @returns {EnhancedArray<Partial<T>>} A new collection of partial items
+   */
+  extract(keys) {
+    return new _EnhancedArray(
+      ...this.map((item) => {
+        if (!item || "object" !== typeof item) {
+          return {};
+        }
+        const extracted = {};
+        for (const key of keys) {
+          if (key in item) {
+            extracted[key] = item[key];
+          }
+        }
+        return extracted;
+      })
+    );
+  }
+  // Utility macros
+  /**
+   * Get the first item or push a default item if the collection is empty.
+   *
+   * @param {T} item The default item to push if empty
+   * @returns {T} The first item or the pushed item
+   */
+  firstOrPush(item) {
+    if (0 === this.length) {
+      this.push(item);
+      return item;
+    }
+    return this[0];
+  }
+  /**
+   * Get every n-th item from the collection.
+   *
+   * @param {number} n The step size
+   * @returns {EnhancedArray<T>} A new collection of every n-th item
+   */
+  getNth(n) {
+    const result = new _EnhancedArray();
+    for (let i = n - 1; i < this.length; i += n) {
+      result.push(this[i]);
+    }
+    return result;
+  }
+  /**
+   * Get a random item from the collection based on weights.
+   *
+   * @param {number[]} [weights] Optional weights for each item
+   * @returns {T | undefined} A random item or undefined if collection is empty
+   */
+  weightedRandom(weights) {
+    if (0 === this.length) {
+      return void 0;
+    }
+    const effectiveWeights = weights ?? new Array(this.length).fill(1);
+    if (effectiveWeights.length !== this.length) {
+      throw new Error("Weights array must have same length as collection");
+    }
+    const totalWeight = effectiveWeights.reduce((sum, weight) => sum + weight, 0);
+    const random = Math.random() * totalWeight;
+    let currentWeight = 0;
+    for (let i = 0; i < this.length; i++) {
+      currentWeight += effectiveWeights[i];
+      if (random <= currentWeight) {
+        return this[i];
+      }
+    }
+    return this[this.length - 1];
+  }
+  /**
+   * Paginate the collection items.
+   *
+   * @param {number} perPage Items per page
+   * @param {number} [page=1] Current page number
+   * @returns {Object} Pagination results
+   */
+  paginate(perPage, page = 1) {
+    const total = this.length;
+    const lastPage = Math.ceil(total / perPage);
+    const currentPage = Math.max(1, Math.min(page, lastPage));
+    const from = (currentPage - 1) * perPage;
+    const to = Math.min(from + perPage, total);
+    return {
+      data: new _EnhancedArray(...this.slice(from, to)),
+      total,
+      perPage,
+      currentPage,
+      lastPage,
+      from: from + 1,
+      to
+    };
+  }
+  /**
+   * Recursively convert all nested arrays to EnhancedArray instances.
+   *
+   * @returns {EnhancedArray<unknown>} A new collection with recursive EnhancedArrays
+   */
+  recursive() {
+    const convert = (item) => {
+      if (Array.isArray(item)) {
+        return new _EnhancedArray(...item.map(convert));
+      }
+      if (item && "object" === typeof item && item.constructor === Object) {
+        const converted = {};
+        for (const [key, value2] of Object.entries(item)) {
+          converted[key] = convert(value2);
+        }
+        return converted;
+      }
+      return item;
+    };
+    return new _EnhancedArray(...this.map(convert));
+  }
+};
+var objectToMap = (obj2) => {
+  return new Map(Object.entries(obj2));
+};
+var mapToObject = (map) => {
+  return Object.fromEntries(map);
+};
+var EnhancedMap = class _EnhancedMap extends Map {
+  /**
+   * Create an EnhancedMap from a plain object.
+   *
+   * @param {Record<string, V>} obj The object to convert
+   * @returns {EnhancedMap<string, V>} A new EnhancedMap instance
+   */
+  static fromObject(obj2) {
+    return new _EnhancedMap(Object.entries(obj2));
+  }
+  /**
+   * Pluck a property from each value in the map.
+   *
+   * @param {P} key The key to pluck
+   * @returns {EnhancedArray<V[P]>} A new collection of plucked values
+   */
+  pluck(key) {
+    return new EnhancedArray(
+      ...Array.from(this.values()).map((value2) => value2 && "object" === typeof value2 ? value2[key] : void 0).filter((val) => val !== void 0)
+    );
+  }
+  /**
+   * Group the map's entries by a given accessor.
+   *
+   * @param {Function} accessor The accessor to group by
+   * @returns {Record<string, EnhancedArray<[K, V]>>} A record of grouped entries
+   */
+  groupBy(accessor) {
+    const groups = {};
+    for (const [key, value2] of this) {
+      const groupKey = String(accessor(value2, key));
+      if (!groups[groupKey]) {
+        groups[groupKey] = new EnhancedArray();
+      }
+      groups[groupKey].push([key, value2]);
+    }
+    return groups;
+  }
+  /**
+   * Convert the map to an array of entries.
+   *
+   * @returns {EnhancedArray<[K, V]>} A collection of entries
+   */
+  toArray() {
+    return new EnhancedArray(...this.entries());
+  }
+  /**
+   * Convert the map to a plain object.
+   *
+   * @returns {Record<string, V>} A plain object representation of the map
+   */
+  toObject() {
+    const obj2 = {};
+    for (const [key, value2] of this) {
+      obj2[String(key)] = value2;
+    }
+    return obj2;
+  }
+};
+var collect = (items) => {
+  return new EnhancedArray(...items);
+};
+var collectMap = (entries) => {
+  return new EnhancedMap(entries);
+};
+
+// src/php-arrays.ts
+var array_chunk = (array, size) => {
+  if (0 >= size) {
+    return [];
+  }
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+};
+var array_filter = (array, callback) => {
+  if (!callback) {
+    return array.filter((item) => Boolean(item));
+  }
+  return array.filter(callback);
+};
+var array_map = (callback, array) => {
+  return array.map(callback);
+};
+var array_reduce = (array, callback, initial) => {
+  return array.reduce((carry, item, index) => callback(carry, item, index), initial);
+};
+var array_merge = (...arrays) => {
+  return arrays.flat();
+};
+var array_unique = (array) => {
+  return [...new Set(array)];
+};
+var array_reverse = (array, _preserveKeys = false) => {
+  return [...array].reverse();
+};
+var array_slice = (array, offset, length) => {
+  const start = 0 > offset ? Math.max(0, array.length + offset) : offset;
+  const end = length !== void 0 ? start + length : void 0;
+  return array.slice(start, end);
+};
+var array_splice = (array, offset, length, ...replacement) => {
+  const result = [...array];
+  const actualLength = length ?? result.length - offset;
+  result.splice(offset, actualLength, ...replacement);
+  return result;
+};
+var array_keys = (array) => {
+  return array.map((_, index) => index);
+};
+var array_search = (needle, haystack) => {
+  const index = haystack.indexOf(needle);
+  return -1 !== index ? index : false;
+};
+var array_key_exists = (key, array) => {
+  return 0 <= key && key < array.length;
+};
+var array_pop = (array) => {
+  const result = [...array];
+  return result.pop();
+};
+var array_push = (array, ...values) => {
+  return [...array, ...values];
+};
+var array_shift = (array) => {
+  const result = [...array];
+  return result.shift();
+};
+var array_unshift = (array, ...values) => {
+  return [...values, ...array];
+};
+var array_sum = (array) => {
+  return array.reduce((sum, num2) => sum + num2, 0);
+};
+var array_product = (array) => {
+  return array.reduce((product, num2) => product * num2, 1);
+};
+var array_rand = (array, num2 = 1) => {
+  if (0 === array.length) {
+    return 1 === num2 ? void 0 : [];
+  }
+  const shuffled = [...array].sort(() => Math.random() - 0.5);
+  if (1 === num2) {
+    return shuffled[0];
+  }
+  return shuffled.slice(0, Math.min(num2, array.length));
+};
+var array_flip = (array) => {
+  const result = {};
+  array.forEach((value2, index) => {
+    result[String(value2)] = index;
+  });
+  return result;
+};
+var array_count_values = (array) => {
+  const result = {};
+  array.forEach((value2) => {
+    const key = String(value2);
+    result[key] = (result[key] || 0) + 1;
+  });
+  return result;
+};
+var array_intersect = (...arrays) => {
+  if (0 === arrays.length) {
+    return [];
+  }
+  const first = arrays[0];
+  return first.filter((item) => arrays.slice(1).every((arr) => arr.includes(item)));
+};
+var array_diff = (array1, ...arrays) => {
+  const otherItems = new Set(arrays.flat());
+  return array1.filter((item) => !otherItems.has(item));
+};
+var array_column = (array, column) => {
+  return array.map((item) => item && "object" === typeof item ? item[column] : void 0).filter((value2) => value2 !== void 0);
+};
+var sort = (array) => {
+  return [...array].sort();
+};
+var rsort = (array) => {
+  return [...array].sort().reverse();
+};
+var usort = (array, compareFunction) => {
+  return [...array].sort(compareFunction);
+};
+var uasort = (array, compareFunction) => {
+  return [...array].sort(compareFunction);
+};
+var uksort = (array, compareFunction) => {
+  const indices = Array.from({ length: array.length }, (_, i) => i);
+  const sortedIndices = indices.sort(compareFunction);
+  return sortedIndices.map((i) => array[i]);
+};
+var shuffle = (array) => {
+  const result = [...array];
+  for (let i = result.length - 1; 0 < i; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+};
+var range = (start, end, step = 1) => {
+  const result = [];
+  if (0 < step) {
+    for (let i = start; i <= end; i += step) {
+      result.push(i);
+    }
+  } else if (0 > step) {
+    for (let i = start; i >= end; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+};
+var php_array = (items) => {
+  const enhanced = new EnhancedArray(...items);
+  Object.assign(enhanced, {
+    // PHP array functions as methods
+    chunk: (size) => array_chunk(enhanced, size),
+    merge: (...arrays) => new EnhancedArray(...array_merge(enhanced, ...arrays)),
+    unique: () => new EnhancedArray(...array_unique(enhanced)),
+    reverse: (preserveKeys = false) => new EnhancedArray(...array_reverse(enhanced, preserveKeys)),
+    search: (needle) => array_search(needle, enhanced),
+    sum: () => array_sum(enhanced),
+    product: () => array_product(enhanced),
+    rand: (num2 = 1) => array_rand(enhanced, num2),
+    flip: () => array_flip(enhanced),
+    countValues: () => array_count_values(enhanced),
+    intersect: (...arrays) => new EnhancedArray(...array_intersect(enhanced, ...arrays)),
+    diff: (...arrays) => new EnhancedArray(...array_diff(enhanced, ...arrays)),
+    column: (column) => array_column(enhanced, column),
+    // PHP sorting as methods
+    sort: () => new EnhancedArray(...sort(enhanced)),
+    rsort: () => new EnhancedArray(...rsort(enhanced)),
+    shuffle: () => new EnhancedArray(...shuffle(enhanced)),
+    usort: (compareFunction) => new EnhancedArray(...usort(enhanced, compareFunction))
+  });
+  return enhanced;
+};
+
+// src/datetime.ts
+var import_dayjs = __toESM(require("dayjs"), 1);
+var import_isBetween = __toESM(require("dayjs/plugin/isBetween"), 1);
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"), 1);
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"), 1);
+var import_relativeTime = __toESM(require("dayjs/plugin/relativeTime"), 1);
+var import_utc = __toESM(require("dayjs/plugin/utc"), 1);
+import_dayjs.default.extend(import_isBetween.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_relativeTime.default);
+import_dayjs.default.extend(import_utc.default);
+var dayjs = import_dayjs.default;
+var now = () => dayjs();
+var today = () => dayjs().startOf("day");
+var tomorrow = () => dayjs().add(1, "day").startOf("day");
+var yesterday = () => dayjs().subtract(1, "day").startOf("day");
+var isBetweenDates = (date, start, end, unit = "day", inclusivity = "[]") => {
+  return dayjs(date).isBetween(dayjs(start), dayjs(end), unit, inclusivity);
+};
+var fromNow = (date) => dayjs(date).fromNow();
+var isToday = (date) => dayjs(date).isSame(dayjs(), "day");
+var isPast = (date) => dayjs(date).isBefore(dayjs());
+var isFuture = (date) => dayjs(date).isAfter(dayjs());
+
+// src/schemas.ts
+var import_zod = require("zod");
+var EmailSchema = import_zod.z.string().email("Invalid email format").min(1, "Email is required");
+var PhoneSchema = import_zod.z.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number format");
+var UrlSchema = import_zod.z.string().url("Invalid URL format");
+var DateSchema = import_zod.z.union([
+  import_zod.z.string().datetime(),
+  import_zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Invalid date format (YYYY-MM-DD)"),
+  import_zod.z.date()
+]);
+var ApiResponseSchema = (dataSchema) => import_zod.z.object({
+  success: import_zod.z.boolean(),
+  data: dataSchema.optional(),
+  message: import_zod.z.string().optional(),
+  errors: import_zod.z.array(import_zod.z.string()).optional()
+});
+var PaginationSchema = import_zod.z.object({
+  page: import_zod.z.number().int().positive().default(1),
+  perPage: import_zod.z.number().int().min(1).max(100).default(15),
+  total: import_zod.z.number().int().nonnegative(),
+  lastPage: import_zod.z.number().int().positive()
+});
+var PaginatedResponseSchema = (itemSchema) => import_zod.z.object({
+  data: import_zod.z.array(itemSchema),
+  pagination: PaginationSchema
+});
+var validateSchema = (schema, data) => {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    const errors = result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+    throw new Error(`Validation failed: ${errors.join(", ")}`);
+  }
+  return result.data;
+};
+var safeValidateSchema = (schema, data) => {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  const errors = result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+  return { success: false, errors };
+};
+
+// src/number.ts
+var Numberable = class {
+  /**
+   * Create a new Numberable instance.
+   *
+   * @param {unknown} value The initial value
+   */
+  constructor(value2) {
+    this.value = Number(value2 ?? 0);
+    if (isNaN(this.value)) {
+      this.value = 0;
+    }
+  }
+  /**
+   * Get the raw number value.
+   *
+   * @returns {number} The raw value
+   */
+  toNumber() {
+    return this.value;
+  }
+  /**
+   * Alias for toNumber().
+   *
+   * @returns {number} The raw value
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Format the number with locale-specific formatting.
+   *
+   * @param {number} [decimals=0] The number of decimal points
+   * @param {string} [locale='en-US'] The locale to use for formatting
+   * @returns {string} The formatted number
+   */
+  format(decimals = 0, locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(this.value);
+  }
+  /**
+   * Format the number as currency.
+   *
+   * @param {string} [currency='USD'] The currency code (e.g., 'USD', 'EUR')
+   * @param {string} [locale='en-US'] The locale to use for formatting
+   * @returns {string} The formatted currency string
+   */
+  currency(currency = "USD", locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency
+    }).format(this.value);
+  }
+  /**
+   * Format the number as a percentage.
+   *
+   * @param {number} [decimals=0] The number of decimal points
+   * @param {string} [locale='en-US'] The locale to use for formatting
+   * @returns {string} The formatted percentage string
+   */
+  percentage(decimals = 0, locale = "en-US") {
+    return new Intl.NumberFormat(locale, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    }).format(this.value / 100);
+  }
+  /**
+   * Format the number as a human-readable file size.
+   *
+   * @param {number} [precision=2] The number of decimal points
+   * @returns {string} The formatted file size (e.g., "1.50 MB")
+   */
+  fileSize(precision = 2) {
+    if (0 === this.value) {
+      return "0 B";
+    }
+    const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const i = Math.floor(Math.log(this.value) / Math.log(1024));
+    return `${parseFloat((this.value / Math.pow(1024, i)).toFixed(precision))} ${units[i]}`;
+  }
+  /**
+   * Abbreviate the number (e.g., 1K, 1M, 1B).
+   *
+   * @param {number} [precision=1] The number of decimal points
+   * @returns {string} The abbreviated number
+   */
+  abbreviate(precision = 1) {
+    if (1e3 > this.value) {
+      return String(this.value);
+    }
+    const units = ["", "K", "M", "B", "T"];
+    const i = Math.floor(Math.log10(this.value) / 3);
+    return `${parseFloat((this.value / Math.pow(1e3, i)).toFixed(precision))}${units[i]}`;
+  }
+  /**
+   * Add an ordinal suffix to the number (e.g., 1st, 2nd, 3rd).
+   *
+   * @returns {string} The number with its ordinal suffix
+   */
+  ordinal() {
+    const s = ["th", "st", "nd", "rd"];
+    const v = this.value % 100;
+    return this.value + (s[(v - 20) % 10] || s[v] || s[0]);
+  }
+  /**
+   * Clamp the number between a minimum and maximum value.
+   *
+   * @param {number} min The minimum value
+   * @param {number} max The maximum value
+   * @returns {this} The Numberable instance
+   */
+  clamp(min, max) {
+    this.value = Math.min(Math.max(this.value, min), max);
+    return this;
+  }
+  /**
+   * Check if the number is between a minimum and maximum value.
+   *
+   * @param {number} min The minimum value
+   * @param {number} max The maximum value
+   * @param {boolean} [inclusive=true] Whether to include the boundaries
+   * @returns {boolean} True if the number is between min and max
+   */
+  isBetween(min, max, inclusive = true) {
+    return inclusive ? this.value >= min && this.value <= max : this.value > min && this.value < max;
+  }
+  /**
+   * Add a value to the current number.
+   *
+   * @param {number} value The value to add
+   * @returns {this} The Numberable instance
+   */
+  add(value2) {
+    this.value += value2;
+    return this;
+  }
+  /**
+   * Subtract a value from the current number.
+   *
+   * @param {number} value The value to subtract
+   * @returns {this} The Numberable instance
+   */
+  sub(value2) {
+    this.value -= value2;
+    return this;
+  }
+  /**
+   * Multiply the current number by a value.
+   *
+   * @param {number} value The value to multiply by
+   * @returns {this} The Numberable instance
+   */
+  mul(value2) {
+    this.value *= value2;
+    return this;
+  }
+  /**
+   * Divide the current number by a value.
+   *
+   * @param {number} value The value to divide by
+   * @returns {this} The Numberable instance
+   */
+  div(value2) {
+    if (0 !== value2) {
+      this.value /= value2;
+    }
+    return this;
+  }
+  /**
+   * Round the number to a specified precision.
+   *
+   * @param {number} [precision=0] The number of decimal points
+   * @returns {this} The Numberable instance
+   */
+  round(precision = 0) {
+    const factor = Math.pow(10, precision);
+    this.value = Math.round(this.value * factor) / factor;
+    return this;
+  }
+  /**
+   * Round the number up to a specified precision.
+   *
+   * @param {number} [precision=0] The number of decimal points
+   * @returns {this} The Numberable instance
+   */
+  ceil(precision = 0) {
+    const factor = Math.pow(10, precision);
+    this.value = Math.ceil(this.value * factor) / factor;
+    return this;
+  }
+  /**
+   * Round the number down to a specified precision.
+   *
+   * @param {number} [precision=0] The number of decimal points
+   * @returns {this} The Numberable instance
+   */
+  floor(precision = 0) {
+    const factor = Math.pow(10, precision);
+    this.value = Math.floor(this.value * factor) / factor;
+    return this;
+  }
+  /**
+   * Pipe the current Numberable instance to a callback.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Execute a callback if a condition is met.
+   *
+   * @param {boolean | Function} condition The condition to check
+   * @param {Function} callback The callback to execute if condition is true
+   * @returns {this} The Numberable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+};
+var num = (value2) => {
+  return new Numberable(value2);
+};
+var NumberHelper = {
+  /** Create a new Numberable instance */
+  of: (value2) => new Numberable(value2),
+  /** Format the number with locale-specific formatting */
+  format: (value2, decimals = 0, locale = "en-US") => new Numberable(value2).format(decimals, locale),
+  /** Format the number as currency */
+  currency: (value2, currency = "USD", locale = "en-US") => new Numberable(value2).currency(currency, locale),
+  /** Format the number as a percentage */
+  percentage: (value2, decimals = 0, locale = "en-US") => new Numberable(value2).percentage(decimals, locale),
+  /** Format the number as a human-readable file size */
+  fileSize: (value2, precision = 2) => new Numberable(value2).fileSize(precision),
+  /** Abbreviate the number */
+  abbreviate: (value2, precision = 1) => new Numberable(value2).abbreviate(precision),
+  /** Add an ordinal suffix to the number */
+  ordinal: (value2) => new Numberable(value2).ordinal()
+};
+
+// src/runtime.ts
+function isRecord(value2) {
+  return null !== value2 && "object" === typeof value2 && !Array.isArray(value2);
+}
+var tap = (value2, callback) => {
+  callback(value2);
+  return value2;
+};
+var when = (condition, onTrue, onFalse) => {
+  const shouldExecute = "function" === typeof condition ? condition() : Boolean(condition);
+  if (shouldExecute) {
+    return onTrue();
+  } else if (onFalse) {
+    return onFalse();
+  }
+  return void 0;
+};
+var value = (val) => {
+  return "function" === typeof val ? val() : val;
+};
+var data_get = (target, key, defaultValue = null) => {
+  if (!isRecord(target) && !Array.isArray(target)) {
+    return defaultValue;
+  }
+  const parts = Array.isArray(key) ? key : key.split(".");
+  let result = target;
+  for (const part of parts) {
+    if (!isRecord(result) && !Array.isArray(result)) {
+      return defaultValue;
+    }
+    if (part in result) {
+      result = result[part];
+    } else {
+      return defaultValue;
+    }
+  }
+  return result;
+};
+var data_set = (target, key, value2) => {
+  if (!isRecord(target) && !Array.isArray(target)) {
+    return target;
+  }
+  const parts = Array.isArray(key) ? key : key.split(".");
+  let current = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!isRecord(current)) {
+      break;
+    }
+    const currentRecord = current;
+    if (!(part in currentRecord) || !isRecord(currentRecord[part])) {
+      currentRecord[part] = {};
+    }
+    current = currentRecord[part];
+  }
+  if (isRecord(current)) {
+    ;
+    current[parts[parts.length - 1]] = value2;
+  }
+  return target;
+};
+var optional = (value2) => {
+  return value2 ?? null;
+};
+var retry = async (times, callback, sleepMilliseconds = 0) => {
+  let lastError;
+  for (let attempt = 1; attempt <= times; attempt++) {
+    try {
+      return await callback(attempt);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < times && 0 < sleepMilliseconds) {
+        await new Promise((resolve) => setTimeout(resolve, sleepMilliseconds));
+      }
+    }
+  }
+  throw lastError ?? new Error(`Retry failed after ${times} attempts`);
+};
+var throw_if = (condition, exception) => {
+  if ("function" === typeof condition ? condition() : Boolean(condition)) {
+    throw "string" === typeof exception ? new Error(exception) : exception;
+  }
+};
+var throw_unless = (condition, exception) => {
+  if (!("function" === typeof condition ? condition() : Boolean(condition))) {
+    throw "string" === typeof exception ? new Error(exception) : exception;
+  }
+};
+
+// src/obj.ts
+var Objectable = class _Objectable {
+  /**
+   * Create a new Objectable instance.
+   *
+   * @param {T} value The initial object value
+   */
+  constructor(value2) {
+    this.value = structuredClone(value2);
+    this.originalValue = structuredClone(value2);
+  }
+  /**
+   * Get the current object state.
+   *
+   * @returns {T} The current object
+   */
+  toObject() {
+    return this.value;
+  }
+  /**
+   * Alias for toObject().
+   *
+   * @returns {T} The current object
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Get the original state from construction.
+   *
+   * @returns {T} The original object
+   */
+  getOriginal() {
+    return this.originalValue;
+  }
+  /**
+   * Sync original state with current state (marking it as clean).
+   *
+   * @returns {this} The Objectable instance
+   */
+  syncOriginal() {
+    this.originalValue = structuredClone(this.value);
+    return this;
+  }
+  /**
+   * Determine if any attribute has been modified.
+   *
+   * @param {string} [key] Optional key to check specifically
+   * @returns {boolean} True if dirty, false otherwise
+   */
+  isDirty(key) {
+    if (key) {
+      return !isEqual(data_get(this.originalValue, key), data_get(this.value, key));
+    }
+    return !isEqual(this.originalValue, this.value);
+  }
+  /**
+   * Determine if the object is equivalent to its original state.
+   *
+   * @param {string} [key] Optional key to check specifically
+   * @returns {boolean} True if clean, false otherwise
+   */
+  isClean(key) {
+    return !this.isDirty(key);
+  }
+  /**
+   * Get the attributes that have been modified.
+   *
+   * @returns {Partial<T>} The dirty attributes
+   */
+  getDirty() {
+    return diff(this.originalValue, this.value);
+  }
+  /**
+   * Get a value by dot notation.
+   *
+   * @param {string} key The key to retrieve
+   * @param {unknown} [defaultValue=null] The default value if not found
+   * @returns {unknown} The retrieved value
+   */
+  dataGet(key, defaultValue = null) {
+    return data_get(this.value, key, defaultValue);
+  }
+  /**
+   * Set a value by dot notation.
+   *
+   * @param {string} key The key to set
+   * @param {unknown} value The value to set
+   * @returns {this} The Objectable instance
+   */
+  dataSet(key, value2) {
+    data_set(this.value, key, value2);
+    return this;
+  }
+  /**
+   * Get only specified keys.
+   *
+   * @param {K[]} keys The keys to include
+   * @returns {Objectable<Pick<T, K>>} A new Objectable instance
+   */
+  only(keys) {
+    const result = {};
+    keys.forEach((key) => {
+      const k = key;
+      if (k in this.value) {
+        result[k] = this.value[k];
+      }
+    });
+    return new _Objectable(result);
+  }
+  /**
+   * Get all keys except specified ones.
+   *
+   * @param {K[]} keys The keys to exclude
+   * @returns {Objectable<Omit<T, K>>} A new Objectable instance
+   */
+  except(keys) {
+    const result = { ...this.value };
+    keys.forEach((key) => {
+      const k = key;
+      delete result[k];
+    });
+    return new _Objectable(result);
+  }
+  /**
+   * Map over object entries.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {Record<string, U>} The resulting object
+   */
+  map(callback) {
+    const result = {};
+    for (const [key, val] of Object.entries(this.value)) {
+      result[key] = callback(val, key);
+    }
+    return result;
+  }
+  /**
+   * Filter object entries.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {this} The Objectable instance
+   */
+  filter(callback) {
+    const result = {};
+    for (const [key, val] of Object.entries(this.value)) {
+      if (callback(val, key)) {
+        result[key] = val;
+      }
+    }
+    this.value = result;
+    return this;
+  }
+  /**
+   * Merge with another object.
+   *
+   * @param {U} other The object to merge with
+   * @returns {Objectable<T & U>} A new Objectable instance
+   */
+  merge(other) {
+    return new _Objectable({ ...this.value, ...other });
+  }
+  /**
+   * Deep merge with another object (non-mutating on source).
+   *
+   * @param {Record<string, unknown>} other The object to deep merge with
+   * @returns {this} The Objectable instance
+   */
+  mergeDeep(other) {
+    const merge = (target, source) => {
+      const result = { ...target };
+      for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = target[key];
+        if (srcVal !== null && "object" === typeof srcVal && !Array.isArray(srcVal) && tgtVal !== null && "object" === typeof tgtVal && !Array.isArray(tgtVal)) {
+          result[key] = merge(tgtVal, srcVal);
+        } else {
+          result[key] = srcVal;
+        }
+      }
+      return result;
+    };
+    this.value = merge(this.value, other);
+    return this;
+  }
+  /**
+   * Check if object has key.
+   *
+   * @param {string} key The key to check
+   * @returns {boolean} True if key exists
+   */
+  has(key) {
+    return key in this.value;
+  }
+  /**
+   * Get keys.
+   *
+   * @returns {string[]} The object keys
+   */
+  keys() {
+    return Object.keys(this.value);
+  }
+  /**
+   * Get values.
+   *
+   * @returns {unknown[]} The object values
+   */
+  values() {
+    return Object.values(this.value);
+  }
+  /**
+   * Clone the object.
+   *
+   * @returns {Objectable<T>} A new cloned Objectable instance
+   */
+  clone() {
+    return new _Objectable(structuredClone(this.value));
+  }
+  /**
+   * Pipe to a callback.
+   *
+   * @param {Function} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Execute callback if condition is met.
+   *
+   * @param {boolean | Function} condition The condition to check
+   * @param {Function} callback The callback to execute
+   * @returns {this} The Objectable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+};
+var obj = (value2) => {
+  return new Objectable(value2);
+};
+var Obj = {
+  /** Create a new Objectable instance */
+  of: (value2) => new Objectable(value2),
+  /** Get object keys */
+  keys: (value2) => Object.keys(value2),
+  /** Get object values */
+  values: (value2) => Object.values(value2),
+  /** Merge objects */
+  merge: (target, ...sources) => Object.assign({}, target, ...sources)
+};
+
+// src/str.ts
+var Stringable = class {
+  constructor(value2) {
+    this.value = String(value2 ?? "");
+  }
+  /**
+   * Get the raw string value
+   *
+   * @returns {string} The raw string
+   */
+  toString() {
+    return this.value;
+  }
+  /**
+   * Alias for toString()
+   *
+   * @returns {string} The raw string
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Convert to title case
+   *
+   * @returns {this} The Stringable instance
+   */
+  title() {
+    this.value = titleCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to slug
+   *
+   * @returns {this} The Stringable instance
+   */
+  slug() {
+    this.value = slugify(this.value);
+    return this;
+  }
+  /**
+   * Convert to snake_case
+   *
+   * @returns {this} The Stringable instance
+   */
+  snake() {
+    this.value = snakeCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to kebab-case
+   *
+   * @returns {this} The Stringable instance
+   */
+  kebab() {
+    this.value = kebabCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to camelCase
+   *
+   * @returns {this} The Stringable instance
+   */
+  camel() {
+    this.value = camelCase(this.value);
+    return this;
+  }
+  /**
+   * Convert to StudlyCase
+   *
+   * @returns {this} The Stringable instance
+   */
+  studly() {
+    this.value = studlyCase(this.value);
+    return this;
+  }
+  /**
+   * Limit the string length
+   *
+   * @param {number} size The maximum length
+   * @param {string} [end='…'] The string to append if limited
+   * @returns {this} The Stringable instance
+   */
+  limit(size, end = "\u2026") {
+    this.value = strLimit(this.value, size);
+    if (this.value.endsWith("\u2026") && "\u2026" !== end) {
+      this.value = this.value.slice(0, -1) + end;
+    }
+    return this;
+  }
+  /**
+   * Append a value to the string
+   *
+   * @param {...unknown[]} values The values to append
+   * @returns {this} The Stringable instance
+   */
+  append(...values) {
+    this.value += values.join("");
+    return this;
+  }
+  /**
+   * Prepend a value to the string
+   *
+   * @param {...unknown[]} values The values to prepend
+   * @returns {this} The Stringable instance
+   */
+  prepend(...values) {
+    this.value = values.join("") + this.value;
+    return this;
+  }
+  /**
+   * Cap the string with a value if it doesn't already end with it
+   *
+   * @param {string} cap The string to end with
+   * @returns {this} The Stringable instance
+   */
+  finish(cap) {
+    this.value = strFinish(this.value, cap);
+    return this;
+  }
+  /**
+   * Start the string with a value if it doesn't already start with it
+   *
+   * @param {string} prefix The string to start with
+   * @returns {this} The Stringable instance
+   */
+  start(prefix) {
+    this.value = strStart(this.value, prefix);
+    return this;
+  }
+  /**
+   * Replace the first occurrence of a value
+   *
+   * @param {string | RegExp} search The value to search for
+   * @param {string} replace The value to replace with
+   * @returns {this} The Stringable instance
+   */
+  replace(search, replace) {
+    this.value = this.value.replace(search, replace);
+    return this;
+  }
+  /**
+   * Replace all occurrences of a value
+   *
+   * @param {string | RegExp} search The value to search for
+   * @param {string} replace The value to replace with
+   * @returns {this} The Stringable instance
+   */
+  replaceAll(search, replace) {
+    if ("string" === typeof search) {
+      this.value = this.value.split(search).join(replace);
+    } else {
+      const flags = search.flags.includes("g") ? search.flags : `${search.flags}g`;
+      this.value = this.value.replace(new RegExp(search.source, flags), replace);
+    }
+    return this;
+  }
+  /**
+   * Reverse the string
+   *
+   * @returns {this} The Stringable instance
+   */
+  reverse() {
+    this.value = strReverse(this.value);
+    return this;
+  }
+  /**
+   * Mask a portion of the string
+   *
+   * @param {string} character The masking character
+   * @param {number} index The starting index
+   * @param {number} [length] The number of characters to mask
+   * @returns {this} The Stringable instance
+   */
+  mask(character, index, length) {
+    this.value = strMask(this.value, character, index, length);
+    return this;
+  }
+  /**
+   * Trim the string
+   *
+   * @param {string} [chars] The characters to trim (defaults to whitespace)
+   * @returns {this} The Stringable instance
+   */
+  trim(chars) {
+    if (!chars) {
+      this.value = this.value.trim();
+    } else {
+      const pattern = new RegExp(`^[${chars}]+|[${chars}]+$`, "g");
+      this.value = this.value.replace(pattern, "");
+    }
+    return this;
+  }
+  /**
+   * Convert to lower case
+   *
+   * @returns {this} The Stringable instance
+   */
+  lower() {
+    this.value = this.value.toLowerCase();
+    return this;
+  }
+  /**
+   * Convert to upper case
+   *
+   * @returns {this} The Stringable instance
+   */
+  upper() {
+    this.value = this.value.toUpperCase();
+    return this;
+  }
+  /**
+   * Capitalize the first letter
+   *
+   * @returns {this} The Stringable instance
+   */
+  capitalize() {
+    this.value = capitalize(this.value);
+    return this;
+  }
+  /**
+   * Check if string contains a value
+   *
+   * @param {string | string[]} needles The values to search for
+   * @returns {boolean} True if the string contains any of the values
+   */
+  contains(needles) {
+    if (Array.isArray(needles)) {
+      return strContainsAny(this.value, needles);
+    }
+    return this.value.includes(needles);
+  }
+  /**
+   * Check if string contains all values
+   *
+   * @param {string[]} needles The values to search for
+   * @returns {boolean} True if the string contains all values
+   */
+  containsAll(needles) {
+    return strContainsAll(this.value, needles);
+  }
+  /**
+   * Check if string starts with a value
+   *
+   * @param {string | string[]} needles The values to check
+   * @returns {boolean} True if the string starts with any of the values
+   */
+  startsWith(needles) {
+    if (Array.isArray(needles)) {
+      return needles.some((needle) => this.value.startsWith(needle));
+    }
+    return this.value.startsWith(needles);
+  }
+  /**
+   * Check if string ends with a value
+   *
+   * @param {string | string[]} needles The values to check
+   * @returns {boolean} True if the string ends with any of the values
+   */
+  endsWith(needles) {
+    if (Array.isArray(needles)) {
+      return needles.some((needle) => this.value.endsWith(needle));
+    }
+    return this.value.endsWith(needles);
+  }
+  /**
+   * Execute a callback with the stringable and return the result
+   *
+   * @param {(str: this) => U} callback The callback to execute
+   * @returns {U} The result of the callback
+   */
+  pipe(callback) {
+    return callback(this);
+  }
+  /**
+   * Conditionally execute a callback
+   *
+   * @param {boolean | (() => boolean)} condition The condition to check
+   * @param {(str: this) => void} callback The callback to execute
+   * @returns {this} The Stringable instance
+   */
+  when(condition, callback) {
+    const shouldExecute = "function" === typeof condition ? condition() : condition;
+    if (shouldExecute) {
+      callback(this);
+    }
+    return this;
+  }
+  /**
+   * Execute a callback and return the stringable (for side effects)
+   *
+   * @param {(str: this) => void} callback The callback to execute
+   * @returns {this} The Stringable instance
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+};
+var str = (value2) => {
+  return new Stringable(value2);
+};
+var Str = {
+  /**
+   * Create a new fluent stringable instance
+   *
+   * @param {unknown} value The initial string value
+   * @returns {Stringable} A new Stringable instance
+   */
+  of: (value2) => new Stringable(value2),
+  /**
+   * Convert a string to a slug
+   *
+   * @param {string} value The string to slugify
+   * @returns {string} The slugified string
+   */
+  slug: (value2) => slugify(value2),
+  /**
+   * Convert a string to snake_case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The snake_case string
+   */
+  snake: (value2) => snakeCase(value2),
+  /**
+   * Convert a string to kebab-case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The kebab-case string
+   */
+  kebab: (value2) => kebabCase(value2),
+  /**
+   * Convert a string to camelCase
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The camelCase string
+   */
+  camel: (value2) => camelCase(value2),
+  /**
+   * Convert a string to StudlyCase
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The StudlyCase string
+   */
+  studly: (value2) => studlyCase(value2),
+  /**
+   * Convert a string to title case
+   *
+   * @param {string} value The string to convert
+   * @returns {string} The title case string
+   */
+  title: (value2) => titleCase(value2),
+  /**
+   * Limit the length of a string
+   *
+   * @param {string} value The string to limit
+   * @param {number} size The maximum length
+   * @param {string} [end='…'] The string to append if limited
+   * @returns {string} The limited string
+   */
+  limit: (value2, size, end = "\u2026") => {
+    const result = strLimit(value2, size);
+    return result.endsWith("\u2026") && "\u2026" !== end ? result.slice(0, -1) + end : result;
+  },
+  /**
+   * Generate a random alphanumeric string
+   *
+   * @param {number} [length=16] The length of the random string
+   * @returns {string} The random string
+   */
+  random: (length = 16) => {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  },
+  /**
+   * Generate a UUID (version 4)
+   *
+   * @returns {string} The generated UUID
+   */
+  uuid: () => crypto.randomUUID()
+};
+
+// src/validator.ts
+var import_zod2 = require("zod");
+var Validator = class {
+  /**
+   * Create a new validation instance
+   *
+   * @param {unknown} data The data to validate
+   * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+   * @returns {ValidationInstance<z.ZodObject<T>>} A new ValidationInstance
+   */
+  static make(data, rules) {
+    const schema = rules instanceof import_zod2.z.ZodObject ? rules : import_zod2.z.object(rules);
+    return new ValidationInstance(data, schema);
+  }
+  /**
+   * Validate data against rules and throw if it fails
+   *
+   * @param {unknown} data The data to validate
+   * @param {T | z.ZodObject<T>} rules The validation rules (Zod shape or object)
+   * @returns {z.infer<z.ZodObject<T>>} The validated data
+   * @throws {z.ZodError} If validation fails
+   */
+  static validate(data, rules) {
+    const schema = rules instanceof import_zod2.z.ZodObject ? rules : import_zod2.z.object(rules);
+    return schema.parse(data);
+  }
+  /**
+   * Compare two objects for equality
+   *
+   * @param {unknown} a First object
+   * @param {unknown} b Second object
+   * @returns {boolean} True if the objects are equal
+   */
+  static isEqual(a, b) {
+    return isEqual(a, b);
+  }
+  /**
+   * Get the differences between two objects
+   *
+   * @param {unknown} a First object
+   * @param {unknown} b Second object
+   * @returns {GenericRecord} An object containing the differences
+   */
+  static diff(a, b) {
+    return diff(a, b);
+  }
+};
+var ValidationInstance = class {
+  constructor(data, schema) {
+    this.data = data;
+    this.schema = schema;
+    this.result = this.schema.safeParse(this.data);
+  }
+  /**
+   * Check if validation failed
+   *
+   * @returns {boolean} True if validation failed
+   */
+  fails() {
+    return !this.result.success;
+  }
+  /**
+   * Check if validation passed
+   *
+   * @returns {boolean} True if validation passed
+   */
+  passes() {
+    return this.result.success;
+  }
+  /**
+   * Get validation errors
+   *
+   * @returns {Record<string, string[]>} An object with field names as keys and arrays of error messages as values
+   */
+  errors() {
+    if (this.result.success) {
+      return {};
+    }
+    const errors = {};
+    this.result.error.issues.forEach((err) => {
+      const path = err.path.join(".") || "root";
+      if (!errors[path]) {
+        errors[path] = [];
+      }
+      errors[path].push(err.message);
+    });
+    return errors;
+  }
+  /**
+   * Get the first error message for a given field
+   *
+   * @param {string} field The field name
+   * @returns {string | undefined} The first error message or undefined
+   */
+  firstError(field) {
+    const fieldErrors = this.errors()[field];
+    return fieldErrors ? fieldErrors[0] : void 0;
+  }
+  /**
+   * Get the validated data
+   *
+   * @returns {z.infer<T>} The validated data
+   * @throws {Error} If validation failed
+   */
+  validated() {
+    if (!this.result.success) {
+      throw new Error("Validation failed");
+    }
+    return this.result.data;
+  }
+  /**
+   * Get all error messages as a flat array
+   *
+   * @returns {string[]} An array of all error messages
+   */
+  allErrors() {
+    if (this.result.success) {
+      return [];
+    }
+    return this.result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`);
+  }
+};
+var validator = (data, rules) => {
+  return Validator.make(data, rules);
+};
+
+// src/pipe.ts
+function pipe(value2) {
+  return {
+    /**
+     * Pass the value through a callback.
+     *
+     * @param {Function} fn The callback function
+     * @returns {ReturnType<typeof pipe>} A new pipe instance with the result
+     */
+    through(fn) {
+      const result = fn(value2);
+      return pipe(result);
+    },
+    /**
+     * Get the current value of the pipe.
+     *
+     * @returns {T} The current value
+     */
+    value() {
+      return value2;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiResponseSchema,
+  DateSchema,
+  EmailSchema,
+  EnhancedArray,
+  EnhancedMap,
+  NumberHelper,
+  Numberable,
+  Obj,
+  Objectable,
+  PaginatedResponseSchema,
+  PaginationSchema,
+  PhoneSchema,
+  Str,
+  Stringable,
+  UrlSchema,
+  ValidationInstance,
+  Validator,
+  arrayAdd,
+  arrayCollapse,
+  arrayDivide,
+  arrayDot,
+  arrayExcept,
+  arrayFirst,
+  arrayFlatten,
+  arrayGet,
+  arrayGroupBy,
+  arrayHas,
+  arrayOnly,
+  arrayPluck,
+  arrayUnique,
+  arrayWhere,
+  array_chunk,
+  array_column,
+  array_count_values,
+  array_diff,
+  array_filter,
+  array_flip,
+  array_intersect,
+  array_key_exists,
+  array_keys,
+  array_map,
+  array_merge,
+  array_pop,
+  array_product,
+  array_push,
+  array_rand,
+  array_reduce,
+  array_reverse,
+  array_search,
+  array_shift,
+  array_slice,
+  array_splice,
+  array_sum,
+  array_unique,
+  array_unshift,
+  blank,
+  camelCase,
+  capitalize,
+  collect,
+  collectMap,
+  data_get,
+  data_set,
+  dayjs,
+  diff,
+  filled,
+  fromNow,
+  isArray,
+  isBase64,
+  isBetweenDates,
+  isBlank,
+  isBoolean,
+  isDate,
+  isEmail,
+  isEmpty,
+  isEqual,
+  isEven,
+  isFalse,
+  isFloat,
+  isFunction,
+  isFuture,
+  isInteger,
+  isIp,
+  isJson,
+  isMacAddress,
+  isNotEmpty,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isOdd,
+  isPast,
+  isPresent,
+  isRecord,
+  isSet,
+  isString,
+  isToday,
+  isTrue,
+  isUndefined,
+  isUrl,
+  isUuid,
+  kebabCase,
+  mapToObject,
+  normalizeString,
+  now,
+  num,
+  numberFormat,
+  obj,
+  objectToMap,
+  optional,
+  php_array,
+  pipe,
+  range,
+  retry,
+  rsort,
+  safeValidateSchema,
+  shuffle,
+  slugify,
+  snakeCase,
+  sort,
+  str,
+  strContainsAll,
+  strContainsAny,
+  strFinish,
+  strLimit,
+  strMask,
+  strPadBoth,
+  strPadLeft,
+  strPadRight,
+  strRemove,
+  strReverse,
+  strStart,
+  strWordCount,
+  strWords,
+  studlyCase,
+  tap,
+  throw_if,
+  throw_unless,
+  titleCase,
+  today,
+  tomorrow,
+  uasort,
+  uksort,
+  usort,
+  validateSchema,
+  validator,
+  value,
+  when,
+  yesterday
+});