@kupola/kupola 1.7.9 → 1.9.0

package/dist/core-LA_QgrQO.js

@@ -0,0 +1,4955 @@
+class KupolaLifecycle {
+  constructor(scope = "app") {
+    this.scope = scope;
+    this.hooks = /* @__PURE__ */ new Map();
+    this.state = "created";
+    this.stateHistory = ["created"];
+    this.transitions = /* @__PURE__ */ new Map([
+      ["created", ["bootstrapped", "destroyed"]],
+      ["bootstrapped", ["mounted", "destroyed"]],
+      ["mounted", ["updated", "unmounted", "destroyed"]],
+      ["updated", ["updated", "unmounted", "destroyed"]],
+      ["unmounted", ["mounted", "destroyed"]],
+      ["destroyed", []]
+    ]);
+    this.phaseStateMap = {
+      "bootstrap": { from: "created", to: "bootstrapped" },
+      "mount": { from: ["bootstrapped", "unmounted"], to: "mounted" },
+      "update": { from: ["mounted", "updated"], to: "updated" },
+      "unmount": { from: ["mounted", "updated"], to: "unmounted" },
+      "destroy": { from: ["bootstrapped", "mounted", "updated", "unmounted"], to: "destroyed" }
+    };
+    this.basePhases = ["bootstrap", "mount", "update", "unmount", "destroy"];
+    this.allPhases = ["error", "errorBoundary"];
+    this.basePhases.forEach((phase) => {
+      this.allPhases.push(`before${phase.charAt(0).toUpperCase() + phase.slice(1)}`);
+      this.allPhases.push(phase);
+      this.allPhases.push(`after${phase.charAt(0).toUpperCase() + phase.slice(1)}`);
+    });
+    this.allPhases.forEach((phase) => {
+      this.hooks.set(phase, []);
+    });
+    this.pendingHooks = /* @__PURE__ */ new Set();
+    this.trace = [];
+    this.errorHandler = null;
+    this.errorBoundary = null;
+    this.lastError = null;
+    this.errorCount = 0;
+    this.maxErrors = 10;
+    this._onErrorCallback = null;
+  }
+  _validateTransition(nextState) {
+    const allowed = this.transitions.get(this.state);
+    if (!allowed || !allowed.includes(nextState)) {
+      throw new Error(`Invalid state transition: ${this.state} -> ${nextState}`);
+    }
+    return true;
+  }
+  _updateState(nextState) {
+    this._validateTransition(nextState);
+    this.state = nextState;
+    this.stateHistory.push(nextState);
+  }
+  _resetResolved(phase) {
+    const handlers = this.hooks.get(phase);
+    if (handlers) {
+      handlers.forEach((hook) => {
+        hook.resolved = false;
+      });
+    }
+  }
+  on(phase, handler, options = {}) {
+    if (!this.allPhases.includes(phase)) {
+      throw new Error(`Unknown lifecycle phase: ${phase}`);
+    }
+    const hooks = this.hooks.get(phase);
+    hooks.push({
+      handler,
+      priority: options.priority || 0,
+      depends: options.depends || [],
+      name: options.name || handler.name || `anonymous_${hooks.length}`
+    });
+    hooks.sort((a, b) => b.priority - a.priority);
+    return () => {
+      const index = hooks.findIndex((h) => h.handler === handler);
+      if (index > -1) {
+        hooks.splice(index, 1);
+      }
+    };
+  }
+  async _resolveDepends(depends, phase) {
+    if (!depends || depends.length === 0) return;
+    for (const depName of depends) {
+      const phaseHooks = this.hooks.get(phase);
+      const depHook = phaseHooks.find((h) => h.name === depName);
+      if (depHook && !depHook.resolved) {
+        await depHook.handler();
+        depHook.resolved = true;
+      }
+    }
+  }
+  async emit(phase, ...args) {
+    if (this.state === "destroyed" && phase !== "error") return;
+    const handlers = this.hooks.get(phase);
+    if (!handlers || handlers.length === 0) return;
+    const emitId = `${phase}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    this.pendingHooks.add(emitId);
+    const startTime = performance.now();
+    try {
+      for (const hook of handlers) {
+        await this._resolveDepends(hook.depends, phase);
+        const hookStartTime = performance.now();
+        let hookResult, hookError;
+        try {
+          hookResult = hook.handler(...args);
+          if (hookResult instanceof Promise) {
+            await hookResult;
+          }
+          hook.resolved = true;
+        } catch (error) {
+          hookError = error;
+          console.error(`[KupolaLifecycle] Error in ${phase} hook "${hook.name}":`, error);
+          if (phase !== "error") {
+            await this._handleError({ phase, hook: hook.name, error, args });
+          }
+        }
+        const hookDuration = performance.now() - hookStartTime;
+        this.trace.push({
+          emitId,
+          phase,
+          hookName: hook.name,
+          duration: hookDuration,
+          status: hookError ? "error" : "success",
+          error: hookError ? hookError.message : null,
+          timestamp: Date.now()
+        });
+      }
+      const totalDuration = performance.now() - startTime;
+      console.debug(`[KupolaLifecycle] ${phase} completed in ${totalDuration.toFixed(2)}ms (${this.scope})`);
+    } finally {
+      this.pendingHooks.delete(emitId);
+    }
+  }
+  async runPhase(phase, ...args) {
+    if (!this.basePhases.includes(phase)) {
+      throw new Error(`Unknown base phase: ${phase}`);
+    }
+    const stateMap = this.phaseStateMap[phase];
+    if (stateMap) {
+      if (Array.isArray(stateMap.from)) {
+        if (!stateMap.from.includes(this.state)) {
+          throw new Error(`Cannot ${phase} from state ${this.state}, expected one of: ${stateMap.from.join(", ")}`);
+        }
+      } else {
+        if (this.state !== stateMap.from) {
+          throw new Error(`Cannot ${phase} from state ${this.state}, expected ${stateMap.from}`);
+        }
+      }
+    }
+    const beforePhase = `before${phase.charAt(0).toUpperCase() + phase.slice(1)}`;
+    const afterPhase = `after${phase.charAt(0).toUpperCase() + phase.slice(1)}`;
+    this._resetResolved(beforePhase);
+    this._resetResolved(phase);
+    this._resetResolved(afterPhase);
+    if (this.allPhases.includes(beforePhase)) {
+      await this.emit(beforePhase, ...args);
+    }
+    await this.emit(phase, ...args);
+    if (stateMap) {
+      this._updateState(stateMap.to);
+    }
+    if (this.allPhases.includes(afterPhase)) {
+      await this.emit(afterPhase, ...args);
+    }
+  }
+  async bootstrap(...args) {
+    await this.runPhase("bootstrap", ...args);
+  }
+  async _waitForDOMReady() {
+    return new Promise((resolve) => {
+      if (document.readyState === "complete" || document.readyState === "interactive") {
+        resolve();
+        return;
+      }
+      const onReady = () => {
+        document.removeEventListener("DOMContentLoaded", onReady);
+        window.removeEventListener("load", onReady);
+        resolve();
+      };
+      document.addEventListener("DOMContentLoaded", onReady);
+      window.addEventListener("load", onReady);
+    });
+  }
+  async mount(...args) {
+    await this.runPhase("mount", ...args);
+  }
+  async mountWithDOMReady(...args) {
+    await this._waitForDOMReady();
+    await this.runPhase("mount", ...args);
+  }
+  async update(...args) {
+    await this.runPhase("update", ...args);
+  }
+  async unmount(...args) {
+    await this.runPhase("unmount", ...args);
+  }
+  async destroy(...args) {
+    await this.runPhase("destroy", ...args);
+    this.hooks.forEach((handlers) => {
+      handlers.length = 0;
+    });
+  }
+  getPhaseHandlers(phase) {
+    return this.hooks.get(phase) || [];
+  }
+  hasHandlers(phase) {
+    const handlers = this.hooks.get(phase);
+    return handlers && handlers.length > 0;
+  }
+  getTrace() {
+    return [...this.trace];
+  }
+  clearTrace() {
+    this.trace = [];
+  }
+  getState() {
+    return this.state;
+  }
+  getStateHistory() {
+    return [...this.stateHistory];
+  }
+  isInState(targetState) {
+    return this.state === targetState;
+  }
+  onError(handler) {
+    this._onErrorCallback = handler;
+    return this.on("error", handler);
+  }
+  setErrorBoundary(boundary) {
+    this.errorBoundary = boundary;
+    return this.on("errorBoundary", (errorInfo) => {
+      if (typeof boundary === "function") {
+        return boundary(errorInfo);
+      }
+      return null;
+    });
+  }
+  setMaxErrors(max2) {
+    this.maxErrors = max2;
+  }
+  getErrorCount() {
+    return this.errorCount;
+  }
+  getLastError() {
+    return this.lastError;
+  }
+  resetErrorCount() {
+    this.errorCount = 0;
+    this.lastError = null;
+  }
+  async _handleError(errorInfo) {
+    this.errorCount++;
+    this.lastError = errorInfo.error;
+    if (this.errorCount >= this.maxErrors) {
+      console.error(`[KupolaLifecycle] Error limit reached (${this.maxErrors}), stopping error handling`);
+      return;
+    }
+    await this.emit("error", errorInfo);
+    if (typeof this._onErrorCallback === "function") {
+      try {
+        await this._onErrorCallback(errorInfo);
+      } catch (e) {
+        console.error("[KupolaLifecycle] Error in onError callback:", e);
+      }
+    }
+    const boundaryHandlers = this.hooks.get("errorBoundary");
+    if (boundaryHandlers && boundaryHandlers.length > 0) {
+      for (const hook of boundaryHandlers) {
+        try {
+          const result = hook.handler(errorInfo);
+          if (result instanceof Promise) {
+            await result;
+          }
+          if (result === "handled") {
+            console.debug(`[KupolaLifecycle] Error handled by errorBoundary hook "${hook.name}"`);
+            return;
+          }
+        } catch (e) {
+          console.error(`[KupolaLifecycle] Error in errorBoundary hook "${hook.name}":`, e);
+        }
+      }
+    }
+    console.error(`[KupolaLifecycle] Unhandled error in ${errorInfo.phase}:`, errorInfo.error);
+  }
+}
+const kupolaLifecycle = new KupolaLifecycle("app");
+function createLifecycle(scope = "app") {
+  return new KupolaLifecycle(scope);
+}
+const _UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function _isUnsafeKey(key) {
+  return _UNSAFE_KEYS.has(key);
+}
+function trim(str) {
+  return str ? str.trim() : "";
+}
+function trimLeft(str) {
+  return str ? str.replace(/^\s+/, "") : "";
+}
+function trimRight(str) {
+  return str ? str.replace(/\s+$/, "") : "";
+}
+function toUpperCase(str) {
+  return str ? str.toUpperCase() : "";
+}
+function toLowerCase(str) {
+  return str ? str.toLowerCase() : "";
+}
+function capitalize(str) {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelize(str) {
+  if (!str) return "";
+  return str.replace(/-(\w)/g, (_, c) => c ? c.toUpperCase() : "");
+}
+function hyphenate(str) {
+  if (!str) return "";
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function padStart(str, length, padChar = " ") {
+  return (String(str) || "").padStart(length, padChar);
+}
+function padEnd(str, length, padChar = " ") {
+  return (String(str) || "").padEnd(length, padChar);
+}
+function truncate(str, maxLength2, suffix = "...") {
+  if (!str || str.length <= maxLength2) return str || "";
+  return str.slice(0, maxLength2) + suffix;
+}
+function replaceAll(str, search, replacement) {
+  if (!str) return "";
+  return str.split(search).join(replacement);
+}
+function format(template, data) {
+  if (!template) return "";
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => data[key] !== void 0 ? data[key] : `{{${key}}}`);
+}
+function startsWith(str, prefix) {
+  return (str || "").startsWith(prefix);
+}
+function endsWith(str, suffix) {
+  return (str || "").endsWith(suffix);
+}
+function includesStr(str, search) {
+  return (str || "").includes(search);
+}
+function repeat(str, times) {
+  return (str || "").repeat(times);
+}
+function reverse(str) {
+  return (str || "").split("").reverse().join("");
+}
+function countOccurrences(str, search) {
+  if (!str || !search) return 0;
+  return str.split(search).length - 1;
+}
+function escapeHtml$1(str) {
+  if (!str) return "";
+  const div = document.createElement("div");
+  div.textContent = str;
+  return div.innerHTML;
+}
+function unescapeHtml(str) {
+  if (!str) return "";
+  const div = document.createElement("div");
+  div.innerHTML = str;
+  return div.textContent;
+}
+function generateRandom(length = 8) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+const stringUtils = { trim, trimLeft, trimRight, toUpperCase, toLowerCase, capitalize, camelize, hyphenate, padStart, padEnd, truncate, replaceAll, format, startsWith, endsWith, includes: includesStr, repeat, reverse, countOccurrences, escapeHtml: escapeHtml$1, unescapeHtml, generateRandom, generateUUID };
+function isArray(arr) {
+  return Array.isArray(arr);
+}
+function isEmpty(arr) {
+  return !arr || arr.length === 0;
+}
+function size(arr) {
+  return arr ? arr.length : 0;
+}
+function first(arr, defaultValue) {
+  return arr && arr.length > 0 ? arr[0] : defaultValue;
+}
+function last(arr, defaultValue) {
+  return arr && arr.length > 0 ? arr[arr.length - 1] : defaultValue;
+}
+function get(arr, index, defaultValue) {
+  return arr && arr[index] !== void 0 ? arr[index] : defaultValue;
+}
+function slice(arr, start, end) {
+  return arr ? arr.slice(start, end) : [];
+}
+function concat(...args) {
+  return args.reduce((result, arg) => result.concat(arg || []), []);
+}
+function join(arr, separator = ",") {
+  return arr ? arr.join(separator) : "";
+}
+function indexOf(arr, item, fromIndex = 0) {
+  if (!arr) return -1;
+  if (Number.isNaN(item)) {
+    for (let i = fromIndex; i < arr.length; i++) {
+      if (Number.isNaN(arr[i])) return i;
+    }
+    return -1;
+  }
+  return arr.indexOf(item, fromIndex);
+}
+function lastIndexOf(arr, item, fromIndex) {
+  if (!arr) return -1;
+  if (Number.isNaN(item)) {
+    const start = fromIndex !== void 0 ? fromIndex : arr.length - 1;
+    for (let i = start; i >= 0; i--) {
+      if (Number.isNaN(arr[i])) return i;
+    }
+    return -1;
+  }
+  return arr.lastIndexOf(item, fromIndex);
+}
+function includes(arr, item) {
+  return arr ? arr.includes(item) : false;
+}
+function push(arr, ...items) {
+  if (arr) arr.push(...items);
+  return arr;
+}
+function pop(arr) {
+  return arr ? arr.pop() : void 0;
+}
+function shift(arr) {
+  return arr ? arr.shift() : void 0;
+}
+function unshift(arr, ...items) {
+  if (arr) arr.unshift(...items);
+  return arr;
+}
+function remove(arr, item) {
+  if (!arr) return arr;
+  const index = Number.isNaN(item) ? arr.findIndex((v) => Number.isNaN(v)) : arr.indexOf(item);
+  if (index > -1) arr.splice(index, 1);
+  return arr;
+}
+function removeAt(arr, index) {
+  if (!arr || index < 0 || index >= arr.length) return arr;
+  arr.splice(index, 1);
+  return arr;
+}
+function insert(arr, index, item) {
+  if (!arr) return arr;
+  arr.splice(index, 0, item);
+  return arr;
+}
+function reverseArr(arr) {
+  return arr ? arr.slice().reverse() : [];
+}
+function sort(arr, compareFn) {
+  return arr ? arr.slice().sort(compareFn) : [];
+}
+function sortBy(arr, key, order = "asc") {
+  if (!arr) return [];
+  return arr.slice().sort((a, b) => {
+    const valA = typeof a === "object" ? a[key] : a;
+    const valB = typeof b === "object" ? b[key] : b;
+    if (valA < valB) return order === "asc" ? -1 : 1;
+    if (valA > valB) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+}
+function filter(arr, predicate) {
+  return arr ? arr.filter(predicate) : [];
+}
+function map(arr, fn) {
+  return arr ? arr.map(fn) : [];
+}
+function reduce(arr, fn, initialValue) {
+  return arr ? arr.reduce(fn, initialValue) : initialValue;
+}
+function forEach(arr, fn) {
+  if (arr) arr.forEach(fn);
+}
+function every(arr, predicate) {
+  return arr ? arr.every(predicate) : true;
+}
+function some(arr, predicate) {
+  return arr ? arr.some(predicate) : false;
+}
+function find(arr, predicate) {
+  return arr ? arr.find(predicate) : void 0;
+}
+function findIndex(arr, predicate) {
+  return arr ? arr.findIndex(predicate) : -1;
+}
+function flat(arr, depth = 1) {
+  return arr ? arr.flat(depth) : [];
+}
+function flattenDeep(arr) {
+  return arr ? arr.reduce((acc, item) => Array.isArray(item) ? acc.concat(flattenDeep(item)) : acc.concat(item), []) : [];
+}
+function unique(arr) {
+  return arr ? [...new Set(arr)] : [];
+}
+function uniqueBy(arr, key) {
+  if (!arr) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const value = typeof item === "object" ? item[key] : item;
+    if (seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+function chunk(arr, chunkSize) {
+  if (!arr || chunkSize <= 0) return [];
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += chunkSize) {
+    chunks.push(arr.slice(i, i + chunkSize));
+  }
+  return chunks;
+}
+function shuffle(arr) {
+  if (!arr) return [];
+  const result = arr.slice();
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+function sum(arr) {
+  return arr ? arr.reduce((acc, val) => acc + (Number(val) || 0), 0) : 0;
+}
+function average(arr) {
+  if (!arr || arr.length === 0) return 0;
+  return sum(arr) / arr.length;
+}
+function max(arr) {
+  return arr && arr.length > 0 ? Math.max(...arr) : -Infinity;
+}
+function min(arr) {
+  return arr && arr.length > 0 ? Math.min(...arr) : Infinity;
+}
+function intersection(...args) {
+  if (args.length === 0) return [];
+  return args.reduce((result, a) => result.filter((item) => a && a.includes(item)));
+}
+function union(...args) {
+  return [...new Set(args.flat().filter(Boolean))];
+}
+function difference(arr1, arr2) {
+  return arr1 ? arr1.filter((item) => !arr2 || !arr2.includes(item)) : [];
+}
+function zip(...args) {
+  if (args.length === 0) return [];
+  const maxLength2 = Math.max(...args.map((a) => a ? a.length : 0));
+  return Array.from({ length: maxLength2 }, (_, i) => args.map((a) => a && a[i]));
+}
+const arrayUtils = { isArray, isEmpty, size, first, last, get, slice, concat, join, indexOf, lastIndexOf, includes, push, pop, shift, unshift, remove, removeAt, insert, reverse: reverseArr, sort, sortBy, filter, map, reduce, forEach, every, some, find, findIndex, flat, flattenDeep, unique, uniqueBy, chunk, shuffle, sum, average, max, min, intersection, union, difference, zip };
+function isObject(obj) {
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj);
+}
+function isEmptyObj(obj) {
+  if (!obj || typeof obj !== "object") return true;
+  return Object.keys(obj).length === 0;
+}
+function keys(obj) {
+  return obj ? Object.keys(obj) : [];
+}
+function values(obj) {
+  return obj ? Object.values(obj) : [];
+}
+function entries(obj) {
+  return obj ? Object.entries(obj) : [];
+}
+function has(obj, key) {
+  return obj ? Object.prototype.hasOwnProperty.call(obj, key) : false;
+}
+function getObj(obj, path, defaultValue) {
+  if (!obj) return defaultValue;
+  const k = path.split(".");
+  if (k.some(_isUnsafeKey)) return defaultValue;
+  return k.reduce((current, key) => current && current[key], obj) ?? defaultValue;
+}
+function setObj(obj, path, value) {
+  if (!obj || typeof obj !== "object") return obj;
+  const k = path.split(".");
+  if (k.some(_isUnsafeKey)) return obj;
+  const lastKey = k.pop();
+  let current = obj;
+  k.forEach((key) => {
+    if (!current[key] || typeof current[key] !== "object") current[key] = {};
+    current = current[key];
+  });
+  current[lastKey] = value;
+  return obj;
+}
+function pick(obj, keys2) {
+  if (!obj) return {};
+  return keys2.reduce((result, key) => {
+    if (obj[key] !== void 0) result[key] = obj[key];
+    return result;
+  }, {});
+}
+function omit(obj, keys2) {
+  if (!obj) return {};
+  return Object.keys(obj).reduce((result, key) => {
+    if (!keys2.includes(key)) result[key] = obj[key];
+    return result;
+  }, {});
+}
+function merge(...args) {
+  return args.reduce((result, obj) => {
+    if (obj && typeof obj === "object") {
+      Object.keys(obj).forEach((key) => {
+        if (_isUnsafeKey(key)) return;
+        if (isObject(obj[key]) && isObject(result[key])) {
+          result[key] = merge(result[key], obj[key]);
+        } else {
+          result[key] = obj[key];
+        }
+      });
+    }
+    return result;
+  }, {});
+}
+function clone(obj) {
+  return obj ? JSON.parse(JSON.stringify(obj)) : obj;
+}
+function deepClone(obj, hash = /* @__PURE__ */ new WeakMap()) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (hash.has(obj)) return hash.get(obj);
+  if (obj instanceof Date) return new Date(obj);
+  if (obj instanceof RegExp) return new RegExp(obj);
+  if (obj instanceof Map) {
+    const m = /* @__PURE__ */ new Map();
+    hash.set(obj, m);
+    obj.forEach((val, key) => m.set(key, deepClone(val, hash)));
+    return m;
+  }
+  if (obj instanceof Set) {
+    const s = /* @__PURE__ */ new Set();
+    hash.set(obj, s);
+    obj.forEach((val) => s.add(deepClone(val, hash)));
+    return s;
+  }
+  if (Array.isArray(obj)) {
+    const a = [];
+    hash.set(obj, a);
+    obj.forEach((item) => a.push(deepClone(item, hash)));
+    return a;
+  }
+  const c = {};
+  hash.set(obj, c);
+  Object.keys(obj).forEach((key) => {
+    if (!_isUnsafeKey(key)) {
+      c[key] = deepClone(obj[key], hash);
+    }
+  });
+  return c;
+}
+function forEachObj(obj, fn) {
+  if (!obj) return;
+  Object.keys(obj).forEach((key) => fn(obj[key], key, obj));
+}
+function mapObj(obj, fn) {
+  if (!obj) return {};
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[key] = fn(obj[key], key, obj);
+  });
+  return result;
+}
+function filterObj(obj, fn) {
+  if (!obj) return {};
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    if (fn(obj[key], key, obj)) result[key] = obj[key];
+  });
+  return result;
+}
+function reduceObj(obj, fn, initialValue) {
+  if (!obj) return initialValue;
+  return Object.keys(obj).reduce((acc, key) => fn(acc, obj[key], key, obj), initialValue);
+}
+function toArray(obj) {
+  if (!obj) return [];
+  return Object.keys(obj).map((key) => ({ key, value: obj[key] }));
+}
+function fromArray(arr, keyField, valueField) {
+  if (!arr) return {};
+  return arr.reduce((result, item) => {
+    const key = typeof item === "object" ? item[keyField] : item;
+    const value = valueField ? item[valueField] : item;
+    if (key !== void 0) result[key] = value;
+    return result;
+  }, {});
+}
+function sizeObj(obj) {
+  return obj ? Object.keys(obj).length : 0;
+}
+function invert(obj) {
+  if (!obj) return {};
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[obj[key]] = key;
+  });
+  return result;
+}
+function isEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (!obj1 || !obj2 || typeof obj1 !== "object" || typeof obj2 !== "object") return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  return keys1.every((key) => isEqual(obj1[key], obj2[key]));
+}
+function freeze(obj) {
+  if (!obj) return obj;
+  Object.freeze(obj);
+  Object.keys(obj).forEach((key) => {
+    if (typeof obj[key] === "object") freeze(obj[key]);
+  });
+  return obj;
+}
+function seal(obj) {
+  return obj ? Object.seal(obj) : obj;
+}
+const objectUtils = { isObject, isEmpty: isEmptyObj, keys, values, entries, has, get: getObj, set: setObj, pick, omit, merge, clone, deepClone, forEach: forEachObj, map: mapObj, filter: filterObj, reduce: reduceObj, toArray, fromArray, size: sizeObj, invert, isEqual, freeze, seal };
+function isNumber(val) {
+  return typeof val === "number" && !isNaN(val);
+}
+function isInteger(val) {
+  return Number.isInteger(val);
+}
+function isFloat(val) {
+  return isNumber(val) && !Number.isInteger(val);
+}
+function isPositive(val) {
+  return isNumber(val) && val > 0;
+}
+function isNegative(val) {
+  return isNumber(val) && val < 0;
+}
+function isZero(val) {
+  return isNumber(val) && val === 0;
+}
+function clamp(val, minVal, maxVal) {
+  if (!isNumber(val)) return val;
+  return Math.min(Math.max(val, minVal), maxVal);
+}
+function round(val, precision = 0) {
+  if (!isNumber(val)) return val;
+  const factor = Math.pow(10, precision);
+  return Math.round(val * factor) / factor;
+}
+function floor(val) {
+  return isNumber(val) ? Math.floor(val) : val;
+}
+function ceil(val) {
+  return isNumber(val) ? Math.ceil(val) : val;
+}
+function abs(val) {
+  return isNumber(val) ? Math.abs(val) : val;
+}
+function minNum(...args) {
+  const nums = args.filter(isNumber);
+  return nums.length > 0 ? Math.min(...nums) : void 0;
+}
+function maxNum(...args) {
+  const nums = args.filter(isNumber);
+  return nums.length > 0 ? Math.max(...nums) : void 0;
+}
+function sumNum(...args) {
+  const nums = args.flat().filter(isNumber);
+  return nums.reduce((acc, val) => acc + val, 0);
+}
+function averageNum(...args) {
+  const nums = args.flat().filter(isNumber);
+  return nums.length > 0 ? sumNum(nums) / nums.length : 0;
+}
+function random(minVal = 0, maxVal = 1) {
+  return Math.random() * (maxVal - minVal) + minVal;
+}
+function randomInt(minVal, maxVal) {
+  return Math.floor(random(minVal, maxVal + 1));
+}
+function formatNum(val, decimals = 2) {
+  if (!isNumber(val)) return String(val);
+  return val.toFixed(decimals);
+}
+function formatCurrency$1(val, currency = "CNY", decimals = 2) {
+  if (!isNumber(val)) return String(val);
+  const formatter = new Intl.NumberFormat("zh-CN", { style: "currency", currency, minimumFractionDigits: decimals, maximumFractionDigits: decimals });
+  return formatter.format(val);
+}
+function formatPercent(val, decimals = 0) {
+  if (!isNumber(val)) return String(val);
+  return `${(val * 100).toFixed(decimals)}%`;
+}
+function toFixed(val, decimals = 0) {
+  if (!isNumber(val)) return String(val);
+  return val.toFixed(decimals);
+}
+function toPrecision(val, precision = 6) {
+  if (!isNumber(val)) return String(val);
+  return val.toPrecision(precision);
+}
+function isNaNVal(val) {
+  return Number.isNaN(val);
+}
+function isFiniteVal(val) {
+  return Number.isFinite(val);
+}
+function parseIntSafe(val, radix = 10) {
+  return Number.parseInt(val, radix);
+}
+function parseFloatSafe(val) {
+  return Number.parseFloat(val);
+}
+function toNumber(val, defaultValue = 0) {
+  const num = Number(val);
+  return isNaN(num) ? defaultValue : num;
+}
+function safeDivide(a, b, defaultValue = 0) {
+  if (!isNumber(a) || !isNumber(b) || b === 0) return defaultValue;
+  return a / b;
+}
+function safeMultiply(...args) {
+  return args.reduce((result, val) => {
+    if (!isNumber(result) || !isNumber(val)) return 0;
+    return result * val;
+  }, 1);
+}
+const numberUtils = { isNumber, isInteger, isFloat, isPositive, isNegative, isZero, clamp, round, floor, ceil, abs, min: minNum, max: maxNum, sum: sumNum, average: averageNum, random, randomInt, format: formatNum, formatCurrency: formatCurrency$1, formatPercent, toFixed, toPrecision, isNaN: isNaNVal, isFinite: isFiniteVal, parseInt: parseIntSafe, parseFloat: parseFloatSafe, toNumber, safeDivide, safeMultiply };
+function now() {
+  return Date.now();
+}
+function today() {
+  const d = /* @__PURE__ */ new Date();
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function tomorrow() {
+  const d = today();
+  d.setDate(d.getDate() + 1);
+  return d;
+}
+function yesterday() {
+  const d = today();
+  d.setDate(d.getDate() - 1);
+  return d;
+}
+function isDate(val) {
+  return val instanceof Date && !isNaN(val.getTime());
+}
+function isValidDate(date) {
+  return isDate(date);
+}
+function parseDate(str) {
+  const d = new Date(str);
+  return isValidDate(d) ? d : null;
+}
+function formatDate$1(date, formatStr = "YYYY-MM-DD HH:mm:ss") {
+  if (!isDate(date)) return "";
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const milliseconds = String(date.getMilliseconds()).padStart(3, "0");
+  const weekDays = ["日", "一", "二", "三", "四", "五", "六"];
+  const weekDay = weekDays[date.getDay()];
+  return formatStr.replace("YYYY", year).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds).replace("SSS", milliseconds).replace("D", date.getDate()).replace("M", date.getMonth() + 1).replace("H", date.getHours()).replace("m", date.getMinutes()).replace("s", date.getSeconds()).replace("W", weekDay);
+}
+function toISO(date) {
+  return isDate(date) ? date.toISOString() : "";
+}
+function toUTC(date) {
+  return isDate(date) ? new Date(date.toUTCString()) : null;
+}
+function addDays(date, days) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  d.setDate(d.getDate() + days);
+  return d;
+}
+function addHours(date, hours) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  d.setHours(d.getHours() + hours);
+  return d;
+}
+function addMinutes(date, minutes) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  d.setMinutes(d.getMinutes() + minutes);
+  return d;
+}
+function addSeconds(date, seconds) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  d.setSeconds(d.getSeconds() + seconds);
+  return d;
+}
+function diffDays(date1, date2) {
+  if (!isDate(date1) || !isDate(date2)) return 0;
+  const d1 = new Date(date1);
+  d1.setHours(0, 0, 0, 0);
+  const d2 = new Date(date2);
+  d2.setHours(0, 0, 0, 0);
+  return Math.floor((d1.getTime() - d2.getTime()) / (1e3 * 60 * 60 * 24));
+}
+function diffHours(date1, date2) {
+  if (!isDate(date1) || !isDate(date2)) return 0;
+  return Math.floor((date1.getTime() - date2.getTime()) / (1e3 * 60 * 60));
+}
+function diffMinutes(date1, date2) {
+  if (!isDate(date1) || !isDate(date2)) return 0;
+  return Math.floor((date1.getTime() - date2.getTime()) / (1e3 * 60));
+}
+function diffSeconds(date1, date2) {
+  if (!isDate(date1) || !isDate(date2)) return 0;
+  return Math.floor((date1.getTime() - date2.getTime()) / 1e3);
+}
+function isToday(date) {
+  if (!isDate(date)) return false;
+  return diffDays(date, today()) === 0;
+}
+function isYesterday(date) {
+  if (!isDate(date)) return false;
+  return diffDays(date, today()) === -1;
+}
+function isTomorrow(date) {
+  if (!isDate(date)) return false;
+  return diffDays(date, today()) === 1;
+}
+function isFuture(date) {
+  if (!isDate(date)) return false;
+  return date.getTime() > now();
+}
+function isPast(date) {
+  if (!isDate(date)) return false;
+  return date.getTime() < now();
+}
+function isLeapYear(date) {
+  if (!isDate(date)) return false;
+  const year = date.getFullYear();
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function getDaysInMonth(date) {
+  if (!isDate(date)) return 0;
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+}
+function getWeekOfYear(date) {
+  if (!isDate(date)) return 0;
+  const startOfYear = new Date(date.getFullYear(), 0, 1);
+  const diff = date.getTime() - startOfYear.getTime();
+  return Math.ceil(diff / (1e3 * 60 * 60 * 24 * 7));
+}
+function getQuarter(date) {
+  if (!isDate(date)) return 0;
+  return Math.ceil((date.getMonth() + 1) / 3);
+}
+function startOfDay(date) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function endOfDay(date) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+function startOfMonth(date) {
+  if (!isDate(date)) return date;
+  return new Date(date.getFullYear(), date.getMonth(), 1);
+}
+function endOfMonth(date) {
+  if (!isDate(date)) return date;
+  return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
+}
+function startOfWeek(date, startDay = 1) {
+  if (!isDate(date)) return date;
+  const d = new Date(date);
+  const day = d.getDay();
+  const diff = day >= startDay ? day - startDay : day + (7 - startDay);
+  d.setDate(d.getDate() - diff);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function endOfWeek(date, startDay = 1) {
+  if (!isDate(date)) return date;
+  const start = startOfWeek(date, startDay);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 6);
+  end.setHours(23, 59, 59, 999);
+  return end;
+}
+function getAge(birthDate) {
+  if (!isDate(birthDate)) return 0;
+  const n2 = /* @__PURE__ */ new Date();
+  let age = n2.getFullYear() - birthDate.getFullYear();
+  if (n2.getMonth() < birthDate.getMonth() || n2.getMonth() === birthDate.getMonth() && n2.getDate() < birthDate.getDate()) {
+    age--;
+  }
+  return Math.max(0, age);
+}
+function fromNow(date) {
+  if (!isDate(date)) return "";
+  const n2 = now();
+  const diff = n2 - date.getTime();
+  const minute = 60 * 1e3;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  const week = 7 * day;
+  const month = 30 * day;
+  const year = 365 * day;
+  if (diff < minute) return "刚刚";
+  if (diff < hour) return `${Math.floor(diff / minute)}分钟前`;
+  if (diff < day) return `${Math.floor(diff / hour)}小时前`;
+  if (diff < week) return `${Math.floor(diff / day)}天前`;
+  if (diff < month) return `${Math.floor(diff / week)}周前`;
+  if (diff < year) return `${Math.floor(diff / month)}个月前`;
+  return `${Math.floor(diff / year)}年前`;
+}
+const dateUtils = { now, today, tomorrow, yesterday, isDate, isValid: isValidDate, parse: parseDate, format: formatDate$1, toISO, toUTC, addDays, addHours, addMinutes, addSeconds, diffDays, diffHours, diffMinutes, diffSeconds, isToday, isYesterday, isTomorrow, isFuture, isPast, isLeapYear, getDaysInMonth, getWeekOfYear, getQuarter, startOfDay, endOfDay, startOfMonth, endOfMonth, startOfWeek, endOfWeek, getAge, fromNow };
+function debounce(func, wait, options = {}) {
+  let timeout = null, lastArgs = null, lastThis = null, lastCallTime = 0;
+  const leading = options.leading || false;
+  const trailing = options.trailing !== false;
+  function invokeFunc() {
+    func.apply(lastThis, lastArgs);
+  }
+  function leadingEdge() {
+    lastCallTime = Date.now();
+    if (leading) {
+      timeout = setTimeout(trailingEdge, wait);
+      invokeFunc();
+    } else {
+      timeout = setTimeout(trailingEdge, wait);
+    }
+  }
+  function trailingEdge() {
+    timeout = null;
+    if (trailing && lastArgs) {
+      invokeFunc();
+    }
+    lastArgs = null;
+    lastThis = null;
+  }
+  function remainingWait() {
+    return Math.max(0, wait - (Date.now() - lastCallTime));
+  }
+  return function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = Date.now();
+    if (!timeout) {
+      leadingEdge();
+    } else {
+      clearTimeout(timeout);
+      timeout = setTimeout(trailingEdge, remainingWait());
+    }
+  };
+}
+function throttle(func, limit, options = {}) {
+  let inThrottle = false;
+  const trailing = options.trailing || false;
+  let lastArgs = null, lastThis = null;
+  function invokeFunc() {
+    func.apply(lastThis, lastArgs);
+    lastArgs = null;
+    lastThis = null;
+  }
+  return function(...args) {
+    if (!inThrottle) {
+      inThrottle = true;
+      lastArgs = args;
+      lastThis = this;
+      invokeFunc();
+      setTimeout(() => {
+        inThrottle = false;
+        if (trailing && lastArgs) {
+          invokeFunc();
+        }
+      }, limit);
+    } else if (trailing) {
+      lastArgs = args;
+      lastThis = this;
+    }
+  };
+}
+function isEmail(str) {
+  return /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(str || "");
+}
+function isPhone(str) {
+  return /^1[3-9]\d{9}$/.test(str || "");
+}
+function isURL(str) {
+  return /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w.-]*)*\/?$/.test(str || "");
+}
+function isIPv4(str) {
+  return /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(str || "");
+}
+function isIPv6(str) {
+  return /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/.test(str || "");
+}
+function isIP(str) {
+  return isIPv4(str) || isIPv6(str);
+}
+function isIDCard(str) {
+  return /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/.test(str || "");
+}
+function isPassport(str) {
+  return /^[A-Z][0-9]{8}$|^[A-Z]{2}[0-9]{7}$/.test(str || "");
+}
+function isCreditCard(str) {
+  const regex = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9]{2})[0-9]{12}|3[47][0-9]{13})$/;
+  const cleanStr = str.replace(/\s/g, "");
+  if (!regex.test(cleanStr)) return false;
+  let s = 0, alt = false;
+  for (let i = cleanStr.length - 1; i >= 0; i--) {
+    let digit = parseInt(cleanStr[i], 10);
+    if (alt) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    s += digit;
+    alt = !alt;
+  }
+  return s % 10 === 0;
+}
+function isHexColor(str) {
+  return /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(str || "");
+}
+function isRGB(str) {
+  const m = /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/.exec(str || "");
+  if (!m) return false;
+  return m.slice(1).every((v) => parseInt(v) >= 0 && parseInt(v) <= 255);
+}
+function isRGBA(str) {
+  const m = /^rgba\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3}),\s*([01]|0\.\d+)\)$/.exec(str || "");
+  if (!m) return false;
+  const [, r, g, b, a] = m;
+  return parseInt(r) >= 0 && parseInt(r) <= 255 && parseInt(g) >= 0 && parseInt(g) <= 255 && parseInt(b) >= 0 && parseInt(b) <= 255 && parseFloat(a) >= 0 && parseFloat(a) <= 1;
+}
+function isColor(str) {
+  return isHexColor(str) || isRGB(str) || isRGBA(str);
+}
+function isDateStr(str) {
+  return !isNaN(new Date(str).getTime());
+}
+function isJSON(str) {
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isEmptyStr(str) {
+  return !str || str.trim() === "";
+}
+function isWhitespace(str) {
+  return /^\s+$/.test(str || "");
+}
+function isNumberStr(str) {
+  return !isNaN(parseFloat(str)) && isFinite(str);
+}
+function isIntegerStr(str) {
+  return /^-?\d+$/.test(str || "");
+}
+function isFloatStr(str) {
+  return /^-?\d+\.\d+$/.test(str || "");
+}
+function isPositiveStr(str) {
+  const num = parseFloat(str);
+  return !isNaN(num) && num > 0;
+}
+function isNegativeStr(str) {
+  const num = parseFloat(str);
+  return !isNaN(num) && num < 0;
+}
+function isAlpha(str) {
+  return /^[a-zA-Z]+$/.test(str || "");
+}
+function isAlphaNumeric(str) {
+  return /^[a-zA-Z0-9]+$/.test(str || "");
+}
+function isChinese(str) {
+  return /^[\u4e00-\u9fa5]+$/.test(str || "");
+}
+function isLength(str, minVal, maxVal) {
+  const len = (str || "").length;
+  return len >= minVal && (maxVal === void 0 || len <= maxVal);
+}
+function minLength(str, minVal) {
+  return (str || "").length >= minVal;
+}
+function maxLength(str, maxVal) {
+  return (str || "").length <= maxVal;
+}
+function matches(str, regex) {
+  return regex instanceof RegExp ? regex.test(str || "") : false;
+}
+function equals(str1, str2) {
+  return String(str1) === String(str2);
+}
+function contains(str, substring) {
+  return (str || "").includes(substring);
+}
+function notContains(str, substring) {
+  return !contains(str, substring);
+}
+function isArrayVal(arr) {
+  return Array.isArray(arr);
+}
+function arrayLength(arr, minVal, maxVal) {
+  const len = arr ? arr.length : 0;
+  return len >= minVal && (maxVal === void 0 || len <= maxVal);
+}
+function arrayMinLength(arr, minVal) {
+  return arr ? arr.length >= minVal : false;
+}
+function arrayMaxLength(arr, maxVal) {
+  return arr ? arr.length <= maxVal : false;
+}
+function isObjectVal(obj) {
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj);
+}
+function hasKeys(obj, keys2) {
+  if (!obj || !keys2 || !Array.isArray(keys2)) return false;
+  return keys2.every((key) => Object.prototype.hasOwnProperty.call(obj, key));
+}
+function validate(obj, rules) {
+  const errors = {};
+  Object.keys(rules).forEach((key) => {
+    const value = obj[key];
+    const fieldRules = rules[key];
+    const fieldErrors = [];
+    fieldRules.forEach((rule) => {
+      if (typeof rule === "string") {
+        const [name, ...params] = rule.split(":");
+        if (!validatorUtils[name](value, ...params)) {
+          fieldErrors.push(name);
+        }
+      } else if (typeof rule === "function") {
+        const result = rule(value, obj);
+        if (result !== true) {
+          fieldErrors.push(result || "validation_failed");
+        }
+      }
+    });
+    if (fieldErrors.length > 0) {
+      errors[key] = fieldErrors;
+    }
+  });
+  return { valid: Object.keys(errors).length === 0, errors };
+}
+const validatorUtils = { isEmail, isPhone, isURL, isIPv4, isIPv6, isIP, isIDCard, isPassport, isCreditCard, isHexColor, isRGB, isRGBA, isColor, isDate: isDateStr, isJSON, isEmpty: isEmptyStr, isWhitespace, isNumber: isNumberStr, isInteger: isIntegerStr, isFloat: isFloatStr, isPositive: isPositiveStr, isNegative: isNegativeStr, isAlpha, isAlphaNumeric, isChinese, isLength, minLength, maxLength, matches, equals, contains, notContains, isArray: isArrayVal, arrayLength, arrayMinLength, arrayMaxLength, isObject: isObjectVal, hasKeys, validate };
+function md5(str) {
+  const message = str ? String(str) : "";
+  const md5Array = [1732584193, 4023233417, 2562383102, 271733878];
+  const K = [3614090360, 3905402710, 606105819, 3250441966, 4118548399, 1200080426, 2821735955, 4249261313, 1770035416, 2336552879, 4294925233, 2304563134, 1804603682, 4254626195, 2792965006, 1236535329, 4129170786, 3225465664, 643717713, 3921069994, 3593408605, 38016083, 3634488961, 3889429448, 568446438, 3275163606, 4107603335, 1163531501, 2850285829, 4243563512, 1735328473, 2368359562, 4294588738, 2272392833, 1839030562, 4259657740, 2763975236, 1272893353, 4139469664, 3200236656, 681279174, 3936430074, 3572445317, 76029189, 3654602809, 3873151461, 530742520, 3299628645, 4096336452, 1126891415, 2878612391, 4237533241, 1700485571, 2399980690, 4293915773, 2240044497, 1873313359, 4264355552, 2734768916, 1309151649, 4149444226, 3174756917, 718787259, 3951481745];
+  const S = [[7, 12, 17, 22], [5, 9, 14, 20], [4, 11, 16, 23], [6, 10, 15, 21]];
+  function leftRotate(value, shift2) {
+    return value << shift2 | value >>> 32 - shift2;
+  }
+  function addPadding(msg) {
+    const bitLength = msg.length * 8;
+    msg += "€";
+    while (msg.length % 64 !== 56) {
+      msg += "\0";
+    }
+    const lowBytes = bitLength & 4294967295;
+    const highBytes = bitLength >>> 32 & 4294967295;
+    for (let i = 0; i < 4; i++) {
+      msg += String.fromCharCode(lowBytes >>> 8 * i & 255);
+    }
+    for (let i = 0; i < 4; i++) {
+      msg += String.fromCharCode(highBytes >>> 8 * i & 255);
+    }
+    return msg;
+  }
+  function processBlock(block, state2) {
+    const [a, b, c, d] = state2;
+    const words = [];
+    for (let i = 0; i < 16; i++) {
+      words[i] = block.charCodeAt(i * 4) & 255 | (block.charCodeAt(i * 4 + 1) & 255) << 8 | (block.charCodeAt(i * 4 + 2) & 255) << 16 | (block.charCodeAt(i * 4 + 3) & 255) << 24;
+    }
+    let AA = a, BB = b, CC = c, DD = d;
+    for (let i = 0; i < 64; i++) {
+      let f, g;
+      const r = Math.floor(i / 16);
+      const wi = i % 16;
+      if (r === 0) {
+        f = BB & CC | ~BB & DD;
+        g = wi;
+      } else if (r === 1) {
+        f = DD & BB | ~DD & CC;
+        g = (5 * wi + 1) % 16;
+      } else if (r === 2) {
+        f = BB ^ CC ^ DD;
+        g = (3 * wi + 5) % 16;
+      } else {
+        f = CC ^ (BB | ~DD);
+        g = 7 * wi % 16;
+      }
+      const temp = DD;
+      DD = CC;
+      CC = BB;
+      BB = BB + leftRotate(AA + f + K[i] + words[g] & 4294967295, S[r][i % 4]);
+      AA = temp;
+    }
+    return [a + AA & 4294967295, b + BB & 4294967295, c + CC & 4294967295, d + DD & 4294967295];
+  }
+  const paddedMessage = addPadding(message);
+  let state = [...md5Array];
+  for (let i = 0; i < paddedMessage.length; i += 64) {
+    state = processBlock(paddedMessage.substring(i, i + 64), state);
+  }
+  let result = "";
+  state.forEach((word) => {
+    for (let i = 0; i < 4; i++) {
+      result += (word >>> 8 * i & 255).toString(16).padStart(2, "0");
+    }
+  });
+  return result;
+}
+function sha256(str) {
+  const message = str ? String(str) : "";
+  const K = [1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298];
+  function rightRotate(value, shift2) {
+    return value >>> shift2 | value << 32 - shift2;
+  }
+  function addPadding(msg) {
+    const bitLength = msg.length * 8;
+    msg += "€";
+    while (msg.length % 64 !== 56) {
+      msg += "\0";
+    }
+    const lowBytes = bitLength & 4294967295;
+    const highBytes = bitLength >>> 32 & 4294967295;
+    for (let i = 0; i < 4; i++) {
+      msg += String.fromCharCode(highBytes >>> 8 * i & 255);
+    }
+    for (let i = 0; i < 4; i++) {
+      msg += String.fromCharCode(lowBytes >>> 8 * i & 255);
+    }
+    return msg;
+  }
+  function processBlock(block, state2) {
+    const words = [];
+    for (let i = 0; i < 16; i++) {
+      words[i] = block.charCodeAt(i * 4) & 255 | (block.charCodeAt(i * 4 + 1) & 255) << 8 | (block.charCodeAt(i * 4 + 2) & 255) << 16 | (block.charCodeAt(i * 4 + 3) & 255) << 24;
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rightRotate(words[i - 15], 7) ^ rightRotate(words[i - 15], 18) ^ words[i - 15] >>> 3;
+      const s1 = rightRotate(words[i - 2], 17) ^ rightRotate(words[i - 2], 19) ^ words[i - 2] >>> 10;
+      words[i] = words[i - 16] + s0 + words[i - 7] + s1 & 4294967295;
+    }
+    let [a, b, c, d, e, f, g, h] = state2;
+    for (let i = 0; i < 64; i++) {
+      const S1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + S1 + ch + K[i] + words[i] & 4294967295;
+      const S0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj & 4294967295;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 & 4294967295;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 & 4294967295;
+    }
+    return [state2[0] + a & 4294967295, state2[1] + b & 4294967295, state2[2] + c & 4294967295, state2[3] + d & 4294967295, state2[4] + e & 4294967295, state2[5] + f & 4294967295, state2[6] + g & 4294967295, state2[7] + h & 4294967295];
+  }
+  const paddedMessage = addPadding(message);
+  let state = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  for (let i = 0; i < paddedMessage.length; i += 64) {
+    state = processBlock(paddedMessage.substring(i, i + 64), state);
+  }
+  let result = "";
+  state.forEach((word) => {
+    for (let i = 3; i >= 0; i--) {
+      result += (word >>> 8 * i & 255).toString(16).padStart(2, "0");
+    }
+  });
+  return result;
+}
+function base64Encode(str) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let result = "";
+  let i = 0;
+  const bytes = str ? str.split("").map((c) => c.charCodeAt(0)) : [];
+  while (i < bytes.length) {
+    const byte1 = bytes[i++];
+    const byte2 = bytes[i++] || 0;
+    const byte3 = bytes[i++] || 0;
+    const enc1 = byte1 >> 2;
+    const enc2 = (byte1 & 3) << 4 | byte2 >> 4;
+    const enc3 = (byte2 & 15) << 2 | byte3 >> 6;
+    const enc4 = byte3 & 63;
+    result += chars[enc1] + chars[enc2] + (i > bytes.length + 1 ? "=" : chars[enc3]) + (i > bytes.length ? "=" : chars[enc4]);
+  }
+  return result;
+}
+function base64Decode(str) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let result = "";
+  let i = 0;
+  str = str.replace(/[^A-Za-z0-9+/=]/g, "");
+  while (i < str.length) {
+    const enc1 = chars.indexOf(str.charAt(i++));
+    const enc2 = chars.indexOf(str.charAt(i++));
+    const enc3 = chars.indexOf(str.charAt(i++));
+    const enc4 = chars.indexOf(str.charAt(i++));
+    const byte1 = enc1 << 2 | enc2 >> 4;
+    const byte2 = (enc2 & 15) << 4 | enc3 >> 2;
+    const byte3 = (enc3 & 3) << 6 | enc4;
+    result += String.fromCharCode(byte1);
+    if (enc3 !== 64) result += String.fromCharCode(byte2);
+    if (enc4 !== 64) result += String.fromCharCode(byte3);
+  }
+  return result;
+}
+function uuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+const cryptoUtils = { md5, sha256, base64Encode, base64Decode, uuid };
+const _preloadCache = /* @__PURE__ */ new Map();
+async function loadImage(url, options = {}) {
+  const { crossOrigin = "anonymous" } = options;
+  if (_preloadCache.has(url)) return _preloadCache.get(url);
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.crossOrigin = crossOrigin;
+    img.onload = () => {
+      _preloadCache.set(url, img);
+      resolve(img);
+    };
+    img.onerror = () => {
+      reject(new Error(`Failed to load image: ${url}`));
+    };
+    img.src = url;
+  });
+}
+async function loadImages(urls, options = {}) {
+  const { parallel = true } = options;
+  if (parallel) return Promise.all(urls.map((url) => loadImage(url, options)));
+  const results = [];
+  for (const url of urls) {
+    results.push(await loadImage(url, options));
+  }
+  return results;
+}
+async function loadScript(url, options = {}) {
+  const { type = "text/javascript", async: isAsync = true, defer = false } = options;
+  if (_preloadCache.has(url)) return _preloadCache.get(url);
+  return new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.type = type;
+    script.async = isAsync;
+    script.defer = defer;
+    script.onload = () => {
+      _preloadCache.set(url, script);
+      resolve(script);
+    };
+    script.onerror = () => {
+      script.remove();
+      reject(new Error(`Failed to load script: ${url}`));
+    };
+    script.src = url;
+    document.head.appendChild(script);
+  });
+}
+async function loadStylesheet(url, options = {}) {
+  const { media = "all" } = options;
+  if (_preloadCache.has(url)) return _preloadCache.get(url);
+  return new Promise((resolve, reject) => {
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = url;
+    link.media = media;
+    link.onload = () => {
+      _preloadCache.set(url, link);
+      resolve(link);
+    };
+    link.onerror = () => {
+      link.remove();
+      reject(new Error(`Failed to load stylesheet: ${url}`));
+    };
+    document.head.appendChild(link);
+  });
+}
+async function loadFont(fontFamily, src, options = {}) {
+  const { weight = "normal", style = "normal" } = options;
+  const fontFace = new FontFace(fontFamily, `url(${src})`, { weight, style });
+  try {
+    await fontFace.load();
+    document.fonts.add(fontFace);
+    return fontFace;
+  } catch (e) {
+    throw new Error(`Failed to load font: ${fontFamily}`);
+  }
+}
+async function preload(url, type = "image") {
+  switch (type) {
+    case "image":
+      return loadImage(url);
+    case "script":
+      return loadScript(url);
+    case "stylesheet":
+    case "style":
+      return loadStylesheet(url);
+    default:
+      throw new Error(`Unsupported preload type: ${type}`);
+  }
+}
+function isLoaded(url) {
+  return _preloadCache.has(url);
+}
+function clearPreloadCache() {
+  _preloadCache.clear();
+}
+function clearCacheByUrl(url) {
+  _preloadCache.delete(url);
+}
+const preloadUtils = { loadImage, loadImages, loadScript, loadStylesheet, loadFont, preload, isLoaded, clearCache: clearPreloadCache, clearCacheByUrl };
+const KupolaUtils = {
+  string: stringUtils,
+  array: arrayUtils,
+  object: objectUtils,
+  number: numberUtils,
+  date: dateUtils,
+  debounce,
+  throttle,
+  validator: validatorUtils,
+  crypto: cryptoUtils,
+  preload: preloadUtils
+};
+function sanitizeHtml$1(html) {
+  if (!html) return "";
+  let str = String(html);
+  const dangerousTags = /<\s*(script|iframe|object|embed|applet|form|base|link|meta|style)\b[^>]*>[\s\S]*?<\s*\/\s*\1\s*>|<\s*(script|iframe|object|embed|applet|form|base|link|meta|style)\b[^>]*\/?>/gi;
+  let prev;
+  do {
+    prev = str;
+    str = str.replace(dangerousTags, "");
+  } while (str !== prev);
+  str = str.replace(/\bon\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+  str = str.replace(/(href|src|action|background)\s*=\s*(?:"[^"]*(?:javascript|vbscript|data)\s*:[^"]*"|'[^']*(?:javascript|vbscript|data)\s*:[^']*'|[^\s>]*(?:javascript|vbscript|data)\s*:[^\s>]*)/gi, '$1=""');
+  str = str.replace(/expression\s*\([^)]*\)/gi, "");
+  return str;
+}
+class TrieNode {
+  constructor() {
+    this.children = {};
+    this.keys = [];
+  }
+}
+class PathTrie {
+  constructor() {
+    this.root = new TrieNode();
+  }
+  insert(key) {
+    let node = this.root;
+    const parts = key.split(".");
+    parts.forEach((part, index) => {
+      if (!node.children[part]) {
+        node.children[part] = new TrieNode();
+      }
+      node = node.children[part];
+      if (index === parts.length - 1) {
+        node.keys.push(key);
+      }
+    });
+  }
+  getSubKeys(key) {
+    let node = this.root;
+    const parts = key.split(".");
+    const result = [];
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!node.children[part]) {
+        break;
+      }
+      node = node.children[part];
+      const collectKeys = (n2) => {
+        if (n2.keys.length > 0) {
+          result.push(...n2.keys);
+        }
+        Object.values(n2.children).forEach((child) => collectKeys(child));
+      };
+      collectKeys(node);
+    }
+    return [...new Set(result)];
+  }
+  getParentKeys(key) {
+    const parts = key.split(".");
+    const result = [];
+    for (let i = 1; i <= parts.length; i++) {
+      const parentPath = parts.slice(0, i).join(".");
+      result.push(parentPath);
+    }
+    return result;
+  }
+}
+const REACTIVE_SYMBOLS = {
+  parent: Symbol("reactive_parent"),
+  path: Symbol("reactive_path"),
+  isReactive: Symbol("reactive_is_reactive")
+};
+class KupolaDataBind {
+  constructor() {
+    this.rawData = {};
+    this.data = null;
+    this.observers = {};
+    this.elements = {};
+    this.computedProperties = {};
+    this.pathTrie = new PathTrie();
+    this.updateQueue = /* @__PURE__ */ new Map();
+    this.isProcessing = false;
+    this.pendingComputed = /* @__PURE__ */ new Set();
+    this.persistedKeys = /* @__PURE__ */ new Map();
+    this.snapshots = [];
+    this.snapshotLimit = 10;
+    this._proxyCache = /* @__PURE__ */ new WeakMap();
+    this.createReactiveData();
+  }
+  createReactiveData() {
+    const handler = {
+      get: (target, key, receiver2) => {
+        if (key === "__raw__") return target;
+        const result = Reflect.get(target, key, receiver2);
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+          return this.wrapReactive(result, key);
+        }
+        return result;
+      },
+      set: (target, key, value, receiver2) => {
+        const oldValue = Reflect.get(target, key, receiver2);
+        const result = Reflect.set(target, key, value, receiver2);
+        const fullPath = this.resolvePath(target, key);
+        this.notify(fullPath, value, oldValue);
+        this.queueUpdate(fullPath, value);
+        return result;
+      },
+      deleteProperty: (target, key) => {
+        const oldValue = Reflect.get(target, key, receiver);
+        const result = Reflect.deleteProperty(target, key);
+        const fullPath = this.resolvePath(target, key);
+        this.notify(fullPath, void 0, oldValue);
+        this.queueUpdate(fullPath, void 0);
+        return result;
+      }
+    };
+    this.data = new Proxy(this.rawData, handler);
+    this.data.__parent__ = null;
+    this.data.__path__ = "";
+  }
+  wrapReactive(obj, parentKey) {
+    if (obj[REACTIVE_SYMBOLS.isReactive]) return obj;
+    if (this._proxyCache.has(obj)) {
+      return this._proxyCache.get(obj);
+    }
+    const handler = {
+      get: (target, key, receiver2) => {
+        if (key === "__raw__") return target;
+        if (key === REACTIVE_SYMBOLS.parent || key === "__parent__") return target[REACTIVE_SYMBOLS.parent];
+        if (key === REACTIVE_SYMBOLS.path || key === "__path__") return target[REACTIVE_SYMBOLS.path];
+        if (key === REACTIVE_SYMBOLS.isReactive || key === "__isReactive__") return true;
+        const result = Reflect.get(target, key, receiver2);
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+          return this.wrapReactive(result, `${target[REACTIVE_SYMBOLS.path]}${target[REACTIVE_SYMBOLS.path] ? "." : ""}${key}`);
+        }
+        return result;
+      },
+      set: (target, key, value, receiver2) => {
+        if (key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive || key === "__parent__" || key === "__path__" || key === "__isReactive__") {
+          return true;
+        }
+        const oldValue = Reflect.get(target, key, receiver2);
+        const result = Reflect.set(target, key, value, receiver2);
+        const fullPath = `${target[REACTIVE_SYMBOLS.path]}${target[REACTIVE_SYMBOLS.path] ? "." : ""}${key}`;
+        this.notify(fullPath, value, oldValue);
+        this.queueUpdate(fullPath, value);
+        return result;
+      },
+      deleteProperty: (target, key) => {
+        if (key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive) {
+          return false;
+        }
+        const oldValue = Reflect.get(target, key);
+        const result = Reflect.deleteProperty(target, key);
+        const fullPath = `${target[REACTIVE_SYMBOLS.path]}${target[REACTIVE_SYMBOLS.path] ? "." : ""}${key}`;
+        this.notify(fullPath, void 0, oldValue);
+        this.queueUpdate(fullPath, void 0);
+        return result;
+      },
+      has: (target, key) => {
+        if (key === "__raw__" || key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive || key === "__parent__" || key === "__path__" || key === "__isReactive__") {
+          return true;
+        }
+        return key in target;
+      },
+      ownKeys: (target) => {
+        return Reflect.ownKeys(target).filter(
+          (key) => key !== REACTIVE_SYMBOLS.parent && key !== REACTIVE_SYMBOLS.path && key !== REACTIVE_SYMBOLS.isReactive
+        );
+      },
+      getOwnPropertyDescriptor: (target, key) => {
+        if (key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive) {
+          return {
+            configurable: false,
+            enumerable: false,
+            writable: false,
+            value: target[key]
+          };
+        }
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      }
+    };
+    const proxy = new Proxy(obj, handler);
+    obj[REACTIVE_SYMBOLS.parent] = obj;
+    obj[REACTIVE_SYMBOLS.path] = parentKey;
+    obj[REACTIVE_SYMBOLS.isReactive] = true;
+    this._proxyCache.set(obj, proxy);
+    Object.keys(obj).forEach((key) => {
+      if (obj[key] && typeof obj[key] === "object" && !Array.isArray(obj[key])) {
+        obj[key] = this.wrapReactive(obj[key], `${parentKey}${parentKey ? "." : ""}${key}`);
+      }
+    });
+    return proxy;
+  }
+  resolvePath(target, key) {
+    if (target[REACTIVE_SYMBOLS.path]) {
+      return `${target[REACTIVE_SYMBOLS.path]}.${key}`;
+    }
+    return key;
+  }
+  queueUpdate(key, value) {
+    this.updateQueue.set(key, value);
+    if (!this.isProcessing) {
+      this.isProcessing = true;
+      requestAnimationFrame(() => {
+        this.processQueue();
+      });
+    }
+  }
+  processQueue() {
+    const updatedKeys = /* @__PURE__ */ new Set();
+    this.updateQueue.forEach((value, key) => {
+      updatedKeys.add(key);
+      this.updateElementsDirect(key, value);
+      const subKeys = this.pathTrie.getSubKeys(key);
+      subKeys.forEach((subKey) => {
+        if (!updatedKeys.has(subKey)) {
+          const subValue = this.get(subKey);
+          this.updateElementsDirect(subKey, subValue);
+          updatedKeys.add(subKey);
+        }
+      });
+    });
+    this.updateQueue.clear();
+    this.processComputed();
+    this.isProcessing = false;
+  }
+  updateElementsDirect(key, value) {
+    if (this.elements[key]) {
+      this.elements[key].forEach((element) => {
+        this.updateElement(element, value);
+      });
+    }
+  }
+  processComputed() {
+    const computedKeys = Object.keys(this.computedProperties);
+    computedKeys.forEach((name) => {
+      const prop = this.computedProperties[name];
+      const depsChanged = prop.deps.some((dep) => {
+        return this.updateQueue.has(dep) || this.pathTrie.getSubKeys(dep).some((k) => this.updateQueue.has(k));
+      });
+      if (depsChanged) {
+        this.updateComputedProperty(name);
+      }
+    });
+  }
+  set(key, value, silent = false) {
+    const oldValue = this.get(key);
+    if (typeof key === "object") {
+      Object.assign(this.rawData, key);
+      Object.keys(key).forEach((k) => {
+        if (!silent) {
+          this.notify(k, key[k], oldValue?.[k]);
+          this.queueUpdate(k, key[k]);
+        }
+      });
+    } else {
+      if (key.includes(".")) {
+        this.setNested(key, value);
+      } else {
+        this.rawData[key] = value;
+      }
+      if (!silent) {
+        this.notify(key, value, oldValue);
+        this.queueUpdate(key, value);
+      }
+    }
+    if (!silent) {
+      this.processComputed();
+    }
+  }
+  get(key) {
+    if (!key) return void 0;
+    if (key.includes(".")) {
+      return this.getNested(key);
+    }
+    return this.rawData[key];
+  }
+  getNested(path) {
+    if (!path) return void 0;
+    return path.split(".").reduce((obj, key) => obj?.[key], this.rawData);
+  }
+  setNested(path, value) {
+    const keys2 = path.split(".");
+    const lastKey = keys2.pop();
+    const parent = keys2.reduce((obj, key) => {
+      if (!obj[key]) obj[key] = {};
+      return obj[key];
+    }, this.rawData);
+    const oldValue = parent[lastKey];
+    parent[lastKey] = value;
+    this.notify(path, value, oldValue);
+    this.queueUpdate(path, value);
+  }
+  observe(key, callback) {
+    if (!this.observers[key]) {
+      this.observers[key] = [];
+    }
+    this.observers[key].push(callback);
+  }
+  unobserve(key, callback) {
+    if (this.observers[key]) {
+      this.observers[key] = this.observers[key].filter((cb) => cb !== callback);
+    }
+  }
+  notify(key, value, oldValue) {
+    if (this.observers[key]) {
+      this.observers[key].forEach((callback) => {
+        try {
+          callback(value, oldValue);
+        } catch (e) {
+          console.error(`Observer error for ${key}:`, e);
+        }
+      });
+    }
+    this.observers["*"]?.forEach((callback) => {
+      try {
+        callback(key, value, oldValue);
+      } catch (e) {
+        console.error("Wildcard observer error:", e);
+      }
+    });
+  }
+  updateElement(element, value) {
+    const binding = element.getAttribute("data-bind");
+    if (!binding) return;
+    const bindings = binding.split("|");
+    bindings.forEach((b) => {
+      const parts = b.split(":");
+      const type = parts[0].trim();
+      const target = parts[1]?.trim();
+      switch (type) {
+        case "text":
+          if (element.textContent !== String(value ?? "")) {
+            element.textContent = value ?? "";
+          }
+          break;
+        case "html":
+          const sanitized = sanitizeHtml$1(value);
+          if (element.innerHTML !== sanitized) {
+            element.innerHTML = sanitized;
+          }
+          break;
+        case "value":
+          if (element.type === "checkbox") {
+            if (element.checked !== !!value) {
+              element.checked = !!value;
+            }
+          } else if (element.value !== String(value ?? "")) {
+            element.value = value ?? "";
+          }
+          break;
+        case "checked":
+          if (element.checked !== !!value) {
+            element.checked = !!value;
+          }
+          break;
+        case "disabled":
+          if (element.disabled !== !!value) {
+            element.disabled = !!value;
+          }
+          break;
+        case "hidden":
+          const display = value ? "none" : "";
+          if (element.style.display !== display) {
+            element.style.display = display;
+          }
+          break;
+        case "class":
+          if (target) {
+            if (value) {
+              element.classList.add(target);
+            } else {
+              element.classList.remove(target);
+            }
+          }
+          break;
+        case "style":
+          if (target && element.style[target] !== String(value ?? "")) {
+            element.style[target] = value ?? "";
+          }
+          break;
+        case "attr":
+          if (target) {
+            const current = element.getAttribute(target);
+            if (current !== String(value ?? "")) {
+              element.setAttribute(target, value ?? "");
+            }
+          }
+          break;
+        case "src":
+          if (element.src !== String(value ?? "")) {
+            element.src = value ?? "";
+          }
+          break;
+        case "href":
+          if (element.href !== String(value ?? "")) {
+            element.href = value ?? "";
+          }
+          break;
+        case "placeholder":
+          if (element.placeholder !== String(value ?? "")) {
+            element.placeholder = value ?? "";
+          }
+          break;
+      }
+    });
+  }
+  computed(name, deps, callback) {
+    this.computedProperties[name] = { deps, callback };
+    deps.forEach((dep) => {
+      this.pathTrie.insert(dep);
+    });
+    this.updateComputedProperty(name);
+  }
+  updateComputedProperty(name) {
+    const prop = this.computedProperties[name];
+    if (!prop) return;
+    try {
+      const values2 = prop.deps.map((dep) => this.get(dep));
+      const result = prop.callback(...values2);
+      this.set(name, result, true);
+    } catch (e) {
+      console.error(`Computed error for ${name}:`, e);
+    }
+  }
+  load(data) {
+    Object.keys(data).forEach((key) => {
+      if (data[key] && typeof data[key] === "object" && !Array.isArray(data[key])) {
+        this.rawData[key] = this.wrapReactive(data[key], key);
+      } else {
+        this.rawData[key] = data[key];
+      }
+      this.queueUpdate(key, this.rawData[key]);
+    });
+    this.processComputed();
+  }
+  reset() {
+    this.rawData = {};
+    this.observers = {};
+    this.elements = {};
+    this.computedProperties = {};
+    this.pathTrie = new PathTrie();
+    this.updateQueue.clear();
+    this.snapshots = [];
+    this.createReactiveData();
+    this.bind();
+  }
+  persist(key, options = {}) {
+    const {
+      storage: storageType = "local",
+      debounce: debounce2 = 0,
+      version = 1,
+      encrypt = false,
+      encryptionKey = null
+    } = options;
+    const storage = storageType === "session" ? sessionStorage : localStorage;
+    this.persistedKeys.set(key, {
+      storage,
+      debounce: debounce2,
+      timeout: null,
+      version,
+      encrypt,
+      encryptionKey
+    });
+    const value = this.get(key);
+    if (value !== void 0) {
+      this._persistSave(key, value, storage, { version, encrypt, encryptionKey });
+    }
+    this.observe(key, (newValue) => {
+      const config2 = this.persistedKeys.get(key);
+      if (!config2) return;
+      if (config2.debounce > 0) {
+        if (config2.timeout) clearTimeout(config2.timeout);
+        config2.timeout = setTimeout(() => {
+          this._persistSave(key, newValue, config2.storage, {
+            version: config2.version,
+            encrypt: config2.encrypt,
+            encryptionKey: config2.encryptionKey
+          });
+        }, config2.debounce);
+      } else {
+        this._persistSave(key, newValue, config2.storage, {
+          version: config2.version,
+          encrypt: config2.encrypt,
+          encryptionKey: config2.encryptionKey
+        });
+      }
+    });
+  }
+  _persistSave(key, value, storage, options = {}) {
+    try {
+      const { version = 1, encrypt = false, encryptionKey = null } = options;
+      const dataToStore = {
+        value,
+        version,
+        timestamp: Date.now()
+      };
+      let serialized = JSON.stringify(dataToStore);
+      if (encrypt && encryptionKey) {
+        serialized = this._encrypt(serialized, encryptionKey);
+      }
+      this._ensureStorageCapacity(storage);
+      storage.setItem(`kupola:${key}`, serialized);
+    } catch (e) {
+      console.warn(`Failed to persist key ${key}:`, e);
+      if (e.name === "QuotaExceededError" && storage === localStorage) {
+        console.warn(`localStorage quota exceeded, trying sessionStorage for key ${key}`);
+        try {
+          sessionStorage.setItem(`kupola:${key}`, JSON.stringify({ value, version: 1 }));
+        } catch (e2) {
+          console.warn(`sessionStorage also failed for key ${key}:`, e2);
+        }
+      }
+    }
+  }
+  _ensureStorageCapacity(storage) {
+    try {
+      const testKey = `kupola:__storage_test__`;
+      storage.setItem(testKey, "test");
+      storage.removeItem(testKey);
+    } catch (e) {
+      if (e.name === "QuotaExceededError") {
+        this._cleanupOldStorage(storage);
+      }
+    }
+  }
+  _cleanupOldStorage(storage) {
+    const now2 = Date.now();
+    const maxAge = 30 * 24 * 60 * 60 * 1e3;
+    for (let i = 0; i < storage.length; i++) {
+      const key = storage.key(i);
+      if (key?.startsWith("kupola:")) {
+        try {
+          const data = JSON.parse(storage.getItem(key));
+          if (data.timestamp && now2 - data.timestamp > maxAge) {
+            storage.removeItem(key);
+          }
+        } catch (e) {
+          storage.removeItem(key);
+        }
+      }
+    }
+  }
+  _encrypt(text, key) {
+    if (!window.CryptoJS) {
+      console.warn("CryptoJS not available, encryption skipped");
+      return text;
+    }
+    return window.CryptoJS.AES.encrypt(text, key).toString();
+  }
+  _decrypt(ciphertext, key) {
+    if (!window.CryptoJS) {
+      console.warn("CryptoJS not available, decryption skipped");
+      return ciphertext;
+    }
+    try {
+      const bytes = window.CryptoJS.AES.decrypt(ciphertext, key);
+      return bytes.toString(window.CryptoJS.enc.Utf8);
+    } catch (e) {
+      console.warn("Decryption failed:", e);
+      return ciphertext;
+    }
+  }
+  unpersist(key) {
+    const config2 = this.persistedKeys.get(key);
+    if (config2) {
+      if (config2.timeout) clearTimeout(config2.timeout);
+      config2.storage.removeItem(`kupola:${key}`);
+      this.persistedKeys.delete(key);
+    }
+  }
+  loadPersisted(options = {}) {
+    const persisted = {};
+    const { encryptionKey = null } = options;
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith("kupola:")) {
+        const dataKey = key.replace("kupola:", "");
+        try {
+          const stored = localStorage.getItem(key);
+          let parsed;
+          if (encryptionKey) {
+            const decrypted = this._decrypt(stored, encryptionKey);
+            parsed = JSON.parse(decrypted);
+          } else {
+            parsed = JSON.parse(stored);
+          }
+          if (parsed.version !== void 0 && parsed.version !== options.version) {
+            console.debug(`Skipping outdated data for ${dataKey} (version ${parsed.version})`);
+            continue;
+          }
+          persisted[dataKey] = parsed.value !== void 0 ? parsed.value : parsed;
+        } catch (e) {
+          console.warn(`Failed to load persisted key ${dataKey}:`, e);
+        }
+      }
+    }
+    for (let i = 0; i < sessionStorage.length; i++) {
+      const key = sessionStorage.key(i);
+      if (key?.startsWith("kupola:")) {
+        const dataKey = key.replace("kupola:", "");
+        try {
+          const stored = sessionStorage.getItem(key);
+          let parsed;
+          if (encryptionKey) {
+            const decrypted = this._decrypt(stored, encryptionKey);
+            parsed = JSON.parse(decrypted);
+          } else {
+            parsed = JSON.parse(stored);
+          }
+          if (parsed.version !== void 0 && parsed.version !== options.version) {
+            console.debug(`Skipping outdated data for ${dataKey} (version ${parsed.version})`);
+            continue;
+          }
+          persisted[dataKey] = parsed.value !== void 0 ? parsed.value : parsed;
+        } catch (e) {
+        }
+      }
+    }
+    if (Object.keys(persisted).length > 0) {
+      this.load(persisted);
+    }
+    return persisted;
+  }
+  _clone(data) {
+    if (typeof structuredClone === "function") {
+      try {
+        return structuredClone(data);
+      } catch (e) {
+        console.warn("structuredClone failed, falling back to JSON:", e);
+      }
+    }
+    return JSON.parse(JSON.stringify(data));
+  }
+  snapshot() {
+    const snapshot = this._clone(this.rawData);
+    this.snapshots.push(snapshot);
+    if (this.snapshots.length > this.snapshotLimit) {
+      this.snapshots.shift();
+    }
+    return this.snapshots.length - 1;
+  }
+  rollback(index = -1) {
+    if (this.snapshots.length === 0) return false;
+    const snapshotIndex = index >= 0 ? index : this.snapshots.length - 1;
+    const snapshot = this.snapshots[snapshotIndex];
+    if (!snapshot) return false;
+    this.rawData = this._clone(snapshot);
+    this.createReactiveData();
+    Object.keys(this.rawData).forEach((key) => {
+      this.queueUpdate(key, this.rawData[key]);
+    });
+    this.processComputed();
+    return true;
+  }
+  getSnapshotCount() {
+    return this.snapshots.length;
+  }
+  clearSnapshots() {
+    this.snapshots = [];
+  }
+  serializeForm(formElement) {
+    const data = {};
+    formElement.querySelectorAll("input, select, textarea").forEach((element) => {
+      const name = element.getAttribute("data-bind");
+      if (!name) return;
+      const parts = name.split(":");
+      const key = parts[1]?.trim();
+      if (!key) return;
+      if (element.type === "checkbox") {
+        if (!data[key]) data[key] = [];
+        if (element.checked) {
+          data[key].push(element.value);
+        }
+      } else if (element.type === "radio") {
+        if (element.checked) {
+          data[key] = element.value;
+        }
+      } else {
+        data[key] = element.value;
+      }
+    });
+    return data;
+  }
+  fillForm(formElement, data) {
+    Object.keys(data).forEach((key) => {
+      formElement.querySelectorAll('[data-bind*=":' + key + '"]').forEach((element) => {
+        if (element.type === "checkbox") {
+          element.checked = Array.isArray(data[key]) ? data[key].includes(element.value) : !!data[key];
+        } else if (element.type === "radio") {
+          element.checked = element.value === data[key];
+        } else {
+          element.value = data[key] ?? "";
+        }
+      });
+    });
+  }
+  createReactive(target, path = "") {
+    if (target[REACTIVE_SYMBOLS.isReactive]) return target;
+    if (this._proxyCache.has(target)) {
+      return this._proxyCache.get(target);
+    }
+    const handler = {
+      get: (target2, key, receiver2) => {
+        if (key === "__raw__") return target2;
+        if (key === REACTIVE_SYMBOLS.parent || key === "__parent__") return target2[REACTIVE_SYMBOLS.parent];
+        if (key === REACTIVE_SYMBOLS.path || key === "__path__") return target2[REACTIVE_SYMBOLS.path];
+        if (key === REACTIVE_SYMBOLS.isReactive || key === "__isReactive__") return true;
+        const result = Reflect.get(target2, key, receiver2);
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+          return this.wrapReactive(result, `${target2[REACTIVE_SYMBOLS.path]}${target2[REACTIVE_SYMBOLS.path] ? "." : ""}${key}`);
+        }
+        return result;
+      },
+      set: (target2, key, value, receiver2) => {
+        if (key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive || key === "__parent__" || key === "__path__" || key === "__isReactive__") {
+          return true;
+        }
+        const oldValue = Reflect.get(target2, key, receiver2);
+        const result = Reflect.set(target2, key, value, receiver2);
+        const fullPath = `${target2[REACTIVE_SYMBOLS.path]}${target2[REACTIVE_SYMBOLS.path] ? "." : ""}${key}`;
+        this.notify(fullPath, value, oldValue);
+        this.queueUpdate(fullPath, value);
+        return result;
+      },
+      deleteProperty: (target2, key) => {
+        if (key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive) {
+          return false;
+        }
+        const oldValue = Reflect.get(target2, key);
+        const result = Reflect.deleteProperty(target2, key);
+        const fullPath = `${target2[REACTIVE_SYMBOLS.path]}${target2[REACTIVE_SYMBOLS.path] ? "." : ""}${key}`;
+        this.notify(fullPath, void 0, oldValue);
+        this.queueUpdate(fullPath, void 0);
+        return result;
+      },
+      has: (target2, key) => {
+        if (key === "__raw__" || key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive || key === "__parent__" || key === "__path__" || key === "__isReactive__") {
+          return true;
+        }
+        return key in target2;
+      },
+      ownKeys: (target2) => {
+        return Reflect.ownKeys(target2).filter(
+          (key) => key !== REACTIVE_SYMBOLS.parent && key !== REACTIVE_SYMBOLS.path && key !== REACTIVE_SYMBOLS.isReactive
+        );
+      },
+      getOwnPropertyDescriptor: (target2, key) => {
+        if (key === REACTIVE_SYMBOLS.parent || key === REACTIVE_SYMBOLS.path || key === REACTIVE_SYMBOLS.isReactive) {
+          return {
+            configurable: false,
+            enumerable: false,
+            writable: false,
+            value: target2[key]
+          };
+        }
+        return Reflect.getOwnPropertyDescriptor(target2, key);
+      }
+    };
+    const proxy = new Proxy(target, handler);
+    target[REACTIVE_SYMBOLS.parent] = target;
+    target[REACTIVE_SYMBOLS.path] = path;
+    target[REACTIVE_SYMBOLS.isReactive] = true;
+    this._proxyCache.set(target, proxy);
+    Object.keys(target).forEach((key) => {
+      if (target[key] && typeof target[key] === "object" && !Array.isArray(target[key])) {
+        target[key] = this.wrapReactive(target[key], `${path}${path ? "." : ""}${key}`);
+      }
+    });
+    return proxy;
+  }
+  bind() {
+    document.querySelectorAll("[data-bind]").forEach((element) => {
+      this._bindElement(element);
+    });
+    if (!this._mutationObserver) {
+      this._isObserving = false;
+      this._mutationObserver = new MutationObserver((mutations) => {
+        if (this._isObserving) return;
+        this._isObserving = true;
+        try {
+          mutations.forEach((mutation) => {
+            mutation.addedNodes.forEach((node) => {
+              if (node.nodeType === Node.ELEMENT_NODE) {
+                const bindElements = node.querySelectorAll("[data-bind]");
+                bindElements.forEach((element) => this._bindElement(element));
+                if (node.hasAttribute && node.hasAttribute("data-bind")) {
+                  this._bindElement(node);
+                }
+              }
+            });
+          });
+        } finally {
+          this._isObserving = false;
+        }
+      });
+      this._mutationObserver.observe(document.body, {
+        childList: true,
+        subtree: true
+      });
+    }
+  }
+  _bindElement(element) {
+    const binding = element.getAttribute("data-bind");
+    const parts = binding.split(":");
+    parts[0].split("|")[0].trim();
+    const key = parts[1]?.trim();
+    if (!key) return;
+    this.pathTrie.insert(key);
+    if (!this.elements[key]) {
+      this.elements[key] = [];
+    }
+    if (!this.elements[key].includes(element)) {
+      this.elements[key].push(element);
+    }
+    if (element.tagName === "INPUT" || element.tagName === "TEXTAREA" || element.tagName === "SELECT") {
+      const existingHandler = element.__kupolaBindHandler;
+      if (existingHandler) {
+        element.removeEventListener("input", existingHandler);
+      }
+      const handler = () => {
+        const value = element.type === "checkbox" ? element.checked : element.value;
+        if (key.includes(".")) {
+          this.setNested(key, value);
+        } else {
+          this.set(key, value);
+        }
+      };
+      element.__kupolaBindHandler = handler;
+      element.addEventListener("input", handler);
+    }
+    if (this.rawData[key] !== void 0) {
+      this.updateElement(element, this.rawData[key]);
+    }
+  }
+  destroy() {
+    if (this._mutationObserver) {
+      this._mutationObserver.disconnect();
+      this._mutationObserver = null;
+    }
+    Object.values(this.elements).forEach((elements) => {
+      elements.forEach((element) => {
+        const handler = element.__kupolaBindHandler;
+        if (handler) {
+          element.removeEventListener("input", handler);
+          delete element.__kupolaBindHandler;
+        }
+      });
+    });
+    this.persistedKeys.forEach((config2, key) => {
+      if (config2.timeout) clearTimeout(config2.timeout);
+    });
+    this.persistedKeys.clear();
+    this.rawData = {};
+    this.observers = {};
+    this.elements = {};
+    this.computedProperties = {};
+    this.pathTrie = new PathTrie();
+    this.updateQueue.clear();
+    this.snapshots = [];
+  }
+}
+class KupolaStore {
+  constructor(name, options = {}) {
+    this.name = name;
+    this._stateKey = `__store_${name}__`;
+    const initialState = options.state ? options.state() : {};
+    this.getters = options.getters || {};
+    this.actions = options.actions || {};
+    this.mutations = options.mutations || {};
+    this.observers = {};
+    if (kupolaData) {
+      kupolaData.set(this._stateKey, initialState);
+      this.state = kupolaData.data?.[this._stateKey] || kupolaData.createReactive(initialState, this._stateKey);
+      kupolaData.observe(this._stateKey, (newState) => {
+        this.notify(newState);
+      });
+    } else {
+      this.state = initialState;
+    }
+    this._bindGetters();
+    this._bindActions();
+  }
+  _bindGetters() {
+    Object.keys(this.getters).forEach((name) => {
+      Object.defineProperty(this, name, {
+        get: () => this.getters[name](this.state),
+        enumerable: true
+      });
+    });
+  }
+  _bindActions() {
+    Object.keys(this.actions).forEach((name) => {
+      this[name] = (...args) => {
+        return this.actions[name]({
+          state: this.state,
+          commit: this.commit.bind(this),
+          dispatch: this.dispatch.bind(this),
+          getters: this
+        }, ...args);
+      };
+    });
+  }
+  commit(type, payload) {
+    const mutation = this.mutations[type];
+    if (!mutation) {
+      console.warn(`Mutation ${type} not found in store ${this.name}`);
+      return;
+    }
+    mutation(this.state, payload);
+  }
+  dispatch(type, payload) {
+    const action = this.actions[type];
+    if (!action) {
+      console.warn(`Action ${type} not found in store ${this.name}`);
+      return;
+    }
+    return action({
+      state: this.state,
+      commit: this.commit.bind(this),
+      dispatch: this.dispatch.bind(this),
+      getters: this
+    }, payload);
+  }
+  observe(callback) {
+    if (!this.observers["*"]) {
+      this.observers["*"] = [];
+    }
+    this.observers["*"].push(callback);
+    return callback;
+  }
+  unobserve(callback) {
+    if (this.observers["*"]) {
+      this.observers["*"] = this.observers["*"].filter((cb) => cb !== callback);
+    }
+  }
+  notify(newState) {
+    if (this.observers["*"]) {
+      this.observers["*"].forEach((callback) => {
+        try {
+          callback(newState);
+        } catch (e) {
+          console.error(`Observer error for store ${this.name}:`, e);
+        }
+      });
+    }
+    if (kupolaData) {
+      kupolaData.set(this.name, newState);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      state: this.state,
+      getters: Object.keys(this.getters).reduce((acc, name) => {
+        acc[name] = this[name];
+        return acc;
+      }, {})
+    };
+  }
+}
+class KupolaStoreManager {
+  constructor() {
+    this.stores = /* @__PURE__ */ new Map();
+  }
+  createStore(name, options) {
+    const store = new KupolaStore(name, options);
+    this.stores.set(name, store);
+    return store;
+  }
+  getStore(name) {
+    return this.stores.get(name);
+  }
+  registerStore(store) {
+    if (store instanceof KupolaStore) {
+      this.stores.set(store.name, store);
+    }
+  }
+  dispose() {
+    this.stores.clear();
+  }
+}
+class KupolaEventBus {
+  constructor() {
+    this.events = {};
+    this.delegatedEvents = {};
+    this.eventListeners = {};
+  }
+  on(eventName, callback) {
+    if (!this.events[eventName]) {
+      this.events[eventName] = [];
+    }
+    this.events[eventName].push(callback);
+    return callback;
+  }
+  off(eventName, callback) {
+    if (this.events[eventName]) {
+      this.events[eventName] = this.events[eventName].filter((cb) => cb !== callback);
+    }
+  }
+  emit(eventName, data) {
+    if (this.events[eventName]) {
+      this.events[eventName].forEach((callback) => {
+        try {
+          callback(data);
+        } catch (e) {
+          console.error(`Error in event handler for ${eventName}:`, e);
+        }
+      });
+    }
+    this.events["*"]?.forEach((callback) => {
+      try {
+        callback(eventName, data);
+      } catch (e) {
+        console.error(`Error in wildcard event handler:`, e);
+      }
+    });
+  }
+  once(eventName, callback) {
+    const onceCallback = (data) => {
+      callback(data);
+      this.off(eventName, onceCallback);
+    };
+    this.on(eventName, onceCallback);
+    return onceCallback;
+  }
+  delegate(selector, eventName, callback) {
+    if (!this.delegatedEvents[eventName]) {
+      this.delegatedEvents[eventName] = [];
+      const listener = (e) => {
+        this.delegatedEvents[eventName].forEach(({ selector: sel, cb }) => {
+          if (e.target.matches(sel) || e.target.closest(sel)) {
+            cb(e);
+          }
+        });
+      };
+      document.addEventListener(eventName, listener);
+      this.eventListeners[eventName] = listener;
+    }
+    this.delegatedEvents[eventName].push({ selector, cb: callback });
+    return callback;
+  }
+  undelegate(selector, eventName) {
+    if (this.delegatedEvents[eventName]) {
+      this.delegatedEvents[eventName] = this.delegatedEvents[eventName].filter(
+        (item) => item.selector !== selector
+      );
+      if (this.delegatedEvents[eventName].length === 0) {
+        const listener = this.eventListeners[eventName];
+        if (listener) {
+          document.removeEventListener(eventName, listener);
+          delete this.eventListeners[eventName];
+        }
+        delete this.delegatedEvents[eventName];
+      }
+    }
+  }
+  destroy() {
+    Object.entries(this.eventListeners).forEach(([eventName, listener]) => {
+      document.removeEventListener(eventName, listener);
+    });
+    this.events = {};
+    this.delegatedEvents = {};
+    this.eventListeners = {};
+  }
+}
+function ref(initialValue = null) {
+  const refObj = {
+    _value: initialValue,
+    _subscribers: /* @__PURE__ */ new Set()
+  };
+  Object.defineProperty(refObj, "value", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return refObj._value;
+    },
+    set(newValue) {
+      if (newValue !== refObj._value) {
+        refObj._value = newValue;
+        refObj._subscribers.forEach((sub) => sub(newValue));
+      }
+    }
+  });
+  refObj.subscribe = (callback) => {
+    refObj._subscribers.add(callback);
+    return {
+      unsubscribe() {
+        refObj._subscribers.delete(callback);
+      }
+    };
+  };
+  return refObj;
+}
+const kupolaData = new KupolaDataBind();
+const kupolaEvents = new KupolaEventBus();
+const kupolaStoreManager = new KupolaStoreManager();
+function createStore(name, options) {
+  return kupolaStoreManager.createStore(name, options);
+}
+function getStore(name) {
+  return kupolaStoreManager.getStore(name);
+}
+const config = {
+  paths: {
+    icons: "/icons/",
+    base: "/"
+  },
+  theme: {
+    default: "dark",
+    brand: "zengqing"
+  },
+  i18n: {
+    locale: "zh-CN",
+    fallbackLocale: "en-US"
+  },
+  http: {
+    baseURL: "",
+    timeout: 1e4,
+    headers: {},
+    withCredentials: false
+  },
+  zIndex: {
+    modal: 1e3,
+    dropdown: 2e3,
+    tooltip: 2100,
+    popover: 2200,
+    datepicker: 2300,
+    message: 3e3,
+    notification: 3100,
+    loading: 5e3
+  },
+  ui: {
+    defaultSize: "md",
+    modal: {
+      backdropClick: true
+    },
+    dropdown: {
+      closeOnClick: true
+    },
+    datepicker: {
+      weekStart: 1
+    },
+    tooltip: {
+      delay: 300
+    }
+  },
+  performance: {
+    lazyLoad: false,
+    debounceDelay: 200,
+    throttleDelay: 100,
+    animationEnabled: true
+  },
+  security: {
+    xssProtection: true,
+    sanitizeHtml: {
+      enabled: true,
+      allowedTags: ["b", "i", "u", "em", "strong", "a", "br", "p", "span", "div", "img"],
+      allowedAttributes: {
+        "a": ["href", "target", "rel"],
+        "img": ["src", "alt", "width", "height"],
+        "span": ["class", "style"],
+        "div": ["class", "style"]
+      }
+    },
+    maskData: {
+      enabled: true,
+      patterns: {
+        phone: { regex: "^(\\d{3})\\d{4}(\\d{4})$", replace: "$1****$2" },
+        email: { regex: "^(.)(.*)(@.*)$", replace: "$1***$3" },
+        idCard: { regex: "^(\\d{6})\\d{8}(\\d{4})$", replace: "$1********$2" },
+        bankCard: { regex: "^(\\d{4})\\d{8}(\\d{4})$", replace: "$1 **** **** $2" }
+      }
+    },
+    secureId: {
+      length: 16,
+      charset: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+    }
+  },
+  message: {
+    duration: 3e3,
+    position: "top-right",
+    maxCount: 5
+  },
+  notification: {
+    duration: 4500,
+    position: "top-right"
+  },
+  validation: {
+    defaultRules: [],
+    showErrors: true,
+    trigger: "blur"
+  },
+  components: {
+    autoInit: true,
+    silentErrors: false
+  }
+};
+const configChangeListeners = [];
+function loadConfigFromGlobal() {
+  if (typeof window !== "undefined" && window.kupolaConfig) {
+    try {
+      mergeDeep(config, window.kupolaConfig);
+      notifyConfigChange();
+    } catch (e) {
+      console.warn("[Kupola] Failed to parse window.kupolaConfig:", e);
+    }
+  }
+}
+function notifyConfigChange() {
+  configChangeListeners.forEach((listener) => {
+    try {
+      listener(config);
+    } catch (e) {
+      console.warn("[Kupola] Error in config change listener:", e);
+    }
+  });
+}
+function onConfigChange(listener) {
+  if (typeof listener === "function") {
+    configChangeListeners.push(listener);
+  }
+}
+function offConfigChange(listener) {
+  const index = configChangeListeners.indexOf(listener);
+  if (index > -1) {
+    configChangeListeners.splice(index, 1);
+  }
+}
+if (typeof document !== "undefined") {
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", loadConfigFromGlobal);
+  } else {
+    loadConfigFromGlobal();
+  }
+}
+function setConfig(options) {
+  mergeDeep(config, options);
+  notifyConfigChange();
+}
+function getConfig(key) {
+  if (!key) {
+    return config;
+  }
+  return getNestedValue(config, key);
+}
+function getIconsPath() {
+  return config.paths.base + config.paths.icons.replace(/^\//, "");
+}
+function getBasePath() {
+  return config.paths.base;
+}
+function getDefaultTheme() {
+  return config.theme.default;
+}
+function getDefaultBrand() {
+  return config.theme.brand;
+}
+function getHttpConfig() {
+  return config.http;
+}
+function getUiConfig() {
+  return config.ui;
+}
+function getZIndexConfig() {
+  return config.zIndex;
+}
+function getSecurityConfig() {
+  return config.security;
+}
+function getPerformanceConfig() {
+  return config.performance;
+}
+function getMessageConfig() {
+  return config.message;
+}
+function getNotificationConfig() {
+  return config.notification;
+}
+function getValidationConfig() {
+  return config.validation;
+}
+function mergeDeep(target, source) {
+  for (const key in source) {
+    if (source[key] instanceof Object && key in target && target[key] instanceof Object) {
+      mergeDeep(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function getNestedValue(obj, key) {
+  return key.split(".").reduce((o, k) => (o && o[k]) !== void 0 ? o[k] : void 0, obj);
+}
+const THEME_KEY = "kupola-theme";
+const BRAND_KEY = "kupola-brand";
+onConfigChange((newConfig) => {
+  const toggleBtn = document.querySelector("[data-theme-toggle]");
+  if (toggleBtn) {
+    const currentTheme = getTheme();
+    updateThemeIcon(toggleBtn);
+    setTheme(currentTheme);
+  }
+});
+const BRAND_OPTIONS = [
+  { id: "green", name: "翠绿", color: "#32F08C" },
+  { id: "xionghuang", name: "雄黄", color: "#FF9900" },
+  { id: "jianghuang", name: "姜黄", color: "#E2C027" },
+  { id: "lanlv", name: "蓝绿", color: "#12A182" },
+  { id: "kongquelan", name: "孔雀蓝", color: "#0EB0C9" },
+  { id: "meiguizi", name: "玫瑰紫", color: "#BA2F7B" },
+  { id: "shihong", name: "柿红", color: "#F2481B" },
+  { id: "quhong", name: "紫云", color: "#B1A6CC" },
+  { id: "shanchahong", name: "山茶红", color: "#F05A46" },
+  { id: "zengqing", name: "曾青", color: "#535164" },
+  { id: "roulan", name: "柔蓝", color: "#106898" }
+];
+function getTheme() {
+  return localStorage.getItem(THEME_KEY) || getDefaultTheme();
+}
+function setTheme(theme) {
+  if (theme !== "dark" && theme !== "light") return;
+  var root = document.documentElement;
+  if (root.hasAttribute("data-kupola-theme-preloaded")) {
+    root.style.removeProperty("--bg-base-default");
+    root.style.removeProperty("--text-default");
+    root.removeAttribute("data-kupola-theme-preloaded");
+  }
+  root.setAttribute("data-theme", theme);
+  localStorage.setItem(THEME_KEY, theme);
+  const toggleBtn = document.querySelector("[data-theme-toggle]");
+  if (toggleBtn) {
+    toggleBtn.setAttribute("data-current-theme", theme);
+    updateThemeIcon(toggleBtn);
+  }
+}
+function getBrand() {
+  return localStorage.getItem(BRAND_KEY) || getDefaultBrand();
+}
+function setBrand(brandId) {
+  const brand = BRAND_OPTIONS.find((b) => b.id === brandId);
+  if (!brand) return;
+  document.documentElement.setAttribute("data-brand", brandId);
+  localStorage.setItem(BRAND_KEY, brandId);
+  const brandToggle = document.querySelector("[data-brand-toggle]");
+  if (brandToggle) {
+    brandToggle.setAttribute("data-current-brand", brandId);
+    const brandIcon = brandToggle.querySelector(".brand-icon");
+    if (brandIcon) {
+      brandIcon.style.backgroundColor = brand.color;
+    }
+    const brandName = brandToggle.querySelector(".brand-name");
+    if (brandName) {
+      brandName.textContent = brand.name;
+    }
+  }
+  const brandButtons = document.querySelectorAll("[data-brand-btn]");
+  brandButtons.forEach((btn) => {
+    if (btn.getAttribute("data-brand-btn") === brandId) {
+      btn.classList.add("is-active");
+    } else {
+      btn.classList.remove("is-active");
+    }
+  });
+}
+function updateThemeIcon(toggleBtn) {
+  const iconEl = toggleBtn.querySelector(".theme-icon");
+  if (iconEl) {
+    const currentTheme = getTheme();
+    const iconsPath = getIconsPath();
+    iconEl.src = currentTheme === "dark" ? iconsPath + "sun.svg" : iconsPath + "moon.svg";
+  }
+}
+function _themeToggleHandler(e) {
+  e.preventDefault();
+  const currentTheme = getTheme();
+  const newTheme = currentTheme === "dark" ? "light" : "dark";
+  setTheme(newTheme);
+}
+function initTheme() {
+  var root = document.documentElement;
+  if (root.hasAttribute("data-kupola-theme-preloaded")) {
+    root.style.removeProperty("--bg-base-default");
+    root.style.removeProperty("--text-default");
+    root.removeAttribute("data-kupola-theme-preloaded");
+  }
+  const toggleBtn = document.querySelector("[data-theme-toggle]");
+  const savedTheme = getTheme();
+  setTheme(savedTheme);
+  const savedBrand = getBrand();
+  setBrand(savedBrand);
+  if (toggleBtn) {
+    updateThemeIcon(toggleBtn);
+    toggleBtn.removeEventListener("click", _themeToggleHandler);
+    toggleBtn.addEventListener("click", _themeToggleHandler);
+  }
+  let brandPicker = document.getElementById("brand-picker");
+  if (!brandPicker) {
+    brandPicker = document.createElement("div");
+    brandPicker.id = "brand-picker";
+    brandPicker.style.position = "fixed";
+    brandPicker.style.top = "64px";
+    brandPicker.style.right = "16px";
+    brandPicker.style.zIndex = "9998";
+    brandPicker.style.display = "none";
+    brandPicker.style.padding = "12px";
+    brandPicker.style.width = "200px";
+    brandPicker.style.gridTemplateColumns = "repeat(3, 1fr)";
+    brandPicker.style.gap = "6px";
+    brandPicker.style.backgroundColor = "var(--bg-base-secondary)";
+    brandPicker.style.border = "1px solid var(--border-neutral-l1)";
+    brandPicker.style.borderRadius = "8px";
+    brandPicker.style.boxShadow = "0 4px 20px rgba(0, 0, 0, 0.2)";
+    brandPicker.style.overflow = "hidden";
+    BRAND_OPTIONS.forEach((brand) => {
+      const btn = document.createElement("button");
+      btn.setAttribute("data-brand-btn", brand.id);
+      btn.style.display = "flex";
+      btn.style.justifyContent = "center";
+      btn.style.alignItems = "center";
+      btn.style.height = "60px";
+      btn.style.backgroundColor = brand.color;
+      btn.style.color = ["#32F08C", "#FF9900", "#E2C027", "#0EB0C9", "#B1A6CC"].includes(brand.color) ? "#0C0C0D" : "#FFFFFF";
+      btn.style.fontWeight = "500";
+      btn.style.borderRadius = "4px";
+      btn.style.border = "none";
+      btn.style.cursor = "pointer";
+      btn.style.margin = "0";
+      btn.style.padding = "0";
+      btn.textContent = brand.name;
+      brandPicker.appendChild(btn);
+    });
+    document.body.appendChild(brandPicker);
+  }
+  const brandToggle = document.querySelector("[data-brand-toggle]");
+  if (brandToggle && brandPicker) {
+    brandToggle.onclick = function(e) {
+      e.stopPropagation();
+      e.preventDefault();
+      const isHidden = brandPicker.style.display === "none";
+      brandPicker.style.display = isHidden ? "grid" : "none";
+      if (isHidden) {
+        setTimeout(() => {
+          document.addEventListener("click", closeBrandPicker, true);
+        }, 0);
+      } else {
+        document.removeEventListener("click", closeBrandPicker, true);
+      }
+    };
+    brandPicker.onclick = function(e) {
+      e.stopPropagation();
+    };
+  }
+  function closeBrandPicker(e) {
+    if (brandPicker && brandToggle) {
+      if (!brandPicker.contains(e.target) && !brandToggle.contains(e.target)) {
+        brandPicker.style.display = "none";
+        document.removeEventListener("click", closeBrandPicker, true);
+      }
+    }
+  }
+  const brandButtons = document.querySelectorAll("[data-brand-btn]");
+  brandButtons.forEach((btn) => {
+    btn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      const brandId = btn.getAttribute("data-brand-btn");
+      setBrand(brandId);
+      if (brandPicker) {
+        brandPicker.style.display = "none";
+      }
+    });
+  });
+}
+function createThemeToggle() {
+  const btn = document.createElement("button");
+  btn.setAttribute("data-theme-toggle", "");
+  btn.setAttribute("data-current-theme", getTheme());
+  btn.className = "ds-btn ds-btn--ghost ds-btn--sm ds-btn--icon";
+  btn.style.position = "fixed";
+  btn.style.top = "16px";
+  btn.style.right = "16px";
+  btn.style.zIndex = "9999";
+  const icon = document.createElement("img");
+  icon.className = "theme-icon";
+  const iconsPath = getIconsPath();
+  icon.src = getTheme() === "dark" ? iconsPath + "sun.svg" : iconsPath + "moon.svg";
+  icon.width = 14;
+  icon.height = 14;
+  icon.alt = "Toggle theme";
+  btn.appendChild(icon);
+  document.body.appendChild(btn);
+  btn.onclick = function(e) {
+    e.preventDefault();
+    const currentTheme = getTheme();
+    const newTheme = currentTheme === "dark" ? "light" : "dark";
+    setTheme(newTheme);
+  };
+  return btn;
+}
+function createBrandPicker() {
+  const container = document.createElement("div");
+  container.id = "brand-picker-auto";
+  container.style.position = "fixed";
+  container.style.top = "56px";
+  container.style.right = "16px";
+  container.style.zIndex = "9998";
+  container.style.display = "none";
+  container.style.padding = "12px";
+  container.style.width = "200px";
+  container.style.gridTemplateColumns = "repeat(3, 1fr)";
+  container.style.gap = "6px";
+  container.style.backgroundColor = "var(--bg-base-secondary)";
+  container.style.border = "1px solid var(--border-neutral-l1)";
+  container.style.borderRadius = "8px";
+  container.style.boxShadow = "0 4px 20px rgba(0, 0, 0, 0.2)";
+  container.style.overflow = "hidden";
+  BRAND_OPTIONS.forEach((brand) => {
+    const btn = document.createElement("button");
+    btn.setAttribute("data-brand-btn", brand.id);
+    btn.style.display = "flex";
+    btn.style.justifyContent = "center";
+    btn.style.alignItems = "center";
+    btn.style.height = "60px";
+    btn.style.backgroundColor = brand.color;
+    btn.style.color = ["#32F08C", "#FF9900", "#E2C027", "#0EB0C9", "#B1A6CC"].includes(brand.color) ? "#0C0C0D" : "#FFFFFF";
+    btn.style.fontWeight = "500";
+    btn.style.borderRadius = "4px";
+    btn.style.border = "none";
+    btn.style.cursor = "pointer";
+    btn.style.margin = "0";
+    btn.style.padding = "0";
+    btn.textContent = brand.name;
+    container.appendChild(btn);
+  });
+  document.body.appendChild(container);
+  const toggleBtn = document.createElement("button");
+  toggleBtn.setAttribute("data-brand-toggle", "");
+  toggleBtn.setAttribute("data-current-brand", getBrand());
+  toggleBtn.className = "ds-btn ds-btn--ghost ds-btn--sm";
+  toggleBtn.style.position = "fixed";
+  toggleBtn.style.top = "16px";
+  toggleBtn.style.right = "56px";
+  toggleBtn.style.zIndex = "9999";
+  toggleBtn.style.display = "flex";
+  toggleBtn.style.alignItems = "center";
+  toggleBtn.style.gap = "6px";
+  const brandIcon = document.createElement("span");
+  brandIcon.className = "brand-icon";
+  brandIcon.style.width = "12px";
+  brandIcon.style.height = "12px";
+  brandIcon.style.borderRadius = "50%";
+  brandIcon.style.backgroundColor = BRAND_OPTIONS.find((b) => b.id === getBrand()).color;
+  const brandName = document.createElement("span");
+  brandName.className = "brand-name";
+  brandName.style.fontSize = "11px";
+  brandName.textContent = BRAND_OPTIONS.find((b) => b.id === getBrand()).name;
+  toggleBtn.appendChild(brandIcon);
+  toggleBtn.appendChild(brandName);
+  document.body.appendChild(toggleBtn);
+  toggleBtn.onclick = function(e) {
+    e.stopPropagation();
+    e.preventDefault();
+    const isHidden = container.style.display === "none";
+    container.style.display = isHidden ? "grid" : "none";
+    if (isHidden) {
+      setTimeout(() => {
+        document.addEventListener("click", closeBrandPickerAuto, true);
+      }, 0);
+    } else {
+      document.removeEventListener("click", closeBrandPickerAuto, true);
+    }
+  };
+  container.onclick = function(e) {
+    e.stopPropagation();
+  };
+  function closeBrandPickerAuto(e) {
+    if (!container.contains(e.target) && !toggleBtn.contains(e.target)) {
+      container.style.display = "none";
+      document.removeEventListener("click", closeBrandPickerAuto, true);
+    }
+  }
+  const brandButtons = container.querySelectorAll("[data-brand-btn]");
+  brandButtons.forEach((btn) => {
+    btn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      const brandId = btn.getAttribute("data-brand-btn");
+      setBrand(brandId);
+      container.style.display = "none";
+    });
+  });
+  return { toggleBtn, container };
+}
+function sanitizeHtml(html, options = {}) {
+  const securityConfig = getSecurityConfig();
+  const sanitizeConfig = securityConfig?.sanitizeHtml || {};
+  if (!sanitizeConfig.enabled && !options.force) {
+    return html;
+  }
+  const allowedTags = options.allowedTags || sanitizeConfig.allowedTags || [];
+  const allowedAttributes = options.allowedAttributes || sanitizeConfig.allowedAttributes || {};
+  if (typeof html !== "string") {
+    return html;
+  }
+  const domParser = new DOMParser();
+  const doc = domParser.parseFromString(html, "text/html");
+  const elements = doc.body.querySelectorAll("*");
+  elements.forEach((element) => {
+    const tagName = element.tagName.toLowerCase();
+    if (!allowedTags.includes(tagName)) {
+      element.remove();
+      return;
+    }
+    Array.from(element.attributes).forEach((attr) => {
+      const attrName = attr.name.toLowerCase();
+      const tagAllowedAttrs = allowedAttributes[tagName] || [];
+      if (!tagAllowedAttrs.includes(attrName)) {
+        element.removeAttribute(attr.name);
+      }
+    });
+  });
+  return doc.body.innerHTML;
+}
+function escapeHtml(text) {
+  if (typeof text !== "string") {
+    return text;
+  }
+  const div = document.createElement("div");
+  div.textContent = text;
+  return div.innerHTML;
+}
+function stripHtml(html) {
+  if (typeof html !== "string") {
+    return html;
+  }
+  const domParser = new DOMParser();
+  const doc = domParser.parseFromString(html, "text/html");
+  return doc.body.textContent || "";
+}
+function maskData(value, type, options = {}) {
+  const securityConfig = getSecurityConfig();
+  const maskConfig = securityConfig?.maskData || {};
+  if (!maskConfig.enabled && !options.force) {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return value;
+  }
+  const patterns = options.patterns || maskConfig.patterns || {};
+  const pattern = patterns[type];
+  if (!pattern) {
+    return value;
+  }
+  const regex = typeof pattern.regex === "string" ? new RegExp(pattern.regex) : pattern.regex;
+  return String(value).replace(regex, pattern.replace);
+}
+function generateSecureId(length, prefix) {
+  const securityConfig = getSecurityConfig();
+  const secureIdConfig = securityConfig?.secureId || {};
+  const idLength = length || secureIdConfig.length || 16;
+  const charset = secureIdConfig.charset || "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  if (typeof crypto === "undefined" || !crypto.getRandomValues) {
+    let result2 = "";
+    for (let i = 0; i < idLength; i++) {
+      result2 += charset[Math.floor(Math.random() * charset.length)];
+    }
+    return prefix ? `${prefix}_${result2}` : result2;
+  }
+  const array = new Uint32Array(idLength);
+  crypto.getRandomValues(array);
+  let result = "";
+  for (let i = 0; i < idLength; i++) {
+    result += charset[array[i] % charset.length];
+  }
+  return prefix ? `${prefix}_${result}` : result;
+}
+class ComponentInitializerRegistry {
+  constructor() {
+    this.initializers = /* @__PURE__ */ new Map();
+    this.cleanupFunctions = /* @__PURE__ */ new Map();
+    this.processedElements = /* @__PURE__ */ new WeakSet();
+    this._dataAttrs = ["data-component"];
+    this._cssClasses = [];
+    this._cachedSelector = null;
+  }
+  /**
+   * Register a component initializer.
+   * @param {string} name - Component name
+   * @param {Function} initFn - Init function called with the DOM element
+   * @param {Function} [cleanupFn] - Optional cleanup/destroy function
+   * @param {Object} [options] - { dataAttribute, cssClass } for auto-discovery
+   */
+  register(name, initFn, cleanupFn = null, options = {}) {
+    this.initializers.set(name, initFn);
+    if (cleanupFn) {
+      this.cleanupFunctions.set(name, cleanupFn);
+    }
+    if (options.dataAttribute && !this._dataAttrs.includes(options.dataAttribute)) {
+      this._dataAttrs.push(options.dataAttribute);
+      this._cachedSelector = null;
+    }
+    if (options.cssClass && !this._cssClasses.includes(options.cssClass)) {
+      this._cssClasses.push(options.cssClass);
+      this._cachedSelector = null;
+    }
+  }
+  unregister(name) {
+    this.initializers.delete(name);
+    this.cleanupFunctions.delete(name);
+  }
+  has(name) {
+    return this.initializers.has(name);
+  }
+  get(name) {
+    return this.initializers.get(name);
+  }
+  _buildSelector() {
+    if (this._cachedSelector !== null) return this._cachedSelector;
+    const parts = this._dataAttrs.map((a) => `[${a}]`);
+    for (const cls of this._cssClasses) {
+      parts.push(`.${cls}`);
+    }
+    this._cachedSelector = parts.join(", ");
+    return this._cachedSelector;
+  }
+  /** Initialize a single DOM element if it matches a registered component. */
+  async initialize(element) {
+    if (this.processedElements.has(element)) return;
+    for (const attr of this._dataAttrs) {
+      const value = element.getAttribute(attr);
+      if (value !== null) {
+        const name = value || attr.replace("data-", "");
+        const initFn = this.initializers.get(name) || this.initializers.get(attr.replace("data-", ""));
+        if (initFn) {
+          try {
+            await initFn(element);
+            this.processedElements.add(element);
+          } catch (error) {
+            console.error(`[ComponentInitializerRegistry] Error initializing "${name}":`, error);
+          }
+          return;
+        }
+      }
+    }
+    const className = element.className;
+    if (typeof className === "string") {
+      for (const cls of this._cssClasses) {
+        const regex = new RegExp(`(^|\\s)${cls}(\\s|$)`);
+        if (regex.test(className)) {
+          const name = cls.replace("ds-", "");
+          const initFn = this.initializers.get(name) || this.initializers.get(cls);
+          if (initFn) {
+            try {
+              await initFn(element);
+              this.processedElements.add(element);
+            } catch (error) {
+              console.error(`[ComponentInitializerRegistry] Error initializing "${name}":`, error);
+            }
+            return;
+          }
+        }
+      }
+    }
+  }
+  /** Run cleanup/destroy for a single DOM element. */
+  cleanup(element) {
+    for (const attr of this._dataAttrs) {
+      const value = element.getAttribute(attr);
+      if (value !== null) {
+        const name = value || attr.replace("data-", "");
+        const cleanupFn = this.cleanupFunctions.get(name) || this.cleanupFunctions.get(attr.replace("data-", ""));
+        if (cleanupFn) {
+          try {
+            cleanupFn(element);
+          } catch (error) {
+            console.error(`[ComponentInitializerRegistry] Error cleaning up "${name}":`, error);
+          }
+          this.processedElements.delete(element);
+          return;
+        }
+      }
+    }
+    const className = element.className;
+    if (typeof className === "string") {
+      for (const cls of this._cssClasses) {
+        const regex = new RegExp(`(^|\\s)${cls}(\\s|$)`);
+        if (regex.test(className)) {
+          const name = cls.replace("ds-", "");
+          const cleanupFn = this.cleanupFunctions.get(name) || this.cleanupFunctions.get(cls);
+          if (cleanupFn) {
+            try {
+              cleanupFn(element);
+            } catch (error) {
+              console.error(`[ComponentInitializerRegistry] Error cleaning up "${name}":`, error);
+            }
+            this.processedElements.delete(element);
+            return;
+          }
+        }
+      }
+    }
+  }
+  /** Scan and initialize all matching components. Uses MutationObserver for dynamic content. */
+  async initializeAll(root = document) {
+    const selector = this._buildSelector();
+    if (!selector) return;
+    const elements = root.querySelectorAll(selector);
+    const promises = [];
+    elements.forEach((element) => {
+      if (!this.processedElements.has(element)) {
+        promises.push(this.initialize(element));
+      }
+    });
+    await Promise.all(promises);
+  }
+}
+const kupolaInitializer = new ComponentInitializerRegistry();
+const knownComponents = [
+  { attr: "data-dropdown", cls: "ds-dropdown" },
+  { attr: "data-select", cls: "ds-select" },
+  { attr: "data-datepicker", cls: "ds-datepicker" },
+  { attr: "data-timepicker", cls: "ds-timepicker" },
+  { attr: "data-slider", cls: "ds-slider" },
+  { attr: "data-carousel", cls: "ds-carousel" },
+  { attr: "data-drawer", cls: "ds-drawer" },
+  { attr: "data-modal", cls: "ds-modal" },
+  { attr: "data-dialog", cls: "ds-dialog" },
+  { attr: "data-color-picker", cls: "ds-color-picker" },
+  { attr: "data-calendar", cls: "ds-calendar" },
+  { attr: "data-slide-captcha", cls: "ds-slide-captcha" },
+  { attr: "data-heatmap", cls: "ds-heatmap" },
+  { cls: "ds-tooltip" },
+  { cls: "ds-tag" },
+  { cls: "ds-statcard" },
+  { cls: "ds-collapse" },
+  { cls: "ds-fileupload" },
+  { cls: "ds-notification" },
+  { cls: "ds-message" }
+];
+for (const comp of knownComponents) {
+  if (comp.attr && !kupolaInitializer._dataAttrs.includes(comp.attr)) {
+    kupolaInitializer._dataAttrs.push(comp.attr);
+  }
+  if (comp.cls && !kupolaInitializer._cssClasses.includes(comp.cls)) {
+    kupolaInitializer._cssClasses.push(comp.cls);
+  }
+}
+class KupolaComponent {
+  constructor(element) {
+    this.element = element;
+    this.isMounted = false;
+    this.isDestroyed = false;
+    this.props = this._parseProps();
+    this.state = {};
+    this.slots = this._parseSlots();
+    this._eventListeners = {};
+    this._appliedMixins = [];
+    this.lifecycle = new KupolaLifecycle();
+    this.setupContext = null;
+  }
+  _parseProps() {
+    const props = {};
+    for (const attr of this.element.attributes) {
+      if (attr.name.startsWith("data-prop-")) {
+        const name = attr.name.replace("data-prop-", "");
+        let value = attr.value;
+        try {
+          value = JSON.parse(value);
+        } catch (e) {
+        }
+        props[name] = value;
+      }
+    }
+    return props;
+  }
+  _parseSlots() {
+    const slots = {};
+    const slotElements = this.element.querySelectorAll("[data-slot]");
+    slotElements.forEach((slotEl) => {
+      const slotName = slotEl.getAttribute("data-slot") || "default";
+      slots[slotName] = slotEl.innerHTML.trim();
+      slotEl.remove();
+    });
+    if (!slots.default && this.element.children.length > 0) {
+      slots.default = this.element.innerHTML.trim();
+    }
+    return slots;
+  }
+  $slot(name = "default") {
+    return this.slots[name] || "";
+  }
+  $emit(eventName, data) {
+    const handlers = this._eventListeners[eventName] || [];
+    handlers.forEach((handler) => {
+      try {
+        handler(data);
+      } catch (e) {
+        console.error(`Error in event handler for ${eventName}:`, e);
+      }
+    });
+    if (this.element) {
+      const customEvent = new CustomEvent(`kupola:${eventName}`, {
+        detail: data,
+        bubbles: true,
+        cancelable: true
+      });
+      this.element.dispatchEvent(customEvent);
+    }
+  }
+  $on(eventName, handler) {
+    if (!this._eventListeners[eventName]) {
+      this._eventListeners[eventName] = [];
+    }
+    this._eventListeners[eventName].push(handler);
+    return handler;
+  }
+  $off(eventName, handler) {
+    if (this._eventListeners[eventName]) {
+      this._eventListeners[eventName] = this._eventListeners[eventName].filter((cb) => cb !== handler);
+    }
+  }
+  async setProps(newProps) {
+    try {
+      this.props = { ...this.props, ...newProps };
+      await this.lifecycle.update();
+      this.setupContext?._executeUpdated();
+    } catch (error) {
+      console.error(`[KupolaComponent] Error in setProps for "${this.constructor.name}":`, error);
+      if (this.lifecycle && typeof this.lifecycle._handleError === "function") {
+        await this.lifecycle._handleError({ phase: "update", hook: "setProps", error, args: [newProps] });
+      }
+    }
+  }
+  async setState(newState) {
+    try {
+      this.state = { ...this.state, ...newState };
+      await this.lifecycle.update();
+      this.setupContext?._executeUpdated();
+    } catch (error) {
+      console.error(`[KupolaComponent] Error in setState for "${this.constructor.name}":`, error);
+      if (this.lifecycle && typeof this.lifecycle._handleError === "function") {
+        await this.lifecycle._handleError({ phase: "update", hook: "setState", error, args: [newState] });
+      }
+    }
+  }
+  async mount() {
+    if (this.isMounted || this.isDestroyed) return;
+    try {
+      this._bindLifecycleHooks();
+      await this.lifecycle.bootstrap();
+      if (typeof this.setup === "function") {
+        const result = this.setup();
+        if (result instanceof Promise) {
+          await result;
+        }
+      }
+      this.isMounted = true;
+      await this.lifecycle.mount();
+      this.setupContext?._executeMounted();
+    } catch (error) {
+      console.error(`[KupolaComponent] Error mounting component "${this.constructor.name}":`, error);
+      if (this.lifecycle && typeof this.lifecycle._handleError === "function") {
+        await this.lifecycle._handleError({ phase: "mount", hook: "component", error, args: [] });
+      }
+      if (typeof this.renderError === "function") {
+        try {
+          this.renderError(error);
+        } catch (e) {
+          console.error(`[KupolaComponent] Error in renderError for "${this.constructor.name}":`, e);
+        }
+      } else {
+        this.element.innerHTML = `
+          <div style="padding: 16px; background: #fee2e2; border: 1px solid #fecaca; border-radius: 8px; color: #991b1b;">
+            <div style="font-weight: bold; margin-bottom: 8px;">Component Error</div>
+            <div style="font-size: 12px; white-space: pre-wrap;">${error.message}</div>
+          </div>
+        `;
+      }
+    }
+  }
+  _bindLifecycleHooks() {
+    if (this._hooksBound) return;
+    const hookMap = {
+      beforeMount: "beforeMount",
+      render: ["mount", "update"],
+      afterMount: "afterMount",
+      updated: "afterUpdate",
+      beforeUnmount: "beforeUnmount",
+      afterUnmount: "afterUnmount",
+      renderError: "errorBoundary"
+    };
+    let proto = Object.getPrototypeOf(this);
+    const registeredHooks = /* @__PURE__ */ new Set();
+    while (proto && proto.constructor !== Object && proto.constructor !== KupolaComponent) {
+      for (const [methodName, lifecyclePhase] of Object.entries(hookMap)) {
+        if (registeredHooks.has(methodName)) continue;
+        if (proto.hasOwnProperty(methodName)) {
+          if (Array.isArray(lifecyclePhase)) {
+            lifecyclePhase.forEach((phase) => {
+              if (methodName === "render") {
+                this.lifecycle.on(phase, () => this.render?.());
+              }
+            });
+          } else if (methodName === "renderError") {
+            this.lifecycle.on(lifecyclePhase, (errorInfo) => {
+              this.renderError(errorInfo.error);
+              return "handled";
+            });
+          } else {
+            this.lifecycle.on(lifecyclePhase, () => this[methodName]?.());
+          }
+          registeredHooks.add(methodName);
+        }
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    this._hooksBound = true;
+  }
+  async unmount() {
+    if (!this.isMounted || this.isDestroyed) return;
+    try {
+      this.setupContext?._executeUnmounted();
+      await this.lifecycle.unmount();
+      this.isMounted = false;
+      this.isDestroyed = true;
+      await this.lifecycle.destroy();
+    } catch (error) {
+      console.error(`[KupolaComponent] Error unmounting component "${this.constructor.name}":`, error);
+      if (this.lifecycle && typeof this.lifecycle._handleError === "function") {
+        await this.lifecycle._handleError({ phase: "unmount", hook: "component", error, args: [] });
+      }
+      this.isMounted = false;
+      this.isDestroyed = true;
+    }
+  }
+  beforeMount() {
+  }
+  afterMount() {
+  }
+  beforeUnmount() {
+  }
+  afterUnmount() {
+  }
+  render() {
+  }
+  renderError(error) {
+  }
+  updated() {
+  }
+  setup() {
+  }
+}
+function applyMixin(componentClass, mixin) {
+  Object.keys(mixin).forEach((key) => {
+    if (key === "constructor") return;
+    if (typeof mixin[key] === "function") {
+      const original = componentClass.prototype[key];
+      if (original) {
+        componentClass.prototype[key] = function(...args) {
+          mixin[key].apply(this, args);
+          return original.apply(this, args);
+        };
+      } else {
+        componentClass.prototype[key] = mixin[key];
+      }
+    } else {
+      componentClass.prototype[key] = mixin[key];
+    }
+  });
+}
+class KupolaComponentRegistry {
+  constructor() {
+    this.components = /* @__PURE__ */ new Map();
+    this.lazyComponents = /* @__PURE__ */ new Map();
+    this.loadedComponents = /* @__PURE__ */ new Map();
+    this.instances = /* @__PURE__ */ new Map();
+    this.observer = null;
+    this.mixins = /* @__PURE__ */ new Map();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+  }
+  register(name, componentClass) {
+    if (!(componentClass.prototype instanceof KupolaComponent)) {
+      throw new Error(`Component ${name} must extend KupolaComponent`);
+    }
+    this.components.set(name, componentClass);
+  }
+  registerLazy(name, loader) {
+    this.lazyComponents.set(name, loader);
+  }
+  unregister(name) {
+    this.components.delete(name);
+    this.lazyComponents.delete(name);
+    this.loadedComponents.delete(name);
+    this.loadingPromises.delete(name);
+  }
+  get(name) {
+    return this.components.get(name) || this.loadedComponents.get(name);
+  }
+  async getAsync(name) {
+    const cached = this.components.get(name) || this.loadedComponents.get(name);
+    if (cached) return cached;
+    if (this.loadingPromises.has(name)) {
+      return this.loadingPromises.get(name);
+    }
+    const loader = this.lazyComponents.get(name);
+    if (!loader) {
+      throw new Error(`Component ${name} not found`);
+    }
+    const loadingPromise = (async () => {
+      try {
+        const result = await loader();
+        const componentClass = result.default || result;
+        if (!(componentClass.prototype instanceof KupolaComponent)) {
+          throw new Error(`Component ${name} must extend KupolaComponent`);
+        }
+        this.loadedComponents.set(name, componentClass);
+        return componentClass;
+      } catch (e) {
+        this.loadingPromises.delete(name);
+        throw e;
+      }
+    })();
+    this.loadingPromises.set(name, loadingPromise);
+    return loadingPromise;
+  }
+  defineMixin(name, mixin) {
+    this.mixins.set(name, mixin);
+  }
+  useMixin(componentClass, ...mixinNames) {
+    mixinNames.forEach((name) => {
+      const mixin = this.mixins.get(name);
+      if (mixin) {
+        applyMixin(componentClass, mixin);
+      }
+    });
+  }
+  async bootstrap(root = document) {
+    await this._upgradeElements(root);
+    this._startObserver(root);
+  }
+  async _upgradeElements(root) {
+    const elements = root.querySelectorAll("[data-component]");
+    const promises = [];
+    elements.forEach((element) => {
+      promises.push(this._upgradeElement(element));
+    });
+    await Promise.all(promises);
+  }
+  async _upgradeElement(element) {
+    if (element.__kupolaInstance || element.__kupolaUpgrading) return;
+    element.__kupolaUpgrading = true;
+    try {
+      const componentName = element.getAttribute("data-component");
+      if (componentName) {
+        const initializer = kupolaInitializer.get(componentName);
+        if (initializer) {
+          try {
+            await initializer(element);
+            return;
+          } catch (e) {
+            console.warn(`[KupolaComponentRegistry] Initializer for "${componentName}" failed, trying component class:`, e);
+          }
+        }
+      }
+      let ComponentClass = this.components.get(componentName);
+      if (!ComponentClass) {
+        try {
+          ComponentClass = await this.getAsync(componentName);
+        } catch (e) {
+          console.error(`Failed to load component ${componentName}:`, e);
+          return;
+        }
+        if (!element.isConnected) {
+          return;
+        }
+      }
+      const mixinNames = element.getAttribute("data-mixins");
+      const componentClass = ComponentClass;
+      if (mixinNames) {
+        mixinNames.split(",").forEach((name) => {
+          const mixin = this.mixins.get(name.trim());
+          if (mixin) {
+            applyMixin(componentClass, mixin);
+          }
+        });
+      }
+      const instance = new componentClass(element);
+      element.__kupolaInstance = instance;
+      this.instances.set(element, instance);
+      instance.mount();
+    } finally {
+      element.__kupolaUpgrading = false;
+    }
+  }
+  _startObserver(root) {
+    if (this.observer) return;
+    this.observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            if (node.hasAttribute("data-component")) {
+              this._upgradeElement(node).catch((e) => console.error(e));
+            }
+            this._upgradeElements(node).catch((e) => console.error(e));
+            kupolaInitializer.initialize(node).catch(() => {
+            });
+            const selector = kupolaInitializer._buildSelector();
+            if (selector) {
+              node.querySelectorAll?.(selector).forEach((child) => {
+                kupolaInitializer.initialize(child).catch(() => {
+                });
+              });
+            }
+          }
+        });
+        mutation.removedNodes.forEach((node) => {
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            const instance = this.instances.get(node);
+            if (instance) {
+              instance.unmount();
+              this.instances.delete(node);
+            }
+            node.querySelectorAll("[data-component]").forEach((child) => {
+              const childInstance = this.instances.get(child);
+              if (childInstance) {
+                childInstance.unmount();
+                this.instances.delete(child);
+              }
+            });
+            kupolaInitializer.cleanup(node);
+            node.querySelectorAll?.("*").forEach((child) => {
+              kupolaInitializer.cleanup(child);
+            });
+          }
+        });
+      });
+    });
+    this.observer.observe(root, {
+      childList: true,
+      subtree: true
+    });
+  }
+  destroy() {
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+    this.instances.forEach((instance) => {
+      instance.unmount();
+    });
+    this.instances.clear();
+    this.components.clear();
+    this.mixins.clear();
+  }
+}
+let kupolaRegistry = null;
+if (typeof window !== "undefined") {
+  kupolaRegistry = new KupolaComponentRegistry();
+}
+function _applySecurityHeaders() {
+  const securityConfig = getSecurityConfig();
+  if (securityConfig.xssProtection && typeof document !== "undefined") {
+    let metaTag = document.querySelector('meta[http-equiv="X-XSS-Protection"]');
+    if (!metaTag) {
+      metaTag = document.createElement("meta");
+      metaTag.setAttribute("http-equiv", "X-XSS-Protection");
+      metaTag.setAttribute("content", "1; mode=block");
+      document.head.insertBefore(metaTag, document.head.firstChild);
+    }
+    metaTag = document.querySelector('meta[http-equiv="X-Content-Type-Options"]');
+    if (!metaTag) {
+      metaTag = document.createElement("meta");
+      metaTag.setAttribute("http-equiv", "X-Content-Type-Options");
+      metaTag.setAttribute("content", "nosniff");
+      document.head.insertBefore(metaTag, document.head.firstChild);
+    }
+  }
+}
+async function kupolaBootstrap() {
+  if (typeof window !== "undefined") {
+    _applySecurityHeaders();
+    const config2 = getConfig();
+    kupolaData.loadPersisted();
+    kupolaData.bind();
+    initTheme();
+    if (config2.components?.autoInit !== false) {
+      await kupolaInitializer.initializeAll();
+      if (kupolaRegistry) {
+        await kupolaRegistry.bootstrap();
+      }
+    }
+  }
+}
+if (typeof document !== "undefined" && document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", kupolaBootstrap);
+} else if (typeof window !== "undefined") {
+  setTimeout(kupolaBootstrap, 0);
+}
+function registerComponent(name, componentClass) {
+  if (kupolaRegistry) {
+    kupolaRegistry.register(name, componentClass);
+  }
+}
+function registerLazyComponent(name, loader) {
+  if (kupolaRegistry) {
+    kupolaRegistry.registerLazy(name, loader);
+  }
+}
+function bootstrapComponents(root) {
+  if (kupolaRegistry) {
+    return kupolaRegistry.bootstrap(root);
+  }
+  return Promise.resolve();
+}
+function defineMixin(name, mixin) {
+  if (kupolaRegistry) {
+    kupolaRegistry.defineMixin(name, mixin);
+  }
+}
+function useMixin(componentClass, ...mixinNames) {
+  if (kupolaRegistry) {
+    kupolaRegistry.useMixin(componentClass, ...mixinNames);
+  }
+}
+function defineComponent(name, options) {
+  if (!options || typeof options !== "object") {
+    throw new Error(`defineComponent("${name}"): options must be an object`);
+  }
+  if (options.componentClass) {
+    if (kupolaRegistry) {
+      kupolaRegistry.register(name, options.componentClass);
+    }
+  } else if (options.lazy) {
+    if (kupolaRegistry) {
+      kupolaRegistry.registerLazy(name, options.lazy);
+    }
+  }
+  if (options.init) {
+    kupolaInitializer.register(name, options.init, options.cleanup || null, {
+      dataAttribute: options.dataAttribute,
+      cssClass: options.cssClass
+    });
+  } else if (options.dataAttribute || options.cssClass) {
+    kupolaInitializer.register(name, () => {
+    }, null, {
+      dataAttribute: options.dataAttribute,
+      cssClass: options.cssClass
+    });
+  }
+}
+class KupolaI18n {
+  constructor(options = {}) {
+    const config2 = getConfig();
+    this.locales = options.locales || {};
+    this.currentLocale = options.defaultLocale || config2.i18n?.locale || "zh-CN";
+    this.fallbackLocale = options.fallbackLocale || config2.i18n?.fallbackLocale || "en-US";
+    this.delimiter = options.delimiter || ".";
+    this.missingHandler = options.missingHandler || ((key) => {
+      console.warn(`Missing translation: ${key}`);
+      return key;
+    });
+    this._initFromDOM();
+  }
+  _initFromDOM() {
+    const scriptTags = document.querySelectorAll('script[type="application/json"][data-kupola-i18n]');
+    scriptTags.forEach((script) => {
+      const locale = script.dataset.kupolaI18n;
+      if (locale) {
+        try {
+          const data = JSON.parse(script.textContent);
+          this.addLocale(locale, data);
+        } catch (e) {
+          console.error("Failed to parse i18n data:", e);
+        }
+      }
+    });
+    const htmlLang = document.documentElement.lang;
+    if (htmlLang && this.locales[htmlLang]) {
+      this.currentLocale = htmlLang;
+    }
+  }
+  addLocale(locale, data) {
+    if (!this.locales[locale]) {
+      this.locales[locale] = {};
+    }
+    this._mergeDeep(this.locales[locale], data);
+  }
+  _mergeDeep(target, source) {
+    for (const key of Object.keys(source)) {
+      if (source[key] instanceof Object && key in target) {
+        this._mergeDeep(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    }
+  }
+  setLocale(locale) {
+    if (this.locales[locale]) {
+      this.currentLocale = locale;
+      document.documentElement.lang = locale;
+      this._emitChange();
+      return true;
+    }
+    return false;
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  t(key, params = {}) {
+    let value = this._getTranslation(key, this.currentLocale);
+    if (!value) {
+      value = this._getTranslation(key, this.fallbackLocale);
+    }
+    if (!value) {
+      return this.missingHandler(key);
+    }
+    return this._interpolate(value, params);
+  }
+  _getTranslation(key, locale) {
+    if (!this.locales[locale]) return null;
+    const keys2 = key.split(this.delimiter);
+    let value = this.locales[locale];
+    for (const k of keys2) {
+      if (value && typeof value === "object" && k in value) {
+        value = value[k];
+      } else {
+        return null;
+      }
+    }
+    return typeof value === "string" ? value : null;
+  }
+  _interpolate(str, params) {
+    return str.replace(/\{(\w+)\}/g, (match, key) => {
+      return params[key] !== void 0 ? params[key] : match;
+    });
+  }
+  n(key, count, params = {}) {
+    const value = this.t(key, { ...params, count });
+    if (!value) return value;
+    const parts = value.split("|");
+    if (parts.length === 1) {
+      return value.replace("{count}", count);
+    }
+    if (parts.length === 2) {
+      return count === 1 ? parts[0] : parts[1];
+    }
+    if (parts.length >= 3) {
+      if (count === 0) return parts[0];
+      if (count === 1) return parts[1];
+      return parts[2];
+    }
+    return value;
+  }
+  _emitChange() {
+    const event = new CustomEvent("kupola:i18n:change", {
+      detail: { locale: this.currentLocale },
+      bubbles: true
+    });
+    document.dispatchEvent(event);
+  }
+  async loadLocale(locale, url) {
+    try {
+      const response = await fetch(url);
+      const data = await response.json();
+      this.addLocale(locale, data);
+      return true;
+    } catch (error) {
+      console.error("Failed to load locale:", error);
+      return false;
+    }
+  }
+  getAvailableLocales() {
+    return Object.keys(this.locales);
+  }
+  hasLocale(locale) {
+    return !!this.locales[locale];
+  }
+  formatDate(date, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    const dateObj = typeof date === "string" ? new Date(date) : date;
+    return new Intl.DateTimeFormat(locale, options).format(dateObj);
+  }
+  formatNumber(number, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    return new Intl.NumberFormat(locale, options).format(number);
+  }
+  formatCurrency(number, currency, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      ...options
+    }).format(number);
+  }
+  formatRelativeTime(value, unit, options = {}) {
+    const locale = options.locale || this.currentLocale;
+    return new Intl.RelativeTimeFormat(locale, options).format(value, unit);
+  }
+}
+const kupolaI18n = new KupolaI18n();
+function createI18n(options) {
+  return new KupolaI18n(options);
+}
+function t(key, params = {}) {
+  return kupolaI18n.t(key, params);
+}
+function n(key, count, params = {}) {
+  return kupolaI18n.n(key, count, params);
+}
+function setLocale(locale) {
+  return kupolaI18n.setLocale(locale);
+}
+function getLocale() {
+  return kupolaI18n.getLocale();
+}
+function formatDate(date, options = {}) {
+  return kupolaI18n.formatDate(date, options);
+}
+function formatNumber(number, options = {}) {
+  return kupolaI18n.formatNumber(number, options);
+}
+function formatCurrency(number, currency, options = {}) {
+  return kupolaI18n.formatCurrency(number, currency, options);
+}
+class GlobalEvents {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map();
+    this._scopeListeners = /* @__PURE__ */ new Map();
+  }
+  on(target, eventName, handler, options = {}) {
+    const { scope = null, once: once2 = false, passive = false, capture = false } = options;
+    const listenerId = this._generateId();
+    const listener = {
+      id: listenerId,
+      target,
+      eventName,
+      handler,
+      scope,
+      once: once2,
+      wrappedHandler: null
+    };
+    listener.wrappedHandler = (event) => {
+      if (once2) {
+        this.offById(listenerId);
+      }
+      handler.call(target, event);
+    };
+    const eventKey = this._getEventKey(target, eventName);
+    if (!this._listeners.has(eventKey)) {
+      this._listeners.set(eventKey, []);
+    }
+    this._listeners.get(eventKey).push(listener);
+    if (scope) {
+      if (!this._scopeListeners.has(scope)) {
+        this._scopeListeners.set(scope, []);
+      }
+      this._scopeListeners.get(scope).push(listenerId);
+    }
+    target.addEventListener(eventName, listener.wrappedHandler, {
+      passive,
+      capture
+    });
+    return {
+      unsubscribe: () => this.offById(listenerId)
+    };
+  }
+  once(target, eventName, handler, options = {}) {
+    return this.on(target, eventName, handler, { ...options, once: true });
+  }
+  off(target, eventName, handler) {
+    const eventKey = this._getEventKey(target, eventName);
+    if (!this._listeners.has(eventKey)) return;
+    const listeners = this._listeners.get(eventKey);
+    const filtered = listeners.filter((listener) => listener.handler !== handler);
+    listeners.forEach((listener) => {
+      if (listener.handler === handler) {
+        target.removeEventListener(eventName, listener.wrappedHandler);
+        this._removeFromScope(listener);
+      }
+    });
+    if (filtered.length === 0) {
+      this._listeners.delete(eventKey);
+    } else {
+      this._listeners.set(eventKey, filtered);
+    }
+  }
+  offById(listenerId) {
+    for (const [eventKey, listeners] of this._listeners) {
+      const index = listeners.findIndex((l) => l.id === listenerId);
+      if (index !== -1) {
+        const listener = listeners[index];
+        listener.target.removeEventListener(listener.eventName, listener.wrappedHandler);
+        listeners.splice(index, 1);
+        if (listeners.length === 0) {
+          this._listeners.delete(eventKey);
+        }
+        this._removeFromScope(listener);
+        return true;
+      }
+    }
+    return false;
+  }
+  offByScope(scope) {
+    if (!this._scopeListeners.has(scope)) return;
+    const listenerIds = this._scopeListeners.get(scope);
+    listenerIds.forEach((listenerId) => {
+      this.offById(listenerId);
+    });
+    this._scopeListeners.delete(scope);
+  }
+  offAll(target, eventName = null) {
+    if (eventName) {
+      const eventKey = this._getEventKey(target, eventName);
+      if (!this._listeners.has(eventKey)) return;
+      const listeners = this._listeners.get(eventKey);
+      listeners.forEach((listener) => {
+        target.removeEventListener(eventName, listener.wrappedHandler);
+        this._removeFromScope(listener);
+      });
+      this._listeners.delete(eventKey);
+    } else {
+      for (const [eventKey, listeners] of this._listeners) {
+        const [targetId] = eventKey.split(":");
+        if (this._getTargetId(target) === targetId) {
+          listeners.forEach((listener) => {
+            target.removeEventListener(listener.eventName, listener.wrappedHandler);
+            this._removeFromScope(listener);
+          });
+          this._listeners.delete(eventKey);
+        }
+      }
+    }
+  }
+  emit(target, eventName, detail = {}) {
+    const event = new CustomEvent(eventName, {
+      detail,
+      bubbles: true,
+      cancelable: true
+    });
+    target.dispatchEvent(event);
+    return event;
+  }
+  emitGlobal(eventName, detail = {}) {
+    return this.emit(document, eventName, detail);
+  }
+  emitToScope(scope, eventName, detail = {}) {
+    if (!this._scopeListeners.has(scope)) return;
+    const listenerIds = this._scopeListeners.get(scope);
+    const targets = /* @__PURE__ */ new Set();
+    for (const [eventKey, listeners] of this._listeners) {
+      listeners.forEach((listener) => {
+        if (listenerIds.includes(listener.id)) {
+          targets.add(listener.target);
+        }
+      });
+    }
+    targets.forEach((target) => {
+      this.emit(target, eventName, detail);
+    });
+  }
+  getListenerCount(target, eventName = null) {
+    if (eventName) {
+      const eventKey = this._getEventKey(target, eventName);
+      return this._listeners.has(eventKey) ? this._listeners.get(eventKey).length : 0;
+    }
+    let count = 0;
+    const targetId = this._getTargetId(target);
+    for (const [eventKey, listeners] of this._listeners) {
+      const [keyTargetId] = eventKey.split(":");
+      if (keyTargetId === targetId) {
+        count += listeners.length;
+      }
+    }
+    return count;
+  }
+  getScopeListenerCount(scope) {
+    return this._scopeListeners.has(scope) ? this._scopeListeners.get(scope).length : 0;
+  }
+  hasListeners(target, eventName = null) {
+    return this.getListenerCount(target, eventName) > 0;
+  }
+  _getEventKey(target, eventName) {
+    return `${this._getTargetId(target)}:${eventName}`;
+  }
+  _getTargetId(target) {
+    if (target === document) return "document";
+    if (target === window) return "window";
+    if (target === document.body) return "body";
+    if (target._kupolaId) return target._kupolaId;
+    target._kupolaId = this._generateId();
+    return target._kupolaId;
+  }
+  _generateId() {
+    return `ge-${Math.random().toString(36).substr(2, 9)}-${Date.now()}`;
+  }
+  _removeFromScope(listener) {
+    if (!listener.scope || !this._scopeListeners.has(listener.scope)) return;
+    const scopeListeners = this._scopeListeners.get(listener.scope);
+    const index = scopeListeners.indexOf(listener.id);
+    if (index !== -1) {
+      scopeListeners.splice(index, 1);
+      if (scopeListeners.length === 0) {
+        this._scopeListeners.delete(listener.scope);
+      }
+    }
+  }
+  destroy() {
+    for (const [eventKey, listeners] of this._listeners) {
+      listeners.forEach((listener) => {
+        listener.target.removeEventListener(listener.eventName, listener.wrappedHandler);
+      });
+    }
+    this._listeners.clear();
+    this._scopeListeners.clear();
+  }
+}
+const globalEvents = new GlobalEvents();
+function on(target, eventName, handler, options) {
+  return globalEvents.on(target, eventName, handler, options);
+}
+function once(target, eventName, handler, options) {
+  return globalEvents.once(target, eventName, handler, options);
+}
+function off(target, eventName, handler) {
+  globalEvents.off(target, eventName, handler);
+}
+function emit(target, eventName, detail) {
+  return globalEvents.emit(target, eventName, detail);
+}
+function emitGlobal(eventName, detail) {
+  return globalEvents.emitGlobal(eventName, detail);
+}
+function offByScope(scope) {
+  globalEvents.offByScope(scope);
+}
+function offAll(target, eventName) {
+  globalEvents.offAll(target, eventName);
+}
+function getListenerCount(target, eventName) {
+  return globalEvents.getListenerCount(target, eventName);
+}
+class Scheduler {
+  constructor() {
+    this._queue = /* @__PURE__ */ new Set();
+    this._scheduled = false;
+    this._flushDepth = 0;
+    this._maxDepth = 10;
+  }
+  schedule(fn) {
+    this._queue.add(fn);
+    if (!this._scheduled) {
+      this._scheduled = true;
+      queueMicrotask(() => this._flush());
+    }
+  }
+  _flush() {
+    if (this._flushDepth >= this._maxDepth) {
+      console.warn("[Kupola Scheduler] Max flush depth reached, possible infinite loop detected");
+      this._queue.clear();
+      this._scheduled = false;
+      return;
+    }
+    const tasks = Array.from(this._queue);
+    this._queue.clear();
+    this._scheduled = false;
+    this._flushDepth++;
+    const seen = /* @__PURE__ */ new Set();
+    for (const task of tasks) {
+      if (!seen.has(task)) {
+        seen.add(task);
+        try {
+          task();
+        } catch (e) {
+          console.error("[DependsScheduler]", e);
+        }
+      }
+    }
+    this._flushDepth--;
+  }
+}
+const globalScheduler = new Scheduler();
+class CacheEntry {
+  constructor(data, ttl) {
+    this.data = data;
+    this.createdAt = Date.now();
+    this.ttl = ttl;
+  }
+  get isFresh() {
+    return Date.now() - this.createdAt < this.ttl;
+  }
+  get isStale() {
+    return !this.isFresh;
+  }
+}
+class CacheManager {
+  constructor() {
+    this._store = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    const entry = this._store.get(key);
+    if (!entry) return null;
+    return entry;
+  }
+  set(key, data, ttl = 6e4) {
+    this._store.set(key, new CacheEntry(data, ttl));
+  }
+  has(key) {
+    return this._store.has(key);
+  }
+  delete(key) {
+    this._store.delete(key);
+  }
+  clear() {
+    this._store.clear();
+  }
+  // Get data regardless of freshness (for stale-while-revalidate)
+  getStale(key) {
+    const entry = this._store.get(key);
+    return entry ? entry.data : null;
+  }
+}
+class DependsError extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "DependsError";
+    this.code = code;
+    this.cause = cause;
+    this.timestamp = Date.now();
+  }
+}
+let _httpClientFetch = typeof globalThis !== "undefined" && globalThis.fetch ? globalThis.fetch.bind(globalThis) : typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : null;
+function configureHttpClient(client) {
+  if (!client || typeof client.fetch !== "function") {
+    throw new TypeError("[Kupola] configureHttpClient: client must provide a fetch function");
+  }
+  _httpClientFetch = client.fetch.bind(client);
+}
+function getHttpClient() {
+  return _httpClientFetch;
+}
+function resetHttpClient() {
+  _httpClientFetch = typeof globalThis !== "undefined" && globalThis.fetch ? globalThis.fetch.bind(globalThis) : typeof window !== "undefined" && window.fetch ? window.fetch.bind(window) : null;
+}
+class DependsSource {
+  constructor(config2, cacheManager) {
+    this.config = config2;
+    this.cacheKey = config2.cacheKey || String(config2.source);
+    this.staleTime = config2.staleTime ?? 6e4;
+    this.cache = cacheManager;
+    this.subscribers = [];
+    this.pending = null;
+    this.retryCount = config2.retry ?? 0;
+    this.retryDelay = config2.retryDelay ?? 1e3;
+    this.onError = config2.onError || null;
+  }
+  subscribe(callback) {
+    this.subscribers.push(callback);
+    return () => {
+      const idx = this.subscribers.indexOf(callback);
+      if (idx > -1) this.subscribers.splice(idx, 1);
+    };
+  }
+  notify() {
+    globalScheduler.schedule(() => {
+      this.subscribers.forEach((cb) => {
+        try {
+          cb();
+        } catch (e) {
+          console.error("[DependsSource.notify]", e);
+        }
+      });
+    });
+  }
+  async fetch(params) {
+    throw new DependsError("Source fetch not implemented", "NOT_IMPLEMENTED");
+  }
+  async getValue(params) {
+    const cached = this.cache.get(this.cacheKey);
+    if (cached && cached.isFresh) {
+      return cached.data;
+    }
+    if (cached && cached.isStale) {
+      this._revalidate(params);
+      return cached.data;
+    }
+    return this._fetchWithRetry(params);
+  }
+  async _fetchWithRetry(params, attempt = 0) {
+    try {
+      const result = await this.fetch(params);
+      this.cache.set(this.cacheKey, result, this.staleTime);
+      this.notify();
+      return result;
+    } catch (error) {
+      if (attempt < this.retryCount) {
+        const baseDelay = this.retryDelay * Math.pow(2, attempt);
+        const jitter = Math.random() * baseDelay * 0.5;
+        const delay = baseDelay + jitter;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return this._fetchWithRetry(params, attempt + 1);
+      }
+      const depError = error instanceof DependsError ? error : new DependsError(error.message || "Fetch failed", "FETCH_ERROR", error);
+      if (this.onError) {
+        try {
+          this.onError(depError);
+        } catch (_) {
+        }
+      }
+      throw depError;
+    }
+  }
+  async _revalidate(params) {
+    try {
+      await this._fetchWithRetry(params);
+    } catch (_) {
+    }
+  }
+  invalidate() {
+    this.cache.delete(this.cacheKey);
+    this.pending = null;
+  }
+  destroy() {
+    this.subscribers = [];
+    this.pending = null;
+  }
+}
+class FetchedSource extends DependsSource {
+  constructor(config2, cacheManager) {
+    super(config2, cacheManager);
+    this.method = config2.method || "GET";
+    this.headers = config2.headers || {};
+    this.queryParams = config2.query || {};
+  }
+  async fetch(params) {
+    let url = this.config.source;
+    const httpConfig = getConfig("http");
+    if (httpConfig?.baseURL && !url.startsWith("http://") && !url.startsWith("https://")) {
+      url = httpConfig.baseURL + url.replace(/^\//, "");
+    }
+    for (const key in params) {
+      url = url.replace(`:${key}`, encodeURIComponent(params[key]));
+    }
+    const queryParts = [];
+    for (const [k, v] of Object.entries(this.queryParams || {})) {
+      queryParts.push(`${encodeURIComponent(k)}=${encodeURIComponent(v)}`);
+    }
+    for (const key in params) {
+      if (!this.config.source.includes(`:${key}`)) {
+        queryParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`);
+      }
+    }
+    if (queryParts.length > 0) {
+      url += (url.includes("?") ? "&" : "?") + queryParts.join("&");
+    }
+    const globalHeaders = httpConfig?.headers || {};
+    const fetchOptions = {
+      method: this.method.toUpperCase(),
+      headers: { "Content-Type": "application/json", ...globalHeaders, ...this.headers }
+    };
+    if (httpConfig?.withCredentials) {
+      fetchOptions.credentials = "include";
+    }
+    if (["POST", "PUT", "PATCH"].includes(fetchOptions.method)) {
+      fetchOptions.body = JSON.stringify(params);
+    }
+    const clientFetch = _httpClientFetch;
+    if (!clientFetch) {
+      throw new DependsError("No HTTP client available. Use configureHttpClient() to set one.", "NO_HTTP_CLIENT");
+    }
+    const response = await clientFetch(url, fetchOptions);
+    const ok = typeof response.ok === "boolean" ? response.ok : response.status >= 200 && response.status < 300;
+    const status = typeof response.status === "number" ? response.status : 0;
+    if (!ok) {
+      throw new DependsError(`HTTP ${status}`, "HTTP_ERROR");
+    }
+    const data = typeof response.json === "function" ? await response.json() : response.data !== void 0 ? response.data : response;
+    return data;
+  }
+}
+class StorageSource extends DependsSource {
+  constructor(config2, cacheManager) {
+    super(config2, cacheManager);
+    this.storageKey = config2.source.replace("localStorage:", "");
+    this.defaultValue = config2.default;
+    this.sync = config2.sync !== false;
+    if (this.sync && typeof window !== "undefined") {
+      this._storageHandler = (e) => {
+        if (e.key === this.storageKey) {
+          this.cache.delete(this.cacheKey);
+          this.notify();
+        }
+      };
+      window.addEventListener("storage", this._storageHandler);
+    }
+  }
+  async fetch() {
+    try {
+      const value = localStorage.getItem(this.storageKey);
+      if (value === null) return this.defaultValue;
+      try {
+        return JSON.parse(value);
+      } catch (_) {
+        return value;
+      }
+    } catch (e) {
+      return this.defaultValue;
+    }
+  }
+  setValue(value) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    localStorage.setItem(this.storageKey, serialized);
+    this.cache.delete(this.cacheKey);
+    this.notify();
+  }
+  destroy() {
+    super.destroy();
+    if (this._storageHandler) {
+      window.removeEventListener("storage", this._storageHandler);
+    }
+  }
+}
+class RouteSource extends DependsSource {
+  constructor(config2, cacheManager) {
+    super(config2, cacheManager);
+    this.paramName = config2.source.replace("route:", "");
+  }
+  async fetch() {
+    if (typeof window === "undefined") return "";
+    const hash = location.hash.slice(1);
+    const match = hash.match(new RegExp(`/${this.paramName}/([^/]+)`));
+    if (match) return decodeURIComponent(match[1]);
+    const urlParams = new URLSearchParams(location.search);
+    return urlParams.get(this.paramName) || "";
+  }
+}
+class FunctionSource extends DependsSource {
+  async fetch(params) {
+    const result = await this.config.source(params);
+    return result;
+  }
+}
+class StaticSource extends DependsSource {
+  async fetch() {
+    return this.config.source;
+  }
+}
+class WebSocketSource extends DependsSource {
+  constructor(config2, cacheManager) {
+    super(config2, cacheManager);
+    this.ws = null;
+    this.reconnect = config2.reconnect !== false;
+    this.reconnectDelay = config2.reconnectDelay || 3e3;
+    this._reconnectAttempt = 0;
+    this._maxReconnectDelay = config2.maxReconnectDelay || 3e4;
+    this.messageHandler = null;
+    this._connected = false;
+    this._destroyed = false;
+  }
+  async fetch() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(this.config.source);
+        this.ws.onopen = () => {
+          this._connected = true;
+          this._reconnectAttempt = 0;
+          resolve(this.cache.getStale(this.cacheKey));
+        };
+        this.messageHandler = (event) => {
+          let data;
+          try {
+            data = JSON.parse(event.data);
+          } catch (_) {
+            data = event.data;
+          }
+          this.cache.set(this.cacheKey, data, this.staleTime);
+          this.notify();
+        };
+        this.ws.onmessage = this.messageHandler;
+        this.ws.onerror = (error) => {
+          if (!this._connected) {
+            reject(new DependsError("WebSocket connection failed", "WS_ERROR", error));
+          }
+        };
+        this.ws.onclose = () => {
+          this._connected = false;
+          if (this.reconnect && !this._destroyed) {
+            const baseDelay = this.reconnectDelay * Math.pow(2, this._reconnectAttempt);
+            const jitter = Math.random() * baseDelay * 0.3;
+            const delay = Math.min(baseDelay + jitter, this._maxReconnectDelay);
+            this._reconnectAttempt++;
+            setTimeout(() => {
+              if (!this._destroyed) this.fetch().catch(() => {
+              });
+            }, delay);
+          }
+        };
+      } catch (e) {
+        reject(new DependsError("WebSocket creation failed", "WS_ERROR", e));
+      }
+    });
+  }
+  send(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(typeof data === "string" ? data : JSON.stringify(data));
+    }
+  }
+  destroy() {
+    this._destroyed = true;
+    super.destroy();
+    if (this.ws) {
+      this.ws.onmessage = null;
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+}
+function createSource(config2, cacheManager) {
+  const source = config2.source;
+  if (typeof source === "function") {
+    return new FunctionSource(config2, cacheManager);
+  } else if (typeof source === "string" && (source.startsWith("ws://") || source.startsWith("wss://"))) {
+    return new WebSocketSource(config2, cacheManager);
+  } else if (typeof source === "string" && (source.startsWith("/") || source.startsWith("http"))) {
+    return new FetchedSource(config2, cacheManager);
+  } else if (typeof source === "string" && source.startsWith("localStorage:")) {
+    return new StorageSource(config2, cacheManager);
+  } else if (typeof source === "string" && source.startsWith("route:")) {
+    return new RouteSource(config2, cacheManager);
+  } else {
+    return new StaticSource(config2, cacheManager);
+  }
+}
+function useDeps(props, depsConfig) {
+  const result = {};
+  const cacheManager = new CacheManager();
+  const unsubscribers = [];
+  for (const key in depsConfig) {
+    let getParams = function() {
+      return _extractPropValues(props);
+    };
+    let config2 = depsConfig[key];
+    if (typeof config2 === "string") {
+      config2 = { source: config2 };
+    }
+    const depConfig = {
+      ...config2,
+      cacheKey: config2.cacheKey || `${key}-${JSON.stringify(_extractPropValues(props))}`
+    };
+    const source = createSource(depConfig, cacheManager);
+    const data = ref(null);
+    const loading = ref(true);
+    const error = ref(null);
+    const lastUpdated = ref(null);
+    let _loadId = 0;
+    async function load() {
+      const thisLoadId = ++_loadId;
+      loading.value = true;
+      error.value = null;
+      try {
+        const value = await source.getValue(getParams());
+        if (thisLoadId !== _loadId) return;
+        data.value = value;
+        lastUpdated.value = Date.now();
+      } catch (e) {
+        if (thisLoadId !== _loadId) return;
+        error.value = e.message || "Unknown error";
+      } finally {
+        if (thisLoadId === _loadId) {
+          loading.value = false;
+        }
+      }
+    }
+    load();
+    const unsubscribeSource = source.subscribe(() => {
+      const cached = cacheManager.getStale(source.cacheKey);
+      if (cached !== null && cached !== void 0) {
+        data.value = cached;
+        lastUpdated.value = Date.now();
+      }
+    });
+    unsubscribers.push(unsubscribeSource);
+    const propKeys = Object.keys(props);
+    if (propKeys.length > 0) {
+      propKeys.forEach((k) => {
+        const prop = props[k];
+        if (prop && typeof prop === "object" && "value" in prop && prop._subscribers) {
+          const handler = () => {
+            source.invalidate();
+            load();
+          };
+          prop._subscribers.add(handler);
+          unsubscribers.push(() => prop._subscribers.delete(handler));
+        }
+      });
+    }
+    result[key] = {
+      data,
+      loading,
+      error,
+      lastUpdated,
+      refresh() {
+        source.invalidate();
+        return load();
+      },
+      // For StorageSource
+      setValue(value) {
+        if (source instanceof StorageSource) {
+          source.setValue(value);
+          data.value = value;
+        }
+      },
+      // For WebSocketSource
+      send(msg) {
+        if (source instanceof WebSocketSource) {
+          source.send(msg);
+        }
+      },
+      _source: source
+    };
+  }
+  result._dispose = () => {
+    unsubscribers.forEach((fn) => fn());
+    if (window.__kupolaDepInstances) {
+      const idx = window.__kupolaDepInstances.indexOf(result);
+      if (idx !== -1) window.__kupolaDepInstances.splice(idx, 1);
+    }
+  };
+  if (!window.__kupolaDepInstances) window.__kupolaDepInstances = [];
+  window.__kupolaDepInstances.push(result);
+  return result;
+}
+function useQuery(config2) {
+  const cacheManager = new CacheManager();
+  const source = createSource(config2, cacheManager);
+  const data = ref(null);
+  const loading = ref(true);
+  const error = ref(null);
+  let _loadId = 0;
+  async function load() {
+    const thisLoadId = ++_loadId;
+    loading.value = true;
+    error.value = null;
+    try {
+      const value = await source.getValue(config2.params || {});
+      if (thisLoadId !== _loadId) return;
+      data.value = value;
+    } catch (e) {
+      if (thisLoadId !== _loadId) return;
+      error.value = e.message || "Unknown error";
+    } finally {
+      if (thisLoadId === _loadId) loading.value = false;
+    }
+  }
+  load();
+  source.subscribe(() => {
+    const cached = cacheManager.getStale(source.cacheKey);
+    if (cached !== null && cached !== void 0) {
+      data.value = cached;
+    }
+  });
+  return {
+    data,
+    loading,
+    error,
+    refresh() {
+      source.invalidate();
+      return load();
+    }
+  };
+}
+function _extractPropValues(props) {
+  const result = {};
+  for (const key in props) {
+    const value = props[key];
+    if (value && typeof value === "object" && "value" in value) {
+      result[key] = value.value;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function clearCache() {
+}
+export {
+  formatNumber as $,
+  clearCache as A,
+  BRAND_OPTIONS as B,
+  CacheEntry as C,
+  DependsError as D,
+  configureHttpClient as E,
+  FetchedSource as F,
+  GlobalEvents as G,
+  createBrandPicker as H,
+  createI18n as I,
+  createLifecycle as J,
+  KupolaComponent as K,
+  createSource as L,
+  createStore as M,
+  createThemeToggle as N,
+  cryptoUtils as O,
+  dateUtils as P,
+  debounce as Q,
+  RouteSource as R,
+  Scheduler as S,
+  defineComponent as T,
+  defineMixin as U,
+  emit as V,
+  WebSocketSource as W,
+  emitGlobal as X,
+  escapeHtml as Y,
+  formatCurrency as Z,
+  formatDate as _,
+  globalEvents as a,
+  generateSecureId as a0,
+  getBasePath as a1,
+  getBrand as a2,
+  getConfig as a3,
+  getDefaultBrand as a4,
+  getDefaultTheme as a5,
+  getHttpClient as a6,
+  getHttpConfig as a7,
+  getIconsPath as a8,
+  getListenerCount as a9,
+  resetHttpClient as aA,
+  sanitizeHtml as aB,
+  setBrand as aC,
+  setConfig as aD,
+  setLocale as aE,
+  setTheme as aF,
+  stringUtils as aG,
+  stripHtml as aH,
+  t as aI,
+  throttle as aJ,
+  useDeps as aK,
+  useMixin as aL,
+  useQuery as aM,
+  validatorUtils as aN,
+  getLocale as aa,
+  getSecurityConfig as ab,
+  getStore as ac,
+  getTheme as ad,
+  initTheme as ae,
+  kupolaBootstrap as af,
+  kupolaData as ag,
+  kupolaEvents as ah,
+  kupolaI18n as ai,
+  kupolaLifecycle as aj,
+  kupolaRegistry as ak,
+  kupolaStoreManager as al,
+  maskData as am,
+  n as an,
+  numberUtils as ao,
+  objectUtils as ap,
+  off as aq,
+  offAll as ar,
+  offByScope as as,
+  offConfigChange as at,
+  on as au,
+  onConfigChange as av,
+  once as aw,
+  preloadUtils as ax,
+  registerComponent as ay,
+  registerLazyComponent as az,
+  getZIndexConfig as b,
+  getNotificationConfig as c,
+  getMessageConfig as d,
+  getValidationConfig as e,
+  getPerformanceConfig as f,
+  getUiConfig as g,
+  CacheManager as h,
+  ComponentInitializerRegistry as i,
+  DependsSource as j,
+  kupolaInitializer as k,
+  FunctionSource as l,
+  KupolaComponentRegistry as m,
+  KupolaDataBind as n,
+  KupolaEventBus as o,
+  KupolaI18n as p,
+  KupolaLifecycle as q,
+  ref as r,
+  KupolaStore as s,
+  KupolaStoreManager as t,
+  KupolaUtils as u,
+  StaticSource as v,
+  StorageSource as w,
+  applyMixin as x,
+  arrayUtils as y,
+  bootstrapComponents as z
+};