@glideappsfinal/glide-data-grid 6.0.9 → 6.0.11

package/dist/cjs/internal/scrolling-data-grid/infinite-scroller.js

@@ -4,48 +4,15 @@ import { useResizeDetector } from "../../common/resize-detector.js";
 import { browserIsSafari } from "../../common/browser-detect.js";
 import { useEventListener } from "../../common/utils.js";
 import useKineticScroll from "./use-kinetic-scroll.js";
-const ScrollRegionStyle = styled.div `
-    .dvn-scroller {
-        overflow: ${p => (p.isSafari ? "scroll" : "auto")};
-        transform: translate3d(0, 0, 0);
-    }
-
-    .dvn-hidden {
-        visibility: hidden;
-    }
-
-    .dvn-scroll-inner {
-        display: flex;
-        pointer-events: none;
-
-        > * {
-            flex-shrink: 0;
-        }
-
-        .dvn-spacer {
-            flex-grow: 1;
-        }
-
-        .dvn-stack {
-            display: flex;
-            flex-direction: column;
-        }
-    }
-
-    .dvn-underlay > * {
-        position: absolute;
-        left: 0;
-        top: 0;
-    }
-
-    canvas {
-        outline: none;
-
-        * {
-            height: 0;
-        }
-    }
-`;
+const _exp = /*#__PURE__*/() => p => p.isSafari ? "scroll" : "auto";
+const ScrollRegionStyle = /*#__PURE__*/styled('div')({
+  name: "ScrollRegionStyle",
+  class: "gdg-s1dgczr6",
+  propsAsIs: false,
+  vars: {
+    "s1dgczr6-0": [_exp()]
+  }
+});
 // Browser's maximum div height limit. Varies a bit by browsers.
 const BROWSER_MAX_DIV_HEIGHT = 33_554_400;
 // Maximum height of a single padder segment to avoid browser performance issues.
@@ -57,19 +24,19 @@ const BROWSER_MAX_DIV_HEIGHT = 33_554_400;
 // based on the current scroll position.
 const MAX_PADDER_SEGMENT_HEIGHT = 5_000_000;
 function useTouchUpDelayed(delay) {
-    const [hasTouches, setHasTouches] = React.useState(false);
-    const safeWindow = typeof window === "undefined" ? null : window;
-    const cbTimer = React.useRef(0);
-    useEventListener("touchstart", React.useCallback(() => {
-        window.clearTimeout(cbTimer.current);
-        setHasTouches(true);
-    }, []), safeWindow, true, false);
-    useEventListener("touchend", React.useCallback(e => {
-        if (e.touches.length === 0) {
-            cbTimer.current = window.setTimeout(() => setHasTouches(false), delay);
-        }
-    }, [delay]), safeWindow, true, false);
-    return hasTouches;
+  const [hasTouches, setHasTouches] = React.useState(false);
+  const safeWindow = typeof window === "undefined" ? null : window;
+  const cbTimer = React.useRef(0);
+  useEventListener("touchstart", React.useCallback(() => {
+    window.clearTimeout(cbTimer.current);
+    setHasTouches(true);
+  }, []), safeWindow, true, false);
+  useEventListener("touchend", React.useCallback(e => {
+    if (e.touches.length === 0) {
+      cbTimer.current = window.setTimeout(() => setHasTouches(false), delay);
+    }
+  }, [delay]), safeWindow, true, false);
+  return hasTouches;
 }
 /**
  * InfiniteScroller provides virtual scrolling capabilities for the data grid.
@@ -83,183 +50,218 @@ function useTouchUpDelayed(delay) {
  *   to the full virtual scroll range
  */
 export const InfiniteScroller = p => {
-    const { children, clientHeight, scrollHeight, scrollWidth, update, draggable, className, preventDiagonalScrolling = false, paddingBottom = 0, paddingRight = 0, rightElement, rightElementProps, kineticScrollPerfHack = false, scrollRef, initialSize, } = p;
-    const padders = [];
-    const rightElementSticky = rightElementProps?.sticky ?? false;
-    const rightElementFill = rightElementProps?.fill ?? false;
-    // Track the virtual scroll position directly for smooth scrolling
-    const virtualScrollY = React.useRef(0);
-    const lastScrollY = React.useRef(0);
-    const scroller = React.useRef(null);
-    const dpr = typeof window === "undefined" ? 1 : window.devicePixelRatio;
-    const lastDpr = React.useRef(dpr);
-    // Reset scroll tracking when device pixel ratio changes (e.g., browser zoom)
-    React.useEffect(() => {
-        if (lastDpr.current !== dpr) {
-            virtualScrollY.current = 0;
-            lastScrollY.current = 0;
-            lastDpr.current = dpr;
-            const el = scroller.current;
-            if (el !== null) {
-                onScrollRef.current(el.scrollLeft, el.scrollTop);
-            }
-        }
-    }, [dpr]);
-    const lastScrollPosition = React.useRef({
-        scrollLeft: 0,
-        scrollTop: 0,
-        lockDirection: undefined,
+  const {
+    children,
+    clientHeight,
+    scrollHeight,
+    scrollWidth,
+    update,
+    draggable,
+    className,
+    preventDiagonalScrolling = false,
+    paddingBottom = 0,
+    paddingRight = 0,
+    rightElement,
+    rightElementProps,
+    kineticScrollPerfHack = false,
+    scrollRef,
+    initialSize
+  } = p;
+  const padders = [];
+  const rightElementSticky = rightElementProps?.sticky ?? false;
+  const rightElementFill = rightElementProps?.fill ?? false;
+  // Track the virtual scroll position directly for smooth scrolling
+  const virtualScrollY = React.useRef(0);
+  const lastScrollY = React.useRef(0);
+  const scroller = React.useRef(null);
+  const dpr = typeof window === "undefined" ? 1 : window.devicePixelRatio;
+  const lastDpr = React.useRef(dpr);
+  // Reset scroll tracking when device pixel ratio changes (e.g., browser zoom)
+  React.useEffect(() => {
+    if (lastDpr.current !== dpr) {
+      virtualScrollY.current = 0;
+      lastScrollY.current = 0;
+      lastDpr.current = dpr;
+      const el = scroller.current;
+      if (el !== null) {
+        onScrollRef.current(el.scrollLeft, el.scrollTop);
+      }
+    }
+  }, [dpr]);
+  const lastScrollPosition = React.useRef({
+    scrollLeft: 0,
+    scrollTop: 0,
+    lockDirection: undefined
+  });
+  const rightWrapRef = React.useRef(null);
+  const hasTouches = useTouchUpDelayed(200);
+  const [isIdle, setIsIdle] = React.useState(true);
+  const idleTimer = React.useRef(0);
+  React.useLayoutEffect(() => {
+    if (!isIdle || hasTouches || lastScrollPosition.current.lockDirection === undefined) return;
+    const el = scroller.current;
+    if (el === null) return;
+    const [lx, ly] = lastScrollPosition.current.lockDirection;
+    if (lx !== undefined) {
+      el.scrollLeft = lx;
+    } else if (ly !== undefined) {
+      el.scrollTop = ly;
+    }
+    lastScrollPosition.current.lockDirection = undefined;
+  }, [hasTouches, isIdle]);
+  const onScroll = React.useCallback((scrollLeft, scrollTop) => {
+    const el = scroller.current;
+    if (el === null) return;
+    scrollTop = scrollTop ?? el.scrollTop;
+    scrollLeft = scrollLeft ?? el.scrollLeft;
+    const lastScrollTop = lastScrollPosition.current.scrollTop;
+    const lastScrollLeft = lastScrollPosition.current.scrollLeft;
+    const dx = scrollLeft - lastScrollLeft;
+    const dy = scrollTop - lastScrollTop;
+    if (hasTouches && dx !== 0 && dy !== 0 && (Math.abs(dx) > 3 || Math.abs(dy) > 3) && preventDiagonalScrolling && lastScrollPosition.current.lockDirection === undefined) {
+      lastScrollPosition.current.lockDirection = Math.abs(dx) < Math.abs(dy) ? [lastScrollLeft, undefined] : [undefined, lastScrollTop];
+    }
+    const lock = lastScrollPosition.current.lockDirection;
+    scrollLeft = lock?.[0] ?? scrollLeft;
+    scrollTop = lock?.[1] ?? scrollTop;
+    lastScrollPosition.current.scrollLeft = scrollLeft;
+    lastScrollPosition.current.scrollTop = scrollTop;
+    const cWidth = el.clientWidth;
+    const cHeight = el.clientHeight;
+    const newY = scrollTop;
+    const delta = lastScrollY.current - newY;
+    const scrollableHeight = el.scrollHeight - cHeight;
+    lastScrollY.current = newY;
+    // Calculate the virtual Y position
+    let virtualY;
+    // When content height exceeds browser limits, use hybrid approach
+    if (scrollableHeight > 0 && scrollHeight > el.scrollHeight + 5) {
+      // For large jumps (scrollbar interaction) or edge positions,
+      // recalculate position based on percentage
+      if (Math.abs(delta) > 2000 || newY === 0 || newY === scrollableHeight) {
+        const scrollProgress = Math.max(0, Math.min(1, newY / scrollableHeight));
+        const virtualScrollableHeight = scrollHeight - cHeight;
+        virtualY = scrollProgress * virtualScrollableHeight;
+        // Update our tracked position for subsequent smooth scrolling
+        virtualScrollY.current = virtualY;
+      } else {
+        // For smooth scrolling, apply the delta directly to virtual position
+        // This preserves 1:1 pixel movement for smooth scrolling
+        virtualScrollY.current -= delta;
+        virtualY = virtualScrollY.current;
+      }
+    } else {
+      // Direct mapping when within browser limits
+      virtualY = newY;
+      virtualScrollY.current = virtualY;
+    }
+    // Ensure virtual Y is within valid bounds
+    virtualY = Math.max(0, Math.min(virtualY, scrollHeight - cHeight));
+    virtualScrollY.current = virtualY; // Keep tracked position in bounds too
+    if (lock !== undefined) {
+      window.clearTimeout(idleTimer.current);
+      setIsIdle(false);
+      idleTimer.current = window.setTimeout(() => setIsIdle(true), 200);
+    }
+    update({
+      x: scrollLeft,
+      y: virtualY,
+      width: cWidth - paddingRight,
+      height: cHeight - paddingBottom,
+      paddingRight: rightWrapRef.current?.clientWidth ?? 0
     });
-    const rightWrapRef = React.useRef(null);
-    const hasTouches = useTouchUpDelayed(200);
-    const [isIdle, setIsIdle] = React.useState(true);
-    const idleTimer = React.useRef(0);
-    React.useLayoutEffect(() => {
-        if (!isIdle || hasTouches || lastScrollPosition.current.lockDirection === undefined)
-            return;
-        const el = scroller.current;
-        if (el === null)
-            return;
-        const [lx, ly] = lastScrollPosition.current.lockDirection;
-        if (lx !== undefined) {
-            el.scrollLeft = lx;
-        }
-        else if (ly !== undefined) {
-            el.scrollTop = ly;
-        }
-        lastScrollPosition.current.lockDirection = undefined;
-    }, [hasTouches, isIdle]);
-    const onScroll = React.useCallback((scrollLeft, scrollTop) => {
-        const el = scroller.current;
-        if (el === null)
-            return;
-        scrollTop = scrollTop ?? el.scrollTop;
-        scrollLeft = scrollLeft ?? el.scrollLeft;
-        const lastScrollTop = lastScrollPosition.current.scrollTop;
-        const lastScrollLeft = lastScrollPosition.current.scrollLeft;
-        const dx = scrollLeft - lastScrollLeft;
-        const dy = scrollTop - lastScrollTop;
-        if (hasTouches &&
-            dx !== 0 &&
-            dy !== 0 &&
-            (Math.abs(dx) > 3 || Math.abs(dy) > 3) &&
-            preventDiagonalScrolling &&
-            lastScrollPosition.current.lockDirection === undefined) {
-            lastScrollPosition.current.lockDirection =
-                Math.abs(dx) < Math.abs(dy) ? [lastScrollLeft, undefined] : [undefined, lastScrollTop];
-        }
-        const lock = lastScrollPosition.current.lockDirection;
-        scrollLeft = lock?.[0] ?? scrollLeft;
-        scrollTop = lock?.[1] ?? scrollTop;
-        lastScrollPosition.current.scrollLeft = scrollLeft;
-        lastScrollPosition.current.scrollTop = scrollTop;
-        const cWidth = el.clientWidth;
-        const cHeight = el.clientHeight;
-        const newY = scrollTop;
-        const delta = lastScrollY.current - newY;
-        const scrollableHeight = el.scrollHeight - cHeight;
-        lastScrollY.current = newY;
-        // Calculate the virtual Y position
-        let virtualY;
-        // When content height exceeds browser limits, use hybrid approach
-        if (scrollableHeight > 0 && scrollHeight > el.scrollHeight + 5) {
-            // For large jumps (scrollbar interaction) or edge positions,
-            // recalculate position based on percentage
-            if (Math.abs(delta) > 2000 || newY === 0 || newY === scrollableHeight) {
-                const scrollProgress = Math.max(0, Math.min(1, newY / scrollableHeight));
-                const virtualScrollableHeight = scrollHeight - cHeight;
-                virtualY = scrollProgress * virtualScrollableHeight;
-                // Update our tracked position for subsequent smooth scrolling
-                virtualScrollY.current = virtualY;
-            }
-            else {
-                // For smooth scrolling, apply the delta directly to virtual position
-                // This preserves 1:1 pixel movement for smooth scrolling
-                virtualScrollY.current -= delta;
-                virtualY = virtualScrollY.current;
-            }
-        }
-        else {
-            // Direct mapping when within browser limits
-            virtualY = newY;
-            virtualScrollY.current = virtualY;
-        }
-        // Ensure virtual Y is within valid bounds
-        virtualY = Math.max(0, Math.min(virtualY, scrollHeight - cHeight));
-        virtualScrollY.current = virtualY; // Keep tracked position in bounds too
-        if (lock !== undefined) {
-            window.clearTimeout(idleTimer.current);
-            setIsIdle(false);
-            idleTimer.current = window.setTimeout(() => setIsIdle(true), 200);
-        }
-        update({
-            x: scrollLeft,
-            y: virtualY,
-            width: cWidth - paddingRight,
-            height: cHeight - paddingBottom,
-            paddingRight: rightWrapRef.current?.clientWidth ?? 0,
-        });
-    }, [paddingBottom, paddingRight, scrollHeight, update, preventDiagonalScrolling, hasTouches]);
-    useKineticScroll(kineticScrollPerfHack && browserIsSafari.value, onScroll, scroller);
-    const onScrollRef = React.useRef(onScroll);
-    onScrollRef.current = onScroll;
-    const lastProps = React.useRef(undefined);
-    const didFirstScroll = React.useRef(false);
-    // if this is not a layout effect there will be a flicker when changing the number of freezeColumns
-    // we need to document what this is needed at all.
-    React.useLayoutEffect(() => {
-        if (didFirstScroll.current)
-            onScroll();
-        else
-            didFirstScroll.current = true;
-    }, [onScroll, paddingBottom, paddingRight]);
-    const setRefs = React.useCallback((instance) => {
-        scroller.current = instance;
-        if (scrollRef !== undefined) {
-            scrollRef.current = instance;
-        }
-    }, [scrollRef]);
-    let key = 0;
-    let h = 0;
-    // Ensure we don't create padders that exceed browser limits
-    const effectiveScrollHeight = Math.min(scrollHeight, BROWSER_MAX_DIV_HEIGHT);
-    padders.push(React.createElement("div", { key: key++, style: { width: scrollWidth, height: 0 } }));
-    while (h < effectiveScrollHeight) {
-        const toAdd = Math.min(MAX_PADDER_SEGMENT_HEIGHT, effectiveScrollHeight - h);
-        padders.push(React.createElement("div", { key: key++, style: { width: 0, height: toAdd } }));
-        h += toAdd;
+  }, [paddingBottom, paddingRight, scrollHeight, update, preventDiagonalScrolling, hasTouches]);
+  useKineticScroll(kineticScrollPerfHack && browserIsSafari.value, onScroll, scroller);
+  const onScrollRef = React.useRef(onScroll);
+  onScrollRef.current = onScroll;
+  const lastProps = React.useRef(undefined);
+  const didFirstScroll = React.useRef(false);
+  // if this is not a layout effect there will be a flicker when changing the number of freezeColumns
+  // we need to document what this is needed at all.
+  React.useLayoutEffect(() => {
+    if (didFirstScroll.current) onScroll();else didFirstScroll.current = true;
+  }, [onScroll, paddingBottom, paddingRight]);
+  const setRefs = React.useCallback(instance => {
+    scroller.current = instance;
+    if (scrollRef !== undefined) {
+      scrollRef.current = instance;
     }
-    const { ref, width, height } = useResizeDetector(initialSize);
-    if (typeof window !== "undefined" && (lastProps.current?.height !== height || lastProps.current?.width !== width)) {
-        window.setTimeout(() => onScrollRef.current(), 0);
-        lastProps.current = { width, height };
+  }, [scrollRef]);
+  let key = 0;
+  let h = 0;
+  // Ensure we don't create padders that exceed browser limits
+  const effectiveScrollHeight = Math.min(scrollHeight, BROWSER_MAX_DIV_HEIGHT);
+  padders.push(React.createElement("div", {
+    key: key++,
+    style: {
+      width: scrollWidth,
+      height: 0
     }
-    if ((width ?? 0) === 0 || (height ?? 0) === 0)
-        return React.createElement("div", { ref: ref });
-    return (React.createElement("div", { ref: ref },
-        React.createElement(ScrollRegionStyle, { isSafari: browserIsSafari.value },
-            React.createElement("div", { className: "dvn-underlay" }, children),
-            React.createElement("div", { ref: setRefs, style: lastProps.current, draggable: draggable, onDragStart: e => {
-                    if (!draggable) {
-                        e.stopPropagation();
-                        e.preventDefault();
-                    }
-                }, className: "dvn-scroller " + (className ?? ""), onScroll: () => onScroll() },
-                React.createElement("div", { className: "dvn-scroll-inner" + (rightElement === undefined ? " dvn-hidden" : "") },
-                    React.createElement("div", { className: "dvn-stack" }, padders),
-                    rightElement !== undefined && (React.createElement(React.Fragment, null,
-                        !rightElementFill && React.createElement("div", { className: "dvn-spacer" }),
-                        React.createElement("div", { ref: rightWrapRef, style: {
-                                height,
-                                maxHeight: clientHeight - Math.ceil(dpr % 1),
-                                position: "sticky",
-                                top: 0,
-                                paddingLeft: 1,
-                                marginBottom: -40,
-                                marginRight: paddingRight,
-                                flexGrow: rightElementFill ? 1 : undefined,
-                                right: rightElementSticky ? (paddingRight ?? 0) : undefined,
-                                pointerEvents: "auto",
-                            } }, rightElement))))))));
+  }));
+  while (h < effectiveScrollHeight) {
+    const toAdd = Math.min(MAX_PADDER_SEGMENT_HEIGHT, effectiveScrollHeight - h);
+    padders.push(React.createElement("div", {
+      key: key++,
+      style: {
+        width: 0,
+        height: toAdd
+      }
+    }));
+    h += toAdd;
+  }
+  const {
+    ref,
+    width,
+    height
+  } = useResizeDetector(initialSize);
+  if (typeof window !== "undefined" && (lastProps.current?.height !== height || lastProps.current?.width !== width)) {
+    window.setTimeout(() => onScrollRef.current(), 0);
+    lastProps.current = {
+      width,
+      height
+    };
+  }
+  if ((width ?? 0) === 0 || (height ?? 0) === 0) return React.createElement("div", {
+    ref: ref
+  });
+  return React.createElement("div", {
+    ref: ref
+  }, React.createElement(ScrollRegionStyle, {
+    isSafari: browserIsSafari.value
+  }, React.createElement("div", {
+    className: "dvn-underlay"
+  }, children), React.createElement("div", {
+    ref: setRefs,
+    style: lastProps.current,
+    draggable: draggable,
+    onDragStart: e => {
+      if (!draggable) {
+        e.stopPropagation();
+        e.preventDefault();
+      }
+    },
+    className: "dvn-scroller " + (className ?? ""),
+    onScroll: () => onScroll()
+  }, React.createElement("div", {
+    className: "dvn-scroll-inner" + (rightElement === undefined ? " dvn-hidden" : "")
+  }, React.createElement("div", {
+    className: "dvn-stack"
+  }, padders), rightElement !== undefined && React.createElement(React.Fragment, null, !rightElementFill && React.createElement("div", {
+    className: "dvn-spacer"
+  }), React.createElement("div", {
+    ref: rightWrapRef,
+    style: {
+      height,
+      maxHeight: clientHeight - Math.ceil(dpr % 1),
+      position: "sticky",
+      top: 0,
+      paddingLeft: 1,
+      marginBottom: -40,
+      marginRight: paddingRight,
+      flexGrow: rightElementFill ? 1 : undefined,
+      right: rightElementSticky ? paddingRight ?? 0 : undefined,
+      pointerEvents: "auto"
+    }
+  }, rightElement))))));
 };
-//# sourceMappingURL=infinite-scroller.js.map
+

package/dist/dts/cells/boolean-cell.d.ts

@@ -1,4 +1,3 @@
 import { type BooleanCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const booleanCellRenderer: InternalCellRenderer<BooleanCell>;
-//# sourceMappingURL=boolean-cell.d.ts.map

package/dist/dts/cells/bubble-cell.d.ts

@@ -1,4 +1,3 @@
 import { type BubbleCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const bubbleCellRenderer: InternalCellRenderer<BubbleCell>;
-//# sourceMappingURL=bubble-cell.d.ts.map

package/dist/dts/cells/cell-types.d.ts

@@ -86,4 +86,3 @@ export type CellRenderer<T extends InnerGridCell> = [T] extends [CustomCell<infe
 /** @category Renderers */
 export type GetCellRendererCallback = <T extends InnerGridCell>(cell: T) => CellRenderer<T> | undefined;
 export {};
-//# sourceMappingURL=cell-types.d.ts.map

package/dist/dts/cells/drilldown-cell.d.ts

@@ -1,4 +1,3 @@
 import { type DrilldownCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const drilldownCellRenderer: InternalCellRenderer<DrilldownCell>;
-//# sourceMappingURL=drilldown-cell.d.ts.map

package/dist/dts/cells/image-cell.d.ts

@@ -2,4 +2,3 @@ import { type BaseGridCell, type ImageCell } from "../internal/data-grid/data-gr
 import type { BaseDrawArgs, InternalCellRenderer } from "./cell-types.js";
 export declare const imageCellRenderer: InternalCellRenderer<ImageCell>;
 export declare function drawImage(args: BaseDrawArgs, data: readonly string[], rounding: number, contentAlign?: BaseGridCell["contentAlign"]): void;
-//# sourceMappingURL=image-cell.d.ts.map

package/dist/dts/cells/index.d.ts

@@ -1,4 +1,3 @@
 import { type InnerGridCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const AllCellRenderers: InternalCellRenderer<InnerGridCell>[];
-//# sourceMappingURL=index.d.ts.map

package/dist/dts/cells/loading-cell.d.ts

@@ -1,4 +1,3 @@
 import { type LoadingCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const loadingCellRenderer: InternalCellRenderer<LoadingCell>;
-//# sourceMappingURL=loading-cell.d.ts.map

package/dist/dts/cells/markdown-cell.d.ts

@@ -1,4 +1,3 @@
 import { type MarkdownCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const markdownCellRenderer: InternalCellRenderer<MarkdownCell>;
-//# sourceMappingURL=markdown-cell.d.ts.map

package/dist/dts/cells/marker-cell.d.ts

@@ -1,4 +1,3 @@
 import { type MarkerCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const markerCellRenderer: InternalCellRenderer<MarkerCell>;
-//# sourceMappingURL=marker-cell.d.ts.map

package/dist/dts/cells/new-row-cell.d.ts

@@ -1,4 +1,3 @@
 import { type NewRowCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const newRowCellRenderer: InternalCellRenderer<NewRowCell>;
-//# sourceMappingURL=new-row-cell.d.ts.map

package/dist/dts/cells/number-cell.d.ts

@@ -1,4 +1,3 @@
 import { type NumberCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const numberCellRenderer: InternalCellRenderer<NumberCell>;
-//# sourceMappingURL=number-cell.d.ts.map

package/dist/dts/cells/protected-cell.d.ts

@@ -1,4 +1,3 @@
 import { type ProtectedCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const protectedCellRenderer: InternalCellRenderer<ProtectedCell>;
-//# sourceMappingURL=protected-cell.d.ts.map

package/dist/dts/cells/row-id-cell.d.ts

@@ -1,4 +1,3 @@
 import { type RowIDCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const rowIDCellRenderer: InternalCellRenderer<RowIDCell>;
-//# sourceMappingURL=row-id-cell.d.ts.map

package/dist/dts/cells/text-cell.d.ts

@@ -1,4 +1,3 @@
 import { type TextCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const textCellRenderer: InternalCellRenderer<TextCell>;
-//# sourceMappingURL=text-cell.d.ts.map

package/dist/dts/cells/uri-cell.d.ts

@@ -1,4 +1,3 @@
 import { type UriCell } from "../internal/data-grid/data-grid-types.js";
 import type { InternalCellRenderer } from "./cell-types.js";
 export declare const uriCellRenderer: InternalCellRenderer<UriCell>;
-//# sourceMappingURL=uri-cell.d.ts.map

package/dist/dts/common/browser-detect.d.ts

@@ -8,4 +8,3 @@ export declare const browserIsFirefox: Lazy<boolean>;
 export declare const browserIsSafari: Lazy<boolean>;
 export declare const browserIsOSX: Lazy<boolean>;
 export {};
-//# sourceMappingURL=browser-detect.d.ts.map

package/dist/dts/common/image-window-loader.d.ts

@@ -12,4 +12,3 @@ declare class ImageWindowLoaderImpl extends WindowingTrackerBase implements Imag
     loadOrGetImage(url: string, col: number, row: number): HTMLImageElement | ImageBitmap | undefined;
 }
 export default ImageWindowLoaderImpl;
-//# sourceMappingURL=image-window-loader.d.ts.map

package/dist/dts/common/is-hotkey.d.ts

@@ -4,4 +4,3 @@ interface HotkeyResultDetails {
 }
 export declare function isHotkey(hotkey: string, args: GridKeyEventArgs, details: HotkeyResultDetails): boolean;
 export {};
-//# sourceMappingURL=is-hotkey.d.ts.map

package/dist/dts/common/math.d.ts

@@ -17,4 +17,3 @@ interface SplitRect {
 }
 export declare function splitRectIntoRegions(rect: Rectangle, splitIndicies: readonly [number, number, number, number], width: number, height: number, splitLocations: readonly [number, number, number, number]): SplitRect[];
 export {};
-//# sourceMappingURL=math.d.ts.map

package/dist/dts/common/render-state-provider.d.ts

@@ -17,4 +17,3 @@ export declare class RenderStateProvider extends WindowingTrackerBase {
     getValue: (location: Item) => any;
     protected clearOutOfWindow: () => void;
 }
-//# sourceMappingURL=render-state-provider.d.ts.map

package/dist/dts/common/resize-detector.d.ts

@@ -8,4 +8,3 @@ export interface UseResizeDetectorReturn<T> extends ReactResizeDetectorDimension
     ref: MutableRefObject<T | null>;
 }
 export {};
-//# sourceMappingURL=resize-detector.d.ts.map

package/dist/dts/common/styles.d.ts

@@ -58,4 +58,3 @@ export declare const ThemeContext: React.Context<Theme>;
 /** @category Hooks */
 export declare function useTheme(): Theme;
 export declare function mergeAndRealizeTheme(theme: Theme, ...overlays: Partial<Theme | undefined>[]): FullTheme;
-//# sourceMappingURL=styles.d.ts.map

package/dist/dts/common/support.d.ts

@@ -10,4 +10,3 @@ export declare function deepEqual(foo: any, bar: any): boolean;
 export type FullyDefined<T> = {
     [K in keyof Required<T>]: T[K];
 };
-//# sourceMappingURL=support.d.ts.map

package/dist/dts/common/utils.d.ts

@@ -35,4 +35,3 @@ export declare function useStateWithReactiveInput<T>(inputState: T): [T, React.D
 export declare function makeAccessibilityStringForArray(arr: readonly string[]): string;
 export declare function useDeepMemo<T>(value: T): T;
 export {};
-//# sourceMappingURL=utils.d.ts.map

package/dist/dts/data-editor/copy-paste.d.ts

@@ -19,4 +19,3 @@ export declare function getCopyBufferContents(cells: readonly (readonly GridCell
 };
 export declare function decodeHTML(html: string): CopyBuffer | undefined;
 export {};
-//# sourceMappingURL=copy-paste.d.ts.map

package/dist/dts/data-editor/data-editor-fns.d.ts

@@ -13,4 +13,3 @@ export declare function copyToClipboard(cells: readonly (readonly GridCell[])[],
  * empty + click -> checked
  */
 export declare function toggleBoolean(data: boolean | null | undefined): boolean | null | undefined;
-//# sourceMappingURL=data-editor-fns.d.ts.map