@trintel/zooy 1.0.1-beta.0 → 1.0.1

package/dist/chunks/main-BGOPab-5.js

@@ -0,0 +1,4041 @@
+const numericString = "0123456789".split("");
+[...numericString];
+const alphaLower = "abcdefghijklmnopqrstuvwxyz".split(""), alphaUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+[...alphaLower, ...alphaUpper, ...numericString];
+(/* @__PURE__ */ new Map()).set("true", !0).set("false", !1);
+const compose = (...O) => (...w) => O.reduce((D, U) => (F) => D(U(F)))(...w), identity = (O) => O, whatType = (O) => typeof O, isDef = (O) => O !== void 0, isUndefined = (O) => O === void 0, isDefAndNotNull = (O) => O != null, isString = (O) => whatType(O) === "string", isNumber = (O) => whatType(O) === "number" && !Number.isNaN(
+  /** @type number */
+  O
+), isObject = (O) => (O && typeof O == "object" && !(O instanceof Array) && !(O instanceof Set) && !(O instanceof Map) && !(O instanceof Date)) === !0, isArray = (O) => O instanceof Array, reverse = (O) => Array.from(O).reduce((w, D) => [D, ...w], []), toLowerCase = (O) => O.toLowerCase(), toString$1 = (O) => O + "", toNumber = (O) => +O;
+compose(toLowerCase, toString$1);
+const makeRandomString = () => {
+  let O = 2147483648;
+  return Math.floor(Math.random() * O).toString(36) + Math.abs(Math.floor(Math.random() * O) ^ Date.now()).toString(36);
+}, stripLeadingChar = (O) => (w) => w.startsWith(O) ? w.slice(O.length) : w, join = (O) => (w) => w.join(O);
+compose(join(""), reverse);
+const pathOr = (O, w) => (D) => {
+  const U = w.reduce((F, q) => {
+    try {
+      return F[maybeNumber(q)];
+    } catch {
+      return;
+    }
+  }, D);
+  return U === void 0 ? O : U;
+}, objToPaths = (O, w = [], D = []) => (Object.entries(O).forEach(([U, F]) => {
+  isObject(F) ? objToPaths(F, [...w, U], D) : D.push([[...w, U], F]);
+}), D), randomId = (O) => {
+  const w = makeRandomString();
+  return O ? w.substr(0, O) : w;
+}, maybeNumber = (O) => {
+  if (O === null || whatType(O) === "string" && O.length > 1 && O.startsWith("0") && !O.startsWith("0."))
+    return O;
+  const w = 1 * O;
+  return w > Number.MAX_SAFE_INTEGER || Number.isNaN(w) ? O : w;
+};
+compose(toNumber, join(""), reverse, toString$1);
+class Evt extends EventTarget {
+  /**
+   * Set this to true to get some debug in the console.
+   * @type {boolean}
+   * @private
+   */
+  #t = !1;
+  /**
+   * True if this is disposed.
+   * @type {boolean}
+   * @private
+   */
+  #e = !1;
+  /**
+   * A map of listener targets to an object of zoo-event functions
+   * When adding a listener, immediately also create the un-listen functions
+   * and store those in an object keyed with the event.
+   * Store these objects against the target in a map
+   * @type {Map<!EventTarget, !Object<string, !Function>>}
+   * @private
+   */
+  #s = /* @__PURE__ */ new Map();
+  /**
+   * A set of components that are currently listening to this component
+   * @type {!Set<!EventTarget>}
+   * @private
+   */
+  #r = /* @__PURE__ */ new Set();
+  /**
+   * A set of interval timers as defined by setInterval.
+   * Use this to store the timers created particular to this component.
+   * On destruction, these timers will be cleared.
+   * @type {Set<any>}
+   * @private
+   */
+  #n = /* @__PURE__ */ new Set();
+  //--[ Static ]--
+  /**
+   * Creates a CustomEvent with the given type and data payload.
+   * @param {string} event The event type
+   * @param {*} data The data to attach to the event's detail property
+   * @return {!CustomEvent} A new CustomEvent instance
+   */
+  static makeEvent(w, D) {
+    return new CustomEvent(w, { detail: D });
+  }
+  /**
+   * Sets debug mode for this component. When enabled, debug messages
+   * will be logged to the console.
+   * @param {boolean} bool True to enable debug mode, false to disable
+   * @throws {Error} If the value is not a boolean
+   */
+  set debugMode(w) {
+    if (typeof w != "boolean")
+      throw new Error("This must be a boolean");
+    this.#t = w;
+  }
+  get debugMode() {
+    return this.#t;
+  }
+  /**
+   * Returns whether this component has been disposed.
+   * @return {boolean} True if disposed, false otherwise
+   */
+  get disposed() {
+    return this.#e;
+  }
+  /**
+   * Returns the map of targets this component is listening to.
+   * @return {!Map<!EventTarget, !Object<string, !Function>>} Map of targets to their event handlers
+   */
+  get listeningTo() {
+    return this.#s;
+  }
+  get isObservedBy() {
+    return this.#r;
+  }
+  get activeIntervals() {
+    return this.#n;
+  }
+  /**
+   * Logs debug messages to the console if debug mode is enabled.
+   * Automatically prepends the constructor name to the output.
+   * @param {...*} s Arguments to log
+   */
+  debugMe(...w) {
+    this.#t && console.log.apply(null, [this.constructor.name, "DEBUG:", ...w]);
+  }
+  //--[ Listeners and Listening ]--
+  /**
+   * @param {!EventTarget|!Evt} comp
+   */
+  isListenedToBy(w) {
+    this.#r.add(w);
+  }
+  /**
+   * WARNING! DO not use options={passive: true} here. It disallows us to
+   * use preventDefault when we intercept the form, and that leads to a
+   * general inability to POST forms.
+   *
+   * @param {!EventTarget|!Evt|!Node} target
+   * @param {string} event
+   * @param {!Function} action
+   * @param {boolean|!Object} options
+   */
+  listen(w, D, U, F = !1) {
+    w.addEventListener(D, U, F);
+    const q = this.listeningTo.get(w) || {};
+    q[D] = () => w.removeEventListener(D, U, F), this.listeningTo.set(w, q), isDef(w.isListenedToBy) && w.isListenedToBy(this);
+  }
+  /**
+   * Remove self from all components tt are listening to me.
+   */
+  stopBeingListenedTo() {
+    for (const w of this.isObservedBy)
+      w.stopListeningTo(this), this.isObservedBy.delete(w);
+  }
+  /**
+   * Stop listening to all events on target.
+   * @param {!EventTarget|!Evt|!Node|undefined} target
+   * @param {string=} opt_event
+   */
+  stopListeningTo(w, D) {
+    w && this.listeningTo.has(w) && (isDef(w.isObservedBy) && w.isObservedBy.delete(this), isDef(D) ? (Object.entries(this.listeningTo.get(w)).forEach(([U, F]) => {
+      U === D && F();
+    }), Object.keys(this.listeningTo.get(w)).length || this.listeningTo.delete(w)) : (Object.values(this.listeningTo.get(w)).forEach((U) => U()), this.listeningTo.delete(w)));
+  }
+  /**
+   * Removes all the event listeners that is managed by this
+   * component.
+   */
+  removeAllListener() {
+    for (const w of this.listeningTo.keys())
+      this.stopListeningTo(w);
+  }
+  /**
+   * Clears all active intervals created by this component.
+   * Called automatically during disposal to prevent memory leaks.
+   */
+  clearAllIntervals() {
+    for (const w of this.activeIntervals)
+      clearInterval(w), this.activeIntervals.delete(w);
+  }
+  /**
+   * Executes a function repeatedly at a specified interval.
+   * The interval is tracked and will be automatically cleared on disposal.
+   * @param {!Function} f The function to execute on each interval
+   * @param {number} interval The interval in milliseconds
+   */
+  doOnBeat(w, D) {
+    const U = setInterval(w, D);
+    this.activeIntervals.add(U);
+  }
+  /**
+   * Disposes of the component.  Calls `exitDocument`, which is expected to
+   * remove event handlers and clean up the component.  Propagates the call to
+   * the component's children, if any. Removes the component's DOM from the
+   * document unless it was decorated.
+   * @protected
+   */
+  disposeInternal() {
+    this.stopBeingListenedTo(), this.removeAllListener(), this.clearAllIntervals(), this.#e = !0;
+  }
+  /**
+   * Public method to dispose of this component. Calls disposeInternal()
+   * to perform cleanup of event listeners, intervals, and observers.
+   * After calling this method, the component should not be used.
+   */
+  dispose() {
+    this.disposeInternal();
+  }
+}
+class ZooyEventData {
+  constructor(w, D) {
+    this.value_ = w, this.data_ = D || {};
+  }
+  getValue() {
+    return this.value_;
+  }
+  getData() {
+    return this.data_;
+  }
+}
+const UiEventType = {
+  /**
+   * Dispatched after the content from the template is in the DOM
+   * and the in-line scripts from the AJAX call has been eval'd.
+   */
+  COMP: randomId(),
+  COMP_DRAG_START: randomId(),
+  COMP_DRAG_MOVE: randomId(),
+  COMP_DRAG_END: randomId(),
+  PANEL: randomId(),
+  VIEW: randomId(),
+  SPLIT: randomId(),
+  SPLIT_WILL_OPEN: randomId(),
+  SPLIT_DID_OPEN: randomId(),
+  SPLIT_WILL_CLOSE: randomId(),
+  SPLIT_DID_CLOSE: randomId(),
+  SPLIT_TRANSITION_END: randomId(),
+  READY: randomId(),
+  PANEL_MINIMIZE: randomId(),
+  FORM_SUBMIT_SUCCESS: randomId()
+};
+var EN_US = ["second", "minute", "hour", "day", "week", "month", "year"];
+function en_US(O, w) {
+  if (w === 0)
+    return ["just now", "right now"];
+  var D = EN_US[Math.floor(w / 2)];
+  return O > 1 && (D += "s"), [O + " " + D + " ago", "in " + O + " " + D];
+}
+var ZH_CN = ["秒", "分钟", "小时", "天", "周", "个月", "年"];
+function zh_CN(O, w) {
+  if (w === 0)
+    return ["刚刚", "片刻后"];
+  var D = ZH_CN[~~(w / 2)];
+  return [O + " " + D + "前", O + " " + D + "后"];
+}
+var Locales = {}, register = function(O, w) {
+  Locales[O] = w;
+}, getLocale = function(O) {
+  return Locales[O] || Locales.en_US;
+}, SEC_ARRAY = [
+  60,
+  60,
+  24,
+  7,
+  365 / 7 / 12,
+  12
+];
+function toDate(O) {
+  return O instanceof Date ? O : !isNaN(O) || /^\d+$/.test(O) ? new Date(parseInt(O)) : (O = (O || "").trim().replace(/\.\d+/, "").replace(/-/, "/").replace(/-/, "/").replace(/(\d)T(\d)/, "$1 $2").replace(/Z/, " UTC").replace(/([+-]\d\d):?(\d\d)/, " $1$2"), new Date(O));
+}
+function formatDiff(O, w) {
+  var D = O < 0 ? 1 : 0;
+  O = Math.abs(O);
+  for (var U = O, F = 0; O >= SEC_ARRAY[F] && F < SEC_ARRAY.length; F++)
+    O /= SEC_ARRAY[F];
+  return O = Math.floor(O), F *= 2, O > (F === 0 ? 9 : 1) && (F += 1), w(O, F, U)[D].replace("%s", O.toString());
+}
+function diffSec(O, w) {
+  var D = /* @__PURE__ */ new Date();
+  return (+D - +toDate(O)) / 1e3;
+}
+var format = function(O, w, D) {
+  var U = diffSec(O);
+  return formatDiff(U, getLocale(w));
+};
+register("en_US", en_US);
+register("zh_CN", zh_CN);
+const getInputChecked_ = function(O) {
+  return O.checked ? (
+    /** @type {?} */
+    O.value
+  ) : null;
+}, getSelectSingle_ = function(O) {
+  const w = (
+    /** @type {!HTMLSelectElement} */
+    O.selectedIndex
+  );
+  return w >= 0 ? (
+    /** @type {!HTMLSelectElement} */
+    O.options[w].value
+  ) : null;
+}, getSelectMultiple_ = function(O) {
+  const w = [];
+  for (let D, U = 0; D = /** @type {!HTMLSelectElement} */
+  O.options[U]; U++)
+    D.selected && w.push(D.value);
+  return w.length ? w : null;
+}, getValue = function(O) {
+  const w = (
+    /** @type {!HTMLInputElement} */
+    O.type
+  );
+  switch (isString(w) && w.toLowerCase()) {
+    case "checkbox":
+    case "radio":
+      return getInputChecked_(O);
+    case "select-one":
+      return getSelectSingle_(O);
+    case "select-multiple":
+      return getSelectMultiple_(O);
+    default:
+      return O.value !== null && O.value !== void 0 ? O.value : null;
+  }
+}, formToJSON = (O) => [...O].reduce((w, D) => (w[D.name] = D.value, w), {}), replaceNode = (O, w) => {
+  const D = w.parentNode;
+  D && D.replaceChild(O, w);
+}, removeNode = (O) => O && O.parentNode ? O.parentNode.removeChild(O) : null, insertSiblingAfter = (O, w) => {
+  w.parentNode && w.parentNode.insertBefore(O, w.nextSibling);
+}, isInPage = (O) => O === document.body ? !1 : document.body.contains(O), getPos = (O) => [O.offsetLeft, O.offsetTop], randomColour = (O) => [1, 2, 3].map(() => Math.floor(Math.random() * 256) + 1).reduce((w, D) => `${w}${D},`, "rgba(") + `${O || 0.5}`, totalWidth = (O) => {
+  const w = window.getComputedStyle(O), D = O.offsetWidth, U = parseFloat(w.marginLeft) + parseFloat(w.marginRight), F = parseFloat(w.paddingLeft) + parseFloat(w.paddingRight), q = parseFloat(w.borderLeftWidth) + parseFloat(w.borderRightWidth);
+  return D + U - F + q;
+}, totalHeight = (O) => {
+  const w = window.getComputedStyle(O), D = O.offsetHeight, U = parseFloat(w.marginTop) + parseFloat(w.marginBottom), F = parseFloat(w.paddingTop) + parseFloat(w.paddingBottom), q = parseFloat(w.borderTopWidth) + parseFloat(w.borderBottomWidth);
+  return D + U - F + q;
+}, evalScripts = (comp) => (arr) => {
+  arr && Array.from(arr).forEach((s) => {
+    (function() {
+      eval(s.text);
+    }).bind(comp)();
+  });
+}, evalModules = (O) => (w) => {
+  w && Array.from(w).forEach((D) => {
+    (function() {
+      const U = document.createElement("script");
+      U.type = "module", U.textContent = D.textContent;
+      const F = O.getElement(), q = getElDataMap(D).zv_comp_access;
+      q && (F.zvComponent = O, F.classList.add(q)), F.appendChild(U);
+    }).bind(O)();
+  });
+}, splitScripts = (O) => {
+  const D = new DOMParser().parseFromString(O, "text/html");
+  return {
+    html: D.body.firstElementChild,
+    scripts: D.querySelectorAll('script:not([type="module"])'),
+    modules: D.querySelectorAll('script[type="module"]')
+  };
+}, handleTemplateProm = (O) => Promise.resolve(splitScripts(O)), enableClass = (O, w, D) => {
+  D ? O.classList.add(w) : O.classList.remove(w);
+}, toggleClass = (O, w) => {
+  const D = !Array.from(O.classList).includes(w);
+  return enableClass(O, w, D), D;
+}, getElDataMap = (O) => O ? Object.assign({}, O.dataset || {}) : {}, dtFormatter = {
+  year: "numeric",
+  month: "short",
+  day: "numeric",
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+}, dFormatter = {
+  year: "numeric",
+  month: "short",
+  day: "numeric"
+}, dtf = new Intl.DateTimeFormat("en", {
+  day: "2-digit",
+  month: "short",
+  year: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  // hour12: false
+  hourCycle: "h23"
+}), dateToZooyStdTimeString = (O) => {
+  const [{ value: w }, , { value: D }, , { value: U }, , { value: F }, , { value: q }, , { value: W }, ,] = dtf.formatToParts(O);
+  return `${D} ${w} ${U} ${F}:${q}:${W}`;
+}, parseMomentAgo = (O, w = "both", D = void 0) => {
+  let U = O;
+  isNumber(U) && U < 9466848e5 ? U = U * 1e3 : D && (U = U + D);
+  const F = new Date(U), q = format(F), W = dateToZooyStdTimeString(F);
+  switch (w) {
+    case "time|ago":
+      return `${W}|${q}`;
+    case "ago":
+      return `${q}`;
+    case "datetime":
+    case "time":
+      return `${W}`;
+    case "both":
+    case "ago (time)":
+    default:
+      return `${q} (${W})`;
+  }
+}, parseObfuscated = (O) => {
+  const D = ((F) => (q) => q < F.length - 4)(O);
+  return ((F) => F.split("").map((q, W) => D(W) ? "*" : q).join(""))(O);
+}, parseMap = (/* @__PURE__ */ new Map()).set(void 0, (O, w, D) => identity(O)).set("", (O, w, D) => identity(O)).set("class_update_only", (O, w, D) => identity(O)).set("frac_100", (O, w, D) => Math.round(O * 100 * 100) / 100).set("date_and_time", (O, w, D) => new Date(O).toLocaleString(void 0, dtFormatter)).set("date", (O, w, D) => new Date(O).toLocaleString(void 0, dFormatter)).set("moment_ago", (O, w, D) => parseMomentAgo(O, "both", D.zdd_date_tz || void 0)).set("moment_ago_only", (O, w, D) => parseMomentAgo(O, "ago", D.zdd_date_tz || void 0)).set("moment_ago_datetime", (O, w, D) => parseMomentAgo(O, "datetime", D.zdd_date_tz || void 0)).set("pretty-json", (O, w, D) => JSON.stringify(O, null, 4)).set("obfuscated", (O, w, D) => parseObfuscated(O)).set("linear-progress", (O, w, D) => {
+  const U = toNumber(D.zpmax), F = w.linProg;
+  return U && F && (F.progress = O / U, O = void 0), O;
+}), parseDataPropKvDef = (O) => O.trim().split(",").map((U) => U.trim()).map((U) => {
+  const [F, q] = U.split(":").map((W) => W.trim());
+  return [F, q];
+}).filter(([U, F]) => U !== "" && F !== ""), parseDataProps = (O, w) => {
+  const D = getElDataMap(O);
+  delete O.dataset.zoodatapropkv;
+  const U = D.zoodatapropkv || "";
+  return parseDataPropKvDef(U).forEach(([q, W]) => {
+    O.dataset[q] = pathOr(void 0, W.split("."))(w);
+  }), O;
+}, mapDataToEls = (O, w, D = /* @__PURE__ */ new Map(), U = void 0) => {
+  if (!w)
+    return;
+  const F = new Map([...parseMap, ...D]);
+  [...O.querySelectorAll("[data-zdd],[data-zdd_class_update],[data-zdd_template_loop_index]")].forEach((q) => {
+    const W = getElDataMap(q), Y = W.zdd || "", G = W.zdd_parse_as, Z = W.zdd_render_effect || "", Q = W.zdd_class_update, tt = W.zdd_template_loop_index, J = W.zdd_units || "";
+    let X = pathOr(void 0, Y.split("."))(w);
+    if (isDefAndNotNull(X) && (X = F.has(G) ? F.get(G)(X, q, W) : X), tt && isNumber(U) && (console.log("loopIndex: ", tt, " opt_loopIndex: ", U), tt === "zero_indexed" ? q.innerHTML = U : tt === "one_indexed" ? q.innerHTML = U + 1 : q.innerHTML = U), Q) {
+      const [K, et, st] = Q.split(":"), rt = pathOr(void 0, K.split("."))(w);
+      if (isDefAndNotNull(rt))
+        switch (et) {
+          case "swap": {
+            const nt = /\{}/gi, ot = st.replace(nt, ""), ct = st.replace(nt, rt);
+            q.classList.remove(...[...q.classList].filter((ht) => ht.includes(ot))), q.classList.add(ct);
+            break;
+          }
+          case "remove_on_data":
+            q.classList.remove(st);
+            break;
+          case "choice_map":
+            st.split("|").filter((nt) => nt !== "").forEach((nt) => {
+              const [ot, ct] = nt.split(">");
+              ot === rt + "" ? q.classList.add.apply(q.classList, ct.split(".")) : q.classList.remove.apply(q.classList, ct.split("."));
+            });
+            break;
+        }
+    }
+    if (G === "templated-array" && isArray(X))
+      if (X.length === 0)
+        q.classList.add("display__none");
+      else {
+        q.classList.remove("display__none"), X = X || [];
+        const K = q.firstElementChild;
+        K.classList.remove("display__none"), q.replaceChildren(...X.map((et, st) => {
+          const rt = K.cloneNode(!0), nt = parseDataProps(rt, et);
+          return mapDataToEls(nt, et, void 0, st), nt;
+        }));
+      }
+    else if (isDefAndNotNull(X))
+      if (Z === "typewriter") {
+        let K = 0;
+        const et = X + J, st = 5, rt = () => {
+          K < et.length && (q.innerHTML += et.charAt(K), K++, setTimeout(rt, st));
+        };
+        q.innerHTML = "", rt();
+      } else
+        q.innerHTML = X + J;
+  });
+}, domUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  dateToZooyStdTimeString,
+  dtf,
+  enableClass,
+  evalModules,
+  evalScripts,
+  formToJSON,
+  getElDataMap,
+  getPos,
+  getValue,
+  handleTemplateProm,
+  insertSiblingAfter,
+  isInPage,
+  mapDataToEls,
+  parseDataPropKvDef,
+  parseMap,
+  parseMomentAgo,
+  randomColour,
+  removeNode,
+  replaceNode,
+  splitScripts,
+  toggleClass,
+  totalHeight,
+  totalWidth
+}, Symbol.toStringTag, { value: "Module" }));
+class ComponentLibraryRegistry {
+  /**
+   * Internal storage for registered component libraries.
+   * @type {Map<string, {render: Function, cache: Map, config: Object}>}
+   * @private
+   */
+  static #t = /* @__PURE__ */ new Map();
+  /**
+   * Registers a pluggable component library.
+   *
+   * @param {string} name - Library identifier (e.g., 'carbon', 'material')
+   * @param {Object} library - Library configuration object
+   * @param {Function} library.render - Main render function: async function(panel, cache)
+   * @param {Function} [library.dispose] - Optional cleanup function: function(element)
+   * @param {Object} [library.config] - Optional library-specific configuration
+   *
+   * @throws {Error} If library doesn't provide a render function
+   *
+   * @example
+   * ComponentLibraryRegistry.register('carbon', {
+   *   render: async function(panel, cache) {
+   *     // Scan, load, and attach components
+   *   },
+   *   dispose: function(element) {
+   *     // Optional cleanup logic
+   *   },
+   *   config: { version: '2.0' }
+   * });
+   */
+  static register(w, D) {
+    if (!D.render)
+      throw new Error(`Component library '${w}' must provide a render function`);
+    this.#t.set(w, {
+      ...D,
+      // Preserve all library properties (utils, helpers, etc.)
+      dispose: D.dispose || null,
+      // Optional disposal function
+      cache: /* @__PURE__ */ new Map(),
+      // Each library gets its own import cache
+      config: D.config || {}
+    }), console.debug(`[ComponentLibraryRegistry] Registered: ${w}`);
+  }
+  /**
+   * Gets a registered component library by name.
+   *
+   * @param {string} name - Library identifier
+   * @returns {Object} Library object with render, cache, config
+   * @throws {Error} If library is not registered
+   */
+  static get(w) {
+    if (!this.#t.has(w)) {
+      const D = Array.from(this.#t.keys()).join(", ");
+      throw new Error(
+        `Component library '${w}' is not registered. Available: ${D || "none"}`
+      );
+    }
+    return this.#t.get(w);
+  }
+  /**
+   * Checks if a component library is registered.
+   *
+   * @param {string} name - Library identifier
+   * @returns {boolean} True if registered
+   */
+  static has(w) {
+    return this.#t.has(w);
+  }
+  /**
+   * Gets all registered library names.
+   *
+   * @returns {string[]} Array of registered library names
+   */
+  static getRegisteredLibraries() {
+    return Array.from(this.#t.keys());
+  }
+  /**
+   * Gets cache statistics for all registered component libraries.
+   * Useful for debugging and monitoring.
+   *
+   * @returns {Object} Map of library name → cache stats
+   */
+  static getCacheStats() {
+    const w = {};
+    for (const [D, U] of this.#t.entries())
+      w[D] = {
+        cacheSize: U.cache.size,
+        config: U.config
+      };
+    return w;
+  }
+  /**
+   * Clears import caches for all component libraries.
+   * Useful for development/hot-reload scenarios.
+   */
+  static clearAllCaches() {
+    for (const [w, D] of this.#t.entries())
+      D.cache.clear(), console.debug(`[ComponentLibraryRegistry] Cleared cache for: ${w}`);
+  }
+  /**
+   * Clears cache for a specific library.
+   *
+   * @param {string} name - Library identifier
+   * @throws {Error} If library is not registered
+   */
+  static clearCache(w) {
+    this.get(w).cache.clear(), console.debug(`[ComponentLibraryRegistry] Cleared cache for: ${w}`);
+  }
+  /**
+   * Unregisters a component library (primarily for testing).
+   *
+   * @param {string} name - Library identifier
+   * @returns {boolean} True if library was unregistered, false if not found
+   */
+  static unregister(w) {
+    return this.#t.delete(w);
+  }
+  /**
+   * Unregisters all component libraries (primarily for testing).
+   */
+  static unregisterAll() {
+    this.#t.clear();
+  }
+}
+const ComponentError = {
+  /**
+   * Error when a method is not supported.
+   */
+  NOT_SUPPORTED: "Method not supported",
+  /**
+   * Error when the given element can not be decorated.
+   */
+  DECORATE_INVALID: "Invalid element to decorate",
+  /**
+   * Error when the component is already rendered and another render attempt is
+   * made.
+   */
+  ALREADY_RENDERED: "Component already rendered",
+  /**
+   * Error when an already disposed component is attempted to be rendered.
+   */
+  ALREADY_DISPOSED: "Component already disposed",
+  /**
+   * Error when an attempt is made to set the parent of a component in a way
+   * that would result in an inconsistent object graph.
+   */
+  PARENT_UNABLE_TO_BE_SET: "Unable to set parent component",
+  /**
+   * Error when an attempt is made to add a child component at an out-of-bounds
+   * index.  We don't support sparse child arrays.
+   */
+  CHILD_INDEX_OUT_OF_BOUNDS: "Child component index out of bounds",
+  /**
+   * Error when an attempt is made to remove a child component from a component
+   * other than its parent.
+   */
+  NOT_OUR_CHILD: "Child is not in parent component",
+  /**
+   * Error when an operation requiring DOM interaction is made when the
+   * component is not in the document
+   */
+  NOT_IN_DOCUMENT: "Operation not supported while component is not in document",
+  /**
+   * Error when an invalid component state is encountered.
+   */
+  STATE_INVALID: "Invalid component state"
+};
+class Component extends Evt {
+  //--[ Static ]--
+  /**
+   * Returns the component event type code used for dispatching component events.
+   * @return {string} The COMP event type
+   */
+  static compEventCode() {
+    return UiEventType.COMP;
+  }
+  /**
+   * Returns the component ready event type code.
+   * @return {string} The READY event type
+   */
+  static compReadyCode() {
+    return UiEventType.READY;
+  }
+  /**
+   * Returns the component error enumeration object.
+   * @return {!Object<string, string>} The ComponentError enum
+   */
+  static compErrors() {
+    return ComponentError;
+  }
+  #t;
+  #e;
+  #s;
+  #r;
+  #n;
+  #i;
+  #o;
+  #a;
+  constructor() {
+    super(), this.#t = () => (
+      /** @type {!HTMLElement} */
+      document.createElement("div")
+    ), this.#e = !1, this.#s = void 0, this.#r = void 0, this.#n = void 0, this.#i = void 0, this.#o = /* @__PURE__ */ new Map(), this.outOfTreeElements = [], this.placeholderDom = void 0, this.#a = () => {
+    };
+  }
+  //--[ Getters and Setters ]--
+  /**
+   * @param {Element|undefined} e
+   */
+  set target(w) {
+    this.#n = w;
+  }
+  /**
+   * @returns {Element|undefined}
+   */
+  get target() {
+    return this.#n;
+  }
+  /**
+   * Sets the model associated with the UI component.
+   * @param {*} m
+   */
+  set model(w) {
+    this.#r = w;
+  }
+  /**
+   * Returns the model associated with the UI component.
+   * @return {*}
+   */
+  get model() {
+    return this.#r;
+  }
+  /**
+   * @param {boolean} bool
+   */
+  set isInDocument(w) {
+    this.#e = w;
+  }
+  /**
+   * @return {boolean}
+   */
+  get isInDocument() {
+    return this.#e;
+  }
+  /**
+   * A function that makes a DOM element.
+   * @param {!function():(!HTMLElement|!Element|!DocumentFragment)} func
+   */
+  set domFunc(w) {
+    this.#t = w;
+  }
+  /**
+   * @param {!Function} func A callback guaranteed to fire after the panels is
+   * ready, and in the document, but before the
+   * {@code UiEventType.READY} event is fired.
+   */
+  set readyFunc(w) {
+    this.#a = w;
+  }
+  //--[ DOM Management ]--
+  /**
+   * Internal method to set the component's root element. Used primarily during
+   * rendering and re-rendering operations.
+   * @param {!Node} frag The DOM node to set as this component's element
+   * @private
+   */
+  setElementInternal_(w) {
+    this.#s = w;
+  }
+  /**
+   * Gets the component's element.
+   * @return {!HTMLElement|undefined} The element
+   *    for the component.
+   */
+  getElement() {
+    return this.#s;
+  }
+  /**
+   * Creates the initial DOM representation for the component.  The default
+   * implementation is to set this.element_ = div.
+   */
+  createDom() {
+    this.#s = this.#t();
+  }
+  /**
+   * Asserts that this component can be rendered asynchronously.
+   * Throws an error if the component has already been disposed.
+   * Used by async rendering methods to validate component state.
+   * @throws {Error} If the component is already disposed
+   */
+  assertCanRenderAsync() {
+    if (this.disposed)
+      throw new Error(ComponentError.ALREADY_DISPOSED);
+  }
+  /**
+   * Renders the component.  If a parent element is supplied, the component's
+   * element will be appended to it.  If there is no optional parent element and
+   * the element doesn't have a parentNode then it will be appended to the
+   * document body.
+   *
+   * If this component has a parent component, and the parent component is
+   * not in the document already, then this will not call `enterDocument`
+   * on this component.
+   *
+   * Throws an Error if the component is already rendered.
+   *
+   * @param {Element=} opt_parentElement Optional parent element to render the
+   *    component into.
+   */
+  render(w) {
+    this.render_(w);
+  }
+  /**
+   * Renders the component.  If a parent element is supplied, the component's
+   * element will be appended to it.  If there is no optional parent element and
+   * the element doesn't have a parentNode then it will be appended to the
+   * document body.
+   *
+   * If this component has a parent component, and the parent component is
+   * not in the document already, then this will not call `enterDocument`
+   * on this component.
+   *
+   * Throws an Error if the component is already rendered.
+   *
+   * @param {Element=} opt_target Optional parent element to render the
+   *    component into.
+   * @private
+   */
+  render_(w) {
+    if (this.disposed)
+      throw new Error(ComponentError.ALREADY_DISPOSED);
+    if (this.isInDocument)
+      throw new Error(ComponentError.ALREADY_RENDERED);
+    this.#s || this.createDom();
+    const D = (
+      /** @type {!Node} */
+      this.#s
+    );
+    w && (this.#n = w), this.placeholderDom && removeNode(this.placeholderDom), this.#n ? isInPage(D) || this.#n.insertBefore(D, null) : isInPage(
+      /** @type {!Node} */
+      D
+    ) || document.body.appendChild(D), (!this.#i || this.#i.isInDocument) && this.enterDocument();
+  }
+  //--[ Life-cycle ]--
+  /**
+   * @param {Node} el
+   * @param {Node} targetParent
+   */
+  hoist(w, D = void 0) {
+    D || (D = document.querySelector("body")), D.appendChild(w), this.outOfTreeElements.push(w);
+  }
+  /**
+   * Executes the beforeReady callback function if one was set.
+   * Called automatically during enterDocument, before the READY event is dispatched.
+   * Allows components to perform final setup operations once they're in the DOM.
+   */
+  executeBeforeReady() {
+    this.#a();
+  }
+  /**
+   * Called when the component's element is known to be in the document. Anything
+   * using document.getElementById etc. should be done at this stage.
+   *
+   * If the component contains child components, this call is propagated to its
+   * children.
+   */
+  enterDocument() {
+    this.disposed ? removeNode(this.getElement()) : (this.isInDocument = !0, [...this.#o.values()].forEach((w) => {
+      !w.isInDocument && w.getElement() && w.enterDocument();
+    }), this.executeBeforeReady(), this.dispatchCompEvent(UiEventType.READY));
+  }
+  /**
+   * Called by dispose to clean up the elements and listeners created by a
+   * component, or by a parent component/application who has removed the
+   * component from the document but wants to reuse it later.
+   *
+   * If the component contains child components, this call is propagated to its
+   * children.
+   *
+   * It should be possible for the component to be rendered again once this
+   * method has been called.
+   */
+  exitDocument() {
+    [...this.#o.values()].forEach((w) => {
+      w.isInDocument && w.exitDocument();
+    }), this.stopBeingListenedTo(), this.removeAllListener(), this.isInDocument = !1, removeNode(this.getElement()), this.placeholderDom && removeNode(this.placeholderDom);
+  }
+  /**
+   * Disposes of the component.  Calls `exitDocument`, which is expected to
+   * remove event handlers and clean up the component.  Propagates the call to
+   * the component's children, if any. Removes the component's DOM from the
+   * document unless it was decorated.
+   * @protected
+   */
+  disposeInternal() {
+    this.isInDocument && this.exitDocument(), this.#o && [...this.#o.values()].forEach((w) => w.disposeInternal()), this.outOfTreeElements.forEach(removeNode), this.#s && removeNode(this.#s), this.placeholderDom && removeNode(this.placeholderDom), this.#o = null, this.#s = void 0, this.#r = null, this.#i = null, super.disposeInternal();
+  }
+  /**
+   * Disposes of the component and performs cleanup. Aborts any pending async
+   * operations, asks registered component libraries to cleanup their components,
+   * and calls the parent dispose method.
+   * After calling this method, the component should not be used.
+   */
+  dispose() {
+    this.abortController && this.abortController.abort();
+    const w = this.getElement();
+    if (w)
+      for (const D of ComponentLibraryRegistry.getRegisteredLibraries())
+        try {
+          const U = ComponentLibraryRegistry.get(D);
+          U.dispose && U.dispose(w);
+        } catch (U) {
+          console.debug(`[${D}] Cleanup error during component disposal (non-critical):`, U);
+        }
+    super.dispose();
+  }
+  //--[ Built in events ]--
+  /**
+   * Dispatches a {@code UiEventType.COMP} event.
+   * A shorthand method to get panels to dispatch uniform events.
+   * Views may listen just to this event, and act on the supplied value or
+   * data payload.
+   * Example:
+   *    b.listen(a, Component.compEventCode(), e => {
+   *      console.log('B got', Component.compEventCode(), e);
+   *      console.log('Value is', e.detail.getValue());
+   *      console.log('Data is', e.detail.getData());
+   *    });
+   * @param {string|number} value
+   * @param {(string|number|?Object)=} opt_data
+   * @return {boolean} If anyone called preventDefault on the event object (or
+   *     if any of the handlers returns false this will also return false.
+   */
+  dispatchCompEvent(w, D) {
+    const U = new ZooyEventData(w, D), F = Evt.makeEvent(UiEventType.COMP, U);
+    return this.dispatchEvent(F);
+  }
+}
+const EV = {
+  // Mouse events
+  CLICK: "click",
+  DBLCLICK: "dblclick",
+  MOUSEDOWN: "mousedown",
+  MOUSEUP: "mouseup",
+  MOUSEMOVE: "mousemove",
+  // Touch events
+  // Note that other touch events exist, but we should follow the W3C list here.
+  // http://www.w3.org/TR/touch-events/#list-of-touchevent-types
+  TOUCHSTART: "touchstart",
+  TOUCHMOVE: "touchmove",
+  TOUCHEND: "touchend",
+  // Form events
+  SUBMIT: "submit",
+  CHANGE: "change",
+  INPUT: "input",
+  INVALID: "invalid",
+  // Drag and drop events
+  DRAGSTART: "dragstart",
+  DRAGEND: "dragend",
+  DRAGOVER: "dragover",
+  DRAGENTER: "dragenter",
+  DRAGEXIT: "dragexit",
+  DRAGLEAVE: "dragleave",
+  DROP: "drop",
+  // Transitions
+  TRANSITIONEND: "transitionend"
+}, touchEvents = [EV.TOUCHMOVE, EV.TOUCHSTART, EV.TOUCHEND], isTouchEvent = (O) => touchEvents.includes(O.type), normalizeEvent = (O) => (isTouchEvent(O) && (O.clientX = O.targetTouches[0].clientX, O.clientY = O.targetTouches[0].clientY), O), dragStartListener = (O, w, D, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F), W = (
+    /** @type {!HTMLElement} */
+    q.currentTarget
+  ), [Y, G] = getPos(W), Z = q.clientX - Y, Q = q.clientY - G, tt = O(Y, G, Z, Q, W), J = D(Y, G, Z, Q, W), X = w(Y, G, Z, Q, W);
+  let K = freeMoveListener(X, W, Z, Q);
+  ["x", "ew"].includes(U) ? K = xMoveOnlyListener(X, W, Z) : ["y", "ns"].includes(U) && (K = yMoveOnlyListener(X, W, Z, Q));
+  let et = !1;
+  const st = (nt) => {
+    et = !0, K(nt);
+  }, rt = (nt) => {
+    document.removeEventListener(EV.MOUSEMOVE, st, !0), document.removeEventListener(EV.TOUCHMOVE, st, !0), document.removeEventListener(EV.MOUSEUP, rt, !0), document.removeEventListener(EV.TOUCHEND, rt, !0), et && J(nt);
+  };
+  return document.addEventListener(EV.MOUSEUP, rt, !0), document.addEventListener(EV.TOUCHEND, rt, !0), document.addEventListener(EV.MOUSEMOVE, st, !0), document.addEventListener(EV.TOUCHMOVE, st, !0), tt(F), rt;
+}, freeMoveListener = (O, w, D, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F);
+  w.style.left = `${q.clientX - D}px`, w.style.top = `${q.clientY - U}px`, O(q);
+}, xMoveOnlyListener = (O, w, D, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F);
+  w.style.left = `${q.clientX - D}px`, O(q);
+}, yMoveOnlyListener = (O, w, D, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F);
+  w.style.top = `${q.clientY - U}px`, O(q);
+}, makeEmitter = (O, w) => (D, U, F, q, W) => (Y) => {
+  O.dispatchCompEvent(w, {
+    component: O,
+    browserEvent: Y,
+    left: D,
+    top: U,
+    clientX: Y.clientX,
+    clientY: Y.clientY,
+    xOrg: F,
+    yOrg: q,
+    deltaX: Y.clientX - F - D,
+    deltaY: Y.clientY - q - U,
+    target: W
+  });
+};
+class Dragger extends Component {
+  #t;
+  #e;
+  #s;
+  #r;
+  /**
+   * @param {string} freedom Restrict the directions in which the
+   * dragger can be moved.
+   */
+  constructor(w = "xy") {
+    super(), this.#t = ["x", "y", "xy", "ew", "ns"].includes(w.toLowerCase()) ? w.toLowerCase() : "xy", this.#e = void 0, this.#s = !0, this.#r = (D) => null;
+  }
+  /**
+   * Cancels the current drag operation in progress, if any.
+   * @param {!Event} event The event that triggered the cancel
+   */
+  cancelDrag(w) {
+    this.#r(w);
+  }
+  //--[ Getters and Setters ]--
+  /**
+   * Sets the direction in which the component can be dragged.
+   * Only 'x' or 'y' will lock the movements to those directions.
+   * Anything else will be considered free movement
+   * @param {string} axis
+   */
+  set moveFreedom(w) {
+    this.#t = w, this.#s || (this.lock(), this.unlock());
+  }
+  /**
+   * Get the direction in which this component can move.
+   * @return {string}
+   */
+  get moveFreedom() {
+    return this.#t;
+  }
+  //--[ Override ]--
+  /**
+   * @inheritDoc
+   */
+  executeBeforeReady() {
+    this.unlock(), super.executeBeforeReady();
+  }
+  //--[ Dragger Specific ]--
+  /**
+   * Make the component draggable
+   */
+  unlock() {
+    const w = (D) => (U) => {
+      this.#r = D(U);
+    };
+    if (this.isInDocument && this.#s) {
+      const D = makeEmitter(this, UiEventType.COMP_DRAG_MOVE), U = makeEmitter(this, UiEventType.COMP_DRAG_START), F = makeEmitter(this, UiEventType.COMP_DRAG_END), q = dragStartListener(
+        U,
+        D,
+        F,
+        this.#t
+      );
+      this.#s = !1, this.#e = /** @type {!Node} */
+      this.#e || this.getElement(), this.listen(this.#e, EV.MOUSEDOWN, w(q)), this.listen(this.#e, EV.TOUCHSTART, q), this.#e.classList.remove("locked");
+    }
+  }
+  /**
+   * Lock the component in place.
+   * Removes all the listeners added when it was made draggable.
+   */
+  lock() {
+    this.stopListeningTo(this.#e, EV.MOUSEDOWN), this.stopListeningTo(this.#e, EV.TOUCHSTART), this.#s = !0, this.#e.classList.add("locked");
+  }
+}
+const splitRe_ = new RegExp(
+  "^(?:([^:/?#.]+):)?(?://(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\\?([^#]*))?(?:#([\\s\\S]*))?$"
+), ComponentIndex = {
+  PATH: 5,
+  QUERY_DATA: 6
+}, split = (O) => (
+  /** @type {!Array<string|undefined>} */
+  O.match(splitRe_)
+), decodeOrEmpty_ = (O, w) => O ? decodeURI(O.replace(/%25/g, "%2525")) : "", getPath = (O) => decodeOrEmpty_(split(O)[ComponentIndex.PATH]), getQueryData = (O) => decodeOrEmpty_(split(O)[ComponentIndex.QUERY_DATA]), objectToUrlParms = (O) => [...Object.entries(O)].map(
+  (w) => `${w[0]}=${w[1]}`
+).join("&"), isValidValue = (O) => O != null && O !== "", queryDataToMap = (O) => O.split("&").reduce((w, D) => {
+  const [U, F] = D.split("=");
+  return isValidValue(U) && isValidValue(F) && w.set(U, F), w;
+}, /* @__PURE__ */ new Map()), uriUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getPath,
+  getQueryData,
+  objectToUrlParms,
+  queryDataToMap
+}, Symbol.toStringTag, { value: "Module" })), stripLeadingSpace = stripLeadingChar(" "), stripLeadingSlash = stripLeadingChar("/"), getCookieByName = (O) => document.cookie.split(";").map((w) => w.split("=")).reduce((w, D) => w.set(stripLeadingSpace(D[0]), D[1]), /* @__PURE__ */ new Map()).get(O), spinner = (O) => {
+  let w = 0, D;
+  const U = (F) => {
+    const q = F > 0;
+    return q ? w += 1 : w -= 1, q ? w === 1 : w === 0;
+  };
+  return (F) => {
+    D = D || document.getElementById(O), D && U(F) && D.classList.toggle("viz", w > 0);
+  };
+}, spin = spinner("the_loader"), startSpin = () => Promise.resolve(spin(1)), stopSpin = (O) => (spin(0), Promise.resolve(O)), checkStatus = (O) => O.ok ? Promise.resolve(O) : Promise.reject(new Error(`${O.url} ${O.status} (${O.statusText})`)), checkStatusTwo = (O) => (w) => {
+  if (w.type === "opaqueredirect" || w.redirected) {
+    const D = stripLeadingSlash(getPath(w.url));
+    O.setIsRedirected(!0, D), console.log("Redirect detected", D);
+  }
+  return checkStatus(w);
+}, getJson = (O) => O.json(), getText = (O) => O.text().then(
+  (w) => Promise.resolve(w),
+  (w) => Promise.reject(new Error(`Could not get text from response: ${w}`))
+), getTextOrJson = (O) => O.headers.get("Content-Type") === "application/json" ? getJson(O) : getText(O), jsonInit = (O, w, D = "POST", U = void 0) => {
+  const F = new Headers();
+  F.append("Content-type", "application/json"), F.append("X-Requested-With", "XMLHttpRequest"), O && O !== "" && F.append("Authorization", `Bearer ${O}`);
+  const q = {
+    cache: "no-cache",
+    method: D,
+    headers: F,
+    credentials: "include",
+    body: JSON.stringify(w)
+  };
+  return U && (q.signal = U), q;
+}, basicPutPostPatchInit = (O, w, D = !1, U = void 0) => {
+  const F = new Headers();
+  if (w && w !== "" && F.append("Authorization", `Bearer ${w}`), F.append("X-Requested-With", "XMLHttpRequest"), D) {
+    const W = getCookieByName("csrftoken");
+    W && D && F.append("X-CSRFToken", W);
+  }
+  const q = {
+    cache: "no-cache",
+    method: O,
+    headers: F,
+    redirect: "follow",
+    // This is anyway the default.
+    credentials: "include"
+  };
+  return U && (q.signal = U), q;
+}, formPostInit = (O, w, D = void 0) => {
+  const F = basicPutPostPatchInit("POST", O, !1, D);
+  return F.body = new FormData(w.formEl), F;
+}, basicGetInit = (O, w = void 0) => {
+  const D = new Headers();
+  D.append("Authorization", `Bearer ${O}`), D.append("X-Requested-With", "XMLHttpRequest");
+  const U = {
+    cache: "no-cache",
+    headers: D,
+    credentials: "include"
+  };
+  return w && (U.signal = w), U;
+}, putPostPatchNobody = (O, w) => {
+  const D = new Request(O);
+  return fetch(D, w).then(checkStatus).then(getText);
+}, genCatchClause = (O, w = void 0) => (D) => (stopSpin("").then(identity), D.name === "AbortError" ? console.info(O, "ABORTED!") : console.error(O, D), w);
+class UserManager {
+  /**
+   * @param {!Object=} opt_data
+   */
+  constructor(w) {
+    this.user_ = {}, this.jwt = "", w && this.updateProfileFromJwt(w).then(() => {
+    });
+  }
+  /**
+   * @param {Object} data
+   * @param {boolean=} opt_onlyIfNoneExists
+   * @return {Promise}
+   * @private
+   */
+  updateProfileFromJwt(w, D = !1) {
+    return D && this.jwt !== "" ? Promise.resolve("User Profile Already exists") : w.non_field_errors ? Promise.reject(new Error(`JWT ${w.non_field_errors}`)) : (this.updateToken(w.token), this.updateProfile(w.user), Promise.resolve("User Profile Updated"));
+  }
+  /**
+   * @param {UserLikeType} data
+   */
+  updateProfile(w) {
+    this.user_ = w;
+  }
+  /**
+   * @param {string} t
+   */
+  updateToken(w) {
+    this.jwt = w;
+  }
+  /**
+   * @return {number|undefined}
+   */
+  get id() {
+    return this.user_.id;
+  }
+  /**
+   * @return {string|undefined}
+   */
+  get name() {
+    return this.user_.name;
+  }
+  /**
+   * @return {string|undefined}
+   */
+  get surname() {
+    return this.user_.surname;
+  }
+  /**
+   * @return {string|undefined}
+   */
+  get salutation() {
+    let w = this.name;
+    const D = this.surname;
+    return D && (w = w + " " + D), w;
+  }
+  /**
+   * @param {FormPanel} formPanel
+   * @return {Promise}
+   */
+  formSubmit(w) {
+    const D = new Request(w.uri.toString()), U = w.processSubmitReply.bind(w), F = genCatchClause("Form submit error");
+    return startSpin().then(() => fetch(D, formPostInit(
+      this.jwt,
+      w,
+      w.abortController.signal
+    ))).then(checkStatusTwo(w)).then(stopSpin).then(getTextOrJson).then(U).catch(F);
+  }
+  /**
+   * @param {string} uri
+   * @param {Boolean} useDocumentCookies
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  putNoBody(w, D = void 0, U = !1) {
+    const F = genCatchClause("putNobody error"), q = basicPutPostPatchInit(
+      "PUT",
+      this.jwt,
+      U,
+      D
+    );
+    return putPostPatchNobody(w, q).catch(F);
+  }
+  /**
+   * @param {string} uri
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  fetch(w, D = void 0) {
+    const U = new Request(w.toString()), F = genCatchClause(`UMan Text GET Fetch: ${w}`);
+    return startSpin().then(() => fetch(U, basicGetInit(this.jwt, D))).then(checkStatus).then(stopSpin).then(getText).catch(F);
+  }
+  /**
+   * Use this if you want to directly get a parsed template that does not go
+   * through panel logic.
+   * @param {string} uri
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  fetchAndSplit(w, D = void 0) {
+    const U = genCatchClause(`fetchAndSplit: ${w}`);
+    return this.fetch(w, D).then(handleTemplateProm).catch(U);
+  }
+  /**
+   * @param {string} uri
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  async fetchJson(w, D = void 0) {
+    const U = new Request(w.toString()), F = genCatchClause(`fetchJson: ${w}`, {}), q = basicGetInit(this.jwt, D);
+    await startSpin();
+    let W = {};
+    try {
+      W = await (await fetch(U, q)).json();
+    } catch (Y) {
+      return F(Y);
+    }
+    return await stopSpin(), W;
+  }
+  /**
+   * @param {string} uri
+   * @param {Object} payload
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  patchJson(w, D, U = void 0) {
+    const F = new Request(w.toString()), q = genCatchClause(`patchJson: ${w}`), W = jsonInit(this.jwt, D, "PATCH", U);
+    return fetch(F, W).then(checkStatus).then(getJson).catch(q);
+  }
+  /**
+   * @param {string} uri
+   * @param {Object} payload
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  postJson(w, D, U = void 0) {
+    const F = new Request(w.toString()), q = genCatchClause(`postJson: ${w}`), W = jsonInit(this.jwt, D, "POST", U);
+    return fetch(F, W).then(checkStatus).then(getJson).catch(q);
+  }
+  /**
+   * @param {string} uri
+   * @param {Object} payload
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  putJson(w, D, U = void 0) {
+    const F = new Request(w.toString()), q = genCatchClause(`putJson: ${w}`), W = jsonInit(this.jwt, D, "PUT", U);
+    return fetch(F, W).then(checkStatus).then(getJson).catch(q);
+  }
+  /**
+   * @param {string} uri
+   * @param {Object} payload
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  delJson(w, D, U = void 0) {
+    const F = new Request(w.toString()), q = genCatchClause(`delJson: ${w}`), W = jsonInit(this.jwt, D, "DELETE", U);
+    return fetch(F, W).then(checkStatus).then(getJson).catch(q);
+  }
+}
+class Panel extends Component {
+  /**
+   * Returns the panel event type code used for dispatching panel events.
+   * @return {string} The PANEL event type
+   */
+  static panelEventCode() {
+    return UiEventType.PANEL;
+  }
+  /**
+   * Returns the component ready event type code.
+   * @return {string} The READY event type
+   */
+  static compReadyCode() {
+    return UiEventType.READY;
+  }
+  /**
+   * Creates a new Panel instance.
+   * @param {string=} uri Optional URI for fetching panel content
+   */
+  constructor(w) {
+    super(), this.qParamMap_ = /* @__PURE__ */ new Map(), this.uri_ = "", w && this.parseUri(w), this.evalScripts = evalScripts(this), this.evalModules = evalModules(this), this.redirected = !1, this.responseObject = { html: null, scripts: null }, this.user_ = void 0, "AbortController" in window ? this.abortController = new AbortController() : this.abortController = {
+      signal: void 0,
+      abort: () => {
+      }
+    }, this.listMap = /* @__PURE__ */ new Map();
+  }
+  //--[ Getters and Setters ]--
+  get uri() {
+    const w = this.qParamMap_.size > 0 ? "?" + objectToUrlParms(Object.fromEntries(this.qParamMap_)) : "";
+    return this.uri_ + w;
+  }
+  /**
+   * @param {!UserManager} user
+   */
+  set user(w) {
+    this.user_ = w;
+  }
+  /**
+   * @return {!UserManager}
+   */
+  get user() {
+    return this.user_ || (this.user_ = new UserManager()), this.user_;
+  }
+  /**
+   * Parses a URI into its path and query parameters. Updates the panel's
+   * internal URI and query parameter map.
+   * @param {string} uri The URI to parse
+   */
+  parseUri(w) {
+    this.uri_ = getPath(w), this.qParamMap_ = queryDataToMap(getQueryData(w));
+  }
+  /**
+   * Adds or updates a query parameter in the panel's query parameter map.
+   * @param {string} k The parameter key
+   * @param {string} v The parameter value
+   */
+  addToQParams(w, D) {
+    this.qParamMap_.set(w, D);
+  }
+  /**
+   * Removes a query parameter from the panel's query parameter map.
+   * @param {string} k The parameter key to remove
+   */
+  removeFromQParams(w) {
+    this.qParamMap_.delete(w);
+  }
+  /**
+   * Clears all query parameters from the panel's query parameter map.
+   */
+  clearQParams() {
+    this.qParamMap_.clear();
+  }
+  //--[ Carbon Component Access ]-----
+  /**
+   * Gets all Carbon components of a specific type in this panel.
+   * Components are scanned and stored during Carbon library initialization.
+   * @param {string} selector - Carbon component selector (e.g., 'cds-table', 'cds-button')
+   * @return {Element[]} Array of matching elements, or empty array if none found
+   * @example
+   *   const tables = this.getCarbonComponents('cds-table');
+   *   const buttons = this.getCarbonComponents('cds-button');
+   */
+  getCarbonComponents(w) {
+    return this.carbonComponents?.get(w) || [];
+  }
+  /**
+   * Gets a single Carbon component by its ID.
+   * Searches across all Carbon component types stored in this panel.
+   * @param {string} id - The element ID to search for
+   * @return {Element|undefined} The matching element, or undefined if not found
+   * @example
+   *   const table = this.getCarbonComponentById('companies-table');
+   */
+  getCarbonComponentById(w) {
+    if (this.carbonComponents)
+      for (const D of this.carbonComponents.values()) {
+        const U = D.find((F) => F.id === w);
+        if (U)
+          return U;
+      }
+  }
+  //--[ Template Render ]-----
+  /**
+   * Temporarily render placeholder DOM
+   * @param {Node!} placeholder
+   */
+  renderPlaceHolder(w) {
+    this.target && (this.placeholderDom = w, this.target.insertBefore(this.placeholderDom, null));
+  }
+  /**
+   * Expects HTML data from a call to the back.
+   * @param {Function=} opt_callback An optional callback to call before
+   * rendering the panel. This is useful for when you only want to attach the
+   * new panel to the view right before you render it - meaning the existing
+   * panel stays in place on the DOM for the duration of the fetch call.
+   * @return {Promise} Returns a promise with this panel as value.
+   */
+  renderWithTemplate(w) {
+    const D = this.user;
+    return D ? D.fetch(this.uri, this.abortController.signal).then((U) => (this.assertCanRenderAsync(), w && w(this), this.onRenderWithTemplateReply(U).catch((F) => {
+      F.message !== Component.compErrors().ALREADY_DISPOSED && console.error("RenderWithTemplate Err:", F);
+    }), this)).catch((U) => {
+      throw console.error("Panel.renderWithTemplate fetch failed:", U), U;
+    }) : Promise.reject(new Error("No UserManager instance available for Panel.renderWithTemplate()"));
+  }
+  /**
+   * @param {string} s
+   * @private
+   * @return {Promise}
+   */
+  onRenderWithTemplateReply(w) {
+    return this.responseObject = splitScripts(w), this.domFunc = () => (
+      /** @type {!Element} */
+      this.responseObject.html
+    ), this.render(), Promise.resolve(this);
+  }
+  /**
+   * Partially replace panel's content.
+   * If an ID query selector (#something) is passed in, then that single node is replaced
+   * in the panel DOM with the single node in the content DOM
+   *
+   * If a class query selector (.some_class) is passed in, all elements in the
+   * panel's dom with that class is replaced with the matching
+   * element ID in the content DOM matching the target DOMs element IDs
+   *
+   * NOTE: For the spot replacement to work, you need both the classname
+   * and a unique element ID on the element you intend to replace.
+   *
+   * NOTE: Top level replacements will clobber child replacements.
+   *
+   * @param content
+   * @param qs
+   */
+  onReplacePartialDom(w, D) {
+    const U = this.getElement();
+    if (isUndefined(U))
+      return;
+    const F = w.html;
+    if (D.startsWith("."))
+      [...U.querySelectorAll(D)].filter((q) => isDefAndNotNull(q.id)).map((q) => [q, F.querySelector(`#${q.id}`)]).filter(([q, W]) => isDefAndNotNull(W)).forEach(([q, W]) => {
+        q.parentNode.replaceChild(W, q), this.parseContent(W);
+      });
+    else if (D.startsWith("#")) {
+      const q = F.querySelector(D), W = U.querySelector(D);
+      W.parentNode.replaceChild(q, W), this.parseContent(q);
+    }
+    this.evalScripts(w.scripts), this.evalModules(w.modules);
+  }
+  //--[ JSON Render ]-----
+  /**
+   * Equivalent to the @code{renderWithTemplate} method in that it is guaranteed
+   * that a reply from the callback is received before @code{render} is called.
+   * @param {function(Object, !Panel)} opt_callback The callback function
+   *      that will receive the reply event.
+   */
+  renderWithJSON(w) {
+    return this.user ? this.user.fetchJson(this.uri_, this.abortController.signal).then((U) => {
+      this.assertCanRenderAsync(), w && w(U, this), this.onRenderWithJSON(U).then(identity);
+    }).catch((U) => {
+      throw console.error("Panel.renderWithJSON fetch failed:", U), U;
+    }) : Promise.reject(new Error("No UserManager instance available for Panel.renderWithJSON()"));
+  }
+  /**
+   * On reply from a GET call to the panel URI
+   * @param {Object} _json The callback function
+   *      that will receive the reply event.
+   * @return {Promise}
+   */
+  onRenderWithJSON(w) {
+    return Promise.resolve(this);
+  }
+  /**
+   * @param {Element} _el
+   * @param {Object} _elDataMap
+   * @param {Object} _json
+   */
+  onAsyncJsonReply(w, D, U) {
+  }
+  /**
+   * Called on each async HTML response, after the content is in the DOM
+   * and rendered.
+   * @param {Element} _el
+   * @param {Object} _elDataMap
+   */
+  onAsyncHtmlReply(w, D) {
+  }
+  /**
+   * Hook method called when the view broadcasts data to all its panels.
+   * Override this method to handle broadcasted data in subclasses.
+   * @param {*} _data The data broadcast from the view
+   */
+  onViewDataBroadcast(w) {
+  }
+  //--[ JSON Render ]-----
+  /**
+   * @param {Element} panel
+   */
+  parseContent(w) {
+    if (this.debugMe("Enable interactions. Panel:", w), typeof window.customElements < "u" && ComponentLibraryRegistry.has("carbon")) {
+      const J = ComponentLibraryRegistry.get("carbon");
+      J.render.call(this, w, J.cache).catch((X) => console.error("[Zooy] Carbon initialization failed:", X));
+    }
+    if (ComponentLibraryRegistry.has("mdc")) {
+      const J = ComponentLibraryRegistry.get("mdc");
+      J.render.call(this, w, J.cache);
+    }
+    w.classList.contains("zoo__modal-base") && w.classList.contains("close_on_click") && this.listen(w, EV.CLICK, (J) => {
+      J.target === w && this.dispatchPanelEvent("destroy_me");
+    }), [...w.querySelectorAll(
+      ".zoo__button:not(.external):not(.mdc-data-table__row)"
+    )].forEach((J) => {
+      this.listen(J, EV.CLICK, (X) => {
+        X.stopPropagation();
+        const K = X.currentTarget, et = getElDataMap(K);
+        this.dispatchPanelEvent(et.zv, Object.assign({
+          orgEvt: X,
+          trigger: K,
+          href: K.href || et.href
+        }, et));
+      });
+    }), [...w.querySelectorAll("[href]:not(.external)")].forEach((J) => {
+      this.listen(J, EV.CLICK, (X) => {
+        const K = X.currentTarget;
+        X.preventDefault(), X.stopPropagation();
+        const et = getElDataMap(K), st = et.zv || "href";
+        this.dispatchPanelEvent(st, Object.assign({
+          orgEvt: X,
+          trigger: X.target,
+          href: K.href || et.href
+        }, et));
+      });
+    }), [...w.querySelectorAll("form.intercept_submit")].forEach((J) => {
+      J.noValidate = !0, this.listen(J, EV.SUBMIT, (X) => {
+        X.preventDefault(), X.stopPropagation();
+        const K = getElDataMap(J), et = formToJSON(J.elements);
+        this.dispatchPanelEvent(K.zv, Object.assign({
+          orgEvt: X,
+          trigger: X.target,
+          formData: et,
+          href: K.href
+        }, K));
+      });
+    }), [...w.querySelectorAll(".zoo__toggle_class_driver")].forEach(
+      (J) => {
+        const X = getElDataMap(J), K = X.toggle_class_target_id, et = X.toggle_class, st = w.querySelector(`#${K}`);
+        st && et && J.addEventListener(EV.CLICK, (rt) => {
+          rt.stopPropagation(), st.classList.toggle(et);
+        });
+      }
+    );
+    const D = Array.from(w.querySelectorAll(".folder_drop_zone")), U = Array.from(w.querySelectorAll("[draggable]")), F = (J) => {
+      J.preventDefault(), J.target.classList.add("drag_over");
+    }, q = (J) => {
+      J.preventDefault();
+    }, W = (J) => {
+      J.preventDefault(), J.target.classList.remove("drag_over");
+    }, Y = (J) => {
+      J.preventDefault(), J.target.classList.remove("drag_over");
+    }, G = (J) => {
+      J.preventDefault(), J.target.classList.remove("drag_over");
+    }, Z = (J) => {
+      J.dataTransfer.dropEffect = "move";
+      const X = getElDataMap(J.target);
+      J.dataTransfer.setData("text/plain", JSON.stringify(X)), J.target.classList.add("drag_in_progress");
+    }, Q = (J) => {
+      J.target.classList.remove("drag_in_progress");
+    }, tt = (J) => {
+      G(J), J.stopPropagation();
+      const X = JSON.parse(J.dataTransfer.getData("text/plain")), K = getElDataMap(J.target);
+      return this.dispatchPanelEvent("drop_on", {
+        custom: { on: K, from: X }
+      }), !1;
+    };
+    D.forEach((J) => {
+      this.listen(J, EV.DRAGOVER, q), this.listen(J, EV.DRAGENTER, F), this.listen(J, EV.DRAGEXIT, Y), this.listen(J, EV.DRAGLEAVE, W), this.listen(J, EV.DROP, tt);
+    }), U.forEach((J) => {
+      this.listen(J, EV.DRAGSTART, Z), this.listen(J, EV.DRAGEND, Q);
+    }), [...w.querySelectorAll(".zoo_async_json")].forEach((J) => {
+      const X = getElDataMap(J), K = X.href, et = this.onAsyncJsonReply.bind(this, J, X);
+      this.user.fetchJson(K, this.abortController.signal).then(et);
+      const st = X.z_json_reusable;
+      st && (this.jsonCallFuncs = this.jsonCallFuncs || {}, this.jsonCallFuncs[st] = () => {
+        this.user.fetchJson(K, this.abortController.signal).then(et);
+      });
+      const rt = toNumber(X.z_interval);
+      isNumber(rt) && this.doOnBeat(() => {
+        this.user.fetchJson(K, this.abortController.signal).then(et);
+      }, rt * 60 * 1e3);
+    }), [...w.querySelectorAll(".zoo_async_html")].forEach(
+      /**
+       * @param {Element} el
+       */
+      (J) => {
+        const X = getElDataMap(J), K = X.href;
+        this.user.fetchAndSplit(K, this.abortController.signal).then((st) => {
+          J.appendChild(st.html), this.parseContent(J), this.evalScripts(st.scripts), this.evalModules(st.modules), this.onAsyncHtmlReply(J, X);
+        });
+        const et = toNumber(X.z_interval);
+        isNumber(et) && this.doOnBeat(() => {
+          this.user.fetchAndSplit(K, this.abortController.signal).then((st) => {
+            J.replaceChildren(st.html), this.parseContent(J), this.evalScripts(st.scripts), this.evalModules(st.modules);
+          });
+        }, et * 60 * 1e3);
+      }
+    );
+  }
+  /**
+   * @inheritDoc
+   * Called when the panel enters the document. Parses content to enable
+   * Material Design Components, executes scripts and modules, then dispatches
+   * the READY event.
+   */
+  enterDocument() {
+    const w = this.getElement();
+    this.parseContent(w), this.evalScripts(this.responseObject.scripts), this.evalModules(this.responseObject.modules), super.enterDocument();
+  }
+  /**
+   * @inheritDoc
+   * Called when the panel exits the document. Aborts any pending async
+   * operations and performs cleanup.
+   */
+  exitDocument() {
+    this.abortController.abort(), super.exitDocument();
+  }
+  /**
+   * @param {boolean} bool
+   * @param {?string} url
+   */
+  setIsRedirected(w, D) {
+    this.redirected = w, this.redirected && D && (this.uri_ = D);
+  }
+  //--[ Built in events ]--
+  /**
+   * Dispatches a @code{UiEventType.PANEL} event.
+   * A shorthand method to get panels to dispatch uniform events.
+   * Views may listen just to this event, and act on the supplied value or
+   * data payload.
+   * @example
+   *    b.listen(a, Panel.panelEventCode(), e => {
+   *      console.log('B got', Panel.panelEventCode(), e);
+   *      console.log('Value is', e.detail.getValue());
+   *      console.log('Data is', e.detail.getData());
+   *    });
+   * @param {string|number} value
+   * @param {(string|number|?Object)=} opt_data
+   * @return {boolean} If anyone called preventDefault on the event object
+   *  or if any of the handlers returns false this will also return false.
+   */
+  dispatchPanelEvent(w, D) {
+    const U = new ZooyEventData(w, D), F = Evt.makeEvent(UiEventType.PANEL, U);
+    return this.debugMe(`PANEL EVENT FIRED:
+      value:${w}
+      data:${D}`), this.dispatchEvent(F);
+  }
+}
+class FormPanel extends Panel {
+  /**
+   * @type {?HTMLFormElement}
+   * @private
+   */
+  #t = null;
+  /**
+   * Map of form fields to their error message DOM elements
+   * @type {!Map<HTMLInputElement, Element>}
+   * @private
+   */
+  #e = /* @__PURE__ */ new Map();
+  #s = !0;
+  /**
+   * Creates a new FormPanel instance.
+   * @param {string=} uri Optional URI for fetching form content
+   * @param {boolean} intercept If false, we do not try and intercept the forms
+   */
+  constructor(w, D = !0) {
+    super(w), this.#s = D, this.debugMode = !0, this.onSubmitSucFunc = (U, F) => null;
+  }
+  /**
+   * Gets the form element managed by this panel.
+   * @return {?HTMLFormElement} The form element, or null if not found
+   */
+  get formEl() {
+    return this.#t;
+  }
+  /**
+   * @inheritDoc
+   * Called when the form panel enters the document. Identifies the form element
+   * and sets up submission interception and field error handling.
+   */
+  enterDocument() {
+    super.enterDocument(), this.formIdElementToForm_();
+  }
+  /**
+   * Internal method to identify the form element and set up interception.
+   * @private
+   */
+  formIdElementToForm_() {
+    this.#t = this.getFormFromId(), this.#t && (this.#a(this.#t), this.#r());
+  }
+  /**
+   * @param {string=} string The id of the form we want to sterilise.
+   * @return {?HTMLFormElement}
+   */
+  getFormFromId(w) {
+    let D = null, U = this.getElement().querySelector("form");
+    return w && (U = document.getElementById(
+      /** @type {string} */
+      w
+    ) || U), U && U.tagName.toLowerCase() === "form" && (D = /** @type {HTMLFormElement} */
+    U), D;
+  }
+  //--[ Field Validation Methods ]--
+  /**
+   * Initializes field validation. Sets up event listeners on the form
+   * for change, input, and invalid events.
+   * @private
+   */
+  #r() {
+    this.#t && (this.listen(this.#t, EV.CHANGE, (w) => {
+      this.#o(w);
+    }, { passive: !0 }), this.listen(this.#t, EV.INPUT, (w) => {
+      this.clearAllValidationErrors(), this.#o(w);
+    }), this.listen(this.#t, EV.INVALID, (w) => {
+      w.preventDefault();
+      const D = (
+        /** @type {HTMLInputElement} */
+        w.target
+      );
+      this.#i(D), this.displayFieldError(D);
+    }, { passive: !0 }));
+  }
+  /**
+   * Checks all form fields for validity. Returns true if all fields are valid.
+   * Displays error messages for any invalid fields.
+   * @return {boolean} True if all fields are valid, false otherwise
+   */
+  checkAllFields() {
+    const w = [...this.#t.elements].map((D) => [this.#n(D), D]).filter((D) => !D[0]);
+    return w.forEach((D) => this.displayFieldError(D[1])), w.length === 0;
+  }
+  /**
+   * Clear all existing validation errors
+   */
+  clearAllValidationErrors() {
+    [...this.#t ? this.#t.elements : []].forEach((U) => this.#i(U)), [...this.#t.querySelectorAll(".non-field-errors")].forEach((U) => U.classList.remove("alert-error"));
+  }
+  /**
+   * Format the message dom object and insert it into the DOM
+   * @param {HTMLInputElement} field The field after which the alert will be inserted.
+   * @param {string} msg The message in the alert.
+   * @param {string} _css A CSS class name to add to the alert div.
+   * @private
+   */
+  displayAlert_(w, D, U) {
+    const F = document.getElementById(`${w.id}-helper-text`) || document.createElement("p");
+    F.textContent = D, this.#e.set(w, F);
+  }
+  /**
+   * Check validation for a single field
+   * @param {HTMLInputElement} field
+   * @return {boolean} True if field is valid
+   * @private
+   */
+  #n(w) {
+    this.#i(w);
+    let D = !w.willValidate;
+    return w.willValidate && (D = w.checkValidity()), D;
+  }
+  /**
+   * Clear alert for a single field
+   * @param {HTMLInputElement} field
+   * @private
+   */
+  #i(w) {
+    w.classList.remove("error"), this.#e.has(w) && (this.#e.get(w).textContent = ""), this.#e.delete(w);
+  }
+  /**
+   * Display the given error message on the given form field.
+   * @param {HTMLInputElement} field
+   * @param {string=} opt_msg
+   */
+  displayFieldError(w, D) {
+    const U = D || w.validationMessage;
+    w.classList.add("error"), this.displayAlert_(w, U, "alert-error");
+  }
+  /**
+   * Display the given success message on the given form field.
+   * @param {HTMLInputElement} field
+   * @param {string} message
+   */
+  displayFieldSuccess(w, D) {
+    this.displayAlert_(w, D, "alert-success");
+  }
+  /**
+   * Display the given information message on the given form field.
+   * @param {HTMLInputElement} field
+   * @param {string} message
+   */
+  displayFieldInfo(w, D) {
+    this.displayAlert_(w, D, "alert-info");
+  }
+  /**
+   * Validate field on change event
+   * @param {Event} e
+   * @private
+   */
+  #o(w) {
+    this.#n(
+      /** @type {HTMLInputElement} */
+      w.target
+    );
+  }
+  /**
+   * Given a form id, get the form, and intercept and sterilise its submit.
+   * Forms that passed through here will not be able to be submitted with a
+   * normal submit button anymore, but built in HTML5 Constraint Validation
+   * will still function on the form. This way, we can still have a button with
+   * type="submit", which will trigger the validation, and we can submit
+   * valid forms with xhrio which allows us to add callbacks to them.
+   *
+   * @param {HTMLFormElement} form The form we want to sterilise.
+   * @return {HTMLFormElement}
+   */
+  #a(w) {
+    if (w && this.#s) {
+      w.noValidate = !0;
+      const D = this.user;
+      this.listen(w, EV.SUBMIT, (U) => {
+        U.preventDefault(), this.debugMe("Intercepted from SUBMIT"), this.checkAllFields() && D && D.formSubmit(this);
+      });
+    }
+    return w;
+  }
+  //--[ Round Trip ]--
+  /**
+   * @param {function(!FormPanel, (string|!ServerFormSuccessJsonType)=): (?|null|Promise<?>)} func
+   */
+  onSubmitSuccess(w) {
+    this.onSubmitSucFunc = w;
+  }
+  /**
+   * Given a 'fetch' reply, replace the form.
+   * This simply replaced the form element with what came back from the server
+   * and re-reads the scripts.
+   * @param {string} reply
+   */
+  replaceForm(w) {
+    if (this.responseObject = splitScripts(w), this.responseObject.html) {
+      if (this.redirected) {
+        this.removeAllListener();
+        const D = this.getElement(), U = D.parentNode;
+        this.setElementInternal_(this.responseObject.html), U.replaceChild(this.getElement(), D);
+      } else {
+        const D = (
+          /** @type {!Element} */
+          this.responseObject.html.querySelector("form")
+        );
+        D && replaceNode(D, this.#t);
+        const U = (
+          /** @type {!Element} */
+          this.responseObject.html.querySelector('button[type="submit"]')
+        ), F = (
+          /** @type {!Element} */
+          this.getElement().querySelector('button[type="submit"]')
+        );
+        U && F && replaceNode(U, F);
+      }
+      this.enterDocument();
+    }
+  }
+  /**
+   * Expects HTML data from a call to the back.
+   * @return {Promise} Returns a promise with this panel as value.
+   */
+  refreshFromFromServer() {
+    const w = this.user, D = this.uri;
+    return w ? w.fetch(D, this.abortController.signal).then(
+      (U) => this.replaceForm(U)
+    ) : Promise.reject(new Error("No UserManager instance available for FormPanel.refreshFromFromServer()"));
+  }
+  /**
+   * @param {string} reply
+   * @return {Promise}
+   */
+  processSubmitReply(w) {
+    this.clearAllValidationErrors();
+    let D = !1;
+    if (whatType(w) === "object" && w.success)
+      return Promise.resolve(this).then(() => {
+        this.onSubmitSucFunc(this, w), this.dispatchCompEvent(UiEventType.FORM_SUBMIT_SUCCESS);
+      });
+    if (w === "success" ? (this.debugMe(`
+      1.REDIRECTED: ${this.redirected}
+      REPLY: ${w}`), D = !0) : w === `redirected_success
+` ? (this.debugMe(`
+      2.REDIRECTED: ${this.redirected}
+      REPLY: ${w}`), D = !0, this.redirected = !1) : (this.debugMe(`
+      3.REDIRECTED: ${this.redirected}
+      REPLY: Some form HTML`), this.replaceForm(w)), D && this.redirected)
+      return this.debugMe(`
+      4.REDIRECTED: ${this.redirected}
+      SUCCESS: ${D}`), this.redirected = !1, Promise.resolve(this);
+    if (D)
+      return this.debugMe(`
+      5.REDIRECTED: ${this.redirected}
+      SUCCESS: ${D}`), Promise.resolve(this).then(() => {
+        this.onSubmitSucFunc(this), this.dispatchCompEvent(UiEventType.FORM_SUBMIT_SUCCESS);
+      });
+    this.debugMe(`
+      6.REDIRECTED: ${this.redirected}
+      SUCCESS: ${D}`);
+  }
+}
+class Split extends Component {
+  /**
+   * Returns the split event type code used for dispatching split events.
+   * @return {string} The SPLIT event type
+   */
+  static splitEventCode() {
+    return UiEventType.SPLIT;
+  }
+  /**
+   * Creates a new Split component instance. Initializes nest tracking and
+   * callback management.
+   */
+  constructor() {
+    super(), this.dragImage_ = document.createElement("canvas"), this.nestMap_ = /* @__PURE__ */ new Map(), this.nestCallbackMap_ = /* @__PURE__ */ new Map(), this.splitNests_ = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Returns all nest entries (name and config object) that have a valid element.
+   * @return {!Array<!Array<string, !Object>>} Array of [nestName, nestConfig] pairs
+   */
+  get nests() {
+    return [...this.nestMap_.entries()].filter(([w, { nestEl: D }]) => D);
+  }
+  /**
+   * Gets the nest element for a given nest name.
+   * @param {string} nestName The nest name to look up
+   * @return {!Element | undefined} The nest element, or undefined if not found
+   */
+  getNest(w) {
+    return this.nestMap_.get(w)?.nestEl;
+  }
+  /**
+   * Returns the names of all nests that haven't been further split.
+   * @return {!Array<string>} Array of nest names
+   */
+  get nestNames() {
+    return [...this.nestMap_.entries()].filter(([w, D]) => !this.splitNests_.has(D)).map(([w]) => w);
+  }
+  /**
+   * Closes and locks all nests in this split component.
+   * @param {!Function=} callback Callback to execute after each nest closes
+   * @param {boolean=} opt_skipAni If true, skips animation
+   */
+  closeAndLockAll(w = identity, D = !1) {
+    this.nestNames.forEach((U) => this.closeAndLock(U, w, D));
+  }
+  /**
+   * Opens and unlocks all nests in this split component.
+   * @param {!Function=} callback Callback to execute after each nest opens
+   * @param {boolean=} opt_skipAni If true, skips animation
+   */
+  openAndUnlockAll(w = identity, D = !1) {
+    this.nestNames.forEach((U) => this.openAndUnlock(U, w, D));
+  }
+  // ---------------------------------------------------------------------------
+  /**
+   * Lock a dragger. Removes the listeners that make it draggable.
+   * Adds the 'locked' class to the element.
+   * Sets the element's "display" style to none.
+   * Even though all these operations are performed on the the dragger, access
+   * is vai the nest name - for consistency with the rest of the API.
+   * @param {string} nestName Nest name
+   */
+  lock(w) {
+    const { dragEl: D } = this.nestMap_.get(w);
+    D.classList.add("locked");
+  }
+  /**
+   * The reverse of a lock. Removes the classes added by <@code>lock</> and
+   * restores the draggable listeners.
+   * Even though all these operations are performed on the the dragger, access
+   * is vai the nest name - for consistency with the rest of the API.
+   * @param {string} nestName Nest name
+   */
+  unlock(w) {
+    const { dragEl: D } = this.nestMap_.get(w);
+    D.classList.remove("locked");
+  }
+  /**
+   * Resize a nest.
+   * @param {string} nestName Nest name
+   * @param {number} size The required size of the resulting move.
+   * @param {Function?} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  resize(w, D, U = identity, F = !1) {
+    const { sizeNow: q, nestEl: W, canResize: Y } = this.nestMap_.get(w);
+    Y && (F || q === D ? (W.classList.remove("animated"), W.style.flexBasis = `${D}px`, this.nestMap_.get(w).sizeNow = D, U()) : (W.classList.add("animated"), this.nestCallbackMap_.set(w, () => {
+      W.classList.remove("animated"), this.nestMap_.get(w).sizeNow = D, U();
+    }), W.style.flexBasis = `${D}px`));
+  }
+  /**
+   * Close the nest and lock it. See <@code>lock</>
+   * @param {string} nestName Nest name
+   * @param {Function?} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  closeAndLock(w, D = identity, U = !1) {
+    const { nestEl: F, dragEl: q, canResize: W } = this.nestMap_.get(w);
+    if (!W)
+      return;
+    const Y = () => {
+      q.classList.add("locked", "closed"), F.classList.add("closed"), D();
+    };
+    this.resize(w, 0, Y, U);
+  }
+  closeAndUnlock(w, D = identity, U = !1) {
+    const { nestEl: F, dragEl: q, canResize: W } = this.nestMap_.get(w);
+    if (!W)
+      return;
+    const Y = () => {
+      F.classList.remove("closed"), q.classList.remove("closed", "locked"), q.classList.add("collapsed"), D();
+    };
+    this.resize(w, 0, Y, U);
+  }
+  /**
+   * Open a closed and locked nest. Simply a convenience method to combine
+   * the unlock and resize steps.
+   * @param {string} nestName Nest name
+   * @param {number?} size The required size of the resulting move.
+   * @param {Function?} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  openAndUnlock(w, D, U, F = !1) {
+    const {
+      nestEl: q,
+      dragEl: W,
+      defSize: Y,
+      lastSize: G,
+      canResize: Z
+    } = this.nestMap_.get(w);
+    if (!Z)
+      return;
+    const Q = D || G || Y;
+    q.classList.remove("closed"), W.classList.remove("closed", "locked", "collapsed"), setTimeout(() => {
+      this.resize(w, Q, U, F);
+    }, 50);
+  }
+  /**
+   * Open a closed and locked nest. Keep the nest locked.
+   * @param {string} nestName Nest name
+   * @param {number?} size The required size of the resulting move.
+   * @param {Function?} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  openAndLock(w, D, U, F = !1) {
+    const {
+      nestEl: q,
+      dragEl: W,
+      defSize: Y,
+      lastSize: G,
+      canResize: Z
+    } = this.nestMap_.get(w);
+    if (!Z)
+      return;
+    const Q = D || G || Y;
+    q.classList.remove("closed"), W.classList.remove("closed", "collapsed"), setTimeout(() => {
+      this.resize(w, Q, U, F);
+    }, 50);
+  }
+  /**
+   * Close nest. Move it out the way, but continue to make it draggable;
+   * to the nest and dragger.
+   * @param {string} nestName Nest name
+   * @param {Function|undefined} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  close(w, D = identity, U = !1) {
+    const { dragEl: F, canResize: q, nestEl: W } = this.nestMap_.get(w);
+    if (!q)
+      return;
+    this.dispatchSplitEvent(UiEventType.SPLIT_WILL_CLOSE, { nestName: w, nestEl: W });
+    const Y = () => {
+      F.classList.add("collapsed"), this.dispatchSplitEvent(UiEventType.SPLIT_DID_CLOSE, { nestName: w, nestEl: W }), D();
+    };
+    this.resize(w, 0, Y, U);
+  }
+  /**
+   * Open the nest ignoring its current locked state.
+   * @param {string} nestName Nest name
+   * @param {Function|undefined} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  open(w, D = identity, U = !1) {
+    const { defSize: F, lastSize: q, dragEl: W, canResize: Y, nestEl: G } = this.nestMap_.get(w);
+    if (!Y)
+      return;
+    this.dispatchSplitEvent(UiEventType.SPLIT_WILL_OPEN, { nestName: w, nestEl: G }), W.classList.remove("collapsed", "closed");
+    const Z = q || F, Q = () => {
+      this.dispatchSplitEvent(UiEventType.SPLIT_DID_OPEN, { nestName: w, nestEl: G }), D();
+    };
+    this.resize(w, Z, Q, U);
+  }
+  /**
+   * Close the nest ignoring its current locked state.
+   * @param {string} nestName Nest name
+   * @param {Function|undefined} callback A callback function to call once
+   *    the resize completed.
+   * @param {boolean?} opt_skipAni When true, the resize won't be animated, but
+   *    simply affected directly.
+   */
+  toggle(w, D, U = !1) {
+    this.nestMap_.get(w).sizeNow === 0 ? this.open(w, D, U) : this.close(w, D, U);
+  }
+  //----------------------------------------------------------------------------
+  /**
+   * Split an element into parts, each separated by a dragger component.
+   * The split creates 3 new elements inside root element. Thus it is not
+   * truly splitting the reference element, but rather overlaying the
+   * split functionality over the reference element.
+   * A split can be either horizontal - called "EW" (east-west) or
+   * vertical - called "NS" (north-south).
+   * By convention the new elements created are called 'nests', and are named
+   * in order "A", "B" and "C" respectively.
+   * For EW splits the we name from left to right:
+   *    A B C
+   * For NS splits we name from top to bottom:
+   *    A
+   *    B
+   *    C
+   * Each newly created nest is a valid root for further splitting.
+   * When a nest is split, the resultant nests names are prepended with the
+   * name of the root nest that was split.
+   * Example: If nest C is split, the resultant nests are named CA, CB, and CC.
+   * When one of these (for example CA) is split further, the pattern continues
+   * with the resulting nests being CAA, CAB, CAC etc.
+   * @param {Element=} opt_el The element to split. If not given, the
+   *    components own element is used. Else, the element is checked to be
+   *    a member of this split-group, and if so, is split.
+   * @param {?string} orientation Only 'EW' or 'NS'. Defaults to 'EW'
+   * @param {?number} defSizeA Default size of the 'A' nest.
+   * @param {?number} defSizeC Default size of the 'C' nest. The 'B' nest gets the
+   *    remainder of the 'A' and 'C' nests, and can not be set directly.
+   * @param {?Array<string>} classArrA Extra class names to be added to this nest
+   * @param {?Array<string>} classArrB Extra class names to be added to this nest
+   * @param {?Array<string>} classArrC Extra class names to be added to this nest
+   * @param {?Array<string>} classArrDragger Extra classes for the dragger element
+   * @param {?Array<string>} classArrGrabber Extra classes for the grabber element
+   */
+  addSplit(w = void 0, D = "EW", U = 100, F = 100, q = [], W = [], Y = [], G = [], Z = []) {
+    const Q = w || this.getElement();
+    if (this.splitNests_.has(Q))
+      return ["Already used!", Q];
+    convertElToSplit(Q, D), this.splitNests_.add(Q);
+    let tt = "";
+    if (w) {
+      const it = [...this.nestMap_.entries()].find(([at, { nestEl: lt }]) => lt === w);
+      if (it)
+        tt = it[0];
+      else
+        return ["Element not managed by this component", w];
+    }
+    const J = `${tt}A`, X = makeOuterNest(U, ["zoo_nest__A", J, ...q]), K = new Dragger(D);
+    K.domFunc = makeDraggerEl([`zoo_drag_${J}`, ...G], Z), K.render(Q), this.nestMap_.set(J, {
+      side: "A",
+      nestEl: X,
+      dragger: K,
+      dragEl: K.getElement(),
+      defSize: U,
+      sizeNow: -1,
+      canResize: !0
+    });
+    const et = `${tt}B`, st = makeInnerNest(["zoo_nest__B", et, ...W]);
+    this.nestMap_.set(et, { nestEl: st, canResize: !1 });
+    const rt = `${tt}C`, nt = new Dragger(D);
+    nt.domFunc = makeDraggerEl([`zoo_drag_${rt}`, ...G], Z), nt.render(Q);
+    const ot = makeOuterNest(F, ["zoo_nest__C", rt, ...Y]);
+    this.nestMap_.set(rt, {
+      side: "C",
+      nestEl: ot,
+      dragger: nt,
+      dragEl: nt.getElement(),
+      defSize: F,
+      sizeNow: -1,
+      canResize: !0
+    }), [X, K.getElement(), st, nt.getElement(), ot].forEach((it) => Q.appendChild(it));
+    let ct = 0;
+    const ht = (it, at, lt, gt) => {
+      let ut;
+      const dt = it === "NS" ? "height" : "width", mt = it === "NS" ? "deltaY" : "deltaX";
+      return (pt) => {
+        switch (pt.detail.value_) {
+          case UiEventType.COMP_DRAG_START:
+            ut = at.getBoundingClientRect()[dt], ct = st.getBoundingClientRect()[dt] + ut, this.nestMap_.get(lt).dragEl.classList.remove("collapsed");
+            break;
+          case UiEventType.COMP_DRAG_MOVE: {
+            const ft = Math.min(ct, ut + gt * pt.detail.data_[mt]);
+            this.nestMap_.get(lt).lastSize = ft, at.style.flexBasis = ft + "px";
+            break;
+          }
+          case UiEventType.COMP_DRAG_END:
+            this.dispatchSplitEvent(UiEventType.COMP_DRAG_END, this.nestMap_.get(lt));
+            break;
+        }
+      };
+    };
+    this.listen(K, Component.compEventCode(), ht(D, X, J, 1)), this.listen(nt, Component.compEventCode(), ht(D, ot, rt, -1)), this.listen(K.getElement(), EV.DBLCLICK, () => this.toggle(J)), this.listen(nt.getElement(), EV.DBLCLICK, () => this.toggle(rt)), this.listen(K.getElement().querySelector(".zoo_grabber"), EV.CLICK, () => this.toggle(J)), this.listen(nt.getElement().querySelector(".zoo_grabber"), EV.CLICK, () => this.toggle(rt)), this.listen(X, EV.TRANSITIONEND, (it) => {
+      if (it.propertyName === "flex-basis" && it.target === X) {
+        const at = this.nestCallbackMap_.get(J);
+        this.nestCallbackMap_.delete(J), at && at(), this.dispatchSplitEvent(UiEventType.SPLIT_TRANSITION_END, this.nestMap_.get(J));
+      }
+    }), this.listen(ot, EV.TRANSITIONEND, (it) => {
+      if (it.propertyName === "flex-basis" && it.target === ot) {
+        const at = this.nestCallbackMap_.get(rt);
+        this.nestCallbackMap_.delete(rt), at && at(), this.dispatchSplitEvent(UiEventType.SPLIT_TRANSITION_END, this.nestMap_.get(rt));
+      }
+    });
+  }
+  //--[ Built in events ]--
+  /**
+   * Dispatches a {@code UiEventType.SPLIT} event.
+   * Views may listen just to this event, and act on the supplied value or
+   * data payload.
+   * @param {string|number} value
+   * @param {(string|number|?Object)=} opt_data
+   * @return {boolean} If anyone called preventDefault on the event object (or
+   *     if any of the handlers returns false this will also return false.
+   */
+  dispatchSplitEvent(w, D) {
+    const U = new ZooyEventData(w, D), F = Evt.makeEvent(UiEventType.SPLIT, U);
+    return this.dispatchEvent(F);
+  }
+}
+const convertElToSplit = (O, w) => (O.classList.add("zoo_split", `zoo_split__${w.toLowerCase()}`), O), makeOuterNest = (O, w = []) => {
+  const D = document.createElement("div");
+  return D.setAttribute("id", randomId(7)), D.classList.add("zoo_nest", "zoo_nest__outer", ...w), D.style.flexBasis = O + "px", D;
+}, makeInnerNest = (O = []) => {
+  const w = document.createElement("div");
+  return w.setAttribute("id", randomId(7)), w.classList.add("zoo_nest", "zoo_nest__inner", ...O), w;
+}, makeDraggerEl = (O = [], w = []) => () => {
+  const D = document.createElement("div");
+  D.setAttribute("id", randomId(7)), D.classList.add("zoo_dragger", ...O);
+  const U = document.createElement("div");
+  return U.classList.add("zoo_grabber", ...w), D.appendChild(U), D;
+}, needsToScroll = (O) => {
+  const D = O.getBoundingClientRect().bottom;
+  return (U) => U.getBoundingClientRect().bottom > D;
+}, treeNodeSelect = (O) => (w) => {
+  const D = O.getElement().querySelector(".zv_tree_container"), U = needsToScroll(D), F = O.getElement().querySelectorAll(".tree-node");
+  let q;
+  [...F].forEach((W) => {
+    enableClass(W, "mdc-deprecated-list-item--activated", W.id === `tree-node_${w}`), W.id === `tree-node_${w}` && (q = W);
+  }), q && U(q) && q.scrollIntoView(!1);
+}, toggleTree = (O, w) => {
+  const D = w.getElement().querySelector(".children"), U = (
+    /**@type {boolean} */
+    O.isOn
+  ), F = w.getElement().querySelectorAll(".children"), q = w.getElement().querySelectorAll(".zoo__reveal_icon");
+  [...F].forEach((W) => enableClass(
+    W,
+    "zoo__tree-children__hidden",
+    W !== D && !U
+  )), [...q].forEach((W) => enableClass(
+    W,
+    "zoo__icon_rotated",
+    W !== D && !U
+  ));
+}, toggleTreeChildren = (O, w) => {
+  const D = w.trigger, U = D.getAttribute("data-child-id"), F = O.getElement().querySelector(`#${U}`);
+  toggleClass(F, "zoo__tree-children__hidden"), toggleClass(D, "zoo__icon_rotated");
+}, _openTreeFromNodeUp = (O, w) => {
+  const D = w.parentElement;
+  D.classList.contains("children") && (enableClass(D, "zoo__tree-children__hidden", !1), _openTreeFromNodeUp(O, D));
+}, treeUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  _openTreeFromNodeUp,
+  toggleTree,
+  toggleTreeChildren,
+  treeNodeSelect
+}, Symbol.toStringTag, { value: "Module" })), MdcTreeHandlers = {
+  /**
+   * Toggle the entire tree open or closed.
+   * First level children remain open for better UX.
+   *
+   * @param {Object} eventData - Event data with isOn boolean
+   * @param {Panel} ePanel - The panel containing the tree
+   */
+  toggle_tree: function(O, w) {
+    toggleTree(O, w);
+  },
+  /**
+   * Toggle children visibility for a specific tree node.
+   *
+   * @param {Object} eventData - Event data with trigger element
+   * @param {Panel} ePanel - The panel containing the tree
+   */
+  "tree_toggle-children": function(O, w) {
+    toggleTreeChildren(w, O);
+  }
+}, SearchHandlers = {
+  /**
+   * Perform search with query string construction.
+   * Builds href with search query and additional query parameters.
+   *
+   * @param {Object} eventData - Event data with href, formData.q, and targetval
+   * @param {Panel} ePanel - The panel to update
+   */
+  search: function(O, w) {
+    let D = `${O.href}`;
+    const U = O.formData.q, F = O.targetval;
+    if (U !== "" && (D = `${D}?q=${U}`), F !== "") {
+      let q = F;
+      F.includes("page=") && (q = F.split("&").filter((W) => !W.includes("page=")).join("&")), D = U !== "" ? `${D}&${q}` : `${D}?${q}`;
+    }
+    this.user.fetchAndSplit(D, w.abortController.signal).then(
+      (q) => w.onReplacePartialDom(q, O.zvptarget)
+    );
+  },
+  /**
+   * Reset search form and query parameters.
+   * Clears the 'q' field in the closest form and removes 'q' from query params.
+   *
+   * @param {Object} eventData - Event data with trigger element
+   * @param {Panel} ePanel - The panel to update
+   */
+  reset_search: function(O, w) {
+    const D = O.trigger.closest("form");
+    w.removeFromQParams("q"), D.elements.q.value = "", D.dispatchEvent(new Event("submit"));
+  }
+}, QueryParamHandlers = {
+  /**
+   * Handle pagination by fetching content with query parameters.
+   *
+   * @param {Object} eventData - Event data with href and targetval for pagination
+   * @param {Panel} ePanel - The panel to update
+   */
+  paginate: function(O, w) {
+    const D = `${O.href}?${O.targetval}`;
+    this.user.fetchAndSplit(D, w.abortController.signal).then(
+      (U) => w.onReplacePartialDom(U, O.zvptarget)
+    );
+  },
+  /**
+   * Handle list filtering with query parameters.
+   *
+   * @param {Object} eventData - Event data with href and targetval for filtering
+   * @param {Panel} ePanel - The panel to update
+   */
+  list_filter: function(O, w) {
+    const D = `${O.href}?${O.targetval}`;
+    this.user.fetchAndSplit(D, w.abortController.signal).then(
+      (U) => w.onReplacePartialDom(U, O.zvptarget)
+    );
+  }
+}, handlers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MdcTreeHandlers,
+  QueryParamHandlers,
+  SearchHandlers
+}, Symbol.toStringTag, { value: "Module" }));
+class View extends Evt {
+  #t = void 0;
+  #e = void 0;
+  //--[ Static ]--
+  /**
+   * Returns the view event type code used for dispatching view events.
+   * @return {string} The VIEW event type
+   */
+  static viewEventCode() {
+    return UiEventType.VIEW;
+  }
+  /**
+   * Creates a new View instance. Initializes panel management, event handling,
+   * and metadata storage.
+   */
+  constructor() {
+    super(), this.panelMap = /* @__PURE__ */ new Map(), this.user_ = void 0, this.split_ = void 0, this.panelEventMap_ = this.initPanelEventsInternal_(), this.switchViewMap_ = /* @__PURE__ */ new Map(), this.metaData_ = /* @__PURE__ */ new Map();
+  }
+  set recordHistory(w) {
+    this.#e = w;
+  }
+  get recordHistory() {
+    return this.#e;
+  }
+  set registerViewConstructor(w) {
+    this.#t = w;
+  }
+  get registerViewConstructor() {
+    return this.#t;
+  }
+  set split(w) {
+    this.split_ = w, this.listen(this.split_, UiEventType.SPLIT, (D) => {
+      const U = D.detail.getValue(), F = D.detail.getData();
+      switch (U) {
+        case UiEventType.SPLIT_WILL_OPEN:
+          this.onSplitWillOpen(F);
+          break;
+        case UiEventType.SPLIT_WILL_CLOSE:
+          this.onSplitWillClose(F);
+          break;
+        case UiEventType.SPLIT_DID_CLOSE:
+          this.onSplitDidClose(F);
+          break;
+        case UiEventType.SPLIT_DID_OPEN:
+          this.onSplitDidOpen(F);
+          break;
+        case UiEventType.SPLIT_TRANSITION_END:
+          break;
+      }
+    });
+  }
+  get split() {
+    if (!this.split_)
+      throw new Error("No SPLIT component available");
+    return this.split_;
+  }
+  /**
+   * @param {!UserManager} user
+   */
+  set user(w) {
+    this.user_ = w, this.panelMap.forEach((D) => D.user = w);
+  }
+  /**
+   * @return {!UserManager}
+   */
+  get user() {
+    return this.user_ || (this.user_ = new UserManager()), this.user_;
+  }
+  /**
+   * Render each of the panels in this view.
+   */
+  render() {
+    this.initPanelEvents(), this.preRender(), this.configurePanels(), this.displayPanels(), this.postRender();
+  }
+  /**
+   * Placeholder for subclasses to add panel event functions.
+   */
+  initPanelEvents() {
+  }
+  /**
+   * Run before the render.
+   */
+  preRender() {
+  }
+  /**
+   * Placeholder for panel configuration functionality;
+   */
+  configurePanels() {
+  }
+  /**
+   * Placeholder for panel display functionality;
+   */
+  displayPanels() {
+  }
+  /**
+   * Placeholder for post render functionality.
+   */
+  postRender() {
+  }
+  /**
+   * @inheritDoc
+   */
+  dispose() {
+    [...this.panelMap.values()].forEach((w) => w.dispose()), super.dispose();
+  }
+  /**
+   * Add a panel as a child of the view.
+   * @param {string} name The name of the panel - used as a key in the panel map.
+   * @param {!Panel} panel The panel itself.
+   */
+  addPanelToView(w, D) {
+    D.user = this.user, this.removePanelByName(w), this.panelMap.set(w, D), this.listen(D, Panel.panelEventCode(), this.onPanelEvent.bind(this));
+  }
+  /**
+   * Remove a panel from the view by name.
+   * @param {string} name The name of the panel - used as a key in the panel map.
+   */
+  removePanelByName(w) {
+    this.panelMap.has(w) && this.panelMap.get(w).dispose();
+  }
+  /**
+   * @param {Panel} panel
+   */
+  removePanel(w) {
+    const [D, U] = [...this.panelMap.entries()].find(([F, q]) => q === w);
+    D && U && (U.dispose(), this.panelMap.delete(D));
+  }
+  /**
+   * @param {string} name
+   * @return {Panel|undefined}
+   */
+  getPanelByName(w) {
+    return this.panelMap.get(w);
+  }
+  /**
+   * Broadcasts data to all panels in this view. Each panel receives the data
+   * via its onViewDataBroadcast method.
+   * @param {*} data The data to broadcast to all panels
+   */
+  broadcastToPanels(w) {
+    [...this.panelMap.values()].forEach((D) => D.onViewDataBroadcast(w));
+  }
+  /**
+   * Initializes the internal panel event map with default event handlers.
+   * Sets up handlers for panel lifecycle and view coordination.
+   *
+   * Note: This method also registers application-specific handlers (search,
+   * pagination, etc.) for backwards compatibility. These will be removed in
+   * a future version - applications should explicitly register handlers they need.
+   *
+   * @return {!Map<string, !Function>} Map of event names to handler functions
+   * @private
+   */
+  initPanelEventsInternal_() {
+    const w = /* @__PURE__ */ new Map();
+    return w.set("destroy_me", (D, U) => {
+      this.removePanel(U);
+    }), w.set("switch_view", (D, U) => {
+      this.debugMe("switch_view received: eventData", D);
+      const F = D.view;
+      this.switchViewMap_.has(F) ? this.switchViewMap_.get(F)(D, U) : this.debugMe("NO VIEW FOUND FOR:", F, this.switchViewMap_);
+    }), Object.entries({
+      ...SearchHandlers,
+      ...QueryParamHandlers
+    }).forEach(([D, U]) => {
+      w.set(D, U.bind(this));
+    }), w;
+  }
+  /**
+   * Maps a panel event name to a handler function. Allows dynamic registration
+   * of custom panel event handlers at runtime.
+   * @param {string} s The event name to map
+   * @param {!Function} func The handler function that receives (eventData, ePanel)
+   */
+  mapPanEv(w, D) {
+    this.panelEventMap_.set(w, D);
+  }
+  /**
+   * A map of string to function where the function receives an object and
+   * a panel.
+   * @param {string} s
+   * @param {function(
+   *  {view:string, pk:string, emit:string, href:string}, Panel):?} func
+   */
+  mapSwitchView(w, D) {
+    this.switchViewMap_.set(w, D);
+  }
+  /**
+   * @param {!CustomEvent} e
+   */
+  onPanelEvent(w) {
+    let D = w.detail.getValue();
+    const U = w.detail.getData();
+    D.startsWith("switch_view:") && (U.view = D.split(":")[1], D = "switch_view");
+    const F = (
+      /** @type {Panel} */
+      w.target
+    );
+    this.panelEventMap_.has(D) ? this.panelEventMap_.get(D)(U, F) : this.debugMe(`NO EVENT MATCH - This usually you are missing 
+        a "mapPanEv(${D} ..." statement in your panel JS
+        or you have a "event='${D}'" attribute in your panel HTML`, {
+      event: w,
+      eventValue: D,
+      eventData: U,
+      panel: F.constructor.name
+    });
+  }
+  //--[ Split Events ]--
+  /**
+   * Triggered before a split will open.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitWillOpen(w) {
+  }
+  /**
+   * Triggered before a split will close.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitWillClose(w) {
+  }
+  /**
+   * Triggered after a split closed.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitDidClose(w) {
+  }
+  /**
+   * Triggered after a split opened.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitDidOpen(w) {
+  }
+  //--[ Built in events ]--
+  /**
+   * Dispatches a {@code UiEventType.VIEW} event.
+   * A shorthand method to get panels to dispatch uniform events.
+   * Views may listen just to this event, and act on the supplied value or
+   * data payload.
+   * Example:
+   *    b.listen(a, Component.compEventCode(), e => {
+   *      console.log('B got', Component.compEventCode(), e);
+   *      console.log('Value is', e.detail.getValue());
+   *      console.log('Data is', e.detail.getData());
+   *    });
+   * @param {string|number} value
+   * @param {(string|number|?Object)=} opt_data
+   * @return {boolean} If anyone called preventDefault on the event object (or
+   *     if any of the handlers returns false this will also return false.
+   */
+  dispatchViewEvent(w, D) {
+    const U = new ZooyEventData(w, D), F = Evt.makeEvent(UiEventType.VIEW, U);
+    return this.dispatchEvent(F);
+  }
+  //--[  Meta Data ]--
+  /**
+   * Returns the metadata map associated with this view.
+   * @return {!Map<string, *>} The metadata map
+   */
+  get metaData() {
+    return this.metaData_;
+  }
+  /**
+   * Sets a metadata key-value pair for this view.
+   * @param {string} k The metadata key
+   * @param {*} v The metadata value
+   * @return {!Map<string, *>} The updated metadata map
+   */
+  setMetaData(w, D) {
+    return this.metaData_.set(w, D), this.metaData;
+  }
+  /**
+   * Retrieves a metadata value by key.
+   * @param {string} k The metadata key
+   * @return {*} The metadata value, or undefined if not found
+   */
+  getMetaData(w) {
+    return this.metaData_.get(w);
+  }
+  /**
+   * Checks if a metadata key exists.
+   * @param {string} k The metadata key
+   * @return {boolean} True if the key exists, false otherwise
+   */
+  hasMetaData(w) {
+    return this.metaData_.has(w);
+  }
+}
+class Conductor extends Evt {
+  #t = /* @__PURE__ */ new Map();
+  #e = null;
+  /**
+   * @type {!UserManager|undefined}
+   * @private
+   */
+  #s = void 0;
+  #r = void 0;
+  #n = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new Conductor instance. Sets up browser history listening
+   * and initializes view event handling.
+   */
+  constructor() {
+    super(), this.#n = this.#i(), window.addEventListener("popstate", (w) => {
+      w.state !== null && this.navTo(w.state);
+    });
+  }
+  set split(w) {
+    this.#r = w;
+  }
+  get split() {
+    if (!this.#r)
+      throw new Error("No SPLIT component available");
+    return this.#r;
+  }
+  /**
+   * @param {!UserManager} user
+   */
+  set user(w) {
+    this.#s = w, this.#e && (this.#e.user = this.user);
+  }
+  /**
+   * @return {!UserManager}
+   */
+  get user() {
+    return this.#s || (this.#s = new UserManager()), this.#s;
+  }
+  /**
+   * Initializes the internal view event map with default event handlers.
+   * Sets up handlers for common view events like 'switch_view'.
+   * @return {!Map<string, !Function>} Map of event names to handler functions
+   * @private
+   */
+  #i() {
+    return (/* @__PURE__ */ new Map()).set("switch_view", (w, D) => {
+      if (this.#t.has(w.view)) {
+        const U = this.#t.get(w.view)(
+          w.pk || w.recordId,
+          w
+        );
+        this.switchView(U);
+      }
+    });
+  }
+  /**
+   * Maps a view event name to a handler function. Allows dynamic registration
+   * of custom view event handlers at runtime.
+   * @param {string} s The event name to map
+   * @param {!Function} func The handler function that receives (eventData, eView)
+   */
+  mapViewEv(w, D) {
+    this.#n.set(w, D);
+  }
+  /**
+   * Registers a view constructor function that can be used to create instances
+   * of a specific view type.
+   * @param {string} s The view type identifier
+   * @param {!Function} f Constructor function that receives (pk, data) and returns a View
+   */
+  registerViewConstructor(w, D) {
+    this.#t.set(w, D);
+  }
+  /**
+   * @param {!CustomEvent} e Event object.
+   */
+  onViewEvent(w) {
+    const D = w.detail.getValue(), U = w.detail.getData(), F = (
+      /** @type {Panel} */
+      w.target
+    );
+    this.#n.has(D) ? this.#n.get(D)(U, F) : console.warn("Unhandled VIEW Event:", w, D, U, F);
+  }
+  /**
+   * Make the given view active.
+   * @param {!View} view
+   */
+  setActiveView(w) {
+    this.#e && (this.stopListeningTo(this.#e), this.#e.dispose(), this.#e = null), this.#e = w, this.#e.render();
+  }
+  /**
+   * @param {!View} view
+   * @returns {!View}
+   */
+  initView(w) {
+    return w.user = this.user, w.split = this.split, w.recordHistory = this.recordHistory.bind(this), w.registerViewConstructor = this.registerViewConstructor.bind(this), this.listen(w, View.viewEventCode(), this.onViewEvent.bind(this)), w;
+  }
+  //--[ Views Utilities ]--
+  /**
+   * @param {!View} view The view we want active.
+   */
+  switchView(w) {
+    this.setActiveView(this.initView(w));
+  }
+  //--[ History and Navigation ]--
+  /**
+   * Records the given item in browser history. If item.init is true, replaces
+   * the current history state. Otherwise, pushes a new history state unless
+   * item.history is true.
+   * @param {!Object} item The history item containing view state
+   */
+  recordHistory(w) {
+    this.debugMe("HISTORY", w), w.init ? history.replaceState(w, "", document.location.href) : w.history || history.pushState(w, "", null);
+  }
+  /**
+   * Navigates to a specific view based on the history item. Attempts to use
+   * the active view's switchViewMap first, falling back to registered view
+   * constructors if needed.
+   * @param {!Object} item History item containing {view, pk, ...} properties
+   */
+  navTo = (w) => {
+    w.history = !0;
+    const D = w.view, U = this.#e;
+    if (U.switchViewMap_.has(D))
+      this.debugMe("NAV:VIEW:MAP", w), U.switchViewMap_.get(D)(w);
+    else if (this.#t.has(D)) {
+      const F = this.#t.get(D)(w.pk, w);
+      this.debugMe("NAV:NEW:VIEW", w), this.switchView(F);
+    }
+  };
+}
+function _isPlaceholder(O) {
+  return O != null && typeof O == "object" && O["@@functional/placeholder"] === !0;
+}
+function _curry1(O) {
+  return function w(D) {
+    return arguments.length === 0 || _isPlaceholder(D) ? w : O.apply(this, arguments);
+  };
+}
+function _curry2(O) {
+  return function w(D, U) {
+    switch (arguments.length) {
+      case 0:
+        return w;
+      case 1:
+        return _isPlaceholder(D) ? w : _curry1(function(F) {
+          return O(D, F);
+        });
+      default:
+        return _isPlaceholder(D) && _isPlaceholder(U) ? w : _isPlaceholder(D) ? _curry1(function(F) {
+          return O(F, U);
+        }) : _isPlaceholder(U) ? _curry1(function(F) {
+          return O(D, F);
+        }) : O(D, U);
+    }
+  };
+}
+function _concat(O, w) {
+  O = O || [], w = w || [];
+  var D, U = O.length, F = w.length, q = [];
+  for (D = 0; D < U; )
+    q[q.length] = O[D], D += 1;
+  for (D = 0; D < F; )
+    q[q.length] = w[D], D += 1;
+  return q;
+}
+function _arity(O, w) {
+  switch (O) {
+    case 0:
+      return function() {
+        return w.apply(this, arguments);
+      };
+    case 1:
+      return function(D) {
+        return w.apply(this, arguments);
+      };
+    case 2:
+      return function(D, U) {
+        return w.apply(this, arguments);
+      };
+    case 3:
+      return function(D, U, F) {
+        return w.apply(this, arguments);
+      };
+    case 4:
+      return function(D, U, F, q) {
+        return w.apply(this, arguments);
+      };
+    case 5:
+      return function(D, U, F, q, W) {
+        return w.apply(this, arguments);
+      };
+    case 6:
+      return function(D, U, F, q, W, Y) {
+        return w.apply(this, arguments);
+      };
+    case 7:
+      return function(D, U, F, q, W, Y, G) {
+        return w.apply(this, arguments);
+      };
+    case 8:
+      return function(D, U, F, q, W, Y, G, Z) {
+        return w.apply(this, arguments);
+      };
+    case 9:
+      return function(D, U, F, q, W, Y, G, Z, Q) {
+        return w.apply(this, arguments);
+      };
+    case 10:
+      return function(D, U, F, q, W, Y, G, Z, Q, tt) {
+        return w.apply(this, arguments);
+      };
+    default:
+      throw new Error("First argument to _arity must be a non-negative integer no greater than ten");
+  }
+}
+function _curryN(O, w, D) {
+  return function() {
+    for (var U = [], F = 0, q = O, W = 0, Y = !1; W < w.length || F < arguments.length; ) {
+      var G;
+      W < w.length && (!_isPlaceholder(w[W]) || F >= arguments.length) ? G = w[W] : (G = arguments[F], F += 1), U[W] = G, _isPlaceholder(G) ? Y = !0 : q -= 1, W += 1;
+    }
+    return !Y && q <= 0 ? D.apply(this, U) : _arity(Math.max(0, q), _curryN(O, U, D));
+  };
+}
+var curryN = /* @__PURE__ */ _curry2(function O(w, D) {
+  return w === 1 ? _curry1(D) : _arity(w, _curryN(w, [], D));
+});
+function _curry3(O) {
+  return function w(D, U, F) {
+    switch (arguments.length) {
+      case 0:
+        return w;
+      case 1:
+        return _isPlaceholder(D) ? w : _curry2(function(q, W) {
+          return O(D, q, W);
+        });
+      case 2:
+        return _isPlaceholder(D) && _isPlaceholder(U) ? w : _isPlaceholder(D) ? _curry2(function(q, W) {
+          return O(q, U, W);
+        }) : _isPlaceholder(U) ? _curry2(function(q, W) {
+          return O(D, q, W);
+        }) : _curry1(function(q) {
+          return O(D, U, q);
+        });
+      default:
+        return _isPlaceholder(D) && _isPlaceholder(U) && _isPlaceholder(F) ? w : _isPlaceholder(D) && _isPlaceholder(U) ? _curry2(function(q, W) {
+          return O(q, W, F);
+        }) : _isPlaceholder(D) && _isPlaceholder(F) ? _curry2(function(q, W) {
+          return O(q, U, W);
+        }) : _isPlaceholder(U) && _isPlaceholder(F) ? _curry2(function(q, W) {
+          return O(D, q, W);
+        }) : _isPlaceholder(D) ? _curry1(function(q) {
+          return O(q, U, F);
+        }) : _isPlaceholder(U) ? _curry1(function(q) {
+          return O(D, q, F);
+        }) : _isPlaceholder(F) ? _curry1(function(q) {
+          return O(D, U, q);
+        }) : O(D, U, F);
+    }
+  };
+}
+const _isArray = Array.isArray || function O(w) {
+  return w != null && w.length >= 0 && Object.prototype.toString.call(w) === "[object Array]";
+};
+function _isTransformer(O) {
+  return O != null && typeof O["@@transducer/step"] == "function";
+}
+function _dispatchable(O, w, D) {
+  return function() {
+    if (arguments.length === 0)
+      return D();
+    var U = arguments[arguments.length - 1];
+    if (!_isArray(U)) {
+      for (var F = 0; F < O.length; ) {
+        if (typeof U[O[F]] == "function")
+          return U[O[F]].apply(U, Array.prototype.slice.call(arguments, 0, -1));
+        F += 1;
+      }
+      if (_isTransformer(U)) {
+        var q = w.apply(null, Array.prototype.slice.call(arguments, 0, -1));
+        return q(U);
+      }
+    }
+    return D.apply(this, arguments);
+  };
+}
+const _xfBase = {
+  init: function() {
+    return this.xf["@@transducer/init"]();
+  },
+  result: function(O) {
+    return this.xf["@@transducer/result"](O);
+  }
+};
+function _has(O, w) {
+  return Object.prototype.hasOwnProperty.call(w, O);
+}
+var toString = Object.prototype.toString, _isArguments = /* @__PURE__ */ (function() {
+  return toString.call(arguments) === "[object Arguments]" ? function(w) {
+    return toString.call(w) === "[object Arguments]";
+  } : function(w) {
+    return _has("callee", w);
+  };
+})(), hasEnumBug = !/* @__PURE__ */ {
+  toString: null
+}.propertyIsEnumerable("toString"), nonEnumerableProps = ["constructor", "valueOf", "isPrototypeOf", "toString", "propertyIsEnumerable", "hasOwnProperty", "toLocaleString"], hasArgsEnumBug = /* @__PURE__ */ (function() {
+  return arguments.propertyIsEnumerable("length");
+})(), contains = function O(w, D) {
+  for (var U = 0; U < w.length; ) {
+    if (w[U] === D)
+      return !0;
+    U += 1;
+  }
+  return !1;
+}, keys = /* @__PURE__ */ _curry1(typeof Object.keys == "function" && !hasArgsEnumBug ? function O(w) {
+  return Object(w) !== w ? [] : Object.keys(w);
+} : function O(w) {
+  if (Object(w) !== w)
+    return [];
+  var D, U, F = [], q = hasArgsEnumBug && _isArguments(w);
+  for (D in w)
+    _has(D, w) && (!q || D !== "length") && (F[F.length] = D);
+  if (hasEnumBug)
+    for (U = nonEnumerableProps.length - 1; U >= 0; )
+      D = nonEnumerableProps[U], _has(D, w) && !contains(F, D) && (F[F.length] = D), U -= 1;
+  return F;
+});
+function _map(O, w) {
+  for (var D = 0, U = w.length, F = Array(U); D < U; )
+    F[D] = O(w[D]), D += 1;
+  return F;
+}
+function _arrayReduce(O, w, D) {
+  for (var U = 0, F = D.length; U < F; )
+    w = O(w, D[U]), U += 1;
+  return w;
+}
+var XMap = /* @__PURE__ */ (function() {
+  function O(w, D) {
+    this.xf = D, this.f = w;
+  }
+  return O.prototype["@@transducer/init"] = _xfBase.init, O.prototype["@@transducer/result"] = _xfBase.result, O.prototype["@@transducer/step"] = function(w, D) {
+    return this.xf["@@transducer/step"](w, this.f(D));
+  }, O;
+})(), _xmap = function O(w) {
+  return function(D) {
+    return new XMap(w, D);
+  };
+}, map = /* @__PURE__ */ _curry2(/* @__PURE__ */ _dispatchable(["fantasy-land/map", "map"], _xmap, function O(w, D) {
+  switch (Object.prototype.toString.call(D)) {
+    case "[object Function]":
+      return curryN(D.length, function() {
+        return w.call(this, D.apply(this, arguments));
+      });
+    case "[object Object]":
+      return _arrayReduce(function(U, F) {
+        return U[F] = w(D[F]), U;
+      }, {}, keys(D));
+    default:
+      return _map(w, D);
+  }
+}));
+const _isInteger = Number.isInteger || function O(w) {
+  return w << 0 === w;
+};
+function _nth(O, w) {
+  var D = O < 0 ? w.length + O : O;
+  return w[D];
+}
+function _prop(O, w) {
+  if (w != null)
+    return _isInteger(O) ? _nth(O, w) : w[O];
+}
+function _isString(O) {
+  return Object.prototype.toString.call(O) === "[object String]";
+}
+var _isArrayLike = /* @__PURE__ */ _curry1(function O(w) {
+  return _isArray(w) ? !0 : !w || typeof w != "object" || _isString(w) ? !1 : w.length === 0 ? !0 : w.length > 0 ? w.hasOwnProperty(0) && w.hasOwnProperty(w.length - 1) : !1;
+}), symIterator = typeof Symbol < "u" ? Symbol.iterator : "@@iterator";
+function _createReduce(O, w, D) {
+  return function(F, q, W) {
+    if (_isArrayLike(W))
+      return O(F, q, W);
+    if (W == null)
+      return q;
+    if (typeof W["fantasy-land/reduce"] == "function")
+      return w(F, q, W, "fantasy-land/reduce");
+    if (W[symIterator] != null)
+      return D(F, q, W[symIterator]());
+    if (typeof W.next == "function")
+      return D(F, q, W);
+    if (typeof W.reduce == "function")
+      return w(F, q, W, "reduce");
+    throw new TypeError("reduce: list must be array or iterable");
+  };
+}
+var and = /* @__PURE__ */ _curry2(function O(w, D) {
+  return w && D;
+});
+function _iterableReduce(O, w, D) {
+  for (var U = D.next(); !U.done; )
+    w = O(w, U.value), U = D.next();
+  return w;
+}
+function _methodReduce(O, w, D, U) {
+  return D[U](O, w);
+}
+var _reduce = /* @__PURE__ */ _createReduce(_arrayReduce, _methodReduce, _iterableReduce), ap = /* @__PURE__ */ _curry2(function O(w, D) {
+  return typeof D["fantasy-land/ap"] == "function" ? D["fantasy-land/ap"](w) : typeof w.ap == "function" ? w.ap(D) : typeof w == "function" ? function(U) {
+    return w(U)(D(U));
+  } : _reduce(function(U, F) {
+    return _concat(U, map(F, D));
+  }, [], w);
+});
+function _assoc(O, w, D) {
+  if (_isInteger(O) && _isArray(D)) {
+    var U = O < 0 ? D.length + O : O, F = [].concat(D);
+    return F[U] = w, F;
+  }
+  var q = {};
+  for (var W in D)
+    q[W] = D[W];
+  return q[O] = w, q;
+}
+var isNil = /* @__PURE__ */ _curry1(function O(w) {
+  return w == null;
+}), assocPath = /* @__PURE__ */ _curry3(function O(w, D, U) {
+  if (w.length === 0)
+    return D;
+  var F = w[0];
+  if (w.length > 1) {
+    var q = _prop(F, U);
+    (isNil(q) || typeof q != "object") && (q = _isInteger(w[1]) ? [] : {}), D = O(Array.prototype.slice.call(w, 1), D, q);
+  }
+  return _assoc(F, D, U);
+});
+function _isFunction(O) {
+  var w = Object.prototype.toString.call(O);
+  return w === "[object Function]" || w === "[object AsyncFunction]" || w === "[object GeneratorFunction]" || w === "[object AsyncGeneratorFunction]";
+}
+var liftN = /* @__PURE__ */ _curry2(function O(w, D) {
+  var U = curryN(w, D);
+  return curryN(w, function() {
+    return _arrayReduce(ap, map(U, arguments[0]), Array.prototype.slice.call(arguments, 1));
+  });
+}), lift = /* @__PURE__ */ _curry1(function O(w) {
+  return liftN(w.length, w);
+}), both = /* @__PURE__ */ _curry2(function O(w, D) {
+  return _isFunction(w) ? function() {
+    return w.apply(this, arguments) && D.apply(this, arguments);
+  } : lift(and)(w, D);
+}), hasPath = /* @__PURE__ */ _curry2(function O(w, D) {
+  if (w.length === 0 || isNil(D))
+    return !1;
+  for (var U = D, F = 0; F < w.length; )
+    if (!isNil(U) && _has(w[F], U))
+      U = U[w[F]], F += 1;
+    else
+      return !1;
+  return !0;
+}), has = /* @__PURE__ */ _curry2(function O(w, D) {
+  return hasPath([w], D);
+});
+function _path(O, w) {
+  for (var D = w, U = 0; U < O.length; U += 1) {
+    if (D == null)
+      return;
+    var F = O[U];
+    _isInteger(F) ? D = _nth(F, D) : D = D[F];
+  }
+  return D;
+}
+var path = /* @__PURE__ */ _curry2(_path);
+const DEFAULT_FORMATTERS = {
+  /**
+   * Format as JSON (useful for debugging)
+   */
+  json: (O) => JSON.stringify(O, null, 2),
+  /**
+   * Format date as "DD MMM YY HH:mm:ss" (e.g., "10 Nov 25 11:27:49")
+   * Accepts ISO date strings, timestamps, or Date objects.
+   * Returns empty string for null/undefined values.
+   */
+  date: (O) => {
+    if (!O) return "";
+    const w = O instanceof Date ? O : new Date(O);
+    return isNaN(w.getTime()) ? (console.warn("[Binder] Invalid date value:", O), "") : dateToZooyStdTimeString(w);
+  }
+};
+class Binder {
+  #t;
+  #e;
+  #s;
+  #r = null;
+  #n;
+  /**
+   * Creates a new Binder instance.
+   *
+   * @param {zooy.Panel} panel
+   * @param {string} url - API endpoint URL
+   * @param {Element} rootEl - Root element to walk for bindings
+   * @param options
+   * @param {Object<string, string|number>} [options.urlParams] - Configuration options
+   * @param {Object<string, Function>} [options.formatters] - Custom formatters
+   * @throws {Error} If url or rootEl is missing/invalid
+   */
+  constructor(w, D, U, F = {}) {
+    if (!D)
+      throw new Error("Binder requires a URL");
+    if (!U || !(U instanceof Element))
+      throw new Error("Binder requires a valid rootEl Element");
+    this.#t = w, this.#e = new URL(D, window.location.origin), this.#s = U, this.#n = { ...DEFAULT_FORMATTERS, ...F.formatters }, F.urlParams && this.#i(F.urlParams);
+  }
+  get url() {
+    return this.#e;
+  }
+  get data() {
+    return this.#r;
+  }
+  get limit() {
+    return parseInt(this.#e.searchParams.get("limit") || "0", 10);
+  }
+  get offset() {
+    return parseInt(this.#e.searchParams.get("offset") || "0", 10);
+  }
+  get isPaginated() {
+    return both(has("count"), has("results"))(this.#r);
+  }
+  #i(w) {
+    return Object.entries(w).forEach(([D, U]) => {
+      if (U == null || U === "") {
+        this.#e.searchParams.delete(D);
+        return;
+      }
+      if (Array.isArray(U)) {
+        this.#e.searchParams.set(D, U.join(","));
+        return;
+      }
+      this.#e.searchParams.set(D, U);
+    }), this.#e;
+  }
+  /**
+   * Fetches data from the configured URL with optional query parameters.
+   * Data is automatically bound to the DOM via setData() after fetch completes.
+   *
+   * @param {Object} [urlParams={}] - Query parameters to append to URL (e.g., {limit: 25, offset: 0, ordering: 'name'})
+   * @return {Promise<void>}
+   * @throws {Error} If fetch fails or response is invalid
+   */
+  async fetchData(w = {}) {
+    const D = await this.#t.user.fetchJson(
+      this.#i(w).toString(),
+      this.#t.abortController.signal
+    );
+    this.setData(D);
+  }
+  /**
+   * Sets data directly without fetching from URL.
+   * This is the convergence point for all data updates (from fetchData() or external sources).
+   *
+   * Behavior:
+   * - Stores full JSON object (not just arrays)
+   * - Calls render() to update the DOM
+   * - render() extracts appropriate slices for each consumer
+   *
+   * @param {Object} data - Full JSON response object
+   */
+  setData(w) {
+    this.#r = w, this.render();
+  }
+  /**
+   * Renders data by walking the rootEl element and processing all bindings.
+   *
+   * Supports two binding patterns:
+   * 1. Simple property binding - Direct zoo-bind attributes on elements (no templates)
+   * 2. Template rendering - Elements with zoo-template duplicate for arrays
+   *
+   * Algorithm:
+   * 1. Process simple bindings (zoo-bind, zoo-bind-attr outside template consumers)
+   * 2. Process template consumers (elements with zoo-template attribute)
+   *    - Get template ID and optional zoo-template-bind
+   *    - Extract data slice using Ramda's R.path()
+   *    - Clear consumer and clone template for each item
+   *
+   * Multiple consumers can exist in the same rootEl, each rendering different slices
+   * of the same JSON response (e.g., results, metadata, alerts).
+   */
+  render() {
+    if (!isDefAndNotNull(this.#r)) {
+      console.warn("[Binder] No data to render");
+      return;
+    }
+    this.#o(this.#s, this.#r, 0), this.#a();
+  }
+  /**
+   * Renders simple property bindings directly to existing elements.
+   * Processes zoo-bind-attr, zoo-bind, and conditional rendering attributes.
+   *
+   * This method is reusable and can be called with different elements and data objects.
+   * Used for both rootEl-level simple bindings and template item rendering.
+   *
+   * @param {Element|DocumentFragment} element - Root element to search for bindings
+   * @param {Object} data - Data object to bind
+   * @param {number} [index=0] - Current index (for $index and $index1 special variables)
+   * @param {Object} [options={}] - Rendering options
+   * @param {boolean} [options.removeOnCondition=false] - Remove elements on failed conditions (vs hiding with display:none)
+   * @param {boolean} [options.removeAttributes=false] - Remove binding attributes after processing (vs keeping for re-render)
+   * @private
+   */
+  #o(w, D, U = 0, F = {}) {
+    const q = F.removeAttributes ?? !1;
+    w.querySelectorAll("[zoo-bind-attr]").forEach((W) => {
+      if (W.closest("[zoo-template]")) return;
+      W.getAttribute("zoo-bind-attr").split(",").forEach((G) => {
+        const [Z, Q] = G.split(":").map((J) => J.trim()), tt = this.#c(D, Q, U);
+        isDefAndNotNull(tt) && W.setAttribute(Z, tt);
+      }), q && W.removeAttribute("zoo-bind-attr");
+    }), w.querySelectorAll("[zoo-bind]").forEach((W) => {
+      if (W.closest("[zoo-template]")) return;
+      const Y = W.getAttribute("zoo-bind"), G = W.getAttribute("zoo-bind-format");
+      let Z = this.#c(D, Y, U);
+      G && this.#n[G] && (Z = this.#n[G](Z, D)), W.textContent = Z ?? "", q && (W.removeAttribute("zoo-bind"), W.removeAttribute("zoo-bind-format"));
+    });
+  }
+  /**
+   * Renders template consumers by duplicating templates for array data.
+   *
+   * @private
+   */
+  #a() {
+    this.#s.querySelectorAll("[zoo-template]").forEach((D) => {
+      const U = D.getAttribute("zoo-template"), F = D.getAttribute("zoo-template-bind");
+      if (!U) {
+        console.warn("[Binder] Consumer missing template ID", D);
+        return;
+      }
+      const q = this.#s.querySelector(`#${U}`);
+      if (!q || q.tagName !== "TEMPLATE") {
+        console.error(`[DataBinder] Template not found or invalid: ${U}`);
+        return;
+      }
+      const W = F ? path(F.split("."), this.#r) : this.#r;
+      if (!W) {
+        console.warn(`[DataBinder] Data slice is undefined. Path: ${F}. Skipping render for this consumer.`);
+        return;
+      }
+      if (!Array.isArray(W)) {
+        console.error(`[DataBinder] Data slice is not an array. Path: ${F}`, W);
+        return;
+      }
+      D.innerHTML = "", W.forEach((Y, G) => {
+        const Z = this.#l(q, Y, G);
+        D.appendChild(Z);
+      });
+    });
+  }
+  /**
+   * Renders a single item from a template.
+   * Uses the unified rendering method with options for template-specific behavior.
+   *
+   * @param {HTMLTemplateElement} template - Template element
+   * @param {Object} item - Data object
+   * @param {number} index - Item index in array
+   * @return {DocumentFragment} Rendered template clone
+   * @private
+   */
+  #l(w, D, U) {
+    const F = w.content.cloneNode(!0);
+    return this.#o(F, D, U, {
+      removeAttributes: !0
+    }), F;
+  }
+  /**
+   * Gets a value from an object using dot notation.
+   *
+   * Special Variables:
+   * - $index: 0-based row number (within current page)
+   * - $index1: 1-based row number (within current page)
+   * - $index__paged: 0-based row number (accounts for pagination offset)
+   * - $index1__paged: 1-based row number (accounts for pagination offset)
+   *
+   * @param {Object} obj - Object to query
+   * @param {string} pathString - Dot-separated path (e.g., "profile.name") or special variable ($index, $index1, $index__paged, $index1__paged)
+   * @param {number} index - Item index in current data array (0-based)
+   * @return {*} The value, or undefined if not found
+   * @private
+   */
+  #c(w, D, U) {
+    const F = {
+      $index: () => U,
+      $index__paged: () => this.offset + U,
+      $index1: () => U + 1,
+      $index1__paged: () => this.offset + U + 1
+    };
+    return F[D] ? F[D]() : path(D.split("."), w);
+  }
+}
+const SEMANTIC_ATTRS = new Map(Object.entries({
+  event: "event",
+  endpoint: "endpoint",
+  href: "href",
+  url: "url",
+  target: "target",
+  "record-id": "recordId",
+  "zoo-sort-field": "sortField",
+  "zoo-view": "view"
+})), getSemanticAttributes = (O) => {
+  let w = {};
+  return Array.from(O.attributes).forEach((D) => {
+    const U = D.name, F = D.value;
+    SEMANTIC_ATTRS.has(U) ? w[SEMANTIC_ATTRS.get(U)] = F : (U.startsWith("data-") || U.startsWith("zoo-")) && (w = assocPath(U.split("-"), F, w));
+  }), w;
+}, getEventAttribute = (O, w, D = "event") => O.getAttribute(w) || O.getAttribute(D);
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t$1 = globalThis, e$2 = t$1.ShadowRoot && (t$1.ShadyCSS === void 0 || t$1.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, s$2 = Symbol(), o$3 = /* @__PURE__ */ new WeakMap();
+let n$2 = class {
+  constructor(w, D, U) {
+    if (this._$cssResult$ = !0, U !== s$2) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = w, this.t = D;
+  }
+  get styleSheet() {
+    let w = this.o;
+    const D = this.t;
+    if (e$2 && w === void 0) {
+      const U = D !== void 0 && D.length === 1;
+      U && (w = o$3.get(D)), w === void 0 && ((this.o = w = new CSSStyleSheet()).replaceSync(this.cssText), U && o$3.set(D, w));
+    }
+    return w;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+const r$2 = (O) => new n$2(typeof O == "string" ? O : O + "", void 0, s$2), i$3 = (O, ...w) => {
+  const D = O.length === 1 ? O[0] : w.reduce(((U, F, q) => U + ((W) => {
+    if (W._$cssResult$ === !0) return W.cssText;
+    if (typeof W == "number") return W;
+    throw Error("Value passed to 'css' function must be a 'css' function result: " + W + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
+  })(F) + O[q + 1]), O[0]);
+  return new n$2(D, O, s$2);
+}, S$1 = (O, w) => {
+  if (e$2) O.adoptedStyleSheets = w.map(((D) => D instanceof CSSStyleSheet ? D : D.styleSheet));
+  else for (const D of w) {
+    const U = document.createElement("style"), F = t$1.litNonce;
+    F !== void 0 && U.setAttribute("nonce", F), U.textContent = D.cssText, O.appendChild(U);
+  }
+}, c$2 = e$2 ? (O) => O : (O) => O instanceof CSSStyleSheet ? ((w) => {
+  let D = "";
+  for (const U of w.cssRules) D += U.cssText;
+  return r$2(D);
+})(O) : O;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const { is: i$2, defineProperty: e$1, getOwnPropertyDescriptor: h$1, getOwnPropertyNames: r$1, getOwnPropertySymbols: o$2, getPrototypeOf: n$1 } = Object, a$1 = globalThis, c$1 = a$1.trustedTypes, l$1 = c$1 ? c$1.emptyScript : "", p$1 = a$1.reactiveElementPolyfillSupport, d$1 = (O, w) => O, u$1 = { toAttribute(O, w) {
+  switch (w) {
+    case Boolean:
+      O = O ? l$1 : null;
+      break;
+    case Object:
+    case Array:
+      O = O == null ? O : JSON.stringify(O);
+  }
+  return O;
+}, fromAttribute(O, w) {
+  let D = O;
+  switch (w) {
+    case Boolean:
+      D = O !== null;
+      break;
+    case Number:
+      D = O === null ? null : Number(O);
+      break;
+    case Object:
+    case Array:
+      try {
+        D = JSON.parse(O);
+      } catch {
+        D = null;
+      }
+  }
+  return D;
+} }, f$1 = (O, w) => !i$2(O, w), b$1 = { attribute: !0, type: String, converter: u$1, reflect: !1, useDefault: !1, hasChanged: f$1 };
+Symbol.metadata ??= Symbol("metadata"), a$1.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
+let y$1 = class extends HTMLElement {
+  static addInitializer(w) {
+    this._$Ei(), (this.l ??= []).push(w);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(w, D = b$1) {
+    if (D.state && (D.attribute = !1), this._$Ei(), this.prototype.hasOwnProperty(w) && ((D = Object.create(D)).wrapped = !0), this.elementProperties.set(w, D), !D.noAccessor) {
+      const U = Symbol(), F = this.getPropertyDescriptor(w, U, D);
+      F !== void 0 && e$1(this.prototype, w, F);
+    }
+  }
+  static getPropertyDescriptor(w, D, U) {
+    const { get: F, set: q } = h$1(this.prototype, w) ?? { get() {
+      return this[D];
+    }, set(W) {
+      this[D] = W;
+    } };
+    return { get: F, set(W) {
+      const Y = F?.call(this);
+      q?.call(this, W), this.requestUpdate(w, Y, U);
+    }, configurable: !0, enumerable: !0 };
+  }
+  static getPropertyOptions(w) {
+    return this.elementProperties.get(w) ?? b$1;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(d$1("elementProperties"))) return;
+    const w = n$1(this);
+    w.finalize(), w.l !== void 0 && (this.l = [...w.l]), this.elementProperties = new Map(w.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(d$1("finalized"))) return;
+    if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(d$1("properties"))) {
+      const D = this.properties, U = [...r$1(D), ...o$2(D)];
+      for (const F of U) this.createProperty(F, D[F]);
+    }
+    const w = this[Symbol.metadata];
+    if (w !== null) {
+      const D = litPropertyMetadata.get(w);
+      if (D !== void 0) for (const [U, F] of D) this.elementProperties.set(U, F);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [D, U] of this.elementProperties) {
+      const F = this._$Eu(D, U);
+      F !== void 0 && this._$Eh.set(F, D);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(w) {
+    const D = [];
+    if (Array.isArray(w)) {
+      const U = new Set(w.flat(1 / 0).reverse());
+      for (const F of U) D.unshift(c$2(F));
+    } else w !== void 0 && D.push(c$2(w));
+    return D;
+  }
+  static _$Eu(w, D) {
+    const U = D.attribute;
+    return U === !1 ? void 0 : typeof U == "string" ? U : typeof w == "string" ? w.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = !1, this.hasUpdated = !1, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    this._$ES = new Promise(((w) => this.enableUpdating = w)), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach(((w) => w(this)));
+  }
+  addController(w) {
+    (this._$EO ??= /* @__PURE__ */ new Set()).add(w), this.renderRoot !== void 0 && this.isConnected && w.hostConnected?.();
+  }
+  removeController(w) {
+    this._$EO?.delete(w);
+  }
+  _$E_() {
+    const w = /* @__PURE__ */ new Map(), D = this.constructor.elementProperties;
+    for (const U of D.keys()) this.hasOwnProperty(U) && (w.set(U, this[U]), delete this[U]);
+    w.size > 0 && (this._$Ep = w);
+  }
+  createRenderRoot() {
+    const w = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return S$1(w, this.constructor.elementStyles), w;
+  }
+  connectedCallback() {
+    this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(!0), this._$EO?.forEach(((w) => w.hostConnected?.()));
+  }
+  enableUpdating(w) {
+  }
+  disconnectedCallback() {
+    this._$EO?.forEach(((w) => w.hostDisconnected?.()));
+  }
+  attributeChangedCallback(w, D, U) {
+    this._$AK(w, U);
+  }
+  _$ET(w, D) {
+    const U = this.constructor.elementProperties.get(w), F = this.constructor._$Eu(w, U);
+    if (F !== void 0 && U.reflect === !0) {
+      const q = (U.converter?.toAttribute !== void 0 ? U.converter : u$1).toAttribute(D, U.type);
+      this._$Em = w, q == null ? this.removeAttribute(F) : this.setAttribute(F, q), this._$Em = null;
+    }
+  }
+  _$AK(w, D) {
+    const U = this.constructor, F = U._$Eh.get(w);
+    if (F !== void 0 && this._$Em !== F) {
+      const q = U.getPropertyOptions(F), W = typeof q.converter == "function" ? { fromAttribute: q.converter } : q.converter?.fromAttribute !== void 0 ? q.converter : u$1;
+      this._$Em = F;
+      const Y = W.fromAttribute(D, q.type);
+      this[F] = Y ?? this._$Ej?.get(F) ?? Y, this._$Em = null;
+    }
+  }
+  requestUpdate(w, D, U) {
+    if (w !== void 0) {
+      const F = this.constructor, q = this[w];
+      if (U ??= F.getPropertyOptions(w), !((U.hasChanged ?? f$1)(q, D) || U.useDefault && U.reflect && q === this._$Ej?.get(w) && !this.hasAttribute(F._$Eu(w, U)))) return;
+      this.C(w, D, U);
+    }
+    this.isUpdatePending === !1 && (this._$ES = this._$EP());
+  }
+  C(w, D, { useDefault: U, reflect: F, wrapped: q }, W) {
+    U && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(w) && (this._$Ej.set(w, W ?? D ?? this[w]), q !== !0 || W !== void 0) || (this._$AL.has(w) || (this.hasUpdated || U || (D = void 0), this._$AL.set(w, D)), F === !0 && this._$Em !== w && (this._$Eq ??= /* @__PURE__ */ new Set()).add(w));
+  }
+  async _$EP() {
+    this.isUpdatePending = !0;
+    try {
+      await this._$ES;
+    } catch (D) {
+      Promise.reject(D);
+    }
+    const w = this.scheduleUpdate();
+    return w != null && await w, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
+        for (const [F, q] of this._$Ep) this[F] = q;
+        this._$Ep = void 0;
+      }
+      const U = this.constructor.elementProperties;
+      if (U.size > 0) for (const [F, q] of U) {
+        const { wrapped: W } = q, Y = this[F];
+        W !== !0 || this._$AL.has(F) || Y === void 0 || this.C(F, void 0, q, Y);
+      }
+    }
+    let w = !1;
+    const D = this._$AL;
+    try {
+      w = this.shouldUpdate(D), w ? (this.willUpdate(D), this._$EO?.forEach(((U) => U.hostUpdate?.())), this.update(D)) : this._$EM();
+    } catch (U) {
+      throw w = !1, this._$EM(), U;
+    }
+    w && this._$AE(D);
+  }
+  willUpdate(w) {
+  }
+  _$AE(w) {
+    this._$EO?.forEach(((D) => D.hostUpdated?.())), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(w)), this.updated(w);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = !1;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(w) {
+    return !0;
+  }
+  update(w) {
+    this._$Eq &&= this._$Eq.forEach(((D) => this._$ET(D, this[D]))), this._$EM();
+  }
+  updated(w) {
+  }
+  firstUpdated(w) {
+  }
+};
+y$1.elementStyles = [], y$1.shadowRootOptions = { mode: "open" }, y$1[d$1("elementProperties")] = /* @__PURE__ */ new Map(), y$1[d$1("finalized")] = /* @__PURE__ */ new Map(), p$1?.({ ReactiveElement: y$1 }), (a$1.reactiveElementVersions ??= []).push("2.1.1");
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const t = globalThis, i$1 = t.trustedTypes, s$1 = i$1 ? i$1.createPolicy("lit-html", { createHTML: (O) => O }) : void 0, e = "$lit$", h = `lit$${Math.random().toFixed(9).slice(2)}$`, o$1 = "?" + h, n = `<${o$1}>`, r = document, l = () => r.createComment(""), c = (O) => O === null || typeof O != "object" && typeof O != "function", a = Array.isArray, u = (O) => a(O) || typeof O?.[Symbol.iterator] == "function", d = `[ 	
+\f\r]`, f = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, v = /-->/g, _ = />/g, m = RegExp(`>|${d}(?:([^\\s"'>=/]+)(${d}*=${d}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g"), p = /'/g, g = /"/g, $ = /^(?:script|style|textarea|title)$/i, y = (O) => (w, ...D) => ({ _$litType$: O, strings: w, values: D }), x = y(1), b = y(2), T = Symbol.for("lit-noChange"), E = Symbol.for("lit-nothing"), A = /* @__PURE__ */ new WeakMap(), C = r.createTreeWalker(r, 129);
+function P(O, w) {
+  if (!a(O) || !O.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return s$1 !== void 0 ? s$1.createHTML(w) : w;
+}
+const V = (O, w) => {
+  const D = O.length - 1, U = [];
+  let F, q = w === 2 ? "<svg>" : w === 3 ? "<math>" : "", W = f;
+  for (let Y = 0; Y < D; Y++) {
+    const G = O[Y];
+    let Z, Q, tt = -1, J = 0;
+    for (; J < G.length && (W.lastIndex = J, Q = W.exec(G), Q !== null); ) J = W.lastIndex, W === f ? Q[1] === "!--" ? W = v : Q[1] !== void 0 ? W = _ : Q[2] !== void 0 ? ($.test(Q[2]) && (F = RegExp("</" + Q[2], "g")), W = m) : Q[3] !== void 0 && (W = m) : W === m ? Q[0] === ">" ? (W = F ?? f, tt = -1) : Q[1] === void 0 ? tt = -2 : (tt = W.lastIndex - Q[2].length, Z = Q[1], W = Q[3] === void 0 ? m : Q[3] === '"' ? g : p) : W === g || W === p ? W = m : W === v || W === _ ? W = f : (W = m, F = void 0);
+    const X = W === m && O[Y + 1].startsWith("/>") ? " " : "";
+    q += W === f ? G + n : tt >= 0 ? (U.push(Z), G.slice(0, tt) + e + G.slice(tt) + h + X) : G + h + (tt === -2 ? Y : X);
+  }
+  return [P(O, q + (O[D] || "<?>") + (w === 2 ? "</svg>" : w === 3 ? "</math>" : "")), U];
+};
+class N {
+  constructor({ strings: w, _$litType$: D }, U) {
+    let F;
+    this.parts = [];
+    let q = 0, W = 0;
+    const Y = w.length - 1, G = this.parts, [Z, Q] = V(w, D);
+    if (this.el = N.createElement(Z, U), C.currentNode = this.el.content, D === 2 || D === 3) {
+      const tt = this.el.content.firstChild;
+      tt.replaceWith(...tt.childNodes);
+    }
+    for (; (F = C.nextNode()) !== null && G.length < Y; ) {
+      if (F.nodeType === 1) {
+        if (F.hasAttributes()) for (const tt of F.getAttributeNames()) if (tt.endsWith(e)) {
+          const J = Q[W++], X = F.getAttribute(tt).split(h), K = /([.?@])?(.*)/.exec(J);
+          G.push({ type: 1, index: q, name: K[2], strings: X, ctor: K[1] === "." ? H : K[1] === "?" ? I : K[1] === "@" ? L : k }), F.removeAttribute(tt);
+        } else tt.startsWith(h) && (G.push({ type: 6, index: q }), F.removeAttribute(tt));
+        if ($.test(F.tagName)) {
+          const tt = F.textContent.split(h), J = tt.length - 1;
+          if (J > 0) {
+            F.textContent = i$1 ? i$1.emptyScript : "";
+            for (let X = 0; X < J; X++) F.append(tt[X], l()), C.nextNode(), G.push({ type: 2, index: ++q });
+            F.append(tt[J], l());
+          }
+        }
+      } else if (F.nodeType === 8) if (F.data === o$1) G.push({ type: 2, index: q });
+      else {
+        let tt = -1;
+        for (; (tt = F.data.indexOf(h, tt + 1)) !== -1; ) G.push({ type: 7, index: q }), tt += h.length - 1;
+      }
+      q++;
+    }
+  }
+  static createElement(w, D) {
+    const U = r.createElement("template");
+    return U.innerHTML = w, U;
+  }
+}
+function S(O, w, D = O, U) {
+  if (w === T) return w;
+  let F = U !== void 0 ? D._$Co?.[U] : D._$Cl;
+  const q = c(w) ? void 0 : w._$litDirective$;
+  return F?.constructor !== q && (F?._$AO?.(!1), q === void 0 ? F = void 0 : (F = new q(O), F._$AT(O, D, U)), U !== void 0 ? (D._$Co ??= [])[U] = F : D._$Cl = F), F !== void 0 && (w = S(O, F._$AS(O, w.values), F, U)), w;
+}
+class M {
+  constructor(w, D) {
+    this._$AV = [], this._$AN = void 0, this._$AD = w, this._$AM = D;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(w) {
+    const { el: { content: D }, parts: U } = this._$AD, F = (w?.creationScope ?? r).importNode(D, !0);
+    C.currentNode = F;
+    let q = C.nextNode(), W = 0, Y = 0, G = U[0];
+    for (; G !== void 0; ) {
+      if (W === G.index) {
+        let Z;
+        G.type === 2 ? Z = new R(q, q.nextSibling, this, w) : G.type === 1 ? Z = new G.ctor(q, G.name, G.strings, this, w) : G.type === 6 && (Z = new z(q, this, w)), this._$AV.push(Z), G = U[++Y];
+      }
+      W !== G?.index && (q = C.nextNode(), W++);
+    }
+    return C.currentNode = r, F;
+  }
+  p(w) {
+    let D = 0;
+    for (const U of this._$AV) U !== void 0 && (U.strings !== void 0 ? (U._$AI(w, U, D), D += U.strings.length - 2) : U._$AI(w[D])), D++;
+  }
+}
+class R {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(w, D, U, F) {
+    this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = w, this._$AB = D, this._$AM = U, this.options = F, this._$Cv = F?.isConnected ?? !0;
+  }
+  get parentNode() {
+    let w = this._$AA.parentNode;
+    const D = this._$AM;
+    return D !== void 0 && w?.nodeType === 11 && (w = D.parentNode), w;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(w, D = this) {
+    w = S(this, w, D), c(w) ? w === E || w == null || w === "" ? (this._$AH !== E && this._$AR(), this._$AH = E) : w !== this._$AH && w !== T && this._(w) : w._$litType$ !== void 0 ? this.$(w) : w.nodeType !== void 0 ? this.T(w) : u(w) ? this.k(w) : this._(w);
+  }
+  O(w) {
+    return this._$AA.parentNode.insertBefore(w, this._$AB);
+  }
+  T(w) {
+    this._$AH !== w && (this._$AR(), this._$AH = this.O(w));
+  }
+  _(w) {
+    this._$AH !== E && c(this._$AH) ? this._$AA.nextSibling.data = w : this.T(r.createTextNode(w)), this._$AH = w;
+  }
+  $(w) {
+    const { values: D, _$litType$: U } = w, F = typeof U == "number" ? this._$AC(w) : (U.el === void 0 && (U.el = N.createElement(P(U.h, U.h[0]), this.options)), U);
+    if (this._$AH?._$AD === F) this._$AH.p(D);
+    else {
+      const q = new M(F, this), W = q.u(this.options);
+      q.p(D), this.T(W), this._$AH = q;
+    }
+  }
+  _$AC(w) {
+    let D = A.get(w.strings);
+    return D === void 0 && A.set(w.strings, D = new N(w)), D;
+  }
+  k(w) {
+    a(this._$AH) || (this._$AH = [], this._$AR());
+    const D = this._$AH;
+    let U, F = 0;
+    for (const q of w) F === D.length ? D.push(U = new R(this.O(l()), this.O(l()), this, this.options)) : U = D[F], U._$AI(q), F++;
+    F < D.length && (this._$AR(U && U._$AB.nextSibling, F), D.length = F);
+  }
+  _$AR(w = this._$AA.nextSibling, D) {
+    for (this._$AP?.(!1, !0, D); w !== this._$AB; ) {
+      const U = w.nextSibling;
+      w.remove(), w = U;
+    }
+  }
+  setConnected(w) {
+    this._$AM === void 0 && (this._$Cv = w, this._$AP?.(w));
+  }
+}
+class k {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(w, D, U, F, q) {
+    this.type = 1, this._$AH = E, this._$AN = void 0, this.element = w, this.name = D, this._$AM = F, this.options = q, U.length > 2 || U[0] !== "" || U[1] !== "" ? (this._$AH = Array(U.length - 1).fill(new String()), this.strings = U) : this._$AH = E;
+  }
+  _$AI(w, D = this, U, F) {
+    const q = this.strings;
+    let W = !1;
+    if (q === void 0) w = S(this, w, D, 0), W = !c(w) || w !== this._$AH && w !== T, W && (this._$AH = w);
+    else {
+      const Y = w;
+      let G, Z;
+      for (w = q[0], G = 0; G < q.length - 1; G++) Z = S(this, Y[U + G], D, G), Z === T && (Z = this._$AH[G]), W ||= !c(Z) || Z !== this._$AH[G], Z === E ? w = E : w !== E && (w += (Z ?? "") + q[G + 1]), this._$AH[G] = Z;
+    }
+    W && !F && this.j(w);
+  }
+  j(w) {
+    w === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, w ?? "");
+  }
+}
+class H extends k {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(w) {
+    this.element[this.name] = w === E ? void 0 : w;
+  }
+}
+class I extends k {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(w) {
+    this.element.toggleAttribute(this.name, !!w && w !== E);
+  }
+}
+class L extends k {
+  constructor(w, D, U, F, q) {
+    super(w, D, U, F, q), this.type = 5;
+  }
+  _$AI(w, D = this) {
+    if ((w = S(this, w, D, 0) ?? E) === T) return;
+    const U = this._$AH, F = w === E && U !== E || w.capture !== U.capture || w.once !== U.once || w.passive !== U.passive, q = w !== E && (U === E || F);
+    F && this.element.removeEventListener(this.name, this, U), q && this.element.addEventListener(this.name, this, w), this._$AH = w;
+  }
+  handleEvent(w) {
+    typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, w) : this._$AH.handleEvent(w);
+  }
+}
+class z {
+  constructor(w, D, U) {
+    this.element = w, this.type = 6, this._$AN = void 0, this._$AM = D, this.options = U;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(w) {
+    S(this, w);
+  }
+}
+const j = t.litHtmlPolyfillSupport;
+j?.(N, R), (t.litHtmlVersions ??= []).push("3.3.1");
+const B = (O, w, D) => {
+  const U = D?.renderBefore ?? w;
+  let F = U._$litPart$;
+  if (F === void 0) {
+    const q = D?.renderBefore ?? null;
+    U._$litPart$ = F = new R(w.insertBefore(l(), q), q, void 0, D ?? {});
+  }
+  return F._$AI(O), F;
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const s = globalThis;
+class i extends y$1 {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+  }
+  createRenderRoot() {
+    const w = super.createRenderRoot();
+    return this.renderOptions.renderBefore ??= w.firstChild, w;
+  }
+  update(w) {
+    const D = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(w), this._$Do = B(D, this.renderRoot, this.renderOptions);
+  }
+  connectedCallback() {
+    super.connectedCallback(), this._$Do?.setConnected(!0);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this._$Do?.setConnected(!1);
+  }
+  render() {
+    return T;
+  }
+}
+i._$litElement$ = !0, i.finalized = !0, s.litElementHydrateSupport?.({ LitElement: i });
+const o = s.litElementPolyfillSupport;
+o?.({ LitElement: i });
+(s.litElementVersions ??= []).push("4.2.1");
+class ZooTag extends i {
+  static properties = {
+    token: { type: String },
+    prefix: { type: String },
+    postfix: { type: String }
+  };
+  static styles = i$3`
+      :host {
+          display: inline-block;
+      }
+
+      .tag {
+          text-align: center;
+          display: inline-flex;
+          align-items: center;
+          justify-content: center;
+          line-height: initial;
+          width: max-content;
+          padding: .2em 1em;
+          border-radius: 1em;
+          font-size: var(--zoo-theme-chips-font-size, 0.75rem);
+          white-space: nowrap;
+          word-break: break-word;
+          box-sizing: border-box;
+      }
+  `;
+  render() {
+    const w = this.prefix ?? "", D = this.token ?? "default", U = this.postfix ?? "", F = `${w}${D}${U}`;
+    return x`
+      <span
+        class="tag"
+        style="
+          background-color: var(--zoo-tag-${F}-bg, var(--zoo-tag-default-bg, #9e9e9e));
+          color: var(--zoo-tag-${F}-fg, var(--zoo-tag-default-fg, #ffffff));
+        "
+      >
+        <slot></slot>
+      </span>
+    `;
+  }
+}
+customElements.get("zoo-tag") || customElements.define("zoo-tag", ZooTag);
+const zoo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ZooTag,
+  getEventAttribute,
+  getSemanticAttributes
+}, Symbol.toStringTag, { value: "Module" }));
+async function registerCarbonLibrary() {
+  const { registerCarbonLibrary: O } = await import("./register-BCEOkbXG.js");
+  return O();
+}
+async function registerMdcLibrary() {
+  const { registerMdcLibrary: O } = await import("./register-Bkr1UKav.js");
+  return O();
+}
+const zooy = {
+  Evt,
+  Component,
+  Dragger,
+  Panel,
+  FormPanel,
+  Split,
+  UserManager,
+  View,
+  Conductor,
+  DataBinder: Binder,
+  UiEventType,
+  domUtils,
+  uriUtils,
+  registerCarbonLibrary,
+  registerMdcLibrary,
+  ComponentLibraryRegistry,
+  handlers,
+  zoo
+};
+export {
+  zoo as A,
+  Binder as B,
+  ComponentLibraryRegistry as C,
+  Dragger as D,
+  E,
+  FormPanel as F,
+  Panel as P,
+  Split as S,
+  T,
+  UserManager as U,
+  View as V,
+  _curry2 as _,
+  i$3 as a,
+  b,
+  isDefAndNotNull as c,
+  getEventAttribute as d,
+  B as e,
+  f$1 as f,
+  getSemanticAttributes as g,
+  hasPath as h,
+  i,
+  getElDataMap as j,
+  treeUtils as k,
+  registerMdcLibrary as l,
+  Evt as m,
+  Component as n,
+  objToPaths as o,
+  path as p,
+  UiEventType as q,
+  registerCarbonLibrary as r,
+  Conductor as s,
+  toLowerCase as t,
+  u$1 as u,
+  domUtils as v,
+  uriUtils as w,
+  x,
+  handlers as y,
+  zooy as z
+};