@trintel/zooy 1.0.1-beta.0 → 1.0.1-beta.1

package/dist/chunks/main-DTOZMPON.js

@@ -0,0 +1,3681 @@
+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) => (...D) => O.reduce((w, U) => (F) => w(U(F)))(...D), 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
+), isArray = (O) => O instanceof Array, reverse = (O) => Array.from(O).reduce((D, w) => [w, ...D], []), toLowerCase = (O) => O.toLowerCase(), toString = (O) => O + "", toNumber = (O) => +O;
+compose(toLowerCase, toString);
+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) => (D) => D.startsWith(O) ? D.slice(O.length) : D, join = (O) => (D) => D.join(O);
+compose(join(""), reverse);
+const pathOr = (O, D) => (w) => {
+  const U = D.reduce((F, q) => {
+    try {
+      return F[maybeNumber(q)];
+    } catch {
+      return;
+    }
+  }, w);
+  return U === void 0 ? O : U;
+}, randomId = (O) => {
+  const D = makeRandomString();
+  return O ? D.substr(0, O) : D;
+}, maybeNumber = (O) => {
+  if (O === null || whatType(O) === "string" && O.length > 1 && O.startsWith("0") && !O.startsWith("0."))
+    return O;
+  const D = 1 * O;
+  return D > Number.MAX_SAFE_INTEGER || Number.isNaN(D) ? O : D;
+};
+compose(toNumber, join(""), reverse, toString);
+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 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(D, w) {
+    return new CustomEvent(D, { detail: w });
+  }
+  /**
+   * 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(D) {
+    if (typeof D != "boolean")
+      throw new Error("This must be a boolean");
+    this.#t = D;
+  }
+  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(...D) {
+    this.#t && console.log.apply(null, [this.constructor.name, "DEBUG:", ...D]);
+  }
+  //--[ Listeners and Listening ]--
+  /**
+   * @param {!EventTarget|!EVT} comp
+   */
+  isListenedToBy(D) {
+    this.#r.add(D);
+  }
+  /**
+   * 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(D, w, U, F = !1) {
+    D.addEventListener(w, U, F);
+    const q = this.listeningTo.get(D) || {};
+    q[w] = () => D.removeEventListener(w, U, F), this.listeningTo.set(D, q), isDef(D.isListenedToBy) && D.isListenedToBy(this);
+  }
+  /**
+   * Remove self from all components tt are listening to me.
+   */
+  stopBeingListenedTo() {
+    for (const D of this.isObservedBy)
+      D.stopListeningTo(this), this.isObservedBy.delete(D);
+  }
+  /**
+   * Stop listening to all events on target.
+   * @param {!EventTarget|!EVT|!Node|undefined} target
+   * @param {string=} opt_event
+   */
+  stopListeningTo(D, w) {
+    D && this.listeningTo.has(D) && (isDef(D.isObservedBy) && D.isObservedBy.delete(this), isDef(w) ? (Object.entries(this.listeningTo.get(D)).forEach(([U, F]) => {
+      U === w && F();
+    }), Object.keys(this.listeningTo.get(D)).length || this.listeningTo.delete(D)) : (Object.values(this.listeningTo.get(D)).forEach((U) => U()), this.listeningTo.delete(D)));
+  }
+  /**
+   * Removes all the event listeners that is managed by this
+   * component.
+   */
+  removeAllListener() {
+    for (const D of this.listeningTo.keys())
+      this.stopListeningTo(D);
+  }
+  /**
+   * Clears all active intervals created by this component.
+   * Called automatically during disposal to prevent memory leaks.
+   */
+  clearAllIntervals() {
+    for (const D of this.activeIntervals)
+      clearInterval(D), this.activeIntervals.delete(D);
+  }
+  /**
+   * 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(D, w) {
+    const U = setInterval(D, w);
+    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(D, w) {
+    this.value_ = D, this.data_ = w || {};
+  }
+  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, D) {
+  if (D === 0)
+    return ["just now", "right now"];
+  var w = EN_US[Math.floor(D / 2)];
+  return O > 1 && (w += "s"), [O + " " + w + " ago", "in " + O + " " + w];
+}
+var ZH_CN = ["秒", "分钟", "小时", "天", "周", "个月", "年"];
+function zh_CN(O, D) {
+  if (D === 0)
+    return ["刚刚", "片刻后"];
+  var w = ZH_CN[~~(D / 2)];
+  return [O + " " + w + "前", O + " " + w + "后"];
+}
+var Locales = {}, register = function(O, D) {
+  Locales[O] = D;
+}, 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, D) {
+  var w = 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), D(O, F, U)[w].replace("%s", O.toString());
+}
+function diffSec(O, D) {
+  var w = /* @__PURE__ */ new Date();
+  return (+w - +toDate(O)) / 1e3;
+}
+var format = function(O, D, w) {
+  var U = diffSec(O);
+  return formatDiff(U, getLocale(D));
+};
+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 D = (
+    /** @type {!HTMLSelectElement} */
+    O.selectedIndex
+  );
+  return D >= 0 ? (
+    /** @type {!HTMLSelectElement} */
+    O.options[D].value
+  ) : null;
+}, getSelectMultiple_ = function(O) {
+  const D = [];
+  for (let w, U = 0; w = /** @type {!HTMLSelectElement} */
+  O.options[U]; U++)
+    w.selected && D.push(w.value);
+  return D.length ? D : null;
+}, getValue = function(O) {
+  const D = (
+    /** @type {!HTMLInputElement} */
+    O.type
+  );
+  switch (isString(D) && D.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((D, w) => (D[w.name] = w.value, D), {}), replaceNode = (O, D) => {
+  const w = D.parentNode;
+  w && w.replaceChild(O, D);
+}, removeNode = (O) => O && O.parentNode ? O.parentNode.removeChild(O) : null, insertSiblingAfter = (O, D) => {
+  D.parentNode && D.parentNode.insertBefore(O, D.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((D, w) => `${D}${w},`, "rgba(") + `${O || 0.5}`, totalWidth = (O) => {
+  const D = window.getComputedStyle(O), w = O.offsetWidth, U = parseFloat(D.marginLeft) + parseFloat(D.marginRight), F = parseFloat(D.paddingLeft) + parseFloat(D.paddingRight), q = parseFloat(D.borderLeftWidth) + parseFloat(D.borderRightWidth);
+  return w + U - F + q;
+}, totalHeight = (O) => {
+  const D = window.getComputedStyle(O), w = O.offsetHeight, U = parseFloat(D.marginTop) + parseFloat(D.marginBottom), F = parseFloat(D.paddingTop) + parseFloat(D.paddingBottom), q = parseFloat(D.borderTopWidth) + parseFloat(D.borderBottomWidth);
+  return w + U - F + q;
+}, evalScripts = (comp) => (arr) => {
+  arr && Array.from(arr).forEach((s) => {
+    (function() {
+      eval(s.text);
+    }).bind(comp)();
+  });
+}, evalModules = (O) => (D) => {
+  D && Array.from(D).forEach((w) => {
+    (function() {
+      const U = document.createElement("script");
+      U.type = "module", U.textContent = w.textContent;
+      const F = O.getElement(), q = getElDataMap(w).zv_comp_access;
+      q && (F.zvComponent = O, F.classList.add(q)), F.appendChild(U);
+    }).bind(O)();
+  });
+}, splitScripts = (O) => {
+  const w = new DOMParser().parseFromString(O, "text/html");
+  return {
+    html: w.body.firstElementChild,
+    scripts: w.querySelectorAll('script:not([type="module"])'),
+    modules: w.querySelectorAll('script[type="module"]')
+  };
+}, handleTemplateProm = (O) => Promise.resolve(splitScripts(O)), enableClass = (O, D, w) => {
+  w ? O.classList.add(D) : O.classList.remove(D);
+}, toggleClass = (O, D) => {
+  const w = !Array.from(O.classList).includes(D);
+  return enableClass(O, D, w), w;
+}, 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: D }, , { value: w }, , { value: U }, , { value: F }, , { value: q }, , { value: W }, ,] = dtf.formatToParts(O);
+  return `${w} ${D} ${U} ${F}:${q}:${W}`;
+}, parseMomentAgo = (O, D = "both", w = void 0) => {
+  let U = O;
+  isNumber(U) && U < 9466848e5 ? U = U * 1e3 : w && (U = U + w);
+  const F = new Date(U), q = format(F), W = dateToZooyStdTimeString(F);
+  switch (D) {
+    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 w = ((F) => (q) => q < F.length - 4)(O);
+  return ((F) => F.split("").map((q, W) => w(W) ? "*" : q).join(""))(O);
+}, parseMap = (/* @__PURE__ */ new Map()).set(void 0, (O, D, w) => identity(O)).set("", (O, D, w) => identity(O)).set("class_update_only", (O, D, w) => identity(O)).set("frac_100", (O, D, w) => Math.round(O * 100 * 100) / 100).set("date_and_time", (O, D, w) => new Date(O).toLocaleString(void 0, dtFormatter)).set("date", (O, D, w) => new Date(O).toLocaleString(void 0, dFormatter)).set("moment_ago", (O, D, w) => parseMomentAgo(O, "both", w.zdd_date_tz || void 0)).set("moment_ago_only", (O, D, w) => parseMomentAgo(O, "ago", w.zdd_date_tz || void 0)).set("moment_ago_datetime", (O, D, w) => parseMomentAgo(O, "datetime", w.zdd_date_tz || void 0)).set("pretty-json", (O, D, w) => JSON.stringify(O, null, 4)).set("obfuscated", (O, D, w) => parseObfuscated(O)).set("linear-progress", (O, D, w) => {
+  const U = toNumber(w.zpmax), F = D.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, D) => {
+  const w = getElDataMap(O);
+  delete O.dataset.zoodatapropkv;
+  const U = w.zoodatapropkv || "";
+  return parseDataPropKvDef(U).forEach(([q, W]) => {
+    O.dataset[q] = pathOr(void 0, W.split("."))(D);
+  }), O;
+}, mapDataToEls = (O, D, w = /* @__PURE__ */ new Map(), U = void 0) => {
+  if (!D)
+    return;
+  const F = new Map([...parseMap, ...w]);
+  [...O.querySelectorAll("[data-zdd],[data-zdd_class_update],[data-zdd_template_loop_index]")].forEach((q) => {
+    const W = getElDataMap(q), X = W.zdd || "", G = W.zdd_parse_as, K = W.zdd_render_effect || "", Q = W.zdd_class_update, tt = W.zdd_template_loop_index, J = W.zdd_units || "";
+    let Y = pathOr(void 0, X.split("."))(D);
+    if (isDefAndNotNull(Y) && (Y = F.has(G) ? F.get(G)(Y, q, W) : Y), 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 [Z, et, st] = Q.split(":"), rt = pathOr(void 0, Z.split("."))(D);
+      if (isDefAndNotNull(rt))
+        switch (et) {
+          case "swap": {
+            const nt = /\{}/gi, ot = st.replace(nt, ""), lt = st.replace(nt, rt);
+            q.classList.remove(...[...q.classList].filter((ht) => ht.includes(ot))), q.classList.add(lt);
+            break;
+          }
+          case "remove_on_data":
+            q.classList.remove(st);
+            break;
+          case "choice_map":
+            st.split("|").filter((nt) => nt !== "").forEach((nt) => {
+              const [ot, lt] = nt.split(">");
+              ot === rt + "" ? q.classList.add.apply(q.classList, lt.split(".")) : q.classList.remove.apply(q.classList, lt.split("."));
+            });
+            break;
+        }
+    }
+    if (G === "templated-array" && isArray(Y))
+      if (Y.length === 0)
+        q.classList.add("display__none");
+      else {
+        q.classList.remove("display__none"), Y = Y || [];
+        const Z = q.firstElementChild;
+        Z.classList.remove("display__none"), q.replaceChildren(...Y.map((et, st) => {
+          const rt = Z.cloneNode(!0), nt = parseDataProps(rt, et);
+          return mapDataToEls(nt, et, void 0, st), nt;
+        }));
+      }
+    else if (isDefAndNotNull(Y))
+      if (K === "typewriter") {
+        let Z = 0;
+        const et = Y + J, st = 5, rt = () => {
+          Z < et.length && (q.innerHTML += et.charAt(Z), Z++, setTimeout(rt, st));
+        };
+        q.innerHTML = "", rt();
+      } else
+        q.innerHTML = Y + 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(D, w) {
+    if (!w.render)
+      throw new Error(`Component library '${D}' must provide a render function`);
+    this.#t.set(D, {
+      ...w,
+      // Preserve all library properties (utils, helpers, etc.)
+      dispose: w.dispose || null,
+      // Optional disposal function
+      cache: /* @__PURE__ */ new Map(),
+      // Each library gets its own import cache
+      config: w.config || {}
+    }), console.debug(`[ComponentLibraryRegistry] Registered: ${D}`);
+  }
+  /**
+   * 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(D) {
+    if (!this.#t.has(D)) {
+      const w = Array.from(this.#t.keys()).join(", ");
+      throw new Error(
+        `Component library '${D}' is not registered. Available: ${w || "none"}`
+      );
+    }
+    return this.#t.get(D);
+  }
+  /**
+   * Checks if a component library is registered.
+   *
+   * @param {string} name - Library identifier
+   * @returns {boolean} True if registered
+   */
+  static has(D) {
+    return this.#t.has(D);
+  }
+  /**
+   * 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 D = {};
+    for (const [w, U] of this.#t.entries())
+      D[w] = {
+        cacheSize: U.cache.size,
+        config: U.config
+      };
+    return D;
+  }
+  /**
+   * Clears import caches for all component libraries.
+   * Useful for development/hot-reload scenarios.
+   */
+  static clearAllCaches() {
+    for (const [D, w] of this.#t.entries())
+      w.cache.clear(), console.debug(`[ComponentLibraryRegistry] Cleared cache for: ${D}`);
+  }
+  /**
+   * Clears cache for a specific library.
+   *
+   * @param {string} name - Library identifier
+   * @throws {Error} If library is not registered
+   */
+  static clearCache(D) {
+    this.get(D).cache.clear(), console.debug(`[ComponentLibraryRegistry] Cleared cache for: ${D}`);
+  }
+  /**
+   * 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(D) {
+    return this.#t.delete(D);
+  }
+  /**
+   * 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(D) {
+    this.#n = D;
+  }
+  /**
+   * @returns {Element|undefined}
+   */
+  get target() {
+    return this.#n;
+  }
+  /**
+   * Sets the model associated with the UI component.
+   * @param {*} m
+   */
+  set model(D) {
+    this.#r = D;
+  }
+  /**
+   * Returns the model associated with the UI component.
+   * @return {*}
+   */
+  get model() {
+    return this.#r;
+  }
+  /**
+   * @param {boolean} bool
+   */
+  set isInDocument(D) {
+    this.#e = D;
+  }
+  /**
+   * @return {boolean}
+   */
+  get isInDocument() {
+    return this.#e;
+  }
+  /**
+   * A function that makes a DOM element.
+   * @param {!function():(!HTMLElement|!Element|!DocumentFragment)} func
+   */
+  set domFunc(D) {
+    this.#t = D;
+  }
+  /**
+   * @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(D) {
+    this.#a = D;
+  }
+  //--[ 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_(D) {
+    this.#s = D;
+  }
+  /**
+   * 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(D) {
+    this.render_(D);
+  }
+  /**
+   * 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_(D) {
+    if (this.disposed)
+      throw new Error(ComponentError.ALREADY_DISPOSED);
+    if (this.isInDocument)
+      throw new Error(ComponentError.ALREADY_RENDERED);
+    this.#s || this.createDom();
+    const w = (
+      /** @type {!Node} */
+      this.#s
+    );
+    D && (this.#n = D), this.placeholderDom && removeNode(this.placeholderDom), this.#n ? isInPage(w) || this.#n.insertBefore(w, null) : isInPage(
+      /** @type {!Node} */
+      w
+    ) || document.body.appendChild(w), (!this.#i || this.#i.isInDocument) && this.enterDocument();
+  }
+  //--[ Life-cycle ]--
+  /**
+   * @param {Node} el
+   * @param {Node} targetParent
+   */
+  hoist(D, w = void 0) {
+    w || (w = document.querySelector("body")), w.appendChild(D), this.outOfTreeElements.push(D);
+  }
+  /**
+   * 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((D) => {
+      !D.isInDocument && D.getElement() && D.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((D) => {
+      D.isInDocument && D.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((D) => D.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 D = this.getElement();
+    if (D)
+      for (const w of ComponentLibraryRegistry.getRegisteredLibraries())
+        try {
+          const U = ComponentLibraryRegistry.get(w);
+          U.dispose && U.dispose(D);
+        } catch (U) {
+          console.debug(`[${w}] 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(D, w) {
+    const U = new ZooyEventData(D, w), 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, D, w, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F), W = (
+    /** @type {!HTMLElement} */
+    q.currentTarget
+  ), [X, G] = getPos(W), K = q.clientX - X, Q = q.clientY - G, tt = O(X, G, K, Q, W), J = w(X, G, K, Q, W), Y = D(X, G, K, Q, W);
+  let Z = freeMoveListener(Y, W, K, Q);
+  ["x", "ew"].includes(U) ? Z = xMoveOnlyListener(Y, W, K) : ["y", "ns"].includes(U) && (Z = yMoveOnlyListener(Y, W, K, Q));
+  let et = !1;
+  const st = (nt) => {
+    et = !0, Z(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, D, w, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F);
+  D.style.left = `${q.clientX - w}px`, D.style.top = `${q.clientY - U}px`, O(q);
+}, xMoveOnlyListener = (O, D, w, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F);
+  D.style.left = `${q.clientX - w}px`, O(q);
+}, yMoveOnlyListener = (O, D, w, U) => (F) => {
+  F.preventDefault();
+  const q = normalizeEvent(F);
+  D.style.top = `${q.clientY - U}px`, O(q);
+}, makeEmitter = (O, D) => (w, U, F, q, W) => (X) => {
+  O.dispatchCompEvent(D, {
+    component: O,
+    browserEvent: X,
+    left: w,
+    top: U,
+    clientX: X.clientX,
+    clientY: X.clientY,
+    xOrg: F,
+    yOrg: q,
+    deltaX: X.clientX - F - w,
+    deltaY: X.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(D = "xy") {
+    super(), this.#t = ["x", "y", "xy", "ew", "ns"].includes(D.toLowerCase()) ? D.toLowerCase() : "xy", this.#e = void 0, this.#s = !0, this.#r = (w) => null;
+  }
+  /**
+   * Cancels the current drag operation in progress, if any.
+   * @param {!Event} event The event that triggered the cancel
+   */
+  cancelDrag(D) {
+    this.#r(D);
+  }
+  //--[ 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(D) {
+    this.#t = D, 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 D = (w) => (U) => {
+      this.#r = w(U);
+    };
+    if (this.isInDocument && this.#s) {
+      const w = makeEmitter(this, UiEventType.COMP_DRAG_MOVE), U = makeEmitter(this, UiEventType.COMP_DRAG_START), F = makeEmitter(this, UiEventType.COMP_DRAG_END), q = dragStartListener(
+        U,
+        w,
+        F,
+        this.#t
+      );
+      this.#s = !1, this.#e = /** @type {!Node} */
+      this.#e || this.getElement(), this.listen(this.#e, EV.MOUSEDOWN, D(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, D) => 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(
+  (D) => `${D[0]}=${D[1]}`
+).join("&"), isValidValue = (O) => O != null && O !== "", queryDataToMap = (O) => O.split("&").reduce((D, w) => {
+  const [U, F] = w.split("=");
+  return isValidValue(U) && isValidValue(F) && D.set(U, F), D;
+}, /* @__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((D) => D.split("=")).reduce((D, w) => D.set(stripLeadingSpace(w[0]), w[1]), /* @__PURE__ */ new Map()).get(O), spinner = (O) => {
+  let D = 0, w;
+  const U = (F) => {
+    const q = F > 0;
+    return q ? D += 1 : D -= 1, q ? D === 1 : D === 0;
+  };
+  return (F) => {
+    w = w || document.getElementById(O), w && U(F) && w.classList.toggle("viz", D > 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) => (D) => {
+  if (D.type === "opaqueredirect" || D.redirected) {
+    const w = stripLeadingSlash(getPath(D.url));
+    O.setIsRedirected(!0, w), console.log("Redirect detected", w);
+  }
+  return checkStatus(D);
+}, getJson = (O) => O.status === 204 ? Promise.resolve({}) : O.json().then(
+  (D) => Promise.resolve(D),
+  (D) => Promise.reject(new Error(`Could not get JSON from response: ${D}`))
+), getText = (O) => O.text().then(
+  (D) => Promise.resolve(D),
+  (D) => Promise.reject(new Error(`Could not get text from response: ${D}`))
+), getTextOrJson = (O) => O.headers.get("Content-Type") === "application/json" ? getJson(O) : getText(O), jsonInit = (O, D, w = "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: w,
+    headers: F,
+    credentials: "include",
+    body: JSON.stringify(D)
+  };
+  return U && (q.signal = U), q;
+}, basicPutPostPatchInit = (O, D, w = !1, U = void 0) => {
+  const F = new Headers();
+  if (D && D !== "" && F.append("Authorization", `Bearer ${D}`), F.append("X-Requested-With", "XMLHttpRequest"), w) {
+    const W = getCookieByName("csrftoken");
+    W && w && 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, D, w = void 0) => {
+  const F = basicPutPostPatchInit("POST", O, !1, w);
+  return F.body = new FormData(D.formEl), F;
+}, basicGetInit = (O, D = void 0) => {
+  const w = new Headers();
+  w.append("Authorization", `Bearer ${O}`), w.append("X-Requested-With", "XMLHttpRequest");
+  const U = {
+    cache: "no-cache",
+    headers: w,
+    credentials: "include"
+  };
+  return D && (U.signal = D), U;
+}, putPostPatchNobody = (O, D) => {
+  const w = new Request(O);
+  return fetch(w, D).then(checkStatus).then(getText);
+}, genCatchClause = (O, D = void 0) => (w) => (stopSpin("").then(identity), w.name === "AbortError" ? console.info(O, "ABORTED!") : console.error(O, w), D);
+class UserManager {
+  /**
+   * @param {!Object=} opt_data
+   */
+  constructor(D) {
+    this.user_ = {}, this.jwt = "", D && this.updateProfileFromJwt(D).then(() => {
+    });
+  }
+  /**
+   * @param {Object} data
+   * @param {boolean=} opt_onlyIfNoneExists
+   * @return {Promise}
+   * @private
+   */
+  updateProfileFromJwt(D, w = !1) {
+    return w && this.jwt !== "" ? Promise.resolve("User Profile Already exists") : D.non_field_errors ? Promise.reject(new Error(`JWT ${D.non_field_errors}`)) : (this.updateToken(D.token), this.updateProfile(D.user), Promise.resolve("User Profile Updated"));
+  }
+  /**
+   * @param {UserLikeType} data
+   */
+  updateProfile(D) {
+    this.user_ = D;
+  }
+  /**
+   * @param {string} t
+   */
+  updateToken(D) {
+    this.jwt = D;
+  }
+  /**
+   * @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 D = this.name;
+    const w = this.surname;
+    return w && (D = D + " " + w), D;
+  }
+  /**
+   * @param {FormPanel} formPanel
+   * @return {Promise}
+   */
+  formSubmit(D) {
+    const w = new Request(D.uri.toString()), U = D.processSubmitReply.bind(D), F = genCatchClause("Form submit error");
+    return startSpin().then(() => fetch(w, formPostInit(
+      this.jwt,
+      D,
+      D.abortController.signal
+    ))).then(checkStatusTwo(D)).then(stopSpin).then(getTextOrJson).then(U).catch(F);
+  }
+  /**
+   * @param {string} uri
+   * @param {Boolean} useDocumentCookies
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  putNoBody(D, w = void 0, U = !1) {
+    const F = genCatchClause("putNobody error"), q = basicPutPostPatchInit(
+      "PUT",
+      this.jwt,
+      U,
+      w
+    );
+    return putPostPatchNobody(D, q).catch(F);
+  }
+  /**
+   * @param {string} uri
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  fetch(D, w = void 0) {
+    const U = new Request(D.toString()), F = genCatchClause(`UMan Text GET Fetch: ${D}`);
+    return startSpin().then(() => fetch(U, basicGetInit(this.jwt, w))).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(D, w = void 0) {
+    const U = genCatchClause(`fetchAndSplit: ${D}`);
+    return this.fetch(D, w).then(handleTemplateProm).catch(U);
+  }
+  /**
+   * @param {string} uri
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  fetchJson(D, w = void 0) {
+    const U = new Request(D.toString()), F = genCatchClause(`fetchJson: ${D}`, {}), q = basicGetInit(this.jwt, w);
+    return startSpin().then(() => fetch(U, q)).then(checkStatus).then(stopSpin).then(getJson).catch(F);
+  }
+  /**
+   * @param {string} uri
+   * @param {Object} payload
+   * @param {AbortSignal|undefined} signal
+   * @return {Promise}
+   */
+  patchJson(D, w, U = void 0) {
+    const F = new Request(D.toString()), q = genCatchClause(`patchJson: ${D}`), W = jsonInit(this.jwt, w, "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(D, w, U = void 0) {
+    const F = new Request(D.toString()), q = genCatchClause(`postJson: ${D}`), W = jsonInit(this.jwt, w, "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(D, w, U = void 0) {
+    const F = new Request(D.toString()), q = genCatchClause(`putJson: ${D}`), W = jsonInit(this.jwt, w, "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(D, w, U = void 0) {
+    const F = new Request(D.toString()), q = genCatchClause(`delJson: ${D}`), W = jsonInit(this.jwt, w, "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(D) {
+    super(), this.qParamMap_ = /* @__PURE__ */ new Map(), this.uri_ = "", D && this.parseUri(D), 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 D = this.qParamMap_.size > 0 ? "?" + objectToUrlParms(Object.fromEntries(this.qParamMap_)) : "";
+    return this.uri_ + D;
+  }
+  /**
+   * @param {!UserManager} user
+   */
+  set user(D) {
+    this.user_ = D;
+  }
+  /**
+   * @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(D) {
+    this.uri_ = getPath(D), this.qParamMap_ = queryDataToMap(getQueryData(D));
+  }
+  /**
+   * 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(D, w) {
+    this.qParamMap_.set(D, w);
+  }
+  /**
+   * Removes a query parameter from the panel's query parameter map.
+   * @param {string} k The parameter key to remove
+   */
+  removeFromQParams(D) {
+    this.qParamMap_.delete(D);
+  }
+  /**
+   * 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(D) {
+    return this.carbonComponents?.get(D) || [];
+  }
+  /**
+   * 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(D) {
+    if (this.carbonComponents)
+      for (const w of this.carbonComponents.values()) {
+        const U = w.find((F) => F.id === D);
+        if (U)
+          return U;
+      }
+  }
+  //--[ Template Render ]-----
+  /**
+   * Temporarily render placeholder DOM
+   * @param {Node!} placeholder
+   */
+  renderPlaceHolder(D) {
+    this.target && (this.placeholderDom = D, 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(D) {
+    const w = this.user;
+    return w ? w.fetch(this.uri, this.abortController.signal).then((U) => (this.assertCanRenderAsync(), D && D(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(D) {
+    return this.responseObject = splitScripts(D), 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(D, w) {
+    const U = this.getElement();
+    if (isUndefined(U))
+      return;
+    const F = D.html;
+    if (w.startsWith("."))
+      [...U.querySelectorAll(w)].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 (w.startsWith("#")) {
+      const q = F.querySelector(w), W = U.querySelector(w);
+      W.parentNode.replaceChild(q, W), this.parseContent(q);
+    }
+    this.evalScripts(D.scripts), this.evalModules(D.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(D) {
+    return this.user ? this.user.fetchJson(this.uri_, this.abortController.signal).then((U) => {
+      this.assertCanRenderAsync(), D && D(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(D) {
+    return Promise.resolve(this);
+  }
+  /**
+   * @param {Element} _el
+   * @param {Object} _elDataMap
+   * @param {Object} _json
+   */
+  onAsyncJsonReply(D, w, U) {
+  }
+  /**
+   * Called on each async HTML response, after the content is in the DOM
+   * and rendered.
+   * @param {Element} _el
+   * @param {Object} _elDataMap
+   */
+  onAsyncHtmlReply(D, w) {
+  }
+  /**
+   * 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(D) {
+  }
+  //--[ JSON Render ]-----
+  /**
+   * @param {Element} panel
+   */
+  parseContent(D) {
+    if (this.debugMe("Enable interactions. Panel:", D), typeof window.customElements < "u" && ComponentLibraryRegistry.has("carbon")) {
+      const J = ComponentLibraryRegistry.get("carbon");
+      J.render.call(this, D, J.cache).catch((Y) => console.error("[Zooy] Carbon initialization failed:", Y));
+    }
+    if (ComponentLibraryRegistry.has("mdc")) {
+      const J = ComponentLibraryRegistry.get("mdc");
+      J.render.call(this, D, J.cache);
+    }
+    D.classList.contains("zoo__modal-base") && D.classList.contains("close_on_click") && this.listen(D, EV.CLICK, (J) => {
+      J.target === D && this.dispatchPanelEvent("destroy_me");
+    }), [...D.querySelectorAll(
+      ".zoo__button:not(.external):not(.mdc-data-table__row)"
+    )].forEach((J) => {
+      this.listen(J, EV.CLICK, (Y) => {
+        Y.stopPropagation();
+        const Z = Y.currentTarget, et = getElDataMap(Z);
+        this.dispatchPanelEvent(et.zv, Object.assign({
+          orgEvt: Y,
+          trigger: Z,
+          href: Z.href || et.href
+        }, et));
+      });
+    }), [...D.querySelectorAll("[href]:not(.external)")].forEach((J) => {
+      this.listen(J, EV.CLICK, (Y) => {
+        const Z = Y.currentTarget;
+        Y.preventDefault(), Y.stopPropagation();
+        const et = getElDataMap(Z), st = et.zv || "href";
+        this.dispatchPanelEvent(st, Object.assign({
+          orgEvt: Y,
+          trigger: Y.target,
+          href: Z.href || et.href
+        }, et));
+      });
+    }), [...D.querySelectorAll("form.intercept_submit")].forEach((J) => {
+      J.noValidate = !0, this.listen(J, EV.SUBMIT, (Y) => {
+        Y.preventDefault(), Y.stopPropagation();
+        const Z = getElDataMap(J), et = formToJSON(J.elements);
+        this.dispatchPanelEvent(Z.zv, Object.assign({
+          orgEvt: Y,
+          trigger: Y.target,
+          formData: et,
+          href: Z.href
+        }, Z));
+      });
+    }), [...D.querySelectorAll(".zoo__toggle_class_driver")].forEach(
+      (J) => {
+        const Y = getElDataMap(J), Z = Y.toggle_class_target_id, et = Y.toggle_class, st = D.querySelector(`#${Z}`);
+        st && et && J.addEventListener(EV.CLICK, (rt) => {
+          rt.stopPropagation(), st.classList.toggle(et);
+        });
+      }
+    );
+    const w = Array.from(D.querySelectorAll(".folder_drop_zone")), U = Array.from(D.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");
+    }, X = (J) => {
+      J.preventDefault(), J.target.classList.remove("drag_over");
+    }, G = (J) => {
+      J.preventDefault(), J.target.classList.remove("drag_over");
+    }, K = (J) => {
+      J.dataTransfer.dropEffect = "move";
+      const Y = getElDataMap(J.target);
+      J.dataTransfer.setData("text/plain", JSON.stringify(Y)), J.target.classList.add("drag_in_progress");
+    }, Q = (J) => {
+      J.target.classList.remove("drag_in_progress");
+    }, tt = (J) => {
+      G(J), J.stopPropagation();
+      const Y = JSON.parse(J.dataTransfer.getData("text/plain")), Z = getElDataMap(J.target);
+      return this.dispatchPanelEvent("drop_on", {
+        custom: { on: Z, from: Y }
+      }), !1;
+    };
+    w.forEach((J) => {
+      this.listen(J, EV.DRAGOVER, q), this.listen(J, EV.DRAGENTER, F), this.listen(J, EV.DRAGEXIT, X), this.listen(J, EV.DRAGLEAVE, W), this.listen(J, EV.DROP, tt);
+    }), U.forEach((J) => {
+      this.listen(J, EV.DRAGSTART, K), this.listen(J, EV.DRAGEND, Q);
+    }), [...D.querySelectorAll(".zoo_async_json")].forEach((J) => {
+      const Y = getElDataMap(J), Z = Y.href, et = this.onAsyncJsonReply.bind(this, J, Y);
+      this.user.fetchJson(Z, this.abortController.signal).then(et);
+      const st = Y.z_json_reusable;
+      st && (this.jsonCallFuncs = this.jsonCallFuncs || {}, this.jsonCallFuncs[st] = () => {
+        this.user.fetchJson(Z, this.abortController.signal).then(et);
+      });
+      const rt = toNumber(Y.z_interval);
+      isNumber(rt) && this.doOnBeat(() => {
+        this.user.fetchJson(Z, this.abortController.signal).then(et);
+      }, rt * 60 * 1e3);
+    }), [...D.querySelectorAll(".zoo_async_html")].forEach(
+      /**
+       * @param {Element} el
+       */
+      (J) => {
+        const Y = getElDataMap(J), Z = Y.href;
+        this.user.fetchAndSplit(Z, this.abortController.signal).then((st) => {
+          J.appendChild(st.html), this.parseContent(J), this.evalScripts(st.scripts), this.evalModules(st.modules), this.onAsyncHtmlReply(J, Y);
+        });
+        const et = toNumber(Y.z_interval);
+        isNumber(et) && this.doOnBeat(() => {
+          this.user.fetchAndSplit(Z, 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 D = this.getElement();
+    this.parseContent(D), 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(D, w) {
+    this.redirected = D, this.redirected && w && (this.uri_ = w);
+  }
+  //--[ 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(D, w) {
+    const U = new ZooyEventData(D, w), F = EVT.makeEvent(UiEventType.PANEL, U);
+    return this.debugMe("PANEL EVENT FIRED. Value:", D, "Opt DATA:", w), 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(D, w = !0) {
+    super(D), this.#s = w, 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(D) {
+    let w = null, U = this.getElement().querySelector("form");
+    return D && (U = document.getElementById(
+      /** @type {string} */
+      D
+    ) || U), U && U.tagName.toLowerCase() === "form" && (w = /** @type {HTMLFormElement} */
+    U), w;
+  }
+  //--[ 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, (D) => {
+      this.#o(D);
+    }, { passive: !0 }), this.listen(this.#t, EV.INPUT, (D) => {
+      this.clearAllValidationErrors(), this.#o(D);
+    }), this.listen(this.#t, EV.INVALID, (D) => {
+      D.preventDefault();
+      const w = (
+        /** @type {HTMLInputElement} */
+        D.target
+      );
+      this.#i(w), this.displayFieldError(w);
+    }, { 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 D = [...this.#t.elements].map((w) => [this.#n(w), w]).filter((w) => !w[0]);
+    return D.forEach((w) => this.displayFieldError(w[1])), D.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_(D, w, U) {
+    const F = document.getElementById(`${D.id}-helper-text`) || document.createElement("p");
+    F.textContent = w, this.#e.set(D, F);
+  }
+  /**
+   * Check validation for a single field
+   * @param {HTMLInputElement} field
+   * @return {boolean} True if field is valid
+   * @private
+   */
+  #n(D) {
+    this.#i(D);
+    let w = !D.willValidate;
+    return D.willValidate && (w = D.checkValidity()), w;
+  }
+  /**
+   * Clear alert for a single field
+   * @param {HTMLInputElement} field
+   * @private
+   */
+  #i(D) {
+    D.classList.remove("error"), this.#e.has(D) && (this.#e.get(D).textContent = ""), this.#e.delete(D);
+  }
+  /**
+   * Display the given error message on the given form field.
+   * @param {HTMLInputElement} field
+   * @param {string=} opt_msg
+   */
+  displayFieldError(D, w) {
+    const U = w || D.validationMessage;
+    D.classList.add("error"), this.displayAlert_(D, U, "alert-error");
+  }
+  /**
+   * Display the given success message on the given form field.
+   * @param {HTMLInputElement} field
+   * @param {string} message
+   */
+  displayFieldSuccess(D, w) {
+    this.displayAlert_(D, w, "alert-success");
+  }
+  /**
+   * Display the given information message on the given form field.
+   * @param {HTMLInputElement} field
+   * @param {string} message
+   */
+  displayFieldInfo(D, w) {
+    this.displayAlert_(D, w, "alert-info");
+  }
+  /**
+   * Validate field on change event
+   * @param {Event} e
+   * @private
+   */
+  #o(D) {
+    this.#n(
+      /** @type {HTMLInputElement} */
+      D.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(D) {
+    if (D && this.#s) {
+      D.noValidate = !0;
+      const w = this.user;
+      this.listen(D, EV.SUBMIT, (U) => {
+        U.preventDefault(), this.debugMe("Intercepted from SUBMIT"), this.checkAllFields() && w && w.formSubmit(this);
+      });
+    }
+    return D;
+  }
+  //--[ Round Trip ]--
+  /**
+   * @param {function(!FormPanel, (string|!ServerFormSuccessJsonType)=): (?|null|Promise<?>)} func
+   */
+  onSubmitSuccess(D) {
+    this.onSubmitSucFunc = D;
+  }
+  /**
+   * 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(D) {
+    if (this.responseObject = splitScripts(D), this.responseObject.html) {
+      if (this.redirected) {
+        this.removeAllListener();
+        const w = this.getElement(), U = w.parentNode;
+        this.setElementInternal_(this.responseObject.html), U.replaceChild(this.getElement(), w);
+      } else {
+        const w = (
+          /** @type {!Element} */
+          this.responseObject.html.querySelector("form")
+        );
+        w && replaceNode(w, 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 D = this.user, w = this.uri;
+    return D ? D.fetch(w, 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(D) {
+    this.clearAllValidationErrors();
+    let w = !1;
+    if (whatType(D) === "object" && D.success)
+      return Promise.resolve(this).then(() => {
+        this.onSubmitSucFunc(this, D), this.dispatchCompEvent(UiEventType.FORM_SUBMIT_SUCCESS);
+      });
+    if (D === "success" ? (this.debugMe(`
+      1.REDIRECTED: ${this.redirected}
+      REPLY: ${D}`), w = !0) : D === `redirected_success
+` ? (this.debugMe(`
+      2.REDIRECTED: ${this.redirected}
+      REPLY: ${D}`), w = !0, this.redirected = !1) : (this.debugMe(`
+      3.REDIRECTED: ${this.redirected}
+      REPLY: Some form HTML`), this.replaceForm(D)), w && this.redirected)
+      return this.debugMe(`
+      4.REDIRECTED: ${this.redirected}
+      SUCCESS: ${w}`), this.redirected = !1, Promise.resolve(this);
+    if (w)
+      return this.debugMe(`
+      5.REDIRECTED: ${this.redirected}
+      SUCCESS: ${w}`), Promise.resolve(this).then(() => {
+        this.onSubmitSucFunc(this), this.dispatchCompEvent(UiEventType.FORM_SUBMIT_SUCCESS);
+      });
+    this.debugMe(`
+      6.REDIRECTED: ${this.redirected}
+      SUCCESS: ${w}`);
+  }
+}
+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(([D, { nestEl: w }]) => w);
+  }
+  /**
+   * 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(D) {
+    return this.nestMap_.get(D)?.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(([D, w]) => !this.splitNests_.has(w)).map(([D]) => D);
+  }
+  /**
+   * 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(D = identity, w = !1) {
+    this.nestNames.forEach((U) => this.closeAndLock(U, D, w));
+  }
+  /**
+   * 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(D = identity, w = !1) {
+    this.nestNames.forEach((U) => this.openAndUnlock(U, D, w));
+  }
+  // ---------------------------------------------------------------------------
+  /**
+   * 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(D) {
+    const { dragEl: w } = this.nestMap_.get(D);
+    w.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(D) {
+    const { dragEl: w } = this.nestMap_.get(D);
+    w.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(D, w, U = identity, F = !1) {
+    const { sizeNow: q, nestEl: W, canResize: X } = this.nestMap_.get(D);
+    X && (F || q === w ? (W.classList.remove("animated"), W.style.flexBasis = `${w}px`, this.nestMap_.get(D).sizeNow = w, U()) : (W.classList.add("animated"), this.nestCallbackMap_.set(D, () => {
+      W.classList.remove("animated"), this.nestMap_.get(D).sizeNow = w, U();
+    }), W.style.flexBasis = `${w}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(D, w = identity, U = !1) {
+    const { nestEl: F, dragEl: q, canResize: W } = this.nestMap_.get(D);
+    if (!W)
+      return;
+    const X = () => {
+      q.classList.add("locked", "closed"), F.classList.add("closed"), w();
+    };
+    this.resize(D, 0, X, U);
+  }
+  closeAndUnlock(D, w = identity, U = !1) {
+    const { nestEl: F, dragEl: q, canResize: W } = this.nestMap_.get(D);
+    if (!W)
+      return;
+    const X = () => {
+      F.classList.remove("closed"), q.classList.remove("closed", "locked"), q.classList.add("collapsed"), w();
+    };
+    this.resize(D, 0, X, 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(D, w, U, F = !1) {
+    const {
+      nestEl: q,
+      dragEl: W,
+      defSize: X,
+      lastSize: G,
+      canResize: K
+    } = this.nestMap_.get(D);
+    if (!K)
+      return;
+    const Q = w || G || X;
+    q.classList.remove("closed"), W.classList.remove("closed", "locked", "collapsed"), setTimeout(() => {
+      this.resize(D, 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(D, w, U, F = !1) {
+    const {
+      nestEl: q,
+      dragEl: W,
+      defSize: X,
+      lastSize: G,
+      canResize: K
+    } = this.nestMap_.get(D);
+    if (!K)
+      return;
+    const Q = w || G || X;
+    q.classList.remove("closed"), W.classList.remove("closed", "collapsed"), setTimeout(() => {
+      this.resize(D, 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(D, w = identity, U = !1) {
+    const { dragEl: F, canResize: q, nestEl: W } = this.nestMap_.get(D);
+    if (!q)
+      return;
+    this.dispatchSplitEvent(UiEventType.SPLIT_WILL_CLOSE, { nestName: D, nestEl: W });
+    const X = () => {
+      F.classList.add("collapsed"), this.dispatchSplitEvent(UiEventType.SPLIT_DID_CLOSE, { nestName: D, nestEl: W }), w();
+    };
+    this.resize(D, 0, X, 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(D, w = identity, U = !1) {
+    const { defSize: F, lastSize: q, dragEl: W, canResize: X, nestEl: G } = this.nestMap_.get(D);
+    if (!X)
+      return;
+    this.dispatchSplitEvent(UiEventType.SPLIT_WILL_OPEN, { nestName: D, nestEl: G }), W.classList.remove("collapsed", "closed");
+    const K = q || F, Q = () => {
+      this.dispatchSplitEvent(UiEventType.SPLIT_DID_OPEN, { nestName: D, nestEl: G }), w();
+    };
+    this.resize(D, K, 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(D, w, U = !1) {
+    this.nestMap_.get(D).sizeNow === 0 ? this.open(D, w, U) : this.close(D, w, 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(D = void 0, w = "EW", U = 100, F = 100, q = [], W = [], X = [], G = [], K = []) {
+    const Q = D || this.getElement();
+    if (this.splitNests_.has(Q))
+      return ["Already used!", Q];
+    convertElToSplit(Q, w), this.splitNests_.add(Q);
+    let tt = "";
+    if (D) {
+      const it = [...this.nestMap_.entries()].find(([at, { nestEl: ct }]) => ct === D);
+      if (it)
+        tt = it[0];
+      else
+        return ["Element not managed by this component", D];
+    }
+    const J = `${tt}A`, Y = makeOuterNest(U, ["zoo_nest__A", J, ...q]), Z = new Dragger(w);
+    Z.domFunc = makeDraggerEl([`zoo_drag_${J}`, ...G], K), Z.render(Q), this.nestMap_.set(J, {
+      side: "A",
+      nestEl: Y,
+      dragger: Z,
+      dragEl: Z.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(w);
+    nt.domFunc = makeDraggerEl([`zoo_drag_${rt}`, ...G], K), nt.render(Q);
+    const ot = makeOuterNest(F, ["zoo_nest__C", rt, ...X]);
+    this.nestMap_.set(rt, {
+      side: "C",
+      nestEl: ot,
+      dragger: nt,
+      dragEl: nt.getElement(),
+      defSize: F,
+      sizeNow: -1,
+      canResize: !0
+    }), [Y, Z.getElement(), st, nt.getElement(), ot].forEach((it) => Q.appendChild(it));
+    let lt = 0;
+    const ht = (it, at, ct, gt) => {
+      let dt;
+      const ut = it === "NS" ? "height" : "width", ft = it === "NS" ? "deltaY" : "deltaX";
+      return (pt) => {
+        switch (pt.detail.value_) {
+          case UiEventType.COMP_DRAG_START:
+            dt = at.getBoundingClientRect()[ut], lt = st.getBoundingClientRect()[ut] + dt, this.nestMap_.get(ct).dragEl.classList.remove("collapsed");
+            break;
+          case UiEventType.COMP_DRAG_MOVE: {
+            const mt = Math.min(lt, dt + gt * pt.detail.data_[ft]);
+            this.nestMap_.get(ct).lastSize = mt, at.style.flexBasis = mt + "px";
+            break;
+          }
+          case UiEventType.COMP_DRAG_END:
+            this.dispatchSplitEvent(UiEventType.COMP_DRAG_END, this.nestMap_.get(ct));
+            break;
+        }
+      };
+    };
+    this.listen(Z, Component.compEventCode(), ht(w, Y, J, 1)), this.listen(nt, Component.compEventCode(), ht(w, ot, rt, -1)), this.listen(Z.getElement(), EV.DBLCLICK, () => this.toggle(J)), this.listen(nt.getElement(), EV.DBLCLICK, () => this.toggle(rt)), this.listen(Z.getElement().querySelector(".zoo_grabber"), EV.CLICK, () => this.toggle(J)), this.listen(nt.getElement().querySelector(".zoo_grabber"), EV.CLICK, () => this.toggle(rt)), this.listen(Y, EV.TRANSITIONEND, (it) => {
+      if (it.propertyName === "flex-basis" && it.target === Y) {
+        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(D, w) {
+    const U = new ZooyEventData(D, w), F = EVT.makeEvent(UiEventType.SPLIT, U);
+    return this.dispatchEvent(F);
+  }
+}
+const convertElToSplit = (O, D) => (O.classList.add("zoo_split", `zoo_split__${D.toLowerCase()}`), O), makeOuterNest = (O, D = []) => {
+  const w = document.createElement("div");
+  return w.setAttribute("id", randomId(7)), w.classList.add("zoo_nest", "zoo_nest__outer", ...D), w.style.flexBasis = O + "px", w;
+}, makeInnerNest = (O = []) => {
+  const D = document.createElement("div");
+  return D.setAttribute("id", randomId(7)), D.classList.add("zoo_nest", "zoo_nest__inner", ...O), D;
+}, makeDraggerEl = (O = [], D = []) => () => {
+  const w = document.createElement("div");
+  w.setAttribute("id", randomId(7)), w.classList.add("zoo_dragger", ...O);
+  const U = document.createElement("div");
+  return U.classList.add("zoo_grabber", ...D), w.appendChild(U), w;
+}, needsToScroll = (O) => {
+  const w = O.getBoundingClientRect().bottom;
+  return (U) => U.getBoundingClientRect().bottom > w;
+}, treeNodeSelect = (O) => (D) => {
+  const w = O.getElement().querySelector(".zv_tree_container"), U = needsToScroll(w), F = O.getElement().querySelectorAll(".tree-node");
+  let q;
+  [...F].forEach((W) => {
+    enableClass(W, "mdc-deprecated-list-item--activated", W.id === `tree-node_${D}`), W.id === `tree-node_${D}` && (q = W);
+  }), q && U(q) && q.scrollIntoView(!1);
+}, toggleTree = (O, D) => {
+  const w = D.getElement().querySelector(".children"), U = (
+    /**@type {boolean} */
+    O.isOn
+  ), F = D.getElement().querySelectorAll(".children"), q = D.getElement().querySelectorAll(".zoo__reveal_icon");
+  [...F].forEach((W) => enableClass(
+    W,
+    "zoo__tree-children__hidden",
+    W !== w && !U
+  )), [...q].forEach((W) => enableClass(
+    W,
+    "zoo__icon_rotated",
+    W !== w && !U
+  ));
+}, toggleTreeChildren = (O, D) => {
+  const w = D.trigger, U = w.getAttribute("data-child-id"), F = O.getElement().querySelector(`#${U}`);
+  toggleClass(F, "zoo__tree-children__hidden"), toggleClass(w, "zoo__icon_rotated");
+}, _openTreeFromNodeUp = (O, D) => {
+  const w = D.parentElement;
+  w.classList.contains("children") && (enableClass(w, "zoo__tree-children__hidden", !1), _openTreeFromNodeUp(O, w));
+}, 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, D) {
+    toggleTree(O, D);
+  },
+  /**
+   * 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, D) {
+    toggleTreeChildren(D, 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, D) {
+    let w = `${O.href}`;
+    const U = O.formData.q, F = O.targetval;
+    if (U !== "" && (w = `${w}?q=${U}`), F !== "") {
+      let q = F;
+      F.includes("page=") && (q = F.split("&").filter((W) => !W.includes("page=")).join("&")), w = U !== "" ? `${w}&${q}` : `${w}?${q}`;
+    }
+    this.user.fetchAndSplit(w, D.abortController.signal).then(
+      (q) => D.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, D) {
+    const w = O.trigger.closest("form");
+    D.removeFromQParams("q"), w.elements.q.value = "", w.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, D) {
+    const w = `${O.href}?${O.targetval}`;
+    this.user.fetchAndSplit(w, D.abortController.signal).then(
+      (U) => D.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, D) {
+    const w = `${O.href}?${O.targetval}`;
+    this.user.fetchAndSplit(w, D.abortController.signal).then(
+      (U) => D.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(D) {
+    this.#e = D;
+  }
+  get recordHistory() {
+    return this.#e;
+  }
+  set registerViewConstructor(D) {
+    this.#t = D;
+  }
+  get registerViewConstructor() {
+    return this.#t;
+  }
+  set split(D) {
+    this.split_ = D, this.listen(this.split_, UiEventType.SPLIT, (w) => {
+      const U = w.detail.getValue(), F = w.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(D) {
+    this.user_ = D, this.panelMap.forEach((w) => w.user = D);
+  }
+  /**
+   * @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((D) => D.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(D, w) {
+    w.user = this.user, this.removePanelByName(D), this.panelMap.set(D, w), this.listen(w, 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(D) {
+    this.panelMap.has(D) && this.panelMap.get(D).dispose();
+  }
+  /**
+   * @param {Panel} panel
+   */
+  removePanel(D) {
+    const [w, U] = [...this.panelMap.entries()].find(([F, q]) => q === D);
+    w && U && (U.dispose(), this.panelMap.delete(w));
+  }
+  /**
+   * @param {string} name
+   * @return {Panel|undefined}
+   */
+  getPanelByName(D) {
+    return this.panelMap.get(D);
+  }
+  /**
+   * 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(D) {
+    [...this.panelMap.values()].forEach((w) => w.onViewDataBroadcast(D));
+  }
+  /**
+   * 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 D = /* @__PURE__ */ new Map();
+    return D.set("destroy_me", (w, U) => {
+      this.removePanel(U);
+    }), D.set("switch_view", (w, U) => {
+      this.debugMe("switch_view received: eventData", w);
+      const F = w.view;
+      this.switchViewMap_.has(F) ? this.switchViewMap_.get(F)(w, U) : this.debugMe("NO VIEW FOUND FOR:", F, this.switchViewMap_);
+    }), Object.entries({
+      ...SearchHandlers,
+      ...QueryParamHandlers
+    }).forEach(([w, U]) => {
+      D.set(w, U.bind(this));
+    }), D;
+  }
+  /**
+   * 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(D, w) {
+    this.panelEventMap_.set(D, w);
+  }
+  /**
+   * 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(D, w) {
+    this.switchViewMap_.set(D, w);
+  }
+  /**
+   * @param {!CustomEvent} e
+   */
+  onPanelEvent(D) {
+    const w = D.detail.getValue(), U = D.detail.getData(), F = (
+      /** @type {Panel} */
+      D.target
+    );
+    this.panelEventMap_.has(w) ? this.panelEventMap_.get(w)(U, F) : this.debugMe(`NO EVENT MATCH
+          oPe: ${D}
+          eventValue: ${w}
+          eventData: ${JSON.stringify(U, void 0, 2)}
+          ePanel: ${F.constructor.name}`);
+  }
+  //--[ Split Events ]--
+  /**
+   * Triggered before a split will open.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitWillOpen(D) {
+  }
+  /**
+   * Triggered before a split will close.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitWillClose(D) {
+  }
+  /**
+   * Triggered after a split closed.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitDidClose(D) {
+  }
+  /**
+   * Triggered after a split opened.
+   *
+   * @param {{nestName: !string, nestEl:!HTMLElement}} _data
+   */
+  onSplitDidOpen(D) {
+  }
+  //--[ 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(D, w) {
+    const U = new ZooyEventData(D, w), 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(D, w) {
+    return this.metaData_.set(D, w), this.metaData;
+  }
+  /**
+   * Retrieves a metadata value by key.
+   * @param {string} k The metadata key
+   * @return {*} The metadata value, or undefined if not found
+   */
+  getMetaData(D) {
+    return this.metaData_.get(D);
+  }
+  /**
+   * Checks if a metadata key exists.
+   * @param {string} k The metadata key
+   * @return {boolean} True if the key exists, false otherwise
+   */
+  hasMetaData(D) {
+    return this.metaData_.has(D);
+  }
+}
+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", (D) => {
+      D.state !== null && this.navTo(D.state);
+    });
+  }
+  set split(D) {
+    this.#r = D;
+  }
+  get split() {
+    if (!this.#r)
+      throw new Error("No SPLIT component available");
+    return this.#r;
+  }
+  /**
+   * @param {!UserManager} user
+   */
+  set user(D) {
+    this.#s = D, 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", (D, w) => {
+      if (this.#t.has(D.view)) {
+        const U = this.#t.get(D.view)(
+          D.pk || D.recordId,
+          D
+        );
+        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(D, w) {
+    this.#n.set(D, w);
+  }
+  /**
+   * 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(D, w) {
+    this.#t.set(D, w);
+  }
+  /**
+   * @param {!CustomEvent} e Event object.
+   */
+  onViewEvent(D) {
+    const w = D.detail.getValue(), U = D.detail.getData(), F = (
+      /** @type {Panel} */
+      D.target
+    );
+    this.#n.has(w) ? this.#n.get(w)(U, F) : console.warn("Unhandled VIEW Event:", D, w, U, F);
+  }
+  /**
+   * Make the given view active.
+   * @param {!View} view
+   */
+  setActiveView(D) {
+    this.#e && (this.stopListeningTo(this.#e), this.#e.dispose(), this.#e = null), this.#e = D, this.#e.render();
+  }
+  /**
+   * @param {!View} view
+   * @returns {!View}
+   */
+  initView(D) {
+    return D.user = this.user, D.split = this.split, D.recordHistory = this.recordHistory.bind(this), D.registerViewConstructor = this.registerViewConstructor.bind(this), this.listen(D, View.viewEventCode(), this.onViewEvent.bind(this)), D;
+  }
+  //--[ Views Utilities ]--
+  /**
+   * @param {!View} view The view we want active.
+   */
+  switchView(D) {
+    this.setActiveView(this.initView(D));
+  }
+  //--[ 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(D) {
+    this.debugMe("HISTORY", D), D.init ? history.replaceState(D, "", document.location.href) : D.history || history.pushState(D, "", 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 = (D) => {
+    D.history = !0;
+    const w = D.view, U = this.#e;
+    if (U.switchViewMap_.has(w))
+      this.debugMe("NAV:VIEW:MAP", D), U.switchViewMap_.get(w)(D);
+    else if (this.#t.has(w)) {
+      const F = this.#t.get(w)(D.pk, D);
+      this.debugMe("NAV:NEW:VIEW", D), this.switchView(F);
+    }
+  };
+}
+const DEFAULT_FORMATTERS = {
+  /**
+   * Format as JSON (useful for debugging)
+   */
+  json: (O) => JSON.stringify(O, null, 2)
+};
+class DataBinder {
+  #t;
+  #e;
+  #s;
+  #r = [];
+  #n;
+  #i;
+  #o;
+  /**
+   * Creates a new DataBinder instance.
+   *
+   * @param {Object} options - Configuration options
+   * @param {string} [options.url] - API endpoint URL (optional if using setData)
+   * @param {string|HTMLTemplateElement} options.template - Template ID or element
+   * @param {Element} options.container - Container element for rendered items
+   * @param {string} [options.dataPath] - JSON path to data array (auto-detected if omitted)
+   * @param {Function} [options.fetchFn] - Custom fetch function (for authentication, etc.)
+   * @param {Object<string, Function>} [options.formatters] - Custom formatters
+   * @throws {Error} If template or container is missing/invalid
+   */
+  constructor(D = {}) {
+    if (!D.template)
+      throw new Error("DataBinder requires options.template");
+    if (!D.container)
+      throw new Error("DataBinder requires options.container");
+    if (this.#t = D.url, this.#i = D.dataPath, this.#s = D.container, this.#o = D.fetchFn || fetch.bind(window), this.#e = typeof D.template == "string" ? document.getElementById(D.template) : D.template, !this.#e || this.#e.tagName !== "TEMPLATE")
+      throw new Error("DataBinder template must be a <template> element or valid template ID");
+    this.#n = { ...DEFAULT_FORMATTERS, ...D.formatters };
+  }
+  /**
+   * Loads data from the configured URL with optional query parameters.
+   * Dispatches 'data-loading', 'data-loaded', and 'data-error' events.
+   *
+   * @param {Object} [params={}] - Query parameters to append to URL
+   * @return {Promise<Array>} The loaded data array
+   * @throws {Error} If fetch fails or URL is not configured
+   */
+  async load(D = {}) {
+    if (!this.#t)
+      throw new Error("DataBinder.load() requires a configured URL");
+    this.#c("data-loading");
+    try {
+      const w = new URL(this.#t, window.location.origin);
+      Object.entries(D).forEach(([q, W]) => {
+        isDefAndNotNull(W) && w.searchParams.set(q, W);
+      });
+      const U = await this.#o(w.toString()), F = U instanceof Response ? U.ok ? await U.json() : Promise.reject(new Error(`HTTP ${U.status}: ${U.statusText}`)) : U;
+      if (this.#r = this.#u(F), !Array.isArray(this.#r))
+        throw new Error("Extracted data is not an array");
+      return this.render(), this.#c("data-loaded", { data: this.#r }), this.#r;
+    } catch (w) {
+      throw this.#c("data-error", { error: w }), w;
+    }
+  }
+  /**
+   * Sets data directly without fetching from URL.
+   * Useful for static data or when data is already available.
+   *
+   * @param {Array} data - Array of data objects
+   */
+  setData(D) {
+    this.#r = Array.isArray(D) ? D : [], this.render();
+  }
+  /**
+   * Gets the current data array.
+   *
+   * @return {Array} The current data
+   */
+  getData() {
+    return this.#r;
+  }
+  /**
+   * Re-renders all items from the current data.
+   * Clears the container and renders each item using the template.
+   */
+  render() {
+    this.#s.innerHTML = "", this.#r.forEach((D, w) => {
+      const U = this.#a(D, w);
+      this.#s.appendChild(U);
+    });
+  }
+  /**
+   * Disposes of this DataBinder instance.
+   * Clears data and container.
+   */
+  dispose() {
+    this.#r = [], this.#s.innerHTML = "", this.#e = null, this.#s = null;
+  }
+  /**
+   * Renders a single item from the template.
+   *
+   * @param {Object} item - Data object
+   * @param {number} index - Item index in array
+   * @return {DocumentFragment} Rendered template clone
+   * @private
+   */
+  #a(D, w) {
+    const U = this.#e.content.cloneNode(!0);
+    return this.#d(U, D, w), U.querySelectorAll("[data-bind]").forEach((F) => {
+      this.#h(F, D, w);
+    }), U.querySelectorAll("[data-show-if]").forEach((F) => {
+      const q = F.getAttribute("data-show-if");
+      this.#l(D, q, w) || F.remove();
+    }), U.querySelectorAll("[data-hide-if]").forEach((F) => {
+      const q = F.getAttribute("data-hide-if");
+      this.#l(D, q, w) && F.remove();
+    }), U.querySelectorAll("[data-bind]").forEach((F) => {
+      F.removeAttribute("data-bind"), F.removeAttribute("data-format");
+    }), U.querySelectorAll("[data-bind-attr]").forEach((F) => {
+      F.removeAttribute("data-bind-attr");
+    }), U.querySelectorAll("[data-show-if]").forEach((F) => {
+      F.removeAttribute("data-show-if");
+    }), U.querySelectorAll("[data-hide-if]").forEach((F) => {
+      F.removeAttribute("data-hide-if");
+    }), U;
+  }
+  /**
+   * Binds data to element content.
+   *
+   * @param {Element} el - Element to bind to
+   * @param {Object} item - Data object
+   * @param {number} index - Item index
+   * @private
+   */
+  #h(D, w, U) {
+    const F = D.getAttribute("data-bind"), q = D.getAttribute("data-format");
+    let W = this.#l(w, F, U);
+    q && this.#n[q] && (W = this.#n[q](W, w)), D.textContent = W ?? "";
+  }
+  /**
+   * Binds data to element attributes.
+   * Supports syntax: data-bind-attr="attr1:path1, attr2:path2"
+   *
+   * @param {DocumentFragment} clone - Template clone
+   * @param {Object} item - Data object
+   * @param {number} index - Item index
+   * @private
+   */
+  #d(D, w, U) {
+    D.querySelectorAll("[data-bind-attr]").forEach((F) => {
+      F.getAttribute("data-bind-attr").split(",").forEach((W) => {
+        const [X, G] = W.split(":").map((K) => K.trim());
+        if (X && G) {
+          const K = this.#l(w, G, U);
+          isDefAndNotNull(K) && F.setAttribute(X, K);
+        }
+      });
+    });
+  }
+  /**
+   * Gets a value from an object using dot notation.
+   * Supports special variables: $index (0-based), $index1 (1-based)
+   *
+   * @param {Object} obj - Object to query
+   * @param {string} path - Dot-separated path (e.g., "profile.name")
+   * @param {number} index - Item index for special variables
+   * @return {*} The value, or undefined if not found
+   * @private
+   */
+  #l(D, w, U) {
+    return w === "$index" ? U : w === "$index1" ? U + 1 : w.split(".").reduce((F, q) => F?.[q], D);
+  }
+  /**
+   * Extracts the data array from a JSON response.
+   * Tries common patterns: json.rows, json.data, json.items, or json itself.
+   *
+   * @param {Object|Array} json - JSON response
+   * @return {Array} Extracted data array
+   * @private
+   */
+  #u(D) {
+    return this.#i ? this.#i.split(".").reduce((w, U) => w?.[U], D) : D.rows ? D.rows : D.data ? D.data : D.items ? D.items : Array.isArray(D) ? D : (console.warn("DataBinder: Could not extract data array from response", D), []);
+  }
+  /**
+   * Dispatches a custom event on the container.
+   *
+   * @param {string} eventName - Event name
+   * @param {Object} [detail={}] - Event detail
+   * @private
+   */
+  #c(D, w = {}) {
+    this.#s.dispatchEvent(new CustomEvent(D, {
+      detail: w,
+      bubbles: !0
+    }));
+  }
+}
+const SEMANTIC_ATTRIBUTES = [
+  // Event attributes
+  "event",
+  "change-event",
+  "open-event",
+  "close-event",
+  "primary-event",
+  // Data/Record identification
+  "record-id",
+  "record-type",
+  // URLs/Endpoints
+  "endpoint",
+  "url",
+  // Actions/Operations
+  "action",
+  "method",
+  // Targeting
+  "target"
+], ATTRIBUTE_TO_PROPERTY = {
+  event: "event",
+  "change-event": "changeEvent",
+  "open-event": "openEvent",
+  "close-event": "closeEvent",
+  "primary-event": "primaryEvent",
+  "record-id": "recordId",
+  "record-type": "recordType",
+  endpoint: "endpoint",
+  url: "url",
+  action: "action",
+  method: "method",
+  target: "target"
+}, getSemanticAttributes = (O) => {
+  const D = {};
+  return SEMANTIC_ATTRIBUTES.forEach((w) => {
+    const U = O.getAttribute(w);
+    if (U !== null) {
+      const F = ATTRIBUTE_TO_PROPERTY[w];
+      D[F] = U;
+    }
+  }), Array.from(O.attributes).forEach((w) => {
+    if (w.name.startsWith("data-")) {
+      const U = w.name.slice(5).replace(/-([a-z])/g, (F, q) => q.toUpperCase());
+      D[U] = w.value;
+    }
+  }), D;
+}, getEventName = (O) => O.getAttribute("event"), getEventAttribute = (O, D, w = "event") => O.getAttribute(D) || O.getAttribute(w);
+/**
+ * @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(D, w, U) {
+    if (this._$cssResult$ = !0, U !== s$2) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = D, this.t = w;
+  }
+  get styleSheet() {
+    let D = this.o;
+    const w = this.t;
+    if (e$2 && D === void 0) {
+      const U = w !== void 0 && w.length === 1;
+      U && (D = o$3.get(w)), D === void 0 && ((this.o = D = new CSSStyleSheet()).replaceSync(this.cssText), U && o$3.set(w, D));
+    }
+    return D;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+const r$2 = (O) => new n$2(typeof O == "string" ? O : O + "", void 0, s$2), i$3 = (O, ...D) => {
+  const w = O.length === 1 ? O[0] : D.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(w, O, s$2);
+}, S$1 = (O, D) => {
+  if (e$2) O.adoptedStyleSheets = D.map(((w) => w instanceof CSSStyleSheet ? w : w.styleSheet));
+  else for (const w of D) {
+    const U = document.createElement("style"), F = t$1.litNonce;
+    F !== void 0 && U.setAttribute("nonce", F), U.textContent = w.cssText, O.appendChild(U);
+  }
+}, c$2 = e$2 ? (O) => O : (O) => O instanceof CSSStyleSheet ? ((D) => {
+  let w = "";
+  for (const U of D.cssRules) w += U.cssText;
+  return r$2(w);
+})(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, D) => O, u$1 = { toAttribute(O, D) {
+  switch (D) {
+    case Boolean:
+      O = O ? l$1 : null;
+      break;
+    case Object:
+    case Array:
+      O = O == null ? O : JSON.stringify(O);
+  }
+  return O;
+}, fromAttribute(O, D) {
+  let w = O;
+  switch (D) {
+    case Boolean:
+      w = O !== null;
+      break;
+    case Number:
+      w = O === null ? null : Number(O);
+      break;
+    case Object:
+    case Array:
+      try {
+        w = JSON.parse(O);
+      } catch {
+        w = null;
+      }
+  }
+  return w;
+} }, f$1 = (O, D) => !i$2(O, D), 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(D) {
+    this._$Ei(), (this.l ??= []).push(D);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(D, w = b$1) {
+    if (w.state && (w.attribute = !1), this._$Ei(), this.prototype.hasOwnProperty(D) && ((w = Object.create(w)).wrapped = !0), this.elementProperties.set(D, w), !w.noAccessor) {
+      const U = Symbol(), F = this.getPropertyDescriptor(D, U, w);
+      F !== void 0 && e$1(this.prototype, D, F);
+    }
+  }
+  static getPropertyDescriptor(D, w, U) {
+    const { get: F, set: q } = h$1(this.prototype, D) ?? { get() {
+      return this[w];
+    }, set(W) {
+      this[w] = W;
+    } };
+    return { get: F, set(W) {
+      const X = F?.call(this);
+      q?.call(this, W), this.requestUpdate(D, X, U);
+    }, configurable: !0, enumerable: !0 };
+  }
+  static getPropertyOptions(D) {
+    return this.elementProperties.get(D) ?? b$1;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(d$1("elementProperties"))) return;
+    const D = n$1(this);
+    D.finalize(), D.l !== void 0 && (this.l = [...D.l]), this.elementProperties = new Map(D.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(d$1("finalized"))) return;
+    if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(d$1("properties"))) {
+      const w = this.properties, U = [...r$1(w), ...o$2(w)];
+      for (const F of U) this.createProperty(F, w[F]);
+    }
+    const D = this[Symbol.metadata];
+    if (D !== null) {
+      const w = litPropertyMetadata.get(D);
+      if (w !== void 0) for (const [U, F] of w) this.elementProperties.set(U, F);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [w, U] of this.elementProperties) {
+      const F = this._$Eu(w, U);
+      F !== void 0 && this._$Eh.set(F, w);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(D) {
+    const w = [];
+    if (Array.isArray(D)) {
+      const U = new Set(D.flat(1 / 0).reverse());
+      for (const F of U) w.unshift(c$2(F));
+    } else D !== void 0 && w.push(c$2(D));
+    return w;
+  }
+  static _$Eu(D, w) {
+    const U = w.attribute;
+    return U === !1 ? void 0 : typeof U == "string" ? U : typeof D == "string" ? D.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(((D) => this.enableUpdating = D)), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach(((D) => D(this)));
+  }
+  addController(D) {
+    (this._$EO ??= /* @__PURE__ */ new Set()).add(D), this.renderRoot !== void 0 && this.isConnected && D.hostConnected?.();
+  }
+  removeController(D) {
+    this._$EO?.delete(D);
+  }
+  _$E_() {
+    const D = /* @__PURE__ */ new Map(), w = this.constructor.elementProperties;
+    for (const U of w.keys()) this.hasOwnProperty(U) && (D.set(U, this[U]), delete this[U]);
+    D.size > 0 && (this._$Ep = D);
+  }
+  createRenderRoot() {
+    const D = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return S$1(D, this.constructor.elementStyles), D;
+  }
+  connectedCallback() {
+    this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(!0), this._$EO?.forEach(((D) => D.hostConnected?.()));
+  }
+  enableUpdating(D) {
+  }
+  disconnectedCallback() {
+    this._$EO?.forEach(((D) => D.hostDisconnected?.()));
+  }
+  attributeChangedCallback(D, w, U) {
+    this._$AK(D, U);
+  }
+  _$ET(D, w) {
+    const U = this.constructor.elementProperties.get(D), F = this.constructor._$Eu(D, U);
+    if (F !== void 0 && U.reflect === !0) {
+      const q = (U.converter?.toAttribute !== void 0 ? U.converter : u$1).toAttribute(w, U.type);
+      this._$Em = D, q == null ? this.removeAttribute(F) : this.setAttribute(F, q), this._$Em = null;
+    }
+  }
+  _$AK(D, w) {
+    const U = this.constructor, F = U._$Eh.get(D);
+    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 X = W.fromAttribute(w, q.type);
+      this[F] = X ?? this._$Ej?.get(F) ?? X, this._$Em = null;
+    }
+  }
+  requestUpdate(D, w, U) {
+    if (D !== void 0) {
+      const F = this.constructor, q = this[D];
+      if (U ??= F.getPropertyOptions(D), !((U.hasChanged ?? f$1)(q, w) || U.useDefault && U.reflect && q === this._$Ej?.get(D) && !this.hasAttribute(F._$Eu(D, U)))) return;
+      this.C(D, w, U);
+    }
+    this.isUpdatePending === !1 && (this._$ES = this._$EP());
+  }
+  C(D, w, { useDefault: U, reflect: F, wrapped: q }, W) {
+    U && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(D) && (this._$Ej.set(D, W ?? w ?? this[D]), q !== !0 || W !== void 0) || (this._$AL.has(D) || (this.hasUpdated || U || (w = void 0), this._$AL.set(D, w)), F === !0 && this._$Em !== D && (this._$Eq ??= /* @__PURE__ */ new Set()).add(D));
+  }
+  async _$EP() {
+    this.isUpdatePending = !0;
+    try {
+      await this._$ES;
+    } catch (w) {
+      Promise.reject(w);
+    }
+    const D = this.scheduleUpdate();
+    return D != null && await D, !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, X = this[F];
+        W !== !0 || this._$AL.has(F) || X === void 0 || this.C(F, void 0, q, X);
+      }
+    }
+    let D = !1;
+    const w = this._$AL;
+    try {
+      D = this.shouldUpdate(w), D ? (this.willUpdate(w), this._$EO?.forEach(((U) => U.hostUpdate?.())), this.update(w)) : this._$EM();
+    } catch (U) {
+      throw D = !1, this._$EM(), U;
+    }
+    D && this._$AE(w);
+  }
+  willUpdate(D) {
+  }
+  _$AE(D) {
+    this._$EO?.forEach(((w) => w.hostUpdated?.())), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(D)), this.updated(D);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = !1;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(D) {
+    return !0;
+  }
+  update(D) {
+    this._$Eq &&= this._$Eq.forEach(((w) => this._$ET(w, this[w]))), this._$EM();
+  }
+  updated(D) {
+  }
+  firstUpdated(D) {
+  }
+};
+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) => (D, ...w) => ({ _$litType$: O, strings: D, values: w }), 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, D) {
+  if (!a(O) || !O.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return s$1 !== void 0 ? s$1.createHTML(D) : D;
+}
+const V = (O, D) => {
+  const w = O.length - 1, U = [];
+  let F, q = D === 2 ? "<svg>" : D === 3 ? "<math>" : "", W = f;
+  for (let X = 0; X < w; X++) {
+    const G = O[X];
+    let K, 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, K = 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 Y = W === m && O[X + 1].startsWith("/>") ? " " : "";
+    q += W === f ? G + n : tt >= 0 ? (U.push(K), G.slice(0, tt) + e + G.slice(tt) + h + Y) : G + h + (tt === -2 ? X : Y);
+  }
+  return [P(O, q + (O[w] || "<?>") + (D === 2 ? "</svg>" : D === 3 ? "</math>" : "")), U];
+};
+class N {
+  constructor({ strings: D, _$litType$: w }, U) {
+    let F;
+    this.parts = [];
+    let q = 0, W = 0;
+    const X = D.length - 1, G = this.parts, [K, Q] = V(D, w);
+    if (this.el = N.createElement(K, U), C.currentNode = this.el.content, w === 2 || w === 3) {
+      const tt = this.el.content.firstChild;
+      tt.replaceWith(...tt.childNodes);
+    }
+    for (; (F = C.nextNode()) !== null && G.length < X; ) {
+      if (F.nodeType === 1) {
+        if (F.hasAttributes()) for (const tt of F.getAttributeNames()) if (tt.endsWith(e)) {
+          const J = Q[W++], Y = F.getAttribute(tt).split(h), Z = /([.?@])?(.*)/.exec(J);
+          G.push({ type: 1, index: q, name: Z[2], strings: Y, ctor: Z[1] === "." ? H : Z[1] === "?" ? I : Z[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 Y = 0; Y < J; Y++) F.append(tt[Y], 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(D, w) {
+    const U = r.createElement("template");
+    return U.innerHTML = D, U;
+  }
+}
+function S(O, D, w = O, U) {
+  if (D === T) return D;
+  let F = U !== void 0 ? w._$Co?.[U] : w._$Cl;
+  const q = c(D) ? void 0 : D._$litDirective$;
+  return F?.constructor !== q && (F?._$AO?.(!1), q === void 0 ? F = void 0 : (F = new q(O), F._$AT(O, w, U)), U !== void 0 ? (w._$Co ??= [])[U] = F : w._$Cl = F), F !== void 0 && (D = S(O, F._$AS(O, D.values), F, U)), D;
+}
+class M {
+  constructor(D, w) {
+    this._$AV = [], this._$AN = void 0, this._$AD = D, this._$AM = w;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(D) {
+    const { el: { content: w }, parts: U } = this._$AD, F = (D?.creationScope ?? r).importNode(w, !0);
+    C.currentNode = F;
+    let q = C.nextNode(), W = 0, X = 0, G = U[0];
+    for (; G !== void 0; ) {
+      if (W === G.index) {
+        let K;
+        G.type === 2 ? K = new R(q, q.nextSibling, this, D) : G.type === 1 ? K = new G.ctor(q, G.name, G.strings, this, D) : G.type === 6 && (K = new z(q, this, D)), this._$AV.push(K), G = U[++X];
+      }
+      W !== G?.index && (q = C.nextNode(), W++);
+    }
+    return C.currentNode = r, F;
+  }
+  p(D) {
+    let w = 0;
+    for (const U of this._$AV) U !== void 0 && (U.strings !== void 0 ? (U._$AI(D, U, w), w += U.strings.length - 2) : U._$AI(D[w])), w++;
+  }
+}
+class R {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(D, w, U, F) {
+    this.type = 2, this._$AH = E, this._$AN = void 0, this._$AA = D, this._$AB = w, this._$AM = U, this.options = F, this._$Cv = F?.isConnected ?? !0;
+  }
+  get parentNode() {
+    let D = this._$AA.parentNode;
+    const w = this._$AM;
+    return w !== void 0 && D?.nodeType === 11 && (D = w.parentNode), D;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(D, w = this) {
+    D = S(this, D, w), c(D) ? D === E || D == null || D === "" ? (this._$AH !== E && this._$AR(), this._$AH = E) : D !== this._$AH && D !== T && this._(D) : D._$litType$ !== void 0 ? this.$(D) : D.nodeType !== void 0 ? this.T(D) : u(D) ? this.k(D) : this._(D);
+  }
+  O(D) {
+    return this._$AA.parentNode.insertBefore(D, this._$AB);
+  }
+  T(D) {
+    this._$AH !== D && (this._$AR(), this._$AH = this.O(D));
+  }
+  _(D) {
+    this._$AH !== E && c(this._$AH) ? this._$AA.nextSibling.data = D : this.T(r.createTextNode(D)), this._$AH = D;
+  }
+  $(D) {
+    const { values: w, _$litType$: U } = D, F = typeof U == "number" ? this._$AC(D) : (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(w);
+    else {
+      const q = new M(F, this), W = q.u(this.options);
+      q.p(w), this.T(W), this._$AH = q;
+    }
+  }
+  _$AC(D) {
+    let w = A.get(D.strings);
+    return w === void 0 && A.set(D.strings, w = new N(D)), w;
+  }
+  k(D) {
+    a(this._$AH) || (this._$AH = [], this._$AR());
+    const w = this._$AH;
+    let U, F = 0;
+    for (const q of D) F === w.length ? w.push(U = new R(this.O(l()), this.O(l()), this, this.options)) : U = w[F], U._$AI(q), F++;
+    F < w.length && (this._$AR(U && U._$AB.nextSibling, F), w.length = F);
+  }
+  _$AR(D = this._$AA.nextSibling, w) {
+    for (this._$AP?.(!1, !0, w); D !== this._$AB; ) {
+      const U = D.nextSibling;
+      D.remove(), D = U;
+    }
+  }
+  setConnected(D) {
+    this._$AM === void 0 && (this._$Cv = D, this._$AP?.(D));
+  }
+}
+class k {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(D, w, U, F, q) {
+    this.type = 1, this._$AH = E, this._$AN = void 0, this.element = D, this.name = w, 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(D, w = this, U, F) {
+    const q = this.strings;
+    let W = !1;
+    if (q === void 0) D = S(this, D, w, 0), W = !c(D) || D !== this._$AH && D !== T, W && (this._$AH = D);
+    else {
+      const X = D;
+      let G, K;
+      for (D = q[0], G = 0; G < q.length - 1; G++) K = S(this, X[U + G], w, G), K === T && (K = this._$AH[G]), W ||= !c(K) || K !== this._$AH[G], K === E ? D = E : D !== E && (D += (K ?? "") + q[G + 1]), this._$AH[G] = K;
+    }
+    W && !F && this.j(D);
+  }
+  j(D) {
+    D === E ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, D ?? "");
+  }
+}
+class H extends k {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(D) {
+    this.element[this.name] = D === E ? void 0 : D;
+  }
+}
+class I extends k {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(D) {
+    this.element.toggleAttribute(this.name, !!D && D !== E);
+  }
+}
+class L extends k {
+  constructor(D, w, U, F, q) {
+    super(D, w, U, F, q), this.type = 5;
+  }
+  _$AI(D, w = this) {
+    if ((D = S(this, D, w, 0) ?? E) === T) return;
+    const U = this._$AH, F = D === E && U !== E || D.capture !== U.capture || D.once !== U.once || D.passive !== U.passive, q = D !== E && (U === E || F);
+    F && this.element.removeEventListener(this.name, this, U), q && this.element.addEventListener(this.name, this, D), this._$AH = D;
+  }
+  handleEvent(D) {
+    typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, D) : this._$AH.handleEvent(D);
+  }
+}
+class z {
+  constructor(D, w, U) {
+    this.element = D, this.type = 6, this._$AN = void 0, this._$AM = w, this.options = U;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(D) {
+    S(this, D);
+  }
+}
+const j = t.litHtmlPolyfillSupport;
+j?.(N, R), (t.litHtmlVersions ??= []).push("3.3.1");
+const B = (O, D, w) => {
+  const U = w?.renderBefore ?? D;
+  let F = U._$litPart$;
+  if (F === void 0) {
+    const q = w?.renderBefore ?? null;
+    U._$litPart$ = F = new R(D.insertBefore(l(), q), q, void 0, w ?? {});
+  }
+  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 D = super.createRenderRoot();
+    return this.renderOptions.renderBefore ??= D.firstChild, D;
+  }
+  update(D) {
+    const w = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(D), this._$Do = B(w, 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 }
+  };
+  static styles = i$3`
+    :host {
+      display: inline-block;
+    }
+
+    .tag {
+      display: inline-flex;
+      align-items: center;
+      min-height: 1.5rem;
+      max-width: 100%;
+      min-width: 2rem;
+      padding: 0 0.5rem;
+      border-radius: 0.9375rem;
+      font-size: 0.75rem;
+      font-weight: 400;
+      line-height: 1.33333;
+      letter-spacing: 0.32px;
+      white-space: nowrap;
+      word-break: break-word;
+      box-sizing: border-box;
+    }
+  `;
+  render() {
+    const D = this.token ?? "default";
+    return x`
+      <span
+        class="tag"
+        style="
+          background-color: var(--zoo-tag-${D}-bg, var(--zoo-tag-default-bg, #9e9e9e));
+          color: var(--zoo-tag-${D}-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,
+  SEMANTIC_ATTRIBUTES,
+  ZooTag,
+  getEventAttribute,
+  getEventName,
+  getSemanticAttributes
+}, Symbol.toStringTag, { value: "Module" }));
+async function registerCarbonLibrary() {
+  const { registerCarbonLibrary: O } = await import("./register-ClkXTZwT.js");
+  return O();
+}
+async function registerMdcLibrary() {
+  const { registerMdcLibrary: O } = await import("./register-CHuMnx--.js");
+  return O();
+}
+const zooy = {
+  EVT,
+  Component,
+  Dragger,
+  Panel,
+  FormPanel,
+  Split,
+  UserManager,
+  View,
+  Conductor,
+  DataBinder,
+  UiEventType,
+  domUtils,
+  uriUtils,
+  registerCarbonLibrary,
+  registerMdcLibrary,
+  ComponentLibraryRegistry,
+  handlers,
+  zoo
+};
+export {
+  B,
+  ComponentLibraryRegistry as C,
+  DataBinder as D,
+  E,
+  FormPanel as F,
+  Panel as P,
+  Split as S,
+  T,
+  UserManager as U,
+  View as V,
+  i$3 as a,
+  b,
+  getEventAttribute as c,
+  getElDataMap as d,
+  isDefAndNotNull as e,
+  f$1 as f,
+  getSemanticAttributes as g,
+  treeUtils as h,
+  i,
+  registerMdcLibrary as j,
+  EVT as k,
+  Component as l,
+  Dragger as m,
+  UiEventType as n,
+  Conductor as o,
+  domUtils as p,
+  uriUtils as q,
+  registerCarbonLibrary as r,
+  handlers as s,
+  toLowerCase as t,
+  u$1 as u,
+  zoo as v,
+  x,
+  zooy as z
+};