@react-aria/virtualizer 3.0.0-nightly-641446f65-240905

package/dist/module.js

@@ -0,0 +1,25 @@
+import {Virtualizer as $6d0a5c394373ae64$export$89be5a243e59c4b2} from "./Virtualizer.module.js";
+import {useVirtualizerItem as $47736c1e63ba1c6d$export$1da781778207e0a2} from "./useVirtualizerItem.module.js";
+import {layoutInfoToStyle as $ccf8a0a04e4175ae$export$1481e64fbe01b8b3, VirtualizerItem as $ccf8a0a04e4175ae$export$6796df8ba7398521} from "./VirtualizerItem.module.js";
+import {ScrollView as $44a6ee657928b002$export$5665e3d6be6adea, useScrollView as $44a6ee657928b002$export$2ea0c4974da4731b} from "./ScrollView.module.js";
+import {getRTLOffsetType as $ce415dc67314b753$export$faf7630257ad4304, getScrollLeft as $ce415dc67314b753$export$1389d168952b34b5, setScrollLeft as $ce415dc67314b753$export$ed5fd5ffe5ab0ac} from "./utils.module.js";
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+
+
+
+
+export {$6d0a5c394373ae64$export$89be5a243e59c4b2 as Virtualizer, $47736c1e63ba1c6d$export$1da781778207e0a2 as useVirtualizerItem, $ccf8a0a04e4175ae$export$6796df8ba7398521 as VirtualizerItem, $ccf8a0a04e4175ae$export$1481e64fbe01b8b3 as layoutInfoToStyle, $44a6ee657928b002$export$5665e3d6be6adea as ScrollView, $44a6ee657928b002$export$2ea0c4974da4731b as useScrollView, $ce415dc67314b753$export$faf7630257ad4304 as getRTLOffsetType, $ce415dc67314b753$export$1389d168952b34b5 as getScrollLeft, $ce415dc67314b753$export$ed5fd5ffe5ab0ac as setScrollLeft};
+//# sourceMappingURL=module.js.map

package/dist/module.js.map

@@ -0,0 +1 @@
+{"mappings":";;;;;;AAAA;;;;;;;;;;CAUC","sources":["packages/@react-aria/virtualizer/src/index.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nexport type {RTLOffsetType} from './utils';\nexport type {VirtualizerItemOptions} from './useVirtualizerItem';\nexport {Virtualizer} from './Virtualizer';\nexport {useVirtualizerItem} from './useVirtualizerItem';\nexport {VirtualizerItem, layoutInfoToStyle} from './VirtualizerItem';\nexport {ScrollView, useScrollView} from './ScrollView';\nexport {getRTLOffsetType, getScrollLeft, setScrollLeft} from './utils';\n"],"names":[],"version":3,"file":"module.js.map"}

package/dist/types.d.ts

@@ -0,0 +1,337 @@
+import { Direction, Key, RefObject, Collection } from "@react-types/shared";
+import { LayoutInfo, Size, Rect, Layout, ReusableView } from "@react-stately/virtualizer";
+import React, { CSSProperties, HTMLAttributes, ReactNode, RefObject as _RefObject1, ReactElement } from "react";
+export type RTLOffsetType = 'negative' | 'positive-descending' | 'positive-ascending';
+export function getRTLOffsetType(recalculate?: boolean): RTLOffsetType;
+export function getScrollLeft(node: Element, direction: Direction): number;
+export function setScrollLeft(node: Element, direction: Direction, scrollLeft: number): void;
+interface IVirtualizer {
+    updateItemSize(key: Key, size: Size): void;
+}
+export interface VirtualizerItemOptions {
+    layoutInfo: LayoutInfo;
+    virtualizer: IVirtualizer;
+    ref: RefObject<HTMLElement | null>;
+}
+export function useVirtualizerItem(options: VirtualizerItemOptions): {
+    updateSize: () => void;
+};
+interface ScrollViewProps extends HTMLAttributes<HTMLElement> {
+    contentSize: Size;
+    onVisibleRectChange: (rect: Rect) => void;
+    children?: ReactNode;
+    innerStyle?: CSSProperties;
+    onScrollStart?: () => void;
+    onScrollEnd?: () => void;
+    scrollDirection?: 'horizontal' | 'vertical' | 'both';
+}
+export const ScrollView: React.ForwardRefExoticComponent<ScrollViewProps & React.RefAttributes<HTMLDivElement>>;
+export function useScrollView(props: ScrollViewProps, ref: _RefObject1<HTMLElement | null>): {
+    scrollViewProps: {
+        style: React.CSSProperties;
+        children?: ReactNode;
+        defaultChecked?: boolean | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined;
+        suppressHydrationWarning?: boolean | undefined;
+        accessKey?: string | undefined;
+        autoFocus?: boolean | undefined;
+        className?: string | undefined;
+        contentEditable?: (boolean | "false" | "true") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined;
+        dir?: string | undefined;
+        draggable?: (boolean | "false" | "true") | undefined;
+        hidden?: boolean | undefined;
+        id?: string | undefined;
+        lang?: string | undefined;
+        nonce?: string | undefined;
+        slot?: string | undefined;
+        spellCheck?: (boolean | "false" | "true") | undefined;
+        tabIndex?: number | undefined;
+        title?: string | undefined;
+        translate?: "yes" | "no" | undefined;
+        radioGroup?: string | undefined;
+        role?: React.AriaRole | undefined;
+        about?: string | undefined;
+        content?: string | undefined;
+        datatype?: string | undefined;
+        inlist?: any;
+        prefix?: string | undefined;
+        property?: string | undefined;
+        rel?: string | undefined;
+        resource?: string | undefined;
+        rev?: string | undefined;
+        typeof?: string | undefined;
+        vocab?: string | undefined;
+        autoCapitalize?: string | undefined;
+        autoCorrect?: string | undefined;
+        autoSave?: string | undefined;
+        color?: string | undefined;
+        itemProp?: string | undefined;
+        itemScope?: boolean | undefined;
+        itemType?: string | undefined;
+        itemID?: string | undefined;
+        itemRef?: string | undefined;
+        results?: number | undefined;
+        security?: string | undefined;
+        unselectable?: "on" | "off" | undefined;
+        popover?: "" | "auto" | "manual" | undefined;
+        popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+        popoverTarget?: string | undefined;
+        inert?: boolean | undefined;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+        is?: string | undefined;
+        "aria-activedescendant"?: string | undefined;
+        "aria-atomic"?: (boolean | "false" | "true") | undefined;
+        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+        "aria-braillelabel"?: string | undefined;
+        "aria-brailleroledescription"?: string | undefined;
+        "aria-busy"?: (boolean | "false" | "true") | undefined;
+        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-colcount"?: number | undefined;
+        "aria-colindex"?: number | undefined;
+        "aria-colindextext"?: string | undefined;
+        "aria-colspan"?: number | undefined;
+        "aria-controls"?: string | undefined;
+        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+        "aria-describedby"?: string | undefined;
+        "aria-description"?: string | undefined;
+        "aria-details"?: string | undefined;
+        "aria-disabled"?: (boolean | "false" | "true") | undefined;
+        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+        "aria-errormessage"?: string | undefined;
+        "aria-expanded"?: (boolean | "false" | "true") | undefined;
+        "aria-flowto"?: string | undefined;
+        "aria-grabbed"?: (boolean | "false" | "true") | undefined;
+        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+        "aria-hidden"?: (boolean | "false" | "true") | undefined;
+        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+        "aria-keyshortcuts"?: string | undefined;
+        "aria-label"?: string | undefined;
+        "aria-labelledby"?: string | undefined;
+        "aria-level"?: number | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined;
+        "aria-modal"?: (boolean | "false" | "true") | undefined;
+        "aria-multiline"?: (boolean | "false" | "true") | undefined;
+        "aria-multiselectable"?: (boolean | "false" | "true") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined;
+        "aria-owns"?: string | undefined;
+        "aria-placeholder"?: string | undefined;
+        "aria-posinset"?: number | undefined;
+        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+        "aria-readonly"?: (boolean | "false" | "true") | undefined;
+        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+        "aria-required"?: (boolean | "false" | "true") | undefined;
+        "aria-roledescription"?: string | undefined;
+        "aria-rowcount"?: number | undefined;
+        "aria-rowindex"?: number | undefined;
+        "aria-rowindextext"?: string | undefined;
+        "aria-rowspan"?: number | undefined;
+        "aria-selected"?: (boolean | "false" | "true") | undefined;
+        "aria-setsize"?: number | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+        "aria-valuemax"?: number | undefined;
+        "aria-valuemin"?: number | undefined;
+        "aria-valuenow"?: number | undefined;
+        "aria-valuetext"?: string | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined;
+        onCopy?: React.ClipboardEventHandler<HTMLElement>;
+        onCopyCapture?: React.ClipboardEventHandler<HTMLElement>;
+        onCut?: React.ClipboardEventHandler<HTMLElement>;
+        onCutCapture?: React.ClipboardEventHandler<HTMLElement>;
+        onPaste?: React.ClipboardEventHandler<HTMLElement>;
+        onPasteCapture?: React.ClipboardEventHandler<HTMLElement>;
+        onCompositionEnd?: React.CompositionEventHandler<HTMLElement>;
+        onCompositionEndCapture?: React.CompositionEventHandler<HTMLElement>;
+        onCompositionStart?: React.CompositionEventHandler<HTMLElement>;
+        onCompositionStartCapture?: React.CompositionEventHandler<HTMLElement>;
+        onCompositionUpdate?: React.CompositionEventHandler<HTMLElement>;
+        onCompositionUpdateCapture?: React.CompositionEventHandler<HTMLElement>;
+        onFocus?: React.FocusEventHandler<HTMLElement>;
+        onFocusCapture?: React.FocusEventHandler<HTMLElement>;
+        onBlur?: React.FocusEventHandler<HTMLElement>;
+        onBlurCapture?: React.FocusEventHandler<HTMLElement>;
+        onChange?: React.FormEventHandler<HTMLElement>;
+        onChangeCapture?: React.FormEventHandler<HTMLElement>;
+        onBeforeInput?: React.FormEventHandler<HTMLElement>;
+        onBeforeInputCapture?: React.FormEventHandler<HTMLElement>;
+        onInput?: React.FormEventHandler<HTMLElement>;
+        onInputCapture?: React.FormEventHandler<HTMLElement>;
+        onReset?: React.FormEventHandler<HTMLElement>;
+        onResetCapture?: React.FormEventHandler<HTMLElement>;
+        onSubmit?: React.FormEventHandler<HTMLElement>;
+        onSubmitCapture?: React.FormEventHandler<HTMLElement>;
+        onInvalid?: React.FormEventHandler<HTMLElement>;
+        onInvalidCapture?: React.FormEventHandler<HTMLElement>;
+        onLoad?: React.ReactEventHandler<HTMLElement>;
+        onLoadCapture?: React.ReactEventHandler<HTMLElement>;
+        onError?: React.ReactEventHandler<HTMLElement>;
+        onErrorCapture?: React.ReactEventHandler<HTMLElement>;
+        onKeyDown?: React.KeyboardEventHandler<HTMLElement>;
+        onKeyDownCapture?: React.KeyboardEventHandler<HTMLElement>;
+        onKeyPress?: React.KeyboardEventHandler<HTMLElement>;
+        onKeyPressCapture?: React.KeyboardEventHandler<HTMLElement>;
+        onKeyUp?: React.KeyboardEventHandler<HTMLElement>;
+        onKeyUpCapture?: React.KeyboardEventHandler<HTMLElement>;
+        onAbort?: React.ReactEventHandler<HTMLElement>;
+        onAbortCapture?: React.ReactEventHandler<HTMLElement>;
+        onCanPlay?: React.ReactEventHandler<HTMLElement>;
+        onCanPlayCapture?: React.ReactEventHandler<HTMLElement>;
+        onCanPlayThrough?: React.ReactEventHandler<HTMLElement>;
+        onCanPlayThroughCapture?: React.ReactEventHandler<HTMLElement>;
+        onDurationChange?: React.ReactEventHandler<HTMLElement>;
+        onDurationChangeCapture?: React.ReactEventHandler<HTMLElement>;
+        onEmptied?: React.ReactEventHandler<HTMLElement>;
+        onEmptiedCapture?: React.ReactEventHandler<HTMLElement>;
+        onEncrypted?: React.ReactEventHandler<HTMLElement>;
+        onEncryptedCapture?: React.ReactEventHandler<HTMLElement>;
+        onEnded?: React.ReactEventHandler<HTMLElement>;
+        onEndedCapture?: React.ReactEventHandler<HTMLElement>;
+        onLoadedData?: React.ReactEventHandler<HTMLElement>;
+        onLoadedDataCapture?: React.ReactEventHandler<HTMLElement>;
+        onLoadedMetadata?: React.ReactEventHandler<HTMLElement>;
+        onLoadedMetadataCapture?: React.ReactEventHandler<HTMLElement>;
+        onLoadStart?: React.ReactEventHandler<HTMLElement>;
+        onLoadStartCapture?: React.ReactEventHandler<HTMLElement>;
+        onPause?: React.ReactEventHandler<HTMLElement>;
+        onPauseCapture?: React.ReactEventHandler<HTMLElement>;
+        onPlay?: React.ReactEventHandler<HTMLElement>;
+        onPlayCapture?: React.ReactEventHandler<HTMLElement>;
+        onPlaying?: React.ReactEventHandler<HTMLElement>;
+        onPlayingCapture?: React.ReactEventHandler<HTMLElement>;
+        onProgress?: React.ReactEventHandler<HTMLElement>;
+        onProgressCapture?: React.ReactEventHandler<HTMLElement>;
+        onRateChange?: React.ReactEventHandler<HTMLElement>;
+        onRateChangeCapture?: React.ReactEventHandler<HTMLElement>;
+        onResize?: React.ReactEventHandler<HTMLElement>;
+        onResizeCapture?: React.ReactEventHandler<HTMLElement>;
+        onSeeked?: React.ReactEventHandler<HTMLElement>;
+        onSeekedCapture?: React.ReactEventHandler<HTMLElement>;
+        onSeeking?: React.ReactEventHandler<HTMLElement>;
+        onSeekingCapture?: React.ReactEventHandler<HTMLElement>;
+        onStalled?: React.ReactEventHandler<HTMLElement>;
+        onStalledCapture?: React.ReactEventHandler<HTMLElement>;
+        onSuspend?: React.ReactEventHandler<HTMLElement>;
+        onSuspendCapture?: React.ReactEventHandler<HTMLElement>;
+        onTimeUpdate?: React.ReactEventHandler<HTMLElement>;
+        onTimeUpdateCapture?: React.ReactEventHandler<HTMLElement>;
+        onVolumeChange?: React.ReactEventHandler<HTMLElement>;
+        onVolumeChangeCapture?: React.ReactEventHandler<HTMLElement>;
+        onWaiting?: React.ReactEventHandler<HTMLElement>;
+        onWaitingCapture?: React.ReactEventHandler<HTMLElement>;
+        onAuxClick?: React.MouseEventHandler<HTMLElement>;
+        onAuxClickCapture?: React.MouseEventHandler<HTMLElement>;
+        onClick?: React.MouseEventHandler<HTMLElement>;
+        onClickCapture?: React.MouseEventHandler<HTMLElement>;
+        onContextMenu?: React.MouseEventHandler<HTMLElement>;
+        onContextMenuCapture?: React.MouseEventHandler<HTMLElement>;
+        onDoubleClick?: React.MouseEventHandler<HTMLElement>;
+        onDoubleClickCapture?: React.MouseEventHandler<HTMLElement>;
+        onDrag?: React.DragEventHandler<HTMLElement>;
+        onDragCapture?: React.DragEventHandler<HTMLElement>;
+        onDragEnd?: React.DragEventHandler<HTMLElement>;
+        onDragEndCapture?: React.DragEventHandler<HTMLElement>;
+        onDragEnter?: React.DragEventHandler<HTMLElement>;
+        onDragEnterCapture?: React.DragEventHandler<HTMLElement>;
+        onDragExit?: React.DragEventHandler<HTMLElement>;
+        onDragExitCapture?: React.DragEventHandler<HTMLElement>;
+        onDragLeave?: React.DragEventHandler<HTMLElement>;
+        onDragLeaveCapture?: React.DragEventHandler<HTMLElement>;
+        onDragOver?: React.DragEventHandler<HTMLElement>;
+        onDragOverCapture?: React.DragEventHandler<HTMLElement>;
+        onDragStart?: React.DragEventHandler<HTMLElement>;
+        onDragStartCapture?: React.DragEventHandler<HTMLElement>;
+        onDrop?: React.DragEventHandler<HTMLElement>;
+        onDropCapture?: React.DragEventHandler<HTMLElement>;
+        onMouseDown?: React.MouseEventHandler<HTMLElement>;
+        onMouseDownCapture?: React.MouseEventHandler<HTMLElement>;
+        onMouseEnter?: React.MouseEventHandler<HTMLElement>;
+        onMouseLeave?: React.MouseEventHandler<HTMLElement>;
+        onMouseMove?: React.MouseEventHandler<HTMLElement>;
+        onMouseMoveCapture?: React.MouseEventHandler<HTMLElement>;
+        onMouseOut?: React.MouseEventHandler<HTMLElement>;
+        onMouseOutCapture?: React.MouseEventHandler<HTMLElement>;
+        onMouseOver?: React.MouseEventHandler<HTMLElement>;
+        onMouseOverCapture?: React.MouseEventHandler<HTMLElement>;
+        onMouseUp?: React.MouseEventHandler<HTMLElement>;
+        onMouseUpCapture?: React.MouseEventHandler<HTMLElement>;
+        onSelect?: React.ReactEventHandler<HTMLElement>;
+        onSelectCapture?: React.ReactEventHandler<HTMLElement>;
+        onTouchCancel?: React.TouchEventHandler<HTMLElement>;
+        onTouchCancelCapture?: React.TouchEventHandler<HTMLElement>;
+        onTouchEnd?: React.TouchEventHandler<HTMLElement>;
+        onTouchEndCapture?: React.TouchEventHandler<HTMLElement>;
+        onTouchMove?: React.TouchEventHandler<HTMLElement>;
+        onTouchMoveCapture?: React.TouchEventHandler<HTMLElement>;
+        onTouchStart?: React.TouchEventHandler<HTMLElement>;
+        onTouchStartCapture?: React.TouchEventHandler<HTMLElement>;
+        onPointerDown?: React.PointerEventHandler<HTMLElement>;
+        onPointerDownCapture?: React.PointerEventHandler<HTMLElement>;
+        onPointerMove?: React.PointerEventHandler<HTMLElement>;
+        onPointerMoveCapture?: React.PointerEventHandler<HTMLElement>;
+        onPointerUp?: React.PointerEventHandler<HTMLElement>;
+        onPointerUpCapture?: React.PointerEventHandler<HTMLElement>;
+        onPointerCancel?: React.PointerEventHandler<HTMLElement>;
+        onPointerCancelCapture?: React.PointerEventHandler<HTMLElement>;
+        onPointerEnter?: React.PointerEventHandler<HTMLElement>;
+        onPointerLeave?: React.PointerEventHandler<HTMLElement>;
+        onPointerOver?: React.PointerEventHandler<HTMLElement>;
+        onPointerOverCapture?: React.PointerEventHandler<HTMLElement>;
+        onPointerOut?: React.PointerEventHandler<HTMLElement>;
+        onPointerOutCapture?: React.PointerEventHandler<HTMLElement>;
+        onGotPointerCapture?: React.PointerEventHandler<HTMLElement>;
+        onGotPointerCaptureCapture?: React.PointerEventHandler<HTMLElement>;
+        onLostPointerCapture?: React.PointerEventHandler<HTMLElement>;
+        onLostPointerCaptureCapture?: React.PointerEventHandler<HTMLElement>;
+        onScroll?: React.UIEventHandler<HTMLElement>;
+        onScrollCapture?: React.UIEventHandler<HTMLElement>;
+        onWheel?: React.WheelEventHandler<HTMLElement>;
+        onWheelCapture?: React.WheelEventHandler<HTMLElement>;
+        onAnimationStart?: React.AnimationEventHandler<HTMLElement>;
+        onAnimationStartCapture?: React.AnimationEventHandler<HTMLElement>;
+        onAnimationEnd?: React.AnimationEventHandler<HTMLElement>;
+        onAnimationEndCapture?: React.AnimationEventHandler<HTMLElement>;
+        onAnimationIteration?: React.AnimationEventHandler<HTMLElement>;
+        onAnimationIterationCapture?: React.AnimationEventHandler<HTMLElement>;
+        onToggle?: React.ToggleEventHandler<HTMLElement>;
+        onBeforeToggle?: React.ToggleEventHandler<HTMLElement>;
+        onTransitionCancel?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionCancelCapture?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionEnd?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionEndCapture?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionRun?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionRunCapture?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionStart?: React.TransitionEventHandler<HTMLElement>;
+        onTransitionStartCapture?: React.TransitionEventHandler<HTMLElement>;
+    };
+    contentProps: {
+        role: string;
+        style: React.CSSProperties;
+    };
+};
+interface VirtualizerItemProps extends Omit<VirtualizerItemOptions, 'ref'> {
+    parent?: LayoutInfo | null;
+    className?: string;
+    children: ReactNode;
+}
+export function VirtualizerItem(props: VirtualizerItemProps): React.JSX.Element;
+export function layoutInfoToStyle(layoutInfo: LayoutInfo, dir: Direction, parent?: LayoutInfo | null): CSSProperties;
+type RenderWrapper<T extends object, V> = (parent: ReusableView<T, V> | null, reusableView: ReusableView<T, V>, children: ReusableView<T, V>[], renderChildren: (views: ReusableView<T, V>[]) => ReactElement[]) => ReactElement;
+interface VirtualizerProps<T extends object, V, O> extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children: (type: string, content: T) => V;
+    renderWrapper?: RenderWrapper<T, V>;
+    layout: Layout<T, O>;
+    collection: Collection<T>;
+    persistedKeys?: Set<Key> | null;
+    scrollDirection?: 'horizontal' | 'vertical' | 'both';
+    isLoading?: boolean;
+    onLoadMore?: () => void;
+    layoutOptions?: O;
+}
+export const Virtualizer: <T extends object, V, O>(props: VirtualizerProps<T, V, O> & {
+    ref?: RefObject<HTMLDivElement | null>;
+}) => ReactElement;
+
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/@react-aria/virtualizer/src/packages/@react-aria/virtualizer/src/utils.ts","packages/@react-aria/virtualizer/src/packages/@react-aria/virtualizer/src/useVirtualizerItem.ts","packages/@react-aria/virtualizer/src/packages/@react-aria/virtualizer/src/ScrollView.tsx","packages/@react-aria/virtualizer/src/packages/@react-aria/virtualizer/src/VirtualizerItem.tsx","packages/@react-aria/virtualizer/src/packages/@react-aria/virtualizer/src/Virtualizer.tsx","packages/@react-aria/virtualizer/src/packages/@react-aria/virtualizer/src/index.ts","packages/@react-aria/virtualizer/src/index.ts"],"sourcesContent":[null,null,null,null,null,null,"/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nexport type {RTLOffsetType} from './utils';\nexport type {VirtualizerItemOptions} from './useVirtualizerItem';\nexport {Virtualizer} from './Virtualizer';\nexport {useVirtualizerItem} from './useVirtualizerItem';\nexport {VirtualizerItem, layoutInfoToStyle} from './VirtualizerItem';\nexport {ScrollView, useScrollView} from './ScrollView';\nexport {getRTLOffsetType, getScrollLeft, setScrollLeft} from './utils';\n"],"names":[],"version":3,"file":"types.d.ts.map"}

package/dist/useVirtualizerItem.main.js

@@ -0,0 +1,53 @@
+var $64doO$reactstatelyvirtualizer = require("@react-stately/virtualizer");
+var $64doO$react = require("react");
+var $64doO$reactariautils = require("@react-aria/utils");
+
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+$parcel$export(module.exports, "useVirtualizerItem", () => $7d70e069fceb2deb$export$1da781778207e0a2);
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+function $7d70e069fceb2deb$export$1da781778207e0a2(options) {
+    let { layoutInfo: layoutInfo, virtualizer: virtualizer, ref: ref } = options;
+    let updateSize = (0, $64doO$react.useCallback)(()=>{
+        if (layoutInfo) {
+            let size = $7d70e069fceb2deb$var$getSize(ref.current);
+            virtualizer.updateItemSize(layoutInfo.key, size);
+        }
+    }, [
+        virtualizer,
+        layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.key,
+        ref
+    ]);
+    (0, $64doO$reactariautils.useLayoutEffect)(()=>{
+        if (layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.estimatedSize) updateSize();
+    });
+    return {
+        updateSize: updateSize
+    };
+}
+function $7d70e069fceb2deb$var$getSize(node) {
+    // Reset height before measuring so we get the intrinsic size
+    let height = node.style.height;
+    node.style.height = '';
+    let size = new (0, $64doO$reactstatelyvirtualizer.Size)(node.scrollWidth, node.scrollHeight);
+    node.style.height = height;
+    return size;
+}
+
+
+//# sourceMappingURL=useVirtualizerItem.main.js.map

package/dist/useVirtualizerItem.main.js.map

@@ -0,0 +1 @@
+{"mappings":";;;;;;;;;;AAAA;;;;;;;;;;CAUC;;;AAiBM,SAAS,0CAAmB,OAA+B;IAChE,IAAI,cAAC,UAAU,eAAE,WAAW,OAAE,GAAG,EAAC,GAAG;IAErC,IAAI,aAAa,CAAA,GAAA,wBAAU,EAAE;QAC3B,IAAI,YAAY;YACd,IAAI,OAAO,8BAAQ,IAAI,OAAO;YAC9B,YAAY,cAAc,CAAC,WAAW,GAAG,EAAE;QAC7C;IACF,GAAG;QAAC;QAAa,uBAAA,iCAAA,WAAY,GAAG;QAAE;KAAI;IAEtC,CAAA,GAAA,qCAAc,EAAE;QACd,IAAI,uBAAA,iCAAA,WAAY,aAAa,EAC3B;IAEJ;IAEA,OAAO;oBAAC;IAAU;AACpB;AAEA,SAAS,8BAAQ,IAAiB;IAChC,6DAA6D;IAC7D,IAAI,SAAS,KAAK,KAAK,CAAC,MAAM;IAC9B,KAAK,KAAK,CAAC,MAAM,GAAG;IACpB,IAAI,OAAO,IAAI,CAAA,GAAA,mCAAG,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY;IACvD,KAAK,KAAK,CAAC,MAAM,GAAG;IACpB,OAAO;AACT","sources":["packages/@react-aria/virtualizer/src/useVirtualizerItem.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {Key, RefObject} from '@react-types/shared';\nimport {LayoutInfo, Size} from '@react-stately/virtualizer';\nimport {useCallback} from 'react';\nimport {useLayoutEffect} from '@react-aria/utils';\n\ninterface IVirtualizer {\n  updateItemSize(key: Key, size: Size): void\n}\n\nexport interface VirtualizerItemOptions {\n  layoutInfo: LayoutInfo,\n  virtualizer: IVirtualizer,\n  ref: RefObject<HTMLElement | null>\n}\n\nexport function useVirtualizerItem(options: VirtualizerItemOptions) {\n  let {layoutInfo, virtualizer, ref} = options;\n\n  let updateSize = useCallback(() => {\n    if (layoutInfo) {\n      let size = getSize(ref.current);\n      virtualizer.updateItemSize(layoutInfo.key, size);\n    }\n  }, [virtualizer, layoutInfo?.key, ref]);\n\n  useLayoutEffect(() => {\n    if (layoutInfo?.estimatedSize) {\n      updateSize();\n    }\n  });\n\n  return {updateSize};\n}\n\nfunction getSize(node: HTMLElement) {\n  // Reset height before measuring so we get the intrinsic size\n  let height = node.style.height;\n  node.style.height = '';\n  let size = new Size(node.scrollWidth, node.scrollHeight);\n  node.style.height = height;\n  return size;\n}\n"],"names":[],"version":3,"file":"useVirtualizerItem.main.js.map"}

package/dist/useVirtualizerItem.mjs

@@ -0,0 +1,48 @@
+import {Size as $uBoVA$Size} from "@react-stately/virtualizer";
+import {useCallback as $uBoVA$useCallback} from "react";
+import {useLayoutEffect as $uBoVA$useLayoutEffect} from "@react-aria/utils";
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+function $47736c1e63ba1c6d$export$1da781778207e0a2(options) {
+    let { layoutInfo: layoutInfo, virtualizer: virtualizer, ref: ref } = options;
+    let updateSize = (0, $uBoVA$useCallback)(()=>{
+        if (layoutInfo) {
+            let size = $47736c1e63ba1c6d$var$getSize(ref.current);
+            virtualizer.updateItemSize(layoutInfo.key, size);
+        }
+    }, [
+        virtualizer,
+        layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.key,
+        ref
+    ]);
+    (0, $uBoVA$useLayoutEffect)(()=>{
+        if (layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.estimatedSize) updateSize();
+    });
+    return {
+        updateSize: updateSize
+    };
+}
+function $47736c1e63ba1c6d$var$getSize(node) {
+    // Reset height before measuring so we get the intrinsic size
+    let height = node.style.height;
+    node.style.height = '';
+    let size = new (0, $uBoVA$Size)(node.scrollWidth, node.scrollHeight);
+    node.style.height = height;
+    return size;
+}
+
+
+export {$47736c1e63ba1c6d$export$1da781778207e0a2 as useVirtualizerItem};
+//# sourceMappingURL=useVirtualizerItem.module.js.map

package/dist/useVirtualizerItem.module.js

@@ -0,0 +1,48 @@
+import {Size as $uBoVA$Size} from "@react-stately/virtualizer";
+import {useCallback as $uBoVA$useCallback} from "react";
+import {useLayoutEffect as $uBoVA$useLayoutEffect} from "@react-aria/utils";
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+
+function $47736c1e63ba1c6d$export$1da781778207e0a2(options) {
+    let { layoutInfo: layoutInfo, virtualizer: virtualizer, ref: ref } = options;
+    let updateSize = (0, $uBoVA$useCallback)(()=>{
+        if (layoutInfo) {
+            let size = $47736c1e63ba1c6d$var$getSize(ref.current);
+            virtualizer.updateItemSize(layoutInfo.key, size);
+        }
+    }, [
+        virtualizer,
+        layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.key,
+        ref
+    ]);
+    (0, $uBoVA$useLayoutEffect)(()=>{
+        if (layoutInfo === null || layoutInfo === void 0 ? void 0 : layoutInfo.estimatedSize) updateSize();
+    });
+    return {
+        updateSize: updateSize
+    };
+}
+function $47736c1e63ba1c6d$var$getSize(node) {
+    // Reset height before measuring so we get the intrinsic size
+    let height = node.style.height;
+    node.style.height = '';
+    let size = new (0, $uBoVA$Size)(node.scrollWidth, node.scrollHeight);
+    node.style.height = height;
+    return size;
+}
+
+
+export {$47736c1e63ba1c6d$export$1da781778207e0a2 as useVirtualizerItem};
+//# sourceMappingURL=useVirtualizerItem.module.js.map

package/dist/useVirtualizerItem.module.js.map

@@ -0,0 +1 @@
+{"mappings":";;;;AAAA;;;;;;;;;;CAUC;;;AAiBM,SAAS,0CAAmB,OAA+B;IAChE,IAAI,cAAC,UAAU,eAAE,WAAW,OAAE,GAAG,EAAC,GAAG;IAErC,IAAI,aAAa,CAAA,GAAA,kBAAU,EAAE;QAC3B,IAAI,YAAY;YACd,IAAI,OAAO,8BAAQ,IAAI,OAAO;YAC9B,YAAY,cAAc,CAAC,WAAW,GAAG,EAAE;QAC7C;IACF,GAAG;QAAC;QAAa,uBAAA,iCAAA,WAAY,GAAG;QAAE;KAAI;IAEtC,CAAA,GAAA,sBAAc,EAAE;QACd,IAAI,uBAAA,iCAAA,WAAY,aAAa,EAC3B;IAEJ;IAEA,OAAO;oBAAC;IAAU;AACpB;AAEA,SAAS,8BAAQ,IAAiB;IAChC,6DAA6D;IAC7D,IAAI,SAAS,KAAK,KAAK,CAAC,MAAM;IAC9B,KAAK,KAAK,CAAC,MAAM,GAAG;IACpB,IAAI,OAAO,IAAI,CAAA,GAAA,WAAG,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY;IACvD,KAAK,KAAK,CAAC,MAAM,GAAG;IACpB,OAAO;AACT","sources":["packages/@react-aria/virtualizer/src/useVirtualizerItem.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {Key, RefObject} from '@react-types/shared';\nimport {LayoutInfo, Size} from '@react-stately/virtualizer';\nimport {useCallback} from 'react';\nimport {useLayoutEffect} from '@react-aria/utils';\n\ninterface IVirtualizer {\n  updateItemSize(key: Key, size: Size): void\n}\n\nexport interface VirtualizerItemOptions {\n  layoutInfo: LayoutInfo,\n  virtualizer: IVirtualizer,\n  ref: RefObject<HTMLElement | null>\n}\n\nexport function useVirtualizerItem(options: VirtualizerItemOptions) {\n  let {layoutInfo, virtualizer, ref} = options;\n\n  let updateSize = useCallback(() => {\n    if (layoutInfo) {\n      let size = getSize(ref.current);\n      virtualizer.updateItemSize(layoutInfo.key, size);\n    }\n  }, [virtualizer, layoutInfo?.key, ref]);\n\n  useLayoutEffect(() => {\n    if (layoutInfo?.estimatedSize) {\n      updateSize();\n    }\n  });\n\n  return {updateSize};\n}\n\nfunction getSize(node: HTMLElement) {\n  // Reset height before measuring so we get the intrinsic size\n  let height = node.style.height;\n  node.style.height = '';\n  let size = new Size(node.scrollWidth, node.scrollHeight);\n  node.style.height = height;\n  return size;\n}\n"],"names":[],"version":3,"file":"useVirtualizerItem.module.js.map"}

package/dist/utils.main.js

@@ -0,0 +1,80 @@
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+
+$parcel$export(module.exports, "getRTLOffsetType", () => $efdd61e59e023a1d$export$faf7630257ad4304);
+$parcel$export(module.exports, "getScrollLeft", () => $efdd61e59e023a1d$export$1389d168952b34b5);
+$parcel$export(module.exports, "setScrollLeft", () => $efdd61e59e023a1d$export$ed5fd5ffe5ab0ac);
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ let $efdd61e59e023a1d$var$cachedRTLResult = null;
+function $efdd61e59e023a1d$export$faf7630257ad4304(recalculate = false) {
+    if ($efdd61e59e023a1d$var$cachedRTLResult === null || recalculate) {
+        const outerDiv = document.createElement('div');
+        const outerStyle = outerDiv.style;
+        outerStyle.width = '50px';
+        outerStyle.height = '50px';
+        outerStyle.overflow = 'scroll';
+        outerStyle.direction = 'rtl';
+        const innerDiv = document.createElement('div');
+        const innerStyle = innerDiv.style;
+        innerStyle.width = '100px';
+        innerStyle.height = '100px';
+        outerDiv.appendChild(innerDiv);
+        document.body.appendChild(outerDiv);
+        if (outerDiv.scrollLeft > 0) $efdd61e59e023a1d$var$cachedRTLResult = 'positive-descending';
+        else {
+            outerDiv.scrollLeft = 1;
+            if (outerDiv.scrollLeft === 0) $efdd61e59e023a1d$var$cachedRTLResult = 'negative';
+            else $efdd61e59e023a1d$var$cachedRTLResult = 'positive-ascending';
+        }
+        document.body.removeChild(outerDiv);
+        return $efdd61e59e023a1d$var$cachedRTLResult;
+    }
+    return $efdd61e59e023a1d$var$cachedRTLResult;
+}
+function $efdd61e59e023a1d$export$1389d168952b34b5(node, direction) {
+    let { scrollLeft: scrollLeft } = node;
+    // scrollLeft in rtl locales differs across browsers, so normalize.
+    // See comment by getRTLOffsetType below for details.
+    if (direction === 'rtl') {
+        let { scrollWidth: scrollWidth, clientWidth: clientWidth } = node;
+        switch($efdd61e59e023a1d$export$faf7630257ad4304()){
+            case 'negative':
+                scrollLeft = -scrollLeft;
+                break;
+            case 'positive-descending':
+                scrollLeft = scrollWidth - clientWidth - scrollLeft;
+                break;
+        }
+    }
+    return scrollLeft;
+}
+function $efdd61e59e023a1d$export$ed5fd5ffe5ab0ac(node, direction, scrollLeft) {
+    if (direction === 'rtl') switch($efdd61e59e023a1d$export$faf7630257ad4304()){
+        case 'negative':
+            scrollLeft = -scrollLeft;
+            break;
+        case 'positive-ascending':
+            break;
+        default:
+            {
+                const { clientWidth: clientWidth, scrollWidth: scrollWidth } = node;
+                scrollLeft = scrollWidth - clientWidth - scrollLeft;
+                break;
+            }
+    }
+    node.scrollLeft = scrollLeft;
+}
+
+
+//# sourceMappingURL=utils.main.js.map

package/dist/utils.main.js.map

@@ -0,0 +1 @@
+{"mappings":";;;;;;;;AAAA;;;;;;;;;;CAUC,GASD,IAAI,wCAAwC;AAarC,SAAS,0CAAiB,cAAuB,KAAK;IAC3D,IAAI,0CAAoB,QAAQ,aAAa;QAC3C,MAAM,WAAW,SAAS,aAAa,CAAC;QACxC,MAAM,aAAa,SAAS,KAAK;QACjC,WAAW,KAAK,GAAG;QACnB,WAAW,MAAM,GAAG;QACpB,WAAW,QAAQ,GAAG;QACtB,WAAW,SAAS,GAAG;QAEvB,MAAM,WAAW,SAAS,aAAa,CAAC;QACxC,MAAM,aAAa,SAAS,KAAK;QACjC,WAAW,KAAK,GAAG;QACnB,WAAW,MAAM,GAAG;QAEpB,SAAS,WAAW,CAAC;QAErB,SAAS,IAAI,CAAC,WAAW,CAAC;QAE1B,IAAI,SAAS,UAAU,GAAG,GACxB,wCAAkB;aACb;YACL,SAAS,UAAU,GAAG;YACtB,IAAI,SAAS,UAAU,KAAK,GAC1B,wCAAkB;iBAElB,wCAAkB;QAEtB;QAEA,SAAS,IAAI,CAAC,WAAW,CAAC;QAE1B,OAAO;IACT;IAEA,OAAO;AACT;AAEO,SAAS,0CAAc,IAAa,EAAE,SAAoB;IAC/D,IAAI,cAAC,UAAU,EAAC,GAAG;IAEnB,mEAAmE;IACnE,qDAAqD;IACrD,IAAI,cAAc,OAAO;QACvB,IAAI,eAAC,WAAW,eAAE,WAAW,EAAC,GAAG;QACjC,OAAQ;YACN,KAAK;gBACH,aAAa,CAAC;gBACd;YACF,KAAK;gBACH,aAAa,cAAc,cAAc;gBACzC;QACJ;IACF;IAEA,OAAO;AACT;AAEO,SAAS,yCAAc,IAAa,EAAE,SAAoB,EAAE,UAAkB;IACnF,IAAI,cAAc,OAChB,OAAQ;QACN,KAAK;YACH,aAAa,CAAC;YACd;QACF,KAAK;YACH;QACF;YAAS;gBACP,MAAM,eAAC,WAAW,eAAE,WAAW,EAAC,GAAG;gBACnC,aAAa,cAAc,cAAc;gBACzC;YACF;IACF;IAGF,KAAK,UAAU,GAAG;AACpB","sources":["packages/@react-aria/virtualizer/src/utils.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {Direction} from '@react-types/shared';\n\nexport type RTLOffsetType =\n  | 'negative'\n  | 'positive-descending'\n  | 'positive-ascending';\n\nlet cachedRTLResult: RTLOffsetType | null = null;\n\n\n// Original licensing for the following methods can be found in the\n// NOTICE file in the root directory of this source tree.\n// See https://github.com/bvaughn/react-window/blob/master/src/createGridComponent.js\n\n// According to the spec, scrollLeft should be negative for RTL aligned elements.\n// Chrome does not seem to adhere; its scrollLeft values are positive (measured relative to the left).\n// Safari's elastic bounce makes detecting this even more complicated wrt potential false positives.\n// The safest way to check this is to intentionally set a negative offset,\n// and then verify that the subsequent \"scroll\" event matches the negative offset.\n// If it does not match, then we can assume a non-standard RTL scroll implementation.\nexport function getRTLOffsetType(recalculate: boolean = false): RTLOffsetType {\n  if (cachedRTLResult === null || recalculate) {\n    const outerDiv = document.createElement('div');\n    const outerStyle = outerDiv.style;\n    outerStyle.width = '50px';\n    outerStyle.height = '50px';\n    outerStyle.overflow = 'scroll';\n    outerStyle.direction = 'rtl';\n\n    const innerDiv = document.createElement('div');\n    const innerStyle = innerDiv.style;\n    innerStyle.width = '100px';\n    innerStyle.height = '100px';\n\n    outerDiv.appendChild(innerDiv);\n\n    document.body.appendChild(outerDiv);\n\n    if (outerDiv.scrollLeft > 0) {\n      cachedRTLResult = 'positive-descending';\n    } else {\n      outerDiv.scrollLeft = 1;\n      if (outerDiv.scrollLeft === 0) {\n        cachedRTLResult = 'negative';\n      } else {\n        cachedRTLResult = 'positive-ascending';\n      }\n    }\n\n    document.body.removeChild(outerDiv);\n\n    return cachedRTLResult;\n  }\n\n  return cachedRTLResult;\n}\n\nexport function getScrollLeft(node: Element, direction: Direction): number {\n  let {scrollLeft} = node;\n\n  // scrollLeft in rtl locales differs across browsers, so normalize.\n  // See comment by getRTLOffsetType below for details.\n  if (direction === 'rtl') {\n    let {scrollWidth, clientWidth} = node;\n    switch (getRTLOffsetType()) {\n      case 'negative':\n        scrollLeft = -scrollLeft;\n        break;\n      case 'positive-descending':\n        scrollLeft = scrollWidth - clientWidth - scrollLeft;\n        break;\n    }\n  }\n\n  return scrollLeft;\n}\n\nexport function setScrollLeft(node: Element, direction: Direction, scrollLeft: number) {\n  if (direction === 'rtl') {\n    switch (getRTLOffsetType()) {\n      case 'negative':\n        scrollLeft = -scrollLeft;\n        break;\n      case 'positive-ascending':\n        break;\n      default: {\n        const {clientWidth, scrollWidth} = node;\n        scrollLeft = scrollWidth - clientWidth - scrollLeft;\n        break;\n      }\n    }\n  }\n\n  node.scrollLeft = scrollLeft;\n}\n"],"names":[],"version":3,"file":"utils.main.js.map"}