@turndown/library 0.1.24 → 0.1.28

package/dist/index.cjs

@@ -0,0 +1,1355 @@
+"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 index_exports = {};
+__export(index_exports, {
+  ACCOUNT_STATUS: () => ACCOUNT_STATUS,
+  ACCOUNT_TYPE: () => ACCOUNT_TYPE,
+  AUTH_STATUS: () => AUTH_STATUS,
+  BILLING_PERIOD: () => BILLING_PERIOD,
+  CHECKLIST_EXECUTION_STATUS: () => CHECKLIST_EXECUTION_STATUS,
+  COMPANY_TYPES: () => COMPANY_TYPES,
+  DAMAGE_SEVERITY: () => DAMAGE_SEVERITY,
+  DAMAGE_STATUS: () => DAMAGE_STATUS,
+  ERROR_CODES: () => ERROR_CODES,
+  HTTP_METHOD: () => HTTP_METHOD,
+  HTTP_STATUS: () => HTTP_STATUS,
+  IMAGE_ENTITY: () => IMAGE_ENTITY,
+  IMAGE_ENTITY_TYPE: () => IMAGE_ENTITY_TYPE,
+  INVENTORY_ITEM_TYPE: () => INVENTORY_ITEM_TYPE,
+  INVENTORY_UNITS: () => INVENTORY_UNITS,
+  JSONStringify: () => JSONStringify,
+  LANGUAGE: () => LANGUAGE,
+  MONTHS: () => MONTHS,
+  PROPERTY_STATUS: () => PROPERTY_STATUS,
+  PROPERTY_TYPES: () => PROPERTY_TYPES,
+  PropertyStatusOptions: () => PropertyStatusOptions,
+  PropertyTypeOptions: () => PropertyTypeOptions,
+  SERVICE_TYPES: () => SERVICE_TYPES,
+  SEVERITY: () => SEVERITY,
+  STATUS: () => STATUS,
+  SUBSCRIPTION_PROVIDER: () => SUBSCRIPTION_PROVIDER,
+  SUBSCRIPTION_STATUS: () => SUBSCRIPTION_STATUS,
+  ServiceTypeOptions: () => ServiceTypeOptions,
+  SeverityOptions: () => SeverityOptions,
+  StatusOptions: () => StatusOptions,
+  US_JURISDICTIONS: () => US_JURISDICTIONS,
+  US_STATES_CODE: () => US_STATES_CODE,
+  UnitedStatesJurisdictionOptions: () => UnitedStatesJurisdictionOptions,
+  WORK_ORDER_PRIORITY: () => WORK_ORDER_PRIORITY,
+  WORK_ORDER_STATUS: () => WORK_ORDER_STATUS,
+  WORK_SESSION_STATUS: () => WORK_SESSION_STATUS,
+  addDays: () => addDays,
+  addWeeks: () => addWeeks,
+  camelCase: () => camelCase,
+  capitalize: () => capitalize,
+  charCount: () => charCount,
+  chunkArray: () => chunkArray,
+  cleanFormData: () => cleanFormData,
+  containsAll: () => containsAll,
+  containsAny: () => containsAny,
+  convertStringBooleans: () => convertStringBooleans,
+  daysBetween: () => daysBetween,
+  deepClone: () => deepClone,
+  deletePropertyIfExists: () => deletePropertyIfExists,
+  endOfDay: () => endOfDay,
+  endOfWeek: () => endOfWeek,
+  escapeRegex: () => escapeRegex,
+  extractNumbers: () => extractNumbers,
+  filterArrayById: () => filterArrayById,
+  flatten: () => flatten,
+  formatAddress: () => formatAddress,
+  formatDate: () => formatDate,
+  formatNumber: () => formatNumber,
+  formatPhoneNumber: () => formatPhoneNumber,
+  fromBase64: () => fromBase64,
+  getFirstPropertyValue: () => getFirstPropertyValue,
+  getNestedValue: () => getNestedValue,
+  getWeekDays: () => getWeekDays,
+  hasOwnProp: () => hasOwnProp,
+  hasProperties: () => hasProperties,
+  hasProperty: () => hasProperty,
+  highlight: () => highlight,
+  isAuthError: () => isAuthError,
+  isEmail: () => isEmail,
+  isEmpty: () => isEmpty,
+  isFuture: () => isFuture,
+  isMissingFieldsError: () => isMissingFieldsError,
+  isNumeric: () => isNumeric,
+  isPalindrome: () => isPalindrome,
+  isPast: () => isPast,
+  isRateLimitError: () => isRateLimitError,
+  isToday: () => isToday,
+  isUrl: () => isUrl,
+  isValidationError: () => isValidationError,
+  kebabCase: () => kebabCase,
+  kebabToSpaces: () => kebabToSpaces,
+  longestWord: () => longestWord,
+  lowerCase: () => lowerCase,
+  normalCase: () => normalCase,
+  normalizeSpaces: () => normalizeSpaces,
+  omitProperties: () => omitProperties,
+  padEnd: () => padEnd,
+  padStart: () => padStart,
+  parseJSON: () => parseJSON,
+  parseNumber: () => parseNumber,
+  pascalCase: () => pascalCase,
+  pluralize: () => pluralize,
+  removeDuplicates: () => removeDuplicates,
+  removeFormProperties: () => removeFormProperties,
+  removeSpecialChars: () => removeSpecialChars,
+  removeUndefined: () => removeUndefined,
+  removeWhitespace: () => removeWhitespace,
+  repeat: () => repeat,
+  repeatChar: () => repeatChar,
+  replaceNulls: () => replaceNulls,
+  resetPagination: () => resetPagination,
+  returnObject: () => returnObject,
+  reverse: () => reverse,
+  sentenceCase: () => sentenceCase,
+  setNestedValue: () => setNestedValue,
+  slug: () => slug,
+  snakeCase: () => snakeCase,
+  snakeCaseToSpaces: () => snakeCaseToSpaces,
+  sortArrayByProperty: () => sortArrayByProperty,
+  splitMultiple: () => splitMultiple,
+  startOfDay: () => startOfDay,
+  startOfWeek: () => startOfWeek,
+  stringSimilarity: () => stringSimilarity,
+  stripHtml: () => stripHtml,
+  subtractDays: () => subtractDays,
+  subtractWeeks: () => subtractWeeks,
+  timeAgo: () => timeAgo,
+  titleCase: () => titleCase,
+  toBase64: () => toBase64,
+  toCamelCase: () => toCamelCase,
+  toKebabCase: () => toKebabCase,
+  toNumber: () => toNumber,
+  toPascalCase: () => toPascalCase,
+  toSnakeCase: () => toSnakeCase,
+  truncate: () => truncate,
+  unflatten: () => unflatten,
+  upperCase: () => upperCase,
+  validPath: () => validPath,
+  wordCount: () => wordCount
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/helpers/date/index.ts
+var import_dayjs = __toESM(require("dayjs"), 1);
+var import_isoWeek = __toESM(require("dayjs/plugin/isoWeek"), 1);
+var import_relativeTime = __toESM(require("dayjs/plugin/relativeTime"), 1);
+import_dayjs.default.extend(import_relativeTime.default);
+import_dayjs.default.extend(import_isoWeek.default);
+var defaultDateFallback = "--";
+var isValidDateInput = (date) => {
+  return date !== null && date !== void 0 && (0, import_dayjs.default)(date).isValid();
+};
+var formatDate = (date, format = "MM/DD/YYYY") => {
+  if (!isValidDateInput(date)) {
+    return defaultDateFallback;
+  }
+  return (0, import_dayjs.default)(date).format(format);
+};
+var timeAgo = (date) => {
+  if (!isValidDateInput(date)) {
+    return defaultDateFallback;
+  }
+  return (0, import_dayjs.default)(date).fromNow();
+};
+var addDays = (date, days) => {
+  return (0, import_dayjs.default)(date).add(days, "day").toDate();
+};
+var subtractDays = (date, days) => {
+  return (0, import_dayjs.default)(date).subtract(days, "day").toDate();
+};
+var daysBetween = (dateA, dateB) => {
+  if (!isValidDateInput(dateA) || !isValidDateInput(dateB)) {
+    return 0;
+  }
+  return Math.abs((0, import_dayjs.default)(dateA).diff((0, import_dayjs.default)(dateB), "day"));
+};
+var isToday = (date) => {
+  if (!isValidDateInput(date)) {
+    return false;
+  }
+  return (0, import_dayjs.default)(date).isSame((0, import_dayjs.default)(), "day");
+};
+var isPast = (date) => {
+  if (!isValidDateInput(date)) {
+    return false;
+  }
+  return (0, import_dayjs.default)(date).isBefore((0, import_dayjs.default)());
+};
+var isFuture = (date) => {
+  if (!isValidDateInput(date)) {
+    return false;
+  }
+  return (0, import_dayjs.default)(date).isAfter((0, import_dayjs.default)());
+};
+var startOfDay = (date) => {
+  return (0, import_dayjs.default)(date).startOf("day").toDate();
+};
+var endOfDay = (date) => {
+  return (0, import_dayjs.default)(date).endOf("day").toDate();
+};
+var startOfWeek = (date) => {
+  return (0, import_dayjs.default)(date).startOf("isoWeek").toDate();
+};
+var endOfWeek = (date) => {
+  return (0, import_dayjs.default)(date).endOf("isoWeek").toDate();
+};
+var getWeekDays = (date) => {
+  const weekStart = (0, import_dayjs.default)(date).startOf("isoWeek");
+  return Array.from({ length: 7 }, (_value, index) => {
+    return weekStart.add(index, "day").startOf("day").toDate();
+  });
+};
+var addWeeks = (date, weeks) => {
+  return (0, import_dayjs.default)(date).add(weeks, "week").toDate();
+};
+var subtractWeeks = (date, weeks) => {
+  return (0, import_dayjs.default)(date).subtract(weeks, "week").toDate();
+};
+
+// src/helpers/object/index.ts
+var unsafePathSegments = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+};
+var isSafePathSegment = (segment) => {
+  return segment.length > 0 && !unsafePathSegments.has(segment);
+};
+var getPathSegments = (path) => {
+  return path.split(".").filter((segment) => segment.length > 0);
+};
+function parseJSON(jsonString, fallbackValue) {
+  if (!jsonString) {
+    return fallbackValue ?? {};
+  }
+  try {
+    const parsedValue = JSON.parse(jsonString);
+    return parsedValue;
+  } catch {
+    return fallbackValue ?? {};
+  }
+}
+var JSONStringify = (value) => {
+  const seenValues = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, nestedValue) => {
+      if (typeof nestedValue === "bigint") {
+        return nestedValue.toString();
+      }
+      if (typeof nestedValue === "object" && nestedValue !== null) {
+        if (seenValues.has(nestedValue)) {
+          return void 0;
+        }
+        seenValues.add(nestedValue);
+      }
+      return nestedValue;
+    });
+  } catch {
+    return void 0;
+  }
+};
+var removeUndefined = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => removeUndefined(item));
+  }
+  if (isRecord(value)) {
+    const updatedValue = Object.entries(value).reduce(
+      (accumulator, [key, nestedValue]) => {
+        if (nestedValue !== void 0) {
+          accumulator[key] = removeUndefined(nestedValue);
+        }
+        return accumulator;
+      },
+      {}
+    );
+    return updatedValue;
+  }
+  return value;
+};
+var validPath = (location, key) => {
+  return location?.pathname === key;
+};
+var returnObject = (input) => {
+  return Array.isArray(input) ? input[0] : input;
+};
+var filterArrayById = (array1, array2) => {
+  if (!Array.isArray(array1) || !Array.isArray(array2)) {
+    return [];
+  }
+  const idsToExclude = new Set(array2.map((item) => item.id));
+  return array1.filter((item) => !idsToExclude.has(item.id));
+};
+var sortArrayByProperty = (array, property) => {
+  if (!Array.isArray(array) || array.length === 0) return [];
+  return array.sort((a, b) => {
+    const firstValue = a[property];
+    const secondValue = b[property];
+    if (firstValue === secondValue) return 0;
+    if (firstValue === null || firstValue === void 0) return 1;
+    if (secondValue === null || secondValue === void 0) return -1;
+    if (firstValue < secondValue) return -1;
+    if (firstValue > secondValue) return 1;
+    return 0;
+  });
+};
+var replaceNulls = (value) => {
+  if (value === null) {
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => replaceNulls(item));
+  }
+  if (isRecord(value)) {
+    const updatedValue = Object.entries(value).reduce(
+      (accumulator, [key, nestedValue]) => {
+        accumulator[key] = replaceNulls(nestedValue);
+        return accumulator;
+      },
+      {}
+    );
+    return updatedValue;
+  }
+  return value;
+};
+var removeFormProperties = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => removeFormProperties(item));
+  }
+  if (isRecord(value)) {
+    const updatedValue = Object.entries(value).reduce(
+      (accumulator, [key, nestedValue]) => {
+        if (!key.includes(".")) {
+          accumulator[key] = removeFormProperties(nestedValue);
+        }
+        return accumulator;
+      },
+      {}
+    );
+    return updatedValue;
+  }
+  return value;
+};
+var convertStringBooleans = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => convertStringBooleans(item));
+  }
+  if (isRecord(value)) {
+    const updatedValue = Object.entries(value).reduce(
+      (accumulator, [key, nestedValue]) => {
+        if (nestedValue === "true") {
+          accumulator[key] = true;
+        } else if (nestedValue === "false") {
+          accumulator[key] = false;
+        } else {
+          accumulator[key] = convertStringBooleans(nestedValue);
+        }
+        return accumulator;
+      },
+      {}
+    );
+    return updatedValue;
+  }
+  return value;
+};
+var cleanFormData = (objectToClean) => {
+  return removeFormProperties(
+    convertStringBooleans(removeUndefined(objectToClean))
+  );
+};
+var resetPagination = (sort, filters) => {
+  return {
+    page: 1,
+    size: 25,
+    sort: sort || [],
+    filters: filters || []
+  };
+};
+var formatPhoneNumber = (value) => {
+  const originalValue = value.toString();
+  const digits = originalValue.replace(/\D/g, "");
+  const normalizedDigits = digits.length === 11 && digits.startsWith("1") ? digits.slice(1) : digits;
+  if (normalizedDigits.length !== 10) return originalValue;
+  const area = normalizedDigits.slice(0, 3);
+  const prefix = normalizedDigits.slice(3, 6);
+  const line = normalizedDigits.slice(6);
+  return `(${area}) ${prefix}-${line}`;
+};
+var formatNumber = (value) => {
+  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+};
+var parseNumber = (value) => {
+  return value.toString().replace(/,/g, "");
+};
+var deletePropertyIfExists = (objectToUpdate, propertyName) => {
+  if (Object.prototype.hasOwnProperty.call(objectToUpdate, propertyName)) {
+    delete objectToUpdate[propertyName];
+  }
+};
+var chunkArray = (array, chunkSize) => {
+  if (!Array.isArray(array) || chunkSize <= 0 || !Number.isFinite(chunkSize)) {
+    return [];
+  }
+  const result = [];
+  const normalizedChunkSize = Math.floor(chunkSize);
+  for (let i = 0; i < array.length; i += normalizedChunkSize) {
+    result.push(array.slice(i, i + normalizedChunkSize));
+  }
+  return result;
+};
+var omitProperties = (objectToOmitFrom, propsToOmit) => {
+  const updatedObject = { ...objectToOmitFrom };
+  propsToOmit.forEach((propertyName) => {
+    delete updatedObject[propertyName];
+  });
+  return updatedObject;
+};
+var hasProperty = (value, key) => {
+  if (value === null || value === void 0) return false;
+  return Object.prototype.hasOwnProperty.call(value, key);
+};
+var hasOwnProp = (value, key) => {
+  return hasProperty(value, key);
+};
+var hasProperties = (value) => {
+  return isRecord(value) && Object.keys(value).length > 0;
+};
+var getFirstPropertyValue = (value) => {
+  if (value === null || value === void 0 || !hasProperties(value)) {
+    return null;
+  }
+  const source = value;
+  const keys = Object.keys(source);
+  return source[keys[0]];
+};
+var getNestedValue = (value, path) => {
+  const pathSegments = getPathSegments(path);
+  if (pathSegments.length === 0) {
+    return value;
+  }
+  let currentValue = value;
+  for (const pathSegment of pathSegments) {
+    if (!isSafePathSegment(pathSegment)) {
+      return void 0;
+    }
+    if (currentValue === null || currentValue === void 0) {
+      return void 0;
+    }
+    if (typeof currentValue !== "object" && typeof currentValue !== "function") {
+      return void 0;
+    }
+    currentValue = currentValue[pathSegment];
+  }
+  return currentValue;
+};
+var setNestedValue = (objectToUpdate, path, value) => {
+  const pathSegments = getPathSegments(path);
+  if (pathSegments.length === 0 || pathSegments.some((pathSegment) => !isSafePathSegment(pathSegment))) {
+    return objectToUpdate;
+  }
+  let currentValue = objectToUpdate;
+  for (let i = 0; i < pathSegments.length - 1; i += 1) {
+    const pathSegment = pathSegments[i];
+    const nextValue = currentValue[pathSegment];
+    if (!isRecord(nextValue)) {
+      currentValue[pathSegment] = {};
+    }
+    currentValue = currentValue[pathSegment];
+  }
+  currentValue[pathSegments[pathSegments.length - 1]] = value;
+  return objectToUpdate;
+};
+var deepClone = (value) => {
+  const cloneValue = (nestedValue, seenValues) => {
+    if (nestedValue === null || typeof nestedValue !== "object") {
+      return nestedValue;
+    }
+    if (nestedValue instanceof Date) {
+      return new Date(nestedValue.getTime());
+    }
+    if (seenValues.has(nestedValue)) {
+      return seenValues.get(nestedValue);
+    }
+    if (Array.isArray(nestedValue)) {
+      const clonedArray = [];
+      seenValues.set(nestedValue, clonedArray);
+      nestedValue.forEach((item) => {
+        clonedArray.push(cloneValue(item, seenValues));
+      });
+      return clonedArray;
+    }
+    const clonedObject = Object.create(
+      Object.getPrototypeOf(nestedValue)
+    );
+    seenValues.set(nestedValue, clonedObject);
+    Reflect.ownKeys(nestedValue).forEach((key) => {
+      clonedObject[key] = cloneValue(
+        nestedValue[key],
+        seenValues
+      );
+    });
+    return clonedObject;
+  };
+  return cloneValue(value, /* @__PURE__ */ new WeakMap());
+};
+var flatten = (value, prefix = "") => {
+  const result = {};
+  Object.entries(value).forEach(([key, nestedValue]) => {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (isRecord(nestedValue)) {
+      Object.assign(result, flatten(nestedValue, newKey));
+      return;
+    }
+    result[newKey] = nestedValue;
+  });
+  return result;
+};
+var unflatten = (value) => {
+  const result = {};
+  Object.entries(value).forEach(([key, nestedValue]) => {
+    setNestedValue(result, key, nestedValue);
+  });
+  return result;
+};
+
+// src/helpers/string/index.ts
+var wordBoundaryRegex = /([a-z0-9])([A-Z])/g;
+var acronymBoundaryRegex = /([A-Z]+)([A-Z][a-z])/g;
+var getWords = (value) => {
+  return value.trim().replace(acronymBoundaryRegex, "$1 $2").replace(wordBoundaryRegex, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean);
+};
+var capitalizeWord = (value) => {
+  if (!value) {
+    return "";
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+};
+var normalCase = (str) => {
+  if (!str) {
+    return "";
+  }
+  return getWords(str).map(capitalizeWord).join(" ");
+};
+var sentenceCase = (str) => {
+  if (!str) {
+    return "";
+  }
+  const normalizedValue = str.trim().toLowerCase();
+  return normalizedValue.charAt(0).toUpperCase() + normalizedValue.slice(1);
+};
+var upperCase = (str) => {
+  return str?.toUpperCase() ?? "";
+};
+var lowerCase = (str) => {
+  return str?.toLowerCase() ?? "";
+};
+var toCamelCase = (str) => {
+  const words = getWords(str);
+  if (words.length === 0) {
+    return "";
+  }
+  const [firstWord, ...remainingWords] = words;
+  return [firstWord.toLowerCase(), ...remainingWords.map(capitalizeWord)].join(
+    ""
+  );
+};
+var camelCase = toCamelCase;
+var toKebabCase = (str) => {
+  return getWords(str).map((word) => word.toLowerCase()).join("-");
+};
+var kebabCase = toKebabCase;
+var toSnakeCase = (str) => {
+  return getWords(str).map((word) => word.toLowerCase()).join("_");
+};
+var snakeCase = toSnakeCase;
+var toPascalCase = (str) => {
+  return getWords(str).map(capitalizeWord).join("");
+};
+var pascalCase = toPascalCase;
+var snakeCaseToSpaces = (str) => {
+  return str.replace(/_+/g, " ").trim();
+};
+var kebabToSpaces = (str) => {
+  return str.replace(/-+/g, " ").trim();
+};
+var capitalize = (str) => {
+  if (!str) {
+    return "";
+  }
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var titleCase = (str) => {
+  return str.replace(/\b\w/g, (char) => char.toUpperCase());
+};
+var truncate = (str, length, suffix = "...") => {
+  if (length <= 0) {
+    return "";
+  }
+  if (str.length <= length) {
+    return str;
+  }
+  const maxLength = Math.max(0, length - suffix.length);
+  if (maxLength === 0) {
+    return suffix.length > length ? "" : suffix;
+  }
+  return str.slice(0, maxLength) + suffix;
+};
+var removeWhitespace = (str) => {
+  return str.replace(/\s+/g, "");
+};
+var removeSpecialChars = (str) => {
+  return str.replace(/[^a-zA-Z0-9]/g, "");
+};
+var slug = (str) => {
+  return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+};
+var isEmail = (str) => {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(str.trim());
+};
+var isUrl = (str) => {
+  try {
+    const parsedUrl = new URL(str);
+    return parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+var isNumeric = (str) => {
+  return /^\d+$/.test(str);
+};
+var isEmpty = (str) => {
+  return str.trim().length === 0;
+};
+var reverse = (str) => {
+  return Array.from(str).reverse().join("");
+};
+var repeat = (str, times) => {
+  return str.repeat(Math.max(0, Math.floor(times)));
+};
+var padStart = (str, length, padChar = " ") => {
+  return str.padStart(length, padChar);
+};
+var padEnd = (str, length, padChar = " ") => {
+  return str.padEnd(length, padChar);
+};
+var toBase64 = (str) => {
+  return Buffer.from(str, "utf-8").toString("base64");
+};
+var fromBase64 = (str) => {
+  return Buffer.from(str, "base64").toString("utf-8");
+};
+var wordCount = (str) => {
+  const trimmedValue = str.trim();
+  if (!trimmedValue) {
+    return 0;
+  }
+  return trimmedValue.split(/\s+/).length;
+};
+var charCount = (str) => {
+  return str.replace(/\s/g, "").length;
+};
+var repeatChar = (char, times) => {
+  return char.repeat(Math.max(0, Math.floor(times)));
+};
+var extractNumbers = (str) => {
+  return str.replace(/\D/g, "");
+};
+var removeDuplicates = (str) => {
+  return str.replace(/(.)\1+/g, "$1");
+};
+var isPalindrome = (str) => {
+  const cleaned = str.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return cleaned === cleaned.split("").reverse().join("");
+};
+var longestWord = (str) => {
+  const words = str.trim().split(/\s+/).filter(Boolean);
+  return words.reduce(
+    (longest, word) => word.length > longest.length ? word : longest,
+    ""
+  );
+};
+var pluralize = (word) => {
+  const exceptions = {
+    child: "children",
+    person: "people",
+    man: "men",
+    woman: "women",
+    tooth: "teeth",
+    foot: "feet",
+    mouse: "mice"
+  };
+  const lowercaseWord = word.toLowerCase();
+  const exception = exceptions[lowercaseWord];
+  if (exception) {
+    return word.charAt(0) === word.charAt(0).toUpperCase() ? capitalize(exception) : exception;
+  }
+  if (/[^aeiou]y$/i.test(word)) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (/(s|x|z|ch|sh)$/i.test(word)) {
+    return `${word}es`;
+  }
+  if (/fe$/i.test(word)) {
+    return `${word.slice(0, -2)}ves`;
+  }
+  if (/f$/i.test(word)) {
+    return `${word.slice(0, -1)}ves`;
+  }
+  return `${word}s`;
+};
+var highlight = (str, substring, marker = "**") => {
+  if (!substring) {
+    return str;
+  }
+  return str.replace(
+    new RegExp(`(${escapeRegex(substring)})`, "gi"),
+    `${marker}$1${marker}`
+  );
+};
+var escapeRegex = (str) => {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+var stringSimilarity = (str1, str2) => {
+  const s1 = str1.toLowerCase();
+  const s2 = str2.toLowerCase();
+  const longer = s1.length > s2.length ? s1 : s2;
+  const shorter = s1.length > s2.length ? s2 : s1;
+  if (longer.length === 0) {
+    return 1;
+  }
+  const editDistance = getEditDistance(longer, shorter);
+  return (longer.length - editDistance) / longer.length;
+};
+var getEditDistance = (s1, s2) => {
+  const costs = [];
+  for (let i = 0; i <= s1.length; i += 1) {
+    let lastValue = i;
+    for (let j = 0; j <= s2.length; j += 1) {
+      if (i === 0) {
+        costs[j] = j;
+      } else if (j > 0) {
+        let newValue = costs[j - 1];
+        if (s1.charAt(i - 1) !== s2.charAt(j - 1)) {
+          newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
+        }
+        costs[j - 1] = lastValue;
+        lastValue = newValue;
+      }
+    }
+    if (i > 0) {
+      costs[s2.length] = lastValue;
+    }
+  }
+  return costs[s2.length];
+};
+var stripHtml = (str) => {
+  return str.replace(/<[^>]*>/g, "");
+};
+var normalizeSpaces = (str) => {
+  return str.replace(/\s+/g, " ").trim();
+};
+var toNumber = (str) => {
+  if (str.trim() === "") {
+    return null;
+  }
+  const num = Number(str);
+  return Number.isNaN(num) ? null : num;
+};
+var splitMultiple = (str, ...delimiters) => {
+  if (delimiters.length === 0) {
+    return [str].filter((part) => part.length > 0);
+  }
+  let result = [str];
+  delimiters.forEach((delimiter) => {
+    if (delimiter !== "") {
+      result = result.flatMap((part) => part.split(delimiter));
+    }
+  });
+  return result.filter((part) => part.length > 0);
+};
+var containsAny = (str, ...substrings) => {
+  return substrings.some((substring) => str.includes(substring));
+};
+var containsAll = (str, ...substrings) => {
+  return substrings.every((substring) => str.includes(substring));
+};
+var formatAddress = (address) => {
+  const parts = [
+    address.addressLine1,
+    address.addressLine2,
+    address.city,
+    address.stateCode,
+    address.postalCode
+  ].filter(Boolean);
+  return parts.join(", ");
+};
+
+// src/types/api/index.ts
+var HTTP_METHOD = {
+  Get: "GET",
+  Post: "POST",
+  Put: "PUT",
+  Patch: "PATCH",
+  Delete: "DELETE"
+};
+var ERROR_CODES = {
+  // 400 - Bad Request
+  BAD_REQUEST: "BAD_REQUEST",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  MISSING_FIELDS: "MISSING_FIELDS",
+  // 401 - Unauthorized
+  UNAUTHORIZED: "UNAUTHORIZED",
+  INVALID_TOKEN: "INVALID_TOKEN",
+  INVALID_CREDENTIALS: "INVALID_CREDENTIALS",
+  // 403 - Forbidden
+  FORBIDDEN: "FORBIDDEN",
+  // 404 - Not Found
+  NOT_FOUND: "NOT_FOUND",
+  // 409 - Conflict
+  CONFLICT: "CONFLICT",
+  ALREADY_EXISTS: "ALREADY_EXISTS",
+  // 429 - Rate Limiting
+  RATE_LIMIT: "RATE_LIMIT",
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  // 500 - Server Errors
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  DATABASE_ERROR: "DATABASE_ERROR"
+};
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  RATE_LIMIT: 429,
+  INTERNAL_ERROR: 500
+};
+
+// src/types/auth/index.ts
+var AUTH_STATUS = {
+  Initializing: "Initializing",
+  Unauthenticated: "Unauthenticated",
+  Authenticated: "Authenticated",
+  Refreshing: "Refreshing",
+  SessionExpired: "SessionExpired"
+};
+
+// src/types/base/index.ts
+var IMAGE_ENTITY = {
+  USER_PROFILE: "user_profile",
+  PROPERTY: "property",
+  PROPERTY_ROOM: "property_room",
+  MAINTENANCE_TICKET: "maintenance_ticket",
+  WORK_REPORT: "work_report"
+};
+var US_STATES_CODE = {
+  // 50 States
+  AL: "AL",
+  AK: "AK",
+  AZ: "AZ",
+  AR: "AR",
+  CA: "CA",
+  CO: "CO",
+  CT: "CT",
+  DE: "DE",
+  FL: "FL",
+  GA: "GA",
+  HI: "HI",
+  ID: "ID",
+  IL: "IL",
+  IN: "IN",
+  IA: "IA",
+  KS: "KS",
+  KY: "KY",
+  LA: "LA",
+  ME: "ME",
+  MD: "MD",
+  MA: "MA",
+  MI: "MI",
+  MN: "MN",
+  MS: "MS",
+  MO: "MO",
+  MT: "MT",
+  NE: "NE",
+  NV: "NV",
+  NH: "NH",
+  NJ: "NJ",
+  NM: "NM",
+  NY: "NY",
+  NC: "NC",
+  ND: "ND",
+  OH: "OH",
+  OK: "OK",
+  OR: "OR",
+  PA: "PA",
+  RI: "RI",
+  SC: "SC",
+  SD: "SD",
+  TN: "TN",
+  TX: "TX",
+  UT: "UT",
+  VT: "VT",
+  VA: "VA",
+  WA: "WA",
+  WV: "WV",
+  WI: "WI",
+  WY: "WY",
+  // Territories
+  DC: "DC",
+  PR: "PR",
+  GU: "GU",
+  VI: "VI",
+  AS: "AS",
+  MP: "MP"
+};
+var US_JURISDICTIONS = {
+  // 50 States
+  AL: "Alabama",
+  AK: "Alaska",
+  AZ: "Arizona",
+  AR: "Arkansas",
+  CA: "California",
+  CO: "Colorado",
+  CT: "Connecticut",
+  DE: "Delaware",
+  FL: "Florida",
+  GA: "Georgia",
+  HI: "Hawaii",
+  ID: "Idaho",
+  IL: "Illinois",
+  IN: "Indiana",
+  IA: "Iowa",
+  KS: "Kansas",
+  KY: "Kentucky",
+  LA: "Louisiana",
+  ME: "Maine",
+  MD: "Maryland",
+  MA: "Massachusetts",
+  MI: "Michigan",
+  MN: "Minnesota",
+  MS: "Mississippi",
+  MO: "Missouri",
+  MT: "Montana",
+  NE: "Nebraska",
+  NV: "Nevada",
+  NH: "New Hampshire",
+  NJ: "New Jersey",
+  NM: "New Mexico",
+  NY: "New York",
+  NC: "North Carolina",
+  ND: "North Dakota",
+  OH: "Ohio",
+  OK: "Oklahoma",
+  OR: "Oregon",
+  PA: "Pennsylvania",
+  RI: "Rhode Island",
+  SC: "South Carolina",
+  SD: "South Dakota",
+  TN: "Tennessee",
+  TX: "Texas",
+  UT: "Utah",
+  VT: "Vermont",
+  VA: "Virginia",
+  WA: "Washington",
+  WV: "West Virginia",
+  WI: "Wisconsin",
+  WY: "Wyoming",
+  // Territories
+  DC: "District of Columbia",
+  PR: "Puerto Rico",
+  GU: "Guam",
+  VI: "United States Virgin Islands",
+  AS: "American Samoa",
+  MP: "Northern Mariana Islands"
+};
+var UnitedStatesJurisdictionOptions = Object.values(
+  US_JURISDICTIONS
+).map((jurisdiction) => ({
+  label: jurisdiction,
+  value: jurisdiction
+}));
+var STATUS = {
+  Pending: "Pending",
+  InProgress: "InProgress",
+  Completed: "Completed",
+  Overdue: "Overdue",
+  Active: "Active",
+  Inactive: "Inactive"
+};
+var StatusOptions = Object.values(STATUS).map((status) => ({
+  label: status,
+  value: status
+}));
+var SEVERITY = {
+  Low: "Low",
+  Medium: "Medium",
+  High: "High"
+};
+var SeverityOptions = Object.values(SEVERITY).map((severity) => ({
+  label: severity,
+  value: severity
+}));
+var SERVICE_TYPES = {
+  Cleaning: "Cleaning",
+  Maintenance: "Maintenance",
+  Inspection: "Inspections",
+  Other: "Other"
+};
+var ServiceTypeOptions = Object.values(SERVICE_TYPES).map(
+  (serviceType) => ({
+    label: serviceType,
+    value: serviceType
+  })
+);
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+
+// src/types/company/index.ts
+var COMPANY_TYPES = {
+  PROPERTY_MANAGEMENT: "PROPERTY_MANAGEMENT",
+  MAINTENANCE: "MAINTENANCE",
+  CLEANER: "CLEANER",
+  OTHER: "OTHER"
+};
+
+// src/types/damage-report/index.ts
+var DAMAGE_SEVERITY = {
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  HIGH: "HIGH",
+  CRITICAL: "CRITICAL"
+};
+var DAMAGE_STATUS = {
+  OPEN: "OPEN",
+  IN_REVIEW: "IN_REVIEW",
+  ASSIGNED: "ASSIGNED",
+  IN_PROGRESS: "IN_PROGRESS",
+  RESOLVED: "RESOLVED",
+  CLOSED: "CLOSED",
+  ESCALATED: "ESCALATED"
+};
+var WORK_ORDER_PRIORITY = {
+  LOW: "LOW",
+  NORMAL: "NORMAL",
+  HIGH: "HIGH",
+  URGENT: "URGENT"
+};
+var WORK_ORDER_STATUS = {
+  PENDING: "PENDING",
+  SCHEDULED: "SCHEDULED",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  CANCELLED: "CANCELLED"
+};
+
+// src/types/errors/index.ts
+var isErrorLike = (error) => {
+  return typeof error === "object" && error !== null;
+};
+function isValidationError(error) {
+  return isErrorLike(error) && error.code === "VALIDATION_ERROR" && Array.isArray(error.details);
+}
+function isMissingFieldsError(error) {
+  return isErrorLike(error) && error.code === "MISSING_FIELDS" && typeof error.details === "object" && error.details !== null && "missingFields" in error.details && Array.isArray(error.details.missingFields);
+}
+function isRateLimitError(error) {
+  return isErrorLike(error) && error.code === "RATE_LIMIT_EXCEEDED";
+}
+function isAuthError(error) {
+  return isErrorLike(error) && (error.code === "UNAUTHORIZED" || error.code === "INVALID_TOKEN" || error.code === "INVALID_CREDENTIALS");
+}
+
+// src/types/image/index.ts
+var IMAGE_ENTITY_TYPE = {
+  USER_PROFILE: "USER_PROFILE",
+  PROPERTY: "PROPERTY",
+  COMPANY: "COMPANY",
+  CHECKLIST_ITEM: "CHECKLIST_ITEM",
+  PROPERTY_ROOM: "PROPERTY_ROOM",
+  MAINTENANCE_TICKET: "MAINTENANCE_TICKET",
+  WORK_REPORT: "WORK_REPORT",
+  CLEANING_REPORT: "CLEANING_REPORT",
+  TURNDOWN_DEFAULT: "TURNDOWN_DEFAULT"
+};
+
+// src/types/inventory/index.ts
+var INVENTORY_UNITS = {
+  COUNT: "COUNT",
+  ROLLS: "ROLLS",
+  PODS: "PODS",
+  BOXES: "BOXES",
+  BOTTLES: "BOTTLES",
+  PACKS: "PACKS",
+  BAGS: "BAGS",
+  GALLONS: "GALLONS",
+  LITERS: "LITERS",
+  KILOGRAMS: "KILOGRAMS",
+  POUNDS: "POUNDS",
+  OUNCES: "OUNCES",
+  GRAMS: "GRAMS",
+  SHEETS: "SHEETS",
+  CASES: "CASES",
+  CARTONS: "CARTONS",
+  OTHER: "OTHER"
+};
+var INVENTORY_ITEM_TYPE = {
+  CONSUMABLE: "CONSUMABLE",
+  FIXED: "FIXED"
+};
+
+// src/types/property/index.ts
+var PROPERTY_STATUS = {
+  Active: "Active",
+  Inactive: "Inactive"
+};
+var PropertyStatusOptions = [
+  {
+    label: "Active",
+    value: PROPERTY_STATUS.Active
+  },
+  {
+    label: "Inactive",
+    value: PROPERTY_STATUS.Inactive
+  }
+];
+var PROPERTY_TYPES = [
+  "Apartment",
+  "Commercial",
+  "Condo",
+  "House"
+];
+var PropertyTypeOptions = PROPERTY_TYPES.map((propertyType) => ({
+  label: propertyType,
+  value: propertyType
+}));
+
+// src/types/subscription/index.ts
+var SUBSCRIPTION_STATUS = {
+  ACTIVE: "active",
+  CANCELED: "canceled",
+  EXPIRED: "expired",
+  PAST_DUE: "past_due",
+  TRIALING: "trialing"
+};
+var SUBSCRIPTION_PROVIDER = {
+  STRIPE: "stripe",
+  APPLE: "apple",
+  GOOGLE: "google"
+};
+var BILLING_PERIOD = {
+  MONTHLY: "monthly",
+  YEARLY: "yearly"
+};
+
+// src/types/user/index.ts
+var ACCOUNT_TYPE = {
+  TURNDOWN_ADMIN: "TURNDOWN_ADMIN",
+  ACCOUNT_ADMIN: "ACCOUNT_ADMIN",
+  MANAGER: "MANAGER",
+  STAFF: "STAFF",
+  GUEST: "GUEST"
+};
+var ACCOUNT_STATUS = {
+  ACTIVE: "ACTIVE",
+  INACTIVE: "INACTIVE",
+  SUSPENDED: "SUSPENDED",
+  PENDING: "PENDING"
+};
+var LANGUAGE = {
+  ENGLISH: "ENGLISH",
+  FRENCH: "FRENCH",
+  SPANISH: "SPANISH",
+  GERMAN: "GERMAN"
+};
+
+// src/types/work-session/index.ts
+var WORK_SESSION_STATUS = {
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  CANCELLED: "CANCELLED"
+};
+var CHECKLIST_EXECUTION_STATUS = {
+  PENDING: "PENDING",
+  IN_PROGRESS: "IN_PROGRESS",
+  COMPLETED: "COMPLETED",
+  SKIPPED: "SKIPPED"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCOUNT_STATUS,
+  ACCOUNT_TYPE,
+  AUTH_STATUS,
+  BILLING_PERIOD,
+  CHECKLIST_EXECUTION_STATUS,
+  COMPANY_TYPES,
+  DAMAGE_SEVERITY,
+  DAMAGE_STATUS,
+  ERROR_CODES,
+  HTTP_METHOD,
+  HTTP_STATUS,
+  IMAGE_ENTITY,
+  IMAGE_ENTITY_TYPE,
+  INVENTORY_ITEM_TYPE,
+  INVENTORY_UNITS,
+  JSONStringify,
+  LANGUAGE,
+  MONTHS,
+  PROPERTY_STATUS,
+  PROPERTY_TYPES,
+  PropertyStatusOptions,
+  PropertyTypeOptions,
+  SERVICE_TYPES,
+  SEVERITY,
+  STATUS,
+  SUBSCRIPTION_PROVIDER,
+  SUBSCRIPTION_STATUS,
+  ServiceTypeOptions,
+  SeverityOptions,
+  StatusOptions,
+  US_JURISDICTIONS,
+  US_STATES_CODE,
+  UnitedStatesJurisdictionOptions,
+  WORK_ORDER_PRIORITY,
+  WORK_ORDER_STATUS,
+  WORK_SESSION_STATUS,
+  addDays,
+  addWeeks,
+  camelCase,
+  capitalize,
+  charCount,
+  chunkArray,
+  cleanFormData,
+  containsAll,
+  containsAny,
+  convertStringBooleans,
+  daysBetween,
+  deepClone,
+  deletePropertyIfExists,
+  endOfDay,
+  endOfWeek,
+  escapeRegex,
+  extractNumbers,
+  filterArrayById,
+  flatten,
+  formatAddress,
+  formatDate,
+  formatNumber,
+  formatPhoneNumber,
+  fromBase64,
+  getFirstPropertyValue,
+  getNestedValue,
+  getWeekDays,
+  hasOwnProp,
+  hasProperties,
+  hasProperty,
+  highlight,
+  isAuthError,
+  isEmail,
+  isEmpty,
+  isFuture,
+  isMissingFieldsError,
+  isNumeric,
+  isPalindrome,
+  isPast,
+  isRateLimitError,
+  isToday,
+  isUrl,
+  isValidationError,
+  kebabCase,
+  kebabToSpaces,
+  longestWord,
+  lowerCase,
+  normalCase,
+  normalizeSpaces,
+  omitProperties,
+  padEnd,
+  padStart,
+  parseJSON,
+  parseNumber,
+  pascalCase,
+  pluralize,
+  removeDuplicates,
+  removeFormProperties,
+  removeSpecialChars,
+  removeUndefined,
+  removeWhitespace,
+  repeat,
+  repeatChar,
+  replaceNulls,
+  resetPagination,
+  returnObject,
+  reverse,
+  sentenceCase,
+  setNestedValue,
+  slug,
+  snakeCase,
+  snakeCaseToSpaces,
+  sortArrayByProperty,
+  splitMultiple,
+  startOfDay,
+  startOfWeek,
+  stringSimilarity,
+  stripHtml,
+  subtractDays,
+  subtractWeeks,
+  timeAgo,
+  titleCase,
+  toBase64,
+  toCamelCase,
+  toKebabCase,
+  toNumber,
+  toPascalCase,
+  toSnakeCase,
+  truncate,
+  unflatten,
+  upperCase,
+  validPath,
+  wordCount
+});