web-mojo 2.2.57 → 2.2.59

package/dist/chunks/Rest-W-sPfGh9.js

@@ -1,4375 +0,0 @@
-const GENERIC_AVATAR_SVG = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0iI2NlZDRkYSI+PHBhdGggZD0iTTEyIDEyYzIuMjEgMCA0LTEuNzkgNC00cy0xLjc5LTQtNC00LTQgMS43OS00IDQgMS43OSA0IDQgNHptMCAyYy0yLjY3IDAtOCAxLjM0LTggNHYyaDE2di0yYzAtMi42Ni01LjMzLTQtOC00eiIvPjwvc3ZnPg==";
-class DataFormatter {
-  constructor() {
-    this.formatters = /* @__PURE__ */ new Map();
-    this.registerBuiltInFormatters();
-  }
-  escapeHtml(str) {
-    if (str === null || str === void 0) {
-      return "";
-    }
-    const map = {
-      "&": "&",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#039;"
-    };
-    return String(str).replace(/[&<>"']/g, (m) => map[m]);
-  }
-  /**
-   * Register all built-in formatters
-   */
-  registerBuiltInFormatters() {
-    this.register("date", this.date.bind(this));
-    this.register("time", this.time.bind(this));
-    this.register("datetime", this.datetime.bind(this));
-    this.register("datetime_tz", this.datetime_tz.bind(this));
-    this.register("datatime_tz", this.datetime_tz.bind(this));
-    this.register("date_range", this.date_range.bind(this));
-    this.register("datetime_range", this.datetime_range.bind(this));
-    this.register("relative", this.relative.bind(this));
-    this.register("fromNow", this.relative.bind(this));
-    this.register("relative_short", this.relative_short.bind(this));
-    this.register("iso", this.iso.bind(this));
-    this.register("epoch", (v) => {
-      if (v === null || v === void 0 || v === "") return v;
-      const num = parseFloat(v);
-      if (isNaN(num)) return v;
-      return num * 1e3;
-    });
-    this.register("number", this.number.bind(this));
-    this.register("currency", this.currency.bind(this));
-    this.register("percent", this.percent.bind(this));
-    this.register("filesize", this.filesize.bind(this));
-    this.register("ordinal", this.ordinal.bind(this));
-    this.register("compact", this.compact.bind(this));
-    this.register("add", this.add.bind(this));
-    this.register("subtract", this.subtract.bind(this));
-    this.register("multiply", this.multiply.bind(this));
-    this.register("divide", this.divide.bind(this));
-    this.register("sub", this.subtract.bind(this));
-    this.register("mult", this.multiply.bind(this));
-    this.register("div", this.divide.bind(this));
-    this.register("uppercase", (v) => String(v).toUpperCase());
-    this.register("lowercase", (v) => String(v).toLowerCase());
-    this.register("upper", (v) => String(v).toUpperCase());
-    this.register("lower", (v) => String(v).toLowerCase());
-    this.register("capitalize", this.capitalize.bind(this));
-    this.register("caps", this.capitalize.bind(this));
-    this.register("replace", this.replace.bind(this));
-    this.register("truncate", this.truncate.bind(this));
-    this.register("truncate_middle", this.truncate_middle.bind(this));
-    this.register("truncate_front", this.truncate_front.bind(this));
-    this.register("slug", this.slug.bind(this));
-    this.register("initials", this.initials.bind(this));
-    this.register("mask", this.mask.bind(this));
-    this.register("hex", this.hex.bind(this));
-    this.register("tohex", this.hex.bind(this));
-    this.register("unhex", this.unhex.bind(this));
-    this.register("fromhex", this.unhex.bind(this));
-    this.register("email", this.email.bind(this));
-    this.register("phone", this.phone.bind(this));
-    this.register("url", this.url.bind(this));
-    this.register("badge", this.badge.bind(this));
-    this.register("badgeClass", this.badgeClass.bind(this));
-    this.register("status", this.status.bind(this));
-    this.register("status_text", this.status_text.bind(this));
-    this.register("status_icon", this.status_icon.bind(this));
-    this.register("boolean", this.boolean.bind(this));
-    this.register("bool", this.bool.bind(this));
-    this.register("yesno", (v) => this.boolean(v, "Yes", "No"));
-    this.register("yesnoicon", this.yesnoicon.bind(this));
-    this.register("icon", this.icon.bind(this));
-    this.register("avatar", this.avatar.bind(this));
-    this.register("image", this.image.bind(this));
-    this.register("tooltip", this.tooltip.bind(this));
-    this.register("linkify", this.linkify.bind(this));
-    this.register("clipboard", this.clipboard.bind(this));
-    this.register("default", this.default.bind(this));
-    this.register("equals", this.equals.bind(this));
-    this.register("json", this.json.bind(this));
-    this.register("raw", (v) => v);
-    this.register("custom", (v, fn) => typeof fn === "function" ? fn(v) : v);
-    this.register("iter", this.iter.bind(this));
-    this.register("keys", (v) => {
-      if (v && typeof v === "object" && !Array.isArray(v)) {
-        return Object.keys(v);
-      }
-      return null;
-    });
-    this.register("values", (v) => {
-      if (v && typeof v === "object" && !Array.isArray(v)) {
-        return Object.values(v);
-      }
-      return null;
-    });
-    this.register("plural", this.plural.bind(this));
-    this.register("list", this.formatList.bind(this));
-    this.register("duration", this.duration.bind(this));
-    this.register("hash", this.hash.bind(this));
-    this.register("stripHtml", this.stripHtml.bind(this));
-    this.register("highlight", this.highlight.bind(this));
-    this.register("nl2br", this.nl2br.bind(this));
-    this.register("code", this.code.bind(this));
-    this.register("pre", (v) => `<pre class="bg-light p-2 rounded border">${this.escapeHtml(String(v))}</pre>`);
-  }
-  relative_short(value) {
-    return this.relative(value, true);
-  }
-  linkify(value, options = {}) {
-    if (value === null || value === void 0) return "";
-    const text = String(value);
-    const escaped = this.escapeHtml(text);
-    const defaults = { urls: true, emails: true, target: "_blank", rel: "noopener noreferrer" };
-    const opts = options && typeof options === "object" ? { ...defaults, ...options } : defaults;
-    let result = escaped;
-    if (opts.urls !== false) {
-      const urlRegex = /(^|\s)((?:https?:\/\/|www\.)[^\s<]+)/gi;
-      result = result.replace(urlRegex, (match, prefix, url) => {
-        const href = url.startsWith("www.") ? `https://${url}` : url;
-        return `${prefix}<a href="${href}" target="${opts.target}" rel="${opts.rel}">${url}</a>`;
-      });
-    }
-    if (opts.emails !== false) {
-      const emailRegex = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
-      result = result.replace(emailRegex, (email) => `<a href="mailto:${email}">${email}</a>`);
-    }
-    return result;
-  }
-  clipboard(value, mode = "text") {
-    if (value === null || value === void 0) return "";
-    const text = String(value);
-    const escapedText = this.escapeHtml(text);
-    const showText = mode !== "icon-only";
-    const buttonHtml = `
-        <button type="button"
-                class="btn btn-sm btn-outline-secondary ms-1 p-0 border-0 bg-transparent"
-                title="Copy"
-                data-bs-toggle="tooltip"
-                data-action="copy-to-clipboard"
-                data-clipboard="${escapedText}">
-          <i class="bi bi-clipboard"></i>
-        </button>`.trim();
-    return `
-        <span class="mojo-clipboard d-inline-flex align-items-center">
-          ${showText ? `<span class="font-monospace">${escapedText}</span>` : ""}
-          ${buttonHtml}
-        </span>
-      `;
-  }
-  nl2br(value) {
-    if (value === null || value === void 0) return "";
-    return this.escapeHtml(String(value)).replace(/\r\n|\r|\n/g, "<br>");
-  }
-  code(value, lang = "") {
-    if (value === null || value === void 0) return "";
-    const language = lang ? `language-${this.escapeHtml(String(lang))}` : "";
-    const content = this.escapeHtml(String(value));
-    return `<pre class="bg-light p-2 rounded border"><code class="${language}">${content}</code></pre>`;
-  }
-  /**
-   * Register a custom formatter
-   * @param {string} name - Formatter name
-   * @param {Function} formatter - Formatter function
-   * @returns {DataFormatter} This instance for chaining
-   */
-  register(name, formatter) {
-    if (typeof formatter !== "function") {
-      throw new Error(`Formatter must be a function, got ${typeof formatter}`);
-    }
-    this.formatters.set(name.toLowerCase(), formatter);
-    return this;
-  }
-  /**
-   * Apply a formatter
-   * @param {string} name - Formatter name
-   * @param {*} value - Value to format
-   * @param {...*} args - Additional arguments
-   * @returns {*} Formatted value
-   */
-  apply(name, value, ...args) {
-    try {
-      const formatter = this.formatters.get(name.toLowerCase());
-      if (!formatter) {
-        console.warn(`Formatter '${name}' not found`);
-        return value;
-      }
-      return formatter(value, ...args);
-    } catch (error) {
-      console.error(`Error in formatter '${name}':`, error);
-      return value;
-    }
-  }
-  /**
-   * Process pipe string
-   * @param {*} value - Value to format
-   * @param {string} pipeString - Pipe string (e.g., "date('YYYY-MM-DD')|uppercase")
-   * @param {object} context - Optional context for resolving variables in formatter arguments
-   * @returns {*} Formatted value
-   */
-  pipe(value, pipeString, context = null) {
-    if (!pipeString) return value;
-    const pipes = this.parsePipeString(pipeString, context);
-    return pipes.reduce((currentValue, pipe) => {
-      return this.apply(pipe.name, currentValue, ...pipe.args);
-    }, value);
-  }
-  /**
-   * Parse pipe string into formatter calls
-   * @param {string} pipeString - Pipe string
-   * @param {object} context - Optional context for resolving variables
-   * @returns {Array} Array of {name, args} objects
-   */
-  parsePipeString(pipeString, context = null) {
-    const pipes = [];
-    const tokens = pipeString.split("|").map((s) => s.trim());
-    for (const token of tokens) {
-      const parsed = this.parseFormatter(token, context);
-      if (parsed) {
-        pipes.push(parsed);
-      }
-    }
-    return pipes;
-  }
-  /**
-   * Parse individual formatter with arguments
-   * Supports both syntaxes:
-   *   - Parentheses: formatter('arg1', 'arg2', 3)
-   *   - Colon: formatter:'arg1':'arg2':3
-   *
-   * @param {string} token - Formatter token
-   * @param {object} context - Optional context for resolving variables
-   * @returns {Object} {name, args} object
-   */
-  parseFormatter(token, context = null) {
-    const parenMatch = token.match(/^([a-zA-Z_]\w*)\s*\((.*)\)$/);
-    if (parenMatch) {
-      const [, name, argsString] = parenMatch;
-      const args = argsString ? this.parseArguments(argsString, context) : [];
-      return { name, args };
-    }
-    const colonMatch = token.match(/^([a-zA-Z_]\w*)(?::(.+))?$/);
-    if (colonMatch) {
-      const [, name, argsString] = colonMatch;
-      const args = argsString ? this.parseColonArguments(argsString, context) : [];
-      return { name, args };
-    }
-    return null;
-  }
-  /**
-   * Parse formatter arguments (comma-separated, parentheses syntax)
-   * @param {string} argsString - Arguments string
-   * @param {object} context - Optional context for resolving variables
-   * @returns {Array} Parsed arguments
-   */
-  parseArguments(argsString, context = null) {
-    const args = [];
-    let current = "";
-    let inQuotes = false;
-    let quoteChar = null;
-    let depth = 0;
-    for (let i = 0; i < argsString.length; i++) {
-      const char = argsString[i];
-      if (!inQuotes && (char === '"' || char === "'")) {
-        inQuotes = true;
-        quoteChar = char;
-        current += char;
-      } else if (inQuotes && char === quoteChar && argsString[i - 1] !== "\\") {
-        inQuotes = false;
-        quoteChar = null;
-        current += char;
-      } else if (!inQuotes && char === "{") {
-        depth++;
-        current += char;
-      } else if (!inQuotes && char === "}") {
-        depth--;
-        current += char;
-      } else if (!inQuotes && depth === 0 && char === ",") {
-        args.push(this.parseValue(current.trim(), context));
-        current = "";
-      } else {
-        current += char;
-      }
-    }
-    if (current.trim()) {
-      args.push(this.parseValue(current.trim(), context));
-    }
-    return args;
-  }
-  /**
-   * Parse formatter arguments (colon-separated syntax)
-   * Handles quoted strings with colons inside them
-   * @param {string} argsString - Arguments string
-   * @param {object} context - Optional context for resolving variables
-   * @returns {Array} Parsed arguments
-   */
-  parseColonArguments(argsString, context = null) {
-    const args = [];
-    let current = "";
-    let inQuotes = false;
-    let quoteChar = null;
-    for (let i = 0; i < argsString.length; i++) {
-      const char = argsString[i];
-      if (!inQuotes && (char === '"' || char === "'")) {
-        inQuotes = true;
-        quoteChar = char;
-        current += char;
-      } else if (inQuotes && char === quoteChar && argsString[i - 1] !== "\\") {
-        inQuotes = false;
-        quoteChar = null;
-        current += char;
-      } else if (!inQuotes && char === ":") {
-        args.push(this.parseValue(current.trim(), context));
-        current = "";
-      } else {
-        current += char;
-      }
-    }
-    if (current.trim()) {
-      args.push(this.parseValue(current.trim(), context));
-    }
-    return args;
-  }
-  /**
-   * Parse a single value
-   * @param {string} value - Value string
-   * @param {object} context - Optional context for resolving variables
-   * @returns {*} Parsed value
-   */
-  parseValue(value, context = null) {
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      return value.slice(1, -1);
-    }
-    if (value === "true") return true;
-    if (value === "false") return false;
-    if (value === "null") return null;
-    if (value === "undefined") return void 0;
-    if (!isNaN(value) && value !== "") {
-      return Number(value);
-    }
-    if (value.startsWith("{") && value.endsWith("}")) {
-      try {
-        return JSON.parse(value);
-      } catch (e) {
-      }
-    }
-    if (context && this.isIdentifier(value)) {
-      if (!value.includes(".")) {
-        if (Object.prototype.hasOwnProperty.call(context, value)) {
-          return context[value];
-        }
-      }
-      if (context.get && typeof context.get === "function") {
-        const contextValue = context.get(value);
-        if (contextValue !== void 0) {
-          return contextValue;
-        }
-      }
-      if (context.getContextValue && typeof context.getContextValue === "function") {
-        const contextValue = context.getContextValue(value);
-        if (contextValue !== void 0) {
-          return contextValue;
-        }
-      }
-      if (value.includes(".")) {
-        const MOJOUtils2 = window.MOJOUtils || (typeof require !== "undefined" ? require("./MOJOUtils.js").default : null);
-        if (MOJOUtils2) {
-          const contextValue = MOJOUtils2.getNestedValue(context, value);
-          if (contextValue !== void 0) {
-            return contextValue;
-          }
-        }
-      }
-    }
-    return value;
-  }
-  /**
-   * Check if a value is a valid identifier (variable name or dot-notation path)
-   * @param {string} value - Value to check
-   * @returns {boolean} True if valid identifier or path
-   */
-  isIdentifier(value) {
-    return /^[a-zA-Z_$][a-zA-Z0-9_$]*(\.[a-zA-Z_$][a-zA-Z0-9_$]*)*$/.test(value);
-  }
-  // ============= Date/Time Formatters =============
-  /**
-   * Format date
-   * @param {*} value - Date value
-   * @param {string} format - Date format pattern
-   * @returns {string} Formatted date
-   */
-  date(value, format = "MM/DD/YYYY") {
-    if (!value) return "";
-    value = this.normalizeEpoch(value);
-    let date;
-    if (value instanceof Date) {
-      date = value;
-    } else if (typeof value === "string") {
-      if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-        const [year, month, day] = value.split("-").map(Number);
-        date = new Date(year, month - 1, day);
-      } else {
-        date = new Date(value);
-      }
-    } else {
-      date = new Date(value);
-    }
-    if (isNaN(date.getTime())) return String(value);
-    const tokens = {
-      "YYYY": date.getFullYear(),
-      "YY": String(date.getFullYear()).slice(-2),
-      "MMMM": date.toLocaleDateString("en-US", { month: "long" }),
-      "MMM": date.toLocaleDateString("en-US", { month: "short" }),
-      "MM": String(date.getMonth() + 1).padStart(2, "0"),
-      "M": date.getMonth() + 1,
-      "dddd": date.toLocaleDateString("en-US", { weekday: "long" }),
-      "ddd": date.toLocaleDateString("en-US", { weekday: "short" }),
-      "DD": String(date.getDate()).padStart(2, "0"),
-      "D": date.getDate()
-    };
-    let result = format;
-    const tokenPattern = new RegExp(`(${Object.keys(tokens).join("|")})`, "g");
-    result = result.replace(tokenPattern, (match) => tokens[match] || match);
-    return result;
-  }
-  /**
-   * Format time
-   * @param {*} value - Time value
-   * @param {string} format - Time format pattern
-   * @returns {string} Formatted time
-   */
-  time(value, format = "HH:mm:ss") {
-    if (!value) return "";
-    value = this.normalizeEpoch(value);
-    const date = value instanceof Date ? value : new Date(value);
-    if (isNaN(date.getTime())) return String(value);
-    const hours = date.getHours();
-    const replacements = {
-      "HH": String(hours).padStart(2, "0"),
-      "H": hours,
-      "hh": String(hours % 12 || 12).padStart(2, "0"),
-      "h": hours % 12 || 12,
-      "mm": String(date.getMinutes()).padStart(2, "0"),
-      "m": date.getMinutes(),
-      "ss": String(date.getSeconds()).padStart(2, "0"),
-      "s": date.getSeconds(),
-      "A": hours >= 12 ? "PM" : "AM",
-      "a": hours >= 12 ? "pm" : "am"
-    };
-    let result = format;
-    const sortedKeys = Object.keys(replacements).sort((a, b) => b.length - a.length);
-    for (const key of sortedKeys) {
-      result = result.replace(new RegExp(key, "g"), replacements[key]);
-    }
-    return result;
-  }
-  /**
-   * Format date and time
-   * @param {*} value - DateTime value
-   * @param {string} dateFormat - Date format
-   * @param {string} timeFormat - Time format
-   * @returns {string} Formatted datetime
-   */
-  datetime(value, dateFormat = "MM/DD/YYYY", timeFormat = "HH:mm:ss") {
-    value = this.normalizeEpoch(value);
-    const dateStr = this.date(value, dateFormat);
-    const timeStr = this.time(value, timeFormat);
-    return dateStr && timeStr ? `${dateStr} ${timeStr}` : "";
-  }
-  /**
-   * Format date and time with short timezone abbreviation (e.g., EST, PDT)
-   * @param {*} value - DateTime value
-   * @param {string} dateFormat - Date format
-   * @param {string} timeFormat - Time format
-   * @param {Object} options - Options: { timeZone?: string, locale?: string }
-   * @returns {string} Formatted datetime with timezone abbreviation
-   */
-  datetime_tz(value, dateFormat = "MM/DD/YYYY", timeFormat = "HH:mm:ss", options = {}) {
-    if (!value) return "";
-    value = this.normalizeEpoch(value);
-    const date = value instanceof Date ? value : new Date(value);
-    if (isNaN(date.getTime())) return String(value);
-    const locale = options && options.locale || "en-US";
-    const timeZone = options && options.timeZone ? options.timeZone : void 0;
-    const getTzAbbr = () => {
-      let abbr2 = "";
-      try {
-        const parts2 = new Intl.DateTimeFormat(locale, {
-          hour: "2-digit",
-          minute: "2-digit",
-          timeZoneName: "short",
-          ...timeZone ? { timeZone } : {}
-        }).formatToParts(date);
-        const tzPart = parts2.find((p) => p.type === "timeZoneName");
-        abbr2 = tzPart ? tzPart.value : "";
-        if (abbr2 && /^GMT[+-]/i.test(abbr2)) {
-          try {
-            const parts22 = new Intl.DateTimeFormat(locale, {
-              timeStyle: "short",
-              timeZoneName: "short",
-              ...timeZone ? { timeZone } : {}
-            }).formatToParts(date);
-            const tz2 = parts22.find((p) => p.type === "timeZoneName");
-            if (tz2 && tz2.value && !/^GMT[+-]/i.test(tz2.value)) {
-              abbr2 = tz2.value;
-            }
-          } catch (e) {
-          }
-        }
-        if (abbr2 && /\s/.test(abbr2)) {
-          const initials = abbr2.split(/\s+/).map((w) => w[0]).join("").toUpperCase();
-          if (initials.length >= 2 && initials.length <= 4) {
-            abbr2 = initials;
-          }
-        }
-      } catch (e) {
-        abbr2 = "";
-      }
-      return abbr2;
-    };
-    if (!timeZone) {
-      const dateStr2 = this.date(date, dateFormat);
-      const timeStr2 = this.time(date, timeFormat);
-      const abbr2 = getTzAbbr();
-      return dateStr2 && timeStr2 ? `${dateStr2} ${timeStr2} ${abbr2}`.trim() : "";
-    }
-    const parts = new Intl.DateTimeFormat(locale, {
-      timeZone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hourCycle: "h23"
-    }).formatToParts(date);
-    const get = (type) => {
-      const p = parts.find((pt) => pt.type === type);
-      return p ? p.value : "";
-    };
-    const y4 = get("year");
-    const M2 = get("month");
-    const D2 = get("day");
-    const H2 = get("hour");
-    const m2 = get("minute");
-    const s2 = get("second");
-    const M = M2 ? String(parseInt(M2, 10)) : "";
-    const D = D2 ? String(parseInt(D2, 10)) : "";
-    const H = H2 ? String(parseInt(H2, 10)) : "";
-    const hNum = H2 ? parseInt(H2, 10) % 12 || 12 : "";
-    const A = H2 ? parseInt(H2, 10) >= 12 ? "PM" : "AM" : "";
-    const a = A ? A.toLowerCase() : "";
-    const monthLong = new Intl.DateTimeFormat(locale, { timeZone, month: "long" }).format(date);
-    const monthShort = new Intl.DateTimeFormat(locale, { timeZone, month: "short" }).format(date);
-    const weekdayLong = new Intl.DateTimeFormat(locale, { timeZone, weekday: "long" }).format(date);
-    const weekdayShort = new Intl.DateTimeFormat(locale, { timeZone, weekday: "short" }).format(date);
-    const dateTokens = {
-      "YYYY": y4,
-      "YY": y4 ? y4.slice(-2) : "",
-      "MMMM": monthLong,
-      "MMM": monthShort,
-      "MM": M2,
-      "M": M,
-      "dddd": weekdayLong,
-      "ddd": weekdayShort,
-      "DD": D2,
-      "D": D
-    };
-    const timeTokens = {
-      "HH": H2,
-      "H": H,
-      "hh": hNum !== "" ? String(hNum).padStart(2, "0") : "",
-      "h": hNum !== "" ? String(hNum) : "",
-      "mm": m2,
-      "m": m2 ? String(parseInt(m2, 10)) : "",
-      "ss": s2,
-      "s": s2 ? String(parseInt(s2, 10)) : "",
-      "A": A,
-      "a": a
-    };
-    const replaceTokens = (fmt, tokens) => {
-      if (!fmt) return "";
-      const pattern = new RegExp(`(${Object.keys(tokens).sort((a2, b) => b.length - a2.length).join("|")})`, "g");
-      return fmt.replace(pattern, (match) => tokens[match] ?? match);
-    };
-    const dateStr = replaceTokens(dateFormat, dateTokens);
-    const timeStr = replaceTokens(timeFormat, timeTokens);
-    const abbr = getTzAbbr();
-    return dateStr && timeStr ? `${dateStr} ${timeStr} ${abbr}`.trim() : "";
-  }
-  normalizeEpoch(value) {
-    if (typeof value !== "number") value = Number(value);
-    if (isNaN(value)) return "";
-    if (value < 1e11) {
-      return value * 1e3;
-    } else if (value > 1e12 && value < 1e13) {
-      return value;
-    } else {
-      throw new Error("Value doesn't look like epoch seconds or ms");
-    }
-  }
-  /**
-   * Format date range
-   * @param {*} startValue - Start date (required)
-   * @param {*} endValue - End date (defaults to now)
-   * @param {string} format - Date format (defaults to 'MM/DD/YYYY')
-   * @returns {string} Formatted date range (e.g., "01/01/2025 - 01/31/2025")
-   */
-  date_range(startValue, endValue = null, format = "MM/DD/YYYY") {
-    if (!startValue) return "";
-    const endVal = endValue || /* @__PURE__ */ new Date();
-    const startStr = this.date(startValue, format);
-    const endStr = this.date(endVal, format);
-    if (!startStr || !endStr) return "";
-    return `${startStr} - ${endStr}`;
-  }
-  /**
-   * Format datetime range
-   * @param {*} startValue - Start datetime (required)
-   * @param {*} endValue - End datetime (defaults to now)
-   * @param {string} dateFormat - Date format (defaults to 'MM/DD/YYYY')
-   * @param {string} timeFormat - Time format (defaults to 'HH:mm')
-   * @returns {string} Formatted datetime range (e.g., "01/01/2025 14:30 - 01/31/2025 16:45")
-   */
-  datetime_range(startValue, endValue = null, dateFormat = "MM/DD/YYYY", timeFormat = "HH:mm") {
-    if (!startValue) return "";
-    const endVal = endValue || /* @__PURE__ */ new Date();
-    const startStr = this.datetime(startValue, dateFormat, timeFormat);
-    const endStr = this.datetime(endVal, dateFormat, timeFormat);
-    if (!startStr || !endStr) return "";
-    return `${startStr} - ${endStr}`;
-  }
-  /**
-   * Format relative time
-   * @param {*} value - Date value
-   * @param {boolean} short - Use short format
-   * @returns {string} Relative time string
-   */
-  relative(value, short = false) {
-    if (!value) return "";
-    value = this.normalizeEpoch(value);
-    const date = value instanceof Date ? value : new Date(value);
-    if (isNaN(date.getTime())) return String(value);
-    const now = /* @__PURE__ */ new Date();
-    const diffMs = date - now;
-    const absDiffMs = Math.abs(diffMs);
-    const diffSecs = Math.floor(absDiffMs / 1e3);
-    const diffMins = Math.floor(diffSecs / 60);
-    const diffHours = Math.floor(diffMins / 60);
-    const diffDays = Math.floor(diffHours / 24);
-    const isFuture = diffMs > 0;
-    if (short) {
-      if (diffDays > 365) return Math.floor(diffDays / 365) + "y";
-      if (diffDays > 30) return Math.floor(diffDays / 30) + "mo";
-      if (diffDays > 7) return Math.floor(diffDays / 7) + "w";
-      if (diffDays > 0) return diffDays + "d";
-      if (diffHours > 0) return diffHours + "h";
-      if (diffMins > 0) return diffMins + "m";
-      return "now";
-    }
-    if (diffDays > 365) {
-      const years = Math.floor(diffDays / 365);
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + years + " year" + (years > 1 ? "s" : "") + suffix;
-    }
-    if (diffDays > 30) {
-      const months = Math.floor(diffDays / 30);
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + months + " month" + (months > 1 ? "s" : "") + suffix;
-    }
-    if (diffDays > 7) {
-      const weeks = Math.floor(diffDays / 7);
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + weeks + " week" + (weeks > 1 ? "s" : "") + suffix;
-    }
-    if (diffDays === 1) return isFuture ? "tomorrow" : "yesterday";
-    if (diffDays > 0) {
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + diffDays + " days" + suffix;
-    }
-    if (diffHours > 0) {
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + diffHours + " hour" + (diffHours > 1 ? "s" : "") + suffix;
-    }
-    if (diffMins > 0) {
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + diffMins + " minute" + (diffMins > 1 ? "s" : "") + suffix;
-    }
-    if (diffSecs > 30) {
-      const prefix = isFuture ? "in " : "";
-      const suffix = isFuture ? "" : " ago";
-      return prefix + diffSecs + " seconds" + suffix;
-    }
-    return "just now";
-  }
-  /**
-   * Format ISO date
-   * @param {*} value - Date value
-   * @param {boolean} dateOnly - Return date only
-   * @returns {string} ISO date string
-   */
-  iso(value, dateOnly = false) {
-    if (!value) return "";
-    value = this.normalizeEpoch(value);
-    const date = value instanceof Date ? value : new Date(value);
-    if (isNaN(date.getTime())) return String(value);
-    if (dateOnly) {
-      return date.toISOString().split("T")[0];
-    }
-    return date.toISOString();
-  }
-  // ============= Number Formatters =============
-  /**
-   * Format number
-   * @param {*} value - Number value
-   * @param {number} decimals - Decimal places
-   * @param {string} locale - Locale string
-   * @returns {string} Formatted number
-   */
-  number(value, decimals = 2, locale = "en-US") {
-    const num = parseFloat(value);
-    if (isNaN(num)) return String(value);
-    return num.toLocaleString(locale, {
-      minimumFractionDigits: decimals,
-      maximumFractionDigits: decimals
-    });
-  }
-  /**
-   * Format currency
-   * @param {*} value - Number value in cents
-   * @param {string} symbol - Currency symbol
-   * @param {number} decimals - Decimal places
-   * @returns {string} Formatted currency
-   */
-  currency(value, symbol = "$", decimals = 2) {
-    const num = parseInt(value);
-    if (isNaN(num)) return String(value);
-    const centsStr = Math.abs(num).toString();
-    const sign = num < 0 ? "-" : "";
-    let dollars, cents;
-    if (centsStr.length <= 2) {
-      dollars = "0";
-      cents = centsStr.padStart(2, "0");
-    } else {
-      dollars = centsStr.slice(0, -2);
-      cents = centsStr.slice(-2);
-    }
-    dollars = dollars.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-    let formatted;
-    if (decimals === 0) {
-      const totalCents = parseInt(cents);
-      if (totalCents >= 50) {
-        dollars = (parseInt(dollars.replace(/,/g, "")) + 1).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-      }
-      formatted = dollars;
-    } else if (decimals === 2) {
-      formatted = `${dollars}.${cents}`;
-    } else {
-      const adjustedCents = cents.slice(0, decimals).padEnd(decimals, "0");
-      formatted = `${dollars}.${adjustedCents}`;
-    }
-    return sign + symbol + formatted;
-  }
-  /**
-   * Format percentage
-   * @param {*} value - Number value
-   * @param {number} decimals - Decimal places
-   * @param {boolean} multiply - Multiply by 100
-   * @returns {string} Formatted percentage
-   */
-  percent(value, decimals = 0, multiply = true) {
-    const num = parseFloat(value);
-    if (isNaN(num)) return String(value);
-    const percent = multiply ? num * 100 : num;
-    return this.number(percent, decimals) + "%";
-  }
-  /**
-   * Format file size
-   * @param {*} value - Size in bytes
-   * @param {boolean} binary - Use binary units (1024)
-   * @param {number} decimals - Decimal places
-   * @returns {string} Formatted file size
-   */
-  filesize(value, binary = false, decimals = 1) {
-    const bytes = parseInt(value);
-    if (isNaN(bytes)) return String(value);
-    const units = binary ? ["B", "KiB", "MiB", "GiB", "TiB"] : ["B", "KB", "MB", "GB", "TB"];
-    const divisor = binary ? 1024 : 1e3;
-    let size = bytes;
-    let unitIndex = 0;
-    while (size >= divisor && unitIndex < units.length - 1) {
-      size /= divisor;
-      unitIndex++;
-    }
-    const decimalPlaces = unitIndex === 0 ? 0 : decimals;
-    return `${size.toFixed(decimalPlaces)} ${units[unitIndex]}`;
-  }
-  /**
-   * Format ordinal number
-   * @param {*} value - Number value
-   * @param {boolean} suffixOnly - Return suffix only
-   * @returns {string} Ordinal number
-   */
-  ordinal(value, suffixOnly = false) {
-    const num = parseInt(value);
-    if (isNaN(num)) return String(value);
-    const j = num % 10;
-    const k = num % 100;
-    let suffix = "th";
-    if (j === 1 && k !== 11) suffix = "st";
-    else if (j === 2 && k !== 12) suffix = "nd";
-    else if (j === 3 && k !== 13) suffix = "rd";
-    return suffixOnly ? suffix : num + suffix;
-  }
-  /**
-   * Format compact number
-   * @param {*} value - Number value
-   * @param {number} decimals - Decimal places
-   * @returns {string} Compact number
-   */
-  compact(value, decimals = 1) {
-    const num = parseFloat(value);
-    if (isNaN(num)) return String(value);
-    const abs = Math.abs(num);
-    const sign = num < 0 ? "-" : "";
-    if (abs >= 1e9) {
-      return sign + (abs / 1e9).toFixed(decimals) + "B";
-    }
-    if (abs >= 1e6) {
-      return sign + (abs / 1e6).toFixed(decimals) + "M";
-    }
-    if (abs >= 1e3) {
-      return sign + (abs / 1e3).toFixed(decimals) + "K";
-    }
-    return String(num);
-  }
-  /**
-   * Add numbers
-   * @param {*} value - First number
-   * @param {*} addend - Number to add
-   * @returns {number} Sum
-   */
-  add(value, addend) {
-    const num1 = parseFloat(value);
-    const num2 = parseFloat(addend);
-    if (isNaN(num1) || isNaN(num2)) return value;
-    return num1 + num2;
-  }
-  /**
-   * Subtract numbers
-   * @param {*} value - First number
-   * @param {*} subtrahend - Number to subtract
-   * @returns {number} Difference
-   */
-  subtract(value, subtrahend) {
-    const num1 = parseFloat(value);
-    const num2 = parseFloat(subtrahend);
-    if (isNaN(num1) || isNaN(num2)) return value;
-    return num1 - num2;
-  }
-  /**
-   * Multiply numbers
-   * @param {*} value - First number
-   * @param {*} multiplier - Number to multiply by
-   * @returns {number} Product
-   */
-  multiply(value, multiplier) {
-    const num1 = parseFloat(value);
-    const num2 = parseFloat(multiplier);
-    if (isNaN(num1) || isNaN(num2)) return value;
-    return num1 * num2;
-  }
-  /**
-   * Divide numbers
-   * @param {*} value - Dividend
-   * @param {*} divisor - Divisor
-   * @returns {number} Quotient
-   */
-  divide(value, divisor) {
-    const num1 = parseFloat(value);
-    const num2 = parseFloat(divisor);
-    if (isNaN(num1) || isNaN(num2) || num2 === 0) return value;
-    return num1 / num2;
-  }
-  // ============= String Formatters =============
-  /**
-   * Capitalize string
-   * @param {*} value - String value
-   * @param {boolean} all - Capitalize all words (default: true). If false, only capitalizes first letter
-   * @returns {string} Capitalized string
-   */
-  capitalize(value, all = true) {
-    const str = String(value);
-    if (!str) return "";
-    if (all) {
-      return str.replace(/\b\w/g, (c) => c.toUpperCase());
-    }
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-  /**
-   * Replace occurrences in a string
-   * @param {*} value - String value
-   * @param {*} search - Search value (string or RegExp-ish string like "/_/g")
-   * @param {*} replacement - Replacement string
-   * @param {string} flags - Optional RegExp flags when search is a plain string
-   * @returns {string} Updated string
-   *
-   * Examples:
-   *  - {{model.name|replace:'_':''}}              // underscores removed (all occurrences)
-   *  - {{model.name|replace('_', '')}}           // parentheses syntax
-   *  - {{model.name|replace:'_':' ':'g'}}        // replace all underscores with spaces
-   *  - {{model.name|replace:'/[_-]+/g':' '}}     // regex form in a string
-   */
-  replace(value, search, replacement = "", flags = "g") {
-    if (value === null || value === void 0) return "";
-    const str = String(value);
-    if (search === null || search === void 0 || search === "") {
-      return str;
-    }
-    if (search instanceof RegExp) {
-      return str.replace(search, String(replacement));
-    }
-    const searchStr = String(search);
-    const regexLike = searchStr.match(/^\/(.+)\/([a-z]*)$/i);
-    if (regexLike) {
-      const [, pattern, rxFlags] = regexLike;
-      try {
-        return str.replace(new RegExp(pattern, rxFlags), String(replacement));
-      } catch (e) {
-      }
-    }
-    if (String(flags).includes("g")) {
-      return str.split(searchStr).join(String(replacement));
-    }
-    return str.replace(searchStr, String(replacement));
-  }
-  /**
-   * Truncate string
-   * @param {*} value - String value
-   * @param {number} length - Max length
-   * @param {string} suffix - Suffix to append
-   * @returns {string} Truncated string
-   */
-  truncate(value, length = 50, suffix = "...") {
-    const str = String(value);
-    if (str.length <= length) return str;
-    return str.substring(0, length) + suffix;
-  }
-  /**
-   * Truncate keeping only the end of the string
-   * @param {*} value - String value
-   * @param {number} length - Characters to keep at the end
-   * @param {string} prefix - Text to prepend when truncating
-   * @returns {string} Truncated string
-   */
-  truncate_front(value, length = 8, prefix = "...") {
-    const str = String(value);
-    if (str.length <= length) {
-      return str;
-    }
-    return `${prefix}${str.slice(-length)}`;
-  }
-  /**
-   * Truncate string in the middle
-   * @param {*} value - String value
-   * @param {number} size - The total number of characters to keep (half for the start, half for the end).
-   * @param {string} replace - The character(s) to use for the middle part.
-   * @returns {string} Truncated string
-   */
-  truncate_middle(value, size = 8, replace = "***") {
-    const str = String(value);
-    if (str.length <= size) {
-      return str;
-    }
-    const halfSize = Math.floor(size / 2);
-    const front = str.substring(0, halfSize);
-    const back = str.substring(str.length - halfSize);
-    return `${front}${replace}${back}`;
-  }
-  /**
-   * Create slug from string
-   * @param {*} value - String value
-   * @param {string} separator - Word separator
-   * @returns {string} Slug
-   */
-  slug(value, separator = "-") {
-    const str = String(value);
-    return str.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, separator).replace(new RegExp(`${separator}+`, "g"), separator).replace(new RegExp(`^${separator}|${separator}$`, "g"), "");
-  }
-  /**
-   * Get initials from string
-   * @param {*} value - String value
-   * @param {number} count - Number of initials
-   * @returns {string} Initials
-   */
-  initials(value, count = 2) {
-    const str = String(value);
-    const words = str.split(/\s+/).filter((w) => w.length > 0);
-    return words.slice(0, count).map((word) => word.charAt(0).toUpperCase()).join("");
-  }
-  /**
-   * Mask string
-   * @param {*} value - String value
-   * @param {string} char - Mask character
-   * @param {number} showLast - Number of chars to show at end
-   * @returns {string} Masked string
-   */
-  mask(value, char = "*", showLast = 4) {
-    const str = String(value);
-    if (str.length <= showLast) return str;
-    const masked = char.repeat(Math.max(0, str.length - showLast));
-    const visible = str.slice(-showLast);
-    return masked + visible;
-  }
-  // ============= HTML/Web Formatters =============
-  /**
-   * Format email
-   * @param {*} value - Email value
-   * @param {Object} options - Options
-   * @returns {string} Formatted email
-   */
-  email(value, options = {}) {
-    const email = String(value).trim();
-    if (!email) return "";
-    if (options.link === false) {
-      return email;
-    }
-    const subject = options.subject ? `?subject=${encodeURIComponent(options.subject)}` : "";
-    const body = options.body ? `&body=${encodeURIComponent(options.body)}` : "";
-    const className = options.class ? ` class="${options.class}"` : "";
-    return `<a href="mailto:${email}${subject}${body}"${className}>${email}</a>`;
-  }
-  /**
-   * Format phone number
-   * @param {*} value - Phone value
-   * @param {string} format - Format type
-   * @param {boolean} link - Create tel link
-   * @returns {string} Formatted phone
-   */
-  phone(value, format = "US", link = true) {
-    let phone = String(value).replace(/\D/g, "");
-    let formatted = phone;
-    if (format === "US") {
-      if (phone.length === 10) {
-        formatted = `(${phone.slice(0, 3)}) ${phone.slice(3, 6)}-${phone.slice(6)}`;
-      } else if (phone.length === 11 && phone[0] === "1") {
-        formatted = `+1 (${phone.slice(1, 4)}) ${phone.slice(4, 7)}-${phone.slice(7)}`;
-      }
-    }
-    if (!link) {
-      return formatted;
-    }
-    return `<a href="tel:${phone}">${formatted}</a>`;
-  }
-  /**
-   * Format URL
-   * @param {*} value - URL value
-   * @param {string} text - Link text
-   * @param {boolean} newWindow - Open in new window
-   * @returns {string} Formatted URL
-   */
-  url(value, text = null, newWindow = true) {
-    let url = String(value).trim();
-    if (!url) return "";
-    if (!/^https?:\/\//.test(url)) {
-      url = "https://" + url;
-    }
-    const linkText = text || url;
-    const target = newWindow ? ' target="_blank"' : "";
-    const rel = newWindow ? ' rel="noopener noreferrer"' : "";
-    return `<a href="${url}"${target}${rel}>${linkText}</a>`;
-  }
-  /**
-   * Format as badge
-   * @param {*} value - Badge text
-   * @param {string} type - Badge type
-   * @returns {string} Badge HTML
-   */
-  badge(value, type = "auto") {
-    if (Array.isArray(value)) {
-      return value.map((item) => this.badge(item, type)).join(" ");
-    }
-    const text = String(value);
-    const badgeType = type === "auto" ? this.inferBadgeType(text) : type;
-    const className = badgeType ? `bg-${badgeType}` : "bg-secondary";
-    return `<span class="badge ${className}">${text}</span>`;
-  }
-  /**
-   * Get badge CSS class for a value
-   * @param {*} value - Value to get badge class for
-   * @param {string} type - Badge type (optional, auto-detected if not specified)
-   * @returns {string} Badge CSS class
-   */
-  badgeClass(value, type = "auto") {
-    const text = String(value);
-    const badgeType = type === "auto" ? this.inferBadgeType(text) : type;
-    return badgeType ? `bg-${badgeType}` : "bg-secondary";
-  }
-  /**
-   * Infer badge type from text
-   * @param {string} text - Badge text
-   * @returns {string} Badge type
-   */
-  inferBadgeType(text) {
-    const lowered = text.toLowerCase();
-    if (["active", "pass", "success", "complete", "completed", "approved", "done", "true", "on", "yes"].includes(lowered)) return "success";
-    if (["error", "failed", "fail", "rejected", "deleted", "cancelled", "false", "off", "no", "declined"].includes(lowered)) return "danger";
-    if (["warning", "pending", "review", "processing", "uploading"].includes(lowered)) return "warning";
-    if (["info", "new", "draft"].includes(lowered)) return "info";
-    if (["inactive", "disabled", "archived", "suspended"].includes(lowered)) return "secondary";
-    return "secondary";
-  }
-  status(value) {
-    return this._status(value);
-  }
-  status_icon(value) {
-    return this._status(value, {}, {}, false, true);
-  }
-  status_text(value) {
-    return this._status(value, {}, {}, true, false);
-  }
-  /**
-   * Format status
-   * @param {*} value - Status value
-   * @param {Object} icons - Icon mapping
-   * @param {Object} colors - Color mapping
-   * @param {boolean} noIcons - Whether to include icons
-   * @param {boolean} noText - Whether to include text
-   * @returns {string} Status HTML
-   */
-  _status(value, icons = {}, colors = {}, noIcons = false, noText = false) {
-    const status = String(value).toLowerCase();
-    const defaultIcons = {
-      "active": "bi bi-check-circle-fill",
-      "approved": "bi bi-check-circle-fill",
-      "declined": "bi bi-x-circle-fill",
-      "inactive": "bi bi-pause-circle-fill",
-      "pending": "bi bi-clock-fill",
-      "success": "bi bi-check-circle-fill",
-      "error": "bi bi-exclamation-triangle-fill",
-      "warning": "bi bi-exclamation-triangle-fill"
-    };
-    const defaultColors = {
-      "active": "success",
-      "approved": "success",
-      "declined": "danger",
-      "inactive": "secondary",
-      "pending": "warning",
-      "success": "success",
-      "error": "danger",
-      "warning": "warning"
-    };
-    const iconClass = icons[status] || defaultIcons[status] || "";
-    const color = colors[status] || defaultColors[status] || "secondary";
-    let icon = "";
-    if (!noIcons && iconClass) {
-      icon = `<i class="${iconClass}"></i>`;
-    }
-    let text = "";
-    if (!noText) {
-      text = value;
-    }
-    return `<span class="text-${color}">${icon}${icon ? " " : ""}${text}</span>`;
-  }
-  /**
-   * Format boolean
-   * @param {*} value - Boolean value
-   * @param {string} trueText - Text for true
-   * @param {string} falseText - Text for false
-   * @returns {string} Boolean text
-   */
-  boolean(value, trueText = "True", falseText = "False", colored = false) {
-    const text = value ? trueText : falseText;
-    return colored ? `<span class="text-${value ? "success" : "danger"}">${text}</span>` : text;
-  }
-  bool(value) {
-    if (value === null || value === void 0 || value === 0 || value === "") {
-      return false;
-    }
-    if (value === false || value === "false") {
-      return false;
-    }
-    if (value === true || value === "true") {
-      return true;
-    }
-    if (Array.isArray(value) && value.length === 0) {
-      return false;
-    }
-    if (value && typeof value === "object" && value.constructor === Object && Object.keys(value).length === 0) {
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Format icon
-   * @param {*} value - Icon key
-   * @param {Object} mapping - Icon mapping
-   * @returns {string} Icon HTML
-   */
-  icon(value, mapping = {}) {
-    const key = String(value).toLowerCase();
-    const icon = mapping[key] || "";
-    return icon ? `<i class="${icon}"></i>` : "";
-  }
-  /**
-   * Format boolean as a yes/no icon
-   * @param {*} value - Boolean value
-   * @returns {string} Icon HTML
-   */
-  yesnoicon(value, yesIcon = "bi bi-check-circle-fill text-success", noIcon = "bi bi-x-circle-fill text-danger") {
-    if (value) {
-      return `<i class="${yesIcon}"></i>`;
-    }
-    return `<i class="${noIcon}"></i>`;
-  }
-  /**
-   * Format value as Bootstrap 5 image with optional rendition support
-   * @param {string|object} value - URL string or file object with renditions
-   * @param {string} rendition - Desired rendition (thumbnail, thumbnail_sm, etc.)
-   * @param {string} classes - Additional CSS classes
-   * @param {string} alt - Alt text for the image
-   * @returns {string} Bootstrap image HTML
-   */
-  image(value, rendition = "thumbnail", classes = "img-fluid", alt = "") {
-    const url = this._extractImageUrl(value, rendition);
-    if (!url) return "";
-    return `<img src="${url}" class="${classes}" alt="${alt}" />`;
-  }
-  /**
-   * Format value as Bootstrap 5 avatar (circular image)
-   * @param {string|object} value - URL string or file object with renditions
-   * @param {string} size - Avatar size (xs, sm, md, lg, xl)
-   * @param {string} classes - Additional CSS classes
-   * @param {string} alt - Alt text for the avatar
-   * @returns {string} Bootstrap avatar HTML
-   */
-  avatar(value, size = "md", classes = "rounded-circle", alt = "") {
-    const url = this._extractImageUrl(value, "square_sm") || GENERIC_AVATAR_SVG;
-    const sizeClasses = {
-      "xs": "width: 1.5rem; height: 1.5rem;",
-      "sm": "width: 2rem; height: 2rem;",
-      "md": "width: 3rem; height: 3rem;",
-      "lg": "width: 4rem; height: 4rem;",
-      "xl": "width: 5rem; height: 5rem;"
-    };
-    const sizeStyle = sizeClasses[size] || sizeClasses["md"];
-    const baseClasses = "object-fit-cover";
-    const allClasses = `${baseClasses} ${classes}`.trim();
-    return `<img src="${url}" class="${allClasses}" style="${sizeStyle}" alt="${alt}" />`;
-  }
-  /**
-   * Tooltip formatter - wraps value with Bootstrap tooltip
-   * Usage:
-   *   {{value|tooltip:'Tooltip text'}}
-   *   {{value|tooltip:'Help text':top}}
-   *   {{value|tooltip:'Info':bottom:html}}
-   *
-   * @param {*} value - Value to display (not escaped, works with formatter chains)
-   * @param {string} text - Tooltip text content
-   * @param {string} placement - Tooltip placement: top, bottom, left, right (default: top)
-   * @param {string} html - 'html' to allow HTML in tooltip (default: text only)
-   * @returns {string} HTML with tooltip
-   */
-  tooltip(value, text = "", placement = "top", html = "") {
-    if (value === null || value === void 0) return "";
-    const displayValue = String(value);
-    const tooltipText = html === "html" ? text : this.escapeHtml(text);
-    const dataAttr = html === "html" ? 'data-bs-html="true"' : "";
-    return `<span data-bs-toggle="tooltip" data-bs-placement="${placement}" ${dataAttr} data-bs-title="${tooltipText}">${displayValue}</span>`;
-  }
-  /**
-   * Helper method to extract image URL from string or file object
-   * @param {string|object} value - URL string or file object with renditions
-   * @param {string} preferredRendition - Preferred rendition name
-   * @returns {string|null} Image URL or null if not found
-   */
-  _extractImageUrl(value, preferredRendition = "thumbnail") {
-    if (!value) return null;
-    if (typeof value === "string") {
-      return value;
-    }
-    if (typeof value === "object") {
-      if (value.attributes) value = value.attributes;
-      if (preferredRendition === "thumbnail" && value.thumbnail && typeof value.thumbnail === "string") {
-        return value.thumbnail;
-      }
-      if (value.renditions && typeof value.renditions === "object") {
-        const rendition = value.renditions[preferredRendition];
-        if (rendition && rendition.url) {
-          return rendition.url;
-        }
-        const availableRenditions = Object.values(value.renditions);
-        if (availableRenditions.length > 0 && availableRenditions[0].url) {
-          return availableRenditions[0].url;
-        }
-      }
-      if (value.url) {
-        return value.url;
-      }
-    }
-    return null;
-  }
-  // ============= Utility Formatters =============
-  /**
-   * Apply default value
-   * @param {*} value - Value
-   * @param {*} defaultValue - Default value
-   * @returns {*} Value or default
-   */
-  default(value, defaultValue = "") {
-    return value === null || value === void 0 || value === "" ? defaultValue : value;
-  }
-  /**
-   * Compare value and return one of two results based on equality
-   * Useful for conditional CSS classes, text, or any conditional output
-   *
-   * @param {*} value - Value to compare
-   * @param {*} compareValue - Value to compare against
-   * @param {*} trueResult - Result if values are equal
-   * @param {*} falseResult - Result if values are not equal (optional, defaults to empty string)
-   * @returns {*} trueResult or falseResult
-   *
-   * @example
-   * // CSS classes
-   * {{status|equals:1:'text-success':'text-secondary'}}
-   * {{model.state|equals:'active':'badge-success':'badge-secondary'}}
-   *
-   * // Text output
-   * {{role|equals:'admin':'Administrator':'User'}}
-   *
-   * // Numbers
-   * {{count|equals:0:'No items':'Has items'}}
-   */
-  equals(value, compareValue, trueResult, falseResult = "") {
-    return value == compareValue ? trueResult : falseResult;
-  }
-  /**
-   * Format as JSON
-   * @param {*} value - Value to stringify
-   * @param {number} indent - Indentation
-   * @returns {string} JSON string
-   */
-  /**
-   * Format pluralization based on count
-   * @param {number} count - The count value
-   * @param {string} singular - Singular form of the word
-   * @param {string|null} plural - Plural form (defaults to singular + 's')
-   * @param {boolean} includeCount - Whether to include the count in output
-   * @returns {string} Formatted plural string
-   */
-  plural(count, singular, plural = null, includeCount = true) {
-    if (count === null || count === void 0 || singular === null || singular === void 0) {
-      return includeCount ? `${count} ${singular}` : singular || "";
-    }
-    const num = parseInt(count);
-    if (isNaN(num)) {
-      return includeCount ? `${count} ${singular}` : singular || "";
-    }
-    const word = Math.abs(num) === 1 ? singular : plural || singular + "s";
-    return includeCount ? `${num} ${word}` : word;
-  }
-  /**
-   * Format array as a human-readable list
-   * @param {Array} array - Array to format
-   * @param {Object} options - Formatting options
-   * @returns {string} Formatted list string
-   */
-  formatList(array, options = {}) {
-    if (!Array.isArray(array)) {
-      return String(array);
-    }
-    const { conjunction = "and", limit = null, moreText = "others" } = options;
-    if (array.length === 0) return "";
-    if (array.length === 1) return String(array[0]);
-    let items = array.slice();
-    let hasMore = false;
-    if (limit && array.length > limit) {
-      items = array.slice(0, limit);
-      hasMore = true;
-    }
-    if (hasMore) {
-      const remaining = array.length - limit;
-      return `${items.join(", ")}, ${conjunction} ${remaining} ${moreText}`;
-    }
-    if (items.length === 2) {
-      return `${items[0]} ${conjunction} ${items[1]}`;
-    }
-    return `${items.slice(0, -1).join(", ")}, ${conjunction} ${items[items.length - 1]}`;
-  }
-  /**
-   * Format duration to human-readable format
-   * @param {number} value - Duration value
-   * @param {string} unit - Input unit: 'ms', 's', 'm', 'h', 'd' (defaults to 'ms')
-   * @param {boolean} short - Use short format (e.g., '1h30m' vs '1 hour 30 minutes')
-   * @param {number} precision - Max number of units to show (defaults to 2)
-   * @returns {string} Formatted duration string
-   */
-  duration(value, unit = "ms", short = false, precision = 2) {
-    if (value === null || value === void 0) return "";
-    const num = parseFloat(value);
-    if (isNaN(num)) return String(value);
-    let ms;
-    switch (unit) {
-      case "s":
-      case "sec":
-      case "seconds":
-        ms = num * 1e3;
-        break;
-      case "m":
-      case "min":
-      case "minutes":
-        ms = num * 6e4;
-        break;
-      case "h":
-      case "hr":
-      case "hours":
-        ms = num * 36e5;
-        break;
-      case "d":
-      case "day":
-      case "days":
-        ms = num * 864e5;
-        break;
-      case "ms":
-      case "milliseconds":
-      default:
-        ms = num;
-    }
-    const units = [
-      { name: "day", short: "d", value: 864e5 },
-      { name: "hour", short: "h", value: 36e5 },
-      { name: "minute", short: "m", value: 6e4 },
-      { name: "second", short: "s", value: 1e3 }
-    ];
-    if (ms === 0) return short ? "0s" : "0 seconds";
-    const absMs = Math.abs(ms);
-    const sign = ms < 0 ? "-" : "";
-    const parts = [];
-    let remaining = absMs;
-    for (const u of units) {
-      if (remaining >= u.value) {
-        const count = Math.floor(remaining / u.value);
-        remaining = remaining % u.value;
-        const unitName = short ? u.short : count === 1 ? u.name : u.name + "s";
-        parts.push(short ? `${count}${unitName}` : `${count} ${unitName}`);
-        if (parts.length >= precision) break;
-      }
-    }
-    if (parts.length === 0) {
-      return short ? `${Math.round(absMs)}ms` : `${Math.round(absMs)} milliseconds`;
-    }
-    return sign + (short ? parts.join("") : parts.join(" "));
-  }
-  /**
-   * Format long strings/IDs with truncation
-   * @param {string} value - Value to format
-   * @param {number} length - Maximum length before truncation
-   * @param {string} prefix - Prefix to add
-   * @param {string} suffix - Suffix for truncated strings
-   * @returns {string} Formatted hash string
-   */
-  hash(value, length = 8, prefix = "", suffix = "...") {
-    if (value === null || value === void 0) return "";
-    const str = String(value);
-    if (str.length <= length) return prefix + str;
-    return prefix + str.substring(0, length) + suffix;
-  }
-  /**
-   * Strip HTML tags from text
-   * @param {string} html - HTML string to strip
-   * @returns {string} Plain text without HTML tags
-   */
-  stripHtml(html) {
-    if (html === null || html === void 0) return "";
-    return String(html).replace(/<[^>]*>/g, "");
-  }
-  /**
-   * Highlight search terms in text
-   * @param {string} text - Text to search in
-   * @param {string} searchTerm - Term to highlight
-   * @param {string} className - CSS class for highlighting
-   * @returns {string} Text with highlighted terms
-   */
-  highlight(text, searchTerm, className = "highlight") {
-    if (text === null || text === void 0 || !searchTerm) {
-      return String(text || "");
-    }
-    const escapedTerm = String(searchTerm).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`(${escapedTerm})`, "gi");
-    return String(text).replace(regex, `<mark class="${className}">$1</mark>`);
-  }
-  /**
-   * Encode a value as a hex string.
-   * - Strings are encoded as UTF-8 bytes, then hex-encoded
-   * - Numbers are converted to base-16 (padded to even length)
-   * - Uint8Array/ArrayBuffer/number[] are treated as bytes
-   *
-   * @param {*} value - The value to encode
-   * @param {boolean} uppercase - Uppercase hex letters (A-F)
-   * @param {boolean} withPrefix - Prefix with '0x'
-   * @returns {string} Hex string
-   */
-  hex(value, uppercase = false, withPrefix = false) {
-    if (value === null || value === void 0) return "";
-    let hexStr = "";
-    const toHexFromBytes = (bytes) => Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-    if (typeof value === "number") {
-      let hex = Math.abs(Math.trunc(value)).toString(16);
-      if (hex.length % 2) hex = "0" + hex;
-      hexStr = hex;
-    } else if (value instanceof Uint8Array) {
-      hexStr = toHexFromBytes(value);
-    } else if (value instanceof ArrayBuffer) {
-      hexStr = toHexFromBytes(new Uint8Array(value));
-    } else if (Array.isArray(value) && value.every((n) => typeof n === "number")) {
-      hexStr = toHexFromBytes(Uint8Array.from(value.map((n) => n & 255)));
-    } else {
-      const enc = new TextEncoder();
-      const bytes = enc.encode(String(value));
-      hexStr = toHexFromBytes(bytes);
-    }
-    if (uppercase) hexStr = hexStr.toUpperCase();
-    return (withPrefix ? "0x" : "") + hexStr;
-  }
-  /**
-   * Decode a hex string into UTF-8 text.
-   * Accepts optional '0x' prefix and ignores whitespace.
-   *
-   * @param {string} value - Hex string
-   * @returns {string} Decoded UTF-8 string (or original value on parse error)
-   */
-  unhex(value) {
-    if (value === null || value === void 0) return "";
-    let str = String(value).trim();
-    if (str.startsWith("0x") || str.startsWith("0X")) str = str.slice(2);
-    str = str.replace(/\s+/g, "");
-    if (str.length === 0) return "";
-    if (str.length % 2 !== 0) str = "0" + str;
-    const bytes = new Uint8Array(str.length / 2);
-    for (let i = 0; i < str.length; i += 2) {
-      const byte = parseInt(str.slice(i, i + 2), 16);
-      if (Number.isNaN(byte)) {
-        return String(value);
-      }
-      bytes[i / 2] = byte;
-    }
-    try {
-      const dec = new TextDecoder();
-      return dec.decode(bytes);
-    } catch (e) {
-      let text = "";
-      for (const b of bytes) text += String.fromCharCode(b);
-      return text;
-    }
-  }
-  json(value, indent = 2) {
-    try {
-      return JSON.stringify(value, null, indent);
-    } catch (e) {
-      return String(value);
-    }
-  }
-  /**
-   * Check if formatter exists
-   * @param {string} name - Formatter name
-   * @returns {boolean} True if exists
-   */
-  has(name) {
-    return this.formatters.has(name.toLowerCase());
-  }
-  /**
-   * Remove a formatter
-   * @param {string} name - Formatter name
-   * @returns {boolean} True if removed
-   */
-  unregister(name) {
-    return this.formatters.delete(name.toLowerCase());
-  }
-  /**
-   * Get all formatter names
-   * @returns {Array} Formatter names
-   */
-  listFormatters() {
-    return Array.from(this.formatters.keys()).sort();
-  }
-  iter(v) {
-    if (v === null || v === void 0) {
-      return [];
-    }
-    if (Array.isArray(v)) {
-      return v;
-    }
-    if (typeof v === "object") {
-      return Object.entries(v).map(([key, value]) => ({
-        key,
-        value
-      }));
-    }
-    return [{ key: "0", value: v }];
-  }
-}
-const dataFormatter = new DataFormatter();
-window.dataFormatter = dataFormatter;
-class MOJOUtils {
-  /**
-   * Get data from context with support for:
-   * - Dot notation (e.g., "user.name")
-   * - Pipe formatting (e.g., "name|uppercase")
-   * - Combined (e.g., "user.name|uppercase|truncate(10)")
-   *
-   * @param {object} context - The data context to search in
-   * @param {string} key - The key path with optional pipes
-   * @returns {*} The value, possibly formatted
-   */
-  static getContextData(context, key) {
-    if (!key || context == null) {
-      return void 0;
-    }
-    let field = key;
-    let pipes = "";
-    let parenDepth = 0;
-    let pipeIndex = -1;
-    for (let i = 0; i < key.length; i++) {
-      const char = key[i];
-      if (char === "(") parenDepth++;
-      else if (char === ")") parenDepth--;
-      else if (char === "|" && parenDepth === 0) {
-        pipeIndex = i;
-        break;
-      }
-    }
-    if (pipeIndex > -1) {
-      field = key.substring(0, pipeIndex).trim();
-      pipes = key.substring(pipeIndex + 1).trim();
-    }
-    const value = this.getNestedValue(context, field);
-    if (pipes) {
-      return dataFormatter.pipe(value, pipes, context);
-    }
-    return value;
-  }
-  /**
-   * Get nested value from object using dot notation
-   * IMPORTANT: Never calls get() on the top-level context to avoid recursion
-   * But DOES call get() on nested objects if they have that method
-   *
-   * @param {object} context - The object to search in
-   * @param {string} path - Dot notation path
-   * @returns {*} The value at the path
-   */
-  static getNestedValue(context, path) {
-    if (!path || context == null) {
-      return void 0;
-    }
-    if (!path.includes(".")) {
-      if (path in context) {
-        const value = context[path];
-        if (typeof value === "function") {
-          return value.call(context);
-        }
-        return value;
-      }
-      return void 0;
-    }
-    const keys = path.split(".");
-    let current = context;
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      if (current == null) {
-        return void 0;
-      }
-      if (i === 0) {
-        if (current.hasOwnProperty(key)) {
-          const value = current[key];
-          if (typeof value === "function") {
-            current = value.call(context);
-          } else {
-            current = value;
-          }
-        } else {
-          return void 0;
-        }
-      } else {
-        if (current && typeof current.getContextValue === "function") {
-          const remainingPath = keys.slice(i).join(".");
-          return current.getContextValue(remainingPath);
-        }
-        if (Array.isArray(current) && !isNaN(key)) {
-          current = current[parseInt(key)];
-        } else if (current.hasOwnProperty(key)) {
-          current = current[key];
-        } else if (typeof current[key] === "function") {
-          current = current[key].call(current);
-        } else {
-          return void 0;
-        }
-      }
-    }
-    return current;
-  }
-  /**
-   * Check if a value is null or undefined
-   * @param {*} value - Value to check
-   * @returns {boolean} True if null or undefined
-   */
-  static isNullOrUndefined(value) {
-    return value === null || value === void 0;
-  }
-  /**
-   * Deep clone an object
-   * @param {*} obj - Object to clone
-   * @returns {*} Cloned object
-   */
-  static deepClone(obj) {
-    if (obj === null || typeof obj !== "object") return obj;
-    if (obj instanceof Date) return new Date(obj.getTime());
-    if (obj instanceof Array) return obj.map((item) => this.deepClone(item));
-    if (obj instanceof Object) {
-      const clonedObj = {};
-      for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-          clonedObj[key] = this.deepClone(obj[key]);
-        }
-      }
-      return clonedObj;
-    }
-  }
-  /**
-   * Merge objects deeply
-   * @param {object} target - Target object
-   * @param {...object} sources - Source objects to merge
-   * @returns {object} Merged object
-   */
-  static deepMerge(target, ...sources) {
-    if (!sources.length) return target;
-    const source = sources.shift();
-    if (this.isObject(target) && this.isObject(source)) {
-      for (const key in source) {
-        if (this.isObject(source[key])) {
-          if (!target[key]) Object.assign(target, { [key]: {} });
-          this.deepMerge(target[key], source[key]);
-        } else {
-          Object.assign(target, { [key]: source[key] });
-        }
-      }
-    }
-    return this.deepMerge(target, ...sources);
-  }
-  /**
-   * Check if value is a plain object
-   * @param {*} item - Value to check
-   * @returns {boolean} True if plain object
-   */
-  static isObject(item) {
-    return item && typeof item === "object" && !Array.isArray(item);
-  }
-  /**
-   * Debounce function calls
-   * @param {function} func - Function to debounce
-   * @param {number} wait - Wait time in milliseconds
-   * @returns {function} Debounced function
-   */
-  static debounce(func, wait) {
-    let timeout;
-    return function executedFunction(...args) {
-      const later = () => {
-        clearTimeout(timeout);
-        func(...args);
-      };
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-    };
-  }
-  /**
-   * Throttle function calls
-   * @param {function} func - Function to throttle
-   * @param {number} limit - Time limit in milliseconds
-   * @returns {function} Throttled function
-   */
-  static throttle(func, limit) {
-    let inThrottle;
-    return function(...args) {
-      if (!inThrottle) {
-        func.apply(this, args);
-        inThrottle = true;
-        setTimeout(() => inThrottle = false, limit);
-      }
-    };
-  }
-  /**
-   * Generate a unique ID
-   * @param {string} prefix - Optional prefix for the ID
-   * @returns {string} Unique ID
-   */
-  static generateId(prefix = "") {
-    const timestamp = Date.now().toString(36);
-    const randomStr = Math.random().toString(36).substr(2, 9);
-    return prefix ? `${prefix}_${timestamp}_${randomStr}` : `${timestamp}_${randomStr}`;
-  }
-  /**
-   * Escape HTML special characters
-   * @param {string} str - String to escape
-   * @returns {string} Escaped string
-   */
-  static escapeHtml(str) {
-    const entityMap = {
-      "&": "&amp;",
-      "<": "&lt;",
-      ">": "&gt;",
-      '"': "&quot;",
-      "'": "&#39;",
-      "/": "&#x2F;",
-      "`": "&#x60;",
-      "=": "&#x3D;"
-    };
-    return String(str).replace(/[&<>"'`=\/]/g, (s) => entityMap[s]);
-  }
-  /**
-   * Check password strength and provide detailed feedback
-   * @param {string} password - Password to check
-   * @returns {object} Password strength analysis
-   */
-  static checkPasswordStrength(password) {
-    if (!password || typeof password !== "string") {
-      return {
-        score: 0,
-        strength: "invalid",
-        feedback: ["Password must be a non-empty string"],
-        details: {
-          length: 0,
-          hasLowercase: false,
-          hasUppercase: false,
-          hasNumbers: false,
-          hasSpecialChars: false,
-          hasCommonPatterns: false,
-          isCommonPassword: false
-        }
-      };
-    }
-    const feedback = [];
-    const details = {
-      length: password.length,
-      hasLowercase: /[a-z]/.test(password),
-      hasUppercase: /[A-Z]/.test(password),
-      hasNumbers: /[0-9]/.test(password),
-      hasSpecialChars: /[^a-zA-Z0-9]/.test(password),
-      hasCommonPatterns: false,
-      isCommonPassword: false
-    };
-    let score = 0;
-    if (password.length < 6) {
-      feedback.push("Password should be at least 6 characters long");
-    } else if (password.length < 8) {
-      score += 1;
-      feedback.push("Consider using at least 8 characters for better security");
-    } else if (password.length < 12) {
-      score += 3;
-    } else {
-      score += 4;
-    }
-    if (details.hasLowercase) score += 1;
-    else feedback.push("Include lowercase letters");
-    if (details.hasUppercase) score += 1;
-    else feedback.push("Include uppercase letters");
-    if (details.hasNumbers) score += 1;
-    else feedback.push("Include numbers");
-    if (details.hasSpecialChars) score += 2;
-    else feedback.push("Include special characters (!@#$%^&* etc.)");
-    const commonPatterns = [
-      /123/,
-      // Sequential numbers
-      /abc/i,
-      // Sequential letters
-      /qwerty/i,
-      // Keyboard patterns
-      /asdf/i,
-      // Keyboard patterns
-      /(.)\1{2,}/,
-      // Repeated characters (aaa, 111)
-      /password/i,
-      // Contains "password"
-      /admin/i,
-      // Contains "admin"
-      /user/i,
-      // Contains "user"
-      /login/i
-      // Contains "login"
-    ];
-    for (const pattern of commonPatterns) {
-      if (pattern.test(password)) {
-        details.hasCommonPatterns = true;
-        score -= 1;
-        feedback.push("Avoid common patterns and dictionary words");
-        break;
-      }
-    }
-    const commonPasswords = [
-      "123456",
-      "password",
-      "123456789",
-      "12345678",
-      "12345",
-      "1234567",
-      "1234567890",
-      "qwerty",
-      "abc123",
-      "111111",
-      "123123",
-      "admin",
-      "letmein",
-      "welcome",
-      "monkey",
-      "password123",
-      "123qwe",
-      "qwerty123",
-      "000000",
-      "dragon",
-      "sunshine",
-      "princess",
-      "azerty",
-      "1234",
-      "iloveyou",
-      "trustno1",
-      "superman",
-      "shadow",
-      "master",
-      "jennifer"
-    ];
-    if (commonPasswords.includes(password.toLowerCase())) {
-      details.isCommonPassword = true;
-      score = Math.max(0, score - 3);
-      feedback.push("This password is too common and easily guessed");
-    }
-    let strength;
-    if (score < 2) {
-      strength = "very-weak";
-    } else if (score < 4) {
-      strength = "weak";
-    } else if (score < 6) {
-      strength = "fair";
-    } else if (score < 8) {
-      strength = "good";
-    } else {
-      strength = "strong";
-    }
-    if (score >= 7 && feedback.length === 0) {
-      feedback.push("Strong password! Consider using a password manager.");
-    } else if (score >= 5 && feedback.length <= 1) {
-      feedback.push("Good password strength. Consider adding more variety.");
-    }
-    return {
-      score: Math.max(0, score),
-      strength,
-      feedback,
-      details
-    };
-  }
-  /**
-   * Generate a secure password with customizable options
-   * @param {object} options - Password generation options
-   * @param {number} options.length - Password length (default: 12)
-   * @param {boolean} options.includeLowercase - Include lowercase letters (default: true)
-   * @param {boolean} options.includeUppercase - Include uppercase letters (default: true)
-   * @param {boolean} options.includeNumbers - Include numbers (default: true)
-   * @param {boolean} options.includeSpecialChars - Include special characters (default: true)
-   * @param {string} options.customChars - Custom character set to use
-   * @param {boolean} options.excludeAmbiguous - Exclude ambiguous characters like 0, O, l, I (default: false)
-   * @returns {string} Generated password
-   */
-  static generatePassword(options = {}) {
-    const defaults = {
-      length: 12,
-      includeLowercase: true,
-      includeUppercase: true,
-      includeNumbers: true,
-      includeSpecialChars: true,
-      customChars: "",
-      excludeAmbiguous: false
-    };
-    const config = { ...defaults, ...options };
-    if (config.length < 4) {
-      throw new Error("Password length must be at least 4 characters");
-    }
-    let lowercase = "abcdefghijklmnopqrstuvwxyz";
-    let uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    let numbers = "0123456789";
-    let specialChars = "!@#$%^&*()_+-=[]{}|;:,.<>?";
-    if (config.excludeAmbiguous) {
-      lowercase = lowercase.replace(/[il]/g, "");
-      uppercase = uppercase.replace(/[IOL]/g, "");
-      numbers = numbers.replace(/[01]/g, "");
-      specialChars = specialChars.replace(/[|]/g, "");
-    }
-    let charPool = "";
-    const requiredChars = [];
-    if (config.customChars) {
-      charPool = config.customChars;
-    } else {
-      if (config.includeLowercase) {
-        charPool += lowercase;
-        requiredChars.push(lowercase[Math.floor(Math.random() * lowercase.length)]);
-      }
-      if (config.includeUppercase) {
-        charPool += uppercase;
-        requiredChars.push(uppercase[Math.floor(Math.random() * uppercase.length)]);
-      }
-      if (config.includeNumbers) {
-        charPool += numbers;
-        requiredChars.push(numbers[Math.floor(Math.random() * numbers.length)]);
-      }
-      if (config.includeSpecialChars) {
-        charPool += specialChars;
-        requiredChars.push(specialChars[Math.floor(Math.random() * specialChars.length)]);
-      }
-    }
-    if (!charPool) {
-      throw new Error("No character types selected for password generation");
-    }
-    let password = "";
-    for (const char of requiredChars) {
-      password += char;
-    }
-    for (let i = password.length; i < config.length; i++) {
-      password += charPool[Math.floor(Math.random() * charPool.length)];
-    }
-    return password.split("").sort(() => Math.random() - 0.5).join("");
-  }
-  /**
-   * Parse query string into object
-   * @param {string} queryString - Query string to parse
-   * @returns {object} Parsed query parameters
-   */
-  static parseQueryString(queryString) {
-    const params = {};
-    const searchParams = new URLSearchParams(queryString);
-    for (const [key, value] of searchParams.entries()) {
-      params[key] = value;
-    }
-    return params;
-  }
-  /**
-   * Convert object to query string
-   * @param {object} params - Parameters object
-   * @returns {string} Query string
-   */
-  static toQueryString(params) {
-    return new URLSearchParams(params).toString();
-  }
-  /**
-   * Wrap data objects to provide get() method support
-   * This ensures pipe formatting works in all contexts
-   * @param {*} data - Data to wrap
-   * @param {object} rootContext - Optional root context for nested access
-   * @returns {*} Wrapped data if object/array, otherwise original
-   */
-  static wrapData(data, rootContext = null, depth = 3) {
-    if (!data || typeof data !== "object") {
-      return data;
-    }
-    if (data instanceof Date || data instanceof RegExp || data instanceof Error) {
-      return data;
-    }
-    if (depth <= 0) {
-      return data;
-    }
-    if (typeof data.getContextValue === "function") {
-      return data;
-    }
-    if (Array.isArray(data)) {
-      return data.map((item) => {
-        if (item && typeof item === "object" && !item.getContextValue) {
-          return new DataWrapper(item, rootContext);
-        }
-        return item;
-      });
-    }
-    return new DataWrapper(data, rootContext);
-  }
-}
-class DataWrapper {
-  constructor(data, rootContext = null) {
-    Object.defineProperty(this, "_data", {
-      value: data,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-    Object.defineProperty(this, "_rootContext", {
-      value: rootContext,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-    if (data && typeof data === "object") {
-      for (const key in data) {
-        if (data.hasOwnProperty(key)) {
-          const value = data[key];
-          this[key] = MOJOUtils.wrapData(value, rootContext);
-        }
-      }
-    }
-  }
-  /**
-   * Get value with pipe support
-   * @param {string} key - Key with optional pipes
-   * @returns {*} Value, possibly formatted
-   */
-  getContextValue(key) {
-    let field = key;
-    let pipes = "";
-    let parenDepth = 0;
-    let pipeIndex = -1;
-    for (let i = 0; i < key.length; i++) {
-      const char = key[i];
-      if (char === "(") parenDepth++;
-      else if (char === ")") parenDepth--;
-      else if (char === "|" && parenDepth === 0) {
-        pipeIndex = i;
-        break;
-      }
-    }
-    if (pipeIndex > -1) {
-      field = key.substring(0, pipeIndex).trim();
-      pipes = key.substring(pipeIndex + 1).trim();
-    }
-    let value;
-    if (field in this && field !== "_data" && field !== "_rootContext") {
-      value = this[field];
-    } else {
-      value = MOJOUtils.getNestedValue(this._data, field);
-    }
-    if (pipes && value !== void 0) {
-      return dataFormatter.pipe(value, pipes, this._rootContext || this._data);
-    }
-    return value;
-  }
-  /**
-   * Check if wrapper has a property
-   * @param {string} key - Property key
-   * @returns {boolean} True if property exists
-   */
-  has(key) {
-    return this._data && this._data.hasOwnProperty(key);
-  }
-  /**
-   * Get the raw wrapped data
-   * @returns {object} The original data object
-   */
-  toJSON() {
-    return this._data;
-  }
-}
-MOJOUtils.DataWrapper = DataWrapper;
-if (typeof window !== "undefined") {
-  window.utils = MOJOUtils;
-}
-const objectToString = Object.prototype.toString;
-const isArray = Array.isArray || function(obj) {
-  return objectToString.call(obj) === "[object Array]";
-};
-const isFunction = function(obj) {
-  return typeof obj === "function";
-};
-const isObject = function(obj) {
-  return obj !== null && typeof obj === "object";
-};
-function getDataFormatter() {
-  if (typeof window === "undefined") return null;
-  if (window.MOJO?.dataFormatter) return window.MOJO.dataFormatter;
-  if (window.dataFormatter) return window.dataFormatter;
-  return null;
-}
-const escapeHtml = function(string) {
-  const entityMap = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-    "/": "&#x2F;",
-    "`": "&#x60;",
-    "=": "&#x3D;"
-  };
-  return String(string).replace(/[&<>"'`=\/]/g, function(s) {
-    return entityMap[s];
-  });
-};
-class Scanner {
-  constructor(string) {
-    this.string = string;
-    this.tail = string;
-    this.pos = 0;
-  }
-  eos() {
-    return this.tail === "";
-  }
-  scan(re) {
-    const match = this.tail.match(re);
-    if (!match || match.index !== 0) {
-      return "";
-    }
-    const string = match[0];
-    this.tail = this.tail.substring(string.length);
-    this.pos += string.length;
-    return string;
-  }
-  scanUntil(re) {
-    const index = this.tail.search(re);
-    let match;
-    switch (index) {
-      case -1:
-        match = this.tail;
-        this.tail = "";
-        break;
-      case 0:
-        match = "";
-        break;
-      default:
-        match = this.tail.substring(0, index);
-        this.tail = this.tail.substring(index);
-    }
-    this.pos += match.length;
-    return match;
-  }
-}
-class Context {
-  constructor(view, parentContext) {
-    this.view = view;
-    this.cache = { ".": this.view };
-    this.parent = parentContext;
-    if (!this.view?._cacheId) {
-      if (this.view && typeof this.view === "object") {
-        this.view._cacheId = Math.random().toString(36).substring(2);
-      }
-    }
-  }
-  push(view) {
-    return new Context(view, this);
-  }
-  lookup(name) {
-    if (this.renderCache && this.view?._cacheId) {
-      const cacheKey = `${this.view._cacheId}:${name}`;
-      if (this.renderCache.has(cacheKey)) {
-        return this.renderCache.get(cacheKey);
-      }
-    }
-    if (name === ".") {
-      return this.view;
-    }
-    if (name && name.startsWith(".")) {
-      let actualName = name.substring(1);
-      let shouldIterate = false;
-      let pipeString = null;
-      const pipeIndex = actualName.indexOf("|");
-      if (pipeIndex !== -1) {
-        pipeString = actualName.substring(pipeIndex + 1).trim();
-        actualName = actualName.substring(0, pipeIndex).trim();
-      }
-      if (actualName.endsWith("|iter")) {
-        actualName = actualName.substring(0, actualName.length - 5);
-        shouldIterate = true;
-      }
-      if (this.view && typeof this.view === "object") {
-        let value2;
-        if (typeof this.view.getContextValue === "function") {
-          try {
-            value2 = this.view.getContextValue(actualName);
-            if (value2 !== void 0) {
-              if (isFunction(value2)) {
-                value2 = value2.call(this.view);
-              }
-            }
-          } catch (e) {
-            value2 = void 0;
-          }
-        }
-        if (value2 === void 0 && actualName in this.view) {
-          value2 = this.view[actualName];
-          if (isFunction(value2)) {
-            value2 = value2.call(this.view);
-          }
-        }
-        if (pipeString && value2 !== void 0) {
-          try {
-            const formatter = getDataFormatter();
-            if (formatter && typeof formatter.pipe === "function") {
-              value2 = formatter.pipe(value2, pipeString, this);
-            }
-          } catch (e) {
-          }
-        }
-        if (isArray(value2)) {
-          if (shouldIterate) {
-            return value2;
-          } else {
-            return value2.length > 0;
-          }
-        }
-        if (isObject(value2)) {
-          if (shouldIterate) {
-            return Object.entries(value2).map(([key, val]) => ({
-              key,
-              value: val
-            }));
-          } else {
-            return Object.keys(value2).length > 0;
-          }
-        }
-        return value2;
-      }
-      return void 0;
-    }
-    const cache = this.cache;
-    let value;
-    if (cache.hasOwnProperty(name)) {
-      value = cache[name];
-    } else {
-      let context = this;
-      let intermediateValue;
-      let names;
-      let index;
-      let lookupHit = false;
-      while (context) {
-        if (context.view && typeof context.view.getContextValue === "function") {
-          try {
-            intermediateValue = context.view.getContextValue(name);
-            if (intermediateValue !== void 0) {
-              lookupHit = true;
-            }
-          } catch (e) {
-            lookupHit = false;
-          }
-        }
-        if (!lookupHit) {
-          if (name.indexOf(".") > 0) {
-            intermediateValue = context.view;
-            names = name.split(".");
-            index = 0;
-            while (intermediateValue != null && index < names.length) {
-              if (intermediateValue && typeof intermediateValue.getContextValue === "function" && index < names.length) {
-                try {
-                  const remainingPath = names.slice(index).join(".");
-                  intermediateValue = intermediateValue.getContextValue(remainingPath);
-                  index = names.length;
-                  if (intermediateValue !== void 0) {
-                    lookupHit = true;
-                  }
-                } catch (e) {
-                  if (index === names.length - 1) {
-                    lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
-                  }
-                  intermediateValue = intermediateValue[names[index++]];
-                }
-              } else {
-                if (index === names.length - 1) {
-                  lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
-                }
-                intermediateValue = intermediateValue[names[index++]];
-              }
-            }
-          } else {
-            intermediateValue = context.view[name];
-            lookupHit = hasProperty(context.view, name);
-          }
-        }
-        if (lookupHit) {
-          value = intermediateValue;
-          break;
-        }
-        context = context.parent;
-      }
-      cache[name] = value;
-    }
-    if (isFunction(value)) value = value.call(this.view);
-    if (this.renderCache && this.view?._cacheId) {
-      const cacheKey = `${this.view._cacheId}:${name}`;
-      this.renderCache.set(cacheKey, value);
-    }
-    return value;
-  }
-}
-function hasProperty(obj, propName) {
-  return obj != null && typeof obj === "object" && propName in obj;
-}
-function primitiveHasOwnProperty(primitive, propName) {
-  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
-}
-class Writer {
-  constructor() {
-    this.templateCache = /* @__PURE__ */ new Map();
-  }
-  clearCache() {
-    this.templateCache.clear();
-  }
-  parse(template, tags) {
-    tags = tags || ["{{", "}}"];
-    const cacheKey = template + ":" + tags.join(":");
-    let tokens = this.templateCache.get(cacheKey);
-    if (tokens == null) {
-      tokens = this.parseTemplate(template, tags);
-      this.templateCache.set(cacheKey, tokens);
-    }
-    return tokens;
-  }
-  parseTemplate(template, tags) {
-    if (!template) return [];
-    const openingTag = tags[0];
-    const closingTag = tags[1];
-    const scanner = new Scanner(template);
-    const tokens = [];
-    let start, type, value, chr, token;
-    const openingTagRe = new RegExp(escapeRegExp(openingTag) + "\\s*");
-    const closingTagRe = new RegExp("\\s*" + escapeRegExp(closingTag));
-    const closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + closingTag));
-    while (!scanner.eos()) {
-      start = scanner.pos;
-      value = scanner.scanUntil(openingTagRe);
-      if (value) {
-        for (let i = 0; i < value.length; ++i) {
-          chr = value.charAt(i);
-          if (chr === "\n") {
-            tokens.push(["text", chr]);
-          } else {
-            tokens.push(["text", chr]);
-          }
-        }
-      }
-      if (!scanner.scan(openingTagRe)) break;
-      type = scanner.scan(/[#^\/>{&=!]/);
-      if (!type) type = "name";
-      scanner.scan(/\s*/);
-      if (type === "=") {
-        value = scanner.scanUntil(/\s*=/);
-        scanner.scan(/\s*=/);
-        scanner.scanUntil(closingTagRe);
-      } else if (type === "{") {
-        value = scanner.scanUntil(closingCurlyRe);
-        scanner.scan(closingCurlyRe);
-        type = "&";
-      } else {
-        value = scanner.scanUntil(closingTagRe);
-      }
-      scanner.scan(closingTagRe);
-      if (type === "#" || type === "^") {
-        token = [type, value, start, scanner.pos];
-        tokens.push(token);
-      } else if (type === "/") {
-        let openSection;
-        for (let i = tokens.length - 1; i >= 0; --i) {
-          if (tokens[i][0] === "#" || tokens[i][0] === "^") {
-            if (tokens[i][1] === value) {
-              openSection = tokens[i];
-              break;
-            }
-          }
-        }
-        if (openSection) {
-          if (openSection.length === 4) {
-            openSection.push(scanner.pos);
-          }
-        }
-        tokens.push([type, value, start, scanner.pos]);
-      } else {
-        tokens.push([type, value, start, scanner.pos]);
-      }
-    }
-    return this.nestSections(this.squashTokens(tokens));
-  }
-  squashTokens(tokens) {
-    const squashedTokens = [];
-    let token, lastToken;
-    for (let i = 0; i < tokens.length; ++i) {
-      token = tokens[i];
-      if (token) {
-        if (token[0] === "text" && lastToken && lastToken[0] === "text") {
-          lastToken[1] += token[1];
-          lastToken[3] = token[3];
-        } else {
-          squashedTokens.push(token);
-          lastToken = token;
-        }
-      }
-    }
-    return squashedTokens;
-  }
-  nestSections(tokens) {
-    const nestedTokens = [];
-    let collector = nestedTokens;
-    const sections = [];
-    for (let i = 0; i < tokens.length; ++i) {
-      const token = tokens[i];
-      switch (token[0]) {
-        case "#":
-        case "^":
-          const sectionToken = [
-            token[0],
-            // type ('#' or '^')
-            token[1],
-            // section name
-            token[2],
-            // start position
-            token[3],
-            // end position after opening tag
-            [],
-            // children array
-            token[4] || null
-            // closing position (if set during parsing)
-          ];
-          collector.push(sectionToken);
-          sections.push(sectionToken);
-          collector = sectionToken[4];
-          break;
-        case "/":
-          const section = sections.pop();
-          if (section) {
-            section[5] = token[2];
-            collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
-          }
-          break;
-        default:
-          collector.push(token);
-      }
-    }
-    return nestedTokens;
-  }
-  render(template, view, partials, config) {
-    const tags = this.getConfigTags(config) || ["{{", "}}"];
-    const tokens = this.parse(template, tags);
-    const renderCache = /* @__PURE__ */ new Map();
-    return this.renderTokens(tokens, new Context(view), partials, template, config, renderCache);
-  }
-  renderTokens(tokens, context, partials, originalTemplate, config, renderCache) {
-    if (renderCache && !context.renderCache) {
-      context.renderCache = renderCache;
-    }
-    let buffer = "";
-    for (let i = 0; i < tokens.length; ++i) {
-      const token = tokens[i];
-      let value;
-      switch (token[0]) {
-        case "#":
-          value = context.lookup(token[1]);
-          if (!value) continue;
-          const childTokens = token[4];
-          if (!childTokens || !isArray(childTokens)) {
-            console.warn(`MUSTACHE WARNING - Section ${token[1]} has no child tokens:`, token);
-            continue;
-          }
-          if (isArray(value)) {
-            for (let j = 0; j < value.length; ++j) {
-              const itemContext = context.push(value[j]);
-              if (context.renderCache) {
-                itemContext.renderCache = context.renderCache;
-              }
-              const itemResult = this.renderTokens(childTokens, itemContext, partials, originalTemplate, config, renderCache);
-              buffer += itemResult;
-            }
-          } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
-            const pushedContext = context.push(value);
-            if (context.renderCache) {
-              pushedContext.renderCache = context.renderCache;
-            }
-            buffer += this.renderTokens(childTokens, pushedContext, partials, originalTemplate, config, renderCache);
-          } else if (isFunction(value)) {
-            const text = originalTemplate == null ? null : originalTemplate.slice(token[3], token[5]);
-            value = value.call(context.view, text, (template) => this.render(template, context.view, partials, config));
-            if (value != null) buffer += value;
-          } else if (value) {
-            buffer += this.renderTokens(childTokens, context, partials, originalTemplate, config, renderCache);
-          }
-          break;
-        case "^":
-          value = context.lookup(token[1]);
-          if (!value || isArray(value) && value.length === 0) {
-            const childTokens2 = token[4];
-            if (childTokens2 && isArray(childTokens2)) {
-              buffer += this.renderTokens(childTokens2, context, partials, originalTemplate, config, renderCache);
-            }
-          }
-          break;
-        case ">":
-          if (!partials) continue;
-          value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
-          if (value != null) {
-            buffer += this.render(value, context.view, partials, config);
-          }
-          break;
-        case "&":
-          value = context.lookup(token[1]);
-          if (value != null) buffer += value;
-          break;
-        case "name":
-          value = context.lookup(token[1]);
-          if (value != null) buffer += escapeHtml(value);
-          break;
-        case "text":
-          buffer += token[1];
-          break;
-      }
-    }
-    return buffer;
-  }
-  getConfigTags(config) {
-    if (isObject(config) && isArray(config.tags)) {
-      return config.tags;
-    }
-    return null;
-  }
-}
-function escapeRegExp(string) {
-  return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
-}
-const defaultWriter = new Writer();
-const Mustache = {
-  name: "MOJO Mustache",
-  version: "1.0.0",
-  tags: ["{{", "}}"],
-  Scanner,
-  Context,
-  Writer,
-  escape: escapeHtml,
-  clearCache() {
-    return defaultWriter.clearCache();
-  },
-  parse(template, tags) {
-    return defaultWriter.parse(template, tags);
-  },
-  render(template, view, partials, config) {
-    if (typeof template !== "string") {
-      throw new TypeError('Invalid template! Template should be a "string"');
-    }
-    if (view && typeof view === "object" && !view.getContextValue && typeof view.toJSON !== "function") {
-      view = MOJOUtils.wrapData(view);
-    }
-    return defaultWriter.render(template, view, partials, config);
-  }
-};
-class EventDelegate {
-  constructor(view) {
-    this.view = view;
-    this.domListeners = [];
-    this.debounceTimers = /* @__PURE__ */ new Map();
-  }
-  bind(rootEl) {
-    this.unbind();
-    if (!rootEl) return;
-    const onClick = async (event) => {
-      const actionEl = event.target.closest("[data-action]");
-      if (actionEl && this.shouldHandle(actionEl, event)) {
-        const action = actionEl.getAttribute("data-action");
-        this.hideTooltip(actionEl);
-        const handled = await this.dispatch(action, event, actionEl);
-        if (handled) {
-          event.preventDefault();
-          event.stopPropagation();
-          event.handledByChild = true;
-          return;
-        }
-      }
-      const navEl = event.target.closest("a[href], [data-page]");
-      if (navEl && !navEl.hasAttribute("data-action") && this.shouldHandle(navEl, event)) {
-        if (event.ctrlKey || event.metaKey || event.shiftKey || event.button === 1) return;
-        if (navEl.tagName === "A") {
-          const href = navEl.getAttribute("href");
-          if (href && href !== "#" && !href.startsWith("#") && (this.view.isExternalLink(href) || navEl.hasAttribute("data-external"))) return;
-        }
-        this.hideTooltip(navEl);
-        event.preventDefault();
-        event.stopPropagation();
-        event.handledByChild = true;
-        if (navEl.hasAttribute("data-page")) await this.view.handlePageNavigation(navEl);
-        else await this.view.handleHrefNavigation(navEl);
-      }
-    };
-    const onChange = (event) => {
-      const el = event.target.closest("[data-change-action]");
-      if (!el || !this.shouldHandle(el, event)) return;
-      const action = el.getAttribute("data-change-action");
-      this.dispatchChange(action, event, el).then((handled) => {
-        if (handled) {
-          event.stopPropagation();
-          event.handledByChild = true;
-        }
-      });
-    };
-    const onInput = (event) => {
-      const el = event.target.closest("[data-change-action]");
-      if (!el || !this.shouldHandle(el, event)) return;
-      const liveSearch = event.target.matches('[data-filter="live-search"]');
-      if (!liveSearch) return;
-      const action = el.getAttribute("data-change-action");
-      const debounceMs = parseInt(el.getAttribute("data-filter-debounce")) || 300;
-      const timerId = `${action}-${el.getAttribute("data-container") || "default"}`;
-      if (this.debounceTimers.has(timerId)) {
-        clearTimeout(this.debounceTimers.get(timerId));
-      }
-      const timer = setTimeout(() => {
-        this.debounceTimers.delete(timerId);
-        this.dispatchChange(action, event, el).then((handled) => {
-          if (handled) {
-            event.stopPropagation();
-            event.handledByChild = true;
-          }
-        });
-      }, debounceMs);
-      this.debounceTimers.set(timerId, timer);
-    };
-    const onKeyDown = (event) => {
-      if (event.target.matches('[data-filter="search"]')) return;
-      const el = event.target.closest("[data-keydown-action]") || event.target.closest("[data-change-action]");
-      if (!el || !this.shouldHandle(el, event)) return;
-      let changeKeys = ["Enter"];
-      if (el.getAttribute("data-change-keys")) {
-        changeKeys = el.getAttribute("data-change-keys").split(",").map((key) => key.trim());
-      }
-      if (changeKeys.includes("*") || changeKeys.includes(event.key)) {
-        const action = el.getAttribute("data-keydown-action") || el.getAttribute("data-change-action");
-        this.dispatch(action, event, el).then((handled) => {
-          if (handled) {
-            event.preventDefault();
-            event.stopPropagation();
-            event.handledByChild = true;
-          }
-        });
-      }
-    };
-    const onSubmit = (event) => {
-      const form = event.target.closest("form[data-action]");
-      if (!form || !this.shouldHandle(form, event)) return;
-      event.preventDefault();
-      const action = form.getAttribute("data-action");
-      this.dispatch(action, event, form);
-    };
-    rootEl.addEventListener("click", onClick);
-    rootEl.addEventListener("change", onChange);
-    rootEl.addEventListener("input", onInput);
-    rootEl.addEventListener("keydown", onKeyDown);
-    rootEl.addEventListener("submit", onSubmit);
-    this.domListeners.push(
-      { el: rootEl, type: "click", fn: onClick },
-      { el: rootEl, type: "change", fn: onChange },
-      { el: rootEl, type: "input", fn: onInput },
-      { el: rootEl, type: "keydown", fn: onKeyDown },
-      { el: rootEl, type: "submit", fn: onSubmit }
-    );
-  }
-  unbind() {
-    for (const { el, type, fn } of this.domListeners) el.removeEventListener(type, fn);
-    this.domListeners = [];
-    for (const timer of this.debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.debounceTimers.clear();
-  }
-  hideDropdown(element) {
-    const dropdownMenu = element.closest(".dropdown-menu");
-    const dropdown = dropdownMenu.closest(".dropdown");
-    if (!dropdown) {
-      return;
-    }
-    const dropdownBtn = dropdown.querySelector('[data-bs-toggle="dropdown"]');
-    if (dropdownBtn && window.bootstrap?.Dropdown) {
-      const dropdownInstance = window.bootstrap.Dropdown.getInstance(dropdownBtn);
-      dropdownInstance?.hide();
-    }
-  }
-  hideTooltip(element) {
-    if (element && window.bootstrap?.Tooltip) {
-      const tooltip = window.bootstrap.Tooltip.getInstance(element);
-      if (tooltip) {
-        tooltip.dispose();
-      }
-    }
-  }
-  hideAllTooltips() {
-    if (window.bootstrap?.Tooltip) {
-      const tooltips = document.querySelectorAll('[data-bs-toggle="tooltip"]');
-      tooltips.forEach((el) => {
-        const tooltip = window.bootstrap.Tooltip.getInstance(el);
-        if (tooltip) {
-          tooltip.hide();
-        }
-      });
-    }
-  }
-  async dispatch(action, event, el) {
-    const v = this.view;
-    const cap = (s) => s.includes("-") ? s.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join("") : s[0].toUpperCase() + s.slice(1);
-    const specific = `handleAction${cap(action)}`;
-    if (typeof v[specific] === "function") {
-      try {
-        event.preventDefault();
-        await v[specific](event, el);
-        return true;
-      } catch (e) {
-        console.error(`Error in action ${action}:`, e);
-        v.handleActionError(action, e, event, el);
-        return true;
-      }
-    }
-    const generic = `onAction${cap(action)}`;
-    if (typeof v[generic] === "function") {
-      try {
-        if (await v[generic](event, el)) {
-          const isInDropdown = !!el.closest(".dropdown-menu");
-          if (isInDropdown) this.hideDropdown(el);
-          event.preventDefault();
-          event.stopPropagation();
-          return true;
-        }
-        return false;
-      } catch (e) {
-        console.error(`Error in action ${action}:`, e);
-        v.handleActionError(action, e, event, el);
-        return true;
-      }
-    }
-    const passThru = `onPassThruAction${cap(action)}`;
-    if (typeof v[passThru] === "function") {
-      try {
-        await v[passThru](event, el);
-        return false;
-      } catch (e) {
-        console.error(`Error in action ${action}:`, e);
-        v.handleActionError(action, e, event, el);
-        return true;
-      }
-    }
-    if (typeof v.onActionDefault === "function") {
-      try {
-        return await v.onActionDefault(action, event, el);
-      } catch (e) {
-        console.error(`Error in default action handler for ${action}:`, e);
-        v.handleActionError(action, e, event, el);
-        return true;
-      }
-    }
-    v.emit?.(`action:${action}`, { action, event, element: el });
-    return false;
-  }
-  async dispatchChange(action, event, el) {
-    const v = this.view;
-    const cap = (s) => s.includes("-") ? s.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join("") : s[0].toUpperCase() + s.slice(1);
-    const changeHandler = `onChange${cap(action)}`;
-    if (typeof v[changeHandler] === "function") {
-      try {
-        await v[changeHandler](event, el);
-        return true;
-      } catch (e) {
-        console.error(`Error in onChange ${action}:`, e);
-        v.handleActionError?.(action, e, event, el);
-        return true;
-      }
-    }
-    return await this.dispatch(action, event, el);
-  }
-  shouldHandle(el, event) {
-    if (this.owns(el)) return true;
-    if (this.contains(el) && !event.handledByChild) return true;
-    return false;
-  }
-  owns(el) {
-    const root = this.view.element;
-    if (!root || !root.contains(el)) return false;
-    for (const child of Object.values(this.view.children)) {
-      if (child.element && child.element.contains(el)) return false;
-    }
-    return true;
-  }
-  contains(el) {
-    return !!this.view.element && this.view.element.contains(el);
-  }
-}
-const EventEmitter = {
-  /**
-   * Add an event listener
-   * @param {string} event - Event name to listen for
-   * @param {Function} callback - Function to call when event is emitted
-   * @param {Object} [context] - Context to bind the callback to (optional)
-   * @returns {Object} This instance for method chaining
-   *
-   * @example
-   * // With context binding
-   * model.on('change', this.handleChange, this);
-   * 
-   * // Without context (traditional)
-   * model.on('change', (data) => console.log(data));
-   */
-  on(event, callback, context) {
-    if (!this._listeners) this._listeners = {};
-    if (!this._listeners[event]) this._listeners[event] = [];
-    const listener = {
-      callback,
-      context,
-      fn: context ? callback.bind(context) : callback
-    };
-    this._listeners[event].push(listener);
-    return this;
-  },
-  /**
-   * Remove an event listener
-   * @param {string} event - Event name
-   * @param {Function} [callback] - Specific callback to remove. If omitted, removes all listeners for the event
-   * @param {Object} [context] - Context that was used when adding the listener
-   * @returns {Object} This instance for method chaining
-   *
-   * @example
-   * // Remove specific listener with context
-   * model.off('change', this.handleChange, this);
-   *
-   * // Remove specific callback (any context)
-   * model.off('change', myHandler);
-   *
-   * // Remove all listeners for an event
-   * model.off('change');
-   */
-  off(event, callback, context) {
-    if (!this._listeners || !this._listeners[event]) return this;
-    if (!callback) {
-      delete this._listeners[event];
-    } else {
-      this._listeners[event] = this._listeners[event].filter((listener) => {
-        if (listener.callback !== callback) return true;
-        if (arguments.length === 3 && listener.context !== context) return true;
-        return false;
-      });
-      if (this._listeners[event].length === 0) {
-        delete this._listeners[event];
-      }
-    }
-    return this;
-  },
-  /**
-   * Add a one-time event listener that automatically removes itself after being called
-   * @param {string} event - Event name to listen for
-   * @param {Function} callback - Function to call when event is emitted (called only once)
-   * @param {Object} [context] - Context to bind the callback to (optional)
-   * @returns {Object} This instance for method chaining
-   *
-   * @example
-   * model.once('ready', this.handleReady, this);
-   */
-  once(event, callback, context) {
-    const onceWrapper = (...args) => {
-      this.off(event, onceWrapper);
-      const fn = context ? callback.bind(context) : callback;
-      fn.apply(context || this, args);
-    };
-    this.on(event, onceWrapper);
-    return this;
-  },
-  /**
-   * Emit an event to all registered listeners
-   * @param {string} event - Event name to emit
-   * @param {...*} args - Arguments to pass to event listeners
-   * @returns {Object} This instance for method chaining
-   *
-   * @example
-   * // Emit with single argument
-   * model.emit('change', { field: 'name', value: 'John' });
-   *
-   * // Emit with multiple arguments
-   * model.emit('update', oldValue, newValue, timestamp);
-   *
-   * // Emit without arguments
-   * model.emit('ready');
-   */
-  emit(event, ...args) {
-    if (!this._listeners || !this._listeners[event]) return this;
-    const listeners = this._listeners[event].slice();
-    for (const listener of listeners) {
-      try {
-        listener.fn.apply(listener.context || this, args);
-      } catch (error) {
-        if (console && console.error) {
-          console.error(`Error in ${event} event handler:`, error);
-        }
-      }
-    }
-    return this;
-  }
-};
-if (typeof window !== "undefined") {
-  window.Mustache = Mustache;
-}
-class View {
-  // ---------------------------------------------
-  // Construction & defaults
-  // ---------------------------------------------
-  constructor(opts = {}) {
-    this.tagName = opts.tagName ?? "div";
-    this.className = opts.className ?? "mojo-view";
-    this.style = opts.style ?? null;
-    this.id = opts.id ?? View._genId();
-    this.containerId = opts.containerId ?? null;
-    this.container = opts.container ?? null;
-    if (typeof this.container === "string") {
-      this.containerId = this.container;
-      this.container = null;
-    }
-    this.parent = opts.parent ?? null;
-    this.children = opts.children ?? {};
-    this.template = opts.template || opts.templateUrl || "";
-    this.data = opts.data ?? {};
-    this.isRendering = false;
-    this.lastRenderTime = 0;
-    this.mounted = false;
-    this.debug = opts.debug ?? false;
-    this.app = opts.app ?? null;
-    this.cacheTemplate = opts.cacheTemplate ?? true;
-    this.enableTooltips = opts.enableTooltips ?? false;
-    this.options = { ...opts };
-    this.element = this._ensureElement();
-    this.events = new EventDelegate(this);
-    if (opts.model) this.setModel(opts.model);
-  }
-  // ---------------------------------------------
-  // Lifecycle hooks (overridable)
-  // ---------------------------------------------
-  async onInit() {
-  }
-  async onInitView() {
-    if (this.initialized) return;
-    this.initialized = true;
-    await this.onInit();
-  }
-  async onBeforeRender() {
-  }
-  async onAfterRender() {
-  }
-  async onBeforeMount() {
-  }
-  async onAfterMount() {
-  }
-  async onBeforeUnmount() {
-  }
-  async onAfterUnmount() {
-  }
-  async onBeforeDestroy() {
-  }
-  async onAfterDestroy() {
-  }
-  // ---------------------------------------------
-  // Public API
-  // ---------------------------------------------
-  setModel(model = {}) {
-    let isDiff = model !== this.model;
-    if (!isDiff) return this;
-    if (this.model && this.model.off) {
-      this.model.off("change", this._onModelChange, this);
-    }
-    this.model = model;
-    if (this.model && this.model.on) {
-      this.model.on("change", this._onModelChange, this);
-    }
-    for (const id in this.children) {
-      const child = this.children[id];
-      if (child && typeof child.setModel === "function") {
-        child.setModel(model);
-      }
-    }
-    if (isDiff) {
-      this._onModelChange();
-    }
-    return this;
-  }
-  _onModelChange() {
-    if (this.isMounted()) {
-      this.render();
-    }
-  }
-  setTemplate(tpl) {
-    this.template = tpl ?? "";
-    return this;
-  }
-  addChild(childView, options) {
-    try {
-      if (!childView || typeof childView !== "object") return this;
-      if (options) {
-        if (options.containerId || options.container) {
-          childView.containerId = options.containerId || options.container;
-        }
-        if (options.id) {
-          childView.id = options.id;
-        }
-      }
-      childView.parent = this;
-      if (this.getApp()) childView.app = this.app;
-      this.children[childView.id] = childView;
-    } catch (e) {
-      View._warn("addChild error", e);
-    }
-    return childView;
-  }
-  removeChild(idOrView) {
-    try {
-      const id = typeof idOrView === "string" ? idOrView : idOrView && idOrView.id;
-      if (!id) return this;
-      const child = this.children[id];
-      if (child) {
-        Promise.resolve(child.destroy()).catch((err) => View._warn("removeChild destroy error", err));
-        delete this.children[id];
-      }
-    } catch (e) {
-      View._warn("removeChild error", e);
-    }
-    return this;
-  }
-  getChild(id) {
-    return this.children[id];
-  }
-  async updateData(newData, rerender = false) {
-    Object.assign(this.data, newData);
-    if (rerender && this.isMounted()) {
-      await this.render();
-    }
-    return this;
-  }
-  toggleClass(className, force) {
-    if (force === void 0) {
-      force = !this.element.classList.contains(className);
-    }
-    this.element.classList.toggle(className, force);
-    return this;
-  }
-  addClass(className) {
-    this.element.classList.add(className);
-    return this;
-  }
-  setClass(className) {
-    this.element.className = className;
-    return this;
-  }
-  removeClass(className) {
-    this.element.classList.remove(className);
-    return this;
-  }
-  canRender() {
-    if (this.isRendering) return false;
-    const now = Date.now();
-    if (this.options.renderCooldown > 0 && now - this.lastRenderTime < this.options.renderCooldown) {
-      View._warn(`View ${this.id}: Render called too quickly, cooldown active`);
-      return false;
-    }
-    if (this.options.noAppend) {
-      if (this.parent) {
-        if (!this.parent.contains(this.containerId || this.container)) {
-          return false;
-        } else if (this.containerId && !document.getElementById(this.containerId)) {
-          return false;
-        } else if (this.container && !document.contains(this.container)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  // ---------------------------------------------
-  // Render flow
-  // ---------------------------------------------
-  async render(allowMount = true, container = null) {
-    const now = Date.now();
-    if (!this.canRender()) {
-      return this;
-    }
-    this.isRendering = true;
-    this.lastRenderTime = now;
-    try {
-      if (!this.initialized) await this.onInitView();
-      this.unbindEvents();
-      await this.onBeforeRender();
-      if (this.getViewData) {
-        this.data = await this.getViewData();
-      }
-      const html = await this.renderTemplate();
-      this.element.innerHTML = html;
-      if (allowMount && !this.isMounted()) {
-        await this.mount(container);
-      }
-      await this._renderChildren();
-      await this.onAfterRender();
-      this.bindEvents();
-    } catch (e) {
-      View._warn(`Render error in ${this.id}`, e);
-    } finally {
-      this.isRendering = false;
-    }
-    return this;
-  }
-  async _renderChildren() {
-    for (const id in this.children) {
-      const child = this.children[id];
-      if (!child) continue;
-      child.parent = this;
-      await Promise.resolve(child.render()).catch((err) => View._warn(`Child render error (${id})`, err));
-    }
-  }
-  async _unmountChildren() {
-    for (const id in this.children) {
-      const child = this.children[id];
-      if (!child) continue;
-      child.unbindEvents();
-    }
-  }
-  isMounted() {
-    return this.element?.isConnected;
-  }
-  getChildElementById(id, root = null) {
-    const cleanId = id.startsWith("#") ? id.substring(1) : id;
-    if (root) {
-      return root.querySelector(`#${cleanId}`);
-    }
-    return this.element.querySelector(`#${cleanId}`);
-  }
-  getChildElement(id) {
-    if (id.startsWith("#")) {
-      return this.getChildElementById(id);
-    }
-    let el = this.element?.querySelector(`[data-container="${id}"]`);
-    if (!el) {
-      return this.getChildElementById(id);
-    }
-    return el;
-  }
-  getContainer() {
-    if (this.replaceById) {
-      if (this.parent) {
-        return this.parent.getChildElementById(this.id);
-      }
-      return null;
-    }
-    if (!this.containerId) return null;
-    if (this.parent) {
-      return this.parent.getChildElement(this.containerId);
-    }
-    return this.getChildElementById(this.containerId, document.body);
-  }
-  async mount(container = null) {
-    await this.onBeforeMount();
-    if (!container) {
-      container = this.getContainer();
-    }
-    if (this.containerId && !container) {
-      console.error(`Container not found for ${this.containerId}`);
-      return;
-    }
-    if (container && this.replaceById) {
-      container.replaceWith(this.element);
-    } else if (container) {
-      container.replaceChildren(this.element);
-    } else if (!this.containerId && this.parent) {
-      this.parent.element.appendChild(this.element);
-    } else if (!this.containerId && !this.parent && this.options.allowAppendToBody) {
-      console.log("APPENDING TO BODY!!!!");
-      document.body.appendChild(this.element);
-    } else {
-      console.error(`Container not found for ${this.containerId}`);
-    }
-    await this.onAfterMount();
-    this.mounted = true;
-  }
-  async unmount() {
-    if (!this.element || !this.element.parentNode) return;
-    await this.onBeforeUnmount();
-    await this._unmountChildren();
-    if (this.element.parentNode) this.element.parentNode.removeChild(this.element);
-    this.events.unbind();
-    await this.onAfterUnmount();
-    this.mounted = false;
-  }
-  // FIX #1: make destroy async (it already awaited hooks)
-  async destroy() {
-    try {
-      this.events.unbind();
-      for (const id in this.children) {
-        const ch = this.children[id];
-        if (ch) {
-          await Promise.resolve(ch.destroy()).catch((err) => View._warn(`Child destroy error (${id})`, err));
-        }
-      }
-      this.mounted = false;
-      if (this.element && this.element.parentNode) {
-        await this.onBeforeDestroy();
-        if (this.element.parentNode) this.element.parentNode.removeChild(this.element);
-        await this.onAfterDestroy();
-      }
-    } catch (e) {
-      View._warn(`Destroy error in ${this.id}`, e);
-    }
-  }
-  // ---------------------------------------------
-  // DOM helpers
-  // ---------------------------------------------
-  _ensureElement() {
-    try {
-      if (this.element && this.element.tagName?.toLowerCase() === this.tagName) {
-        this._syncAttrs();
-        return this.element;
-      }
-      const el = document.createElement(this.tagName);
-      this.element = el;
-      this.el = el;
-      this._syncAttrs();
-      return el;
-    } catch (e) {
-      View._warn("ensureElement error", e);
-      const el = document.createElement("div");
-      el.id = this.id || View._genId();
-      return el;
-    }
-  }
-  _syncAttrs() {
-    try {
-      if (!this.element) return;
-      if (this.id) this.element.id = this.id;
-      this.element.className = this.className || "";
-      if (this.style == null) {
-        this.element.removeAttribute("style");
-      } else {
-        this.element.style.cssText = String(this.style);
-      }
-    } catch (e) {
-      View._warn("_syncAttrs error", e);
-    }
-  }
-  bindEvents() {
-    this.events.bind(this.element);
-    if (this.enableTooltips) {
-      this.initializeTooltips();
-    }
-  }
-  unbindEvents() {
-    this.events.unbind();
-    if (this.enableTooltips) {
-      this.disposeTooltips();
-    }
-  }
-  // ---------------------------------------------
-  // Template helpers
-  // ---------------------------------------------
-  async renderTemplate() {
-    const templateContent = await this.getTemplate();
-    if (!templateContent) return "";
-    const partials = this.getPartials();
-    return Mustache.render(templateContent, this, partials);
-  }
-  renderTemplateString(template, context, partials) {
-    return Mustache.render(template, context, partials);
-  }
-  getPartials() {
-    return {};
-  }
-  async getTemplate() {
-    if (this._templateCache && this.cacheTemplate) {
-      return this._templateCache;
-    }
-    const template = this.template || this.templateUrl;
-    if (!template) {
-      throw new Error("Template not found");
-    }
-    let templateContent = "";
-    if (typeof template === "string") {
-      if (template.includes("<") || template.includes("{")) {
-        templateContent = template;
-      } else {
-        try {
-          let templatePath = template;
-          if (!this.app) this.app = this.getApp();
-          if (this.app && this.app.basePath) {
-            if (!templatePath.startsWith("/") && !templatePath.startsWith("http://") && !templatePath.startsWith("https://")) {
-              const base = this.app.basePath.endsWith("/") ? this.app.basePath.slice(0, -1) : this.app.basePath;
-              templatePath = `${base}/${templatePath}`;
-            }
-          }
-          const response = await fetch(templatePath);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-          }
-          templateContent = await response.text();
-        } catch (error) {
-          View._warn(`Failed to load template from ${template}: ${error}`);
-          this.showError?.(`Failed to load template from ${template}: ${error.message}`);
-        }
-      }
-    } else if (typeof template === "function") {
-      templateContent = await this.template(this.data, this.state);
-    }
-    if (this.cacheTemplate && templateContent) {
-      this._templateCache = templateContent;
-    }
-    return templateContent;
-  }
-  getContextValue(path) {
-    const value = MOJOUtils.getContextData(this, path);
-    if (path && path.startsWith("data.") && value && typeof value === "object") {
-      return MOJOUtils.wrapData(value, this);
-    }
-    if (path && path.startsWith("model.") && path !== "model" && value && typeof value === "object" && typeof value.getContextValue !== "function") {
-      return MOJOUtils.wrapData(value, null);
-    }
-    return value;
-  }
-  // 9) Navigation Helpers ------------------------------------------------------
-  async handlePageNavigation(element) {
-    const pageName = element.getAttribute("data-page");
-    const paramsAttr = element.getAttribute("data-params");
-    let params = {};
-    if (paramsAttr) {
-      try {
-        params = JSON.parse(paramsAttr);
-      } catch (error) {
-        console.warn("Invalid JSON in data-params:", paramsAttr);
-      }
-    }
-    const app = this.getApp();
-    if (app) {
-      app.showPage(pageName, params);
-      return;
-    }
-    const router = this.findRouter();
-    if (router && typeof router.navigateToPage === "function") {
-      await router.navigateToPage(pageName, params);
-    } else {
-      console.error(`No router found for page navigation to '${pageName}'`);
-    }
-  }
-  async handleHrefNavigation(element) {
-    const href = element.getAttribute("href");
-    if (this.isExternalLink(href) || element.hasAttribute("data-external")) return;
-    const router = this.findRouter();
-    if (router) {
-      if (router.options && router.options.mode === "param" && href.startsWith("?")) {
-        const fullPath = "/" + href;
-        await router.navigate(fullPath);
-        return;
-      }
-      if (router.options && router.options.mode === "hash" && href.startsWith("#")) {
-        await router.navigate(href);
-        return;
-      }
-      const routePath = this.hrefToRoutePath(href);
-      await router.navigate(routePath);
-    } else {
-      console.warn("No router found for navigation, using default behavior");
-      window.location.href = href;
-    }
-  }
-  isExternalLink(href) {
-    if (!href) return true;
-    if (href.startsWith("/") && this.getApp()) {
-      if (href.startsWith(this.findRouter().basePath)) return false;
-      return true;
-    }
-    return href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:") || href.startsWith("http://") || href.startsWith("https://") || href.startsWith("//");
-  }
-  hrefToRoutePath(href) {
-    if (href.startsWith("/")) {
-      const router = this.findRouter();
-      if (router && router.options && router.options.base) {
-        const base = router.options.base;
-        if (href.startsWith(base)) return href.substring(base.length) || "/";
-      }
-      return href;
-    }
-    return href.startsWith("./") ? href.substring(2) : href;
-  }
-  findRouter() {
-    this.getApp();
-    return this.app?.router || null;
-  }
-  getApp() {
-    if (this.app) return this.app;
-    const apps = [
-      window.__app__,
-      window.MOJO?.app,
-      window.APP,
-      window.app,
-      window.WebApp,
-      window.matchUUID ? window[window.matchUUID]() : window[window.matchUUID]
-    ];
-    this.app = apps.find((app) => app && typeof app.showPage === "function") || null;
-    return this.app;
-  }
-  handleActionError(action, err, evt, el) {
-    this.showError(`Action '${action}' failed: ${err}`, evt, el);
-  }
-  // ---------------------------------------------
-  // Utilities
-  // ---------------------------------------------
-  /**
-   * Escape HTML characters
-   * @param {string} str - String to escape
-   * @returns {string} Escaped string
-   */
-  escapeHtml(str) {
-    if (typeof str !== "string") return str;
-    const div = document.createElement("div");
-    div.textContent = str;
-    return div.innerHTML;
-  }
-  contains(el) {
-    if (typeof el === "string") {
-      if (!this.element) return false;
-      el = document.getElementById(el);
-    }
-    if (!el) return false;
-    return this.element.contains(el);
-  }
-  /**
-   * Initialize Bootstrap tooltips in this view's element
-   * Called automatically in bindEvents() if enableTooltips is true
-   */
-  initializeTooltips() {
-    if (!this.element || !window.bootstrap?.Tooltip) return;
-    this.disposeTooltips();
-    const tooltipTriggerList = this.element.querySelectorAll('[data-bs-toggle="tooltip"]');
-    [...tooltipTriggerList].map((tooltipTriggerEl) => {
-      const theme = tooltipTriggerEl.getAttribute("data-tooltip-theme");
-      const size = tooltipTriggerEl.getAttribute("data-tooltip-size");
-      let customClass = "";
-      if (theme) customClass += `tooltip-${theme} `;
-      if (size) customClass += `tooltip-${size}`;
-      const options = {};
-      const trimmedClass = customClass.trim();
-      if (trimmedClass) {
-        options.customClass = trimmedClass;
-      }
-      return new window.bootstrap.Tooltip(tooltipTriggerEl, options);
-    });
-  }
-  /**
-   * Dispose all Bootstrap tooltips in this view's element
-   * Called automatically in unbindEvents() if enableTooltips is true
-   */
-  disposeTooltips() {
-    if (!this.element || !window.bootstrap?.Tooltip) return;
-    const tooltipElements = this.element.querySelectorAll('[data-bs-toggle="tooltip"]');
-    tooltipElements.forEach((element) => {
-      const tooltip = window.bootstrap.Tooltip.getInstance(element);
-      if (tooltip) {
-        tooltip.dispose();
-      }
-    });
-  }
-  /**
-   * Show error message
-   * @param {string} message - Error message
-   */
-  async showError(message) {
-    console.error(`View ${this.id} error:`, message);
-    const app = this.getApp ? this.getApp() : this.app || null;
-    if (app && typeof app.showError === "function") {
-      await app.showError(message);
-      return;
-    }
-    alert(`Error: ${message}`);
-  }
-  /**
-   * Show success message
-   * @param {string} message - Success message
-   */
-  async showSuccess(message) {
-    if (this.debug) {
-      console.log(`View ${this.id} success:`, message);
-    }
-    const app = this.getApp ? this.getApp() : this.app || null;
-    if (app && typeof app.showSuccess === "function") {
-      await app.showSuccess(message);
-      return;
-    }
-    alert(`Success: ${message}`);
-  }
-  /**
-   * Show info message
-   * @param {string} message - Info message
-   */
-  async showInfo(message) {
-    console.info(`View ${this.id} info:`, message);
-    const app = this.getApp ? this.getApp() : this.app || null;
-    if (app && typeof app.showInfo === "function") {
-      await app.showInfo(message);
-      return;
-    }
-    alert(`Info: ${message}`);
-  }
-  /**
-   * Show warning message
-   * @param {string} message - Warning message
-   */
-  async showWarning(message) {
-    console.warn(`View ${this.id} warning:`, message);
-    const app = this.getApp ? this.getApp() : this.app || null;
-    if (app && typeof app.showWarning === "function") {
-      await app.showWarning(message);
-      return;
-    }
-    alert(`Warning: ${message}`);
-  }
-  // Default action: copy value from data-clipboard to clipboard
-  async onActionCopyToClipboard(event, element) {
-    try {
-      const carrier = element?.closest("[data-clipboard]") || element;
-      const text = carrier?.getAttribute("data-clipboard") || "";
-      if (!text) return true;
-      if (navigator.clipboard && window.isSecureContext) {
-        await navigator.clipboard.writeText(text);
-      } else {
-        const textarea = document.createElement("textarea");
-        textarea.value = text;
-        document.body.appendChild(textarea);
-        textarea.select();
-        document.execCommand("copy");
-        document.body.removeChild(textarea);
-      }
-      const icon = element.querySelector("i");
-      const originalClass = icon && icon.className;
-      if (icon) {
-        icon.className = "bi bi-check";
-        setTimeout(() => {
-          icon.className = originalClass;
-        }, 1e3);
-      }
-      return true;
-    } catch (err) {
-      console.warn("Copy to clipboard failed:", err);
-      return true;
-    }
-  }
-  static _genId() {
-    return `view_${Math.random().toString(36).substr(2, 9)}`;
-  }
-  static _warn(msg, err) {
-    try {
-      if (err) console.warn(`[View] ${msg}:`, err);
-      else console.warn(`[View] ${msg}`);
-    } catch {
-    }
-  }
-}
-Object.assign(View.prototype, EventEmitter);
-class Rest {
-  constructor() {
-    this.config = {
-      baseURL: "",
-      timeout: 3e4,
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "application/json"
-      },
-      trackDevice: true,
-      // New setting to control DUID tracking
-      duidHeader: "X-Mojo-UID",
-      // Header name for the DUID
-      duidTransport: "header"
-      // How to send the DUID: 'payload' or 'header'
-    };
-    this.interceptors = {
-      request: [],
-      response: []
-    };
-    this.duid = null;
-    if (this.config.trackDevice) {
-      this._initializeDuid();
-    }
-  }
-  /**
-   * Initialize or generate the Device Unique ID (DUID)
-   * @private
-   */
-  _initializeDuid() {
-    const storageKey = "mojo_device_uid";
-    try {
-      let storedDuid = localStorage.getItem(storageKey);
-      if (storedDuid) {
-        this.duid = storedDuid;
-      } else {
-        this.duid = this._generateDuid();
-        localStorage.setItem(storageKey, this.duid);
-      }
-    } catch (e) {
-      console.error("Could not access localStorage to get/set DUID.", e);
-      this.duid = this._generateDuid();
-    }
-  }
-  /**
-   * Generate a new DUID (UUID v4)
-   * @private
-   * @returns {string} A new UUID
-   */
-  _generateDuid() {
-    if (crypto && crypto.randomUUID) {
-      return crypto.randomUUID();
-    }
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-      const r = Math.random() * 16 | 0, v = c === "x" ? r : r & 3 | 8;
-      return v.toString(16);
-    });
-  }
-  /**
-   * Configure the REST client
-   * @param {object} config - Configuration object
-   */
-  configure(config) {
-    if (config.baseUrl) config.baseURL = config.baseUrl;
-    const oldTrackDevice = this.config.trackDevice;
-    this.config = {
-      ...this.config,
-      ...config,
-      headers: {
-        ...this.config.headers,
-        ...config.headers
-      }
-    };
-    if (this.config.trackDevice && !oldTrackDevice) {
-      this._initializeDuid();
-    }
-  }
-  /**
-   * Add request or response interceptor
-   * @param {string} type - 'request' or 'response'
-   * @param {function} interceptor - Interceptor function
-   */
-  addInterceptor(type, interceptor) {
-    if (this.interceptors[type]) {
-      this.interceptors[type].push(interceptor);
-    }
-  }
-  /**
-   * Build complete URL
-   * @param {string} url - Endpoint URL
-   * @returns {string} Complete URL
-   */
-  buildUrl(url) {
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return url;
-    }
-    const baseURL = this.config.baseURL.endsWith("/") ? this.config.baseURL.slice(0, -1) : this.config.baseURL;
-    const endpoint = url.startsWith("/") ? url : `/${url}`;
-    return `${baseURL}${endpoint}`;
-  }
-  /**
-   * Categorize error into common reason codes
-   * @param {Error} error - The error object
-   * @param {number} status - HTTP status code (if available)
-   * @returns {object} Object with reason code and user-friendly message
-   */
-  categorizeError(error, status = 0) {
-    if (error.name === "TypeError" && error.message.includes("fetch")) {
-      return {
-        reason: "not_reachable",
-        message: "Service is not reachable - please check your connection"
-      };
-    }
-    if (error.name === "AbortError") {
-      return {
-        reason: "cancelled",
-        message: "Request was cancelled"
-      };
-    }
-    if (error.name === "TimeoutError" || error.message.includes("timeout")) {
-      return {
-        reason: "timed_out",
-        message: "Request timed out - please try again"
-      };
-    }
-    if (status >= 400) {
-      if (status === 400) {
-        return {
-          reason: "bad_request",
-          message: "Invalid request data"
-        };
-      }
-      if (status === 401) {
-        return {
-          reason: "unauthorized",
-          message: "Authentication required"
-        };
-      }
-      if (status === 403) {
-        return {
-          reason: "forbidden",
-          message: "Access denied"
-        };
-      }
-      if (status === 404) {
-        return {
-          reason: "not_found",
-          message: "Resource not found"
-        };
-      }
-      if (status === 409) {
-        return {
-          reason: "conflict",
-          message: "Resource conflict"
-        };
-      }
-      if (status === 422) {
-        return {
-          reason: "validation_error",
-          message: "Validation failed"
-        };
-      }
-      if (status === 429) {
-        return {
-          reason: "rate_limited",
-          message: "Too many requests - please wait"
-        };
-      }
-      if (status >= 500) {
-        return {
-          reason: "server_error",
-          message: "Server error - please try again later"
-        };
-      }
-      if (status >= 400) {
-        return {
-          reason: "client_error",
-          message: "Request error"
-        };
-      }
-    }
-    if (error.message.includes("CORS")) {
-      return {
-        reason: "cors_error",
-        message: "Cross-origin request blocked"
-      };
-    }
-    if (error.message.includes("DNS") || error.message.includes("ENOTFOUND")) {
-      return {
-        reason: "dns_error",
-        message: "Unable to resolve server address"
-      };
-    }
-    return {
-      reason: "unknown_error",
-      message: `Network error: ${error.message}`
-    };
-  }
-  /**
-   * Build query string from parameters
-   * @param {object} params - Query parameters
-   * @returns {string} Query string
-   */
-  buildQueryString(params = {}) {
-    const searchParams = new URLSearchParams();
-    Object.entries(params).forEach(([key, value]) => {
-      if (value !== null && value !== void 0) {
-        if (Array.isArray(value)) {
-          value.forEach((v) => searchParams.append(`${key}[]`, v));
-        } else {
-          searchParams.append(key, value);
-        }
-      }
-    });
-    const queryString = searchParams.toString();
-    return queryString ? `?${queryString}` : "";
-  }
-  /**
-   * Process request through interceptors
-   * @param {object} request - Request configuration
-   * @returns {object} Processed request configuration
-   */
-  async processRequestInterceptors(request) {
-    let processedRequest = { ...request };
-    for (const interceptor of this.interceptors.request) {
-      try {
-        processedRequest = await interceptor(processedRequest);
-      } catch (error) {
-        console.error("Request interceptor error:", error);
-        throw error;
-      }
-    }
-    return processedRequest;
-  }
-  /**
-   * Process response through interceptors
-   * @param {Response} response - Fetch response object
-   * @param {object} request - Original request configuration
-   * @returns {object} Processed response data
-   */
-  async processResponseInterceptors(response, request) {
-    let responseData = {
-      success: response.ok,
-      status: response.status,
-      statusText: response.statusText,
-      headers: Object.fromEntries(response.headers.entries()),
-      data: null,
-      errors: null,
-      message: null,
-      reason: null
-    };
-    try {
-      const contentType = response.headers.get("content-type");
-      if (contentType && contentType.includes("application/json")) {
-        const jsonData = await response.json();
-        responseData.data = jsonData;
-        if (!response.ok) {
-          const errorInfo = this.categorizeError(new Error("HTTP Error"), response.status);
-          responseData.errors = jsonData.errors || {};
-          responseData.message = jsonData.message || errorInfo.message;
-          responseData.reason = errorInfo.reason;
-        }
-      } else {
-        responseData.data = await response.text();
-        if (!response.ok) {
-          const errorInfo = this.categorizeError(new Error("HTTP Error"), response.status);
-          responseData.message = errorInfo.message;
-          responseData.reason = errorInfo.reason;
-        }
-      }
-    } catch (error) {
-      responseData.errors = { parse: "Failed to parse response" };
-      responseData.message = "Invalid response format";
-    }
-    for (const interceptor of this.interceptors.response) {
-      try {
-        responseData = await interceptor(responseData, request);
-      } catch (error) {
-        console.error("Response interceptor error:", error);
-      }
-    }
-    return responseData;
-  }
-  /**
-   * Make HTTP request
-   * @param {string} method - HTTP method
-   * @param {string} url - Request URL
-   * @param {object} data - Request body data
-   * @param {object} params - Query parameters
-   * @param {object} options - Additional request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async request(method, url, data = null, params = {}, options = {}) {
-    let request = {
-      method: method.toUpperCase(),
-      url: this.buildUrl(url) + this.buildQueryString(params),
-      headers: {
-        ...this.config.headers,
-        ...options.headers
-      },
-      data,
-      options: {
-        timeout: this.config.timeout,
-        ...options
-      }
-    };
-    request = await this.processRequestInterceptors(request);
-    if (this.config.trackDevice && this.duid) {
-      if (this.config.duidTransport === "header") {
-        request.headers[this.config.duidHeader] = this.duid;
-      } else {
-        if (request.method === "GET") {
-          const url2 = new URL(request.url);
-          url2.searchParams.append("duid", this.duid);
-          request.url = url2.toString();
-        } else if (request.data && typeof request.data === "object" && !(request.data instanceof FormData)) {
-          request.data.duid = this.duid;
-        }
-      }
-    }
-    const fetchOptions = {
-      method: request.method,
-      headers: request.headers
-    };
-    const signals = [];
-    if (request.options.timeout) {
-      signals.push(AbortSignal.timeout(request.options.timeout));
-    }
-    if (request.options.signal) {
-      signals.push(request.options.signal);
-    }
-    if (signals.length > 1) {
-      fetchOptions.signal = AbortSignal.any ? AbortSignal.any(signals) : signals[0];
-    } else if (signals.length === 1) {
-      fetchOptions.signal = signals[0];
-    }
-    if (request.data && ["POST", "PUT", "PATCH"].includes(request.method)) {
-      if (request.data instanceof FormData) {
-        fetchOptions.body = request.data;
-        delete fetchOptions.headers["Content-Type"];
-      } else if (typeof request.data === "object") {
-        fetchOptions.body = JSON.stringify(request.data);
-      } else {
-        fetchOptions.body = request.data;
-      }
-    }
-    try {
-      const response = await fetch(request.url, fetchOptions);
-      const responseData = await this.processResponseInterceptors(response, request);
-      return responseData;
-    } catch (error) {
-      if (error.name === "AbortError") {
-        throw error;
-      }
-      const errorInfo = this.categorizeError(error);
-      const errorResponse = {
-        success: false,
-        status: 0,
-        statusText: "Network Error",
-        headers: {},
-        data: null,
-        errors: { network: error.message },
-        message: errorInfo.message,
-        reason: errorInfo.reason
-      };
-      const mockResponse = {
-        ok: false,
-        status: 0,
-        statusText: "Network Error",
-        headers: new Headers(),
-        json: async () => ({}),
-        text: async () => ""
-      };
-      await this.processResponseInterceptors(mockResponse, request);
-      return errorResponse;
-    }
-  }
-  /**
-   * GET request
-   * @param {string} url - Request URL
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async GET(url, params = {}, options = {}) {
-    return this.request("GET", url, null, params, options);
-  }
-  /**
-   * POST request
-   * @param {string} url - Request URL
-   * @param {object} data - Request body data
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async POST(url, data = {}, params = {}, options = {}) {
-    return this.request("POST", url, data, params, options);
-  }
-  /**
-   * PUT request
-   * @param {string} url - Request URL
-   * @param {object} data - Request body data
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async PUT(url, data = {}, params = {}, options = {}) {
-    return this.request("PUT", url, data, params, options);
-  }
-  /**
-   * PATCH request
-   * @param {string} url - Request URL
-   * @param {object} data - Request body data
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async PATCH(url, data = {}, params = {}, options = {}) {
-    return this.request("PATCH", url, data, params, options);
-  }
-  /**
-   * DELETE request
-   * @param {string} url - Request URL
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async DELETE(url, params = {}, options = {}) {
-    return this.request("DELETE", url, null, params, options);
-  }
-  /**
-   * Download a file from a URL
-   * @param {string} url - Request URL
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves when download is initiated
-   */
-  async download(url, params = {}, options = {}) {
-    const requestUrl = this.buildUrl(url) + this.buildQueryString(params);
-    const request = {
-      method: "GET",
-      url: requestUrl,
-      headers: {
-        ...this.config.headers,
-        "Accept": "*/*",
-        // Default, can be overridden by options
-        ...options.headers
-      },
-      options: {
-        ...options
-      }
-    };
-    delete request.headers["Content-Type"];
-    try {
-      const response = await fetch(request.url, {
-        method: request.method,
-        headers: request.headers,
-        signal: request.options.signal
-      });
-      if (!response.ok) {
-        throw new Error(`Download failed: ${response.status} ${response.statusText}`);
-      }
-      const contentDisposition = response.headers.get("content-disposition");
-      let filename = options.filename || "download";
-      if (contentDisposition) {
-        const filenameMatch = contentDisposition.match(/filename="?(.+)"?/);
-        if (filenameMatch && filenameMatch.length > 1) {
-          filename = filenameMatch[1];
-        }
-      }
-      const reader = response.body.getReader();
-      const stream = new ReadableStream({
-        start(controller) {
-          function pump() {
-            return reader.read().then(({ done, value }) => {
-              if (done) {
-                controller.close();
-                return;
-              }
-              controller.enqueue(value);
-              return pump();
-            });
-          }
-          return pump();
-        }
-      });
-      const blob = await new Response(stream).blob();
-      const downloadUrl = window.URL.createObjectURL(blob);
-      const a = document.createElement("a");
-      a.style.display = "none";
-      a.href = downloadUrl;
-      a.download = filename;
-      document.body.appendChild(a);
-      a.click();
-      window.URL.revokeObjectURL(downloadUrl);
-      a.remove();
-      return { success: true, message: "Download initiated" };
-    } catch (error) {
-      console.error("Download error:", error);
-      return { success: false, message: error.message };
-    }
-  }
-  /**
-   * Download a file from a URL by fetching the entire content into a Blob.
-   * @param {string} url - Request URL
-   * @param {object} params - Query parameters
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves when download is initiated
-   */
-  async downloadBlob(url, params = {}, options = {}) {
-    const requestUrl = this.buildUrl(url) + this.buildQueryString(params);
-    const request = {
-      method: "GET",
-      url: requestUrl,
-      headers: {
-        ...this.config.headers,
-        "Accept": "*/*",
-        // Default, can be overridden by options
-        ...options.headers
-      },
-      options: {
-        ...options
-      }
-    };
-    delete request.headers["Content-Type"];
-    try {
-      const response = await fetch(request.url, {
-        method: request.method,
-        headers: request.headers,
-        signal: request.options.signal
-      });
-      if (!response.ok) {
-        throw new Error(`Download failed: ${response.status} ${response.statusText}`);
-      }
-      const blob = await response.blob();
-      const contentDisposition = response.headers.get("content-disposition");
-      let filename = options.filename || "download";
-      if (contentDisposition) {
-        const filenameMatch = contentDisposition.match(/filename="?(.+)"?/);
-        if (filenameMatch && filenameMatch.length > 1) {
-          filename = filenameMatch[1];
-        }
-      }
-      const downloadUrl = window.URL.createObjectURL(blob);
-      const a = document.createElement("a");
-      a.style.display = "none";
-      a.href = downloadUrl;
-      a.download = filename;
-      document.body.appendChild(a);
-      a.click();
-      window.URL.revokeObjectURL(downloadUrl);
-      a.remove();
-      return { success: true, message: "Download initiated" };
-    } catch (error) {
-      console.error("Download error:", error);
-      return { success: false, message: error.message };
-    }
-  }
-  /**
-   * Upload file with raw PUT request (compatible with legacy backend)
-   * @param {string} url - Upload URL
-   * @param {File} file - Single file to upload
-   * @param {object} options - Request options
-   * @param {function} options.onProgress - Progress callback function(event)
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async upload(url, file, options = {}) {
-    return new Promise((resolve, reject) => {
-      if (!(file instanceof File)) {
-        reject(new Error("Only single File objects are supported for legacy backend compatibility"));
-        return;
-      }
-      const xhr = new XMLHttpRequest();
-      if (options.onProgress && typeof options.onProgress === "function") {
-        xhr.upload.onprogress = options.onProgress;
-      }
-      xhr.onload = function() {
-        if (xhr.status >= 200 && xhr.status < 300) {
-          resolve({
-            data: xhr.response,
-            status: xhr.status,
-            statusText: xhr.statusText,
-            xhr
-          });
-        } else {
-          reject(new Error(`Upload failed: ${xhr.status} ${xhr.statusText}`));
-        }
-      };
-      xhr.onerror = function() {
-        reject(new Error("Upload failed: Network error"));
-      };
-      xhr.ontimeout = function() {
-        reject(new Error("Upload failed: Timeout"));
-      };
-      xhr.open("PUT", url);
-      xhr.setRequestHeader("Content-Type", file.type);
-      if (options.timeout) {
-        xhr.timeout = options.timeout;
-      }
-      xhr.send(file);
-    });
-  }
-  /**
-   * Upload multiple files with multipart/form-data (for modern backends)
-   * @param {string} url - Upload URL
-   * @param {File|FileList|FormData} files - File(s) to upload
-   * @param {object} additionalData - Additional form fields
-   * @param {object} options - Request options
-   * @returns {Promise} Promise that resolves with response data
-   */
-  async uploadMultipart(url, files, additionalData = {}, options = {}) {
-    const formData = new FormData();
-    if (files instanceof FileList) {
-      Array.from(files).forEach((file, index) => {
-        formData.append(`file_${index}`, file);
-      });
-    } else if (files instanceof File) {
-      formData.append("file", files);
-    } else if (files instanceof FormData) {
-      return this.POST(url, files, {}, options);
-    }
-    Object.entries(additionalData).forEach(([key, value]) => {
-      formData.append(key, value);
-    });
-    return this.POST(url, formData, {}, options);
-  }
-  /**
-   * Set authentication token
-   * @param {string} token - JWT or API token
-   * @param {string} type - Token type ('Bearer', 'Token', etc.)
-   */
-  setAuthToken(token, type = "Bearer") {
-    if (token) {
-      this.config.headers["Authorization"] = `${type} ${token}`;
-    } else {
-      delete this.config.headers["Authorization"];
-    }
-  }
-  /**
-   * Clear authentication
-   */
-  clearAuth() {
-    delete this.config.headers["Authorization"];
-  }
-  /**
-   * Check if an error is retryable (network issues that might resolve)
-   * @param {object} response - Response object with reason field
-   * @returns {boolean} True if error can be retried
-   */
-  isRetryableError(response) {
-    const retryableReasons = [
-      "not_reachable",
-      "timed_out",
-      "server_error",
-      "dns_error"
-    ];
-    return retryableReasons.includes(response.reason);
-  }
-  /**
-   * Check if error requires authentication
-   * @param {object} response - Response object with reason field
-   * @returns {boolean} True if authentication is required
-   */
-  requiresAuth(response) {
-    return response.reason === "unauthorized";
-  }
-  /**
-   * Check if error is network-related
-   * @param {object} response - Response object with reason field
-   * @returns {boolean} True if it's a network error
-   */
-  isNetworkError(response) {
-    const networkReasons = [
-      "not_reachable",
-      "timed_out",
-      "cancelled",
-      "cors_error",
-      "dns_error"
-    ];
-    return networkReasons.includes(response.reason);
-  }
-  /**
-   * Get user-friendly error message based on reason
-   * @param {object} response - Response object with reason field
-   * @returns {string} User-friendly error message
-   */
-  getUserMessage(response) {
-    if (response.message) {
-      return response.message;
-    }
-    const messages = {
-      "not_reachable": "Unable to connect to the server. Please check your internet connection.",
-      "timed_out": "The request took too long. Please try again.",
-      "cancelled": "The request was cancelled.",
-      "unauthorized": "Please log in to continue.",
-      "forbidden": "You don't have permission to perform this action.",
-      "not_found": "The requested resource was not found.",
-      "validation_error": "Please check your input and try again.",
-      "rate_limited": "Too many requests. Please wait a moment before trying again.",
-      "server_error": "Server error. Please try again later.",
-      "cors_error": "Access blocked by security policy.",
-      "dns_error": "Unable to reach the server.",
-      "unknown_error": "An unexpected error occurred."
-    };
-    return messages[response.reason] || "An error occurred. Please try again.";
-  }
-}
-const rest = new Rest();
-export {
-  DataWrapper as D,
-  EventDelegate as E,
-  Mustache as M,
-  View as V,
-  MOJOUtils as a,
-  EventEmitter as b,
-  dataFormatter as d,
-  rest as r
-};
-//# sourceMappingURL=Rest-W-sPfGh9.js.map