@epam/ai-dial-ui-kit 0.14.0-dev.9 → 0.14.1

package/dist/node_modules/ag-grid-react/dist/package/index.esm.js

@@ -0,0 +1,1989 @@
+import a, { Component as ut, useContext as ee, useRef as o, useState as c, useCallback as U, useMemo as E, useEffect as ce, useLayoutEffect as fe, memo as ne, forwardRef as Ue, useImperativeHandle as He, createElement as dt, createContext as pt, Suspense as ht } from "react";
+import { _findEnterpriseCoreModule as mt, _combineAttributesAndGridOptions as ft, GridCoreCreator as Ct, _processOnChange as gt, _getGridOption as De, VanillaFrameworkOverrides as yt, BaseComponentWrapper as vt, BeanStub as wt, _warn as Ve, _getGridRegisteredModules as bt, _observeResize as Ye, _toString as Rt, AgPromise as de, GridCtrl as Pt, _isClientSideRowModel as St, _isServerSideRowModel as Ft, CssClassManager as Ie, GridBodyCtrl as Et, TabGuardCtrl as kt, _setAriaRowCount as Mt, _setAriaColCount as Gt, FakeHScrollComp as At, FakeVScrollComp as Dt, TabGuardClassNames as We, GridHeaderCtrl as Bt, HeaderRowContainerCtrl as xt, _getRowContainerOptions as It, _getRowViewportClass as Ot, _getRowContainerClass as Wt, _getRowSpanContainerClass as Tt, RowContainerCtrl as Nt, _EmptyBean as Se, _setAriaSort as Ut, _removeAriaSort as Ht, _removeFromParent as ze, _getActiveDomElement as Vt } from "../../../ag-grid-community/dist/package/main.esm.js";
+import _t, { createPortal as Ze } from "react-dom";
+var re = a.createContext({}), Xe = a.createContext("default"), Me = (e, t, r, s) => {
+  if (!e || e.componentFromFramework || t.isDestroyed())
+    return;
+  const d = e.newAgStackInstance();
+  let i, u, l = !1;
+  return d.then((m) => {
+    if (l) {
+      t.destroyBean(m);
+      return;
+    }
+    i = m, u = i.getGui(), r.appendChild(u), je(s, i);
+  }), () => {
+    l = !0, i && (u?.remove(), t.destroyBean(i), s && je(s, void 0));
+  };
+}, je = (e, t) => {
+  if (e)
+    if (e instanceof Function)
+      e(t);
+    else {
+      const r = e;
+      r.current = t;
+    }
+}, le = (...e) => e.filter((r) => r != null && r !== "").join(" "), ue = class et {
+  constructor(...t) {
+    this.classesMap = {};
+    for (const r of t)
+      this.classesMap[r] = !0;
+  }
+  setClass(t, r) {
+    if (!!this.classesMap[t] == r)
+      return this;
+    const n = new et();
+    return n.classesMap = { ...this.classesMap }, n.classesMap[t] = r, n;
+  }
+  toString() {
+    return Object.keys(this.classesMap).filter((r) => this.classesMap[r]).join(" ");
+  }
+}, Fe = (e) => {
+  const t = () => typeof Symbol == "function" && Symbol.for, r = () => t() ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
+  return typeof e == "function" && !(e.prototype && e.prototype.isReactComponent) || typeof e == "object" && e.$$typeof === r();
+}, Ne = a.version?.split(".")[0], tt = Ne === "16" || Ne === "17";
+function Lt() {
+  return Ne === "19";
+}
+var Be = !1;
+function zt(e) {
+  return Be || setTimeout(() => Be = !1, 0), Be = !0, e();
+}
+var ke = (e, t) => {
+  !tt && e && !Be ? _t.flushSync(t) : t();
+}, jt = (e) => {
+  tt ? e() : a.startTransition(e);
+};
+function $t(e, t, r) {
+  return a.useSyncExternalStore ? a.useSyncExternalStore(e, t) : r;
+}
+function xe(e, t, r) {
+  if (t == null || e == null)
+    return t;
+  if (e === t || t.length === 0 && e.length === 0)
+    return e;
+  if (r || e.length === 0 && t.length > 0 || e.length > 0 && t.length === 0)
+    return t;
+  const s = [], n = [], d = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  for (let u = 0; u < t.length; u++) {
+    const l = t[u];
+    i.set(l.instanceId, l);
+  }
+  for (let u = 0; u < e.length; u++) {
+    const l = e[u];
+    d.set(l.instanceId, l), i.has(l.instanceId) && s.push(l);
+  }
+  for (let u = 0; u < t.length; u++) {
+    const l = t[u], m = l.instanceId;
+    d.has(m) || n.push(l);
+  }
+  return s.length === e.length && n.length === 0 ? e : s.length === 0 && n.length === t.length ? t : s.length === 0 ? n : n.length === 0 ? s : [...s, ...n];
+}
+var rt = Ue((e, t) => {
+  const { registry: r, context: s } = ee(re), n = o(null), d = o(null), i = o(null), u = o(null), l = o(null), m = o(), [p, S] = c(), [b, y] = c(), [A, w] = c(), [v, h] = c(() => new ue()), [D, W] = c(() => new ue("ag-hidden")), [R, f] = c(() => new ue("ag-hidden")), [H, k] = c(() => new ue("ag-invisible"));
+  He(t, () => ({
+    // force new instance when grid tries to refresh
+    refresh() {
+      return !1;
+    }
+  })), fe(() => Me(p, s, d.current), [p]);
+  const V = U((L) => {
+    if (n.current = L, !L || s.isDestroyed()) {
+      m.current = s.destroyBean(m.current);
+      return;
+    }
+    const F = {
+      setInnerRenderer: (M, z) => {
+        S(M), w(z);
+      },
+      setChildCount: (M) => y(M),
+      toggleCss: (M, z) => h((G) => G.setClass(M, z)),
+      setContractedDisplayed: (M) => f((z) => z.setClass("ag-hidden", !M)),
+      setExpandedDisplayed: (M) => W((z) => z.setClass("ag-hidden", !M)),
+      setCheckboxVisible: (M) => k((z) => z.setClass("ag-invisible", !M)),
+      setCheckboxSpacing: (M) => k((z) => z.setClass("ag-group-checkbox-spacing", M))
+    }, N = r.createDynamicBean("groupCellRendererCtrl", !0);
+    N && (m.current = s.createBean(N), m.current.init(
+      F,
+      L,
+      i.current,
+      u.current,
+      l.current,
+      rt,
+      e
+    ));
+  }, []), O = E(() => `ag-cell-wrapper ${v.toString()}`, [v]), _ = E(() => `ag-group-expanded ${D.toString()}`, [D]), C = E(
+    () => `ag-group-contracted ${R.toString()}`,
+    [R]
+  ), P = E(() => `ag-group-checkbox ${H.toString()}`, [H]), x = p?.componentFromFramework, q = x ? p.componentClass : void 0, g = p == null && A != null, T = Rt(A);
+  return /* @__PURE__ */ a.createElement(
+    "span",
+    {
+      className: O,
+      ref: V,
+      ...e.colDef ? {} : { role: m.current?.getCellAriaRole() }
+    },
+    /* @__PURE__ */ a.createElement("span", { className: _, ref: u }),
+    /* @__PURE__ */ a.createElement("span", { className: C, ref: l }),
+    /* @__PURE__ */ a.createElement("span", { className: P, ref: i }),
+    /* @__PURE__ */ a.createElement("span", { className: "ag-group-value", ref: d }, g ? T : x ? /* @__PURE__ */ a.createElement(q, { ...p.params }) : null),
+    /* @__PURE__ */ a.createElement("span", { className: "ag-group-child-count" }, b)
+  );
+}), $e = rt, _e = pt({
+  setMethods: () => {
+  }
+}), Kt = (e) => {
+  const { initialProps: t, addUpdateCallback: r, CustomComponentClass: s, setMethods: n } = e, [{ key: d, ...i }, u] = c(t);
+  return ce(() => {
+    r((l) => u(l));
+  }, []), /* @__PURE__ */ a.createElement(_e.Provider, { value: { setMethods: n } }, /* @__PURE__ */ a.createElement(s, { key: d, ...i }));
+}, Jt = ne(Kt), qt = 0;
+function Ke() {
+  return `agPortalKey_${++qt}`;
+}
+var st = class {
+  constructor(e, t, r, s) {
+    this.portal = null, this.oldPortal = null, this.reactComponent = e, this.portalManager = t, this.componentType = r, this.suppressFallbackMethods = !!s, this.statelessComponent = this.isStateless(this.reactComponent), this.key = Ke(), this.portalKey = Ke(), this.instanceCreated = this.isStatelessComponent() ? de.resolve(!1) : new de((n) => {
+      this.resolveInstanceCreated = n;
+    });
+  }
+  getGui() {
+    return this.eParentElement;
+  }
+  /** `getGui()` returns the parent element. This returns the actual root element. */
+  getRootElement() {
+    return this.eParentElement.firstChild;
+  }
+  destroy() {
+    this.componentInstance && typeof this.componentInstance.destroy == "function" && this.componentInstance.destroy();
+    const e = this.portal;
+    e && this.portalManager.destroyPortal(e);
+  }
+  createParentElement(e) {
+    const t = this.portalManager.getComponentWrappingElement(), r = document.createElement(t || "div");
+    return r.classList.add("ag-react-container"), e.reactContainer = r, r;
+  }
+  statelessComponentRendered() {
+    return this.eParentElement.childElementCount > 0 || this.eParentElement.childNodes.length > 0;
+  }
+  getFrameworkComponentInstance() {
+    return this.componentInstance;
+  }
+  isStatelessComponent() {
+    return this.statelessComponent;
+  }
+  getReactComponentName() {
+    return this.reactComponent.name;
+  }
+  getMemoType() {
+    return this.hasSymbol() ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
+  }
+  hasSymbol() {
+    return typeof Symbol == "function" && Symbol.for;
+  }
+  isStateless(e) {
+    return typeof e == "function" && !(e.prototype && e.prototype.isReactComponent) || typeof e == "object" && e.$$typeof === this.getMemoType();
+  }
+  hasMethod(e) {
+    const t = this.getFrameworkComponentInstance();
+    return !!t && t[e] != null || this.fallbackMethodAvailable(e);
+  }
+  callMethod(e, t) {
+    const r = this.getFrameworkComponentInstance();
+    if (this.isStatelessComponent())
+      return this.fallbackMethod(e, t && t[0] ? t[0] : {});
+    if (!r) {
+      setTimeout(() => this.callMethod(e, t));
+      return;
+    }
+    const s = r[e];
+    if (s)
+      return s.apply(r, t);
+    if (this.fallbackMethodAvailable(e))
+      return this.fallbackMethod(e, t && t[0] ? t[0] : {});
+  }
+  addMethod(e, t) {
+    this[e] = t;
+  }
+  init(e) {
+    return this.eParentElement = this.createParentElement(e), this.createOrUpdatePortal(e), new de((t) => this.createReactComponent(t));
+  }
+  createOrUpdatePortal(e) {
+    this.isStatelessComponent() || (this.ref = (t) => {
+      this.componentInstance = t, this.resolveInstanceCreated?.(!0), this.resolveInstanceCreated = void 0;
+    }, e.ref = this.ref), this.reactElement = this.createElement(this.reactComponent, { ...e, key: this.key }), this.portal = Ze(
+      this.reactElement,
+      this.eParentElement,
+      this.portalKey
+      // fixed deltaRowModeRefreshCompRenderer
+    );
+  }
+  createElement(e, t) {
+    return dt(e, t);
+  }
+  createReactComponent(e) {
+    this.portalManager.mountReactPortal(this.portal, this, e);
+  }
+  rendered() {
+    return this.isStatelessComponent() && this.statelessComponentRendered() || !!(!this.isStatelessComponent() && this.getFrameworkComponentInstance());
+  }
+  /*
+   * fallback methods - these will be invoked if a corresponding instance method is not present
+   * for example if refresh is called and is not available on the component instance, then refreshComponent on this
+   * class will be invoked instead
+   *
+   * Currently only refresh is supported
+   */
+  refreshComponent(e) {
+    this.oldPortal = this.portal, this.createOrUpdatePortal(e), this.portalManager.updateReactPortal(this.oldPortal, this.portal);
+  }
+  fallbackMethod(e, t) {
+    const r = this[`${e}Component`];
+    if (!this.suppressFallbackMethods && r)
+      return r.bind(this)(t);
+  }
+  fallbackMethodAvailable(e) {
+    return this.suppressFallbackMethods ? !1 : !!this[`${e}Component`];
+  }
+};
+function Oe(e, t, r) {
+  for (const s of e) {
+    const n = t[s];
+    n && (r[s] = n);
+  }
+}
+var pe = class extends st {
+  constructor() {
+    super(...arguments), this.awaitUpdateCallback = new de((e) => {
+      this.resolveUpdateCallback = e;
+    }), this.wrapperComponent = Jt;
+  }
+  init(e) {
+    return this.sourceParams = e, super.init(this.getProps());
+  }
+  addMethod() {
+  }
+  getInstance() {
+    return this.instanceCreated.then(() => this.componentInstance);
+  }
+  getFrameworkComponentInstance() {
+    return this;
+  }
+  createElement(e, t) {
+    return super.createElement(this.wrapperComponent, {
+      initialProps: t,
+      CustomComponentClass: e,
+      setMethods: (r) => this.setMethods(r),
+      addUpdateCallback: (r) => {
+        this.updateCallback = () => (r(this.getProps()), new de((s) => {
+          setTimeout(() => {
+            s();
+          });
+        })), this.resolveUpdateCallback();
+      }
+    });
+  }
+  setMethods(e) {
+    this.providedMethods = e, Oe(this.getOptionalMethods(), this.providedMethods, this);
+  }
+  getOptionalMethods() {
+    return [];
+  }
+  getProps() {
+    return {
+      ...this.sourceParams,
+      key: this.key,
+      ref: this.ref
+    };
+  }
+  refreshProps() {
+    return this.updateCallback ? this.updateCallback() : new de(
+      (e) => this.awaitUpdateCallback.then(() => {
+        this.updateCallback().then(() => e());
+      })
+    );
+  }
+}, Qt = class extends pe {
+  refresh(e) {
+    return this.sourceParams = e, this.refreshProps(), !0;
+  }
+}, Yt = class extends pe {
+  refresh(e) {
+    this.sourceParams = e, this.refreshProps();
+  }
+}, Zt = class extends pe {
+  constructor() {
+    super(...arguments), this.date = null, this.onDateChange = (e) => this.updateDate(e);
+  }
+  getDate() {
+    return this.date;
+  }
+  setDate(e) {
+    this.date = e, this.refreshProps();
+  }
+  refresh(e) {
+    this.sourceParams = e, this.refreshProps();
+  }
+  getOptionalMethods() {
+    return ["afterGuiAttached", "setInputPlaceholder", "setInputAriaLabel", "setDisabled"];
+  }
+  updateDate(e) {
+    this.setDate(e), this.sourceParams.onDateChanged();
+  }
+  getProps() {
+    const e = super.getProps();
+    return e.date = this.date, e.onDateChange = this.onDateChange, delete e.onDateChanged, e;
+  }
+}, Xt = class extends pe {
+  constructor() {
+    super(...arguments), this.label = "", this.icon = null, this.shake = !1;
+  }
+  setIcon(e, t) {
+    this.icon = e, this.shake = t, this.refreshProps();
+  }
+  setLabel(e) {
+    this.label = e, this.refreshProps();
+  }
+  getProps() {
+    const e = super.getProps(), { label: t, icon: r, shake: s } = this;
+    return e.label = t, e.icon = r, e.shake = s, e;
+  }
+}, er = class extends pe {
+  constructor() {
+    super(...arguments), this.model = null, this.onModelChange = (e) => this.updateModel(e), this.onUiChange = () => this.sourceParams.filterModifiedCallback(), this.expectingNewMethods = !0, this.hasBeenActive = !1, this.awaitSetMethodsCallback = new de((e) => {
+      this.resolveSetMethodsCallback = e;
+    });
+  }
+  isFilterActive() {
+    return this.model != null;
+  }
+  doesFilterPass(e) {
+    return this.providedMethods.doesFilterPass(e);
+  }
+  getModel() {
+    return this.model;
+  }
+  setModel(e) {
+    return this.expectingNewMethods = !0, this.model = e, this.hasBeenActive || (this.hasBeenActive = this.isFilterActive()), this.refreshProps();
+  }
+  refresh(e) {
+    return this.sourceParams = e, this.refreshProps(), !0;
+  }
+  afterGuiAttached(e) {
+    const t = this.providedMethods;
+    t ? t.afterGuiAttached?.(e) : this.awaitSetMethodsCallback.then(() => this.providedMethods?.afterGuiAttached?.(e));
+  }
+  getOptionalMethods() {
+    return ["afterGuiDetached", "onNewRowsLoaded", "getModelAsString", "onAnyFilterChanged"];
+  }
+  setMethods(e) {
+    this.expectingNewMethods === !1 && this.hasBeenActive && this.providedMethods?.doesFilterPass !== e?.doesFilterPass && setTimeout(() => {
+      this.sourceParams.filterChangedCallback();
+    }), this.expectingNewMethods = !1, super.setMethods(e), this.resolveSetMethodsCallback(), this.resolveFilterPassCallback?.(), this.resolveFilterPassCallback = void 0;
+  }
+  updateModel(e) {
+    this.resolveFilterPassCallback?.();
+    const t = new de((r) => {
+      this.resolveFilterPassCallback = r;
+    });
+    this.setModel(e).then(() => {
+      t.then(() => {
+        this.sourceParams.filterChangedCallback();
+      });
+    });
+  }
+  getProps() {
+    const e = super.getProps();
+    return e.model = this.model, e.onModelChange = this.onModelChange, e.onUiChange = this.onUiChange, delete e.filterChangedCallback, e;
+  }
+}, tr = class extends pe {
+  constructor() {
+    super(...arguments), this.awaitSetMethodsCallback = new de((e) => {
+      this.resolveSetMethodsCallback = e;
+    });
+  }
+  refresh(e) {
+    return this.sourceParams = e, this.refreshProps(), !0;
+  }
+  afterGuiAttached(e) {
+    const t = this.providedMethods;
+    t ? t.afterGuiAttached?.(e) : this.awaitSetMethodsCallback.then(() => this.providedMethods?.afterGuiAttached?.(e));
+  }
+  getOptionalMethods() {
+    return ["afterGuiDetached", "onNewRowsLoaded", "onAnyFilterChanged"];
+  }
+  setMethods(e) {
+    super.setMethods(e), this.resolveSetMethodsCallback();
+  }
+};
+function nt(e, t) {
+  e.parentFilterInstance((r) => {
+    (r.setModel(t) || de.resolve()).then(() => {
+      e.filterParams.filterChangedCallback();
+    });
+  });
+}
+var rr = class {
+  constructor(e, t) {
+    this.floatingFilterParams = e, this.refreshProps = t, this.model = null, this.onModelChange = (r) => this.updateModel(r);
+  }
+  getProps() {
+    return {
+      ...this.floatingFilterParams,
+      model: this.model,
+      onModelChange: this.onModelChange
+    };
+  }
+  onParentModelChanged(e) {
+    this.model = e, this.refreshProps();
+  }
+  refresh(e) {
+    this.floatingFilterParams = e, this.refreshProps();
+  }
+  setMethods(e) {
+    Oe(this.getOptionalMethods(), e, this);
+  }
+  getOptionalMethods() {
+    return ["afterGuiAttached"];
+  }
+  updateModel(e) {
+    this.model = e, this.refreshProps(), nt(this.floatingFilterParams, e);
+  }
+}, sr = class extends pe {
+  constructor() {
+    super(...arguments), this.model = null, this.onModelChange = (e) => this.updateModel(e);
+  }
+  onParentModelChanged(e) {
+    this.model = e, this.refreshProps();
+  }
+  refresh(e) {
+    this.sourceParams = e, this.refreshProps();
+  }
+  getOptionalMethods() {
+    return ["afterGuiAttached"];
+  }
+  updateModel(e) {
+    this.model = e, this.refreshProps(), nt(this.sourceParams, e);
+  }
+  getProps() {
+    const e = super.getProps();
+    return e.model = this.model, e.onModelChange = this.onModelChange, e;
+  }
+}, nr = class extends pe {
+  refresh(e) {
+    this.sourceParams = e, this.refreshProps();
+  }
+  getOptionalMethods() {
+    return ["afterGuiAttached"];
+  }
+}, or = class extends pe {
+  refresh(e) {
+    return this.sourceParams = e, this.refreshProps(), !0;
+  }
+}, ar = class extends pe {
+  constructor() {
+    super(...arguments), this.active = !1, this.expanded = !1, this.onActiveChange = (e) => this.updateActive(e);
+  }
+  setActive(e) {
+    this.awaitSetActive(e);
+  }
+  setExpanded(e) {
+    this.expanded = e, this.refreshProps();
+  }
+  getOptionalMethods() {
+    return ["select", "configureDefaults"];
+  }
+  awaitSetActive(e) {
+    return this.active = e, this.refreshProps();
+  }
+  updateActive(e) {
+    const t = this.awaitSetActive(e);
+    e && t.then(() => this.sourceParams.onItemActivated());
+  }
+  getProps() {
+    const e = super.getProps();
+    return e.active = this.active, e.expanded = this.expanded, e.onActiveChange = this.onActiveChange, delete e.onItemActivated, e;
+  }
+}, cr = class extends pe {
+  refresh(e) {
+    return this.sourceParams = e, this.refreshProps(), !0;
+  }
+}, ir = class extends pe {
+  constructor() {
+    super(...arguments), this.onStateChange = (e) => this.updateState(e);
+  }
+  refresh(e) {
+    return this.sourceParams = e, this.refreshProps(), !0;
+  }
+  getState() {
+    return this.state;
+  }
+  updateState(e) {
+    this.state = e, this.refreshProps(), this.sourceParams.onStateUpdated();
+  }
+  getProps() {
+    const e = super.getProps();
+    return e.state = this.state, e.onStateChange = this.onStateChange, e;
+  }
+};
+function Le() {
+  Ve(231);
+}
+var lr = 1e3, ur = class {
+  constructor(e, t, r) {
+    this.destroyed = !1, this.portals = [], this.hasPendingPortalUpdate = !1, this.wrappingElement = t || "div", this.refresher = e, this.maxComponentCreationTimeMs = r || lr;
+  }
+  getPortals() {
+    return this.portals;
+  }
+  destroy() {
+    this.destroyed = !0;
+  }
+  destroyPortal(e) {
+    this.portals = this.portals.filter((t) => t !== e), this.batchUpdate();
+  }
+  getComponentWrappingElement() {
+    return this.wrappingElement;
+  }
+  mountReactPortal(e, t, r) {
+    this.portals = [...this.portals, e], this.waitForInstance(t, r), this.batchUpdate();
+  }
+  updateReactPortal(e, t) {
+    this.portals[this.portals.indexOf(e)] = t, this.batchUpdate();
+  }
+  batchUpdate() {
+    this.hasPendingPortalUpdate || (setTimeout(() => {
+      this.destroyed || (this.refresher(), this.hasPendingPortalUpdate = !1);
+    }), this.hasPendingPortalUpdate = !0);
+  }
+  waitForInstance(e, t, r = Date.now()) {
+    if (this.destroyed) {
+      t(null);
+      return;
+    }
+    if (e.rendered())
+      t(e);
+    else {
+      if (Date.now() - r >= this.maxComponentCreationTimeMs && !this.hasPendingPortalUpdate) {
+        ke(!0, () => this.refresher()), e.rendered() && t(e);
+        return;
+      }
+      window.setTimeout(() => {
+        this.waitForInstance(e, t, r);
+      });
+    }
+  }
+}, dr = a.createContext([]), pr = a.createContext(void 0), hr = ({ ctrl: e }) => {
+  const t = e.isAlive(), { context: r } = ee(re), [s, n] = c(), [d, i] = c(), u = o(), l = o(null), m = o(null), p = o(null), S = o(), b = o();
+  t && !b.current && (b.current = new Ie(() => l.current));
+  const y = U((h) => {
+    if (l.current = h, !h || !e.isAlive() || r.isDestroyed()) {
+      u.current = r.destroyBean(u.current);
+      return;
+    }
+    u.current = r.createBean(new Se());
+    const D = () => {
+      const R = e.getSelectAllGui();
+      R && (m.current?.insertAdjacentElement("afterend", R), u.current.addDestroyFunc(() => R.remove()));
+    }, W = {
+      setWidth: (R) => {
+        l.current && (l.current.style.width = R);
+      },
+      toggleCss: (R, f) => b.current.toggleCss(R, f),
+      setUserStyles: (R) => i(R),
+      setAriaSort: (R) => {
+        l.current && (R ? Ut(l.current, R) : Ht(l.current));
+      },
+      setUserCompDetails: (R) => n(R),
+      getUserCompInstance: () => S.current || void 0,
+      refreshSelectAllGui: D,
+      removeSelectAllGui: () => e.getSelectAllGui()?.remove()
+    };
+    e.setComp(W, h, m.current, p.current, u.current), D();
+  }, []);
+  fe(
+    () => Me(s, r, p.current, S),
+    [s]
+  ), ce(() => {
+    e.setDragSource(l.current);
+  }, [s]);
+  const A = E(() => !!(s?.componentFromFramework && Fe(s.componentClass)), [s]), w = s?.componentFromFramework, v = s?.componentClass;
+  return /* @__PURE__ */ a.createElement("div", { ref: y, style: d, className: "ag-header-cell", role: "columnheader" }, /* @__PURE__ */ a.createElement("div", { ref: m, className: "ag-header-cell-resize", role: "presentation" }), /* @__PURE__ */ a.createElement("div", { ref: p, className: "ag-header-cell-comp-wrapper", role: "presentation" }, w ? A ? /* @__PURE__ */ a.createElement(v, { ...s.params }) : /* @__PURE__ */ a.createElement(v, { ...s.params, ref: S }) : null));
+}, mr = ne(hr), fr = class {
+  constructor(e, t) {
+    this.floatingFilterParams = e, this.refreshProps = t;
+  }
+  getProps() {
+    return this.floatingFilterParams;
+  }
+  refresh(e) {
+    this.floatingFilterParams = e, this.refreshProps();
+  }
+  setMethods(e) {
+    Oe(this.getOptionalMethods(), e, this);
+  }
+  getOptionalMethods() {
+    return ["afterGuiAttached"];
+  }
+}, Cr = ({ ctrl: e }) => {
+  const { context: t, gos: r } = ee(re), [s, n] = c(), [d, i] = c(
+    () => new ue("ag-header-cell", "ag-floating-filter")
+  ), [u, l] = c(() => new ue()), [m, p] = c(
+    () => new ue("ag-floating-filter-button", "ag-hidden")
+  ), [S, b] = c("false"), [y, A] = c(), [, w] = c(1), v = o(), h = o(null), D = o(null), W = o(null), R = o(null), f = o(), H = o(), k = (M) => {
+    M != null && f.current?.(M);
+  }, V = U((M) => {
+    if (h.current = M, !M || !e.isAlive() || t.isDestroyed()) {
+      v.current = t.destroyBean(v.current);
+      return;
+    }
+    v.current = t.createBean(new Se()), H.current = new de((G) => {
+      f.current = G;
+    });
+    const z = {
+      toggleCss: (G, j) => i((Y) => Y.setClass(G, j)),
+      setUserStyles: (G) => n(G),
+      addOrRemoveBodyCssClass: (G, j) => l((Y) => Y.setClass(G, j)),
+      setButtonWrapperDisplayed: (G) => {
+        p((j) => j.setClass("ag-hidden", !G)), b(G ? "false" : "true");
+      },
+      setWidth: (G) => {
+        h.current && (h.current.style.width = G);
+      },
+      setCompDetails: (G) => A(G),
+      getFloatingFilterComp: () => H.current ? H.current : null,
+      setMenuIcon: (G) => R.current?.appendChild(G)
+    };
+    e.setComp(z, M, R.current, D.current, v.current);
+  }, []);
+  fe(
+    () => Me(y, t, D.current, k),
+    [y]
+  );
+  const O = E(() => d.toString(), [d]), _ = E(() => u.toString(), [u]), C = E(() => m.toString(), [m]), P = E(() => !!(y && y.componentFromFramework && Fe(y.componentClass)), [y]), x = E(() => r.get("reactiveCustomComponents"), []), q = E(() => r.get("enableFilterHandlers"), []), [g, T] = c();
+  ce(() => {
+    if (y?.componentFromFramework)
+      if (x) {
+        const M = q ? fr : rr, z = new M(y.params, () => w((G) => G + 1));
+        k(z), T(z);
+      } else
+        Le();
+  }, [y]);
+  const L = g?.getProps(), F = y?.componentFromFramework, N = y?.componentClass;
+  return /* @__PURE__ */ a.createElement("div", { ref: V, style: s, className: O, role: "gridcell" }, /* @__PURE__ */ a.createElement("div", { ref: D, className: _, role: "presentation" }, F ? x ? L && /* @__PURE__ */ a.createElement(
+    _e.Provider,
+    {
+      value: {
+        setMethods: (M) => g.setMethods(M)
+      }
+    },
+    /* @__PURE__ */ a.createElement(N, { ...L })
+  ) : /* @__PURE__ */ a.createElement(N, { ...y.params, ref: P ? () => {
+  } : k }) : null), /* @__PURE__ */ a.createElement(
+    "div",
+    {
+      ref: W,
+      "aria-hidden": S,
+      className: C,
+      role: "presentation"
+    },
+    /* @__PURE__ */ a.createElement(
+      "button",
+      {
+        ref: R,
+        type: "button",
+        className: "ag-button ag-floating-filter-button-button",
+        tabIndex: -1
+      }
+    )
+  ));
+}, gr = ne(Cr), yr = ({ ctrl: e }) => {
+  const { context: t } = ee(re), [r, s] = c(), [n, d] = c(() => new ue()), [i, u] = c(() => new ue()), [l, m] = c("false"), [p, S] = c(), [b, y] = c(), A = o(), w = o(null), v = o(null), h = o(null), D = o(), W = U((O) => {
+    if (w.current = O, !O || !e.isAlive() || t.isDestroyed()) {
+      A.current = t.destroyBean(A.current);
+      return;
+    }
+    A.current = t.createBean(new Se());
+    const _ = {
+      setWidth: (C) => {
+        w.current && (w.current.style.width = C);
+      },
+      toggleCss: (C, P) => d((x) => x.setClass(C, P)),
+      setUserStyles: (C) => s(C),
+      setHeaderWrapperHidden: (C) => {
+        const P = h.current;
+        P && (C ? P.style.setProperty("display", "none") : P.style.removeProperty("display"));
+      },
+      setHeaderWrapperMaxHeight: (C) => {
+        const P = h.current;
+        P && (C != null ? P.style.setProperty("max-height", `${C}px`) : P.style.removeProperty("max-height"), P.classList.toggle("ag-header-cell-comp-wrapper-limited-height", C != null));
+      },
+      setUserCompDetails: (C) => y(C),
+      setResizableDisplayed: (C) => {
+        u((P) => P.setClass("ag-hidden", !C)), m(C ? "false" : "true");
+      },
+      setAriaExpanded: (C) => S(C),
+      getUserCompInstance: () => D.current || void 0
+    };
+    e.setComp(_, O, v.current, h.current, A.current);
+  }, []);
+  fe(() => Me(b, t, h.current), [b]), ce(() => {
+    w.current && e.setDragSource(w.current);
+  }, [b]);
+  const R = E(() => !!(b?.componentFromFramework && Fe(b.componentClass)), [b]), f = E(() => "ag-header-group-cell " + n.toString(), [n]), H = E(
+    () => "ag-header-cell-resize " + i.toString(),
+    [i]
+  ), k = b?.componentFromFramework, V = b?.componentClass;
+  return /* @__PURE__ */ a.createElement("div", { ref: W, style: r, className: f, role: "columnheader", "aria-expanded": p }, /* @__PURE__ */ a.createElement("div", { ref: h, className: "ag-header-cell-comp-wrapper", role: "presentation" }, k ? R ? /* @__PURE__ */ a.createElement(V, { ...b.params }) : /* @__PURE__ */ a.createElement(V, { ...b.params, ref: D }) : null), /* @__PURE__ */ a.createElement("div", { ref: v, "aria-hidden": l, className: H }));
+}, vr = ne(yr), wr = ({ ctrl: e }) => {
+  const { gos: t, context: r } = ee(re), { topOffset: s, rowHeight: n } = E(() => e.getTopAndHeight(), []), d = E(() => t.get("tabIndex"), []), [i, u] = c(() => e.getAriaRowIndex()), l = e.headerRowClass, [m, p] = c(() => n + "px"), [S, b] = c(() => s + "px"), y = o(null), [A, w] = c(() => e.getUpdatedHeaderCtrls()), v = o(), h = o(null), D = U((f) => {
+    if (h.current = f, !f || !e.isAlive() || r.isDestroyed()) {
+      v.current = r.destroyBean(v.current);
+      return;
+    }
+    v.current = r.createBean(new Se());
+    const H = {
+      setHeight: (k) => p(k),
+      setTop: (k) => b(k),
+      setHeaderCtrls: (k, V, O) => {
+        const _ = y.current, C = xe(_, k, V);
+        C !== _ && (y.current = C, ke(O, () => w(C)));
+      },
+      setWidth: (k) => {
+        h.current && (h.current.style.width = k);
+      },
+      setRowIndex: (k) => {
+        u(k);
+      }
+    };
+    e.setComp(H, v.current, !1);
+  }, []), W = E(
+    () => ({
+      height: m,
+      top: S
+    }),
+    [m, S]
+  ), R = U((f) => {
+    switch (e.type) {
+      case "group":
+        return /* @__PURE__ */ a.createElement(vr, { ctrl: f, key: f.instanceId });
+      case "filter":
+        return /* @__PURE__ */ a.createElement(gr, { ctrl: f, key: f.instanceId });
+      default:
+        return /* @__PURE__ */ a.createElement(mr, { ctrl: f, key: f.instanceId });
+    }
+  }, []);
+  return /* @__PURE__ */ a.createElement(
+    "div",
+    {
+      ref: D,
+      className: l,
+      role: "row",
+      style: W,
+      tabIndex: d,
+      "aria-rowindex": i
+    },
+    A.map(R)
+  );
+}, br = ne(wr), Rr = ({ pinned: e }) => {
+  const [t, r] = c(!0), [s, n] = c([]), { context: d } = ee(re), i = o(null), u = o(null), l = o(), m = e === "left", p = e === "right", S = !m && !p, b = U((w) => {
+    if (i.current = w, !w || d.isDestroyed()) {
+      l.current = d.destroyBean(l.current);
+      return;
+    }
+    l.current = d.createBean(new xt(e));
+    const v = {
+      setDisplayed: r,
+      setCtrls: (h) => n(h),
+      // centre only
+      setCenterWidth: (h) => {
+        u.current && (u.current.style.width = h);
+      },
+      setViewportScrollLeft: (h) => {
+        i.current && (i.current.scrollLeft = h);
+      },
+      // pinned only
+      setPinnedContainerWidth: (h) => {
+        i.current && (i.current.style.width = h, i.current.style.minWidth = h, i.current.style.maxWidth = h);
+      }
+    };
+    l.current.setComp(v, i.current);
+  }, []), y = t ? "" : "ag-hidden", A = () => s.map((w) => /* @__PURE__ */ a.createElement(br, { ctrl: w, key: w.instanceId }));
+  return m ? /* @__PURE__ */ a.createElement("div", { ref: b, className: "ag-pinned-left-header " + y, "aria-hidden": !t, role: "rowgroup" }, A()) : p ? /* @__PURE__ */ a.createElement("div", { ref: b, className: "ag-pinned-right-header " + y, "aria-hidden": !t, role: "rowgroup" }, A()) : S ? /* @__PURE__ */ a.createElement("div", { ref: b, className: "ag-header-viewport " + y, role: "rowgroup", tabIndex: -1 }, /* @__PURE__ */ a.createElement("div", { ref: u, className: "ag-header-container", role: "presentation" }, A())) : null;
+}, Te = ne(Rr), Pr = () => {
+  const [e, t] = c(() => new ue()), [r, s] = c(), { context: n } = ee(re), d = o(null), i = o(), u = U((p) => {
+    if (d.current = p, !p || n.isDestroyed()) {
+      i.current = n.destroyBean(i.current);
+      return;
+    }
+    i.current = n.createBean(new Bt());
+    const S = {
+      toggleCss: (b, y) => t((A) => A.setClass(b, y)),
+      setHeightAndMinHeight: (b) => s(b)
+    };
+    i.current.setComp(S, p, p);
+  }, []), l = E(() => "ag-header " + e.toString(), [e]), m = E(
+    () => ({
+      height: r,
+      minHeight: r
+    }),
+    [r]
+  );
+  return /* @__PURE__ */ a.createElement("div", { ref: u, className: l, style: m, role: "presentation" }, /* @__PURE__ */ a.createElement(Te, { pinned: "left" }), /* @__PURE__ */ a.createElement(Te, { pinned: null }), /* @__PURE__ */ a.createElement(Te, { pinned: "right" }));
+}, Sr = ne(Pr), Fr = (e, t) => {
+  ce(() => {
+    const r = t.current;
+    if (r) {
+      const s = r.parentElement;
+      if (s) {
+        const n = document.createComment(e);
+        return s.insertBefore(n, r), () => {
+          n.remove();
+        };
+      }
+    }
+  }, [e]);
+}, be = Fr, Er = class {
+  constructor(e, t) {
+    this.cellEditorParams = e, this.refreshProps = t, this.instanceCreated = new de((r) => {
+      this.resolveInstanceCreated = r;
+    }), this.onValueChange = (r) => this.updateValue(r), this.value = e.value;
+  }
+  getProps() {
+    return {
+      ...this.cellEditorParams,
+      initialValue: this.cellEditorParams.value,
+      value: this.value,
+      onValueChange: this.onValueChange
+    };
+  }
+  getValue() {
+    return this.value;
+  }
+  refresh(e) {
+    this.cellEditorParams = e, this.refreshProps();
+  }
+  setMethods(e) {
+    Oe(this.getOptionalMethods(), e, this);
+  }
+  getInstance() {
+    return this.instanceCreated.then(() => this.componentInstance);
+  }
+  setRef(e) {
+    this.componentInstance = e, this.resolveInstanceCreated?.(), this.resolveInstanceCreated = void 0;
+  }
+  getOptionalMethods() {
+    return [
+      "isCancelBeforeStart",
+      "isCancelAfterEnd",
+      "focusIn",
+      "focusOut",
+      "afterGuiAttached",
+      "getValidationErrors",
+      "getValidationElement"
+    ];
+  }
+  updateValue(e) {
+    this.value = e, this.refreshProps();
+  }
+}, kr = (e) => {
+  const t = o(e), r = o(), s = o(!1), n = o(!1), [, d] = c(0);
+  s.current && (n.current = !0), ce(() => (s.current || (r.current = t.current(), s.current = !0), d((i) => i + 1), () => {
+    n.current && r.current?.();
+  }), []);
+}, Mr = (e) => {
+  const [t, r] = c(), s = ee(re), { context: n, popupSvc: d, gos: i, editSvc: u } = s, { editDetails: l, cellCtrl: m, eParentCell: p } = e;
+  return kr(() => {
+    const { compDetails: S } = l, b = i.get("stopEditingWhenCellsLoseFocus");
+    let y, A;
+    if (!n.isDestroyed()) {
+      A = n.createBean(u.createPopupEditorWrapper(S.params));
+      const w = A.getGui();
+      if (e.jsChildComp) {
+        const f = e.jsChildComp.getGui();
+        f && w.appendChild(f);
+      }
+      const { column: v, rowNode: h } = m, D = {
+        column: v,
+        rowNode: h,
+        type: "popupCellEditor",
+        eventSource: p,
+        ePopup: w,
+        position: l.popupPosition,
+        keepWithinBounds: !0
+      }, W = d?.positionPopupByComponent.bind(d, D), R = d?.addPopup({
+        modal: b,
+        eChild: w,
+        closeOnEsc: !0,
+        closedCallback: (f) => {
+          m.onPopupEditorClosed(f);
+        },
+        anchorToElement: p,
+        positionCallback: W,
+        ariaOwns: p
+      });
+      y = R ? R.hideFunc : void 0, r(A), e.jsChildComp?.afterGuiAttached?.();
+    }
+    return () => {
+      y?.(), n.destroyBean(A);
+    };
+  }), fe(() => () => {
+    m.isCellFocused() && t?.getGui().contains(Vt(s)) && p.focus({ preventScroll: !0 });
+  }, [t]), t && e.wrappedContent ? Ze(e.wrappedContent, t.getGui()) : null;
+}, Je = ne(Mr), Gr = (e, t, r) => {
+  const { compProxy: s } = e;
+  r(s);
+  const n = s.getProps(), d = Fe(t);
+  return /* @__PURE__ */ a.createElement(
+    _e.Provider,
+    {
+      value: {
+        setMethods: (i) => s.setMethods(i)
+      }
+    },
+    d ? /* @__PURE__ */ a.createElement(t, { ...n }) : /* @__PURE__ */ a.createElement(t, { ...n, ref: (i) => s.setRef(i) })
+  );
+}, qe = (e, t, r) => e.compProxy ? Gr(e, t, r) : /* @__PURE__ */ a.createElement(t, { ...e.compDetails.params, ref: r }), Ar = (e, t, r, s, n) => {
+  const d = e.compDetails, i = d.componentClass, u = d.componentFromFramework && !e.popup, l = d.componentFromFramework && e.popup, m = !d.componentFromFramework && e.popup;
+  return u ? qe(e, i, t) : l ? /* @__PURE__ */ a.createElement(
+    Je,
+    {
+      editDetails: e,
+      cellCtrl: s,
+      eParentCell: r,
+      wrappedContent: qe(e, i, t)
+    }
+  ) : m && n ? /* @__PURE__ */ a.createElement(Je, { editDetails: e, cellCtrl: s, eParentCell: r, jsChildComp: n }) : null;
+}, Dr = (e, t, r, s, n, d, i = !1) => {
+  const { context: u } = ee(re), l = U(() => {
+    const m = n.current;
+    if (!m)
+      return;
+    const p = m.getGui();
+    p && p.parentElement && p.remove(), u.destroyBean(m), n.current = void 0;
+  }, []);
+  ce(() => {
+    const m = e != null && !i, p = e?.compDetails && !e.compDetails.componentFromFramework, S = t && r == null;
+    if (!(m && p && !S)) {
+      l();
+      return;
+    }
+    const y = e.compDetails;
+    if (n.current) {
+      const w = n.current, h = w.refresh != null && e.force == !1 ? w.refresh(y.params) : !1;
+      if (h === !0 || h === void 0)
+        return;
+      l();
+    }
+    y.newAgStackInstance().then((w) => {
+      if (!w)
+        return;
+      const v = w.getGui();
+      if (!v)
+        return;
+      (t ? r : d.current).appendChild(v), n.current = w;
+    });
+  }, [e, t, s, i]), ce(() => l, []);
+}, ot = Dr, Br = ({
+  cellCtrl: e,
+  parent: t
+}) => {
+  const r = o(), s = E(() => {
+    const { loadingComp: n } = e.getDeferLoadingCellRenderer();
+    return n ? {
+      value: void 0,
+      compDetails: n,
+      force: !1
+    } : void 0;
+  }, [e]);
+  if (ot(s, !1, void 0, 1, r, t), s?.compDetails?.componentFromFramework) {
+    const n = s.compDetails.componentClass;
+    return /* @__PURE__ */ a.createElement(n, { ...s.compDetails.params });
+  }
+  return /* @__PURE__ */ a.createElement(a.Fragment, null);
+}, xr = ({
+  cellCtrl: e,
+  printLayout: t,
+  editingCell: r
+}) => {
+  const s = ee(re), { context: n } = s, {
+    column: { colIdSanitised: d },
+    instanceId: i
+  } = e, u = o(), [l, m] = c(
+    () => e.isCellRenderer() ? void 0 : { compDetails: void 0, value: e.getValueToDisplay(), force: !1 }
+  ), [p, S] = c(), [b, y] = c(1), [A, w] = c(), [v, h] = c(!1), [D, W] = c(!1), [R, f] = c(!1), H = o(null), [k, V] = c(), O = E(() => e.isForceWrapper(), [e]), _ = E(() => e.getCellAriaRole(), [e]), C = o(null), P = o(null), x = o(null), q = o(), g = o(), T = o(), L = o([]), F = o(), N = o(), [M, z] = c(0), G = U((I) => {
+    N.current = I, z(($) => $ + 1);
+  }, []), j = l != null && (v || R || D) && (p == null || !!p.popup), Y = O || j, Ce = E(() => e.getCellValueClass(), [e]), ie = U(
+    (I) => {
+      if (g.current = I, I) {
+        const $ = I.isCancelBeforeStart && I.isCancelBeforeStart();
+        setTimeout(() => {
+          $ ? (e.stopEditing(!0), e.focusCell(!0)) : (e.cellEditorAttached(), e.enableEditorTooltipFeature(I));
+        });
+      }
+    },
+    [e]
+  ), me = o();
+  me.current || (me.current = new Ie(() => C.current));
+  const Ee = !!p && !p.popup;
+  ot(
+    l,
+    Y,
+    N.current,
+    M,
+    q,
+    C,
+    Ee
+  );
+  const Re = o();
+  fe(() => {
+    const I = Re.current, $ = l;
+    if (Re.current = l, I == null || I.compDetails == null || $ == null || $.compDetails == null)
+      return;
+    F.current?.refreshVisibility();
+    const Z = I.compDetails, K = $.compDetails;
+    if (Z.componentClass != K.componentClass || x.current?.refresh == null)
+      return;
+    x.current.refresh(K.params) != !0 && y((X) => X + 1);
+  }, [l]), fe(() => {
+    if (!(p && !p.compDetails.componentFromFramework) || n.isDestroyed())
+      return;
+    const $ = p.compDetails, Z = p.popup === !0, K = $.newAgStackInstance();
+    return K.then((B) => {
+      if (!B)
+        return;
+      const X = B.getGui();
+      ie(B), Z || ((O ? T : C).current?.appendChild(X), B.afterGuiAttached?.()), V(B);
+    }), () => {
+      K.then((B) => {
+        const X = B.getGui();
+        e.disableEditorTooltipFeature(), n.destroyBean(B), ie(void 0), V(void 0), X?.remove();
+      });
+    };
+  }, [p]);
+  const J = U(
+    (I) => {
+      if (T.current = I, !I || n.isDestroyed() || !e.isAlive()) {
+        const K = L.current;
+        L.current = [];
+        for (const B of K)
+          B();
+        return;
+      }
+      let $;
+      const Z = (K) => {
+        K && (I.insertAdjacentElement("afterbegin", K.getGui()), L.current.push(() => {
+          ze(K.getGui()), n.destroyBean(K), F.current === $ && (F.current = void 0);
+        }));
+      };
+      v && Z(e.createSelectionCheckbox()), R && Z(e.createDndSource()), D && ($ = e.createRowDragComp(), F.current = $, $ && (Z($), $.refreshVisibility()));
+    },
+    [e, n, R, D, v]
+  ), ge = U(() => {
+    const I = !e.isCellSpanning() || P.current, $ = C.current;
+    if (!$ || !I || !e || !e.isAlive() || n.isDestroyed()) {
+      u.current = n.destroyBean(u.current);
+      return;
+    }
+    u.current = n.createBean(new Se());
+    const Z = {
+      toggleCss: (B, X) => me.current.toggleCss(B, X),
+      setUserStyles: (B) => w(B),
+      getFocusableElement: () => C.current,
+      setIncludeSelection: (B) => h(B),
+      setIncludeRowDrag: (B) => W(B),
+      setIncludeDndSource: (B) => f(B),
+      setRowResizerElement: (B) => {
+        H.current && ze(H.current), H.current = B, B && C.current && C.current.appendChild(B);
+      },
+      getCellEditor: () => g.current ?? null,
+      getCellRenderer: () => x.current ?? q.current,
+      getParentOfValue: () => N.current ?? T.current ?? C.current,
+      setRenderDetails: (B, X, te) => {
+        const we = () => {
+          m((oe) => oe?.compDetails !== B || oe?.value !== X || oe?.force !== te ? {
+            value: X,
+            compDetails: B,
+            force: te
+          } : oe);
+        };
+        if (B?.params?.deferRender && !e.rowNode.group) {
+          const { loadingComp: oe, onReady: Pe } = e.getDeferLoadingCellRenderer();
+          if (oe) {
+            m({
+              value: void 0,
+              compDetails: oe,
+              force: !1
+            }), Pe.then(() => jt(we));
+            return;
+          }
+        }
+        we();
+      },
+      setEditDetails: (B, X, te, we) => {
+        if (B) {
+          let oe;
+          B.componentFromFramework && (we ? oe = new Er(
+            B.params,
+            () => y((Pe) => Pe + 1)
+          ) : Le()), S({
+            compDetails: B,
+            popup: X,
+            popupPosition: te,
+            compProxy: oe
+          }), X || m(void 0);
+        } else
+          e.hasBrowserFocus() && Z.getFocusableElement().focus({ preventScroll: !0 }), g.current = void 0, S(void 0);
+      },
+      refreshEditStyles: (B, X) => {
+        if (!C.current)
+          return;
+        const { current: te } = me;
+        te.toggleCss("ag-cell-value", !Y), te.toggleCss("ag-cell-inline-editing", !!B && !X), te.toggleCss("ag-cell-popup-editing", !!B && !!X), te.toggleCss("ag-cell-not-inline-editing", !B || !!X);
+      }
+    }, K = T.current || void 0;
+    e.setComp(
+      Z,
+      $,
+      P.current ?? void 0,
+      K,
+      t,
+      r,
+      u.current
+    );
+  }, []), se = U((I) => {
+    C.current = I, ge();
+  }, []), he = U((I) => {
+    P.current = I, ge();
+  }, []), ye = E(() => !!(l?.compDetails?.componentFromFramework && Fe(l.compDetails.componentClass)), [l]);
+  fe(() => {
+    if (!C.current)
+      return;
+    const { current: I } = me;
+    I.toggleCss("ag-cell-value", !Y), I.toggleCss("ag-cell-inline-editing", !!p && !p.popup), I.toggleCss("ag-cell-popup-editing", !!p && !!p.popup), I.toggleCss("ag-cell-not-inline-editing", !p || !!p.popup);
+  });
+  const ve = () => {
+    const { compDetails: I, value: $ } = l;
+    if (!I)
+      return $?.toString?.() ?? $;
+    if (I.componentFromFramework) {
+      const Z = I.componentClass;
+      return /* @__PURE__ */ a.createElement(ht, { fallback: /* @__PURE__ */ a.createElement(Br, { cellCtrl: e, parent: C }) }, ye ? /* @__PURE__ */ a.createElement(Z, { ...I.params, key: b }) : /* @__PURE__ */ a.createElement(Z, { ...I.params, key: b, ref: x }));
+    }
+  }, Ge = () => {
+    const I = () => l == null ? null : Y ? /* @__PURE__ */ a.createElement("span", { role: "presentation", id: `cell-${i}`, className: Ce, ref: G }, ve()) : ve(), $ = (Z) => Ar(Z, ie, C.current, e, k);
+    return p != null ? p.popup ? /* @__PURE__ */ a.createElement(a.Fragment, null, I(), $(p)) : $(p) : I();
+  }, Ae = () => /* @__PURE__ */ a.createElement("div", { ref: se, style: A, role: _, "col-id": d }, Y ? /* @__PURE__ */ a.createElement("div", { className: "ag-cell-wrapper", role: "presentation", ref: J }, Ge()) : Ge());
+  return e.isCellSpanning() ? /* @__PURE__ */ a.createElement("div", { ref: he, className: "ag-spanned-cell-wrapper", role: "presentation" }, Ae()) : Ae();
+}, Ir = ne(xr), Or = ({ rowCtrl: e, containerType: t }) => {
+  const { context: r, gos: s, editSvc: n } = ee(re), d = ee(Xe) === "default", i = o(), u = o(e.getDomOrder()), l = e.isFullWidth(), m = e.rowNode.displayed, [p, S] = c(
+    () => m ? e.rowNode.getRowIndexString() : null
+  ), [b, y] = c(() => e.rowId), [A, w] = c(() => e.businessKey), [v, h] = c(() => e.rowStyles), D = o(null), [W, R] = c(() => null), [f, H] = c(), [k, V] = c(
+    () => m ? e.getInitialRowTop(t) : void 0
+  ), [O, _] = c(
+    () => m ? e.getInitialTransform(t) : void 0
+  ), C = o(null), P = o(), x = o(), q = o(!1), [g, T] = c(0);
+  ce(() => {
+    if (q.current || !f || g > 10)
+      return;
+    const J = C.current?.firstChild;
+    J ? (e.setupDetailRowAutoHeight(J), q.current = !0) : T((ge) => ge + 1);
+  }, [f, g]);
+  const L = o();
+  L.current || (L.current = new Ie(() => C.current));
+  const F = o(() => {
+  }), N = U((J) => (F.current = J, () => {
+    F.current = () => {
+    };
+  }), []), M = $t(
+    N,
+    () => D.current,
+    []
+  ), z = d ? M : W, G = U((J) => {
+    if (C.current = J, i.current = J ? r.createBean(new Se()) : r.destroyBean(i.current), !J) {
+      e.unsetComp(t);
+      return;
+    }
+    if (!e.isAlive() || r.isDestroyed())
+      return;
+    const ge = {
+      // the rowTop is managed by state, instead of direct style manipulation by rowCtrl (like all the other styles)
+      // as we need to have an initial value when it's placed into he DOM for the first time, for animation to work.
+      setTop: V,
+      setTransform: _,
+      // i found using React for managing classes at the row level was to slow, as modifying classes caused a lot of
+      // React code to execute, so avoiding React for managing CSS Classes made the grid go much faster.
+      toggleCss: (se, he) => L.current.toggleCss(se, he),
+      setDomOrder: (se) => u.current = se,
+      setRowIndex: S,
+      setRowId: y,
+      setRowBusinessKey: w,
+      setUserStyles: h,
+      // if we don't maintain the order, then cols will be ripped out and into the dom
+      // when cols reordered, which would stop the CSS transitions from working
+      setCellCtrls: (se, he) => {
+        const ye = D.current, ve = xe(ye, se, u.current);
+        ve !== ye && (D.current = ve, d ? F.current() : ke(he, () => R(ve)));
+      },
+      showFullWidth: (se) => {
+        x.current = se.params, H(se);
+      },
+      getFullWidthCellRenderer: () => P.current,
+      getFullWidthCellRendererParams: () => x.current,
+      refreshFullWidth: (se) => {
+        const he = se();
+        return x.current = he, me.current ? (H((ye) => ({
+          ...ye,
+          params: he
+        })), !0) : !P.current || !P.current.refresh ? !1 : P.current.refresh(he);
+      }
+    };
+    e.setComp(ge, J, t, i.current);
+  }, []);
+  fe(
+    () => Me(f, r, C.current, P),
+    [f]
+  );
+  const j = E(() => {
+    const J = { top: k, transform: O };
+    return Object.assign(J, v), J;
+  }, [k, O, v]), Y = l && f?.componentFromFramework, Ce = !l && z != null, ie = E(() => !!(f?.componentFromFramework && Fe(f.componentClass)), [f]), me = o(!1);
+  ce(() => {
+    me.current = ie && !!f && !!s.get("reactiveCustomComponents");
+  }, [ie, f]);
+  const Ee = () => z?.map((J) => /* @__PURE__ */ a.createElement(
+    Ir,
+    {
+      cellCtrl: J,
+      editingCell: n?.isEditing(J, { withOpenEditor: !0 }) ?? !1,
+      printLayout: e.printLayout,
+      key: J.instanceId
+    }
+  )), Re = () => {
+    const J = f.componentClass;
+    return ie ? /* @__PURE__ */ a.createElement(J, { ...f.params }) : /* @__PURE__ */ a.createElement(J, { ...f.params, ref: P });
+  };
+  return /* @__PURE__ */ a.createElement(
+    "div",
+    {
+      ref: G,
+      role: "row",
+      style: j,
+      "row-index": p,
+      "row-id": b,
+      "row-business-key": A
+    },
+    Ce ? Ee() : Y ? Re() : null
+  );
+}, Qe = ne(Or), Wr = ({ name: e }) => {
+  const { context: t, gos: r } = ee(re), s = E(() => It(e), [e]), n = o(null), d = o(null), i = o(null), u = o([]), l = o([]), [m, p] = c(() => []), S = !!r.get("enableCellSpan") && !!s.getSpannedRowCtrls, b = o([]), y = o([]), [A, w] = c(() => []), v = o(!1), h = o(), D = E(() => le("ag-viewport", Ot(e)), [e]), W = E(() => le(Wt(e)), [e]), R = E(() => le("ag-spanning-container", Tt(e)), [e]), f = s.type === "center" || S, H = f ? n : d;
+  be(" AG Row Container " + e + " ", H);
+  const k = U(() => {
+    const g = !f || n.current != null, T = d.current != null, L = !S || i.current != null;
+    return g && T && L;
+  }, []), V = U(() => n.current == null && d.current == null && i.current == null, []), O = U(() => {
+    if (V() && (h.current = t.destroyBean(h.current)), !t.isDestroyed() && k()) {
+      const g = (F) => {
+        const N = xe(
+          l.current,
+          u.current,
+          v.current
+        );
+        N !== l.current && (l.current = N, ke(F, () => p(N)));
+      }, T = (F) => {
+        const N = xe(
+          y.current,
+          b.current,
+          v.current
+        );
+        N !== y.current && (y.current = N, ke(F, () => w(N)));
+      }, L = {
+        setHorizontalScroll: (F) => {
+          n.current && (n.current.scrollLeft = F);
+        },
+        setViewportHeight: (F) => {
+          n.current && (n.current.style.height = F);
+        },
+        setRowCtrls: ({ rowCtrls: F, useFlushSync: N }) => {
+          const M = !!N && u.current.length > 0 && F.length > 0;
+          u.current = F, g(M);
+        },
+        setSpannedRowCtrls: (F, N) => {
+          const M = !!N && b.current.length > 0 && F.length > 0;
+          b.current = F, T(M);
+        },
+        setDomOrder: (F) => {
+          v.current != F && (v.current = F, g(!1));
+        },
+        setContainerWidth: (F) => {
+          d.current && (d.current.style.width = F);
+        },
+        setOffsetTop: (F) => {
+          d.current && (d.current.style.transform = `translateY(${F})`);
+        }
+      };
+      h.current = t.createBean(new Nt(e)), h.current.setComp(
+        L,
+        d.current,
+        i.current ?? void 0,
+        n.current
+      );
+    }
+  }, [k, V]), _ = U(
+    (g) => {
+      d.current = g, O();
+    },
+    [O]
+  ), C = U(
+    (g) => {
+      i.current = g, O();
+    },
+    [O]
+  ), P = U(
+    (g) => {
+      n.current = g, O();
+    },
+    [O]
+  ), x = () => /* @__PURE__ */ a.createElement(
+    "div",
+    {
+      className: W,
+      ref: _,
+      role: f ? "presentation" : "rowgroup"
+    },
+    m.map((g) => /* @__PURE__ */ a.createElement(Qe, { rowCtrl: g, containerType: s.type, key: g.instanceId }))
+  );
+  if (!f)
+    return x();
+  const q = () => /* @__PURE__ */ a.createElement("div", { className: R, ref: C, role: "presentation" }, A.map((g) => /* @__PURE__ */ a.createElement(Qe, { rowCtrl: g, containerType: s.type, key: g.instanceId })));
+  return /* @__PURE__ */ a.createElement("div", { className: D, ref: P, role: "rowgroup" }, x(), S ? q() : null);
+}, Tr = ne(Wr), Nr = () => {
+  const e = ee(re), { context: t, overlays: r } = e, [s, n] = c(""), [d, i] = c(0), [u, l] = c(0), [m, p] = c("0px"), [S, b] = c("0px"), [y, A] = c("100%"), [w, v] = c("0px"), [h, D] = c("0px"), [W, R] = c("100%"), [f, H] = c(!0), [k, V] = c(!0), [O, _] = c(null), [C, P] = c(""), [x, q] = c(null), [g, T] = c("ag-layout-normal"), L = o();
+  L.current || (L.current = new Ie(() => F.current));
+  const F = o(null), N = o(null), M = o(null), z = o(null), G = o(null), j = o(null), Y = o(null), Ce = o([]), ie = o([]);
+  be(" AG Grid Body ", F), be(" AG Pinned Top ", N), be(" AG Sticky Top ", M), be(" AG Middle ", j), be(" AG Pinned Bottom ", Y);
+  const me = U((K) => {
+    if (F.current = K, !K || t.isDestroyed()) {
+      Ce.current = t.destroyBeans(Ce.current);
+      for (const Q of ie.current)
+        Q();
+      ie.current = [];
+      return;
+    }
+    const B = (Q, ae) => {
+      Q.appendChild(ae), ie.current.push(() => ae.remove());
+    }, X = (Q) => {
+      const ae = t.createBean(new Q());
+      return Ce.current.push(ae), ae;
+    }, te = (Q, ae, lt) => {
+      B(Q, document.createComment(lt)), B(Q, X(ae).getGui());
+    };
+    te(K, At, " AG Fake Horizontal Scroll ");
+    const we = r?.getOverlayWrapperCompClass();
+    we && te(K, we, " AG Overlay Wrapper "), G.current && te(G.current, Dt, " AG Fake Vertical Scroll ");
+    const oe = {
+      setRowAnimationCssOnBodyViewport: n,
+      setColumnCount: (Q) => {
+        F.current && Gt(F.current, Q);
+      },
+      setRowCount: (Q) => {
+        F.current && Mt(F.current, Q);
+      },
+      setTopHeight: i,
+      setBottomHeight: l,
+      setStickyTopHeight: p,
+      setStickyTopTop: b,
+      setStickyTopWidth: A,
+      setTopInvisible: H,
+      setBottomInvisible: V,
+      setColumnMovingCss: (Q, ae) => L.current.toggleCss(Q, ae),
+      updateLayoutClasses: T,
+      setAlwaysVerticalScrollClass: _,
+      setPinnedTopBottomOverflowY: P,
+      setCellSelectableCss: (Q, ae) => q(ae ? Q : null),
+      setBodyViewportWidth: (Q) => {
+        j.current && (j.current.style.width = Q);
+      },
+      registerBodyViewportResizeListener: (Q) => {
+        if (j.current) {
+          const ae = Ye(e, j.current, Q);
+          ie.current.push(() => ae());
+        }
+      },
+      setStickyBottomHeight: v,
+      setStickyBottomBottom: D,
+      setStickyBottomWidth: R,
+      setGridRootRole: (Q) => K.setAttribute("role", Q)
+    }, Pe = t.createBean(new Et());
+    Ce.current.push(Pe), Pe.setComp(
+      oe,
+      K,
+      j.current,
+      N.current,
+      Y.current,
+      M.current,
+      z.current
+    );
+  }, []), Ee = E(() => le("ag-root", "ag-unselectable", g), [g]), Re = E(
+    () => le(
+      "ag-body-viewport",
+      s,
+      g,
+      O,
+      x
+    ),
+    [s, g, O, x]
+  ), J = E(() => le("ag-body", g), [g]), ge = E(
+    () => le("ag-floating-top", f ? "ag-invisible" : null, x),
+    [x, f]
+  ), se = E(() => le("ag-sticky-top", x), [x]), he = E(
+    () => le("ag-sticky-bottom", w === "0px" ? "ag-invisible" : null, x),
+    [x, w]
+  ), ye = E(
+    () => le("ag-floating-bottom", k ? "ag-invisible" : null, x),
+    [x, k]
+  ), ve = E(
+    () => ({
+      height: d,
+      minHeight: d,
+      overflowY: C
+    }),
+    [d, C]
+  ), Ge = E(
+    () => ({
+      height: m,
+      top: S,
+      width: y
+    }),
+    [m, S, y]
+  ), Ae = E(
+    () => ({
+      height: w,
+      bottom: h,
+      width: W
+    }),
+    [w, h, W]
+  ), I = E(
+    () => ({
+      height: u,
+      minHeight: u,
+      overflowY: C
+    }),
+    [u, C]
+  ), $ = (K) => /* @__PURE__ */ a.createElement(Tr, { name: K, key: `${K}-container` }), Z = ({
+    section: K,
+    children: B,
+    className: X,
+    style: te
+  }) => /* @__PURE__ */ a.createElement("div", { ref: K, className: X, role: "presentation", style: te }, B.map($));
+  return /* @__PURE__ */ a.createElement("div", { ref: me, className: Ee }, /* @__PURE__ */ a.createElement(Sr, null), Z({
+    section: N,
+    className: ge,
+    style: ve,
+    children: ["topLeft", "topCenter", "topRight", "topFullWidth"]
+  }), /* @__PURE__ */ a.createElement("div", { className: J, ref: G, role: "presentation" }, Z({
+    section: j,
+    className: Re,
+    children: ["left", "center", "right", "fullWidth"]
+  })), Z({
+    section: M,
+    className: se,
+    style: Ge,
+    children: ["stickyTopLeft", "stickyTopCenter", "stickyTopRight", "stickyTopFullWidth"]
+  }), Z({
+    section: z,
+    className: he,
+    style: Ae,
+    children: ["stickyBottomLeft", "stickyBottomCenter", "stickyBottomRight", "stickyBottomFullWidth"]
+  }), Z({
+    section: Y,
+    className: ye,
+    style: I,
+    children: ["bottomLeft", "bottomCenter", "bottomRight", "bottomFullWidth"]
+  }));
+}, Ur = ne(Nr), Hr = (e, t) => {
+  const { children: r, eFocusableElement: s, onTabKeyDown: n, gridCtrl: d, forceFocusOutWhenTabGuardsAreEmpty: i, isEmpty: u } = e, { context: l } = ee(re), m = o(null), p = o(null), S = o(), b = (h) => {
+    const D = h == null ? void 0 : parseInt(h, 10).toString();
+    for (const W of [m, p])
+      D === void 0 ? W.current?.removeAttribute("tabindex") : W.current?.setAttribute("tabindex", D);
+  };
+  He(t, () => ({
+    forceFocusOutOfContainer(h) {
+      S.current?.forceFocusOutOfContainer(h);
+    }
+  }));
+  const y = U(() => {
+    const h = m.current, D = p.current;
+    if (!h && !D || l.isDestroyed()) {
+      S.current = l.destroyBean(S.current);
+      return;
+    }
+    if (h && D) {
+      const W = {
+        setTabIndex: b
+      };
+      S.current = l.createBean(
+        new kt({
+          comp: W,
+          eTopGuard: h,
+          eBottomGuard: D,
+          eFocusableElement: s,
+          onTabKeyDown: n,
+          forceFocusOutWhenTabGuardsAreEmpty: i,
+          focusInnerElement: (R) => d.focusInnerElement(R),
+          isEmpty: u
+        })
+      );
+    }
+  }, []), A = U(
+    (h) => {
+      m.current = h, y();
+    },
+    [y]
+  ), w = U(
+    (h) => {
+      p.current = h, y();
+    },
+    [y]
+  ), v = (h) => {
+    const D = h === "top" ? We.TAB_GUARD_TOP : We.TAB_GUARD_BOTTOM;
+    return /* @__PURE__ */ a.createElement(
+      "div",
+      {
+        className: `${We.TAB_GUARD} ${D}`,
+        role: "presentation",
+        ref: h === "top" ? A : w
+      }
+    );
+  };
+  return /* @__PURE__ */ a.createElement(a.Fragment, null, v("top"), r, v("bottom"));
+}, Vr = Ue(Hr), _r = ne(Vr), Lr = ({ context: e }) => {
+  const [t, r] = c(""), [s, n] = c(""), [d, i] = c(null), [u, l] = c(null), [m, p] = c(!1), [S, b] = c(), y = o(), A = o(null), w = o(), [v, h] = c(null), D = o(() => {
+  }), W = o(), R = o([]), f = U(() => {
+  }, []);
+  be(" AG Grid ", A);
+  const H = U((P) => {
+    if (A.current = P, y.current = P ? e.createBean(new Pt()) : e.destroyBean(y.current), !P || e.isDestroyed())
+      return;
+    const x = y.current;
+    D.current = x.focusInnerElement.bind(x);
+    const q = {
+      destroyGridUi: () => {
+      },
+      // do nothing, as framework users destroy grid by removing the comp
+      setRtlClass: r,
+      forceFocusOutOfContainer: (g) => {
+        if (!g && W.current?.isDisplayed()) {
+          W.current.forceFocusOutOfContainer(g);
+          return;
+        }
+        w.current?.forceFocusOutOfContainer(g);
+      },
+      updateLayoutClasses: n,
+      getFocusableContainers: () => {
+        const g = [], T = [], L = A.current?.querySelector(".ag-root");
+        for (const N of R.current) {
+          if (!N.isDisplayed())
+            continue;
+          const M = N.getFocusableContainerName();
+          if (M === "rowGroupToolbar" || M === "pivotToolbar") {
+            g.push(N);
+            continue;
+          }
+          T.push(N);
+        }
+        const F = [...g];
+        return L && F.push({
+          getGui: () => L,
+          getFocusableContainerName: () => "gridBody"
+        }), F.push(...T), F;
+      },
+      setCursor: i,
+      setUserSelect: l
+    };
+    x.setComp(q, P, P), p(!0);
+  }, []);
+  ce(() => {
+    const P = y.current, x = A.current;
+    if (!S || !P || !v || !x || e.isDestroyed())
+      return;
+    const q = [];
+    R.current = [], W.current = void 0;
+    const {
+      watermarkSelector: g,
+      paginationSelector: T,
+      sideBarSelector: L,
+      statusBarSelector: F,
+      gridHeaderDropZonesSelector: N
+    } = P.getOptionalSelectors(), M = [];
+    if (N) {
+      const G = e.createBean(
+        new N.component()
+      ), j = G.getGui();
+      x.insertAdjacentElement("afterbegin", j), M.push(j), q.push(G), R.current.push(...G.getFocusableContainers?.() ?? []);
+    }
+    if (L) {
+      const G = e.createBean(new L.component()), j = G.getGui(), Y = v.querySelector(".ag-tab-guard-bottom");
+      Y && (Y.insertAdjacentElement("beforebegin", j), M.push(j)), q.push(G), R.current.push(G);
+    }
+    const z = (G) => {
+      const j = e.createBean(new G()), Y = j.getGui();
+      return x.insertAdjacentElement("beforeend", Y), M.push(Y), q.push(j), j;
+    };
+    if (F) {
+      const G = z(F.component);
+      R.current.push(G);
+    }
+    if (T) {
+      const G = z(T.component);
+      W.current = G, R.current.push(G);
+    }
+    return g && z(g.component), () => {
+      e.destroyBeans(q), R.current = [], W.current = void 0;
+      for (const G of M)
+        G.remove();
+    };
+  }, [S, v, e]);
+  const k = E(
+    () => le("ag-root-wrapper", t, s),
+    [t, s]
+  ), V = E(
+    () => le("ag-root-wrapper-body", "ag-focus-managed", s),
+    [s]
+  ), O = E(
+    () => ({
+      userSelect: u ?? "",
+      WebkitUserSelect: u ?? "",
+      cursor: d ?? ""
+    }),
+    [u, d]
+  ), _ = U((P) => {
+    w.current = P, b(P !== null);
+  }, []), C = U(() => !y.current?.isFocusable(), []);
+  return /* @__PURE__ */ a.createElement("div", { ref: H, className: k, style: O, role: "presentation" }, /* @__PURE__ */ a.createElement("div", { className: V, ref: h, role: "presentation" }, m && v && !e.isDestroyed() && /* @__PURE__ */ a.createElement(re.Provider, { value: e.getBeans() }, /* @__PURE__ */ a.createElement(
+    _r,
+    {
+      ref: _,
+      eFocusableElement: v,
+      onTabKeyDown: f,
+      gridCtrl: y.current,
+      forceFocusOutWhenTabGuardsAreEmpty: !0,
+      isEmpty: C
+    },
+    // we wait for initialised before rending the children, so GridComp has created and registered with it's
+    // GridCtrl before we create the child GridBodyComp. Otherwise the GridBodyComp would initialise first,
+    // before we have set the the Layout CSS classes, causing the GridBodyComp to render rows to a grid that
+    // doesn't have it's height specified, which would result if all the rows getting rendered (and if many rows,
+    // hangs the UI)
+    /* @__PURE__ */ a.createElement(Ur, null)
+  ))));
+}, zr = ne(Lr), jr = class extends wt {
+  postConstruct() {
+    if (this.beans.colAutosize) {
+      const e = this.queueResizeOperationsForTick.bind(this);
+      this.addManagedEventListeners({
+        rowExpansionStateChanged: e,
+        expandOrCollapseAll: e,
+        // Enable devs to resize after they updated via the API
+        cellValueChanged: e,
+        rowNodeDataChanged: e,
+        rowDataUpdated: e
+      });
+    }
+  }
+  queueResizeOperationsForTick() {
+    const e = this.beans.colAutosize;
+    e.shouldQueueResizeOperations = !0, setTimeout(() => {
+      e.processResizeOperations();
+    }, 0);
+  }
+  areHeaderCellsRendered() {
+    return this.beans.ctrlsSvc.getHeaderRowContainerCtrls().every((e) => e.getAllCtrls().every((t) => t.areCellsRendered()));
+  }
+  areCellsRendered() {
+    return this.beans.rowRenderer.getAllRowCtrls().every((e) => e.isRowRendered() && e.getAllCellCtrls().every((t) => !!t.eGui));
+  }
+}, $r = typeof window > "u" ? ce : fe, at = {
+  setGridApi: void 0,
+  maxComponentCreationTimeMs: void 0,
+  children: void 0
+}, Kr = {
+  gridOptions: void 0,
+  modules: void 0,
+  containerStyle: void 0,
+  className: void 0,
+  passGridApi: void 0,
+  componentWrappingElement: void 0,
+  ...at
+}, ct = new Set(Object.keys(Kr)), Jr = new Set(Object.keys(at)), it = (e) => {
+  const t = ee(dr), r = ee(pr), s = o(), n = o(null), d = o(null), i = o([]), u = o([]), l = o(e), m = o(), p = o(), S = o(!1), [b, y] = c(void 0), [, A] = c(0), w = o(), v = (f) => {
+    const H = n.current?.classList, k = (V = "") => V.trim().split(/\s+/g).filter(Boolean);
+    if (w.current !== f) {
+      for (const V of k(w.current))
+        H?.contains(V) && H.remove(V);
+      for (const V of k(f))
+        H?.contains(V) || H?.add(V);
+      w.current = f;
+    }
+  };
+  $r(() => {
+    v(e.className);
+  }, [e.className]);
+  const h = U((f) => {
+    if (n.current = f, v(e.className), !f) {
+      for (const g of i.current)
+        g();
+      i.current.length = 0;
+      return;
+    }
+    const H = [...e.modules ?? [], ...t ?? []];
+    r && mt(H)?.setLicenseKey(r), d.current || (d.current = new ur(
+      () => A((g) => g + 1),
+      e.componentWrappingElement,
+      e.maxComponentCreationTimeMs
+    ), i.current.push(() => {
+      d.current?.destroy(), d.current = null;
+    }));
+    const k = ft(
+      e.gridOptions,
+      e,
+      Object.keys(e).filter((g) => !ct.has(g))
+    ), V = () => {
+      if (S.current) {
+        const g = () => m.current?.shouldQueueUpdates() ? void 0 : u.current.shift();
+        let T = g();
+        for (; T; )
+          T(), T = g();
+      }
+    }, O = new Zr(V);
+    m.current = O;
+    const _ = new jr(), C = {
+      providedBeanInstances: {
+        frameworkCompWrapper: new Qr(d.current, k),
+        renderStatus: _
+      },
+      modules: H,
+      frameworkOverrides: O,
+      setThemeOnGridDiv: !0
+    }, P = (g) => {
+      y(g), g.createBean(_), i.current.push(() => {
+        g.destroy();
+      }), g.getBean("ctrlsSvc").whenReady(
+        {
+          addDestroyFunc: (T) => {
+            i.current.push(T);
+          }
+        },
+        () => {
+          if (g.isDestroyed())
+            return;
+          const T = s.current;
+          T && e.passGridApi?.(T);
+        }
+      );
+    }, x = (g) => {
+      g.getBean("ctrlsSvc").whenReady(
+        {
+          addDestroyFunc: (T) => {
+            i.current.push(T);
+          }
+        },
+        () => {
+          for (const T of u.current)
+            T();
+          u.current.length = 0, S.current = !0;
+        }
+      );
+    }, q = new Ct();
+    k.gridId ?? (k.gridId = p.current), s.current = q.create(
+      f,
+      k,
+      P,
+      x,
+      C
+    ), i.current.push(() => {
+      s.current = void 0;
+    }), s.current && (p.current = s.current.getGridId());
+  }, []), D = E(() => ({
+    height: "100%",
+    ...e.containerStyle || {}
+  }), [e.containerStyle]), W = U((f) => {
+    S.current && !m.current?.shouldQueueUpdates() ? f() : u.current.push(f);
+  }, []);
+  ce(() => {
+    const f = qr(l.current, e);
+    l.current = e, W(() => {
+      s.current && gt(f, s.current);
+    });
+  }, [e]);
+  const R = !a.useSyncExternalStore || De(e, "renderingMode") === "legacy" ? "legacy" : "default";
+  return (
+    // IMPORTANT! Don't set className here, we must use classList
+    // imperatively to avoid removing classes set by the grid
+    /* @__PURE__ */ a.createElement("div", { style: D, ref: h }, /* @__PURE__ */ a.createElement(Xe.Provider, { value: R }, b && !b.isDestroyed() ? /* @__PURE__ */ a.createElement(zr, { key: b.instanceId, context: b }) : null, d.current?.getPortals() ?? null))
+  );
+};
+function qr(e, t) {
+  const r = {};
+  for (const s of Object.keys(t)) {
+    if (ct.has(s)) {
+      Jr.has(s) && Ve(274, { prop: s });
+      continue;
+    }
+    const n = t[s];
+    e[s] !== n && (r[s] = n);
+  }
+  return r;
+}
+var Qr = class extends vt {
+  constructor(e, t) {
+    super(), this.parent = e, this.gridOptions = t;
+  }
+  createWrapper(e, t) {
+    const r = this.gridOptions;
+    if (De(r, "reactiveCustomComponents")) {
+      const i = ((u) => {
+        switch (u) {
+          case "filter":
+            return De(r, "enableFilterHandlers") ? tr : er;
+          case "floatingFilterComponent":
+            return De(r, "enableFilterHandlers") ? nr : sr;
+          case "dateComponent":
+            return Zt;
+          case "dragAndDropImageComponent":
+            return Xt;
+          case "loadingOverlayComponent":
+          case "noRowsOverlayComponent":
+          case "activeOverlay":
+            return Yt;
+          case "statusPanel":
+            return cr;
+          case "toolPanel":
+            return ir;
+          case "menuItem":
+            return ar;
+          case "cellRenderer":
+            return Qt;
+          case "innerHeaderComponent":
+            return or;
+        }
+      })(t.name);
+      if (i)
+        return new i(e, this.parent, t);
+    } else
+      switch (t.name) {
+        case "filter":
+        case "floatingFilterComponent":
+        case "dateComponent":
+        case "dragAndDropImageComponent":
+        case "loadingOverlayComponent":
+        case "noRowsOverlayComponent":
+        case "activeOverlay":
+        case "statusPanel":
+        case "toolPanel":
+        case "menuItem":
+        case "cellRenderer":
+          Le();
+          break;
+      }
+    const n = !t.cellRenderer && t.name !== "toolPanel";
+    return new st(e, this.parent, t, n);
+  }
+}, Yr = Ue((e, t) => {
+  const r = ee(re), { registry: s, context: n, gos: d, rowModel: i } = r, [u, l] = c(() => new ue()), [m, p] = c(() => new ue()), [S, b] = c(), [y, A] = c(), w = o(), v = o(null), h = o(), D = E(
+    () => bt(e.api.getGridId(), S?.rowModelType ?? "clientSide"),
+    [e]
+  ), W = E(() => u.toString() + " ag-details-row", [u]), R = E(() => m.toString() + " ag-details-grid", [m]);
+  t && He(t, () => ({
+    refresh() {
+      return w.current?.refresh() ?? !1;
+    }
+  })), e.template && Ve(230);
+  const f = U((k) => {
+    if (v.current = k, !k || n.isDestroyed()) {
+      w.current = n.destroyBean(w.current), h.current?.();
+      return;
+    }
+    const V = {
+      toggleCss: (_, C) => l((P) => P.setClass(_, C)),
+      toggleDetailGridCss: (_, C) => p((P) => P.setClass(_, C)),
+      setDetailGrid: (_) => b(_),
+      setRowData: (_) => A(_),
+      getGui: () => v.current
+    }, O = s.createDynamicBean("detailCellRendererCtrl", !0);
+    if (O && (n.createBean(O), O.init(V, e), w.current = O, d.get("detailRowAutoHeight"))) {
+      const _ = () => {
+        if (v.current == null)
+          return;
+        const C = v.current.clientHeight;
+        C != null && C > 0 && setTimeout(() => {
+          e.node.setRowHeight(C), (St(d) || Ft(d)) && i.onRowHeightChanged();
+        }, 0);
+      };
+      h.current = Ye(r, k, _), _();
+    }
+  }, []), H = U((k) => {
+    w.current?.registerDetailWithMaster(k);
+  }, []);
+  return /* @__PURE__ */ a.createElement("div", { className: W, ref: f }, S && /* @__PURE__ */ a.createElement(
+    it,
+    {
+      className: R,
+      ...S,
+      modules: D,
+      rowData: y,
+      passGridApi: H
+    }
+  ));
+}), Zr = class extends yt {
+  constructor(e) {
+    super("react"), this.processQueuedUpdates = e, this.queueUpdates = !1, this.renderingEngine = "react", this.frameworkComponents = {
+      agGroupCellRenderer: $e,
+      agGroupRowRenderer: $e,
+      agDetailCellRenderer: Yr
+    }, this.wrapIncoming = (t, r) => r === "ensureVisible" ? zt(t) : t();
+  }
+  frameworkComponent(e) {
+    return this.frameworkComponents[e];
+  }
+  isFrameworkComponent(e) {
+    if (!e)
+      return !1;
+    const t = e.prototype;
+    return !(t && "getGui" in t);
+  }
+  getLockOnRefresh() {
+    this.queueUpdates = !0;
+  }
+  releaseLockOnRefresh() {
+    this.queueUpdates = !1, this.processQueuedUpdates();
+  }
+  shouldQueueUpdates() {
+    return this.queueUpdates;
+  }
+  runWhenReadyAsync() {
+    return Lt();
+  }
+}, rs = class extends ut {
+  constructor() {
+    super(...arguments), this.apiListeners = [], this.setGridApi = (e) => {
+      this.api = e;
+      for (const t of this.apiListeners)
+        t(e);
+    };
+  }
+  registerApiListener(e) {
+    this.apiListeners.push(e);
+  }
+  componentWillUnmount() {
+    this.apiListeners.length = 0;
+  }
+  render() {
+    return /* @__PURE__ */ a.createElement(it, { ...this.props, passGridApi: this.setGridApi });
+  }
+};
+export {
+  rs as AgGridReact,
+  _e as CustomComponentContext,
+  Le as warnReactiveCustomComponents
+};