@gnwebsoft/ui 4.1.2 → 4.2.0

package/dist/chunk-VDANRHRZ.js

@@ -0,0 +1,568 @@
+// src/utils/fileUtils.ts
+var IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp"];
+var DOCUMENT_EXTENSIONS = [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".txt"];
+var ALL_FILE_EXTENSIONS = [...IMAGE_EXTENSIONS, ...DOCUMENT_EXTENSIONS];
+var IMAGE_EXT_SET = new Set(IMAGE_EXTENSIONS);
+function isImageFile(file) {
+  if (file.type.startsWith("image/")) return true;
+  const ext = "." + file.name.split(".").pop()?.toLowerCase();
+  return IMAGE_EXT_SET.has(ext);
+}
+function isImageMimeType(mimeType) {
+  return mimeType.startsWith("image/");
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${units[i]}`;
+}
+
+// src/utils/flattenObjectKeys.ts
+var isNested = (obj) => typeof obj === "object" && obj !== null && !Array.isArray(obj);
+var isArray = (obj) => Array.isArray(obj);
+var flattenObjectKeys = (obj, prefix = "") => {
+  if (!isNested(obj)) {
+    return {
+      [prefix]: obj
+    };
+  }
+  return Object.keys(obj).reduce((acc, key) => {
+    const currentPrefix = prefix.length ? `${prefix}.` : "";
+    if (isNested(obj[key]) && Object.keys(obj[key]).length) {
+      if (isArray(obj[key]) && obj[key].length) {
+        obj[key].forEach((item, index) => {
+          Object.assign(
+            acc,
+            flattenObjectKeys(item, `${currentPrefix + key}.${index}`)
+          );
+        });
+      } else {
+        Object.assign(acc, flattenObjectKeys(obj[key], currentPrefix + key));
+      }
+      acc[currentPrefix + key] = obj[key];
+    } else {
+      acc[currentPrefix + key] = obj[key];
+    }
+    return acc;
+  }, {});
+};
+
+// src/utils/getTimezone.ts
+function getTimezone(adapter, value) {
+  return value == null || !adapter.utils.isValid(value) ? null : adapter.utils.getTimezone(value);
+}
+
+// src/utils/handleServerErrors.ts
+var handleServerErrors = function handleServerErrors2(args) {
+  const { errors, setError } = args;
+  for (const key in errors) {
+    const isKeyInVariables = Object.keys(flattenObjectKeys(errors)).includes(
+      key
+    );
+    if (!isKeyInVariables) {
+      continue;
+    }
+    const fieldError = errors[key];
+    let errorMessage = "";
+    if (Array.isArray(fieldError)) {
+      errorMessage = fieldError.join(" ");
+    }
+    if (typeof fieldError === "string") {
+      errorMessage = fieldError;
+    }
+    if (typeof fieldError === "boolean" && fieldError) {
+      errorMessage = "Field is not valid.";
+    }
+    setError(key, {
+      message: errorMessage
+    });
+  }
+};
+
+// src/utils/propertyExists.ts
+function propertyExists(obj, prop) {
+  return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+// src/utils/readValueAsDate.ts
+function readValueAsDate(adapter, value) {
+  if (typeof value === "string") {
+    if (value === "") {
+      return null;
+    }
+    return adapter.utils.date(value);
+  }
+  return value;
+}
+
+// src/utils/removeLeadingTrailingSlashes.ts
+var removeLeadingTrailingSlashes = (route) => {
+  return route.replace(/^\/|\/$/g, "");
+};
+
+// src/utils/schemaTools.ts
+import dayjs from "dayjs";
+import { z } from "zod";
+function isValidLuhn(value) {
+  if (!value || value.trim() === "") {
+    return false;
+  }
+  const number = value.replace(/[\s-]/g, "");
+  if (!/^\d+$/.test(number)) {
+    return false;
+  }
+  if (number.length < 13 || number.length > 19) {
+    return false;
+  }
+  let sum = 0;
+  let alternate = false;
+  for (let i = number.length - 1; i >= 0; i--) {
+    let digit = parseInt(number.charAt(i), 10);
+    if (alternate) {
+      digit *= 2;
+      if (digit > 9) {
+        digit -= 9;
+      }
+    }
+    sum += digit;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+var schemaTools = {
+  // Date validations
+  date: ({ message } = {}) => z.coerce.string().transform((c) => c === "null" || c === "undefined" ? null : c).refine((c) => !!c, { message: message || "Date is required" }).refine((c) => c ? dayjs(c).isValid() : true, {
+    message: message || "Invalid date"
+  }),
+  nullableDate: ({ message } = {}) => z.coerce.string().transform((c) => c === "null" ? null : c).transform((c) => c === "undefined" ? null : c).refine((c) => !c && c !== null ? dayjs(c).isValid() : true, {
+    message: message || "Invalid date"
+  }),
+  pastDate: ({ message } = {}) => z.coerce.date().refine((date) => date < /* @__PURE__ */ new Date(), {
+    message: message || "Must be a past date"
+  }),
+  futureDate: ({ message } = {}) => z.coerce.date().refine((date) => date > /* @__PURE__ */ new Date(), {
+    message: message || "Must be a future date"
+  }),
+  todayOrFutureDate: ({ message } = {}) => z.coerce.date().refine(
+    (date) => {
+      const today = /* @__PURE__ */ new Date();
+      today.setHours(0, 0, 0, 0);
+      return date.setHours(0, 0, 0, 0) >= today.getTime();
+    },
+    { message: message || "Must be today or a future date" }
+  ),
+  todayOrPastDate: ({ message } = {}) => z.coerce.date().refine(
+    (date) => {
+      const today = /* @__PURE__ */ new Date();
+      today.setHours(0, 0, 0, 0);
+      return date.setHours(0, 0, 0, 0) <= today.getTime();
+    },
+    { message: message || "Must be today or a past date" }
+  ),
+  adult: ({ message } = {}) => z.coerce.date().refine(
+    (date) => {
+      const eighteenYearsAgo = /* @__PURE__ */ new Date();
+      eighteenYearsAgo.setFullYear(eighteenYearsAgo.getFullYear() - 18);
+      eighteenYearsAgo.setHours(0, 0, 0, 0);
+      const dob = new Date(date);
+      dob.setHours(0, 0, 0, 0);
+      return dob <= eighteenYearsAgo;
+    },
+    { message: message || "Must be at least 18 years old" }
+  ),
+  minimumAge: ({
+    message,
+    minimumAge
+  } = {}) => z.coerce.date().refine(
+    (date) => {
+      if (typeof minimumAge !== "number") return false;
+      const minYearsAgo = /* @__PURE__ */ new Date();
+      minYearsAgo.setFullYear(minYearsAgo.getFullYear() - minimumAge);
+      minYearsAgo.setHours(0, 0, 0, 0);
+      const dob = new Date(date);
+      dob.setHours(0, 0, 0, 0);
+      return dob <= minYearsAgo;
+    },
+    {
+      message: message || `Must be at least ${minimumAge ?? "the required"} years old`
+    }
+  ),
+  withinDays: ({ message, days } = {}) => z.coerce.date().refine(
+    (date) => {
+      const today = /* @__PURE__ */ new Date();
+      today.setHours(0, 0, 0, 0);
+      const inputDate = new Date(date);
+      inputDate.setHours(0, 0, 0, 0);
+      const diffTime = Math.abs(inputDate.getTime() - today.getTime());
+      const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+      return typeof days === "number" ? diffDays <= days : false;
+    },
+    { message: message || `Must be within ${days} days of today` }
+  ),
+  weekday: ({ message } = {}) => z.coerce.date().refine(
+    (date) => {
+      const day = date.getDay();
+      return day !== 0 && day !== 6;
+    },
+    { message: message || "Must be a weekday" }
+  ),
+  dateRange: ({ message } = {}) => z.object({
+    start: z.coerce.date(),
+    end: z.coerce.date()
+  }).refine((data) => data.start <= data.end, {
+    message: message || "Start date must be before or equal to end date"
+  }),
+  time: ({ message } = {}) => z.coerce.date().transform((c) => c === null || c === void 0 ? null : c).refine((c) => !!c, { message: message || "Time is required" }).refine((c) => c ? dayjs(c).isValid() : true, {
+    message: message || "Invalid time"
+  }),
+  dateTime: ({ message } = {}) => z.coerce.date().transform((c) => c === null || c === void 0 ? null : c).refine((c) => !!c, { message: message || "Date and Time is required" }).refine((c) => c ? dayjs(c).isValid() : true, {
+    message: message || "Invalid Date and Time"
+  }),
+  // String validations
+  requiredString: ({
+    message,
+    min,
+    max
+  } = {}) => z.string().trim().min(
+    min || 1,
+    message || `String must be at least ${min || 1} characters`
+  ).max(
+    max || 255,
+    message || `String must be at most ${max || 255} characters`
+  ),
+  email: ({ message } = {}) => z.string().email(message || "Invalid email address").max(254, "Email must be at most 254 characters"),
+  url: ({ message } = {}) => z.string().url(message || "Invalid URL format"),
+  phone: ({ message } = {}) => z.string().regex(/^[+]?[1-9][\d]{0,15}$/, message || "Invalid phone number format"),
+  creditCard: ({ message } = {}) => z.string().refine((value) => isValidLuhn(value), {
+    message: message || "Must be a valid credit card number"
+  }),
+  indianMobile: ({ message } = {}) => z.string().regex(/^[6-9]\d{9}$/, message || "Must be a valid Indian mobile number"),
+  internationalPhone: ({ message } = {}) => z.string().regex(
+    /^\+?[1-9]\d{6,14}$/,
+    message || "Must be a valid international phone number"
+  ),
+  alphabetic: ({ message } = {}) => z.string().regex(
+    /^[A-Za-z, ]+$/,
+    message || "Must contain only letters, commas, and spaces"
+  ),
+  guid: ({ message } = {}) => z.string().uuid(message || "Must be a valid GUID"),
+  nonEmptyOrWhitespace: ({ message } = {}) => z.string().trim().min(1, message || "Must not be empty or whitespace"),
+  username: ({ message } = {}) => z.string().regex(
+    /^[a-zA-Z][a-zA-Z0-9_]{2,29}$/,
+    message || "Must be 3-30 characters, start with a letter, and contain only letters, numbers, and underscores"
+  ),
+  exactLength: ({
+    message,
+    length
+  } = {}) => {
+    if (typeof length !== "number") {
+      throw new Error("Length must be provided for exactLength validator");
+    }
+    return z.string().length(length, message || `Must be exactly ${length} characters`);
+  },
+  minWords: ({
+    message,
+    minWords
+  } = {}) => z.string().refine(
+    (value) => {
+      if (!value) return true;
+      const words = value.split(/[\s\t\n\r]+/).filter(Boolean);
+      return words.length >= (typeof minWords === "number" ? minWords : 0);
+    },
+    { message: message || `Must have at least ${minWords} word(s)` }
+  ),
+  maxWords: ({
+    message,
+    maxWords
+  } = {}) => z.string().refine(
+    (value) => {
+      if (!value) return true;
+      const words = value.split(/[\s\t\n\r]+/).filter(Boolean);
+      return words.length <= (typeof maxWords === "number" ? maxWords : 0);
+    },
+    { message: message || `Must have at most ${maxWords} word(s)` }
+  ),
+  strongPassword: ({ message } = {}) => z.string().regex(
+    /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/,
+    message || "Must be at least 8 characters and contain uppercase, lowercase, number, and special character"
+  ),
+  noHtml: ({ message } = {}) => z.string().refine(
+    (value) => !value || !/<[^>]*>/.test(value),
+    message || "Must not contain HTML tags"
+  ),
+  noScriptInjection: ({ message } = {}) => z.string().refine(
+    (value) => !value || !/<script|javascript:|on\w+\s*=/i.test(value),
+    message || "Contains potentially unsafe content"
+  ),
+  noSqlInjection: ({ message } = {}) => z.string().refine(
+    (value) => !value || !/('|--|;|\b(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|ALTER|CREATE|EXEC|EXECUTE)\b)/i.test(
+      value
+    ),
+    message || "Contains potentially unsafe content"
+  ),
+  indianPinCode: ({ message } = {}) => z.string().regex(/^[1-9][0-9]{5}$/, message || "Must be a valid 6-digit PIN code"),
+  usZipCode: ({ message } = {}) => z.string().regex(/^\d{5}(-\d{4})?$/, message || "Must be a valid US ZIP code"),
+  ukPostalCode: ({ message } = {}) => z.string().regex(
+    /^[A-Z]{1,2}[0-9][0-9A-Z]?\s?[0-9][A-Z]{2}$/i,
+    message || "Must be a valid UK postal code"
+  ),
+  ipv4: ({ message } = {}) => z.string().regex(
+    /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+    message || "Must be a valid IPv4 address"
+  ),
+  ipv6: ({ message } = {}) => z.string().regex(
+    /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::$|^::1$|^([0-9a-fA-F]{1,4}:){1,7}:$/,
+    message || "Must be a valid IPv6 address"
+  ),
+  macAddress: ({ message } = {}) => z.string().regex(
+    /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/,
+    message || "Must be a valid MAC address"
+  ),
+  allowedFileExtension: ({
+    message,
+    allowedExtensions
+  } = {}) => z.string().refine(
+    (fileName) => {
+      if (!fileName) return true;
+      const extension = fileName.split(".").pop()?.toLowerCase();
+      const lowerAllowed = allowedExtensions?.map(
+        (ext) => ext.toLowerCase().startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`
+      );
+      return extension && lowerAllowed?.includes(`.${extension}`);
+    },
+    {
+      message: message || `Must have one of the following extensions: ${allowedExtensions?.join(", ")}`
+    }
+  ),
+  validImageExtension: ({ message } = {}) => schemaTools.allowedFileExtension({
+    allowedExtensions: [...IMAGE_EXTENSIONS],
+    message: message || `Must have a valid image extension (${IMAGE_EXTENSIONS.join(", ")})`
+  }),
+  validDocumentExtension: ({ message } = {}) => schemaTools.allowedFileExtension({
+    allowedExtensions: [...DOCUMENT_EXTENSIONS],
+    message: message || `Must have a valid document extension (${DOCUMENT_EXTENSIONS.join(", ")})`
+  }),
+  panCard: ({ message } = {}) => z.string().regex(
+    /^[A-Z]{5}[0-9]{4}[A-Z]{1}$/,
+    message || "Must be a valid PAN card number"
+  ),
+  aadhaar: ({ message } = {}) => z.string().regex(
+    /^[2-9]{1}[0-9]{11}$/,
+    message || "Must be a valid Aadhaar number"
+  ),
+  gstin: ({ message } = {}) => z.string().regex(
+    /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$/,
+    message || "Must be a valid GSTIN"
+  ),
+  ifsc: ({ message } = {}) => z.string().regex(/^[A-Z]{4}0[A-Z0-9]{6}$/, message || "Must be a valid IFSC code"),
+  alphanumeric: ({ message } = {}) => z.string().regex(
+    /^[a-zA-Z0-9]+$/,
+    message || "Only letters and numbers are allowed"
+  ),
+  slug: ({ message } = {}) => z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, message || "Invalid slug format"),
+  // Number validations
+  positiveNumber: ({
+    message,
+    min,
+    max
+  } = {}) => z.number().positive(message || "Number must be positive").min(min || 0.01, `Number must be at least ${min || 0.01}`).max(
+    max || Number.MAX_SAFE_INTEGER,
+    `Number must be at most ${max || Number.MAX_SAFE_INTEGER}`
+  ),
+  maxDecimalPlaces: ({
+    message,
+    maxPlaces
+  } = {}) => z.number().refine(
+    (value) => {
+      if (value === null || value === void 0) return true;
+      const decimalPart = value.toString().split(".")[1];
+      return !decimalPart || decimalPart.length <= (typeof maxPlaces === "number" ? maxPlaces : 0);
+    },
+    { message: message || `Must have at most ${maxPlaces} decimal places` }
+  ),
+  currency: ({ message } = {}) => z.number().min(0, message || "Must be a valid currency amount (positive)").refine(
+    (value) => {
+      if (value === null || value === void 0) return true;
+      const decimalPart = value.toString().split(".")[1];
+      return !decimalPart || decimalPart.length <= 2;
+    },
+    {
+      message: message || "Must be a valid currency amount (max 2 decimal places)"
+    }
+  ),
+  validAge: ({ message } = {}) => z.number().int("Must be an integer").min(0, message || "Must be a valid age (between 0 and 150)").max(150, message || "Must be a valid age (between 0 and 150)"),
+  nonNegativeNumber: ({
+    message,
+    max
+  } = {}) => z.number().min(0, message || "Number must be non-negative").max(
+    max || Number.MAX_SAFE_INTEGER,
+    `Number must be at most ${max || Number.MAX_SAFE_INTEGER}`
+  ),
+  integer: ({
+    message,
+    min,
+    max
+  } = {}) => z.number().int(message || "Must be an integer").min(
+    min || Number.MIN_SAFE_INTEGER,
+    `Number must be at least ${min || Number.MIN_SAFE_INTEGER}`
+  ).max(
+    max || Number.MAX_SAFE_INTEGER,
+    `Number must be at most ${max || Number.MAX_SAFE_INTEGER}`
+  ),
+  percentage: ({ message } = {}) => z.number().min(0, message || "Percentage must be between 0 and 100").max(100, message || "Percentage must be between 0 and 100"),
+  // Array validations
+  nonEmptyArray: (schema, { message } = {}) => z.array(schema).min(1, message || "At least one item is required"),
+  uniqueArray: (schema, { message } = {}) => z.array(schema).refine((items) => new Set(items).size === items.length, {
+    message: message || "All items must be unique"
+  }),
+  noNullArrayItems: (schema, { message } = {}) => z.array(schema.nullable()).refine((items) => items.every((item) => item !== null), {
+    message: message || "Must not contain null items"
+  }),
+  // Boolean validations
+  requiredBoolean: ({ message } = {}) => z.boolean({
+    message: message || "This field is required"
+  }),
+  // Object validations
+  nonEmptyObject: (schema, { message } = {}) => schema.refine((obj) => Object.keys(obj).length > 0, {
+    message: message || "Object cannot be empty"
+  }),
+  // File validations
+  requiredFile: ({ message } = {}) => z.instanceof(File, { message: message || "File is required" }).refine((file) => file.size > 0, {
+    message: message || "File cannot be empty"
+  }),
+  fileSize: ({ maxSize, message }) => z.instanceof(File).refine((file) => file.size <= maxSize, {
+    message: message || `File size must be less than ${Math.round(maxSize / 1024 / 1024)}MB`
+  }),
+  fileType: ({
+    allowedTypes,
+    message
+  }) => z.instanceof(File).refine((file) => allowedTypes.includes(file.type), {
+    message: message || `File type must be one of: ${allowedTypes.join(", ")}`
+  }),
+  // Custom validators
+  conditional: (condition, trueSchema, falseSchema) => z.union([trueSchema, falseSchema]).superRefine((data, ctx) => {
+    const shouldUseTrue = condition(data);
+    const schema = shouldUseTrue ? trueSchema : falseSchema;
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: result.error.message
+      });
+    }
+  }),
+  transform: {
+    toLowerCase: z.string().transform((val) => val.toLowerCase()),
+    toUpperCase: z.string().transform((val) => val.toUpperCase()),
+    trim: z.string().transform((val) => val.trim()),
+    toNumber: z.string().transform((val) => Number(val)),
+    toBoolean: z.string().transform((val) => val === "true"),
+    parseJson: (schema) => z.string().transform((val, ctx) => {
+      try {
+        const parsed = JSON.parse(val);
+        const result = schema.safeParse(parsed);
+        if (result.success) return result.data;
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: result.error.message
+        });
+        return z.NEVER;
+      } catch {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "Invalid JSON"
+        });
+        return z.NEVER;
+      }
+    })
+  }
+};
+
+// src/utils/typeGuards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasProperty(obj, key) {
+  return isRecord(obj) && key in obj;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isArray2(value) {
+  return Array.isArray(value);
+}
+function isNonEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNull(value) {
+  return value === null;
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isNullish(value) {
+  return value === null || value === void 0;
+}
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+function isDate(value) {
+  return value instanceof Date && !isNaN(value.getTime());
+}
+function isPromise(value) {
+  return value instanceof Promise || isRecord(value) && typeof value.then === "function";
+}
+function isError(error) {
+  return error instanceof Error;
+}
+function matches(value, validator) {
+  return validator(value);
+}
+
+export {
+  IMAGE_EXTENSIONS,
+  DOCUMENT_EXTENSIONS,
+  ALL_FILE_EXTENSIONS,
+  isImageFile,
+  isImageMimeType,
+  formatFileSize,
+  flattenObjectKeys,
+  getTimezone,
+  handleServerErrors,
+  propertyExists,
+  readValueAsDate,
+  removeLeadingTrailingSlashes,
+  schemaTools,
+  isRecord,
+  hasProperty,
+  isNonEmptyString,
+  isArray2 as isArray,
+  isNonEmptyArray,
+  isFunction,
+  isString,
+  isNumber,
+  isBoolean,
+  isNull,
+  isUndefined,
+  isNullish,
+  isDefined,
+  isDate,
+  isPromise,
+  isError,
+  matches
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/utils/fileUtils.ts", "../src/utils/flattenObjectKeys.ts", "../src/utils/getTimezone.ts", "../src/utils/handleServerErrors.ts", "../src/utils/propertyExists.ts", "../src/utils/readValueAsDate.ts", "../src/utils/removeLeadingTrailingSlashes.ts", "../src/utils/schemaTools.ts", "../src/utils/typeGuards.ts"],
  "sourcesContent": ["/** Canonical image extensions \u2014 matches backend appsettings.json Images.FileTypes */\nexport const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.webp'] as const;\n\n/** Canonical document extensions \u2014 matches backend appsettings.json Documents.FileTypes */\nexport const DOCUMENT_EXTENSIONS = ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.txt'] as const;\n\n/** All allowed file extensions (image + document) */\nexport const ALL_FILE_EXTENSIONS: string[] = [...IMAGE_EXTENSIONS, ...DOCUMENT_EXTENSIONS];\n\nconst IMAGE_EXT_SET = new Set<string>(IMAGE_EXTENSIONS);\n\n/** Check if a File object is an image (MIME type check, extension fallback) */\nexport function isImageFile(file: File): boolean {\n  if (file.type.startsWith('image/')) return true;\n  const ext = '.' + file.name.split('.').pop()?.toLowerCase();\n  return IMAGE_EXT_SET.has(ext);\n}\n\n/** Check if a MIME type string is an image type */\nexport function isImageMimeType(mimeType: string): boolean {\n  return mimeType.startsWith('image/');\n}\n\n/** Format byte count to human-readable string */\nexport function formatFileSize(bytes: number): string {\n  if (bytes === 0) return '0 B';\n  const k = 1024;\n  const units = ['B', 'KB', 'MB', 'GB'];\n  const i = Math.floor(Math.log(bytes) / Math.log(k));\n  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${units[i]}`;\n}\n", "/**\n * Checks if a value is a nested object (not null and not an array).\n *\n * @param obj - The value to check\n * @returns True if the value is a nested object\n *\n * @internal\n */\nconst isNested = (obj: unknown): obj is Record<string, unknown> => \n  typeof obj === \"object\" && obj !== null && !Array.isArray(obj);\n\n/**\n * Checks if a value is an array.\n *\n * @param obj - The value to check\n * @returns True if the value is an array\n *\n * @internal\n */\nconst isArray = (obj: unknown): obj is unknown[] => Array.isArray(obj);\n\n/**\n * Recursively flattens an object into a flat structure with dot-notation keys.\n *\n * This utility function takes a nested object and converts it into a flat object\n * where nested properties are represented using dot notation. It handles both\n * nested objects and arrays, preserving all levels of the original structure\n * as separate keys in the result.\n *\n * @example\n * Basic object flattening:\n * ```tsx\n * const nested = {\n *   user: {\n *     name: 'John',\n *     address: {\n *       city: 'New York',\n *       zip: '10001'\n *     }\n *   }\n * };\n *\n * const flattened = flattenObjectKeys(nested);\n * // Result:\n * // {\n * //   'user': { name: 'John', address: { city: 'New York', zip: '10001' } },\n * //   'user.name': 'John',\n * //   'user.address': { city: 'New York', zip: '10001' },\n * //   'user.address.city': 'New York',\n * //   'user.address.zip': '10001'\n * // }\n * ```\n *\n * @example\n * Array handling:\n * ```tsx\n * const withArrays = {\n *   items: [\n *     { id: 1, name: 'Item 1' },\n *     { id: 2, name: 'Item 2' }\n *   ]\n * };\n *\n * const flattened = flattenObjectKeys(withArrays);\n * // Result includes:\n * // {\n * //   'items': [...],\n * //   'items.0': { id: 1, name: 'Item 1' },\n * //   'items.0.id': 1,\n * //   'items.0.name': 'Item 1',\n * //   'items.1': { id: 2, name: 'Item 2' },\n * //   'items.1.id': 2,\n * //   'items.1.name': 'Item 2'\n * // }\n * ```\n *\n * @param obj - The object to flatten\n * @param prefix - Internal parameter for building key paths (used in recursion)\n * @returns A flat object with dot-notation keys representing the original structure\n *\n * @public\n */\nexport const flattenObjectKeys = (obj: unknown, prefix = \"\"): Record<string, unknown> => {\n  if (!isNested(obj)) {\n    return {\n      [prefix]: obj,\n    };\n  }\n\n  return Object.keys(obj).reduce((acc, key) => {\n    const currentPrefix = prefix.length ? `${prefix}.` : \"\";\n\n    if (isNested(obj[key]) && Object.keys(obj[key]).length) {\n      if (isArray(obj[key]) && obj[key].length) {\n        obj[key].forEach((item, index: number) => {\n          Object.assign(\n            acc,\n            flattenObjectKeys(item, `${currentPrefix + key}.${index}`)\n          );\n        });\n      } else {\n        Object.assign(acc, flattenObjectKeys(obj[key], currentPrefix + key));\n      }\n\n      // Even if it's a nested object, it should be treated as a key as well\n      acc[currentPrefix + key] = obj[key];\n    } else {\n      acc[currentPrefix + key] = obj[key];\n    }\n\n    return acc;\n  }, {} as Record<string, unknown>);\n};\n", "import type { PickerValidDate } from \"@mui/x-date-pickers\";\nimport type { useLocalizationContext } from \"@mui/x-date-pickers/internals\";\nimport type { Dayjs } from \"dayjs\";\n\nexport function getTimezone<TDate extends PickerValidDate>(\n  adapter: ReturnType<typeof useLocalizationContext>,\n  value: TDate\n): string | null {\n  return value == null || !adapter.utils.isValid(value as unknown as Dayjs)\n    ? null\n    : adapter.utils.getTimezone(value as unknown as Dayjs);\n}\n", "import type { FieldValues, Path, UseFormSetError } from 'react-hook-form';\n\nimport { flattenObjectKeys } from './flattenObjectKeys';\n\nimport type { ValidationErrors } from '@/core';\n\n/**\n * Configuration options for the handleServerErrors function.\n *\n * @template TFieldValues - The form values type\n *\n * @public\n */\ninterface HandleServerErrorsType<\n  TFieldValues extends FieldValues = FieldValues,\n> {\n  /**\n   * Server validation errors object containing field-specific error messages\n   * @example { email: 'Email is already taken', password: ['Too short', 'Must contain numbers'] }\n   */\n  errors?: ValidationErrors;\n  /**\n   * The setError function from react-hook-form for setting field errors\n   */\n  setError: UseFormSetError<TFieldValues>;\n}\n\n/**\n * Processes server validation errors and applies them to react-hook-form fields.\n *\n * This utility function takes validation errors from a server response and automatically\n * applies them to the corresponding form fields using react-hook-form's setError function.\n * It supports various error formats including strings, arrays of strings, and boolean flags.\n *\n * The function uses object flattening to handle nested error structures and ensures\n * that only valid field paths are processed.\n *\n * @example\n * Basic usage with server response:\n * ```tsx\n * const { setError } = useForm();\n *\n * try {\n *   await submitForm(data);\n * } catch (error) {\n *   handleServerErrors({\n *     errors: error.response.data.errors,\n *     setError\n *   });\n * }\n * ```\n *\n * @example\n * With different error formats:\n * ```tsx\n * const serverErrors = {\n *   email: 'Email is already taken',\n *   password: ['Too short', 'Must contain numbers'],\n *   terms: true // Boolean flag indicating invalid\n * };\n *\n * handleServerErrors({ errors: serverErrors, setError });\n * // Results in:\n * // - email field shows: \"Email is already taken\"\n * // - password field shows: \"Too short Must contain numbers\"\n * // - terms field shows: \"Field is not valid.\"\n * ```\n *\n * @template TFieldValues - The form values type\n *\n * @param args - Configuration object containing errors and setError function\n *\n * @public\n */\nexport const handleServerErrors = function handleServerErrors<\n  TFieldValues extends FieldValues = FieldValues,\n>(args: HandleServerErrorsType<TFieldValues>) {\n  const { errors, setError } = args;\n\n  for (const key in errors) {\n    const isKeyInVariables = Object.keys(flattenObjectKeys(errors)).includes(\n      key\n    );\n\n    if (!isKeyInVariables) {\n      continue;\n    }\n\n    const fieldError = errors[key];\n\n    let errorMessage = '';\n\n    if (Array.isArray(fieldError)) {\n      errorMessage = fieldError.join(' ');\n    }\n\n    if (typeof fieldError === 'string') {\n      errorMessage = fieldError;\n    }\n\n    if (typeof fieldError === 'boolean' && fieldError) {\n      errorMessage = 'Field is not valid.';\n    }\n\n    setError(key as Path<TFieldValues>, {\n      message: errorMessage,\n    });\n  }\n};\n", "/**\n * Type-safe property existence checker that acts as a type guard.\n *\n * Checks if a given property exists on an object and narrows the TypeScript type\n * to include that property. This is useful for safely accessing properties on\n * objects of unknown structure while maintaining type safety.\n *\n * @template X - The type of the object being checked\n * @template Y - The type of the property key (extends PropertyKey)\n *\n * @param obj - The object to check for the property\n * @param prop - The property key to check for existence\n *\n * @returns A type predicate indicating whether the property exists on the object.\n *          If true, the object type is narrowed to include the specified property.\n *\n * @example\n * ```typescript\n * const data: unknown = { name: \"John\", age: 30 };\n *\n * if (propertyExists(data, \"name\")) {\n *   // TypeScript now knows data has a 'name' property\n *   console.log(data.name); // Type-safe access\n * }\n *\n * // Check for nested property existence\n * if (propertyExists(obj, \"user\") && propertyExists(obj.user, \"id\")) {\n *   console.log(obj.user.id); // Safe nested access\n * }\n * ```\n *\n * @since 2.18.45\n */\nexport function propertyExists<X, Y extends PropertyKey>(\n  obj: X,\n  prop: Y\n): obj is X & Record<Y, unknown> {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    Object.prototype.hasOwnProperty.call(obj, prop)\n  );\n}\n", "import type { PickerValidDate } from \"@mui/x-date-pickers\";\nimport type { useLocalizationContext } from \"@mui/x-date-pickers/internals\";\n\nexport function readValueAsDate<TDate extends PickerValidDate>(\n  adapter: ReturnType<typeof useLocalizationContext>,\n  value: string | null | TDate\n): TDate | null {\n  if (typeof value === \"string\") {\n    if (value === \"\") {\n      return null;\n    }\n\n    return adapter.utils.date(value) as TDate;\n  }\n\n  return value;\n}\n", "export const removeLeadingTrailingSlashes = (route: string) => {\n  return route.replace(/^\\/|\\/$/g, \"\");\n};\n", "import dayjs from 'dayjs';\nimport { z } from 'zod';\nimport { IMAGE_EXTENSIONS, DOCUMENT_EXTENSIONS } from './fileUtils';\n\n// Helper function for Luhn algorithm validation\nfunction isValidLuhn(value: string): boolean {\n  if (!value || value.trim() === '') {\n    return false;\n  }\n\n  const number = value.replace(/[\\s-]/g, '');\n\n  if (!/^\\d+$/.test(number)) {\n    return false;\n  }\n\n  if (number.length < 13 || number.length > 19) {\n    return false;\n  }\n\n  let sum = 0;\n  let alternate = false;\n\n  for (let i = number.length - 1; i >= 0; i--) {\n    let digit = parseInt(number.charAt(i), 10);\n\n    if (alternate) {\n      digit *= 2;\n      if (digit > 9) {\n        digit -= 9;\n      }\n    }\n\n    sum += digit;\n    alternate = !alternate;\n  }\n\n  return sum % 10 === 0;\n}\n\nexport const schemaTools = {\n  // Date validations\n  date: ({ message }: { message?: string } = {}) =>\n    z.coerce\n      .string()\n      .transform(c => (c === 'null' || c === 'undefined' ? null : c))\n      .refine(c => !!c, { message: message || 'Date is required' })\n      .refine(c => (c ? dayjs(c).isValid() : true), {\n        message: message || 'Invalid date',\n      }),\n\n  nullableDate: ({ message }: { message?: string } = {}) =>\n    z.coerce\n      .string()\n      .transform(c => (c === 'null' ? null : c))\n      .transform(c => (c === 'undefined' ? null : c))\n      .refine(c => (!c && c !== null ? dayjs(c).isValid() : true), {\n        message: message || 'Invalid date',\n      }),\n\n  pastDate: ({ message }: { message?: string } = {}) =>\n    z.coerce.date().refine(date => date < new Date(), {\n      message: message || 'Must be a past date',\n    }),\n\n  futureDate: ({ message }: { message?: string } = {}) =>\n    z.coerce.date().refine(date => date > new Date(), {\n      message: message || 'Must be a future date',\n    }),\n\n  todayOrFutureDate: ({ message }: { message?: string } = {}) =>\n    z.coerce.date().refine(\n      date => {\n        const today = new Date();\n\n        today.setHours(0, 0, 0, 0);\n\n        return date.setHours(0, 0, 0, 0) >= today.getTime();\n      },\n      { message: message || 'Must be today or a future date' }\n    ),\n\n  todayOrPastDate: ({ message }: { message?: string } = {}) =>\n    z.coerce.date().refine(\n      date => {\n        const today = new Date();\n\n        today.setHours(0, 0, 0, 0);\n\n        return date.setHours(0, 0, 0, 0) <= today.getTime();\n      },\n      { message: message || 'Must be today or a past date' }\n    ),\n\n  adult: ({ message }: { message?: string } = {}) =>\n    z.coerce.date().refine(\n      date => {\n        const eighteenYearsAgo = new Date();\n\n        eighteenYearsAgo.setFullYear(eighteenYearsAgo.getFullYear() - 18);\n        eighteenYearsAgo.setHours(0, 0, 0, 0); // Normalize to start of day\n        const dob = new Date(date);\n\n        dob.setHours(0, 0, 0, 0); // Normalize to start of day\n\n        return dob <= eighteenYearsAgo;\n      },\n      { message: message || 'Must be at least 18 years old' }\n    ),\n\n  minimumAge: ({\n    message,\n    minimumAge,\n  }: { message?: string; minimumAge?: number } = {}) =>\n    z.coerce.date().refine(\n      date => {\n        if (typeof minimumAge !== 'number') return false;\n        const minYearsAgo = new Date();\n\n        minYearsAgo.setFullYear(minYearsAgo.getFullYear() - minimumAge);\n        minYearsAgo.setHours(0, 0, 0, 0); // Normalize to start of day\n        const dob = new Date(date);\n\n        dob.setHours(0, 0, 0, 0); // Normalize to start of day\n\n        return dob <= minYearsAgo;\n      },\n      {\n        message:\n          message ||\n          `Must be at least ${minimumAge ?? 'the required'} years old`,\n      }\n    ),\n\n  withinDays: ({ message, days }: { message?: string; days?: number } = {}) =>\n    z.coerce.date().refine(\n      date => {\n        const today = new Date();\n\n        today.setHours(0, 0, 0, 0);\n        const inputDate = new Date(date);\n\n        inputDate.setHours(0, 0, 0, 0);\n\n        const diffTime = Math.abs(inputDate.getTime() - today.getTime());\n        const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24)); // Convert milliseconds to days\n\n        return typeof days === 'number' ? diffDays <= days : false;\n      },\n      { message: message || `Must be within ${days} days of today` }\n    ),\n\n  weekday: ({ message }: { message?: string } = {}) =>\n    z.coerce.date().refine(\n      date => {\n        const day = date.getDay(); // 0 = Sunday, 1 = Monday, ..., 6 = Saturday\n\n        return day !== 0 && day !== 6;\n      },\n      { message: message || 'Must be a weekday' }\n    ),\n\n  dateRange: ({ message }: { message?: string } = {}) =>\n    z\n      .object({\n        start: z.coerce.date(),\n        end: z.coerce.date(),\n      })\n      .refine(data => data.start <= data.end, {\n        message: message || 'Start date must be before or equal to end date',\n      }),\n\n  time: ({ message }: { message?: string } = {}) =>\n    z.coerce\n      .date()\n      .transform(c => (c === null || c === undefined ? null : c))\n      .refine(c => !!c, { message: message || 'Time is required' })\n      .refine(c => (c ? dayjs(c).isValid() : true), {\n        message: message || 'Invalid time',\n      }),\n\n  dateTime: ({ message }: { message?: string } = {}) =>\n    z.coerce\n      .date()\n      .transform(c => (c === null || c === undefined ? null : c))\n      .refine(c => !!c, { message: message || 'Date and Time is required' })\n      .refine(c => (c ? dayjs(c).isValid() : true), {\n        message: message || 'Invalid Date and Time',\n      }),\n\n  // String validations\n  requiredString: ({\n    message,\n    min,\n    max,\n  }: { message?: string; min?: number; max?: number } = {}) =>\n    z\n      .string()\n      .trim()\n      .min(\n        min || 1,\n        message || `String must be at least ${min || 1} characters`\n      )\n      .max(\n        max || 255,\n        message || `String must be at most ${max || 255} characters`\n      ),\n\n  email: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .email(message || 'Invalid email address')\n      .max(254, 'Email must be at most 254 characters'),\n\n  url: ({ message }: { message?: string } = {}) =>\n    z.string().url(message || 'Invalid URL format'),\n\n  phone: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(/^[+]?[1-9][\\d]{0,15}$/, message || 'Invalid phone number format'),\n\n  creditCard: ({ message }: { message?: string } = {}) =>\n    z.string().refine(value => isValidLuhn(value), {\n      message: message || 'Must be a valid credit card number',\n    }),\n\n  indianMobile: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(/^[6-9]\\d{9}$/, message || 'Must be a valid Indian mobile number'),\n\n  internationalPhone: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^\\+?[1-9]\\d{6,14}$/,\n        message || 'Must be a valid international phone number'\n      ),\n\n  alphabetic: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[A-Za-z, ]+$/,\n        message || 'Must contain only letters, commas, and spaces'\n      ),\n\n  guid: ({ message }: { message?: string } = {}) =>\n    z.string().uuid(message || 'Must be a valid GUID'),\n\n  nonEmptyOrWhitespace: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .trim()\n      .min(1, message || 'Must not be empty or whitespace'),\n\n  username: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[a-zA-Z][a-zA-Z0-9_]{2,29}$/,\n        message ||\n          'Must be 3-30 characters, start with a letter, and contain only letters, numbers, and underscores'\n      ),\n\n  exactLength: ({\n    message,\n    length,\n  }: { message?: string; length?: number } = {}) => {\n    if (typeof length !== 'number') {\n      throw new Error('Length must be provided for exactLength validator');\n    }\n\n    return z\n      .string()\n      .length(length, message || `Must be exactly ${length} characters`);\n  },\n\n  minWords: ({\n    message,\n    minWords,\n  }: { message?: string; minWords?: number } = {}) =>\n    z.string().refine(\n      value => {\n        if (!value) return true;\n        const words = value.split(/[\\s\\t\\n\\r]+/).filter(Boolean);\n\n        return words.length >= (typeof minWords === 'number' ? minWords : 0);\n      },\n      { message: message || `Must have at least ${minWords} word(s)` }\n    ),\n\n  maxWords: ({\n    message,\n    maxWords,\n  }: { message?: string; maxWords?: number } = {}) =>\n    z.string().refine(\n      value => {\n        if (!value) return true;\n        const words = value.split(/[\\s\\t\\n\\r]+/).filter(Boolean);\n\n        return words.length <= (typeof maxWords === 'number' ? maxWords : 0);\n      },\n      { message: message || `Must have at most ${maxWords} word(s)` }\n    ),\n\n  strongPassword: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]{8,}$/,\n        message ||\n          'Must be at least 8 characters and contain uppercase, lowercase, number, and special character'\n      ),\n\n  noHtml: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .refine(\n        value => !value || !/<[^>]*>/.test(value),\n        message || 'Must not contain HTML tags'\n      ),\n\n  noScriptInjection: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .refine(\n        value => !value || !/<script|javascript:|on\\w+\\s*=/i.test(value),\n        message || 'Contains potentially unsafe content'\n      ),\n\n  noSqlInjection: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .refine(\n        value =>\n          !value ||\n          !/('|--|;|\\b(SELECT|INSERT|UPDATE|DELETE|DROP|UNION|ALTER|CREATE|EXEC|EXECUTE)\\b)/i.test(\n            value\n          ),\n        message || 'Contains potentially unsafe content'\n      ),\n\n  indianPinCode: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(/^[1-9][0-9]{5}$/, message || 'Must be a valid 6-digit PIN code'),\n\n  usZipCode: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(/^\\d{5}(-\\d{4})?$/, message || 'Must be a valid US ZIP code'),\n\n  ukPostalCode: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[A-Z]{1,2}[0-9][0-9A-Z]?\\s?[0-9][A-Z]{2}$/i,\n        message || 'Must be a valid UK postal code'\n      ),\n\n  ipv4: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,\n        message || 'Must be a valid IPv4 address'\n      ),\n\n  ipv6: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::$|^::1$|^([0-9a-fA-F]{1,4}:){1,7}:$/,\n        message || 'Must be a valid IPv6 address'\n      ),\n\n  macAddress: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/,\n        message || 'Must be a valid MAC address'\n      ),\n\n  allowedFileExtension: ({\n    message,\n    allowedExtensions,\n  }: { message?: string; allowedExtensions?: string[] } = {}) =>\n    z.string().refine(\n      fileName => {\n        if (!fileName) return true;\n        const extension = fileName.split('.').pop()?.toLowerCase();\n        const lowerAllowed = allowedExtensions?.map(ext =>\n          ext.toLowerCase().startsWith('.')\n            ? ext.toLowerCase()\n            : `.${ext.toLowerCase()}`\n        );\n\n        return extension && lowerAllowed?.includes(`.${extension}`);\n      },\n      {\n        message:\n          message ||\n          `Must have one of the following extensions: ${allowedExtensions?.join(', ')}`,\n      }\n    ),\n\n  validImageExtension: ({ message }: { message?: string } = {}) =>\n    schemaTools.allowedFileExtension({\n      allowedExtensions: [...IMAGE_EXTENSIONS],\n      message:\n        message ||\n        `Must have a valid image extension (${IMAGE_EXTENSIONS.join(', ')})`,\n    }),\n\n  validDocumentExtension: ({ message }: { message?: string } = {}) =>\n    schemaTools.allowedFileExtension({\n      allowedExtensions: [...DOCUMENT_EXTENSIONS],\n      message:\n        message ||\n        `Must have a valid document extension (${DOCUMENT_EXTENSIONS.join(', ')})`,\n    }),\n\n  panCard: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[A-Z]{5}[0-9]{4}[A-Z]{1}$/,\n        message || 'Must be a valid PAN card number'\n      ),\n\n  aadhaar: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[2-9]{1}[0-9]{11}$/,\n        message || 'Must be a valid Aadhaar number'\n      ),\n\n  gstin: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$/,\n        message || 'Must be a valid GSTIN'\n      ),\n\n  ifsc: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(/^[A-Z]{4}0[A-Z0-9]{6}$/, message || 'Must be a valid IFSC code'),\n\n  alphanumeric: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(\n        /^[a-zA-Z0-9]+$/,\n        message || 'Only letters and numbers are allowed'\n      ),\n\n  slug: ({ message }: { message?: string } = {}) =>\n    z\n      .string()\n      .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, message || 'Invalid slug format'),\n\n  // Number validations\n  positiveNumber: ({\n    message,\n    min,\n    max,\n  }: { message?: string; min?: number; max?: number } = {}) =>\n    z\n      .number()\n      .positive(message || 'Number must be positive')\n      .min(min || 0.01, `Number must be at least ${min || 0.01}`)\n      .max(\n        max || Number.MAX_SAFE_INTEGER,\n        `Number must be at most ${max || Number.MAX_SAFE_INTEGER}`\n      ),\n\n  maxDecimalPlaces: ({\n    message,\n    maxPlaces,\n  }: { message?: string; maxPlaces?: number } = {}) =>\n    z.number().refine(\n      value => {\n        if (value === null || value === undefined) return true;\n        const decimalPart = value.toString().split('.')[1];\n\n        return (\n          !decimalPart ||\n          decimalPart.length <= (typeof maxPlaces === 'number' ? maxPlaces : 0)\n        );\n      },\n      { message: message || `Must have at most ${maxPlaces} decimal places` }\n    ),\n\n  currency: ({ message }: { message?: string } = {}) =>\n    z\n      .number()\n      .min(0, message || 'Must be a valid currency amount (positive)')\n      .refine(\n        value => {\n          if (value === null || value === undefined) return true;\n          const decimalPart = value.toString().split('.')[1];\n\n          return !decimalPart || decimalPart.length <= 2;\n        },\n        {\n          message:\n            message || 'Must be a valid currency amount (max 2 decimal places)',\n        }\n      ),\n\n  validAge: ({ message }: { message?: string } = {}) =>\n    z\n      .number()\n      .int('Must be an integer')\n      .min(0, message || 'Must be a valid age (between 0 and 150)')\n      .max(150, message || 'Must be a valid age (between 0 and 150)'),\n\n  nonNegativeNumber: ({\n    message,\n    max,\n  }: { message?: string; max?: number } = {}) =>\n    z\n      .number()\n      .min(0, message || 'Number must be non-negative')\n      .max(\n        max || Number.MAX_SAFE_INTEGER,\n        `Number must be at most ${max || Number.MAX_SAFE_INTEGER}`\n      ),\n\n  integer: ({\n    message,\n    min,\n    max,\n  }: { message?: string; min?: number; max?: number } = {}) =>\n    z\n      .number()\n      .int(message || 'Must be an integer')\n      .min(\n        min || Number.MIN_SAFE_INTEGER,\n        `Number must be at least ${min || Number.MIN_SAFE_INTEGER}`\n      )\n      .max(\n        max || Number.MAX_SAFE_INTEGER,\n        `Number must be at most ${max || Number.MAX_SAFE_INTEGER}`\n      ),\n\n  percentage: ({ message }: { message?: string } = {}) =>\n    z\n      .number()\n      .min(0, message || 'Percentage must be between 0 and 100')\n      .max(100, message || 'Percentage must be between 0 and 100'),\n\n  // Array validations\n  nonEmptyArray: <T>(\n    schema: z.ZodSchema<T>,\n    { message }: { message?: string } = {}\n  ) => z.array(schema).min(1, message || 'At least one item is required'),\n\n  uniqueArray: <T>(\n    schema: z.ZodSchema<T>,\n    { message }: { message?: string } = {}\n  ) =>\n    z.array(schema).refine(items => new Set(items).size === items.length, {\n      message: message || 'All items must be unique',\n    }),\n\n  noNullArrayItems: <T>(\n    schema: z.ZodSchema<T>,\n    { message }: { message?: string } = {}\n  ) =>\n    z\n      .array(schema.nullable())\n      .refine(items => items.every(item => item !== null), {\n        message: message || 'Must not contain null items',\n      }),\n\n  // Boolean validations\n  requiredBoolean: ({ message }: { message?: string } = {}) =>\n    z.boolean({\n      message: message || 'This field is required',\n    }),\n\n  // Object validations\n  nonEmptyObject: <T extends Record<string, unknown>>(\n    schema: z.ZodSchema<T>,\n    { message }: { message?: string } = {}\n  ) =>\n    schema.refine(obj => Object.keys(obj).length > 0, {\n      message: message || 'Object cannot be empty',\n    }),\n\n  // File validations\n  requiredFile: ({ message }: { message?: string } = {}) =>\n    z\n      .instanceof(File, { message: message || 'File is required' })\n      .refine(file => file.size > 0, {\n        message: message || 'File cannot be empty',\n      }),\n\n  fileSize: ({ maxSize, message }: { maxSize: number; message?: string }) =>\n    z.instanceof(File).refine(file => file.size <= maxSize, {\n      message:\n        message ||\n        `File size must be less than ${Math.round(maxSize / 1024 / 1024)}MB`,\n    }),\n\n  fileType: ({\n    allowedTypes,\n    message,\n  }: {\n    allowedTypes: string[];\n    message?: string;\n  }) =>\n    z.instanceof(File).refine(file => allowedTypes.includes(file.type), {\n      message:\n        message || `File type must be one of: ${allowedTypes.join(', ')}`,\n    }),\n\n  // Custom validators\n  conditional: <T, U>(\n    condition: (data: T) => boolean,\n    trueSchema: z.ZodSchema<U>,\n    falseSchema: z.ZodSchema<U>\n  ) =>\n    z.union([trueSchema, falseSchema]).superRefine((data, ctx) => {\n      const shouldUseTrue = condition(data as unknown as T);\n      const schema = shouldUseTrue ? trueSchema : falseSchema;\n      const result = schema.safeParse(data);\n\n      if (!result.success) {\n        ctx.addIssue({\n          code: z.ZodIssueCode.custom,\n          message: result.error.message,\n        });\n      }\n    }),\n\n  transform: {\n    toLowerCase: z.string().transform(val => val.toLowerCase()),\n    toUpperCase: z.string().transform(val => val.toUpperCase()),\n    trim: z.string().transform(val => val.trim()),\n    toNumber: z.string().transform(val => Number(val)),\n    toBoolean: z.string().transform(val => val === 'true'),\n    parseJson: <T>(schema: z.ZodSchema<T>) =>\n      z.string().transform((val, ctx) => {\n        try {\n          const parsed = JSON.parse(val);\n          const result = schema.safeParse(parsed);\n\n          if (result.success) return result.data;\n\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            message: result.error.message,\n          });\n\n          return z.NEVER;\n        } catch {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            message: 'Invalid JSON',\n          });\n\n          return z.NEVER;\n        }\n      }),\n  },\n};\n", "/**\n * Type guard utilities for runtime type checking\n * \n * @packageDocumentation\n */\n\n/**\n * Type guard to check if a value is a non-null object (excluding arrays)\n * \n * @param value - The value to check\n * @returns True if the value is a plain object\n * \n * @example\n * ```typescript\n * if (isRecord(value)) {\n *   // value is Record<string, unknown>\n *   const keys = Object.keys(value);\n * }\n * ```\n * \n * @public\n */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Type guard to check if an object has a specific property\n * \n * @param obj - The object to check\n * @param key - The property key to look for\n * @returns True if the object has the property\n * \n * @example\n * ```typescript\n * if (hasProperty(obj, 'name')) {\n *   // obj is Record<'name', unknown>\n *   console.log(obj.name);\n * }\n * ```\n * \n * @public\n */\nexport function hasProperty<K extends PropertyKey>(\n  obj: unknown,\n  key: K\n): obj is Record<K, unknown> {\n  return isRecord(obj) && key in obj;\n}\n\n/**\n * Type guard to check if a value is a non-empty string\n * \n * @param value - The value to check\n * @returns True if the value is a non-empty string\n * \n * @example\n * ```typescript\n * if (isNonEmptyString(value)) {\n *   // value is string with length > 0\n *   console.log(value.toUpperCase());\n * }\n * ```\n * \n * @public\n */\nexport function isNonEmptyString(value: unknown): value is string {\n  return typeof value === 'string' && value.length > 0;\n}\n\n/**\n * Type guard to check if a value is a valid array\n * \n * @param value - The value to check\n * @returns True if the value is an array\n * \n * @example\n * ```typescript\n * if (isArray(value)) {\n *   // value is unknown[]\n *   value.forEach(item => console.log(item));\n * }\n * ```\n * \n * @public\n */\nexport function isArray<T = unknown>(value: unknown): value is T[] {\n  return Array.isArray(value);\n}\n\n/**\n * Type guard to check if a value is a non-empty array\n * \n * @param value - The value to check\n * @returns True if the value is a non-empty array\n * \n * @example\n * ```typescript\n * if (isNonEmptyArray(items)) {\n *   // items is [T, ...T[]] - guaranteed to have at least one element\n *   const first = items[0];  // Safe access\n * }\n * ```\n * \n * @public\n */\nexport function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]] {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/**\n * Type guard to check if a value is a function\n * \n * @param value - The value to check\n * @returns True if the value is a function\n * \n * @example\n * ```typescript\n * if (isFunction(callback)) {\n *   // callback is (...args: unknown[]) => unknown\n *   callback();\n * }\n * ```\n * \n * @public\n */\nexport function isFunction(\n  value: unknown\n): value is (...args: readonly unknown[]) => unknown {\n  return typeof value === 'function';\n}\n\n/**\n * Type guard to check if a value is a string\n * \n * @param value - The value to check\n * @returns True if the value is a string (including empty string)\n * \n * @example\n * ```typescript\n * if (isString(value)) {\n *   // value is string\n *   console.log(value.length);\n * }\n * ```\n * \n * @public\n */\nexport function isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n\n/**\n * Type guard to check if a value is a number (excluding NaN)\n * \n * @param value - The value to check\n * @returns True if the value is a valid number\n * \n * @example\n * ```typescript\n * if (isNumber(value)) {\n *   // value is number (not NaN)\n *   const doubled = value * 2;\n * }\n * ```\n * \n * @public\n */\nexport function isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !isNaN(value);\n}\n\n/**\n * Type guard to check if a value is a boolean\n * \n * @param value - The value to check\n * @returns True if the value is a boolean\n * \n * @example\n * ```typescript\n * if (isBoolean(value)) {\n *   // value is boolean\n *   console.log(!value);\n * }\n * ```\n * \n * @public\n */\nexport function isBoolean(value: unknown): value is boolean {\n  return typeof value === 'boolean';\n}\n\n/**\n * Type guard to check if a value is null\n * \n * @param value - The value to check\n * @returns True if the value is null\n * \n * @example\n * ```typescript\n * if (isNull(value)) {\n *   // value is null\n *   return defaultValue;\n * }\n * ```\n * \n * @public\n */\nexport function isNull(value: unknown): value is null {\n  return value === null;\n}\n\n/**\n * Type guard to check if a value is undefined\n * \n * @param value - The value to check\n * @returns True if the value is undefined\n * \n * @example\n * ```typescript\n * if (isUndefined(value)) {\n *   // value is undefined\n *   return defaultValue;\n * }\n * ```\n * \n * @public\n */\nexport function isUndefined(value: unknown): value is undefined {\n  return value === undefined;\n}\n\n/**\n * Type guard to check if a value is null or undefined\n * \n * @param value - The value to check\n * @returns True if the value is nullish\n * \n * @example\n * ```typescript\n * if (isNullish(value)) {\n *   // value is null | undefined\n *   return defaultValue;\n * }\n * \n * if (!isNullish(value)) {\n *   // value is NonNullable<typeof value>\n *   console.log(value);\n * }\n * ```\n * \n * @public\n */\nexport function isNullish(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * Type guard to check if a value is defined (not null or undefined)\n * \n * @param value - The value to check\n * @returns True if the value is not null or undefined\n * \n * @example\n * ```typescript\n * const filtered = items.filter(isDefined);\n * // filtered has type: NonNullable<T>[]\n * ```\n * \n * @public\n */\nexport function isDefined<T>(value: T): value is NonNullable<T> {\n  return value !== null && value !== undefined;\n}\n\n/**\n * Type guard to check if a value is a Date object\n * \n * @param value - The value to check\n * @returns True if the value is a Date\n * \n * @example\n * ```typescript\n * if (isDate(value)) {\n *   // value is Date\n *   console.log(value.toISOString());\n * }\n * ```\n * \n * @public\n */\nexport function isDate(value: unknown): value is Date {\n  return value instanceof Date && !isNaN(value.getTime());\n}\n\n/**\n * Type guard to check if a value is a Promise\n * \n * @param value - The value to check\n * @returns True if the value is a Promise\n * \n * @example\n * ```typescript\n * if (isPromise(value)) {\n *   // value is Promise<unknown>\n *   const result = await value;\n * }\n * ```\n * \n * @public\n */\nexport function isPromise(value: unknown): value is Promise<unknown> {\n  return (\n    value instanceof Promise ||\n    (isRecord(value) &&\n      typeof (value as Record<string, unknown>).then === 'function')\n  );\n}\n\n/**\n * Type guard to check if an error is an Error instance\n * \n * @param error - The error to check\n * @returns True if the error is an Error instance\n * \n * @example\n * ```typescript\n * try {\n *   // ...\n * } catch (error) {\n *   if (isError(error)) {\n *     // error is Error\n *     console.error(error.message);\n *   }\n * }\n * ```\n * \n * @public\n */\nexport function isError(error: unknown): error is Error {\n  return error instanceof Error;\n}\n\n/**\n * Type guard to check if a value matches a specific type using a validator function\n * \n * @param value - The value to check\n * @param validator - Function that returns true if value matches the type\n * @returns True if the value matches the type\n * \n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name: string;\n * }\n * \n * const isUser = (value: unknown): value is User =>\n *   isRecord(value) &&\n *   hasProperty(value, 'id') &&\n *   hasProperty(value, 'name') &&\n *   isString(value.id) &&\n *   isString(value.name);\n * \n * if (isUser(data)) {\n *   // data is User\n *   console.log(data.name);\n * }\n * ```\n * \n * @public\n */\nexport function matches<T>(\n  value: unknown,\n  validator: (value: unknown) => value is T\n): value is T {\n  return validator(value);\n}\n"],
  "mappings": ";AACO,IAAM,mBAAmB,CAAC,QAAQ,SAAS,QAAQ,QAAQ,OAAO;AAGlE,IAAM,sBAAsB,CAAC,QAAQ,QAAQ,SAAS,QAAQ,SAAS,MAAM;AAG7E,IAAM,sBAAgC,CAAC,GAAG,kBAAkB,GAAG,mBAAmB;AAEzF,IAAM,gBAAgB,IAAI,IAAY,gBAAgB;AAG/C,SAAS,YAAY,MAAqB;AAC/C,MAAI,KAAK,KAAK,WAAW,QAAQ,EAAG,QAAO;AAC3C,QAAM,MAAM,MAAM,KAAK,KAAK,MAAM,GAAG,EAAE,IAAI,GAAG,YAAY;AAC1D,SAAO,cAAc,IAAI,GAAG;AAC9B;AAGO,SAAS,gBAAgB,UAA2B;AACzD,SAAO,SAAS,WAAW,QAAQ;AACrC;AAGO,SAAS,eAAe,OAAuB;AACpD,MAAI,UAAU,EAAG,QAAO;AACxB,QAAM,IAAI;AACV,QAAM,QAAQ,CAAC,KAAK,MAAM,MAAM,IAAI;AACpC,QAAM,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC;AAClD,SAAO,GAAG,YAAY,QAAQ,KAAK,IAAI,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC;AACvE;;;ACtBA,IAAM,WAAW,CAAC,QAChB,OAAO,QAAQ,YAAY,QAAQ,QAAQ,CAAC,MAAM,QAAQ,GAAG;AAU/D,IAAM,UAAU,CAAC,QAAmC,MAAM,QAAQ,GAAG;AA+D9D,IAAM,oBAAoB,CAAC,KAAc,SAAS,OAAgC;AACvF,MAAI,CAAC,SAAS,GAAG,GAAG;AAClB,WAAO;AAAA,MACL,CAAC,MAAM,GAAG;AAAA,IACZ;AAAA,EACF;AAEA,SAAO,OAAO,KAAK,GAAG,EAAE,OAAO,CAAC,KAAK,QAAQ;AAC3C,UAAM,gBAAgB,OAAO,SAAS,GAAG,MAAM,MAAM;AAErD,QAAI,SAAS,IAAI,GAAG,CAAC,KAAK,OAAO,KAAK,IAAI,GAAG,CAAC,EAAE,QAAQ;AACtD,UAAI,QAAQ,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,EAAE,QAAQ;AACxC,YAAI,GAAG,EAAE,QAAQ,CAAC,MAAM,UAAkB;AACxC,iBAAO;AAAA,YACL;AAAA,YACA,kBAAkB,MAAM,GAAG,gBAAgB,GAAG,IAAI,KAAK,EAAE;AAAA,UAC3D;AAAA,QACF,CAAC;AAAA,MACH,OAAO;AACL,eAAO,OAAO,KAAK,kBAAkB,IAAI,GAAG,GAAG,gBAAgB,GAAG,CAAC;AAAA,MACrE;AAGA,UAAI,gBAAgB,GAAG,IAAI,IAAI,GAAG;AAAA,IACpC,OAAO;AACL,UAAI,gBAAgB,GAAG,IAAI,IAAI,GAAG;AAAA,IACpC;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,CAA4B;AAClC;;;AC5GO,SAAS,YACd,SACA,OACe;AACf,SAAO,SAAS,QAAQ,CAAC,QAAQ,MAAM,QAAQ,KAAyB,IACpE,OACA,QAAQ,MAAM,YAAY,KAAyB;AACzD;;;AC+DO,IAAM,qBAAqB,SAASA,oBAEzC,MAA4C;AAC5C,QAAM,EAAE,QAAQ,SAAS,IAAI;AAE7B,aAAW,OAAO,QAAQ;AACxB,UAAM,mBAAmB,OAAO,KAAK,kBAAkB,MAAM,CAAC,EAAE;AAAA,MAC9D;AAAA,IACF;AAEA,QAAI,CAAC,kBAAkB;AACrB;AAAA,IACF;AAEA,UAAM,aAAa,OAAO,GAAG;AAE7B,QAAI,eAAe;AAEnB,QAAI,MAAM,QAAQ,UAAU,GAAG;AAC7B,qBAAe,WAAW,KAAK,GAAG;AAAA,IACpC;AAEA,QAAI,OAAO,eAAe,UAAU;AAClC,qBAAe;AAAA,IACjB;AAEA,QAAI,OAAO,eAAe,aAAa,YAAY;AACjD,qBAAe;AAAA,IACjB;AAEA,aAAS,KAA2B;AAAA,MAClC,SAAS;AAAA,IACX,CAAC;AAAA,EACH;AACF;;;AC3EO,SAAS,eACd,KACA,MAC+B;AAC/B,SACE,OAAO,QAAQ,YACf,QAAQ,QACR,OAAO,UAAU,eAAe,KAAK,KAAK,IAAI;AAElD;;;ACvCO,SAAS,gBACd,SACA,OACc;AACd,MAAI,OAAO,UAAU,UAAU;AAC7B,QAAI,UAAU,IAAI;AAChB,aAAO;AAAA,IACT;AAEA,WAAO,QAAQ,MAAM,KAAK,KAAK;AAAA,EACjC;AAEA,SAAO;AACT;;;AChBO,IAAM,+BAA+B,CAAC,UAAkB;AAC7D,SAAO,MAAM,QAAQ,YAAY,EAAE;AACrC;;;ACFA,OAAO,WAAW;AAClB,SAAS,SAAS;AAIlB,SAAS,YAAY,OAAwB;AAC3C,MAAI,CAAC,SAAS,MAAM,KAAK,MAAM,IAAI;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,MAAM,QAAQ,UAAU,EAAE;AAEzC,MAAI,CAAC,QAAQ,KAAK,MAAM,GAAG;AACzB,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,SAAS,MAAM,OAAO,SAAS,IAAI;AAC5C,WAAO;AAAA,EACT;AAEA,MAAI,MAAM;AACV,MAAI,YAAY;AAEhB,WAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;AAC3C,QAAI,QAAQ,SAAS,OAAO,OAAO,CAAC,GAAG,EAAE;AAEzC,QAAI,WAAW;AACb,eAAS;AACT,UAAI,QAAQ,GAAG;AACb,iBAAS;AAAA,MACX;AAAA,IACF;AAEA,WAAO;AACP,gBAAY,CAAC;AAAA,EACf;AAEA,SAAO,MAAM,OAAO;AACtB;AAEO,IAAM,cAAc;AAAA;AAAA,EAEzB,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EAAE,OACC,OAAO,EACP,UAAU,OAAM,MAAM,UAAU,MAAM,cAAc,OAAO,CAAE,EAC7D,OAAO,OAAK,CAAC,CAAC,GAAG,EAAE,SAAS,WAAW,mBAAmB,CAAC,EAC3D,OAAO,OAAM,IAAI,MAAM,CAAC,EAAE,QAAQ,IAAI,MAAO;AAAA,IAC5C,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEL,cAAc,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAClD,EAAE,OACC,OAAO,EACP,UAAU,OAAM,MAAM,SAAS,OAAO,CAAE,EACxC,UAAU,OAAM,MAAM,cAAc,OAAO,CAAE,EAC7C,OAAO,OAAM,CAAC,KAAK,MAAM,OAAO,MAAM,CAAC,EAAE,QAAQ,IAAI,MAAO;AAAA,IAC3D,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEL,UAAU,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC9C,EAAE,OAAO,KAAK,EAAE,OAAO,UAAQ,OAAO,oBAAI,KAAK,GAAG;AAAA,IAChD,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEH,YAAY,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAChD,EAAE,OAAO,KAAK,EAAE,OAAO,UAAQ,OAAO,oBAAI,KAAK,GAAG;AAAA,IAChD,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEH,mBAAmB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACvD,EAAE,OAAO,KAAK,EAAE;AAAA,IACd,UAAQ;AACN,YAAM,QAAQ,oBAAI,KAAK;AAEvB,YAAM,SAAS,GAAG,GAAG,GAAG,CAAC;AAEzB,aAAO,KAAK,SAAS,GAAG,GAAG,GAAG,CAAC,KAAK,MAAM,QAAQ;AAAA,IACpD;AAAA,IACA,EAAE,SAAS,WAAW,iCAAiC;AAAA,EACzD;AAAA,EAEF,iBAAiB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACrD,EAAE,OAAO,KAAK,EAAE;AAAA,IACd,UAAQ;AACN,YAAM,QAAQ,oBAAI,KAAK;AAEvB,YAAM,SAAS,GAAG,GAAG,GAAG,CAAC;AAEzB,aAAO,KAAK,SAAS,GAAG,GAAG,GAAG,CAAC,KAAK,MAAM,QAAQ;AAAA,IACpD;AAAA,IACA,EAAE,SAAS,WAAW,+BAA+B;AAAA,EACvD;AAAA,EAEF,OAAO,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC3C,EAAE,OAAO,KAAK,EAAE;AAAA,IACd,UAAQ;AACN,YAAM,mBAAmB,oBAAI,KAAK;AAElC,uBAAiB,YAAY,iBAAiB,YAAY,IAAI,EAAE;AAChE,uBAAiB,SAAS,GAAG,GAAG,GAAG,CAAC;AACpC,YAAM,MAAM,IAAI,KAAK,IAAI;AAEzB,UAAI,SAAS,GAAG,GAAG,GAAG,CAAC;AAEvB,aAAO,OAAO;AAAA,IAChB;AAAA,IACA,EAAE,SAAS,WAAW,gCAAgC;AAAA,EACxD;AAAA,EAEF,YAAY,CAAC;AAAA,IACX;AAAA,IACA;AAAA,EACF,IAA+C,CAAC,MAC9C,EAAE,OAAO,KAAK,EAAE;AAAA,IACd,UAAQ;AACN,UAAI,OAAO,eAAe,SAAU,QAAO;AAC3C,YAAM,cAAc,oBAAI,KAAK;AAE7B,kBAAY,YAAY,YAAY,YAAY,IAAI,UAAU;AAC9D,kBAAY,SAAS,GAAG,GAAG,GAAG,CAAC;AAC/B,YAAM,MAAM,IAAI,KAAK,IAAI;AAEzB,UAAI,SAAS,GAAG,GAAG,GAAG,CAAC;AAEvB,aAAO,OAAO;AAAA,IAChB;AAAA,IACA;AAAA,MACE,SACE,WACA,oBAAoB,cAAc,cAAc;AAAA,IACpD;AAAA,EACF;AAAA,EAEF,YAAY,CAAC,EAAE,SAAS,KAAK,IAAyC,CAAC,MACrE,EAAE,OAAO,KAAK,EAAE;AAAA,IACd,UAAQ;AACN,YAAM,QAAQ,oBAAI,KAAK;AAEvB,YAAM,SAAS,GAAG,GAAG,GAAG,CAAC;AACzB,YAAM,YAAY,IAAI,KAAK,IAAI;AAE/B,gBAAU,SAAS,GAAG,GAAG,GAAG,CAAC;AAE7B,YAAM,WAAW,KAAK,IAAI,UAAU,QAAQ,IAAI,MAAM,QAAQ,CAAC;AAC/D,YAAM,WAAW,KAAK,KAAK,YAAY,MAAO,KAAK,KAAK,GAAG;AAE3D,aAAO,OAAO,SAAS,WAAW,YAAY,OAAO;AAAA,IACvD;AAAA,IACA,EAAE,SAAS,WAAW,kBAAkB,IAAI,iBAAiB;AAAA,EAC/D;AAAA,EAEF,SAAS,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC7C,EAAE,OAAO,KAAK,EAAE;AAAA,IACd,UAAQ;AACN,YAAM,MAAM,KAAK,OAAO;AAExB,aAAO,QAAQ,KAAK,QAAQ;AAAA,IAC9B;AAAA,IACA,EAAE,SAAS,WAAW,oBAAoB;AAAA,EAC5C;AAAA,EAEF,WAAW,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC/C,EACG,OAAO;AAAA,IACN,OAAO,EAAE,OAAO,KAAK;AAAA,IACrB,KAAK,EAAE,OAAO,KAAK;AAAA,EACrB,CAAC,EACA,OAAO,UAAQ,KAAK,SAAS,KAAK,KAAK;AAAA,IACtC,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEL,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EAAE,OACC,KAAK,EACL,UAAU,OAAM,MAAM,QAAQ,MAAM,SAAY,OAAO,CAAE,EACzD,OAAO,OAAK,CAAC,CAAC,GAAG,EAAE,SAAS,WAAW,mBAAmB,CAAC,EAC3D,OAAO,OAAM,IAAI,MAAM,CAAC,EAAE,QAAQ,IAAI,MAAO;AAAA,IAC5C,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEL,UAAU,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC9C,EAAE,OACC,KAAK,EACL,UAAU,OAAM,MAAM,QAAQ,MAAM,SAAY,OAAO,CAAE,EACzD,OAAO,OAAK,CAAC,CAAC,GAAG,EAAE,SAAS,WAAW,4BAA4B,CAAC,EACpE,OAAO,OAAM,IAAI,MAAM,CAAC,EAAE,QAAQ,IAAI,MAAO;AAAA,IAC5C,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA;AAAA,EAGL,gBAAgB,CAAC;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAsD,CAAC,MACrD,EACG,OAAO,EACP,KAAK,EACL;AAAA,IACC,OAAO;AAAA,IACP,WAAW,2BAA2B,OAAO,CAAC;AAAA,EAChD,EACC;AAAA,IACC,OAAO;AAAA,IACP,WAAW,0BAA0B,OAAO,GAAG;AAAA,EACjD;AAAA,EAEJ,OAAO,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC3C,EACG,OAAO,EACP,MAAM,WAAW,uBAAuB,EACxC,IAAI,KAAK,sCAAsC;AAAA,EAEpD,KAAK,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACzC,EAAE,OAAO,EAAE,IAAI,WAAW,oBAAoB;AAAA,EAEhD,OAAO,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC3C,EACG,OAAO,EACP,MAAM,yBAAyB,WAAW,6BAA6B;AAAA,EAE5E,YAAY,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAChD,EAAE,OAAO,EAAE,OAAO,WAAS,YAAY,KAAK,GAAG;AAAA,IAC7C,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEH,cAAc,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAClD,EACG,OAAO,EACP,MAAM,gBAAgB,WAAW,sCAAsC;AAAA,EAE5E,oBAAoB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACxD,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,YAAY,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAChD,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EAAE,OAAO,EAAE,KAAK,WAAW,sBAAsB;AAAA,EAEnD,sBAAsB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1D,EACG,OAAO,EACP,KAAK,EACL,IAAI,GAAG,WAAW,iCAAiC;AAAA,EAExD,UAAU,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC9C,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WACE;AAAA,EACJ;AAAA,EAEJ,aAAa,CAAC;AAAA,IACZ;AAAA,IACA;AAAA,EACF,IAA2C,CAAC,MAAM;AAChD,QAAI,OAAO,WAAW,UAAU;AAC9B,YAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAEA,WAAO,EACJ,OAAO,EACP,OAAO,QAAQ,WAAW,mBAAmB,MAAM,aAAa;AAAA,EACrE;AAAA,EAEA,UAAU,CAAC;AAAA,IACT;AAAA,IACA;AAAA,EACF,IAA6C,CAAC,MAC5C,EAAE,OAAO,EAAE;AAAA,IACT,WAAS;AACP,UAAI,CAAC,MAAO,QAAO;AACnB,YAAM,QAAQ,MAAM,MAAM,aAAa,EAAE,OAAO,OAAO;AAEvD,aAAO,MAAM,WAAW,OAAO,aAAa,WAAW,WAAW;AAAA,IACpE;AAAA,IACA,EAAE,SAAS,WAAW,sBAAsB,QAAQ,WAAW;AAAA,EACjE;AAAA,EAEF,UAAU,CAAC;AAAA,IACT;AAAA,IACA;AAAA,EACF,IAA6C,CAAC,MAC5C,EAAE,OAAO,EAAE;AAAA,IACT,WAAS;AACP,UAAI,CAAC,MAAO,QAAO;AACnB,YAAM,QAAQ,MAAM,MAAM,aAAa,EAAE,OAAO,OAAO;AAEvD,aAAO,MAAM,WAAW,OAAO,aAAa,WAAW,WAAW;AAAA,IACpE;AAAA,IACA,EAAE,SAAS,WAAW,qBAAqB,QAAQ,WAAW;AAAA,EAChE;AAAA,EAEF,gBAAgB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACpD,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WACE;AAAA,EACJ;AAAA,EAEJ,QAAQ,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC5C,EACG,OAAO,EACP;AAAA,IACC,WAAS,CAAC,SAAS,CAAC,UAAU,KAAK,KAAK;AAAA,IACxC,WAAW;AAAA,EACb;AAAA,EAEJ,mBAAmB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACvD,EACG,OAAO,EACP;AAAA,IACC,WAAS,CAAC,SAAS,CAAC,iCAAiC,KAAK,KAAK;AAAA,IAC/D,WAAW;AAAA,EACb;AAAA,EAEJ,gBAAgB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACpD,EACG,OAAO,EACP;AAAA,IACC,WACE,CAAC,SACD,CAAC,mFAAmF;AAAA,MAClF;AAAA,IACF;AAAA,IACF,WAAW;AAAA,EACb;AAAA,EAEJ,eAAe,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACnD,EACG,OAAO,EACP,MAAM,mBAAmB,WAAW,kCAAkC;AAAA,EAE3E,WAAW,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC/C,EACG,OAAO,EACP,MAAM,oBAAoB,WAAW,6BAA6B;AAAA,EAEvE,cAAc,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAClD,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,YAAY,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAChD,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,sBAAsB,CAAC;AAAA,IACrB;AAAA,IACA;AAAA,EACF,IAAwD,CAAC,MACvD,EAAE,OAAO,EAAE;AAAA,IACT,cAAY;AACV,UAAI,CAAC,SAAU,QAAO;AACtB,YAAM,YAAY,SAAS,MAAM,GAAG,EAAE,IAAI,GAAG,YAAY;AACzD,YAAM,eAAe,mBAAmB;AAAA,QAAI,SAC1C,IAAI,YAAY,EAAE,WAAW,GAAG,IAC5B,IAAI,YAAY,IAChB,IAAI,IAAI,YAAY,CAAC;AAAA,MAC3B;AAEA,aAAO,aAAa,cAAc,SAAS,IAAI,SAAS,EAAE;AAAA,IAC5D;AAAA,IACA;AAAA,MACE,SACE,WACA,8CAA8C,mBAAmB,KAAK,IAAI,CAAC;AAAA,IAC/E;AAAA,EACF;AAAA,EAEF,qBAAqB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACzD,YAAY,qBAAqB;AAAA,IAC/B,mBAAmB,CAAC,GAAG,gBAAgB;AAAA,IACvC,SACE,WACA,sCAAsC,iBAAiB,KAAK,IAAI,CAAC;AAAA,EACrE,CAAC;AAAA,EAEH,wBAAwB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC5D,YAAY,qBAAqB;AAAA,IAC/B,mBAAmB,CAAC,GAAG,mBAAmB;AAAA,IAC1C,SACE,WACA,yCAAyC,oBAAoB,KAAK,IAAI,CAAC;AAAA,EAC3E,CAAC;AAAA,EAEH,SAAS,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC7C,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,SAAS,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC7C,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,OAAO,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC3C,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EACG,OAAO,EACP,MAAM,0BAA0B,WAAW,2BAA2B;AAAA,EAE3E,cAAc,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAClD,EACG,OAAO,EACP;AAAA,IACC;AAAA,IACA,WAAW;AAAA,EACb;AAAA,EAEJ,MAAM,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC1C,EACG,OAAO,EACP,MAAM,8BAA8B,WAAW,qBAAqB;AAAA;AAAA,EAGzE,gBAAgB,CAAC;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAsD,CAAC,MACrD,EACG,OAAO,EACP,SAAS,WAAW,yBAAyB,EAC7C,IAAI,OAAO,MAAM,2BAA2B,OAAO,IAAI,EAAE,EACzD;AAAA,IACC,OAAO,OAAO;AAAA,IACd,0BAA0B,OAAO,OAAO,gBAAgB;AAAA,EAC1D;AAAA,EAEJ,kBAAkB,CAAC;AAAA,IACjB;AAAA,IACA;AAAA,EACF,IAA8C,CAAC,MAC7C,EAAE,OAAO,EAAE;AAAA,IACT,WAAS;AACP,UAAI,UAAU,QAAQ,UAAU,OAAW,QAAO;AAClD,YAAM,cAAc,MAAM,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC;AAEjD,aACE,CAAC,eACD,YAAY,WAAW,OAAO,cAAc,WAAW,YAAY;AAAA,IAEvE;AAAA,IACA,EAAE,SAAS,WAAW,qBAAqB,SAAS,kBAAkB;AAAA,EACxE;AAAA,EAEF,UAAU,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC9C,EACG,OAAO,EACP,IAAI,GAAG,WAAW,4CAA4C,EAC9D;AAAA,IACC,WAAS;AACP,UAAI,UAAU,QAAQ,UAAU,OAAW,QAAO;AAClD,YAAM,cAAc,MAAM,SAAS,EAAE,MAAM,GAAG,EAAE,CAAC;AAEjD,aAAO,CAAC,eAAe,YAAY,UAAU;AAAA,IAC/C;AAAA,IACA;AAAA,MACE,SACE,WAAW;AAAA,IACf;AAAA,EACF;AAAA,EAEJ,UAAU,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAC9C,EACG,OAAO,EACP,IAAI,oBAAoB,EACxB,IAAI,GAAG,WAAW,yCAAyC,EAC3D,IAAI,KAAK,WAAW,yCAAyC;AAAA,EAElE,mBAAmB,CAAC;AAAA,IAClB;AAAA,IACA;AAAA,EACF,IAAwC,CAAC,MACvC,EACG,OAAO,EACP,IAAI,GAAG,WAAW,6BAA6B,EAC/C;AAAA,IACC,OAAO,OAAO;AAAA,IACd,0BAA0B,OAAO,OAAO,gBAAgB;AAAA,EAC1D;AAAA,EAEJ,SAAS,CAAC;AAAA,IACR;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAsD,CAAC,MACrD,EACG,OAAO,EACP,IAAI,WAAW,oBAAoB,EACnC;AAAA,IACC,OAAO,OAAO;AAAA,IACd,2BAA2B,OAAO,OAAO,gBAAgB;AAAA,EAC3D,EACC;AAAA,IACC,OAAO,OAAO;AAAA,IACd,0BAA0B,OAAO,OAAO,gBAAgB;AAAA,EAC1D;AAAA,EAEJ,YAAY,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAChD,EACG,OAAO,EACP,IAAI,GAAG,WAAW,sCAAsC,EACxD,IAAI,KAAK,WAAW,sCAAsC;AAAA;AAAA,EAG/D,eAAe,CACb,QACA,EAAE,QAAQ,IAA0B,CAAC,MAClC,EAAE,MAAM,MAAM,EAAE,IAAI,GAAG,WAAW,+BAA+B;AAAA,EAEtE,aAAa,CACX,QACA,EAAE,QAAQ,IAA0B,CAAC,MAErC,EAAE,MAAM,MAAM,EAAE,OAAO,WAAS,IAAI,IAAI,KAAK,EAAE,SAAS,MAAM,QAAQ;AAAA,IACpE,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEH,kBAAkB,CAChB,QACA,EAAE,QAAQ,IAA0B,CAAC,MAErC,EACG,MAAM,OAAO,SAAS,CAAC,EACvB,OAAO,WAAS,MAAM,MAAM,UAAQ,SAAS,IAAI,GAAG;AAAA,IACnD,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA;AAAA,EAGL,iBAAiB,CAAC,EAAE,QAAQ,IAA0B,CAAC,MACrD,EAAE,QAAQ;AAAA,IACR,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA;AAAA,EAGH,gBAAgB,CACd,QACA,EAAE,QAAQ,IAA0B,CAAC,MAErC,OAAO,OAAO,SAAO,OAAO,KAAK,GAAG,EAAE,SAAS,GAAG;AAAA,IAChD,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA;AAAA,EAGH,cAAc,CAAC,EAAE,QAAQ,IAA0B,CAAC,MAClD,EACG,WAAW,MAAM,EAAE,SAAS,WAAW,mBAAmB,CAAC,EAC3D,OAAO,UAAQ,KAAK,OAAO,GAAG;AAAA,IAC7B,SAAS,WAAW;AAAA,EACtB,CAAC;AAAA,EAEL,UAAU,CAAC,EAAE,SAAS,QAAQ,MAC5B,EAAE,WAAW,IAAI,EAAE,OAAO,UAAQ,KAAK,QAAQ,SAAS;AAAA,IACtD,SACE,WACA,+BAA+B,KAAK,MAAM,UAAU,OAAO,IAAI,CAAC;AAAA,EACpE,CAAC;AAAA,EAEH,UAAU,CAAC;AAAA,IACT;AAAA,IACA;AAAA,EACF,MAIE,EAAE,WAAW,IAAI,EAAE,OAAO,UAAQ,aAAa,SAAS,KAAK,IAAI,GAAG;AAAA,IAClE,SACE,WAAW,6BAA6B,aAAa,KAAK,IAAI,CAAC;AAAA,EACnE,CAAC;AAAA;AAAA,EAGH,aAAa,CACX,WACA,YACA,gBAEA,EAAE,MAAM,CAAC,YAAY,WAAW,CAAC,EAAE,YAAY,CAAC,MAAM,QAAQ;AAC5D,UAAM,gBAAgB,UAAU,IAAoB;AACpD,UAAM,SAAS,gBAAgB,aAAa;AAC5C,UAAM,SAAS,OAAO,UAAU,IAAI;AAEpC,QAAI,CAAC,OAAO,SAAS;AACnB,UAAI,SAAS;AAAA,QACX,MAAM,EAAE,aAAa;AAAA,QACrB,SAAS,OAAO,MAAM;AAAA,MACxB,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AAAA,EAEH,WAAW;AAAA,IACT,aAAa,EAAE,OAAO,EAAE,UAAU,SAAO,IAAI,YAAY,CAAC;AAAA,IAC1D,aAAa,EAAE,OAAO,EAAE,UAAU,SAAO,IAAI,YAAY,CAAC;AAAA,IAC1D,MAAM,EAAE,OAAO,EAAE,UAAU,SAAO,IAAI,KAAK,CAAC;AAAA,IAC5C,UAAU,EAAE,OAAO,EAAE,UAAU,SAAO,OAAO,GAAG,CAAC;AAAA,IACjD,WAAW,EAAE,OAAO,EAAE,UAAU,SAAO,QAAQ,MAAM;AAAA,IACrD,WAAW,CAAI,WACb,EAAE,OAAO,EAAE,UAAU,CAAC,KAAK,QAAQ;AACjC,UAAI;AACF,cAAM,SAAS,KAAK,MAAM,GAAG;AAC7B,cAAM,SAAS,OAAO,UAAU,MAAM;AAEtC,YAAI,OAAO,QAAS,QAAO,OAAO;AAElC,YAAI,SAAS;AAAA,UACX,MAAM,EAAE,aAAa;AAAA,UACrB,SAAS,OAAO,MAAM;AAAA,QACxB,CAAC;AAED,eAAO,EAAE;AAAA,MACX,QAAQ;AACN,YAAI,SAAS;AAAA,UACX,MAAM,EAAE,aAAa;AAAA,UACrB,SAAS;AAAA,QACX,CAAC;AAED,eAAO,EAAE;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACL;AACF;;;AC3oBO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAmBO,SAAS,YACd,KACA,KAC2B;AAC3B,SAAO,SAAS,GAAG,KAAK,OAAO;AACjC;AAkBO,SAAS,iBAAiB,OAAiC;AAChE,SAAO,OAAO,UAAU,YAAY,MAAM,SAAS;AACrD;AAkBO,SAASC,SAAqB,OAA8B;AACjE,SAAO,MAAM,QAAQ,KAAK;AAC5B;AAkBO,SAAS,gBAAmB,OAAsC;AACvE,SAAO,MAAM,QAAQ,KAAK,KAAK,MAAM,SAAS;AAChD;AAkBO,SAAS,WACd,OACmD;AACnD,SAAO,OAAO,UAAU;AAC1B;AAkBO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU;AAC1B;AAkBO,SAAS,SAAS,OAAiC;AACxD,SAAO,OAAO,UAAU,YAAY,CAAC,MAAM,KAAK;AAClD;AAkBO,SAAS,UAAU,OAAkC;AAC1D,SAAO,OAAO,UAAU;AAC1B;AAkBO,SAAS,OAAO,OAA+B;AACpD,SAAO,UAAU;AACnB;AAkBO,SAAS,YAAY,OAAoC;AAC9D,SAAO,UAAU;AACnB;AAuBO,SAAS,UAAU,OAA2C;AACnE,SAAO,UAAU,QAAQ,UAAU;AACrC;AAgBO,SAAS,UAAa,OAAmC;AAC9D,SAAO,UAAU,QAAQ,UAAU;AACrC;AAkBO,SAAS,OAAO,OAA+B;AACpD,SAAO,iBAAiB,QAAQ,CAAC,MAAM,MAAM,QAAQ,CAAC;AACxD;AAkBO,SAAS,UAAU,OAA2C;AACnE,SACE,iBAAiB,WAChB,SAAS,KAAK,KACb,OAAQ,MAAkC,SAAS;AAEzD;AAsBO,SAAS,QAAQ,OAAgC;AACtD,SAAO,iBAAiB;AAC1B;AA+BO,SAAS,QACd,OACA,WACY;AACZ,SAAO,UAAU,KAAK;AACxB;",
  "names": ["handleServerErrors", "isArray"]
}
