@ynput/ayon-frontend-shared 0.1.0

package/dist/index.es8.js

@@ -0,0 +1,4340 @@
+import { j as A } from "./jsx-runtime-Drh4NO5G.mjs";
+import * as Ce from "react";
+import { forwardRef as le, useState as Q, useEffect as J, useRef as re, createContext as de, useContext as ce, useMemo as U, useCallback as M, memo as Me, createElement as pt } from "react";
+import { flushSync as yt, createPortal as wt } from "react-dom";
+import { functionalUpdate as ve, sortingFns as Ve, flexRender as Je, useReactTable as bt, filterFns as xt, getSortedRowModel as It, getExpandedRowModel as vt, getFilteredRowModel as Ct, getCoreRowModel as Tt } from "@tanstack/react-table";
+import { c as q, E as St } from "./EmptyPlaceholderFlex.styled-C3tjIk5V.mjs";
+import N from "styled-components";
+import { c as Et, t as Le, m as Ge, a as Xe, i as Se, f as Oe } from "./format-DUCu0Y-3.mjs";
+import { Icon as ae, Dropdown as At, Button as et, theme as Rt } from "@ynput/ayon-react-components";
+import { y as ie, c as We } from "./confirmDelete-BSaFL2RH.mjs";
+import { u as kt } from "./useLocalStorage-BQSzWJ4Q.mjs";
+import { a as Dt } from "./useCreateContextMenu-DvOhPycB.mjs";
+import { a as Ee, K as Ae } from "./platform-DNAvZtra.mjs";
+function Ue(e, n) {
+  const t = () => Et(n == null ? void 0 : n.in, NaN), s = $t(e);
+  let i;
+  if (s.date) {
+    const x = Mt(s.date, 2);
+    i = _t(x.restDateString, x.year);
+  }
+  if (!i || isNaN(+i)) return t();
+  const r = +i;
+  let l = 0, f;
+  if (s.time && (l = Nt(s.time), isNaN(l)))
+    return t();
+  if (s.timezone) {
+    if (f = Ft(s.timezone), isNaN(f)) return t();
+  } else {
+    const x = new Date(r + l), d = Le(0, n == null ? void 0 : n.in);
+    return d.setFullYear(
+      x.getUTCFullYear(),
+      x.getUTCMonth(),
+      x.getUTCDate()
+    ), d.setHours(
+      x.getUTCHours(),
+      x.getUTCMinutes(),
+      x.getUTCSeconds(),
+      x.getUTCMilliseconds()
+    ), d;
+  }
+  return Le(r + l + f, n == null ? void 0 : n.in);
+}
+const Ie = {
+  dateTimeDelimiter: /[T ]/,
+  timeZoneDelimiter: /[Z ]/i,
+  timezone: /([Z+-].*)$/
+}, zt = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/, jt = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/, Ot = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function $t(e) {
+  const n = {}, t = e.split(Ie.dateTimeDelimiter);
+  let o;
+  if (t.length > 2)
+    return n;
+  if (/:/.test(t[0]) ? o = t[0] : (n.date = t[0], o = t[1], Ie.timeZoneDelimiter.test(n.date) && (n.date = e.split(Ie.timeZoneDelimiter)[0], o = e.substr(
+    n.date.length,
+    e.length
+  ))), o) {
+    const s = Ie.timezone.exec(o);
+    s ? (n.time = o.replace(s[1], ""), n.timezone = s[1]) : n.time = o;
+  }
+  return n;
+}
+function Mt(e, n) {
+  const t = new RegExp(
+    "^(?:(\\d{4}|[+-]\\d{" + (4 + n) + "})|(\\d{2}|[+-]\\d{" + (2 + n) + "})$)"
+  ), o = e.match(t);
+  if (!o) return { year: NaN, restDateString: "" };
+  const s = o[1] ? parseInt(o[1]) : null, i = o[2] ? parseInt(o[2]) : null;
+  return {
+    year: i === null ? s : i * 100,
+    restDateString: e.slice((o[1] || o[2]).length)
+  };
+}
+function _t(e, n) {
+  if (n === null) return /* @__PURE__ */ new Date(NaN);
+  const t = e.match(zt);
+  if (!t) return /* @__PURE__ */ new Date(NaN);
+  const o = !!t[4], s = we(t[1]), i = we(t[2]) - 1, r = we(t[3]), l = we(t[4]), f = we(t[5]) - 1;
+  if (o)
+    return Ut(n, l, f) ? Pt(n, l, f) : /* @__PURE__ */ new Date(NaN);
+  {
+    const x = /* @__PURE__ */ new Date(0);
+    return !Lt(n, i, r) || !Wt(n, s) ? /* @__PURE__ */ new Date(NaN) : (x.setUTCFullYear(n, i, Math.max(s, r)), x);
+  }
+}
+function we(e) {
+  return e ? parseInt(e) : 1;
+}
+function Nt(e) {
+  const n = e.match(jt);
+  if (!n) return NaN;
+  const t = Re(n[1]), o = Re(n[2]), s = Re(n[3]);
+  return Kt(t, o, s) ? t * Ge + o * Xe + s * 1e3 : NaN;
+}
+function Re(e) {
+  return e && parseFloat(e.replace(",", ".")) || 0;
+}
+function Ft(e) {
+  if (e === "Z") return 0;
+  const n = e.match(Ot);
+  if (!n) return 0;
+  const t = n[1] === "+" ? -1 : 1, o = parseInt(n[2]), s = n[3] && parseInt(n[3]) || 0;
+  return Bt(o, s) ? t * (o * Ge + s * Xe) : NaN;
+}
+function Pt(e, n, t) {
+  const o = /* @__PURE__ */ new Date(0);
+  o.setUTCFullYear(e, 0, 4);
+  const s = o.getUTCDay() || 7, i = (n - 1) * 7 + t + 1 - s;
+  return o.setUTCDate(o.getUTCDate() + i), o;
+}
+const Vt = [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function tt(e) {
+  return e % 400 === 0 || e % 4 === 0 && e % 100 !== 0;
+}
+function Lt(e, n, t) {
+  return n >= 0 && n <= 11 && t >= 1 && t <= (Vt[n] || (tt(e) ? 29 : 28));
+}
+function Wt(e, n) {
+  return n >= 1 && n <= (tt(e) ? 366 : 365);
+}
+function Ut(e, n, t) {
+  return n >= 1 && n <= 53 && t >= 0 && t <= 6;
+}
+function Kt(e, n, t) {
+  return e === 24 ? n === 0 && t === 0 : t >= 0 && t < 60 && n >= 0 && n < 60 && e >= 0 && e < 25;
+}
+function Bt(e, n) {
+  return n >= 0 && n <= 59;
+}
+function ge(e, n, t) {
+  let o = t.initialDeps ?? [], s;
+  function i() {
+    var r, l, f, x;
+    let d;
+    t.key && ((r = t.debug) != null && r.call(t)) && (d = Date.now());
+    const v = e();
+    if (!(v.length !== o.length || v.some((a, h) => o[h] !== a)))
+      return s;
+    o = v;
+    let g;
+    if (t.key && ((l = t.debug) != null && l.call(t)) && (g = Date.now()), s = n(...v), t.key && ((f = t.debug) != null && f.call(t))) {
+      const a = Math.round((Date.now() - d) * 100) / 100, h = Math.round((Date.now() - g) * 100) / 100, c = h / 16, y = (p, w) => {
+        for (p = String(p); p.length < w; )
+          p = " " + p;
+        return p;
+      };
+      console.info(
+        `%c⏱ ${y(h, 5)} /${y(a, 5)} ms`,
+        `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(
+          0,
+          Math.min(120 - 120 * c, 120)
+        )}deg 100% 31%);`,
+        t == null ? void 0 : t.key
+      );
+    }
+    return (x = t == null ? void 0 : t.onChange) == null || x.call(t, s), s;
+  }
+  return i.updateDeps = (r) => {
+    o = r;
+  }, i;
+}
+function ke(e, n) {
+  if (e === void 0)
+    throw new Error("Unexpected undefined");
+  return e;
+}
+const Ht = (e, n) => Math.abs(e - n) < 1, qt = (e, n, t) => {
+  let o;
+  return function(...s) {
+    e.clearTimeout(o), o = e.setTimeout(() => n.apply(this, s), t);
+  };
+}, Yt = (e) => e, Zt = (e) => {
+  const n = Math.max(e.startIndex - e.overscan, 0), t = Math.min(e.endIndex + e.overscan, e.count - 1), o = [];
+  for (let s = n; s <= t; s++)
+    o.push(s);
+  return o;
+}, Qt = (e, n) => {
+  const t = e.scrollElement;
+  if (!t)
+    return;
+  const o = e.targetWindow;
+  if (!o)
+    return;
+  const s = (r) => {
+    const { width: l, height: f } = r;
+    n({ width: Math.round(l), height: Math.round(f) });
+  };
+  if (s(t.getBoundingClientRect()), !o.ResizeObserver)
+    return () => {
+    };
+  const i = new o.ResizeObserver((r) => {
+    const l = () => {
+      const f = r[0];
+      if (f != null && f.borderBoxSize) {
+        const x = f.borderBoxSize[0];
+        if (x) {
+          s({ width: x.inlineSize, height: x.blockSize });
+          return;
+        }
+      }
+      s(t.getBoundingClientRect());
+    };
+    e.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(l) : l();
+  });
+  return i.observe(t, { box: "border-box" }), () => {
+    i.unobserve(t);
+  };
+}, Ke = {
+  passive: !0
+}, Be = typeof window > "u" ? !0 : "onscrollend" in window, Jt = (e, n) => {
+  const t = e.scrollElement;
+  if (!t)
+    return;
+  const o = e.targetWindow;
+  if (!o)
+    return;
+  let s = 0;
+  const i = e.options.useScrollendEvent && Be ? () => {
+  } : qt(
+    o,
+    () => {
+      n(s, !1);
+    },
+    e.options.isScrollingResetDelay
+  ), r = (d) => () => {
+    const { horizontal: v, isRtl: u } = e.options;
+    s = v ? t.scrollLeft * (u && -1 || 1) : t.scrollTop, i(), n(s, d);
+  }, l = r(!0), f = r(!1);
+  f(), t.addEventListener("scroll", l, Ke);
+  const x = e.options.useScrollendEvent && Be;
+  return x && t.addEventListener("scrollend", f, Ke), () => {
+    t.removeEventListener("scroll", l), x && t.removeEventListener("scrollend", f);
+  };
+}, Gt = (e, n, t) => {
+  if (n != null && n.borderBoxSize) {
+    const o = n.borderBoxSize[0];
+    if (o)
+      return Math.round(
+        o[t.options.horizontal ? "inlineSize" : "blockSize"]
+      );
+  }
+  return Math.round(
+    e.getBoundingClientRect()[t.options.horizontal ? "width" : "height"]
+  );
+}, Xt = (e, {
+  adjustments: n = 0,
+  behavior: t
+}, o) => {
+  var s, i;
+  const r = e + n;
+  (i = (s = o.scrollElement) == null ? void 0 : s.scrollTo) == null || i.call(s, {
+    [o.options.horizontal ? "left" : "top"]: r,
+    behavior: t
+  });
+};
+class en {
+  constructor(n) {
+    this.unsubs = [], this.scrollElement = null, this.targetWindow = null, this.isScrolling = !1, this.scrollToIndexTimeoutId = null, this.measurementsCache = [], this.itemSizeCache = /* @__PURE__ */ new Map(), this.pendingMeasuredCacheIndexes = [], this.scrollRect = null, this.scrollOffset = null, this.scrollDirection = null, this.scrollAdjustments = 0, this.elementsCache = /* @__PURE__ */ new Map(), this.observer = /* @__PURE__ */ (() => {
+      let t = null;
+      const o = () => t || (!this.targetWindow || !this.targetWindow.ResizeObserver ? null : t = new this.targetWindow.ResizeObserver((s) => {
+        s.forEach((i) => {
+          const r = () => {
+            this._measureElement(i.target, i);
+          };
+          this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(r) : r();
+        });
+      }));
+      return {
+        disconnect: () => {
+          var s;
+          (s = o()) == null || s.disconnect(), t = null;
+        },
+        observe: (s) => {
+          var i;
+          return (i = o()) == null ? void 0 : i.observe(s, { box: "border-box" });
+        },
+        unobserve: (s) => {
+          var i;
+          return (i = o()) == null ? void 0 : i.unobserve(s);
+        }
+      };
+    })(), this.range = null, this.setOptions = (t) => {
+      Object.entries(t).forEach(([o, s]) => {
+        typeof s > "u" && delete t[o];
+      }), this.options = {
+        debug: !1,
+        initialOffset: 0,
+        overscan: 1,
+        paddingStart: 0,
+        paddingEnd: 0,
+        scrollPaddingStart: 0,
+        scrollPaddingEnd: 0,
+        horizontal: !1,
+        getItemKey: Yt,
+        rangeExtractor: Zt,
+        onChange: () => {
+        },
+        measureElement: Gt,
+        initialRect: { width: 0, height: 0 },
+        scrollMargin: 0,
+        gap: 0,
+        indexAttribute: "data-index",
+        initialMeasurementsCache: [],
+        lanes: 1,
+        isScrollingResetDelay: 150,
+        enabled: !0,
+        isRtl: !1,
+        useScrollendEvent: !1,
+        useAnimationFrameWithResizeObserver: !1,
+        ...t
+      };
+    }, this.notify = (t) => {
+      var o, s;
+      (s = (o = this.options).onChange) == null || s.call(o, this, t);
+    }, this.maybeNotify = ge(
+      () => (this.calculateRange(), [
+        this.isScrolling,
+        this.range ? this.range.startIndex : null,
+        this.range ? this.range.endIndex : null
+      ]),
+      (t) => {
+        this.notify(t);
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "maybeNotify",
+        debug: () => this.options.debug,
+        initialDeps: [
+          this.isScrolling,
+          this.range ? this.range.startIndex : null,
+          this.range ? this.range.endIndex : null
+        ]
+      }
+    ), this.cleanup = () => {
+      this.unsubs.filter(Boolean).forEach((t) => t()), this.unsubs = [], this.observer.disconnect(), this.scrollElement = null, this.targetWindow = null;
+    }, this._didMount = () => () => {
+      this.cleanup();
+    }, this._willUpdate = () => {
+      var t;
+      const o = this.options.enabled ? this.options.getScrollElement() : null;
+      if (this.scrollElement !== o) {
+        if (this.cleanup(), !o) {
+          this.maybeNotify();
+          return;
+        }
+        this.scrollElement = o, this.scrollElement && "ownerDocument" in this.scrollElement ? this.targetWindow = this.scrollElement.ownerDocument.defaultView : this.targetWindow = ((t = this.scrollElement) == null ? void 0 : t.window) ?? null, this.elementsCache.forEach((s) => {
+          this.observer.observe(s);
+        }), this._scrollToOffset(this.getScrollOffset(), {
+          adjustments: void 0,
+          behavior: void 0
+        }), this.unsubs.push(
+          this.options.observeElementRect(this, (s) => {
+            this.scrollRect = s, this.maybeNotify();
+          })
+        ), this.unsubs.push(
+          this.options.observeElementOffset(this, (s, i) => {
+            this.scrollAdjustments = 0, this.scrollDirection = i ? this.getScrollOffset() < s ? "forward" : "backward" : null, this.scrollOffset = s, this.isScrolling = i, this.maybeNotify();
+          })
+        );
+      }
+    }, this.getSize = () => this.options.enabled ? (this.scrollRect = this.scrollRect ?? this.options.initialRect, this.scrollRect[this.options.horizontal ? "width" : "height"]) : (this.scrollRect = null, 0), this.getScrollOffset = () => this.options.enabled ? (this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset == "function" ? this.options.initialOffset() : this.options.initialOffset), this.scrollOffset) : (this.scrollOffset = null, 0), this.getFurthestMeasurement = (t, o) => {
+      const s = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+      for (let r = o - 1; r >= 0; r--) {
+        const l = t[r];
+        if (s.has(l.lane))
+          continue;
+        const f = i.get(
+          l.lane
+        );
+        if (f == null || l.end > f.end ? i.set(l.lane, l) : l.end < f.end && s.set(l.lane, !0), s.size === this.options.lanes)
+          break;
+      }
+      return i.size === this.options.lanes ? Array.from(i.values()).sort((r, l) => r.end === l.end ? r.index - l.index : r.end - l.end)[0] : void 0;
+    }, this.getMeasurementOptions = ge(
+      () => [
+        this.options.count,
+        this.options.paddingStart,
+        this.options.scrollMargin,
+        this.options.getItemKey,
+        this.options.enabled
+      ],
+      (t, o, s, i, r) => (this.pendingMeasuredCacheIndexes = [], {
+        count: t,
+        paddingStart: o,
+        scrollMargin: s,
+        getItemKey: i,
+        enabled: r
+      }),
+      {
+        key: !1
+      }
+    ), this.getMeasurements = ge(
+      () => [this.getMeasurementOptions(), this.itemSizeCache],
+      ({ count: t, paddingStart: o, scrollMargin: s, getItemKey: i, enabled: r }, l) => {
+        if (!r)
+          return this.measurementsCache = [], this.itemSizeCache.clear(), [];
+        this.measurementsCache.length === 0 && (this.measurementsCache = this.options.initialMeasurementsCache, this.measurementsCache.forEach((d) => {
+          this.itemSizeCache.set(d.key, d.size);
+        }));
+        const f = this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
+        this.pendingMeasuredCacheIndexes = [];
+        const x = this.measurementsCache.slice(0, f);
+        for (let d = f; d < t; d++) {
+          const v = i(d), u = this.options.lanes === 1 ? x[d - 1] : this.getFurthestMeasurement(x, d), g = u ? u.end + this.options.gap : o + s, a = l.get(v), h = typeof a == "number" ? a : this.options.estimateSize(d), c = g + h, y = u ? u.lane : d % this.options.lanes;
+          x[d] = {
+            index: d,
+            start: g,
+            size: h,
+            end: c,
+            key: v,
+            lane: y
+          };
+        }
+        return this.measurementsCache = x, x;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getMeasurements",
+        debug: () => this.options.debug
+      }
+    ), this.calculateRange = ge(
+      () => [
+        this.getMeasurements(),
+        this.getSize(),
+        this.getScrollOffset(),
+        this.options.lanes
+      ],
+      (t, o, s, i) => this.range = t.length > 0 && o > 0 ? tn({
+        measurements: t,
+        outerSize: o,
+        scrollOffset: s,
+        lanes: i
+      }) : null,
+      {
+        key: process.env.NODE_ENV !== "production" && "calculateRange",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualIndexes = ge(
+      () => {
+        let t = null, o = null;
+        const s = this.calculateRange();
+        return s && (t = s.startIndex, o = s.endIndex), this.maybeNotify.updateDeps([this.isScrolling, t, o]), [
+          this.options.rangeExtractor,
+          this.options.overscan,
+          this.options.count,
+          t,
+          o
+        ];
+      },
+      (t, o, s, i, r) => i === null || r === null ? [] : t({
+        startIndex: i,
+        endIndex: r,
+        overscan: o,
+        count: s
+      }),
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+        debug: () => this.options.debug
+      }
+    ), this.indexFromElement = (t) => {
+      const o = this.options.indexAttribute, s = t.getAttribute(o);
+      return s ? parseInt(s, 10) : (console.warn(
+        `Missing attribute name '${o}={index}' on measured element.`
+      ), -1);
+    }, this._measureElement = (t, o) => {
+      const s = this.indexFromElement(t), i = this.measurementsCache[s];
+      if (!i)
+        return;
+      const r = i.key, l = this.elementsCache.get(r);
+      l !== t && (l && this.observer.unobserve(l), this.observer.observe(t), this.elementsCache.set(r, t)), t.isConnected && this.resizeItem(s, this.options.measureElement(t, o, this));
+    }, this.resizeItem = (t, o) => {
+      const s = this.measurementsCache[t];
+      if (!s)
+        return;
+      const i = this.itemSizeCache.get(s.key) ?? s.size, r = o - i;
+      r !== 0 && ((this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(s, r, this) : s.start < this.getScrollOffset() + this.scrollAdjustments) && (process.env.NODE_ENV !== "production" && this.options.debug && console.info("correction", r), this._scrollToOffset(this.getScrollOffset(), {
+        adjustments: this.scrollAdjustments += r,
+        behavior: void 0
+      })), this.pendingMeasuredCacheIndexes.push(s.index), this.itemSizeCache = new Map(this.itemSizeCache.set(s.key, o)), this.notify(!1));
+    }, this.measureElement = (t) => {
+      if (!t) {
+        this.elementsCache.forEach((o, s) => {
+          o.isConnected || (this.observer.unobserve(o), this.elementsCache.delete(s));
+        });
+        return;
+      }
+      this._measureElement(t, void 0);
+    }, this.getVirtualItems = ge(
+      () => [this.getVirtualIndexes(), this.getMeasurements()],
+      (t, o) => {
+        const s = [];
+        for (let i = 0, r = t.length; i < r; i++) {
+          const l = t[i], f = o[l];
+          s.push(f);
+        }
+        return s;
+      },
+      {
+        key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+        debug: () => this.options.debug
+      }
+    ), this.getVirtualItemForOffset = (t) => {
+      const o = this.getMeasurements();
+      if (o.length !== 0)
+        return ke(
+          o[nt(
+            0,
+            o.length - 1,
+            (s) => ke(o[s]).start,
+            t
+          )]
+        );
+    }, this.getOffsetForAlignment = (t, o, s = 0) => {
+      const i = this.getSize(), r = this.getScrollOffset();
+      o === "auto" && (o = t >= r + i ? "end" : "start"), o === "center" ? t += (s - i) / 2 : o === "end" && (t -= i);
+      const l = this.options.horizontal ? "scrollWidth" : "scrollHeight", x = (this.scrollElement ? "document" in this.scrollElement ? this.scrollElement.document.documentElement[l] : this.scrollElement[l] : 0) - i;
+      return Math.max(Math.min(x, t), 0);
+    }, this.getOffsetForIndex = (t, o = "auto") => {
+      t = Math.max(0, Math.min(t, this.options.count - 1));
+      const s = this.measurementsCache[t];
+      if (!s)
+        return;
+      const i = this.getSize(), r = this.getScrollOffset();
+      if (o === "auto")
+        if (s.end >= r + i - this.options.scrollPaddingEnd)
+          o = "end";
+        else if (s.start <= r + this.options.scrollPaddingStart)
+          o = "start";
+        else
+          return [r, o];
+      const l = o === "end" ? s.end + this.options.scrollPaddingEnd : s.start - this.options.scrollPaddingStart;
+      return [
+        this.getOffsetForAlignment(l, o, s.size),
+        o
+      ];
+    }, this.isDynamicMode = () => this.elementsCache.size > 0, this.cancelScrollToIndex = () => {
+      this.scrollToIndexTimeoutId !== null && this.targetWindow && (this.targetWindow.clearTimeout(this.scrollToIndexTimeoutId), this.scrollToIndexTimeoutId = null);
+    }, this.scrollToOffset = (t, { align: o = "start", behavior: s } = {}) => {
+      this.cancelScrollToIndex(), s === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getOffsetForAlignment(t, o), {
+        adjustments: void 0,
+        behavior: s
+      });
+    }, this.scrollToIndex = (t, { align: o = "auto", behavior: s } = {}) => {
+      t = Math.max(0, Math.min(t, this.options.count - 1)), this.cancelScrollToIndex(), s === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      );
+      const i = this.getOffsetForIndex(t, o);
+      if (!i) return;
+      const [r, l] = i;
+      this._scrollToOffset(r, { adjustments: void 0, behavior: s }), s !== "smooth" && this.isDynamicMode() && this.targetWindow && (this.scrollToIndexTimeoutId = this.targetWindow.setTimeout(() => {
+        if (this.scrollToIndexTimeoutId = null, this.elementsCache.has(
+          this.options.getItemKey(t)
+        )) {
+          const [x] = ke(
+            this.getOffsetForIndex(t, l)
+          );
+          Ht(x, this.getScrollOffset()) || this.scrollToIndex(t, { align: l, behavior: s });
+        } else
+          this.scrollToIndex(t, { align: l, behavior: s });
+      }));
+    }, this.scrollBy = (t, { behavior: o } = {}) => {
+      this.cancelScrollToIndex(), o === "smooth" && this.isDynamicMode() && console.warn(
+        "The `smooth` scroll behavior is not fully supported with dynamic size."
+      ), this._scrollToOffset(this.getScrollOffset() + t, {
+        adjustments: void 0,
+        behavior: o
+      });
+    }, this.getTotalSize = () => {
+      var t;
+      const o = this.getMeasurements();
+      let s;
+      if (o.length === 0)
+        s = this.options.paddingStart;
+      else if (this.options.lanes === 1)
+        s = ((t = o[o.length - 1]) == null ? void 0 : t.end) ?? 0;
+      else {
+        const i = Array(this.options.lanes).fill(null);
+        let r = o.length - 1;
+        for (; r >= 0 && i.some((l) => l === null); ) {
+          const l = o[r];
+          i[l.lane] === null && (i[l.lane] = l.end), r--;
+        }
+        s = Math.max(...i.filter((l) => l !== null));
+      }
+      return Math.max(
+        s - this.options.scrollMargin + this.options.paddingEnd,
+        0
+      );
+    }, this._scrollToOffset = (t, {
+      adjustments: o,
+      behavior: s
+    }) => {
+      this.options.scrollToFn(t, { behavior: s, adjustments: o }, this);
+    }, this.measure = () => {
+      this.itemSizeCache = /* @__PURE__ */ new Map(), this.notify(!1);
+    }, this.setOptions(n);
+  }
+}
+const nt = (e, n, t, o) => {
+  for (; e <= n; ) {
+    const s = (e + n) / 2 | 0, i = t(s);
+    if (i < o)
+      e = s + 1;
+    else if (i > o)
+      n = s - 1;
+    else
+      return s;
+  }
+  return e > 0 ? e - 1 : 0;
+};
+function tn({
+  measurements: e,
+  outerSize: n,
+  scrollOffset: t,
+  lanes: o
+}) {
+  const s = e.length - 1, i = (f) => e[f].start;
+  if (e.length <= o)
+    return {
+      startIndex: 0,
+      endIndex: s
+    };
+  let r = nt(
+    0,
+    s,
+    i,
+    t
+  ), l = r;
+  if (o === 1)
+    for (; l < s && e[l].end < t + n; )
+      l++;
+  else if (o > 1) {
+    const f = Array(o).fill(0);
+    for (; l < s && f.some((d) => d < t + n); ) {
+      const d = e[l];
+      f[d.lane] = d.end, l++;
+    }
+    const x = Array(o).fill(t + n);
+    for (; r >= 0 && x.some((d) => d >= t); ) {
+      const d = e[r];
+      x[d.lane] = d.start, r--;
+    }
+    r = Math.max(0, r - r % o), l = Math.min(s, l + (o - 1 - l % o));
+  }
+  return { startIndex: r, endIndex: l };
+}
+const He = typeof document < "u" ? Ce.useLayoutEffect : Ce.useEffect;
+function nn(e) {
+  const n = Ce.useReducer(() => ({}), {})[1], t = {
+    ...e,
+    onChange: (s, i) => {
+      var r;
+      i ? yt(n) : n(), (r = e.onChange) == null || r.call(e, s, i);
+    }
+  }, [o] = Ce.useState(
+    () => new en(t)
+  );
+  return o.setOptions(t), He(() => o._didMount(), []), He(() => o._willUpdate()), o;
+}
+function ot(e) {
+  return nn({
+    observeElementRect: Qt,
+    observeElementOffset: Jt,
+    scrollToFn: Xt,
+    ...e
+  });
+}
+const on = N.div`
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background-color: #ffffff;
+
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+`, sn = le(
+  ({ color: e, ...n }, t) => /* @__PURE__ */ A.jsx(on, { style: { backgroundColor: e }, ...n, ref: t })
+), rn = N.input`
+  z-index: 10;
+  border: none;
+  outline: none;
+  padding: 0;
+  padding-left: 1px;
+  margin: 0;
+  cursor: text;
+  font-size: inherit;
+  font-family: inherit;
+  font-weight: inherit;
+  background-color: transparent;
+  width: 100%;
+  box-sizing: border-box;
+`, ln = le(
+  ({ value: e, onChange: n, onCancel: t, autoFocus: o = !0, ...s }, i) => {
+    const [r, l] = Q(() => {
+      if (e) {
+        const g = Ue(e);
+        if (Se(g))
+          return Oe(g, "yyyy-MM-dd");
+      }
+      return "";
+    });
+    J(() => {
+      if (e) {
+        const g = Ue(e);
+        Se(g) ? l(Oe(g, "yyyy-MM-dd")) : l("");
+      }
+    }, [e]);
+    const f = re(null);
+    J(() => {
+      o && f.current && (f.current.focus(), setTimeout(() => {
+        var g;
+        try {
+          (g = f.current) == null || g.showPicker();
+        } catch (a) {
+          console.debug("Date picker could not be shown automatically:", a);
+        }
+      }, 100));
+    }, [o]);
+    const x = (g) => {
+      var a;
+      g.preventDefault();
+      try {
+        (a = f.current) == null || a.showPicker();
+      } catch (h) {
+        console.debug("Date picker could not be shown on click:", h);
+      }
+    }, d = (g) => {
+      if (r) {
+        const a = Date.parse(r);
+        if (Se(a)) {
+          const h = new Date(a);
+          return h.setUTCHours(0, 0, 0, 0), n(h.toISOString(), g), !0;
+        }
+      }
+      return !1;
+    }, v = () => {
+      d("Click") || t == null || t();
+    }, u = (g) => {
+      var a;
+      g.key === "Enter" ? (g.preventDefault(), d("Enter"), (a = f.current) == null || a.blur()) : g.key === "Escape" && (g.preventDefault(), t == null || t());
+    };
+    return /* @__PURE__ */ A.jsx(
+      rn,
+      {
+        ...s,
+        ref: f,
+        type: "date",
+        value: r,
+        onChange: (g) => l(g.target.value),
+        onBlur: v,
+        onKeyDown: u,
+        onClick: x
+      }
+    );
+  }
+), an = le(
+  ({ value: e, isEditing: n, isReadOnly: t, isInherited: o, onChange: s, onCancelEdit: i, ...r }, l) => {
+    let f = "";
+    try {
+      f = Oe(new Date(e), "dd-MM-yyyy");
+    } catch {
+      console.error("Invalid date value:", e), f = "Invalid Date";
+    }
+    return n ? /* @__PURE__ */ A.jsx(
+      ln,
+      {
+        value: e,
+        onChange: s,
+        onCancel: i,
+        readOnly: t,
+        disabled: t,
+        ...r
+      }
+    ) : /* @__PURE__ */ A.jsx("span", { ...r, ref: l, children: f });
+  }
+), dn = N.div`
+  display: flex;
+  gap: var(--base-gap-small);
+  align-items: center;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  border-radius: var(--border-radius-m);
+  padding: 0 2px;
+  cursor: pointer;
+
+  &:hover {
+    background-color: var(--md-sys-color-surface-container-high-hover);
+  }
+
+  &.item {
+    padding: 4px 2px;
+    border-radius: 0;
+
+    &:hover {
+      background-color: var(--md-sys-color-surface-container-hover);
+    }
+  }
+
+  &.selected {
+    background-color: var(--md-sys-color-primary-container);
+
+    &:hover {
+      background-color: var(--md-sys-color-primary-container-hover);
+    }
+  }
+`, cn = N.div`
+  display: flex;
+  gap: var(--base-gap-small);
+  align-items: center;
+  overflow: hidden;
+  border-radius: var(--border-radius-m);
+`, un = N.div`
+  display: flex;
+  gap: var(--base-gap-small);
+  align-items: center;
+
+  overflow: hidden;
+  max-width: 100%;
+  min-width: 20px;
+`, hn = N.span`
+  /* push expand icon to the end */
+  flex: 1;
+  overflow: hidden;
+  white-space: nowrap;
+  width: 100%;
+  text-overflow: ellipsis;
+  text-align: left;
+  border-radius: var(--border-radius-m);
+  padding: 0px 2px;
+  text-align: center;
+
+  &.placeholder {
+    color: var(--md-sys-color-outline);
+  }
+`, fn = N.img`
+  width: 20px;
+  height: 20px;
+  object-fit: cover;
+
+  &.avatar {
+    border-radius: 50%;
+  }
+`, gn = N(ae)`
+  margin-left: auto;
+  transition: rotate 0.2s;
+`, mn = N(At)`
+  height: 100%;
+  width: 100%;
+`, pn = (e = "") => e.startsWith("/") || e.startsWith("./") || e.startsWith("../") || e.startsWith("http://") || e.startsWith("https://"), yn = (e) => e.includes("avatar"), wn = le(
+  ({
+    value: e,
+    isEditing: n,
+    options: t,
+    type: o,
+    autoOpen: s = !0,
+    isReadOnly: i,
+    enableCustomValues: r,
+    onOpen: l,
+    onChange: f,
+    onCancelEdit: x,
+    onNext: d,
+    pt: v,
+    ...u
+  }, g) => {
+    var D;
+    const a = e.map((b) => b == null ? void 0 : b.toString()).filter((b) => !!b);
+    let h = t.filter(
+      (b) => a.includes(b.value.toString())
+    );
+    a.forEach((b) => {
+      t.find((I) => I.value === b) || (h = [
+        ...h,
+        {
+          label: b,
+          value: b,
+          color: r ? "var(--md-sys-color-surface-container)" : "var(--md-sys-color-error)",
+          icon: r ? void 0 : "warning"
+        }
+      ]);
+    });
+    const c = h.length > 1, y = re(null), p = (b) => {
+      b.target instanceof HTMLElement && b.target.closest(".expand") && l && !i && (l(), b.stopPropagation());
+    }, [w, m] = Q(!1);
+    J(() => {
+      var b;
+      n && y.current && s ? (!y.current.isOpen && ((b = y.current) == null || b.open()), m(!0)) : m(!1);
+    }, [n, y.current, s]), J(() => {
+      var b;
+      if (w) {
+        const I = (b = y.current) == null ? void 0 : b.getOptions(), C = I == null ? void 0 : I.querySelector("li");
+        C && (C.focus(), C.style.outline = "none");
+      }
+    }, [w]);
+    const E = !!(o != null && o.includes("list")), k = (b) => {
+      const I = r ? b : b.filter((C) => t.find((S) => S.value === C));
+      o != null && o.includes("list") ? f(I, "Click") : f(I[0], "Click");
+    };
+    return n ? /* @__PURE__ */ A.jsx(
+      mn,
+      {
+        options: t,
+        value: a,
+        ref: y,
+        valueTemplate: (b, I, C) => {
+          var S;
+          return /* @__PURE__ */ A.jsx(
+            De,
+            {
+              selectedOptions: h,
+              hasMultipleValues: I.length > 1,
+              isOpen: C,
+              isReadOnly: i,
+              isMultiSelect: E,
+              ...v == null ? void 0 : v.template,
+              placeholder: u.placeholder,
+              className: q("enum-dropdown-value", (S = v == null ? void 0 : v.template) == null ? void 0 : S.className)
+            }
+          );
+        },
+        itemTemplate: (b, I, C) => {
+          var S;
+          return /* @__PURE__ */ A.jsx(
+            De,
+            {
+              selectedOptions: [b],
+              hasMultipleValues: !1,
+              isOpen: !1,
+              isItem: !0,
+              isSelected: C,
+              ...v == null ? void 0 : v.template,
+              className: q("enum-dropdown-item", (S = v == null ? void 0 : v.template) == null ? void 0 : S.className)
+            }
+          );
+        },
+        widthExpand: !0,
+        multiSelect: E,
+        disableOpen: i,
+        disabled: i,
+        sortBySelected: !0,
+        ...u,
+        onChange: k,
+        onClose: x
+      }
+    ) : /* @__PURE__ */ A.jsx(
+      De,
+      {
+        selectedOptions: h,
+        hasMultipleValues: c,
+        onClick: p,
+        isMultiSelect: E,
+        isReadOnly: i,
+        ...v == null ? void 0 : v.template,
+        placeholder: u.placeholder,
+        className: q("enum-value", (D = v == null ? void 0 : v.template) == null ? void 0 : D.className, u.className)
+      }
+    );
+  }
+), De = ({
+  selectedOptions: e,
+  placeholder: n,
+  hasMultipleValues: t,
+  isMultiSelect: o,
+  isOpen: s,
+  isItem: i,
+  isSelected: r,
+  isReadOnly: l,
+  className: f,
+  ...x
+}) => {
+  const d = e.every((a) => a.icon), v = !t || !d, u = !d && o && !i, g = !e.length && n;
+  return g && (e = [
+    {
+      label: n,
+      value: ""
+    }
+  ]), /* @__PURE__ */ A.jsxs(dn, { className: q(f, { selected: r, item: i }), ...x, children: [
+    /* @__PURE__ */ A.jsx(cn, { children: e.map((a, h) => /* @__PURE__ */ A.jsxs(un, { children: [
+      a.icon && pn(a.icon) ? /* @__PURE__ */ A.jsx(
+        fn,
+        {
+          src: a.icon,
+          className: q({ avatar: yn(a.icon) })
+        }
+      ) : a.icon ? /* @__PURE__ */ A.jsx(ae, { icon: a.icon, style: { color: a.color } }) : null,
+      (v || !a.icon) && /* @__PURE__ */ A.jsx(
+        hn,
+        {
+          style: {
+            color: u ? "inherit" : a.color,
+            backgroundColor: u ? a.color || "var(--md-sys-color-surface-container)" : "transparent"
+          },
+          className: q({ placeholder: g }),
+          children: a.label
+        }
+      )
+    ] }, a.value.toString() + h)) }),
+    !i && !l && /* @__PURE__ */ A.jsx(
+      gn,
+      {
+        className: "expand",
+        icon: "expand_more",
+        style: { rotate: s ? "180deg" : "0" }
+      }
+    )
+  ] });
+}, bn = N.input`
+  z-index: 10;
+  border: none;
+  outline: none;
+  padding: 0;
+  padding-left: 1px;
+  margin: 0;
+  cursor: text;
+  font-size: inherit;
+  font-family: inherit;
+  font-weight: inherit;
+  background-color: transparent;
+  width: 100%;
+  box-sizing: border-box;
+`, xn = le(
+  ({ value: e, onChange: n, onCancel: t, autoFocus: o = !0, ...s }, i) => {
+    const [r, l] = Q(e), f = re(null), x = re(!1);
+    J(() => {
+      o && f && f.current && (f.current.focus(), f.current.select());
+    }, [o]);
+    const d = (u) => {
+      u.key === "Enter" ? (u.preventDefault(), n(r, "Enter")) : u.key === "Escape" && (u.preventDefault(), u.stopPropagation(), x.current = !0, t == null || t());
+    }, v = (u) => {
+      var g;
+      ((g = u.relatedTarget) == null ? void 0 : g.tagName) !== "INPUT" && (x.current || n(r, "Click"), x.current = !1);
+    };
+    return /* @__PURE__ */ A.jsx(
+      bn,
+      {
+        ...s,
+        ref: f,
+        value: r,
+        onChange: (u) => l(u.target.value),
+        onKeyDown: d,
+        onBlur: v
+      }
+    );
+  }
+), In = N.span`
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+`, qe = le(
+  ({ value: e, isEditing: n, isInherited: t, onChange: o, onCancelEdit: s, ...i }, r) => n ? /* @__PURE__ */ A.jsx(xn, { value: e, onChange: o, onCancel: s, type: "text" }) : /* @__PURE__ */ A.jsx(In, { ...i, ref: r, children: e })
+), vn = N.input`
+  margin: auto;
+  z-index: 1;
+  cursor: pointer;
+
+  width: 16px;
+  height: 16px;
+  background-color: transparent;
+  border: 1px solid var(--md-sys-color-outline);
+  appearance: none;
+  border-radius: 2px;
+
+  &:hover {
+    border-color: hsl(212.31deg 16.83% 74.65%);
+  }
+
+  &:checked {
+    background-color: var(--md-sys-color-primary);
+    border-color: var(--md-sys-color-primary);
+    appearance: auto;
+  }
+`, Cn = le(
+  ({ value: e, onChange: n, isReadOnly: t, isEditing: o, onCancelEdit: s, ...i }, r) => /* @__PURE__ */ A.jsx(
+    vn,
+    {
+      ...i,
+      checked: e,
+      onChange: (l) => n(l.target.checked),
+      ref: r,
+      type: "checkbox",
+      disabled: t,
+      readOnly: t
+    }
+  )
+), st = de(
+  void 0
+), Lo = ({
+  children: e,
+  updateEntities: n,
+  getFoldersTasks: t
+}) => /* @__PURE__ */ A.jsx(
+  st.Provider,
+  {
+    value: {
+      updateEntities: n,
+      getFoldersTasks: t
+    },
+    children: e
+  }
+), _e = () => {
+  const e = ce(st);
+  if (!e)
+    throw new Error(
+      "useProjectTableQueriesContext must be used within a ProjectTableQueriesProvider"
+    );
+  return e;
+}, $e = (e, n = 50, { type: t = "folder", parentId: o } = {}) => new Array(n).fill(0).map(
+  (s, i) => ({
+    id: `loading-${t}-${i}-${o}`,
+    name: "Loading...",
+    parentId: o,
+    isLoading: !0,
+    label: "Loading...",
+    color: null,
+    icon: null,
+    img: null,
+    entityType: t,
+    ownAttrib: [],
+    tags: [],
+    subRows: [],
+    path: "",
+    attrib: e.reduce((r, l) => (r[l.name] = null, r), {})
+  })
+), Tn = (e = 10) => Array(e).fill(null).map((n, t) => ({
+  name: `loading-attribute${t}`,
+  scope: ["folder", "task"],
+  data: {
+    type: "string"
+  },
+  position: t
+})), Wo = ({
+  expandedFoldersTasks: e,
+  expandedParentIds: n,
+  foldersMap: t
+}) => {
+  var f;
+  const o = e.map((x) => x.folderId), s = n.filter(
+    (x) => {
+      var d;
+      return (d = t.get(x)) == null ? void 0 : d.hasTasks;
+    }
+  ), i = new Set(o), r = /* @__PURE__ */ new Set();
+  for (const x of s)
+    i.has(x) || r.add(x);
+  const l = {};
+  for (const x of r) {
+    const d = t.get(x);
+    d && (l[x] = ((f = d.taskNames) == null ? void 0 : f.length) || 0);
+  }
+  return l;
+}, Sn = 100;
+function En({
+  foldersMap: e,
+  tasksMap: n,
+  tasksByFolderMap: t,
+  expanded: o,
+  folderTypes: s = [],
+  taskTypes: i = [],
+  showHierarchy: r,
+  loadingTasks: l = {},
+  isLoadingMore: f = !1
+}) {
+  const x = U(() => {
+    const c = /* @__PURE__ */ new Map();
+    for (const y of s)
+      c.set(y.name, y);
+    return c;
+  }, [s]), d = U(() => {
+    const c = /* @__PURE__ */ new Map();
+    for (const y of i)
+      c.set(y.name, y);
+    return c;
+  }, [i]), v = U(() => JSON.stringify(o), [o]), u = U(() => new Set(
+    Object.entries(o).filter(([c, y]) => y).map(([c]) => c)
+  ), [v]), { childToParentMap: g, parentToChildrenMap: a } = U(() => {
+    const c = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map();
+    for (const p of e.values()) {
+      if (!p.id) continue;
+      const w = p.parentId;
+      if (w) {
+        c.set(p.id, w);
+        let m = y.get(w);
+        m || (m = /* @__PURE__ */ new Set(), y.set(w, m)), m.add(p.id);
+      }
+    }
+    return { childToParentMap: c, parentToChildrenMap: y };
+  }, [e]), h = U(() => {
+    const c = /* @__PURE__ */ new Set(), y = [];
+    for (const p of e.values())
+      p.id && (!p.parentId || !e.has(p.parentId)) && (c.add(p.id), y.push(p.id));
+    for (; y.length > 0; ) {
+      const p = y.shift();
+      if (!u.has(p)) continue;
+      const m = a.get(p);
+      if (m)
+        for (const E of m)
+          c.has(E) || (c.add(E), y.push(E));
+    }
+    return c;
+  }, [e, a, u]);
+  return U(() => {
+    var w, m, E, k, D, b, I;
+    const c = (C, S) => {
+      var j, T;
+      return {
+        id: C.id,
+        entityType: "task",
+        parentId: S || C.folderId,
+        name: C.name || "",
+        label: C.label || C.name || "",
+        icon: ((j = d.get(C.taskType)) == null ? void 0 : j.icon) || null,
+        color: ((T = d.get(C.taskType)) == null ? void 0 : T.color) || null,
+        status: C.status,
+        assignees: C.assignees,
+        tags: C.tags,
+        img: null,
+        subRows: [],
+        subType: C.taskType || null,
+        attrib: C.attrib,
+        ownAttrib: C.ownAttrib,
+        path: C.folder.path
+      };
+    };
+    if (!r) {
+      const C = [];
+      for (const S of n.values())
+        S.id && C.push(c(S));
+      if (C.length > 1 && C.sort((S, j) => S.name < j.name ? -1 : S.name > j.name ? 1 : 0), f) {
+        const S = ((E = (m = (w = n.entries().next()) == null ? void 0 : w.value) == null ? void 0 : m[1]) == null ? void 0 : E.attrib) || {}, j = Object.keys(S).map((z) => ({
+          name: z
+        })), T = Sn;
+        {
+          const z = $e(j, T, {
+            type: "task"
+          });
+          C.push(...z);
+        }
+      }
+      return C;
+    }
+    const y = /* @__PURE__ */ new Map(), p = [];
+    for (const C of h) {
+      const S = e.get(C);
+      if (!S) continue;
+      const j = {
+        id: C,
+        entityType: "folder",
+        parentId: S.parentId || void 0,
+        name: S.name || "",
+        label: S.label || S.name || "",
+        icon: ((k = x.get(S.folderType)) == null ? void 0 : k.icon) || null,
+        color: null,
+        img: null,
+        subRows: [],
+        status: S.status,
+        tags: S.tags || [],
+        subType: S.folderType || null,
+        ownAttrib: S.ownAttrib || [],
+        path: S.path,
+        attrib: S.attrib || {},
+        childOnlyMatch: S.childOnlyMatch || !1
+      };
+      if (y.set(C, j), (!S.parentId || !e.has(S.parentId)) && p.push(j), u.has(C)) {
+        const z = (t.get(C) || []).flatMap((R) => n.get(R) || []);
+        if (z.length || l[C]) {
+          const R = new Array(z.length);
+          for (let O = 0; O < z.length; O++)
+            R[O] = c(z[O], C);
+          if (l[C]) {
+            const O = ((I = (b = (D = n.entries().next()) == null ? void 0 : D.value) == null ? void 0 : b[1]) == null ? void 0 : I.attrib) || {}, $ = Object.keys(O).map((_) => ({
+              name: _
+            })), F = l[C];
+            if (F > 0) {
+              const _ = $e($, F, {
+                type: "task",
+                parentId: C
+              });
+              R.push(..._);
+            }
+          }
+          R.length > 1 && R.sort((O, $) => O.name < $.name ? -1 : O.name > $.name ? 1 : 0), j.subRows = R;
+        }
+      }
+    }
+    for (const C of h) {
+      const S = g.get(C);
+      if (!S || !u.has(S)) continue;
+      const j = y.get(C), T = y.get(S);
+      !j || !T || T.subRows.push(j);
+    }
+    for (const C of u) {
+      const S = y.get(C);
+      if (!S || S.subRows.length <= 1) continue;
+      S.subRows.some((T) => T.entityType === "task") && S.subRows.some((T) => T.entityType === "folder") && S.subRows.sort((T, z) => {
+        const R = T.entityType === "task" ? 0 : 1, O = z.entityType === "task" ? 0 : 1;
+        return R !== O ? R - O : T.name < z.name ? -1 : T.name > z.name ? 1 : 0;
+      });
+    }
+    return p.length > 1 && p.sort((C, S) => C.name < S.name ? -1 : C.name > S.name ? 1 : 0), p;
+  }, [
+    e,
+    n,
+    h,
+    g,
+    u,
+    r,
+    d,
+    l,
+    f
+  ]);
+}
+function An({
+  foldersMap: e,
+  tasksMap: n,
+  tasksByFolderMap: t,
+  getEntityById: o,
+  projectAttrib: s,
+  attribFields: i
+}) {
+  const r = U(() => {
+    const g = /* @__PURE__ */ new Map();
+    for (const a of e.values()) {
+      const h = a.parentId;
+      h && (g.has(h) || g.set(h, []), g.get(h).push(a.id));
+    }
+    return g;
+  }, [e]), l = M(
+    (g) => {
+      const a = [], h = [g], c = /* @__PURE__ */ new Set();
+      for (; h.length > 0; ) {
+        const y = h.shift();
+        if (c.has(y)) continue;
+        if (c.add(y), y !== g) {
+          const m = e.get(y);
+          m && a.push({ ...m, entityType: "folder" });
+        }
+        const p = t.get(y);
+        if (p != null && p.length)
+          for (const m of p) {
+            const E = n.get(m);
+            E && a.push({ ...E, entityType: "task" });
+          }
+        const w = r.get(y);
+        w != null && w.length && h.push(...w);
+      }
+      return a;
+    },
+    [e, t, n, r]
+  ), f = M(
+    (g) => {
+      const a = [];
+      let h = g;
+      for (; ; ) {
+        const c = e.get(h);
+        if (!c || !c.parentId) break;
+        a.push(c.parentId), h = c.parentId;
+      }
+      return a;
+    },
+    [e]
+  ), x = M(
+    (g) => {
+      const a = n.get(g);
+      if (!a || !a.folderId) return [];
+      const h = [a.folderId], c = f(a.folderId);
+      return h.push(...c), h;
+    },
+    [n, f]
+  ), d = M(
+    (g, a) => {
+      var p;
+      if (!a.length) return {};
+      const h = {}, c = new Set(a);
+      let y = g;
+      for (; c.size > 0; ) {
+        const w = o(y);
+        if (!w || !y) {
+          for (const m of c)
+            s && m in s && (h[m] = s[m], c.delete(m));
+          break;
+        }
+        for (const m of Array.from(c))
+          (p = w.ownAttrib) != null && p.includes(m) && w.attrib && m in w.attrib && (h[m] = w.attrib[m], c.delete(m));
+        y = w.parentId;
+      }
+      for (const w of c)
+        h[w] = null;
+      return h;
+    },
+    [o]
+  ), v = M(
+    (g) => {
+      if (!g.length) return [];
+      const a = [], h = /* @__PURE__ */ new Map();
+      for (const c of g) {
+        if (c.entityType !== "folder") continue;
+        const y = Object.entries(c.attrib);
+        if (!y.length) continue;
+        const w = l(c.entityId).filter(
+          (m) => !g.find((E) => E.entityId === m.id)
+        );
+        if (w.length)
+          for (const m of w) {
+            const E = y.filter(
+              ([b]) => {
+                var I, C, S;
+                return !((I = m.ownAttrib) != null && I.includes(b)) && ((S = (C = i == null ? void 0 : i.find((j) => j.name === b)) == null ? void 0 : C.data) == null ? void 0 : S.inherit);
+              }
+            ), k = y.filter(
+              ([b]) => {
+                var I;
+                return (I = m.ownAttrib) == null ? void 0 : I.includes(b);
+              }
+            );
+            k.length && (h.has(m.id) || h.set(m.id, /* @__PURE__ */ new Set()), k.forEach(([b]) => {
+              h.get(m.id).add(b);
+            }));
+            const D = E.filter(([b]) => {
+              const I = m.entityType === "task" ? x(m.id) : f(m.id);
+              for (const C of I)
+                if (h.has(C) && h.get(C).has(b))
+                  return !1;
+              return !0;
+            });
+            if (D.length) {
+              const b = a.findIndex((I) => I.entityId === m.id);
+              b !== -1 ? a[b].attrib = {
+                ...a[b].attrib,
+                ...Object.fromEntries(D)
+              } : a.push({
+                entityId: m.id,
+                entityType: m.entityType || ("parentId" in m ? "folder" : "task"),
+                attrib: Object.fromEntries(D)
+              });
+            }
+          }
+      }
+      return a;
+    },
+    [l, n, x, f]
+  ), u = M(
+    (g, a, h) => {
+      var p;
+      const c = o(g);
+      if (!c) return null;
+      let y = a === "task" ? c.folderId : c.parentId;
+      for (; y; ) {
+        const w = o(y);
+        if (!w) break;
+        if ((p = w.ownAttrib) != null && p.includes(h) && w.attrib && h in w.attrib)
+          return w.attrib[h];
+        y = w.parentId;
+      }
+      return null;
+    },
+    [o]
+  );
+  return {
+    folderChildrenMap: r,
+    getChildrenEntities: l,
+    getInheritedDependents: v,
+    findInheritedValueFromAncestors: u,
+    findNonInheritedValues: d,
+    getAncestorsOf: f
+  };
+}
+const it = de(void 0), Uo = ({
+  children: e,
+  foldersMap: n,
+  tasksMap: t,
+  tasksByFolderMap: o,
+  expanded: s,
+  projectInfo: i,
+  showHierarchy: r,
+  loadingTasks: l,
+  isLoadingMore: f,
+  isLoading: x,
+  isInitialized: d,
+  projectName: v,
+  users: u,
+  attribFields: g,
+  filters: a,
+  setFilters: h,
+  queryFilters: c,
+  updateShowHierarchy: y,
+  toggleExpanded: p,
+  updateExpanded: w,
+  sorting: m,
+  updateSorting: E,
+  fetchNextPage: k,
+  reloadTableData: D,
+  setExpanded: b
+}) => {
+  const { folderTypes: I, taskTypes: C } = i || {}, S = En({
+    foldersMap: n,
+    tasksMap: t,
+    tasksByFolderMap: o,
+    expanded: s,
+    folderTypes: I,
+    taskTypes: C,
+    showHierarchy: r,
+    loadingTasks: l,
+    isLoadingMore: f
+  }), j = M(
+    (_) => {
+      if (n.has(_))
+        return { ...n.get(_), entityType: "folder" };
+      if (t.has(_))
+        return { ...t.get(_), entityType: "task" };
+    },
+    [n, t]
+  ), {
+    getInheritedDependents: T,
+    getChildrenEntities: z,
+    findInheritedValueFromAncestors: R,
+    findNonInheritedValues: O,
+    getAncestorsOf: $
+  } = An({
+    foldersMap: n,
+    tasksMap: t,
+    tasksByFolderMap: o,
+    getEntityById: j,
+    projectAttrib: i == null ? void 0 : i.attrib,
+    attribFields: g
+  }), F = M(
+    (_, K) => {
+      const L = typeof s == "object" ? s : {}, W = { ...L };
+      _.forEach((P) => {
+        const ee = z(P).map((Y) => Y.id), G = L[P] || !1;
+        (K !== void 0 ? !K : G) ? (W[P] = !1, ee.forEach((Y) => {
+          W[Y] = !1;
+        })) : (W[P] = !0, ee.forEach((Y) => {
+          W[Y] = !0;
+        }));
+      }), b(W);
+    },
+    [s, z, b]
+  );
+  return /* @__PURE__ */ A.jsx(
+    it.Provider,
+    {
+      value: {
+        // from this context
+        tableData: S,
+        // forwarded on
+        isInitialized: d,
+        isLoading: x,
+        projectInfo: i,
+        attribFields: g,
+        users: u,
+        projectName: v,
+        tasksMap: t,
+        foldersMap: n,
+        fetchNextPage: k,
+        reloadTableData: D,
+        // filters
+        filters: a,
+        setFilters: h,
+        queryFilters: c,
+        // hierarchy
+        showHierarchy: r,
+        updateShowHierarchy: y,
+        // expanded state
+        expanded: s,
+        toggleExpanded: p,
+        updateExpanded: w,
+        toggleExpandAll: F,
+        // sorting
+        sorting: m,
+        updateSorting: E,
+        getEntityById: j,
+        // folder relationships
+        getInheritedDependents: T,
+        findInheritedValueFromAncestors: R,
+        findNonInheritedValues: O,
+        getAncestorsOf: $
+      },
+      children: e
+    }
+  );
+}, ue = () => {
+  const e = ce(it);
+  if (!e)
+    throw new Error("useProjectTableContext must be used within a ProjectTableProvider");
+  return e;
+}, Rn = (e) => {
+  const { pushHistory: n } = e || {}, {
+    getEntityById: t,
+    projectName: o,
+    getInheritedDependents: s,
+    findInheritedValueFromAncestors: i,
+    findNonInheritedValues: r
+  } = ue(), { updateEntities: l } = _e(), f = M(
+    async (d = [], v = !0) => {
+      var y;
+      if (!d.length || !o)
+        return;
+      if (n && v) {
+        const p = d.map(
+          ({ id: m, type: E, field: k, isAttrib: D }) => {
+            var j;
+            const b = t(m), I = D ? ((j = b.attrib) == null ? void 0 : j[k]) ?? null : b[k] ?? null, C = (b == null ? void 0 : b.ownAttrib) || [], S = D && !C.includes(k);
+            return {
+              id: m,
+              type: E,
+              field: k,
+              value: I,
+              isAttrib: D,
+              wasInherited: S,
+              // Track inheritance status for undo
+              ownAttrib: C,
+              folderId: b == null ? void 0 : b.folderId
+            };
+          }
+        ), w = d.flatMap(
+          ({ id: m, type: E, field: k, value: D, isAttrib: b }) => {
+            const I = t(m);
+            return I ? {
+              id: m,
+              type: E,
+              field: k,
+              value: D,
+              isAttrib: b,
+              ownAttrib: (I == null ? void 0 : I.ownAttrib) || [],
+              folderId: "folderId" in I ? I.folderId : I == null ? void 0 : I.parentId
+            } : [];
+          }
+        );
+        n(p, w);
+      }
+      const u = ["task", "folder"];
+      let g = [];
+      for (const p of d) {
+        let { id: w, type: m, field: E, value: k, isAttrib: D } = p, b = m;
+        if (!u.includes(b))
+          continue;
+        const I = D ? { attrib: { [E]: k } } : { [E]: k };
+        if (D) {
+          const S = t(w), j = [...(S == null ? void 0 : S.ownAttrib) || []];
+          j.includes(E) || j.push(E), I.ownAttrib = j;
+        }
+        const C = g.findIndex(
+          (S) => S.entityId === p.id && S.entityType === b
+        );
+        if (C !== -1) {
+          const S = g[C];
+          let j = { ...S.data, ...I };
+          (y = S.data) != null && y.attrib && I.attrib && (j = { ...j, attrib: { ...S.data.attrib, ...I.attrib } }), g[C] = {
+            ...S,
+            data: j
+          };
+        } else
+          g.push({
+            entityType: b,
+            entityId: p.id,
+            type: "update",
+            data: I
+          });
+      }
+      const a = g.filter((p) => !!p.entityId && p.type === "update" && p.data && "attrib" in p.data).map((p) => {
+        var w;
+        return {
+          entityId: p.entityId,
+          entityType: p.entityType,
+          attrib: p.data && "attrib" in p.data ? (w = p.data) == null ? void 0 : w.attrib : {}
+        };
+      }), c = s(a).map((p) => ({
+        entityId: p.entityId,
+        entityType: p.entityType,
+        data: {
+          attrib: p.attrib
+        }
+      }));
+      try {
+        await l({
+          operations: g,
+          patchOperations: c
+        });
+      } catch {
+        ie.error("Failed to update entities");
+      }
+    },
+    [o, l, t, s, n]
+  ), x = M(
+    async (d, v = !0) => {
+      var c, y;
+      if (!d.length || !o)
+        return;
+      if (v && n) {
+        const p = [];
+        for (const m of d) {
+          const E = t(m.entityId);
+          for (const k of m.attribs)
+            E != null && E.attrib && k in E.attrib && p.push({
+              id: m.entityId,
+              type: m.entityType,
+              field: k,
+              value: E.attrib[k],
+              isAttrib: !0,
+              wasInherited: !1,
+              // Mark as not inherited
+              ownAttrib: (E == null ? void 0 : E.ownAttrib) || [],
+              folderId: E == null ? void 0 : E.folderId
+            });
+        }
+        const w = d.flatMap(
+          (m) => m.attribs.map((E) => ({
+            id: m.entityId,
+            type: m.entityType,
+            field: E,
+            value: null,
+            isAttrib: !0,
+            wasInherited: !0,
+            // Mark as inherited
+            ownAttrib: m.ownAttrib,
+            folderId: m.folderId
+          }))
+        );
+        p.length > 0 && n(p, w);
+      }
+      const u = ["task", "folder"], g = [], a = [];
+      for (const p of d) {
+        let w = p.entityType;
+        if (!u.includes(w))
+          continue;
+        w = w;
+        const m = {};
+        p.attribs.forEach((C) => {
+          m[C] = null;
+        }), g.push({
+          entityType: w,
+          entityId: p.entityId,
+          type: "update",
+          data: {
+            attrib: m
+          }
+        });
+        const k = (() => {
+          const C = p.folderId, S = [];
+          let j = C, T = d.find((R) => R.entityId === j);
+          for (; T; )
+            S.push(T), j = T.folderId, T = d.find((R) => R.entityId === j);
+          return S.length > 0 ? S[S.length - 1] : null;
+        })(), D = (k == null ? void 0 : k.attribs) || [], b = p.attribs.filter(
+          (C) => D.includes(C)
+        ), I = p.attribs.filter(
+          (C) => !D.includes(C)
+        );
+        I.length > 0 && a.push({
+          ...p,
+          attribs: I
+        }), k && b.length > 0 && a.push({
+          ...p,
+          attribs: b,
+          folderId: k.folderId
+        });
+      }
+      const h = [];
+      for (const p of a) {
+        const w = p.entityType, m = [...p.ownAttrib || []].filter(
+          (I) => !p.attribs.includes(I)
+        ), E = r(p.folderId, p.attribs), k = {
+          entityId: p.entityId,
+          entityType: w,
+          data: {
+            attrib: E,
+            ownAttrib: m
+          }
+        };
+        h.push(k);
+        const b = s([
+          { entityId: p.entityId, entityType: w, attrib: E }
+        ]).map((I) => ({
+          entityId: I.entityId,
+          entityType: I.entityType,
+          data: {
+            attrib: I.attrib
+          }
+        }));
+        for (const I of b) {
+          const C = h.findIndex(
+            (S) => S.entityId === I.entityId
+          );
+          if (C !== -1) {
+            const S = h[C];
+            let j = {
+              // @ts-ignore
+              ...((c = S.data) == null ? void 0 : c.attrib) || {},
+              // @ts-ignore
+              ...((y = I.data) == null ? void 0 : y.attrib) || {}
+            };
+            h[C] = {
+              ...S,
+              data: { attrib: j }
+            };
+          } else
+            h.push({
+              entityId: I.entityId,
+              entityType: I.entityType,
+              data: I.data
+            });
+        }
+      }
+      try {
+        await l({
+          operations: g,
+          patchOperations: h
+        });
+      } catch {
+        ie.error("Failed to update entities");
+      }
+    },
+    [
+      o,
+      l,
+      s,
+      i,
+      n
+    ]
+  );
+  return { updateEntities: f, inheritFromParent: x };
+}, kn = {
+  status: "statuses",
+  folderType: "folderTypes",
+  taskType: "taskTypes"
+}, X = (e) => ie.error(e), Dn = (e) => {
+  const n = e.trim().split(`
+`), t = [], o = [];
+  return n.forEach((s) => {
+    const i = s.split("	");
+    t.push({ values: i, colIds: o });
+  }), t;
+}, rt = (e, n, t, o) => {
+  const s = n ? t.get(e) : o.get(e);
+  if (!s) return "";
+  const i = s.name || "", r = s.folderId || s.parentId;
+  if (!r) return i;
+  const l = rt(r, !0, t, o);
+  return l ? `${l} / ${i}` : i;
+}, zn = (e, n) => {
+  if (n === "array")
+    try {
+      try {
+        const t = JSON.parse(e);
+        return Array.isArray(t) ? t : [t];
+      } catch {
+        return e.includes(",") ? e.split(",").map((t) => t.trim()) : [e];
+      }
+    } catch {
+      return [e];
+    }
+  else {
+    if (n === "number")
+      return Number(e) || 0;
+    if (n === "boolean")
+      return e.toLowerCase() === "true" || e === "1" || e.toLowerCase() === "yes";
+  }
+  return e;
+}, jn = (e) => {
+  const {
+    colId: n,
+    isFolder: t,
+    pasteValue: o,
+    parsedData: s,
+    columnEnums: i,
+    columnReadOnly: r,
+    rowIndex: l,
+    colIndex: f,
+    isSingleCellValue: x
+  } = e;
+  if (!o) return !0;
+  if (n.startsWith("attrib_") && r.includes(n.replace("attrib_", "")))
+    return X(`This column is read-only: "${n}". Paste operation cancelled.`), !1;
+  if (n === "assignees") {
+    const a = o.split(",").map((y) => y.trim()), h = i.assignees || [], c = a.filter(
+      (y) => h.some((p) => p.value === y || p.label === y)
+    );
+    if (x)
+      s[0].values[0] = c.join(", ");
+    else {
+      const y = l % s.length, p = f % s[y].values.length;
+      s[y].values[p] = c.join(", ");
+    }
+    return !0;
+  }
+  let d = n === "subType" ? t ? "folderType" : "taskType" : n;
+  if (d = kn[d] || d, !(d in i)) return !0;
+  const v = i[d];
+  return !Array.isArray(v) || v.length === 0 || o.split(",").map((a) => a.trim()).every(
+    (a) => v.some((h) => h.value === a || h.label === a)
+  ) ? !0 : (X(`Invalid ${d === "folderType" || d === "taskType" ? `${t ? "folder" : "task"} type` : d} value: "${o}". Paste operation cancelled.`), !1);
+};
+var pe = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Top = 1] = "Top", e[e.Right = 2] = "Right", e[e.Bottom = 4] = "Bottom", e[e.Left = 8] = "Left", e[e.All = 15] = "All", e))(pe || {});
+const B = (e, n) => `cell-${e}-${n}`, V = (e) => {
+  const n = e.match(/^cell-(.+)-(.+)$/);
+  return n ? { rowId: n[1], colId: n[2] } : null;
+}, Te = (e, n) => {
+  if (!e || !n) return;
+  const t = n.split("_");
+  let o = e;
+  for (const s of t)
+    if (o && typeof o == "object" && s in o)
+      o = o[s];
+    else
+      return;
+  return o;
+}, On = (e) => {
+  const n = [];
+  return e & 1 && n.push("shadow-top"), e & 2 && n.push("shadow-right"), e & 4 && n.push("shadow-bottom"), e & 8 && n.push("shadow-left"), n;
+}, H = "__row_selection__", lt = de(void 0), Ko = ({ children: e }) => {
+  const [n, t] = Q(/* @__PURE__ */ new Set()), [o, s] = Q(null), [i, r] = Q(!1), [l, f] = Q(null), [x, d] = Q({
+    rowIdToIndex: /* @__PURE__ */ new Map(),
+    colIdToIndex: /* @__PURE__ */ new Map(),
+    indexToRowId: /* @__PURE__ */ new Map(),
+    indexToColId: /* @__PURE__ */ new Map()
+  }), v = (T) => JSON.stringify(Array.from(T.entries())), u = U(
+    () => x,
+    [
+      v(x.rowIdToIndex),
+      v(x.colIdToIndex),
+      v(x.indexToRowId),
+      v(x.indexToColId)
+    ]
+  ), g = re(!1), a = U(
+    () => Array.from(n).filter(
+      (T) => {
+        var z, R;
+        return ((z = V(T)) == null ? void 0 : z.colId) === H && ((R = V(T)) == null ? void 0 : R.rowId);
+      }
+    ).map((T) => {
+      var z;
+      return (z = V(T)) == null ? void 0 : z.rowId;
+    }),
+    [n]
+  ), h = M((T, z) => {
+    const R = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), $ = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
+    T.forEach((_, K) => {
+      R.set(_, K), $.set(K, _);
+    }), z.forEach((_, K) => {
+      O.set(_, K), F.set(K, _);
+    }), d({ rowIdToIndex: R, colIdToIndex: O, indexToRowId: $, indexToColId: F });
+  }, []), c = M((T, z) => {
+    t((R) => {
+      let O = new Set(T);
+      if (z.colId !== H) {
+        const $ = Array.from(R).filter(
+          (F) => {
+            var _;
+            return ((_ = V(F)) == null ? void 0 : _.colId) === H;
+          }
+        );
+        $.length && (O = /* @__PURE__ */ new Set([...O, ...$]));
+      }
+      return O;
+    });
+  }, []), y = M(
+    (T, z, R) => {
+      R || c(/* @__PURE__ */ new Set(), T);
+      const O = u.rowIdToIndex.get(T.rowId) ?? 0, $ = u.colIdToIndex.get(T.colId) ?? 0, F = u.rowIdToIndex.get(z.rowId) ?? 0, _ = u.colIdToIndex.get(z.colId) ?? 0, K = Math.min(O, F), L = Math.max(O, F), W = Math.min($, _), P = Math.max($, _), ee = new Set(R ? n : []);
+      for (let G = K; G <= L; G++) {
+        const Y = u.indexToRowId.get(G);
+        if (Y)
+          for (let fe = W; fe <= P; fe++) {
+            const xe = u.indexToColId.get(fe);
+            xe && ee.add(B(Y, xe));
+          }
+      }
+      return ee;
+    },
+    [u, n]
+  ), p = M(
+    (T, z) => {
+      const R = V(T);
+      R && (r(!0), g.current = n.has(T), z ? t((O) => {
+        const $ = new Set(O);
+        return $.has(T) ? ($.delete(T), o === T && ($.size > 0 ? s(Array.from($)[Array.from($).length - 1]) : s(null))) : ($.add(T), s(T), f(R)), $;
+      }) : n.size === 1 && n.has(T) && [H, "name"].includes(R.colId) ? (t(/* @__PURE__ */ new Set()), f(null), s(null)) : (c(/* @__PURE__ */ new Set([T]), R), f(R), s(T)));
+    },
+    [n, o]
+  ), w = M(
+    (T, z) => {
+      if (!i || !l) return;
+      const R = V(T);
+      if (R)
+        if (z)
+          t((O) => {
+            const $ = new Set(O);
+            return V(T) && (g.current ? $.delete(T) : $.add(T)), $;
+          });
+        else {
+          const O = y(l, R, !1);
+          c(O, R);
+        }
+    },
+    [i, l, y]
+  ), m = M(() => {
+    r(!1);
+  }, []), E = M(
+    (T, z, R) => {
+      const O = V(T);
+      if (O)
+        if (R && l) {
+          const $ = y(l, O, z);
+          c($, O);
+        } else z ? t(($) => {
+          const F = new Set($);
+          return F.has(T) ? F.delete(T) : F.add(T), F;
+        }) : (c(/* @__PURE__ */ new Set([T]), O), f(O));
+    },
+    [l, y]
+  ), k = M((T) => {
+    s(T);
+  }, []), D = M(() => {
+    t(/* @__PURE__ */ new Set()), f(null);
+  }, []), b = M((T) => n.has(T), [n]), I = M((T) => T === o, [o]), C = M((T) => V(T), []), S = M(
+    (T) => {
+      if (!b(T)) return [];
+      const z = V(T);
+      if (!z) return [];
+      const R = u.rowIdToIndex.get(z.rowId), O = u.colIdToIndex.get(z.colId);
+      if (R === void 0 || O === void 0) return [];
+      const $ = u.indexToRowId.get(R - 1), F = u.indexToColId.get(O + 1), _ = u.indexToRowId.get(R + 1), K = u.indexToColId.get(O - 1);
+      let L = pe.None;
+      return (!$ || !n.has(B($, z.colId))) && (L |= pe.Top), (!F || !n.has(B(z.rowId, F))) && (L |= pe.Right), (!_ || !n.has(B(_, z.colId))) && (L |= pe.Bottom), (!K || !n.has(B(z.rowId, K))) && (L |= pe.Left), On(L);
+    },
+    [n, u, b]
+  ), j = U(
+    () => ({
+      selectedCells: n,
+      selectedRows: a,
+      focusedCellId: o,
+      selectionInProgress: i,
+      anchorCell: l,
+      gridMap: u,
+      setSelectedCells: t,
+      setFocusedCellId: s,
+      setAnchorCell: f,
+      registerGrid: h,
+      selectCell: E,
+      startSelection: p,
+      extendSelection: w,
+      endSelection: m,
+      focusCell: k,
+      clearSelection: D,
+      isCellSelected: b,
+      isCellFocused: I,
+      getCellPositionFromId: C,
+      getCellBorderClasses: S
+    }),
+    [
+      n,
+      a,
+      o,
+      i,
+      l,
+      u
+      // setSelectedCells,
+      // setFocusedCellId,
+      // setAnchorCell,
+      // registerGrid,
+      // selectCell,
+      // startSelection,
+      // extendSelection,
+      // endSelection,
+      // focusCell,
+      // clearSelection,
+      // isCellSelected,
+      // isCellFocused,
+      // getCellPositionFromId,
+      // getCellBorderClasses,
+    ]
+  );
+  return /* @__PURE__ */ A.jsx(lt.Provider, { value: j, children: e });
+}, he = () => {
+  const e = ce(lt);
+  if (e === void 0)
+    throw new Error("useSelectionContext must be used within a SelectionProvider");
+  return e;
+}, at = de(void 0), $n = ({
+  children: e,
+  foldersMap: n,
+  tasksMap: t,
+  columnEnums: o,
+  columnReadOnly: s
+}) => {
+  const { selectedCells: i, gridMap: r, focusedCellId: l } = he(), { updateEntities: f } = ye(), x = M(
+    async (a, h) => {
+      const { headers: c, fullRow: y } = h || {};
+      try {
+        const p = /* @__PURE__ */ new Map();
+        a.forEach((D) => {
+          var S;
+          const b = V(D);
+          if (!b) return;
+          const { rowId: I, colId: C } = b;
+          C !== H && (p.has(I) || p.set(I, /* @__PURE__ */ new Set()), (S = p.get(I)) == null || S.add(C));
+        }), y && a.filter(
+          (b) => {
+            var I, C;
+            return ((I = V(b)) == null ? void 0 : I.rowId) && ((C = V(b)) == null ? void 0 : C.colId) === H;
+          }
+        ).map((b) => {
+          var I;
+          return (I = V(b)) == null ? void 0 : I.rowId;
+        }).forEach((b) => {
+          p.has(b) || p.set(b, /* @__PURE__ */ new Set()), Array.from(r.colIdToIndex.keys()).forEach((C) => {
+            var S;
+            (S = p.get(b)) == null || S.add(C);
+          });
+        });
+        const w = Array.from(p.keys()).sort((D, b) => {
+          const I = r.rowIdToIndex.get(D) ?? 1 / 0, C = r.rowIdToIndex.get(b) ?? 1 / 0;
+          return I - C;
+        });
+        let m = "";
+        const E = w[0];
+        if (!E) return "";
+        const k = Array.from(p.get(E) || []).sort((D, b) => {
+          const I = r.colIdToIndex.get(D) ?? 1 / 0, C = r.colIdToIndex.get(b) ?? 1 / 0;
+          return I - C;
+        });
+        if (c && k.length > 0) {
+          const D = [];
+          for (const b of k) {
+            const I = b;
+            D.push(`${I.replace(/"/g, '""')}`);
+          }
+          m += D.join("	") + `
+`;
+        }
+        for (const D of w) {
+          const b = n.has(D), I = b ? n.get(D) : t.get(D);
+          if (!I) continue;
+          const S = Array.from(p.get(D) || []).sort((T, z) => {
+            const R = r.colIdToIndex.get(T) ?? 1 / 0, O = r.colIdToIndex.get(z) ?? 1 / 0;
+            return R - O;
+          }).filter((T) => T !== H), j = [];
+          for (const T of S) {
+            let z = "";
+            const R = Te(I, T);
+            z = R != null ? String(R) : "", T === "name" && (z = rt(D, b, n, t)), T === "subType" && (z = I[b ? "folderType" : "taskType"] || ""), j.push(`${z.replace(/"/g, '""')}`);
+          }
+          m += j.join("	") + `
+`;
+        }
+        return m;
+      } catch (p) {
+        console.error("Failed to copy to clipboard:", p);
+      }
+    },
+    [i, l, r, n, t]
+  ), d = M(
+    async (a, h) => {
+      if (a = a || Array.from(i), !a.length) return;
+      const c = await x(a, { fullRow: h });
+      if (c) {
+        if (!navigator.clipboard) {
+          X("Clipboard API not supported in this browser.");
+          return;
+        }
+        if (!window.isSecureContext) {
+          X("Clipboard operations require a secure HTTPS context.");
+          return;
+        }
+        try {
+          await navigator.clipboard.writeText(c), console.log("Copied to clipboard successfully", c);
+        } catch (y) {
+          X(`Failed to copy to clipboard: ${y.message}`);
+        }
+      }
+    },
+    [i, n, t, r]
+  ), v = M(
+    async (a, h, c) => {
+      if (a = a || Array.from(i), !!a.length)
+        try {
+          const y = await x(a, { headers: !0, fullRow: c });
+          if (!y) return;
+          const p = new Blob([y], { type: "text/csv" }), w = URL.createObjectURL(p), m = document.createElement("a");
+          m.href = w;
+          const E = a.length;
+          m.download = `${h}-export-${E}_cells-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`, m.click(), URL.revokeObjectURL(w);
+        } catch (y) {
+          console.error("Failed to copy to clipboard:", y);
+        }
+    },
+    [i, n, t, r, x]
+  ), u = M(
+    async (a) => {
+      if (a = a || Array.from(i), !a.length) return;
+      if (!navigator.clipboard) {
+        X("Clipboard API not supported in this browser.");
+        return;
+      }
+      if (!window.isSecureContext) {
+        X("Clipboard operations require a secure HTTPS context.");
+        return;
+      }
+      let h;
+      try {
+        h = await navigator.clipboard.readText();
+      } catch (b) {
+        X(`Failed to read from clipboard: ${b.message}`);
+        return;
+      }
+      if (!h.trim()) return;
+      const c = Dn(h);
+      if (!c.length) return;
+      const y = c.length === 1 && c[0].values.length === 1, p = /* @__PURE__ */ new Map();
+      Array.from(a).forEach((b) => {
+        var j;
+        const I = V(b);
+        if (!I) return;
+        const { rowId: C, colId: S } = I;
+        p.has(C) || p.set(C, /* @__PURE__ */ new Set()), (j = p.get(C)) == null || j.add(S);
+      });
+      const w = Array.from(p.keys()).sort((b, I) => {
+        const C = r.rowIdToIndex.get(b) ?? 1 / 0, S = r.rowIdToIndex.get(I) ?? 1 / 0;
+        return C - S;
+      }), m = w[0], E = Array.from(p.get(m) || []).sort((b, I) => {
+        const C = r.colIdToIndex.get(b) ?? 1 / 0, S = r.colIdToIndex.get(I) ?? 1 / 0;
+        return C - S;
+      });
+      for (let b = 0; b < E.length; b++) {
+        const I = E[b];
+        for (let C = 0; C < w.length; C++) {
+          const S = w[C], j = n.has(S);
+          let T;
+          if (y)
+            T = c[0].values[0];
+          else {
+            const R = C % c.length, O = b % c[R].values.length;
+            T = c[R].values[O];
+          }
+          if (!jn({
+            colId: I,
+            isFolder: j,
+            pasteValue: T,
+            parsedData: c,
+            columnEnums: o,
+            columnReadOnly: s,
+            rowIndex: C,
+            colIndex: b,
+            isSingleCellValue: y
+          })) return;
+        }
+      }
+      const k = /* @__PURE__ */ new Map();
+      for (let b = 0; b < E.length; b++) {
+        const I = E[b];
+        if (I === "name") continue;
+        let C = !1, S = "string";
+        if (w.length > 0) {
+          const j = w[0], z = n.has(j) ? n.get(j) : t.get(j);
+          if (z) {
+            C = I.startsWith("attrib_");
+            const R = Te(z, I);
+            Array.isArray(R) ? S = "array" : typeof R == "number" ? S = "number" : typeof R == "boolean" && (S = "boolean"), I === "subType" && (C = !1);
+          }
+        }
+        for (let j = 0; j < w.length; j++) {
+          const T = w[j], z = n.has(T), R = z ? "folder" : "task";
+          let O;
+          if (y)
+            O = c[0].values[0];
+          else {
+            const L = j % c.length, W = b % c[L].values.length;
+            O = c[L].values[W];
+          }
+          let $ = I.split("_").pop() || I;
+          if (I === "subType" && ($ = z ? "folderType" : "taskType", C = !1, !O))
+            continue;
+          const F = zn(O, S), _ = `${T}-${R}`;
+          k.has(_) || k.set(_, {
+            id: T,
+            type: R,
+            fields: {},
+            attrib: {}
+          });
+          const K = k.get(_);
+          C ? K.attrib[$] = F : K.fields[$] = F;
+        }
+      }
+      const D = [];
+      if (k.forEach((b) => {
+        Object.entries(b.fields).forEach(([I, C]) => {
+          D.push({
+            id: b.id,
+            type: b.type,
+            field: I,
+            value: C
+          });
+        }), Object.entries(b.attrib).forEach(([I, C]) => {
+          D.push({
+            id: b.id,
+            type: b.type,
+            field: I,
+            value: C,
+            isAttrib: !0
+          });
+        });
+      }), D.length > 0)
+        try {
+          await f(D);
+        } catch (b) {
+          console.error("Error updating entities:", b), X(
+            `Failed to update: ${b instanceof Error ? b.message : "Unknown error"}`
+          );
+        }
+    },
+    [i, r, n, t, f, o]
+  );
+  J(() => {
+    const a = (h) => {
+      (h.ctrlKey || h.metaKey) && h.key === "c" && d(), (h.ctrlKey || h.metaKey) && h.key === "v" && u();
+    };
+    return window.addEventListener("keydown", a), () => {
+      window.removeEventListener("keydown", a);
+    };
+  }, [d, u]);
+  const g = U(
+    () => ({
+      copyToClipboard: d,
+      pasteFromClipboard: u,
+      exportCSV: v
+    }),
+    [d, u]
+  );
+  return /* @__PURE__ */ A.jsx(at.Provider, { value: g, children: e });
+}, Mn = () => {
+  const e = ce(at);
+  if (e === void 0)
+    throw new Error("useClipboard must be used within a ClipboardProvider");
+  return e;
+}, dt = de(void 0), Bo = ({
+  children: e,
+  config: n,
+  onChange: t
+}) => {
+  const o = n, { columnOrder: s = [], columnPinning: i = {}, columnVisibility: r = {} } = o, l = (w) => {
+    t({
+      ...o,
+      columnVisibility: w
+    });
+  }, f = (w) => {
+    t({
+      ...o,
+      columnOrder: w
+    });
+  }, x = (w) => {
+    t({
+      ...o,
+      columnPinning: w
+    });
+  }, d = (w) => {
+    const m = { ...i }, E = m.left || [], k = Object.keys(w).filter((b) => w[b] === !1), D = E.filter((b) => !k.includes(b));
+    return {
+      ...m,
+      left: D
+    };
+  }, v = (w) => {
+    const m = { ...i }, E = m.left || [], k = w.filter((D) => E.includes(D));
+    return {
+      ...m,
+      left: k
+    };
+  }, u = (w) => [...s].sort((m, E) => {
+    var b, I;
+    const k = (b = w.left) != null && b.includes(m) ? 1 : 0;
+    return ((I = w.left) != null && I.includes(E) ? 1 : 0) - k;
+  }), g = (w) => {
+    const m = d(w);
+    t({
+      ...o,
+      columnVisibility: w,
+      columnPinning: m
+    });
+  }, a = (w) => {
+    const m = v(w);
+    t({
+      ...o,
+      columnOrder: w,
+      columnPinning: m
+    });
+  }, h = (w) => {
+    const m = u(w);
+    t({
+      ...o,
+      columnOrder: m,
+      columnPinning: w
+    });
+  }, c = (w) => {
+    const m = ve(w, r);
+    g(m);
+  }, y = (w) => {
+    const m = ve(w, s);
+    a(m);
+  }, p = (w) => {
+    const m = ve(w, i);
+    h(m);
+  };
+  return /* @__PURE__ */ A.jsx(
+    dt.Provider,
+    {
+      value: {
+        // column visibility
+        columnVisibility: r,
+        setColumnVisibility: l,
+        updateColumnVisibility: g,
+        columnVisibilityUpdater: c,
+        // column pinning
+        columnPinning: i,
+        setColumnPinning: x,
+        updateColumnPinning: h,
+        columnPinningUpdater: p,
+        // column order
+        columnOrder: s,
+        setColumnOrder: f,
+        updateColumnOrder: a,
+        columnOrderUpdater: y,
+        // global change
+        setColumnsConfig: t
+      },
+      children: e
+    }
+  );
+}, _n = () => {
+  const e = ce(dt);
+  if (!e)
+    throw new Error("useColumnSettings must be used within a ColumnSettingsProvider");
+  return e;
+}, ct = de(void 0), Ho = ({ children: e }) => {
+  const { selectedCells: n, gridMap: t, setSelectedCells: o, setFocusedCellId: s, setAnchorCell: i } = he(), r = re([]), l = U(
+    () => Array.from(n).filter(
+      (h) => {
+        var c, y;
+        return ((c = V(h)) == null ? void 0 : c.colId) === H && ((y = V(h)) == null ? void 0 : y.rowId);
+      }
+    ).map((h) => {
+      var c;
+      return (c = V(h)) == null ? void 0 : c.rowId;
+    }),
+    [n]
+  ), f = U(() => {
+    const h = [...l].sort(), c = [...r.current].sort();
+    return h.length !== c.length || h.some((p, w) => p !== c[w]) ? (r.current = l, l) : r.current;
+  }, [l]), x = M(() => {
+    const h = Array.from(t.rowIdToIndex.keys()), c = /* @__PURE__ */ new Set();
+    if (h.forEach((y) => {
+      c.add(B(y, H));
+    }), o(c), h.length > 0) {
+      const y = B(h[0], H);
+      s(y), i(V(y));
+    }
+  }, [t]), d = M(() => {
+    o((h) => {
+      const c = new Set(h);
+      return Array.from(c).forEach((y) => {
+        var p;
+        ((p = V(y)) == null ? void 0 : p.colId) === H && c.delete(y);
+      }), c;
+    });
+  }, [o]), v = M(
+    (h) => f.includes(h),
+    [f]
+  ), u = M(() => {
+    const h = t.rowIdToIndex.size;
+    return h > 0 && f.length === h;
+  }, [t, f]), g = M(() => f.length > 0 && !u(), [f, u]), a = U(() => ({
+    selectedRows: f,
+    selectAllRows: x,
+    clearRowsSelection: d,
+    isRowSelected: v,
+    areAllRowsSelected: u,
+    areSomeRowsSelected: g
+  }), [f, x, u, g, d]);
+  return /* @__PURE__ */ A.jsx(ct.Provider, { value: a, children: e });
+}, ut = () => {
+  const e = ce(ct);
+  if (!e)
+    throw new Error("useSelectedRowsContext must be used within a SelectedRowsProvider");
+  return e;
+}, Nn = () => {
+  const { attribFields: e } = ue();
+  return (t = []) => {
+    for (const { isAttrib: o, value: s, field: i } of t) {
+      if (!o) continue;
+      const r = e.find((m) => m.name === i);
+      if (!r) continue;
+      let l = s;
+      const { type: f } = r.data;
+      if (f === "integer" || f === "float") {
+        if (typeof s == "string") {
+          if (s.trim() === "" || isNaN(Number(s)))
+            throw new Error(`“${i}” must be a valid number`);
+          l = f === "integer" ? parseInt(s, 10) : parseFloat(s);
+        } else if (typeof s != "number")
+          throw new Error(`“${i}” must be a valid number`);
+      }
+      const x = [
+        "ge",
+        "gt",
+        "le",
+        "lt",
+        "minLength",
+        "maxLength",
+        "minItems",
+        "maxItems"
+      ], d = Object.entries(r.data).reduce((m, [E, k]) => (x.includes(E) && (m[E] = k), m), {}), { ge: v, gt: u, le: g, lt: a, minLength: h, maxLength: c, minItems: y, maxItems: p } = d, w = r.data.regex;
+      if (typeof l == "number") {
+        if (v != null && l < v) throw new Error(`“${i}” must be ≥ ${v}`);
+        if (u != null && l <= u) throw new Error(`“${i}” must be > ${u}`);
+        if (g != null && l > g) throw new Error(`“${i}” must be ≤ ${g}`);
+        if (a != null && l >= a) throw new Error(`“${i}” must be < ${a}`);
+      } else if (typeof l == "string") {
+        if (h != null && l.length < h)
+          throw new Error(`“${i}” length must be ≥ ${h}`);
+        if (c != null && l.length > c)
+          throw new Error(`“${i}” length must be ≤ ${c}`);
+        if (w && !new RegExp(w).test(l))
+          throw new Error(`“${i}” must match pattern ${w}`);
+      } else if (Array.isArray(l)) {
+        if (y != null && l.length < y)
+          throw new Error(`“${i}” items must be ≥ ${y}`);
+        if (p != null && l.length > p)
+          throw new Error(`“${i}” items must be ≤ ${p}`);
+      }
+    }
+  };
+}, Fn = (e = 50) => {
+  const [n, t] = Q([]), [o, s] = Q([]), i = M(
+    (d, v) => {
+      d.length && (t((u) => {
+        const g = [...u, { undo: d, redo: v, timestamp: Date.now() }];
+        return g.length > e ? g.slice(g.length - e) : g;
+      }), s([]));
+    },
+    [e]
+  ), r = (d) => d.reduce(
+    (v, u) => (u.wasInherited && u.folderId ? v[1].push({
+      entityId: u.id,
+      entityType: u.type,
+      folderId: u.folderId,
+      attribs: [u.field],
+      ownAttrib: u.ownAttrib
+    }) : v[0].push(u), v),
+    [[], []]
+  ), l = M(() => {
+    if (n.length === 0) return null;
+    const d = [...n], v = d.pop();
+    return t(d), s((u) => [...u, v]), r(v.undo);
+  }, [n]), f = M(() => {
+    if (o.length === 0) return null;
+    const d = [...o], v = d.pop();
+    return s(d), t((u) => [...u, v]), r(v.redo);
+  }, [o]), x = M(() => {
+    t([]), s([]);
+  }, []);
+  return {
+    pushHistory: i,
+    undo: l,
+    redo: f,
+    canUndo: n.length > 0,
+    canRedo: o.length > 0,
+    clearHistory: x
+  };
+}, ht = de(void 0), qo = ({ children: e }) => {
+  const [n, t] = Q(null), o = M((c) => c === n, [n]), { pushHistory: s, undo: i, redo: r, canUndo: l, canRedo: f } = Fn(), { updateEntities: x, inheritFromParent: d } = Rn({
+    pushHistory: s
+  }), v = Nn(), u = async (c = [], y = !0) => {
+    try {
+      return v(c), await x(c, y);
+    } catch (p) {
+      return ie.error(p.message), Promise.reject(p);
+    }
+  }, g = async () => {
+    const [c, y] = i() || [];
+    if (c && c.length > 0)
+      try {
+        await u(c, !1);
+      } catch {
+        ie.error("Failed to undo changes");
+      }
+    if (y && y.length > 0)
+      try {
+        await d(y, !1);
+      } catch {
+        ie.error("Failed to inherit changes");
+      }
+  }, a = async () => {
+    const [c, y] = r() || [];
+    if (c && c.length > 0)
+      try {
+        await u(c, !1);
+      } catch {
+        ie.error("Failed to redo changes");
+      }
+    if (y && y.length > 0)
+      try {
+        await d(y, !1);
+      } catch {
+        ie.error("Failed to inherit changes");
+      }
+  }, h = U(
+    () => ({
+      editingCellId: n,
+      setEditingCellId: t,
+      isEditing: o,
+      updateEntities: u,
+      inheritFromParent: d,
+      undo: g,
+      redo: a,
+      canUndo: l,
+      canRedo: f
+    }),
+    [
+      n,
+      o,
+      u,
+      d,
+      g,
+      a,
+      l,
+      f
+    ]
+  );
+  return J(() => {
+    const c = (y) => {
+      const p = y.target;
+      if (p.tagName === "INPUT" || p.tagName === "TEXTAREA" || p.isContentEditable || p.getAttribute("role") === "textbox" || p.tagName === "LI")
+        return;
+      const m = typeof navigator < "u" && // @ts-expect-error
+      (navigator.userAgentData && // @ts-expect-error
+      navigator.userAgentData.platform.toUpperCase().includes("MAC") || navigator.userAgent.toUpperCase().includes("MAC")) ? y.metaKey : y.ctrlKey;
+      m && y.key === "z" && (y.preventDefault(), l && g()), (m && y.key === "y" || m && y.shiftKey && y.key === "z" || m && y.key === "Z") && (y.preventDefault(), f && a());
+    };
+    return document.addEventListener("keydown", c), () => document.removeEventListener("keydown", c);
+  }, [l, f, g, a]), /* @__PURE__ */ A.jsx(ht.Provider, { value: h, children: e });
+}, ye = () => {
+  const e = ce(ht);
+  if (e === void 0)
+    throw new Error("useCellEditing must be used within a CellEditingProvider");
+  return e;
+}, Pn = N.div`
+  position: absolute;
+  inset: 0;
+  padding: 4px 8px;
+  display: flex;
+  align-items: center;
+
+  &:focus-visible {
+    outline: none;
+  }
+
+  &.inherited {
+    opacity: 0.6;
+    font-style: italic;
+  }
+
+  &.loading {
+    inset: 4px;
+    border-radius: 4px;
+    opacity: 1;
+  }
+`, Vn = ({
+  rowId: e,
+  columnId: n,
+  value: t,
+  attributeData: o,
+  options: s = [],
+  isCollapsed: i,
+  isInherited: r,
+  isPlaceholder: l,
+  isReadOnly: f,
+  enableCustomValues: x,
+  onChange: d,
+  ...v
+}) => {
+  const u = re(null), g = o == null ? void 0 : o.type, { isEditing: a, setEditingCellId: h } = ye(), { isCellFocused: c, gridMap: y, selectCell: p, focusCell: w } = he(), m = B(e, n), E = a(m), k = c(m), D = M(() => {
+    l || f || h(m);
+  }, [m, h, l]), b = () => {
+    E || h(null);
+  }, I = () => {
+    const T = y.rowIdToIndex.get(e);
+    if (T === void 0) return;
+    const z = y.indexToRowId.get(T + 1);
+    if (z) {
+      const R = B(z, n);
+      p(R, !1, !1), w(R), h(R);
+    }
+  }, C = (T, z) => {
+    h(null), !f && (z === "Enter" && I(), (T !== t || z === "Enter") && (d == null || d(T, z)));
+  }, S = () => {
+    h(null);
+  }, j = U(() => {
+    const T = {
+      onChange: C,
+      onCancelEdit: S,
+      isEditing: E
+    }, z = ["string", "integer", "float"];
+    switch (!0) {
+      // this is showing the collapsed widget (dot)
+      case i: {
+        const R = g != null && g.includes("list") ? s.find(
+          ($) => Array.isArray(t) ? t.includes($.value) : t === $.value
+        ) : void 0, O = R == null ? void 0 : R.color;
+        return /* @__PURE__ */ A.jsx(sn, { color: O });
+      }
+      case !!s.length: {
+        const R = Array.isArray(t) ? t : [t];
+        return /* @__PURE__ */ A.jsx(
+          wn,
+          {
+            value: R,
+            options: s,
+            type: g,
+            onOpen: () => !f && h(m),
+            enableCustomValues: x,
+            ...T
+          }
+        );
+      }
+      case z.includes(g):
+        return /* @__PURE__ */ A.jsx(qe, { value: t, isInherited: r, ...T });
+      case (g === "datetime" && t !== null && t !== void 0):
+        return /* @__PURE__ */ A.jsx(an, { value: t, isInherited: r, ...T });
+      case g === "boolean":
+        return /* @__PURE__ */ A.jsx(Cn, { value: t, ...T });
+      case l:
+        return null;
+      default:
+        return /* @__PURE__ */ A.jsx(qe, { value: t, ...T });
+    }
+  }, [m, t, g, E, s, i]);
+  return /* @__PURE__ */ A.jsx(
+    Pn,
+    {
+      ...v,
+      className: q(v.className, { inherited: r && !E }),
+      ref: u,
+      onDoubleClick: D,
+      onClick: b,
+      id: m,
+      "data-tooltip": r && !E && k ? "Inherited" : void 0,
+      "data-tooltip-delay": 200,
+      children: j
+    }
+  );
+};
+function Ln(e, n) {
+  var t, o, s, i, r, l;
+  return e.rowId === n.rowId && e.columnId === n.columnId && e.isCollapsed === n.isCollapsed && JSON.stringify(e.value) === JSON.stringify(n.value) && ((t = e == null ? void 0 : e.attributeData) == null ? void 0 : t.type) === ((o = n == null ? void 0 : n.attributeData) == null ? void 0 : o.type) && // Only check options length for list types to avoid deep comparison
+  (!((s = e == null ? void 0 : e.attributeData) != null && s.type.includes("list")) && !((i = n == null ? void 0 : n.attributeData) != null && i.type.includes("list")) || ((r = e.options) == null ? void 0 : r.length) === ((l = n.options) == null ? void 0 : l.length)) && e.isInherited === n.isInherited && e.enableCustomValues === n.enableCustomValues && e.isReadOnly === n.isReadOnly && e.isPlaceholder === n.isPlaceholder && e.isFocused === n.isFocused && e.isCollapsed === n.isCollapsed;
+}
+const me = Me(Vn, Ln), Wn = N(et)`
+  background-color: unset;
+  padding: 2px !important;
+  cursor: pointer;
+`, Un = N.div`
+  position: relative;
+  display: flex;
+  align-items: center;
+  gap: var(--base-gap-small);
+  height: 100%;
+  width: 100%;
+  padding-right: 8px;
+`, Kn = N.div`
+  width: 100%;
+  height: 24px;
+  overflow: hidden;
+  position: relative;
+`, Bn = N.div`
+  position: absolute;
+  inset: 0;
+`, Hn = N.div`
+  display: flex;
+  align-items: center;
+  gap: var(--base-gap-large);
+  padding: 2px 4px;
+  border-radius: var(--border-radius-m);
+  cursor: pointer;
+  overflow: hidden;
+  width: fit-content;
+  max-width: 100%;
+  height: 100%;
+
+  /* &:hover {
+    &,
+    .icon,
+    .path {
+      color: var(--md-sys-color-primary);
+    }
+  } */
+`, qn = N.div`
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+
+  .path {
+    ${Rt.labelSmall}
+    margin-bottom: -4px;
+    color: var(--md-sys-color-outline);
+  }
+
+  span {
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+  }
+`, Yn = ({
+  id: e,
+  label: n,
+  name: t,
+  path: o,
+  showHierarchy: s,
+  icon: i,
+  type: r,
+  isExpanded: l,
+  toggleExpandAll: f,
+  toggleExpanded: x
+}) => /* @__PURE__ */ A.jsxs(Un, { children: [
+  s ? r === "folder" ? /* @__PURE__ */ A.jsx(
+    Wn,
+    {
+      onClick: (d) => {
+        d.stopPropagation(), d.altKey ? f(e) : x();
+      },
+      className: "expander",
+      icon: l ? "expand_more" : "chevron_right"
+    }
+  ) : /* @__PURE__ */ A.jsx("div", { style: { display: "inline-block", minWidth: 24 } }) : null,
+  /* @__PURE__ */ A.jsx(Kn, { style: { height: o ? 32 : 24 }, children: /* @__PURE__ */ A.jsx(Bn, { children: /* @__PURE__ */ A.jsxs(Hn, { children: [
+    i && /* @__PURE__ */ A.jsx(ae, { icon: i }),
+    /* @__PURE__ */ A.jsxs(qn, { children: [
+      o && /* @__PURE__ */ A.jsx("span", { className: "path", children: o }),
+      /* @__PURE__ */ A.jsx("span", { className: "label", children: n || t })
+    ] })
+  ] }) }) })
+] }), te = "inset 0 1px 0 0 var(--md-sys-color-primary)", ne = "inset -1px 0 0 0 var(--md-sys-color-primary)", oe = "inset 0 -1px 0 0 var(--md-sys-color-primary)", se = "inset 1px 0 0 0 var(--md-sys-color-primary)", Z = (e) => e ? "inset -2px -1px 0 0 var(--md-sys-color-surface-container), inset 1px 0 0 0 var(--md-sys-color-surface-container)" : "inset 1px -1px 0 0 var(--md-sys-color-surface-container)", Zn = N.tr`
+  display: flex;
+  position: absolute;
+  width: 100%;
+`, Ne = 50, ft = N.div`
+  display: flex;
+  align-items: center;
+  gap: var(--base-gap-small);
+  height: 100%;
+  width: 100%;
+  padding: 0px 8px;
+  border-radius: var(--border-radius-m);
+  user-select: none;
+  padding-right: 0;
+
+  min-width: ${Ne}px;
+  &.bold {
+    font-weight: 600;
+  }
+
+  &.loading {
+    margin: 0px 5px;
+    padding: 0 !important;
+    width: calc(100% - 10px);
+    height: 28px;
+    margin-top: 3px;
+
+    &:not(.hierarchy) {
+      height: 32px;
+    }
+  }
+
+  &:focus-visible {
+    outline: none;
+  }
+`, Qn = N.div`
+  position: absolute;
+  right: -1px;
+  top: 0;
+  bottom: 0;
+  width: 6px;
+  cursor: col-resize;
+  background-color: var(--md-sys-color-surface-container-high);
+
+  opacity: 0;
+
+  &.resizing {
+    background-color: var(--md-sys-color-primary);
+    opacity: 1;
+  }
+`, Jn = N.tr`
+  background-color: var(--md-sys-color-surface-container-low);
+`, Gn = N.th`
+  position: relative;
+  background-color: var(--md-sys-color-surface-container-lowest);
+  box-shadow: inset 1px -1px 0 0 var(--md-sys-color-surface-container);
+  display: flex;
+  align-items: center;
+  min-height: fit-content;
+  min-width: ${Ne}px;
+  &.large {
+    min-width: 300px;
+  }
+  &:hover {
+    .resize-handle {
+      opacity: 1;
+    }
+  }
+
+  /* show action button */
+  &:hover {
+    .action {
+      display: flex;
+    }
+  }
+
+  /* Styling for the last pinned left column */
+  &.last-pinned-left {
+    box-shadow: inset 1px -1px 0 0 var(--md-sys-color-surface-container),
+      inset -2px 0 0 0 var(--md-sys-color-surface-container);
+  }
+
+  /* special styles for the left selection column */
+  &.__row_selection__ {
+    min-width: unset;
+    width: 20px !important;
+
+    .actions {
+      display: none;
+    }
+  }
+`, Xn = N.div`
+  display: flex;
+  gap: var(--base-gap-small);
+
+  position: absolute;
+  z-index: 10;
+  right: 8px;
+  top: 50%;
+  transform: translateY(-50%);
+`, eo = N.td`
+  position: relative;
+  box-shadow: ${Z(!1)};
+  min-width: ${Ne}px;
+  background-color: var(--md-sys-color-surface-container-low);
+
+  &.task {
+    background-color: hsl(216 15% 11.5% / 1);
+  }
+
+  &.selected-row {
+    background-color: var(--md-sys-color-surface-container-high);
+  }
+
+  &.selected {
+    background-color: var(--md-sys-color-secondary-container);
+    position: relative;
+    z-index: 1;
+  }
+
+  /* remove default focus style */
+  &:focus-visible {
+    outline: none;
+  }
+
+  /* Styling for the last pinned left column */
+  /* extra border on the right */
+  &.last-pinned-left {
+    box-shadow: inset 1px -1px 0 0 var(--md-sys-color-surface-container),
+      inset -2px 0 0 0 var(--md-sys-color-surface-container);
+  }
+
+  /* Shadow combinations - single side */
+  &.shadow-top:not(.shadow-right):not(.shadow-bottom):not(.shadow-left) {
+    box-shadow: ${te}, ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-right:not(.shadow-top):not(.shadow-bottom):not(.shadow-left) {
+    box-shadow: ${ne}, ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-bottom:not(.shadow-top):not(.shadow-right):not(.shadow-left) {
+    box-shadow: ${oe}, ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-left:not(.shadow-top):not(.shadow-right):not(.shadow-bottom) {
+    box-shadow: ${se}, ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  /* Two sides */
+  &.shadow-top.shadow-right:not(.shadow-bottom):not(.shadow-left) {
+    box-shadow: ${te}, ${ne},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-top.shadow-bottom:not(.shadow-right):not(.shadow-left) {
+    box-shadow: ${te}, ${oe},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-top.shadow-left:not(.shadow-right):not(.shadow-bottom) {
+    box-shadow: ${te}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-right.shadow-bottom:not(.shadow-top):not(.shadow-left) {
+    box-shadow: ${ne}, ${oe},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-right.shadow-left:not(.shadow-top):not(.shadow-bottom) {
+    box-shadow: ${ne}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-bottom.shadow-left:not(.shadow-top):not(.shadow-right) {
+    box-shadow: ${oe}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  /* Three sides */
+  &.shadow-top.shadow-right.shadow-bottom:not(.shadow-left) {
+    box-shadow: ${te}, ${ne}, ${oe},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-top.shadow-right.shadow-left:not(.shadow-bottom) {
+    box-shadow: ${te}, ${ne}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-top.shadow-bottom.shadow-left:not(.shadow-right) {
+    box-shadow: ${te}, ${oe}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  &.shadow-right.shadow-bottom.shadow-left:not(.shadow-top) {
+    box-shadow: ${ne}, ${oe}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  /* All four sides */
+  &.shadow-top.shadow-right.shadow-bottom.shadow-left {
+    box-shadow: ${te}, ${ne}, ${oe}, ${se},
+      ${({ $isLastPinned: e }) => Z(e || !1)};
+  }
+
+  /* Focus styling */
+  &.focused {
+    position: relative;
+    z-index: 2;
+  }
+
+  /* Use pseudo-element for focused outline to avoid box-shadow conflicts */
+  &.focused::after {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    border: 2px solid var(--md-sys-color-primary);
+    pointer-events: none;
+  }
+
+  &.editing {
+    z-index: 10 !important;
+    /* light border around the outside */
+    &::before {
+      content: '';
+      position: absolute;
+      inset: 2px;
+      border: 2px solid var(--md-sys-color-surface-container-low);
+    }
+  }
+
+  /* special styles for selection bar cells */
+  &.__row_selection__ {
+    width: 20px !important;
+    min-width: unset;
+
+    &.selected {
+      background-color: var(--md-sys-color-primary-container) !important;
+      box-shadow: none !important;
+      /* reveal the check mark */
+      [icon='check'] {
+        display: block;
+      }
+    }
+  }
+`, to = N.thead`
+  display: grid !important;
+  position: sticky;
+  top: 0;
+  min-height: 34px;
+  z-index: 10;
+  background-color: var(--md-sys-color-surface-container-lowest);
+`, no = N.div`
+  overflow: hidden;
+  position: absolute;
+  inset: 0;
+  border-radius: var(--border-radius-m);
+
+  background-color: var(--md-sys-color-surface-container-low);
+`, oo = N.div`
+  display: flex;
+
+  height: 100%;
+  width: 100%;
+  overflow: auto;
+  padding: 4px;
+  padding-top: 0;
+
+  &.isLoading {
+    overflow: hidden;
+  }
+
+  table {
+    height: fit-content;
+    width: 100%;
+    display: grid;
+  }
+
+  thead {
+    display: none;
+  }
+
+  tbody {
+    position: relative;
+    display: grid;
+  }
+
+  td {
+    height: 34px;
+    padding: 1px 0px;
+    width: 100%;
+  }
+`, so = N.div`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  /* This is super important as it prevents onMouseOver incorrectly firing when Icon is added/removed */
+  pointer-events: none;
+  height: 100%;
+
+  /* default hidden. Shown with styles in ProjectTreeTable.styled */
+  [icon='check'] {
+    display: none;
+  }
+`, io = le(
+  ({ isSelected: e, ...n }, t) => /* @__PURE__ */ A.jsx(so, { ...n, ref: t, children: /* @__PURE__ */ A.jsx(ae, { icon: "check" }) })
+), ro = N.div`
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+
+  &:hover {
+    background-color: var(--md-sys-color-surface-container-high);
+  }
+`, lo = () => {
+  const { areAllRowsSelected: e, areSomeRowsSelected: n, selectAllRows: t, clearRowsSelection: o } = ut(), s = e(), i = n(), r = () => {
+    s || i ? o() : t();
+  };
+  return /* @__PURE__ */ A.jsx(ro, { onClick: r, children: s ? (
+    // Show double check mark when all rows are selected
+    /* @__PURE__ */ A.jsx(ae, { icon: "done_all" })
+  ) : i ? (
+    // Show minimize icon when some (but not all) rows are selected
+    /* @__PURE__ */ A.jsx(ae, { icon: "remove" })
+  ) : (
+    // Show nothing when no rows are selected
+    null
+  ) });
+}, ao = Me(lo), ze = (e) => (n, t, ...o) => n.original.isLoading !== t.original.isLoading ? n.original.isLoading ? 1 : -1 : e(n, t, ...o), co = (e, n) => {
+  const t = e.original.label || e.original.name, o = n.original.label || n.original.name;
+  return t.localeCompare(o);
+}, uo = (e, n) => {
+  const t = e.original.path || e.original.name, o = n.original.path || n.original.name;
+  return t.localeCompare(o);
+}, Ye = (e, n, t, o) => {
+  const s = Te(e.original, t), i = Te(n.original, t);
+  if (o && o.enum) {
+    const r = o.enum.findIndex((f) => f.value === s), l = o.enum.findIndex((f) => f.value === i);
+    return r - l < 0 ? 1 : -1;
+  } else return (o == null ? void 0 : o.type) === "datetime" ? Ve.datetime(e, n, t) : (o == null ? void 0 : o.type) === "boolean" ? (s === !0 ? 1 : 0) - (i === !0 ? 1 : 0) : Ve.alphanumeric(e, n, t);
+}, ho = ({
+  tableData: e,
+  attribs: n,
+  columnSizing: t = {},
+  showHierarchy: o,
+  isLoading: s,
+  sliceId: i,
+  options: r,
+  toggleExpandAll: l,
+  toggleExpanded: f
+}) => {
+  const { updateEntities: x } = ye();
+  return U(() => {
+    const d = [
+      {
+        id: H,
+        header: () => /* @__PURE__ */ A.jsx(ao, {}),
+        cell: () => /* @__PURE__ */ A.jsx(io, {}),
+        size: 20
+      },
+      {
+        accessorKey: "name",
+        header: () => "Folder / Task",
+        sortingFn: ze(o ? co : uo),
+        cell: ({ row: u, column: g }) => {
+          const a = B(u.id, g.id);
+          return /* @__PURE__ */ A.jsx(
+            ft,
+            {
+              id: a,
+              className: q("large", u.original.entityType, {
+                loading: u.original.isLoading,
+                hierarchy: o
+              }),
+              style: {
+                paddingLeft: `calc(${u.depth * 1}rem + 8px)`
+              },
+              tabIndex: 0,
+              children: /* @__PURE__ */ A.jsx(
+                Yn,
+                {
+                  id: u.id,
+                  label: u.original.label,
+                  name: u.original.name,
+                  path: o ? void 0 : u.original.path,
+                  showHierarchy: o,
+                  icon: u.original.icon,
+                  type: u.original.entityType,
+                  isExpanded: u.getIsExpanded(),
+                  toggleExpandAll: l,
+                  toggleExpanded: () => f(u.id)
+                }
+              )
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "status",
+        header: () => "Status",
+        sortingFn: ze(
+          (u, g, a) => Ye(u, g, a, { enum: r.statuses, type: "string" })
+        ),
+        sortDescFirst: !0,
+        size: t.status || 150,
+        cell: ({ row: u, column: g }) => {
+          const { value: a, id: h, type: c } = be(u, g.id);
+          return /* @__PURE__ */ A.jsx(
+            me,
+            {
+              rowId: h,
+              className: q("status", { loading: u.original.isLoading }),
+              columnId: g.id,
+              value: a,
+              attributeData: { type: "string" },
+              options: r.statuses.filter((y) => {
+                var p;
+                return (p = y.scope) == null ? void 0 : p.includes(c);
+              }),
+              isCollapsed: !!u.original.childOnlyMatch,
+              onChange: (y) => x([{ field: g.id, value: y, id: h, type: c }])
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "subType",
+        header: () => "Type",
+        size: t.type || 150,
+        cell: ({ row: u, column: g }) => {
+          const { value: a, id: h, type: c } = be(u, g.id), y = c === "folder" ? "folderType" : "taskType";
+          return /* @__PURE__ */ A.jsx(
+            me,
+            {
+              rowId: h,
+              className: q("subType", { loading: u.original.isLoading }),
+              columnId: g.id,
+              value: a,
+              attributeData: { type: "string" },
+              options: c === "folder" ? r.folderTypes : r.taskTypes,
+              isCollapsed: !!u.original.childOnlyMatch,
+              onChange: (p) => x([{ field: y, value: p, id: h, type: c }])
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "assignees",
+        header: () => "Assignees",
+        size: t.assignees || 150,
+        cell: ({ row: u, column: g }) => {
+          const { value: a, id: h, type: c } = be(u, g.id);
+          return c === "folder" ? /* @__PURE__ */ A.jsx(
+            me,
+            {
+              rowId: h,
+              className: q("assignees", { loading: u.original.isLoading }),
+              columnId: g.id,
+              value: "",
+              isPlaceholder: !0
+            }
+          ) : /* @__PURE__ */ A.jsx(
+            me,
+            {
+              rowId: h,
+              className: q("assignees", { loading: u.original.isLoading }),
+              columnId: g.id,
+              value: a,
+              attributeData: { type: "list_of_strings" },
+              options: r.assignees,
+              isCollapsed: !!u.original.childOnlyMatch,
+              onChange: (y) => x([{ field: g.id, value: y, id: h, type: c }])
+            }
+          );
+        }
+      },
+      {
+        accessorKey: "tags",
+        header: () => "Tags",
+        size: t.tags || 150,
+        cell: ({ row: u, column: g }) => {
+          const { value: a, id: h, type: c } = be(u, g.id);
+          return /* @__PURE__ */ A.jsx(
+            me,
+            {
+              rowId: h,
+              className: q("tags", { loading: u.original.isLoading }),
+              columnId: g.id,
+              value: a,
+              attributeData: { type: "list_of_strings" },
+              options: r.tags,
+              isCollapsed: !!u.original.childOnlyMatch,
+              onChange: (y) => x([{ field: g.id, value: y, id: h, type: c }]),
+              enableCustomValues: !0
+            }
+          );
+        }
+      }
+    ], v = n.map((u) => ({
+      accessorKey: "attrib." + u.name,
+      header: () => u.data.title || u.name,
+      filterFn: "fuzzy",
+      sortingFn: ze((a, h, c) => Ye(a, h, c, u.data)),
+      cell: ({ row: a, column: h }) => {
+        const c = h.id.replace("attrib_", ""), { value: y, id: p, type: w } = be(a, c, "attrib"), m = !a.original.ownAttrib.includes(c);
+        return /* @__PURE__ */ A.jsx(
+          me,
+          {
+            rowId: p,
+            className: q("attrib", { loading: a.original.isLoading }),
+            columnId: h.id,
+            value: y,
+            attributeData: { type: u.data.type || "string" },
+            options: u.data.enum || [],
+            isCollapsed: !!a.original.childOnlyMatch,
+            isInherited: m,
+            isReadOnly: u.readOnly,
+            onChange: (E) => x([{ field: c, value: E, id: p, type: w, isAttrib: !0 }])
+          }
+        );
+      }
+    }));
+    return [...d, ...v];
+  }, [s, i, e, r, n, o, x]);
+}, be = (e, n, t) => {
+  var o;
+  return {
+    value: t ? (o = e.original[t]) == null ? void 0 : o[n] : e.original[n],
+    id: e.id,
+    type: e.original.entityType
+  };
+}, fo = N(et)`
+  padding: 0px !important;
+  display: none;
+  background-color: var(--md-sys-color-surface-container-lowest);
+
+  &.selected {
+    display: flex;
+  }
+`, je = ({ selected: e, style: n, ...t }) => /* @__PURE__ */ A.jsx(
+  fo,
+  {
+    ...t,
+    selected: e,
+    className: q(t.className, "action", { selected: e }),
+    variant: "text",
+    style: { ...n }
+  }
+), go = (e, n) => {
+  const t = e.getFlatHeaders(), o = e.getState().columnSizingInfo;
+  return U(() => {
+    const i = {};
+    for (let r = 0; r < t.length; r++) {
+      const l = t[r];
+      i[`--header-${l.id}-size`] = l.getSize(), i[`--col-${l.column.id}-size`] = l.column.getSize();
+    }
+    return i;
+  }, [o, n, t]);
+}, mo = () => {
+  const { getFoldersTasks: e } = _e(), [n, t] = Q([]), { projectName: o, queryFilters: s } = ue();
+  return { handlePreFetchTasks: (r) => {
+    const l = r.target, f = l.closest("td");
+    if (!l.closest(".expander") || !f) return;
+    const x = f.firstElementChild, d = x == null ? void 0 : x.id;
+    if (!d) return;
+    const { colId: v, rowId: u } = V(d) || {};
+    v !== "name" || !u || !x.className.includes("folder") || n.includes(u) || (t((a) => [...a, u]), e(
+      {
+        parentIds: [u],
+        filter: s.filterString,
+        search: s.search
+      },
+      !0
+    ));
+  } };
+}, po = ({ onSuccess: e }) => {
+  const { updateEntities: n } = _e(), { getEntityById: t } = ue();
+  return M(
+    async (s) => {
+      if (!s || s.length === 0)
+        return;
+      const i = s.map((l) => {
+        var f;
+        return t(((f = V(l)) == null ? void 0 : f.rowId) || "");
+      }).filter(Boolean);
+      if (i.length === 0) return;
+      const r = async (l = !1) => {
+        const f = [];
+        for (const x of i)
+          x && f.push({
+            entityType: "folderId" in x ? "task" : "folder",
+            type: "delete",
+            entityId: x.id,
+            force: l
+          });
+        try {
+          await (n == null ? void 0 : n({ operations: f })), e && e();
+        } catch (x) {
+          const d = (x == null ? void 0 : x.error) || "Failed to delete entities";
+          throw console.error("Failed to delete entities:", x), { message: d, ...x };
+        }
+      };
+      We({
+        label: "folders and tasks",
+        message: `Are you sure you want to delete ${s.length} entities? This action cannot be undone.`,
+        accept: r,
+        onError: (l) => {
+          var x;
+          (x = l == null ? void 0 : l.errorCodes) != null && x.includes("delete-folder-with-children") && We({
+            label: "folders and tasks",
+            message: `This folder has child tasks or products that will also be deleted. Are you sure you want to delete ${s.length} entities and all of it's dependencies?`,
+            accept: () => r(!0),
+            deleteLabel: "Delete all (dangerous)"
+          });
+        },
+        deleteLabel: "Delete forever"
+      });
+    },
+    [t, n, e]
+  );
+}, yo = ({ attribs: e, onOpenNew: n }) => {
+  const { projectName: t, showHierarchy: o, getEntityById: s, toggleExpandAll: i } = ue(), { copyToClipboard: r, exportCSV: l, pasteFromClipboard: f } = Mn(), { isCellSelected: x, selectedCells: d, clearSelection: v, selectCell: u } = he(), { inheritFromParent: g } = ye(), a = po({}), [h] = Dt(), c = (w, m, E) => {
+    const { rowId: k, colId: D } = V(m) || {}, b = e.find((L) => L.name === (D == null ? void 0 : D.replace("attrib_", "")));
+    if (!k)
+      return [
+        {
+          label: "Copy",
+          icon: "content_copy",
+          shortcut: Ee("c", [Ae.Ctrl]),
+          command: () => r(E),
+          shouldShow: !0
+        }
+      ];
+    const I = D === "name", C = E.length === 1, S = y(E), j = /* @__PURE__ */ new Set(), T = /* @__PURE__ */ new Set();
+    for (const L of E) {
+      const W = V(L);
+      W && (W.rowId && j.add(W.rowId), W.colId && T.add(W.colId));
+    }
+    const z = Array.from(j), R = Array.from(d).filter(
+      (L) => {
+        var W;
+        return ((W = V(L)) == null ? void 0 : W.colId) === H;
+      }
+    ), O = j.size > 1, $ = T.size > 1, F = O && $, _ = S.length > 0 && o && !F;
+    return [
+      // Clipboard operations
+      {
+        label: "Copy",
+        icon: "content_copy",
+        shortcut: Ee("c", [Ae.Ctrl]),
+        command: () => r(E),
+        shouldShow: !0
+        // Always shown
+      },
+      {
+        label: `Copy row${R.length > 1 ? "s" : ""}`,
+        icon: "content_copy",
+        command: () => r(R, !0),
+        shouldShow: I && R.some((L) => {
+          var W, P;
+          return ((W = V(L)) == null ? void 0 : W.rowId) === ((P = V(m)) == null ? void 0 : P.rowId);
+        })
+      },
+      {
+        label: "Paste",
+        icon: "content_paste",
+        shortcut: Ee("v", [Ae.Ctrl]),
+        command: () => f(E),
+        shouldShow: !I,
+        disabled: b == null ? void 0 : b.readOnly
+      },
+      // Entity operations
+      {
+        label: "Show details",
+        icon: "dock_to_left",
+        shortcut: "Double click",
+        command: () => {
+          const L = B(k, H);
+          u(L, !1, !1);
+        },
+        shouldShow: I && C
+      },
+      // Expand/collapse (all) operations - only for name column
+      {
+        label: "Expand all",
+        icon: "expand_all",
+        shortcut: "Alt + click",
+        command: () => i(z, !0),
+        shouldShow: I
+      },
+      {
+        label: "Collapse all",
+        icon: "collapse_all",
+        shortcut: "Alt + click",
+        command: () => i(z, !1),
+        shouldShow: I
+      },
+      // Attribute operations
+      {
+        label: "Inherit from parent",
+        icon: "disabled_by_default",
+        command: () => g(S),
+        shouldShow: _
+      },
+      // Export operations
+      {
+        label: "Export selection",
+        icon: "download",
+        command: () => l(E, t),
+        shouldShow: !0
+        // Always shown
+      },
+      // Creation operations (only in name column and hierarchy mode)
+      {
+        label: "Create folder",
+        icon: "create_new_folder",
+        command: () => n == null ? void 0 : n("folder"),
+        shouldShow: I && o && !!n
+      },
+      {
+        label: "Create root folder",
+        icon: "create_new_folder",
+        command: () => {
+          v(), n == null || n("folder");
+        },
+        shouldShow: I && o && !!n
+      },
+      {
+        label: "Create task",
+        icon: "add_task",
+        command: () => n == null ? void 0 : n("task"),
+        shouldShow: I && o && !!n
+      },
+      // Destructive operations
+      {
+        label: "Delete",
+        icon: "delete",
+        danger: !0,
+        command: () => a(E),
+        shouldShow: I
+      }
+    ].filter((L) => L.shouldShow).map(({ shouldShow: L, ...W }) => W);
+  }, y = (w) => w.reduce((m, E) => {
+    var j;
+    const { rowId: k, colId: D } = V(E) || {};
+    if (!k || !D || !D.startsWith("attrib_")) return m;
+    const b = s(k);
+    if (!b) return m;
+    const I = D.replace("attrib_", ""), C = e.find((T) => T.name === I), S = C == null ? void 0 : C.data.inherit;
+    if ((j = b.ownAttrib) != null && j.includes(I) && S) {
+      const T = m.findIndex((z) => z.entityId === k);
+      T >= 0 ? m[T].attribs.includes(I) || m[T].attribs.push(I) : m.push({
+        entityId: k,
+        entityType: "folderId" in b ? "task" : "folder",
+        attribs: [I],
+        ownAttrib: b.ownAttrib || [],
+        // @ts-ignore
+        folderId: b.parentId ?? b.folderId
+      });
+    }
+    return m;
+  }, []);
+  return { handleTableBodyContextMenu: (w) => {
+    var D;
+    const E = w.target.closest("td"), k = (D = E == null ? void 0 : E.firstElementChild) == null ? void 0 : D.id;
+    if (k) {
+      let b = Array.from(d);
+      x(k) || (b = [k]), h(w, c(w, k, b));
+    }
+  } };
+}, wo = ({
+  visibleColumns: e,
+  tableContainerRef: n,
+  columnPinning: t
+}) => {
+  var x;
+  const o = U(() => e.filter((d) => d.getIsPinned() === "left").map((d) => d.getIndex()), [e, t]), s = [];
+  if (o.length > 0) {
+    const d = Math.max(...o);
+    for (let v = 0; v <= d; v++)
+      s.push(v);
+  }
+  const i = ot({
+    count: e.length,
+    estimateSize: (d) => e[d].getSize(),
+    //estimate width of each column for accurate scrollbar dragging
+    getScrollElement: () => n.current,
+    horizontal: !0,
+    overscan: 0,
+    //how many columns to render on each side off screen each way (adjust this for performance)
+    rangeExtractor: (d) => {
+      const v = d.startIndex, u = d.endIndex, g = d.overscan, a = [];
+      for (let c = v - g; c <= u + g; c++)
+        c >= 0 && c < e.length && a.push(c);
+      const h = /* @__PURE__ */ new Set([
+        ...s,
+        // All columns up to the highest pinned column
+        ...a
+        // Visible columns in the current range
+      ]);
+      return Array.from(h).sort((c, y) => c - y);
+    }
+  }), r = i.getVirtualItems();
+  let l, f;
+  if (i && r.length) {
+    const d = i.getTotalSize(), v = r.findIndex(
+      (g) => !s.includes(g.index)
+    );
+    if (v !== -1) {
+      const g = r[v].start, a = s.reduce((h, c) => {
+        const y = e[c];
+        return h + y.getSize();
+      }, 0);
+      l = Math.max(0, g - a);
+    } else
+      l = 0;
+    const u = ((x = r[r.length - 1]) == null ? void 0 : x.end) ?? 0;
+    f = Math.max(0, d - u);
+  }
+  return {
+    columnVirtualizer: i,
+    virtualPaddingLeft: l,
+    virtualPaddingRight: f
+  };
+};
+function bo() {
+  const { attribFields: e } = ue(), { focusedCellId: n, gridMap: t, selectCell: o, focusCell: s, clearSelection: i, setFocusedCellId: r } = he(), { setEditingCellId: l, editingCellId: f } = ye(), x = M(
+    (d) => {
+      var p;
+      const v = d.target;
+      if (!(v != null && v.closest("table")) || v.tagName === "INPUT" || v.tagName === "TEXTAREA" || v.isContentEditable || v.getAttribute("role") === "textbox" || v.tagName === "LI" || f || !n) return;
+      const u = V(n);
+      if (!u) return;
+      const { rowId: g, colId: a } = u, h = t.rowIdToIndex.get(g), c = t.colIdToIndex.get(a);
+      if (h === void 0 || c === void 0) return;
+      const y = a.startsWith("attrib_") && ((p = e.find((w) => w.name === a.replace("attrib_", ""))) == null ? void 0 : p.readOnly);
+      switch (d.key) {
+        case "ArrowUp": {
+          if (d.preventDefault(), h > 0) {
+            const w = t.indexToRowId.get(h - 1);
+            if (w) {
+              const m = B(w, a);
+              o(m, d.shiftKey, d.shiftKey), s(m);
+            }
+          }
+          break;
+        }
+        case "ArrowDown": {
+          d.preventDefault();
+          const w = t.indexToRowId.get(h + 1);
+          if (w) {
+            const m = B(w, a);
+            o(m, d.shiftKey, d.shiftKey), s(m);
+          }
+          break;
+        }
+        case "ArrowLeft": {
+          if (d.preventDefault(), c > 0) {
+            const w = t.indexToColId.get(c - 1);
+            if (w) {
+              const m = B(g, w);
+              o(m, d.shiftKey, d.shiftKey), s(m);
+            }
+          }
+          break;
+        }
+        case "ArrowRight": {
+          d.preventDefault();
+          const w = t.indexToColId.get(c + 1);
+          if (w) {
+            const m = B(g, w);
+            o(m, d.shiftKey, d.shiftKey), s(m);
+          }
+          break;
+        }
+        case "Enter": {
+          if (d.preventDefault(), y) return;
+          l(n);
+          break;
+        }
+        case "Escape": {
+          d.preventDefault(), i(), l(null), r(null);
+          break;
+        }
+        case "Tab": {
+          d.preventDefault();
+          const w = d.shiftKey ? c - 1 : c + 1, m = t.indexToColId.get(w);
+          if (m) {
+            const E = B(g, m);
+            o(E, !1, !1), s(E);
+          } else if (!d.shiftKey && h < t.rowIdToIndex.size - 1) {
+            const E = t.indexToRowId.get(h + 1), k = t.indexToColId.get(0);
+            if (E && k) {
+              const D = B(E, k);
+              o(D, !1, !1), s(D);
+            }
+          } else if (d.shiftKey && h > 0) {
+            const E = t.indexToRowId.get(h - 1), k = t.indexToColId.get(t.colIdToIndex.size - 1);
+            if (E && k) {
+              const D = B(E, k);
+              o(D, !1, !1), s(D);
+            }
+          }
+          break;
+        }
+      }
+    },
+    [
+      n,
+      t,
+      o,
+      s,
+      i,
+      l,
+      f
+    ]
+  );
+  return J(() => (document.addEventListener("keydown", x), () => {
+    document.removeEventListener("keydown", x);
+  }), [
+    x,
+    n,
+    t,
+    o,
+    s,
+    i,
+    l,
+    f
+  ]), {
+    handleKeyDown: x,
+    focusedCellId: n,
+    gridMap: t,
+    selectCell: o,
+    focusCell: s,
+    clearSelection: i,
+    setEditingCellId: l,
+    editingCellId: f
+  };
+}
+const gt = (e) => {
+  const n = e.getIsPinned();
+  return {
+    left: n === "left" ? `${e.getStart("left")}px` : void 0,
+    right: n === "right" ? `${e.getAfter("right")}px` : void 0,
+    position: n ? "sticky" : "relative",
+    width: e.getSize(),
+    zIndex: n ? 100 : 0
+  };
+}, Yo = (e) => {
+  const n = U(() => e.attribs.reduce((t, o) => {
+    var s, i, r;
+    return (i = (s = o.data) == null ? void 0 : s.enum) != null && i.length && (t[o.name] = (r = o.data) == null ? void 0 : r.enum), t;
+  }, {}), [e.attribs]);
+  return /* @__PURE__ */ A.jsx(
+    $n,
+    {
+      foldersMap: e.foldersMap,
+      tasksMap: e.tasksMap,
+      columnEnums: { ...e.options, ...n },
+      columnReadOnly: e.attribs.filter((t) => t.readOnly).map((t) => t.name),
+      children: /* @__PURE__ */ A.jsx(xo, { ...e })
+    }
+  );
+}, xo = ({
+  scope: e,
+  attribs: n,
+  options: t,
+  sliceId: o,
+  fetchMoreOnBottomReached: s,
+  onOpenNew: i
+}) => {
+  const {
+    columnVisibility: r,
+    columnVisibilityUpdater: l,
+    columnPinning: f,
+    columnPinningUpdater: x,
+    columnOrder: d,
+    columnOrderUpdater: v
+  } = _n(), {
+    tableData: u,
+    isLoading: g,
+    isInitialized: a,
+    expanded: h,
+    updateExpanded: c,
+    toggleExpandAll: y,
+    toggleExpanded: p,
+    sorting: w,
+    updateSorting: m,
+    showHierarchy: E
+  } = ue(), k = re(null), { registerGrid: D } = he(), [b, I] = kt(
+    `column-widths-${e}`,
+    {}
+  ), C = (P) => {
+    I(ve(P, b));
+  };
+  J(() => {
+    s(k.current);
+  }, [s]);
+  const { loadingAttrib: S, loadingRows: j } = U(() => {
+    var Y;
+    const P = ((Y = k.current) == null ? void 0 : Y.querySelectorAll("tbody tr").length) || 0, ee = Tn(), G = $e(
+      n,
+      E && u.length > 0 ? Math.min(P, 50) : 50
+    );
+    return { loadingAttrib: ee, loadingRows: G };
+  }, [n, u, E, k.current]), T = !a || g, z = ho({
+    tableData: T ? j : u,
+    columnSizing: b,
+    attribs: a ? n : S,
+    isLoading: !a,
+    showHierarchy: E,
+    sliceId: o,
+    options: t,
+    toggleExpandAll: (P) => y([P]),
+    toggleExpanded: (P) => p(P)
+  }), R = bt({
+    data: T ? j : u,
+    columns: z,
+    enableRowSelection: !0,
+    //enable row selection for all rows
+    getRowId: (P) => P.id,
+    enableSubRowSelection: !1,
+    //disable sub row selection
+    getSubRows: (P) => P.subRows,
+    getRowCanExpand: () => !0,
+    getCoreRowModel: Tt(),
+    getFilteredRowModel: Ct(),
+    getExpandedRowModel: vt(),
+    filterFromLeafRows: !0,
+    // EXPANDABLE
+    onExpandedChange: c,
+    // SORTING
+    getSortedRowModel: It(),
+    onSortingChange: m,
+    columnResizeMode: "onChange",
+    onColumnPinningChange: x,
+    onColumnSizingChange: C,
+    onColumnVisibilityChange: l,
+    onColumnOrderChange: v,
+    // @ts-ignore
+    filterFns: xt,
+    state: {
+      expanded: h,
+      sorting: w,
+      columnPinning: {
+        left: [H, ...f.left || []],
+        right: f.right
+      },
+      columnSizing: b,
+      columnVisibility: r,
+      columnOrder: d
+    },
+    enableSorting: !0
+  }), { rows: O } = R.getRowModel();
+  J(() => {
+    const P = O.map((Y) => Y.id), G = [...R.getAllLeafColumns().map((Y) => Y.id)].sort((Y, fe) => {
+      var Fe, Pe;
+      if (H === fe) return 1;
+      const xe = (Fe = f.left) != null && Fe.includes(Y) ? 0 : 1, mt = (Pe = f.left) != null && Pe.includes(fe) ? 0 : 1;
+      return xe - mt;
+    });
+    D(P, G);
+  }, [O, R.getAllLeafColumns(), f, H, D]);
+  const $ = R.getVisibleLeafColumns(), { columnVirtualizer: F, virtualPaddingLeft: _, virtualPaddingRight: K } = wo({
+    visibleColumns: $,
+    tableContainerRef: k,
+    columnPinning: f
+  }), L = go(R, b), W = U(
+    () => n.filter((P) => P.readOnly).map((P) => "attrib_" + P.name),
+    [n]
+  );
+  return /* @__PURE__ */ A.jsx(no, { children: /* @__PURE__ */ A.jsx(
+    oo,
+    {
+      ref: k,
+      style: { height: "100%", padding: 0 },
+      onScroll: (P) => s(P.currentTarget),
+      className: "table-container",
+      children: /* @__PURE__ */ A.jsxs(
+        "table",
+        {
+          style: {
+            display: "grid",
+            borderCollapse: "collapse",
+            userSelect: "none",
+            ...L,
+            width: R.getTotalSize()
+          },
+          children: [
+            /* @__PURE__ */ A.jsx(
+              Io,
+              {
+                columnVirtualizer: F,
+                table: R,
+                virtualPaddingLeft: _,
+                virtualPaddingRight: K,
+                isLoading: g,
+                readOnlyColumns: W
+              }
+            ),
+            /* @__PURE__ */ A.jsx(
+              To,
+              {
+                columnVirtualizer: F,
+                table: R,
+                tableContainerRef: k,
+                virtualPaddingLeft: _,
+                virtualPaddingRight: K,
+                showHierarchy: E,
+                attribs: n,
+                onOpenNew: i
+              }
+            )
+          ]
+        }
+      )
+    }
+  ) });
+}, Io = ({
+  columnVirtualizer: e,
+  table: n,
+  virtualPaddingLeft: t,
+  virtualPaddingRight: o,
+  isLoading: s,
+  readOnlyColumns: i
+}) => /* @__PURE__ */ A.jsx(to, { children: n.getHeaderGroups().map((r) => /* @__PURE__ */ A.jsx(
+  vo,
+  {
+    columnVirtualizer: e,
+    headerGroup: r,
+    virtualPaddingLeft: t,
+    virtualPaddingRight: o,
+    isLoading: s,
+    readOnlyColumns: i
+  },
+  r.id
+)) }), vo = ({
+  columnVirtualizer: e,
+  headerGroup: n,
+  virtualPaddingLeft: t,
+  virtualPaddingRight: o,
+  isLoading: s,
+  readOnlyColumns: i
+}) => {
+  const r = e.getVirtualItems();
+  return /* @__PURE__ */ A.jsxs(Jn, { style: { display: "flex" }, children: [
+    t ? (
+      //fake empty column to the left for virtualization scroll padding
+      /* @__PURE__ */ A.jsx("th", { style: { display: "flex", width: t } })
+    ) : null,
+    r.map((l) => {
+      const f = n.headers[l.index];
+      return /* @__PURE__ */ A.jsx(
+        Co,
+        {
+          header: f,
+          isLoading: s,
+          isReadOnly: i == null ? void 0 : i.includes(f.id)
+        },
+        f.id
+      );
+    }),
+    o ? (
+      //fake empty column to the right for virtualization scroll padding
+      /* @__PURE__ */ A.jsx("th", { style: { display: "flex", width: o } })
+    ) : null
+  ] }, n.id);
+}, Co = ({ header: e, isLoading: n, isReadOnly: t }) => {
+  const { column: o } = e, s = o.id === H;
+  return /* @__PURE__ */ A.jsx(
+    Gn,
+    {
+      className: q(e.id, "shimmer-dark", {
+        loading: n,
+        large: o.id === "folderType",
+        "last-pinned-left": o.getIsPinned() === "left" && o.getIsLastColumn("left")
+      }),
+      style: {
+        ...gt(o),
+        width: `calc(var(--header-${e == null ? void 0 : e.id}-size) * 1px)`
+      },
+      children: e.isPlaceholder ? null : /* @__PURE__ */ A.jsxs(
+        ft,
+        {
+          className: q("bold", {
+            large: o.id === "folderType"
+          }),
+          children: [
+            Je(o.columnDef.header, e.getContext()),
+            t && /* @__PURE__ */ A.jsx(ae, { icon: "lock", "data-tooltip": "You only have permission to read this column." }),
+            /* @__PURE__ */ A.jsxs(Xn, { className: "actions", children: [
+              /* @__PURE__ */ A.jsx(
+                je,
+                {
+                  icon: "visibility_off",
+                  selected: !o.getIsVisible(),
+                  onClick: o.getToggleVisibilityHandler()
+                }
+              ),
+              /* @__PURE__ */ A.jsx(
+                je,
+                {
+                  icon: "push_pin",
+                  selected: e.column.getIsPinned() === "left",
+                  onClick: () => {
+                    e.column.getIsPinned() === "left" ? e.column.pin(!1) : e.column.pin("left");
+                  }
+                }
+              ),
+              /* @__PURE__ */ A.jsx(
+                je,
+                {
+                  icon: "sort",
+                  style: {
+                    transform: o.getIsSorted() === "asc" ? "scaleY(-1)" : void 0
+                  },
+                  onClick: o.getToggleSortingHandler(),
+                  selected: !!o.getIsSorted()
+                }
+              )
+            ] }),
+            !s && /* @__PURE__ */ A.jsx(
+              Qn,
+              {
+                onDoubleClick: () => o.resetSize(),
+                onMouseDown: e.getResizeHandler(),
+                onTouchStart: e.getResizeHandler(),
+                className: q("resize-handle", {
+                  resizing: o.getIsResizing()
+                })
+              }
+            )
+          ]
+        }
+      )
+    },
+    e.id
+  );
+}, To = ({
+  columnVirtualizer: e,
+  table: n,
+  tableContainerRef: t,
+  showHierarchy: o,
+  virtualPaddingLeft: s,
+  virtualPaddingRight: i,
+  attribs: r,
+  onOpenNew: l
+}) => {
+  const { handleTableBodyContextMenu: f } = yo({ attribs: r, onOpenNew: l }), { handlePreFetchTasks: x } = mo(), { rows: d } = n.getRowModel(), v = ot({
+    count: d.length,
+    estimateSize: () => o ? 36 : 40,
+    //estimate row height for accurate scrollbar dragging
+    getScrollElement: () => t.current,
+    //measure dynamic row height, except in firefox because it measures table border height incorrectly
+    measureElement: typeof window < "u" && navigator.userAgent.indexOf("Firefox") === -1 ? (g) => g == null ? void 0 : g.getBoundingClientRect().height : void 0,
+    overscan: 5
+  }), u = v.getVirtualItems();
+  return bo(), u.length ? /* @__PURE__ */ A.jsx(
+    "tbody",
+    {
+      style: {
+        height: `${v.getTotalSize()}px`,
+        position: "relative",
+        display: "grid"
+      },
+      onContextMenu: f,
+      onMouseOver: (g) => {
+        x(g);
+      },
+      children: u.map((g) => {
+        const a = d[g.index];
+        return /* @__PURE__ */ A.jsx(
+          So,
+          {
+            columnVirtualizer: e,
+            row: a,
+            rowVirtualizer: v,
+            virtualPaddingLeft: s,
+            virtualPaddingRight: i,
+            virtualRow: g,
+            showHierarchy: o
+          },
+          a.id
+        );
+      })
+    }
+  ) : t.current && wt(
+    /* @__PURE__ */ A.jsx(St, { message: "No folders or tasks found" }),
+    t.current
+  );
+}, So = ({
+  columnVirtualizer: e,
+  row: n,
+  rowVirtualizer: t,
+  virtualPaddingLeft: o,
+  virtualPaddingRight: s,
+  virtualRow: i,
+  showHierarchy: r
+}) => {
+  const l = n.getVisibleCells(), f = e.getVirtualItems();
+  return /* @__PURE__ */ A.jsxs(
+    Zn,
+    {
+      "data-index": i.index,
+      ref: (x) => t.measureElement(x),
+      style: {
+        transform: `translateY(${i.start}px)`
+        //this should always be a `style` as it changes on scroll
+      },
+      children: [
+        o ? (
+          //fake empty column to the left for virtualization scroll padding
+          /* @__PURE__ */ A.jsx("td", { style: { display: "flex", width: o } })
+        ) : null,
+        f.map((x) => {
+          const d = l[x.index], v = B(n.id, d.column.id);
+          return /* @__PURE__ */ A.jsx(
+            Ao,
+            {
+              cell: d,
+              cellId: v,
+              rowId: n.id,
+              showHierarchy: r
+            },
+            d.id
+          );
+        }),
+        s ? (
+          //fake empty column to the right for virtualization scroll padding
+          /* @__PURE__ */ A.jsx("td", { style: { display: "flex", width: s } })
+        ) : null
+      ]
+    },
+    n.id
+  );
+}, Eo = ({ cell: e, rowId: n, cellId: t, className: o, showHierarchy: s, ...i }) => {
+  const {
+    isCellSelected: r,
+    isCellFocused: l,
+    startSelection: f,
+    extendSelection: x,
+    endSelection: d,
+    selectCell: v,
+    getCellBorderClasses: u
+  } = he(), { isRowSelected: g } = ut(), { isEditing: a } = ye(), h = u(t), y = e.column.getIsPinned() === "left" && e.column.getIsLastColumn("left"), p = e.column.id === H;
+  return /* @__PURE__ */ pt(
+    eo,
+    {
+      ...i,
+      tabIndex: 0,
+      key: e.id,
+      $isLastPinned: y,
+      className: q(
+        e.column.id,
+        e.column.id === "folderType" ? "large" : "",
+        {
+          selected: r(t),
+          focused: l(t),
+          editing: a(t),
+          "last-pinned-left": y,
+          "selected-row": g(n),
+          task: e.row.original.entityType === "task"
+        },
+        o,
+        ...h
+      ),
+      style: {
+        ...gt(e.column),
+        width: `calc(var(--col-${e.column.id}-size) * 1px)`,
+        height: s ? 36 : 40
+      },
+      onMouseDown: (w) => {
+        if (w.button !== 0 || w.target.closest(".expander")) return;
+        const m = w.metaKey || w.ctrlKey || p;
+        w.shiftKey ? v(t, m, !0) : f(t, m);
+      },
+      onMouseOver: (w) => {
+        w.buttons === 1 && x(t, p);
+      },
+      onMouseUp: () => {
+        d(t);
+      },
+      onDoubleClick: (w) => {
+        if (e.column.id === "name") {
+          const m = B(e.row.id, H);
+          if (!r(m)) {
+            const E = w.metaKey || w.ctrlKey;
+            v(m, E, !1);
+          }
+        }
+      },
+      onContextMenu: (w) => {
+        w.preventDefault(), r(t) || v(t, !1, !1);
+      }
+    },
+    Je(e.column.columnDef.cell, e.getContext())
+  );
+}, Ao = Me(Eo), Ze = "no_date", Zo = (e) => {
+  if (!e || e.length === 0)
+    return {};
+  const n = e.filter((t) => {
+    var o;
+    return !!((o = t.values) != null && o.length);
+  }).filter((t) => !t.id.includes("text")).filter((t) => t.id !== "hierarchy").flatMap((t) => Ro(t));
+  return console.log(n), {
+    conditions: n,
+    operator: "and"
+  };
+}, Ro = (e) => {
+  var f, x, d;
+  const n = e.id.split("_")[0];
+  let t;
+  const o = Array.isArray(e.values) && ((f = e.values.map((v) => v.id)) == null ? void 0 : f.includes("hasValue")), s = Array.isArray(e.values) && ((x = e.values.map((v) => v.id)) == null ? void 0 : x.includes("noValue"));
+  e.values && e.values.length > 0 && (e.singleSelect ? t = Qe(e.values[0].id, e.type) : t = e.values.map((v) => Qe(v.id, e.type)));
+  const i = ((d = e.type) == null ? void 0 : d.startsWith("list_of_")) || n.includes("tags") || n.includes("assignees"), r = e.type === "datetime";
+  let l = "eq";
+  if (t === void 0)
+    return l = e.inverted ? "notnull" : "isnull", { key: n, operator: l };
+  if (o)
+    t = i ? [] : void 0, l = i ? e.inverted ? "eq" : "ne" : e.inverted ? "isnull" : "notnull";
+  else if (s)
+    t = i ? [] : void 0, l = i ? e.inverted ? "ne" : "eq" : e.inverted ? "notnull" : "isnull";
+  else if (i)
+    e.inverted ? l = e.operator === "AND" ? "excludesall" : "excludesany" : l = e.operator === "AND" ? "includesall" : "includesany";
+  else if (r) {
+    if (e.values && e.values.length > 0) {
+      const v = e.values.flatMap((u) => {
+        const g = [], a = u.values;
+        return (a == null ? void 0 : a[0]) !== void 0 && (a == null ? void 0 : a[0].id) !== Ze && g.push({
+          key: n,
+          operator: e.inverted ? "lte" : "gte",
+          value: a[0].id
+        }), (a == null ? void 0 : a[1]) !== void 0 && (a == null ? void 0 : a[1].id) !== Ze && g.push({
+          key: n,
+          operator: e.inverted ? "gte" : "lte",
+          value: a[1].id
+        }), g;
+      });
+      if (v.length > 0)
+        return {
+          conditions: v,
+          operator: e.inverted ? "or" : "and"
+        };
+    }
+    l = e.inverted ? "ne" : "eq";
+  } else
+    l = e.inverted ? "notin" : "in";
+  return { key: n, value: t, operator: l };
+}, Qe = (e, n) => {
+  if (!n) return e;
+  switch (n) {
+    case "integer":
+      return parseInt(e, 10);
+    case "float":
+      return parseFloat(e);
+    case "boolean":
+      return e.toLowerCase() === "true";
+    default:
+      return e;
+  }
+};
+export {
+  qo as CellEditingProvider,
+  $n as ClipboardProvider,
+  Bo as ColumnSettingsProvider,
+  Uo as ProjectTableProvider,
+  Lo as ProjectTableQueriesProvider,
+  Yo as ProjectTreeTable,
+  H as ROW_SELECTION_COLUMN_ID,
+  Ho as SelectedRowsProvider,
+  Ko as SelectionProvider,
+  kn as builtInFieldMappings,
+  Zo as clientFilterToQueryFilter,
+  X as clipboardError,
+  Wo as determineLoadingTaskFolders,
+  Tn as generateDummyAttributes,
+  $e as generateLoadingRows,
+  rt as getEntityPath,
+  Dn as parseClipboardText,
+  zn as processFieldValue,
+  ye as useCellEditing,
+  Mn as useClipboard,
+  _n as useColumnSettings,
+  ue as useProjectTableContext,
+  _e as useProjectTableQueriesContext,
+  ut as useSelectedRowsContext,
+  he as useSelectionContext,
+  jn as validateClipboardData
+};
+//# sourceMappingURL=index.es8.js.map