@legendapp/list 2.0.0-next.9 → 2.1.0-next.0

package/index.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var React3 = require('react');
-var reactNative = require('react-native');
 var shim = require('use-sync-external-store/shim');
 
 function _interopNamespace(e) {
@@ -24,15 +23,476 @@ function _interopNamespace(e) {
 
 var React3__namespace = /*#__PURE__*/_interopNamespace(React3);
 
-// src/components/LazyLegendList.tsx
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/react-dom/cjs/react-dom.production.js
+var require_react_dom_production = __commonJS({
+  "node_modules/react-dom/cjs/react-dom.production.js"(exports) {
+    var React12 = __require("react");
+    function formatProdErrorMessage(code) {
+      var url = "https://react.dev/errors/" + code;
+      if (1 < arguments.length) {
+        url += "?args[]=" + encodeURIComponent(arguments[1]);
+        for (var i = 2; i < arguments.length; i++)
+          url += "&args[]=" + encodeURIComponent(arguments[i]);
+      }
+      return "Minified React error #" + code + "; visit " + url + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
+    }
+    function noop2() {
+    }
+    var Internals = {
+      d: {
+        f: noop2,
+        r: function() {
+          throw Error(formatProdErrorMessage(522));
+        },
+        D: noop2,
+        C: noop2,
+        L: noop2,
+        m: noop2,
+        X: noop2,
+        S: noop2,
+        M: noop2
+      },
+      p: 0,
+      findDOMNode: null
+    };
+    var REACT_PORTAL_TYPE = Symbol.for("react.portal");
+    function createPortal$1(children, containerInfo, implementation) {
+      var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+      return {
+        $$typeof: REACT_PORTAL_TYPE,
+        key: null == key ? null : "" + key,
+        children,
+        containerInfo,
+        implementation
+      };
+    }
+    var ReactSharedInternals = React12.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+    function getCrossOriginStringAs(as, input) {
+      if ("font" === as) return "";
+      if ("string" === typeof input)
+        return "use-credentials" === input ? input : "";
+    }
+    exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
+    exports.createPortal = function(children, container) {
+      var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
+      if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
+        throw Error(formatProdErrorMessage(299));
+      return createPortal$1(children, container, null, key);
+    };
+    exports.flushSync = function(fn) {
+      var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
+      try {
+        if (ReactSharedInternals.T = null, Internals.p = 2, fn) return fn();
+      } finally {
+        ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f();
+      }
+    };
+    exports.preconnect = function(href, options) {
+      "string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals.d.C(href, options));
+    };
+    exports.prefetchDNS = function(href) {
+      "string" === typeof href && Internals.d.D(href);
+    };
+    exports.preinit = function(href, options) {
+      if ("string" === typeof href && options && "string" === typeof options.as) {
+        var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
+        "style" === as ? Internals.d.S(
+          href,
+          "string" === typeof options.precedence ? options.precedence : void 0,
+          {
+            crossOrigin,
+            integrity,
+            fetchPriority
+          }
+        ) : "script" === as && Internals.d.X(href, {
+          crossOrigin,
+          integrity,
+          fetchPriority,
+          nonce: "string" === typeof options.nonce ? options.nonce : void 0
+        });
+      }
+    };
+    exports.preinitModule = function(href, options) {
+      if ("string" === typeof href)
+        if ("object" === typeof options && null !== options) {
+          if (null == options.as || "script" === options.as) {
+            var crossOrigin = getCrossOriginStringAs(
+              options.as,
+              options.crossOrigin
+            );
+            Internals.d.M(href, {
+              crossOrigin,
+              integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+              nonce: "string" === typeof options.nonce ? options.nonce : void 0
+            });
+          }
+        } else null == options && Internals.d.M(href);
+    };
+    exports.preload = function(href, options) {
+      if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
+        var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
+        Internals.d.L(href, as, {
+          crossOrigin,
+          integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+          nonce: "string" === typeof options.nonce ? options.nonce : void 0,
+          type: "string" === typeof options.type ? options.type : void 0,
+          fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
+          referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
+          imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
+          imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
+          media: "string" === typeof options.media ? options.media : void 0
+        });
+      }
+    };
+    exports.preloadModule = function(href, options) {
+      if ("string" === typeof href)
+        if (options) {
+          var crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
+          Internals.d.m(href, {
+            as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
+            crossOrigin,
+            integrity: "string" === typeof options.integrity ? options.integrity : void 0
+          });
+        } else Internals.d.m(href);
+    };
+    exports.requestFormReset = function(form) {
+      Internals.d.r(form);
+    };
+    exports.unstable_batchedUpdates = function(fn, a) {
+      return fn(a);
+    };
+    exports.useFormState = function(action, initialState, permalink) {
+      return ReactSharedInternals.H.useFormState(action, initialState, permalink);
+    };
+    exports.useFormStatus = function() {
+      return ReactSharedInternals.H.useHostTransitionStatus();
+    };
+    exports.version = "19.1.1";
+  }
+});
+
+// node_modules/react-dom/cjs/react-dom.development.js
+var require_react_dom_development = __commonJS({
+  "node_modules/react-dom/cjs/react-dom.development.js"(exports) {
+    "production" !== process.env.NODE_ENV && function() {
+      function noop2() {
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function createPortal$1(children, containerInfo, implementation) {
+        var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+        try {
+          testStringCoercion(key);
+          var JSCompiler_inline_result = false;
+        } catch (e) {
+          JSCompiler_inline_result = true;
+        }
+        JSCompiler_inline_result && (console.error(
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          "function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"
+        ), testStringCoercion(key));
+        return {
+          $$typeof: REACT_PORTAL_TYPE,
+          key: null == key ? null : "" + key,
+          children,
+          containerInfo,
+          implementation
+        };
+      }
+      function getCrossOriginStringAs(as, input) {
+        if ("font" === as) return "";
+        if ("string" === typeof input)
+          return "use-credentials" === input ? input : "";
+      }
+      function getValueDescriptorExpectingObjectForWarning(thing) {
+        return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : 'something with type "' + typeof thing + '"';
+      }
+      function getValueDescriptorExpectingEnumForWarning(thing) {
+        return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : "string" === typeof thing ? JSON.stringify(thing) : "number" === typeof thing ? "`" + thing + "`" : 'something with type "' + typeof thing + '"';
+      }
+      function resolveDispatcher() {
+        var dispatcher = ReactSharedInternals.H;
+        null === dispatcher && console.error(
+          "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
+        );
+        return dispatcher;
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React12 = __require("react"), Internals = {
+        d: {
+          f: noop2,
+          r: function() {
+            throw Error(
+              "Invalid form element. requestFormReset must be passed a form that was rendered by React."
+            );
+          },
+          D: noop2,
+          C: noop2,
+          L: noop2,
+          m: noop2,
+          X: noop2,
+          S: noop2,
+          M: noop2
+        },
+        p: 0,
+        findDOMNode: null
+      }, REACT_PORTAL_TYPE = Symbol.for("react.portal"), ReactSharedInternals = React12.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+      "function" === typeof Map && null != Map.prototype && "function" === typeof Map.prototype.forEach && "function" === typeof Set && null != Set.prototype && "function" === typeof Set.prototype.clear && "function" === typeof Set.prototype.forEach || console.error(
+        "React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"
+      );
+      exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
+      exports.createPortal = function(children, container) {
+        var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
+        if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
+          throw Error("Target container is not a DOM element.");
+        return createPortal$1(children, container, null, key);
+      };
+      exports.flushSync = function(fn) {
+        var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
+        try {
+          if (ReactSharedInternals.T = null, Internals.p = 2, fn)
+            return fn();
+        } finally {
+          ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f() && console.error(
+            "flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."
+          );
+        }
+      };
+      exports.preconnect = function(href, options) {
+        "string" === typeof href && href ? null != options && "object" !== typeof options ? console.error(
+          "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        ) : null != options && "string" !== typeof options.crossOrigin && console.error(
+          "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
+          getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
+        ) : console.error(
+          "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          getValueDescriptorExpectingObjectForWarning(href)
+        );
+        "string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals.d.C(href, options));
+      };
+      exports.prefetchDNS = function(href) {
+        if ("string" !== typeof href || !href)
+          console.error(
+            "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+            getValueDescriptorExpectingObjectForWarning(href)
+          );
+        else if (1 < arguments.length) {
+          var options = arguments[1];
+          "object" === typeof options && options.hasOwnProperty("crossOrigin") ? console.error(
+            "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+            getValueDescriptorExpectingEnumForWarning(options)
+          ) : console.error(
+            "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
+            getValueDescriptorExpectingEnumForWarning(options)
+          );
+        }
+        "string" === typeof href && Internals.d.D(href);
+      };
+      exports.preinit = function(href, options) {
+        "string" === typeof href && href ? null == options || "object" !== typeof options ? console.error(
+          "ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.",
+          getValueDescriptorExpectingEnumForWarning(options)
+        ) : "style" !== options.as && "script" !== options.as && console.error(
+          'ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are "style" and "script".',
+          getValueDescriptorExpectingEnumForWarning(options.as)
+        ) : console.error(
+          "ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
+          getValueDescriptorExpectingObjectForWarning(href)
+        );
+        if ("string" === typeof href && options && "string" === typeof options.as) {
+          var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
+          "style" === as ? Internals.d.S(
+            href,
+            "string" === typeof options.precedence ? options.precedence : void 0,
+            {
+              crossOrigin,
+              integrity,
+              fetchPriority
+            }
+          ) : "script" === as && Internals.d.X(href, {
+            crossOrigin,
+            integrity,
+            fetchPriority,
+            nonce: "string" === typeof options.nonce ? options.nonce : void 0
+          });
+        }
+      };
+      exports.preinitModule = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "script" !== options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingEnumForWarning(options.as) + ".");
+        if (encountered)
+          console.error(
+            "ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s",
+            encountered
+          );
+        else
+          switch (encountered = options && "string" === typeof options.as ? options.as : "script", encountered) {
+            case "script":
+              break;
+            default:
+              encountered = getValueDescriptorExpectingEnumForWarning(encountered), console.error(
+                'ReactDOM.preinitModule(): Currently the only supported "as" type for this function is "script" but received "%s" instead. This warning was generated for `href` "%s". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)',
+                encountered,
+                href
+              );
+          }
+        if ("string" === typeof href)
+          if ("object" === typeof options && null !== options) {
+            if (null == options.as || "script" === options.as)
+              encountered = getCrossOriginStringAs(
+                options.as,
+                options.crossOrigin
+              ), Internals.d.M(href, {
+                crossOrigin: encountered,
+                integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+                nonce: "string" === typeof options.nonce ? options.nonce : void 0
+              });
+          } else null == options && Internals.d.M(href);
+      };
+      exports.preload = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        null == options || "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : "string" === typeof options.as && options.as || (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+        encountered && console.error(
+          'ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel="preload" as="..." />` tag.%s',
+          encountered
+        );
+        if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
+          encountered = options.as;
+          var crossOrigin = getCrossOriginStringAs(
+            encountered,
+            options.crossOrigin
+          );
+          Internals.d.L(href, encountered, {
+            crossOrigin,
+            integrity: "string" === typeof options.integrity ? options.integrity : void 0,
+            nonce: "string" === typeof options.nonce ? options.nonce : void 0,
+            type: "string" === typeof options.type ? options.type : void 0,
+            fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
+            referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
+            imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
+            imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
+            media: "string" === typeof options.media ? options.media : void 0
+          });
+        }
+      };
+      exports.preloadModule = function(href, options) {
+        var encountered = "";
+        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
+        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
+        encountered && console.error(
+          'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
+          encountered
+        );
+        "string" === typeof href && (options ? (encountered = getCrossOriginStringAs(
+          options.as,
+          options.crossOrigin
+        ), Internals.d.m(href, {
+          as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
+          crossOrigin: encountered,
+          integrity: "string" === typeof options.integrity ? options.integrity : void 0
+        })) : Internals.d.m(href));
+      };
+      exports.requestFormReset = function(form) {
+        Internals.d.r(form);
+      };
+      exports.unstable_batchedUpdates = function(fn, a) {
+        return fn(a);
+      };
+      exports.useFormState = function(action, initialState, permalink) {
+        return resolveDispatcher().useFormState(action, initialState, permalink);
+      };
+      exports.useFormStatus = function() {
+        return resolveDispatcher().useHostTransitionStatus();
+      };
+      exports.version = "19.1.1";
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    }();
+  }
+});
+
+// node_modules/react-dom/index.js
+var require_react_dom = __commonJS({
+  "node_modules/react-dom/index.js"(exports, module) {
+    function checkDCE() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") {
+        return;
+      }
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error("^_^");
+      }
+      try {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
+      } catch (err) {
+        console.error(err);
+      }
+    }
+    if (process.env.NODE_ENV === "production") {
+      checkDCE();
+      module.exports = require_react_dom_production();
+    } else {
+      module.exports = require_react_dom_development();
+    }
+  }
+});
+var AnimatedView = React3.forwardRef(function AnimatedView2(props, ref) {
+  return /* @__PURE__ */ React.createElement("div", { ref, ...props });
+});
+var View = React3.forwardRef(function View2(props, ref) {
+  return /* @__PURE__ */ React.createElement("div", { ref, ...props });
+});
+var Text = View;
+
+// src/platform/Animated.tsx
+var createAnimatedValue = (value) => value;
+
+// src/state/state.tsx
 var ContextState = React3__namespace.createContext(null);
 function StateProvider({ children }) {
   const [value] = React3__namespace.useState(() => ({
+    animatedScrollY: createAnimatedValue(0),
     columnWrapperStyle: void 0,
+    internalState: void 0,
     listeners: /* @__PURE__ */ new Map(),
     mapViewabilityAmountCallbacks: /* @__PURE__ */ new Map(),
     mapViewabilityAmountValues: /* @__PURE__ */ new Map(),
     mapViewabilityCallbacks: /* @__PURE__ */ new Map(),
+    mapViewabilityConfigStates: /* @__PURE__ */ new Map(),
     mapViewabilityValues: /* @__PURE__ */ new Map(),
     values: /* @__PURE__ */ new Map([
       ["alignItemsPaddingTop", 0],
@@ -130,7 +590,7 @@ function useSelector$(signalName, selector) {
 
 // src/components/DebugView.tsx
 var DebugRow = ({ children }) => {
-  return /* @__PURE__ */ React3__namespace.createElement(reactNative.View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
+  return /* @__PURE__ */ React3__namespace.createElement(View, { style: { alignItems: "center", flexDirection: "row", justifyContent: "space-between" } }, children);
 };
 var DebugView = React3__namespace.memo(function DebugView2({ state }) {
   const ctx = useStateContext();
@@ -148,7 +608,7 @@ var DebugView = React3__namespace.memo(function DebugView2({ state }) {
     forceUpdate();
   }, 100);
   return /* @__PURE__ */ React3__namespace.createElement(
-    reactNative.View,
+    View,
     {
       pointerEvents: "none",
       style: {
@@ -163,14 +623,12 @@ var DebugView = React3__namespace.memo(function DebugView2({ state }) {
         top: 0
       }
     },
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "TotalSize:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, totalSize.toFixed(2))),
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "ContentSize:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, contentSize.toFixed(2))),
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "At end:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, String(state.isAtEnd))),
-    /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null),
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "ScrollAdjust:"), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, scrollAdjust.toFixed(2))),
-    /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null),
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "RawScroll: "), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, rawScroll.toFixed(2))),
-    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, "ComputedScroll: "), /* @__PURE__ */ React3__namespace.createElement(reactNative.Text, null, scroll.toFixed(2)))
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "TotalSize:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, totalSize.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "ContentSize:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, contentSize.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "At end:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, String(state.isAtEnd))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "ScrollAdjust:"), /* @__PURE__ */ React3__namespace.createElement(Text, null, scrollAdjust.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "RawScroll: "), /* @__PURE__ */ React3__namespace.createElement(Text, null, rawScroll.toFixed(2))),
+    /* @__PURE__ */ React3__namespace.createElement(DebugRow, null, /* @__PURE__ */ React3__namespace.createElement(Text, null, "ComputedScroll: "), /* @__PURE__ */ React3__namespace.createElement(Text, null, scroll.toFixed(2)))
   );
 });
 function useInterval(callback, delay) {
@@ -179,24 +637,141 @@ function useInterval(callback, delay) {
     return () => clearInterval(interval);
   }, [delay]);
 }
-var LeanViewComponent = React3__namespace.forwardRef((props, ref) => {
-  return React3__namespace.createElement("RCTView", { ...props, ref });
-});
-LeanViewComponent.displayName = "RCTView";
-var LeanView = reactNative.Platform.OS === "android" || reactNative.Platform.OS === "ios" ? LeanViewComponent : reactNative.View;
+var globalResizeObserver = null;
+function getGlobalResizeObserver() {
+  if (!globalResizeObserver) {
+    globalResizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const callbacks = callbackMap.get(entry.target);
+        if (callbacks) {
+          for (const callback of callbacks) {
+            callback(entry);
+          }
+        }
+      }
+    });
+  }
+  return globalResizeObserver;
+}
+var callbackMap = /* @__PURE__ */ new WeakMap();
+function useResizeObserver(element, callback) {
+  React3.useEffect(() => {
+    if (!element) return;
+    const observer = getGlobalResizeObserver();
+    let callbacks = callbackMap.get(element);
+    if (!callbacks) {
+      callbacks = /* @__PURE__ */ new Set();
+      callbackMap.set(element, callbacks);
+      observer.observe(element);
+    }
+    callbacks.add(callback);
+    return () => {
+      const callbacks2 = callbackMap.get(element);
+      if (callbacks2) {
+        callbacks2.delete(callback);
+        if (callbacks2.size === 0) {
+          callbackMap.delete(element);
+          observer.unobserve(element);
+        }
+      }
+    };
+  }, [element, callback]);
+}
 
-// src/components/Separator.tsx
-function Separator({ ItemSeparatorComponent, itemKey, leadingItem }) {
-  const [lastItemKeys] = useArr$(["lastItemKeys"]);
-  const isALastItem = lastItemKeys.includes(itemKey);
-  return isALastItem ? null : /* @__PURE__ */ React.createElement(ItemSeparatorComponent, { leadingItem });
+// src/hooks/useSyncLayout.tsx
+function useSyncLayout({
+  ref,
+  onLayoutChange
+}) {
+  var _a, _b;
+  useResizeObserver(
+    ((_b = (_a = ref.current) == null ? void 0 : _a.getScrollableNode) == null ? void 0 : _b.call(_a)) || ref.current,
+    React3.useCallback(
+      (entry) => {
+        onLayoutChange(entry.contentRect, false);
+      },
+      [onLayoutChange]
+    )
+  );
+  React3.useLayoutEffect(() => {
+    if (ref.current) {
+      const rect = ref.current.getBoundingClientRect();
+      onLayoutChange(
+        {
+          height: rect.height,
+          width: rect.width,
+          x: rect.left,
+          y: rect.top
+        },
+        true
+      );
+    }
+  }, []);
+  return {};
 }
 
+// src/components/LayoutView.tsx
+var LayoutView = ({ onLayoutChange, refView, children, ...rest }) => {
+  const ref = refView != null ? refView : React3.useRef();
+  useSyncLayout({ onLayoutChange, ref });
+  return /* @__PURE__ */ React.createElement("div", { ...rest, ref }, children);
+};
+
 // src/constants.ts
 var POSITION_OUT_OF_VIEW = -1e7;
 var ENABLE_DEVMODE = __DEV__ && false;
 var ENABLE_DEBUG_VIEW = __DEV__ && false;
-var IsNewArchitecture = global.nativeFabricUIManager != null;
+var typedForwardRef = React3.forwardRef;
+var typedMemo = React3.memo;
+
+// src/components/PositionView.tsx
+var PositionViewState = typedMemo(function PositionView({
+  id,
+  horizontal,
+  style,
+  refView,
+  ...rest
+}) {
+  const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
+  const base = Array.isArray(style) ? Object.assign({}, ...style) : style;
+  const combinedStyle = horizontal ? { ...base, left: position } : { ...base, top: position };
+  return /* @__PURE__ */ React3__namespace.createElement(LayoutView, { refView, style: combinedStyle, ...rest });
+});
+var PositionViewSticky = typedMemo(function PositionViewSticky2({
+  id,
+  horizontal,
+  style,
+  refView,
+  index,
+  ...rest
+}) {
+  const [position = POSITION_OUT_OF_VIEW] = useArr$([`containerPosition${id}`]);
+  const viewStyle = React3__namespace.useMemo(() => {
+    const base = Array.isArray(style) ? Object.assign({}, ...style) : style;
+    const axisStyle = horizontal ? { transform: `translateX(${position}px)` } : { top: position };
+    return {
+      ...base,
+      zIndex: index + 1e3,
+      ...axisStyle
+    };
+  }, [style, position, horizontal, index]);
+  return /* @__PURE__ */ React3__namespace.createElement(LayoutView, { refView, style: viewStyle, ...rest });
+});
+var PositionView2 = PositionViewState;
+function Separator({ ItemSeparatorComponent, itemKey, leadingItem }) {
+  const [lastItemKeys] = useArr$(["lastItemKeys"]);
+  const isALastItem = lastItemKeys.includes(itemKey);
+  return isALastItem ? null : /* @__PURE__ */ React3__namespace.createElement(ItemSeparatorComponent, { leadingItem });
+}
+
+// src/constants-platform.ts
+var IsNewArchitecture = true;
+
+// src/platform/Platform.ts
+var Platform = {
+  // Widen the type to avoid unreachable-branch lints in cross-platform code that compares against other OSes
+  OS: "web"
+};
 var symbolFirst = Symbol();
 function useInit(cb) {
   const refValue = React3.useRef(symbolFirst);
@@ -333,8 +908,12 @@ function useListScrollSize() {
   const [scrollSize] = useArr$(["scrollSize"]);
   return scrollSize;
 }
-var typedForwardRef = React3.forwardRef;
-var typedMemo = React3.memo;
+function useSyncLayout2() {
+  {
+    const { triggerLayout: syncLayout } = React3.useContext(ContextContainer);
+    return syncLayout;
+  }
+}
 
 // src/components/Container.tsx
 var Container = typedMemo(function Container2({
@@ -346,51 +925,56 @@ var Container = typedMemo(function Container2({
   ItemSeparatorComponent
 }) {
   const ctx = useStateContext();
-  const columnWrapperStyle = ctx.columnWrapperStyle;
-  const [column = 0, data, itemKey, position = POSITION_OUT_OF_VIEW, numColumns, extraData] = useArr$([
+  const { columnWrapperStyle } = ctx;
+  const [column = 0, data, itemKey, numColumns, extraData, isSticky] = useArr$([
     `containerColumn${id}`,
     `containerItemData${id}`,
     `containerItemKey${id}`,
-    `containerPosition${id}`,
     "numColumns",
-    "extraData"
+    "extraData",
+    `containerSticky${id}`
   ]);
   const refLastSize = React3.useRef();
   const ref = React3.useRef(null);
-  const [layoutRenderCount, forceLayoutRender] = React3.useState(0);
+  const [_, forceLayoutRender] = React3.useState(0);
   const otherAxisPos = numColumns > 1 ? `${(column - 1) / numColumns * 100}%` : 0;
   const otherAxisSize = numColumns > 1 ? `${1 / numColumns * 100}%` : void 0;
-  let didLayout = false;
-  let paddingStyles;
-  if (columnWrapperStyle) {
-    const { columnGap, rowGap, gap } = columnWrapperStyle;
-    if (horizontal) {
-      paddingStyles = {
-        paddingRight: columnGap || gap || void 0,
-        paddingVertical: numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0
-      };
-    } else {
-      paddingStyles = {
-        paddingBottom: rowGap || gap || void 0,
-        paddingHorizontal: numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0
-      };
+  const style = React3.useMemo(() => {
+    let paddingStyles;
+    if (columnWrapperStyle) {
+      const { columnGap, rowGap, gap } = columnWrapperStyle;
+      if (horizontal) {
+        const py = numColumns > 1 ? (rowGap || gap || 0) / 2 : void 0;
+        paddingStyles = {
+          paddingBottom: py,
+          paddingRight: columnGap || gap || void 0,
+          paddingTop: py
+        };
+      } else {
+        const px = numColumns > 1 ? (columnGap || gap || 0) / 2 : void 0;
+        paddingStyles = {
+          paddingBottom: rowGap || gap || void 0,
+          paddingLeft: px,
+          paddingRight: px
+        };
+      }
     }
-  }
-  const style = horizontal ? {
-    flexDirection: ItemSeparatorComponent ? "row" : void 0,
-    height: otherAxisSize,
-    left: position,
-    position: "absolute",
-    top: otherAxisPos,
-    ...paddingStyles || {}
-  } : {
-    left: otherAxisPos,
-    position: "absolute",
-    right: numColumns > 1 ? null : 0,
-    top: position,
-    width: otherAxisSize,
-    ...paddingStyles || {}
-  };
+    return horizontal ? {
+      flexDirection: ItemSeparatorComponent ? "row" : void 0,
+      height: otherAxisSize,
+      left: 0,
+      position: "absolute",
+      top: otherAxisPos,
+      ...paddingStyles || {}
+    } : {
+      left: otherAxisPos,
+      position: "absolute",
+      right: numColumns > 1 ? void 0 : 0,
+      top: 0,
+      width: otherAxisSize,
+      ...paddingStyles || {}
+    };
+  }, [horizontal, otherAxisPos, otherAxisSize, columnWrapperStyle, numColumns]);
   const renderedItemInfo = React3.useMemo(
     () => itemKey !== void 0 ? getRenderedItem2(itemKey) : null,
     [itemKey, data, extraData]
@@ -408,104 +992,183 @@ var Container = typedMemo(function Container2({
       value: data
     };
   }, [id, itemKey, index, data]);
-  const onLayout = (event) => {
-    var _a, _b;
+  const onLayoutChange = (rectangle) => {
     if (!isNullOrUndefined(itemKey)) {
-      didLayout = true;
-      let layout = event.nativeEvent.layout;
-      const size = layout[horizontal ? "width" : "height"];
+      let layout = rectangle;
+      layout[horizontal ? "width" : "height"];
       const doUpdate = () => {
         refLastSize.current = { height: layout.height, width: layout.width };
         updateItemSize2(itemKey, layout);
       };
-      if (IsNewArchitecture || size > 0) {
+      {
         doUpdate();
-      } else {
-        (_b = (_a = ref.current) == null ? void 0 : _a.measure) == null ? void 0 : _b.call(_a, (_x, _y, width, height) => {
-          layout = { height, width };
-          doUpdate();
-        });
       }
     }
   };
-  if (IsNewArchitecture) {
-    React3.useLayoutEffect(() => {
-      var _a, _b;
-      if (!isNullOrUndefined(itemKey)) {
-        const measured = (_b = (_a = ref.current) == null ? void 0 : _a.unstable_getBoundingClientRect) == null ? void 0 : _b.call(_a);
-        if (measured) {
-          const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-          if (size) {
-            updateItemSize2(itemKey, measured);
-          }
+  const PositionComponent = isSticky ? PositionViewSticky : PositionView2;
+  return /* @__PURE__ */ React.createElement(ContextContainer.Provider, { value: contextValue }, /* @__PURE__ */ React.createElement(
+    PositionComponent,
+    {
+      horizontal,
+      id,
+      index,
+      key: recycleItems ? void 0 : itemKey,
+      onLayoutChange,
+      refView: ref,
+      style
+    },
+    renderedItem,
+    renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React.createElement(
+      Separator,
+      {
+        ItemSeparatorComponent,
+        itemKey,
+        leadingItem: renderedItemInfo.item
+      }
+    )
+  ));
+});
+
+// src/utils/reordering.ts
+var mapFn = (element) => {
+  const indexStr = element.getAttribute("index");
+  return [element, indexStr === null ? null : parseInt(indexStr)];
+};
+function sortDOMElementsPatience(container) {
+  const elements = Array.from(container.children);
+  if (elements.length <= 1) return elements;
+  const items = elements.map(mapFn);
+  items.sort((a, b) => {
+    const aKey = a[1];
+    const bKey = b[1];
+    if (aKey === null) {
+      return 1;
+    }
+    if (bKey === null) {
+      return -1;
+    }
+    return aKey - bKey;
+  });
+  const targetPositions = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    targetPositions.set(item[0], index);
+  });
+  const currentPositions = elements.map((el) => targetPositions.get(el));
+  const lis = findLIS(currentPositions);
+  const stableIndices = new Set(lis);
+  for (let targetPos = 0; targetPos < items.length; targetPos++) {
+    const element = items[targetPos][0];
+    const currentPos = elements.indexOf(element);
+    if (!stableIndices.has(currentPos)) {
+      let nextStableElement = null;
+      for (let i = targetPos + 1; i < items.length; i++) {
+        const nextEl = items[i][0];
+        const nextCurrentPos = elements.indexOf(nextEl);
+        if (stableIndices.has(nextCurrentPos)) {
+          nextStableElement = nextEl;
+          break;
         }
       }
-    }, [itemKey, layoutRenderCount]);
-  } else {
-    React3.useEffect(() => {
-      if (!isNullOrUndefined(itemKey)) {
-        const timeout = setTimeout(() => {
-          if (!didLayout && refLastSize.current) {
-            updateItemSize2(itemKey, refLastSize.current);
-          }
-        }, 16);
-        return () => {
-          clearTimeout(timeout);
-        };
+      if (nextStableElement) {
+        container.insertBefore(element, nextStableElement);
+      } else {
+        container.appendChild(element);
       }
-    }, [itemKey]);
+    }
   }
-  return /* @__PURE__ */ React3__namespace.createElement(LeanView, { key: recycleItems ? void 0 : itemKey, onLayout, ref, style }, /* @__PURE__ */ React3__namespace.createElement(ContextContainer.Provider, { value: contextValue }, renderedItem, renderedItemInfo && ItemSeparatorComponent && /* @__PURE__ */ React3__namespace.createElement(
-    Separator,
-    {
-      ItemSeparatorComponent,
-      itemKey,
-      leadingItem: renderedItemInfo.item
+}
+function findLIS(arr) {
+  const n = arr.length;
+  const tails = [];
+  const predecessors = new Array(n).fill(-1);
+  const indices = [];
+  for (let i = 0; i < n; i++) {
+    const num = arr[i];
+    let left = 0, right = tails.length;
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2);
+      if (arr[indices[mid]] < num) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
     }
-  )));
-});
-var useAnimatedValue = (initialValue) => {
-  return React3.useRef(new reactNative.Animated.Value(initialValue)).current;
-};
+    if (left === tails.length) {
+      tails.push(num);
+      indices.push(i);
+    } else {
+      tails[left] = num;
+      indices[left] = i;
+    }
+    if (left > 0) {
+      predecessors[i] = indices[left - 1];
+    }
+  }
+  const result = [];
+  let k = indices[indices.length - 1];
+  while (k !== -1) {
+    result.unshift(k);
+    k = predecessors[k];
+  }
+  return result;
+}
 
-// src/hooks/useValue$.ts
-function useValue$(key, params) {
-  var _a;
-  const { getValue, delay } = params || {};
+// src/hooks/useDOMOrder.ts
+function useDOMOrder(ref) {
   const ctx = useStateContext();
-  const animValue = useAnimatedValue((_a = getValue ? getValue(peek$(ctx, key)) : peek$(ctx, key)) != null ? _a : 0);
-  React3.useMemo(() => {
-    let newValue;
-    let prevValue;
-    let didQueueTask = false;
-    listen$(ctx, key, (v) => {
-      newValue = getValue ? getValue(v) : v;
-      if (delay !== void 0) {
-        const fn = () => {
-          didQueueTask = false;
-          if (newValue !== void 0) {
-            animValue.setValue(newValue);
-          }
-        };
-        const delayValue = typeof delay === "function" ? delay(newValue, prevValue) : delay;
-        prevValue = newValue;
-        if (!didQueueTask) {
-          didQueueTask = true;
-          if (delayValue === 0) {
-            queueMicrotask(fn);
-          } else {
-            setTimeout(fn, delayValue);
-          }
+  const debounceRef = React3.useRef(void 0);
+  React3.useEffect(() => {
+    const unsubscribe = listen$(ctx, "lastPositionUpdate", () => {
+      if (debounceRef.current !== void 0) {
+        clearTimeout(debounceRef.current);
+      }
+      debounceRef.current = setTimeout(() => {
+        const parent = ref.current;
+        if (parent) {
+          sortDOMElementsPatience(parent);
         }
-      } else {
-        animValue.setValue(newValue);
-      }
+        debounceRef.current = void 0;
+      }, 500);
     });
-  }, []);
-  return animValue;
+    return () => {
+      unsubscribe();
+      if (debounceRef.current !== void 0) {
+        clearTimeout(debounceRef.current);
+      }
+    };
+  }, [ctx]);
 }
 
 // src/components/Containers.tsx
+var ContainersInner = typedMemo(function ContainersInner2({ horizontal, numColumns, children }) {
+  const ref = React3.useRef(null);
+  const ctx = useStateContext();
+  const columnWrapperStyle = ctx.columnWrapperStyle;
+  const [totalSize, otherAxisSize] = useArr$(["totalSize", "otherAxisSize"]);
+  useDOMOrder(ref);
+  const style = horizontal ? { minHeight: otherAxisSize, width: totalSize } : { height: totalSize, minWidth: otherAxisSize };
+  if (columnWrapperStyle && numColumns > 1) {
+    const { columnGap, rowGap, gap } = columnWrapperStyle;
+    const gapX = columnGap || gap || 0;
+    const gapY = rowGap || gap || 0;
+    if (horizontal) {
+      if (gapY) {
+        style.marginTop = style.marginBottom = -gapY / 2;
+      }
+      if (gapX) {
+        style.marginRight = -gapX;
+      }
+    } else {
+      if (gapX) {
+        style.marginLeft = style.marginRight = -gapX;
+      }
+      if (gapY) {
+        style.marginBottom = -gapY;
+      }
+    }
+  }
+  return /* @__PURE__ */ React3__namespace.createElement("div", { ref, style }, children);
+});
 var Containers = typedMemo(function Containers2({
   horizontal,
   recycleItems,
@@ -514,15 +1177,7 @@ var Containers = typedMemo(function Containers2({
   updateItemSize: updateItemSize2,
   getRenderedItem: getRenderedItem2
 }) {
-  const ctx = useStateContext();
-  const columnWrapperStyle = ctx.columnWrapperStyle;
   const [numContainers, numColumns] = useArr$(["numContainersPooled", "numColumns"]);
-  const animSize = useValue$("totalSize", {
-    // Use a microtask if increasing the size significantly, otherwise use a timeout
-    delay: (value, prevValue) => !prevValue || value - prevValue > 20 ? 0 : 200
-  });
-  const animOpacity = waitForInitialLayout && !IsNewArchitecture ? useValue$("containersDidLayout", { getValue: (value) => value ? 1 : 0 }) : void 0;
-  const otherAxisSize = useValue$("otherAxisSize", { delay: 0 });
   const containers = [];
   for (let i = 0; i < numContainers; i++) {
     containers.push(
@@ -540,45 +1195,209 @@ var Containers = typedMemo(function Containers2({
       )
     );
   }
-  const style = horizontal ? { minHeight: otherAxisSize, opacity: animOpacity, width: animSize } : { height: animSize, minWidth: otherAxisSize, opacity: animOpacity };
-  if (columnWrapperStyle && numColumns > 1) {
-    const { columnGap, rowGap, gap } = columnWrapperStyle;
-    const gapX = columnGap || gap || 0;
-    const gapY = rowGap || gap || 0;
-    if (horizontal) {
-      if (gapY) {
-        style.marginVertical = -gapY / 2;
+  return /* @__PURE__ */ React3__namespace.createElement(ContainersInner, { horizontal, numColumns, waitForInitialLayout }, containers);
+});
+var DevNumbers = __DEV__ && React3__namespace.memo(function DevNumbers2() {
+  return Array.from({ length: 100 }).map((_, index) => /* @__PURE__ */ React3__namespace.createElement(
+    View,
+    {
+      key: index,
+      style: {
+        height: 100,
+        pointerEvents: "none",
+        position: "absolute",
+        top: index * 100,
+        width: "100%"
       }
-      if (gapX) {
-        style.marginRight = -gapX;
+    },
+    /* @__PURE__ */ React3__namespace.createElement(Text, { style: { color: "red" } }, index * 100)
+  ));
+});
+var ListComponentScrollView = React3.forwardRef(function ListComponentScrollView2({
+  children,
+  style,
+  contentContainerStyle,
+  horizontal = false,
+  contentOffset,
+  maintainVisibleContentPosition,
+  onScroll: onScroll2,
+  onMomentumScrollEnd,
+  showsHorizontalScrollIndicator = true,
+  showsVerticalScrollIndicator = true,
+  refreshControl,
+  onLayout,
+  ScrollComponent,
+  ...props
+}, ref) {
+  const scrollRef = React3.useRef(null);
+  const contentRef = React3.useRef(null);
+  const momentumTimeout = React3.useRef(null);
+  React3.useImperativeHandle(ref, () => {
+    const api = {
+      getBoundingClientRect: () => {
+        var _a;
+        return (_a = scrollRef.current) == null ? void 0 : _a.getBoundingClientRect();
+      },
+      getScrollableNode: () => scrollRef.current,
+      getScrollResponder: () => scrollRef.current,
+      scrollBy: (options) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { x = 0, y = 0, animated = true } = options;
+        el.scrollBy({ behavior: animated ? "smooth" : "auto", left: x, top: y });
+      },
+      scrollTo: (options) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { x = 0, y = 0, animated = true } = options;
+        el.scrollTo({ behavior: animated ? "smooth" : "auto", left: x, top: y });
+      },
+      scrollToEnd: (options = {}) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { animated = true } = options;
+        if (horizontal) {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", left: el.scrollWidth });
+        } else {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", top: el.scrollHeight });
+        }
+      },
+      scrollToOffset: (params) => {
+        const el = scrollRef.current;
+        if (!el) return;
+        const { offset, animated = true } = params;
+        if (horizontal) {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", left: offset });
+        } else {
+          el.scrollTo({ behavior: animated ? "smooth" : "auto", top: offset });
+        }
       }
-    } else {
-      if (gapX) {
-        style.marginHorizontal = -gapX;
+    };
+    return api;
+  }, [horizontal]);
+  const handleScroll = React3.useCallback(
+    (event) => {
+      if (!onScroll2 || !(event == null ? void 0 : event.target)) {
+        return;
       }
-      if (gapY) {
-        style.marginBottom = -gapY;
+      const target = event.target;
+      const scrollEvent = {
+        nativeEvent: {
+          contentOffset: {
+            x: target.scrollLeft,
+            y: target.scrollTop
+          },
+          contentSize: {
+            height: target.scrollHeight,
+            width: target.scrollWidth
+          },
+          layoutMeasurement: {
+            height: target.clientHeight,
+            width: target.clientWidth
+          }
+        }
+      };
+      onScroll2(scrollEvent);
+      if (onMomentumScrollEnd) {
+        if (momentumTimeout.current != null) clearTimeout(momentumTimeout.current);
+        momentumTimeout.current = setTimeout(() => {
+          onMomentumScrollEnd({
+            nativeEvent: {
+              contentOffset: scrollEvent.nativeEvent.contentOffset
+            }
+          });
+        }, 100);
       }
+    },
+    [onScroll2, onMomentumScrollEnd]
+  );
+  React3.useLayoutEffect(() => {
+    const element = scrollRef.current;
+    if (!element) return;
+    element.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      element.removeEventListener("scroll", handleScroll);
+    };
+  }, [handleScroll]);
+  React3.useLayoutEffect(() => {
+    if (contentOffset && scrollRef.current) {
+      scrollRef.current.scrollLeft = contentOffset.x || 0;
+      scrollRef.current.scrollTop = contentOffset.y || 0;
     }
-  }
-  return /* @__PURE__ */ React3__namespace.createElement(reactNative.Animated.View, { style }, containers);
+  }, [contentOffset]);
+  React3.useLayoutEffect(() => {
+    if (!onLayout || !scrollRef.current) return;
+    const element = scrollRef.current;
+    const fireLayout = () => {
+      const rect = element.getBoundingClientRect();
+      onLayout({
+        nativeEvent: {
+          layout: {
+            height: rect.height,
+            width: rect.width,
+            x: rect.left,
+            y: rect.top
+          }
+        }
+      });
+    };
+    fireLayout();
+    const resizeObserver = new ResizeObserver(() => {
+      fireLayout();
+    });
+    resizeObserver.observe(element);
+    return () => resizeObserver.disconnect();
+  }, [onLayout]);
+  const scrollViewStyle = {
+    overflow: "auto",
+    overflowX: horizontal ? "auto" : showsHorizontalScrollIndicator ? "auto" : "hidden",
+    overflowY: horizontal ? showsVerticalScrollIndicator ? "auto" : "hidden" : "auto",
+    position: "relative",
+    // Ensure proper positioning context
+    WebkitOverflowScrolling: "touch",
+    // iOS momentum scrolling
+    ...style
+  };
+  const contentStyle = {
+    display: horizontal ? "flex" : "block",
+    flexDirection: horizontal ? "row" : void 0,
+    minHeight: horizontal ? void 0 : "100%",
+    minWidth: horizontal ? "100%" : void 0,
+    ...contentContainerStyle
+  };
+  return /* @__PURE__ */ React.createElement("div", { ref: scrollRef, style: scrollViewStyle, ...props }, refreshControl, /* @__PURE__ */ React.createElement("div", { ref: contentRef, style: contentStyle }, children));
 });
+function useValueListener$(key, callback) {
+  const ctx = useStateContext();
+  React3.useLayoutEffect(() => {
+    listen$(ctx, key, (value) => {
+      callback(value);
+    });
+  }, []);
+}
+
+// src/components/ScrollAdjust.tsx
 function ScrollAdjust() {
-  const bias = 1e7;
-  const [scrollAdjust, scrollAdjustUserOffset] = useArr$(["scrollAdjust", "scrollAdjustUserOffset"]);
-  const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0) + bias;
-  return /* @__PURE__ */ React3__namespace.createElement(
-    reactNative.View,
-    {
-      style: {
-        height: 0,
-        left: 0,
-        position: "absolute",
-        top: scrollOffset,
-        width: 0
-      }
+  const ctx = useStateContext();
+  const lastScrollOffsetRef = React3__namespace.useRef(0);
+  const callback = React3__namespace.useCallback(() => {
+    var _a;
+    const scrollAdjust = peek$(ctx, "scrollAdjust");
+    const scrollAdjustUserOffset = peek$(ctx, "scrollAdjustUserOffset");
+    const scrollOffset = (scrollAdjust || 0) + (scrollAdjustUserOffset || 0);
+    const scrollView = (_a = ctx.internalState) == null ? void 0 : _a.refScroller.current;
+    if (scrollView && scrollOffset !== lastScrollOffsetRef.current) {
+      const scrollDelta = scrollOffset - lastScrollOffsetRef.current;
+      if (scrollDelta !== 0) {
+        scrollView.scrollBy(0, scrollDelta);
+        console.log("ScrollAdjust (web scrollBy)", scrollDelta, "total offset:", scrollOffset);
+      }
+      lastScrollOffsetRef.current = scrollOffset;
     }
-  );
+  }, []);
+  useValueListener$("scrollAdjust", callback);
+  useValueListener$("scrollAdjustUserOffset", callback);
+  return null;
 }
 
 // src/components/SnapWrapper.tsx
@@ -586,26 +1405,11 @@ function SnapWrapper({ ScrollComponent, ...props }) {
   const [snapToOffsets] = useArr$(["snapToOffsets"]);
   return /* @__PURE__ */ React.createElement(ScrollComponent, { ...props, snapToOffsets });
 }
-function useSyncLayout({
-  onChange
-}) {
-  const ref = React3.useRef(null);
-  const onLayout = React3.useCallback(
-    (event) => {
-      onChange(event.nativeEvent.layout, false);
-    },
-    [onChange]
-  );
-  if (IsNewArchitecture) {
-    React3.useLayoutEffect(() => {
-      if (ref.current) {
-        ref.current.measure((x, y, width, height) => {
-          onChange({ height, width, x, y }, true);
-        });
-      }
-    }, []);
-  }
-  return { onLayout, ref };
+
+// src/hooks/useValue$.ts
+function useValue$(key, params) {
+  const [value] = useArr$([key]);
+  return value;
 }
 
 // src/components/ListComponent.tsx
@@ -619,13 +1423,13 @@ var getComponent = (Component) => {
   return null;
 };
 var Padding = () => {
-  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React3__namespace.createElement(reactNative.Animated.View, { style: { paddingTop: animPaddingTop } });
+  const animPaddingTop = useValue$("alignItemsPaddingTop");
+  return /* @__PURE__ */ React3__namespace.createElement(AnimatedView, { style: { paddingTop: animPaddingTop } });
 };
 var PaddingDevMode = () => {
-  const animPaddingTop = useValue$("alignItemsPaddingTop", { delay: 0 });
-  return /* @__PURE__ */ React3__namespace.createElement(React3__namespace.Fragment, null, /* @__PURE__ */ React3__namespace.createElement(reactNative.Animated.View, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React3__namespace.createElement(
-    reactNative.Animated.View,
+  const animPaddingTop = useValue$("alignItemsPaddingTop");
+  return /* @__PURE__ */ React3__namespace.createElement(React3__namespace.Fragment, null, /* @__PURE__ */ React3__namespace.createElement(AnimatedView, { style: { paddingTop: animPaddingTop } }), /* @__PURE__ */ React3__namespace.createElement(
+    AnimatedView,
     {
       style: {
         backgroundColor: "green",
@@ -663,16 +1467,15 @@ var ListComponent = typedMemo(function ListComponent2({
   scrollAdjustHandler,
   onLayoutHeader,
   snapToIndices,
+  stickyIndices,
   ...rest
 }) {
   const ctx = useStateContext();
-  const { onLayout: onLayoutHeaderSync, ref: refHeader } = useSyncLayout({
-    onChange: onLayoutHeader
-  });
+  const refHeader = React3__namespace.useRef(null);
   const ScrollComponent = renderScrollComponent ? React3.useMemo(
     () => React3__namespace.forwardRef((props, ref) => renderScrollComponent({ ...props, ref })),
     [renderScrollComponent]
-  ) : reactNative.ScrollView;
+  ) : ListComponentScrollView;
   React3__namespace.useEffect(() => {
     if (canRender) {
       setTimeout(() => {
@@ -681,16 +1484,17 @@ var ListComponent = typedMemo(function ListComponent2({
     }
   }, [canRender]);
   const SnapOrScroll = snapToIndices ? SnapWrapper : ScrollComponent;
+  const contentContainerStyleWeb = React3.useMemo(() => {
+    const base = contentContainerStyle || void 0;
+    if (!horizontal) return base;
+    if (base && base.height === "100%") return base;
+    return { ...base || {}, height: "100%" };
+  }, [horizontal, (contentContainerStyle == null ? void 0 : contentContainerStyle.height) === "100%" ? 1 : 0]);
   return /* @__PURE__ */ React3__namespace.createElement(
     SnapOrScroll,
     {
       ...rest,
-      contentContainerStyle: [
-        contentContainerStyle,
-        horizontal ? {
-          height: "100%"
-        } : {}
-      ],
+      contentContainerStyle: contentContainerStyleWeb,
       contentOffset: initialContentOffset ? horizontal ? { x: initialContentOffset, y: 0 } : { x: 0, y: initialContentOffset } : void 0,
       horizontal,
       maintainVisibleContentPosition: maintainVisibleContentPosition && !ListEmptyComponent ? { minIndexForVisible: 0 } : void 0,
@@ -702,7 +1506,15 @@ var ListComponent = typedMemo(function ListComponent2({
     },
     maintainVisibleContentPosition && /* @__PURE__ */ React3__namespace.createElement(ScrollAdjust, null),
     ENABLE_DEVMODE ? /* @__PURE__ */ React3__namespace.createElement(PaddingDevMode, null) : /* @__PURE__ */ React3__namespace.createElement(Padding, null),
-    ListHeaderComponent && /* @__PURE__ */ React3__namespace.createElement(reactNative.View, { onLayout: onLayoutHeaderSync, ref: refHeader, style: ListHeaderComponentStyle }, getComponent(ListHeaderComponent)),
+    ListHeaderComponent && /* @__PURE__ */ React3__namespace.createElement(
+      LayoutView,
+      {
+        onLayoutChange: onLayoutHeader,
+        refView: refHeader,
+        style: ListHeaderComponentStyle
+      },
+      getComponent(ListHeaderComponent)
+    ),
     ListEmptyComponent && getComponent(ListEmptyComponent),
     canRender && /* @__PURE__ */ React3__namespace.createElement(
       Containers,
@@ -716,16 +1528,17 @@ var ListComponent = typedMemo(function ListComponent2({
       }
     ),
     ListFooterComponent && /* @__PURE__ */ React3__namespace.createElement(
-      reactNative.View,
+      LayoutView,
       {
-        onLayout: (event) => {
-          const size = event.nativeEvent.layout[horizontal ? "width" : "height"];
+        onLayoutChange: (layout) => {
+          const size = layout[horizontal ? "width" : "height"];
           set$(ctx, "footerSize", size);
         },
         style: ListFooterComponentStyle
       },
       getComponent(ListFooterComponent)
-    )
+    ),
+    __DEV__ && ENABLE_DEVMODE && /* @__PURE__ */ React3__namespace.createElement(DevNumbers, null)
   );
 });
 
@@ -746,33 +1559,45 @@ function calculateOffsetForIndex(ctx, state, index) {
   let position = 0;
   if (index !== void 0) {
     position = (state == null ? void 0 : state.positions.get(getId(state, index))) || 0;
-  }
-  const paddingTop = peek$(ctx, "stylePaddingTop");
-  if (paddingTop) {
-    position += paddingTop;
-  }
-  const headerSize = peek$(ctx, "headerSize");
-  if (headerSize) {
-    position += headerSize;
+    const paddingTop = peek$(ctx, "stylePaddingTop");
+    if (paddingTop) {
+      position += paddingTop;
+    }
+    const headerSize = peek$(ctx, "headerSize");
+    if (headerSize) {
+      position += headerSize;
+    }
   }
   return position;
 }
 
 // src/utils/getItemSize.ts
 function getItemSize(state, key, index, data, useAverageSize) {
+  var _a, _b;
   const {
     sizesKnown,
     sizes,
     scrollingTo,
-    props: { estimatedItemSize, getEstimatedItemSize }
+    averageSizes,
+    props: { estimatedItemSize, getEstimatedItemSize, getFixedItemSize, getItemType }
   } = state;
   const sizeKnown = sizesKnown.get(key);
   if (sizeKnown !== void 0) {
     return sizeKnown;
   }
   let size;
-  if (useAverageSize !== void 0 && sizeKnown === void 0 && !getEstimatedItemSize && !scrollingTo) {
-    size = useAverageSize;
+  const itemType = getItemType ? (_a = getItemType(data, index)) != null ? _a : "" : "";
+  if (getFixedItemSize) {
+    size = getFixedItemSize(index, data, itemType);
+    if (size !== void 0) {
+      sizesKnown.set(key, size);
+    }
+  }
+  if (size === void 0 && useAverageSize && sizeKnown === void 0 && !scrollingTo) {
+    const averageSizeForType = (_b = averageSizes[itemType]) == null ? void 0 : _b.avg;
+    if (averageSizeForType !== void 0) {
+      size = roundSize(averageSizeForType);
+    }
   }
   if (size === void 0) {
     size = sizes.get(key);
@@ -781,7 +1606,7 @@ function getItemSize(state, key, index, data, useAverageSize) {
     }
   }
   if (size === void 0) {
-    size = getEstimatedItemSize ? getEstimatedItemSize(index, data) : estimatedItemSize;
+    size = getEstimatedItemSize ? getEstimatedItemSize(index, data, itemType) : estimatedItemSize;
   }
   sizes.set(key, size);
   return size;
@@ -800,11 +1625,46 @@ function calculateOffsetWithOffsetPosition(state, offsetParam, params) {
   return offset;
 }
 
+// src/core/finishScrollTo.ts
+var finishScrollTo = (state) => {
+  if (state) {
+    state.scrollingTo = void 0;
+    state.scrollHistory.length = 0;
+  }
+};
+
+// src/core/scrollTo.ts
+function scrollTo(state, params = {}) {
+  var _a;
+  const { animated, noScrollingTo } = params;
+  const {
+    refScroller,
+    props: { horizontal }
+  } = state;
+  const offset = calculateOffsetWithOffsetPosition(state, params.offset, params);
+  state.scrollHistory.length = 0;
+  if (!noScrollingTo) {
+    state.scrollingTo = params;
+  }
+  state.scrollPending = offset;
+  (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
+    animated: !!animated,
+    x: horizontal ? offset : 0,
+    y: horizontal ? 0 : offset
+  });
+  if (!animated) {
+    state.scroll = offset;
+    setTimeout(() => finishScrollTo(state), 100);
+  }
+}
+
 // src/utils/requestAdjust.ts
-function requestAdjust(ctx, state, positionDiff) {
+function requestAdjust(ctx, state, positionDiff, dataChanged) {
   if (Math.abs(positionDiff) > 0.1) {
     const doit = () => {
-      state.scrollAdjustHandler.requestAdjust(positionDiff);
+      {
+        state.scrollAdjustHandler.requestAdjust(positionDiff);
+      }
     };
     state.scroll += positionDiff;
     state.scrollForNextCalculateItemsInView = void 0;
@@ -823,49 +1683,72 @@ function requestAdjust(ctx, state, positionDiff) {
       if (state.ignoreScrollFromMVCPTimeout) {
         clearTimeout(state.ignoreScrollFromMVCPTimeout);
       }
-      state.ignoreScrollFromMVCPTimeout = setTimeout(() => {
-        state.ignoreScrollFromMVCP = void 0;
-      }, 100);
+      state.ignoreScrollFromMVCPTimeout = setTimeout(
+        () => {
+          state.ignoreScrollFromMVCP = void 0;
+        },
+        100
+      );
     } else {
       requestAnimationFrame(doit);
     }
   }
 }
 
-// src/core/prepareMVCP.ts
-function prepareMVCP(ctx, state) {
+// src/core/mvcp.ts
+function prepareMVCP(ctx, state, dataChanged) {
   const {
+    idsInView,
     positions,
     scrollingTo,
     props: { maintainVisibleContentPosition }
   } = state;
   let prevPosition;
   let targetId;
-  let targetIndex;
+  const idsInViewWithPositions = [];
   const scrollTarget = scrollingTo == null ? void 0 : scrollingTo.index;
   if (maintainVisibleContentPosition) {
     const indexByKey = state.indexByKey;
     if (scrollTarget !== void 0) {
       targetId = getId(state, scrollTarget);
-      targetIndex = scrollTarget;
-    } else if (state.idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
-      targetId = state.idsInView.find((id) => indexByKey.get(id) !== void 0);
-      targetIndex = indexByKey.get(targetId);
+    } else if (idsInView.length > 0 && peek$(ctx, "containersDidLayout")) {
+      if (dataChanged) {
+        for (let i = 0; i < idsInView.length; i++) {
+          const id = idsInView[i];
+          const index = indexByKey.get(id);
+          if (index !== void 0) {
+            idsInViewWithPositions.push({ id, position: positions.get(id) });
+          }
+        }
+      } else {
+        targetId = state.idsInView.find((id) => indexByKey.get(id) !== void 0);
+      }
     }
-    if (targetId !== void 0 && targetIndex !== void 0) {
+    if (targetId !== void 0) {
       prevPosition = positions.get(targetId);
     }
   }
   return () => {
+    let positionDiff;
+    if (dataChanged && targetId === void 0) {
+      for (let i = 0; i < idsInViewWithPositions.length; i++) {
+        const { id, position } = idsInViewWithPositions[i];
+        const newPosition = positions.get(id);
+        if (newPosition !== void 0) {
+          positionDiff = newPosition - position;
+          break;
+        }
+      }
+    }
     if (targetId !== void 0 && prevPosition !== void 0) {
       const newPosition = positions.get(targetId);
       if (newPosition !== void 0) {
-        const positionDiff = newPosition - prevPosition;
-        if (Math.abs(positionDiff) > 0.1) {
-          requestAdjust(ctx, state, positionDiff);
-        }
+        positionDiff = newPosition - prevPosition;
       }
     }
+    if (positionDiff !== void 0 && Math.abs(positionDiff) > 0.1) {
+      requestAdjust(ctx, state, positionDiff);
+    }
   };
 }
 
@@ -874,10 +1757,10 @@ function setPaddingTop(ctx, state, { stylePaddingTop, alignItemsPaddingTop }) {
   if (stylePaddingTop !== void 0) {
     const prevStylePaddingTop = peek$(ctx, "stylePaddingTop") || 0;
     if (stylePaddingTop < prevStylePaddingTop) {
-      let prevTotalSize = peek$(ctx, "totalSize");
+      let prevTotalSize = peek$(ctx, "totalSize") || 0;
       set$(ctx, "totalSize", prevTotalSize + prevStylePaddingTop);
       state.timeoutSetPaddingTop = setTimeout(() => {
-        prevTotalSize = peek$(ctx, "totalSize");
+        prevTotalSize = peek$(ctx, "totalSize") || 0;
         set$(ctx, "totalSize", prevTotalSize - prevStylePaddingTop);
       }, 16);
     }
@@ -941,43 +1824,6 @@ function addTotalSize(ctx, state, key, add) {
   }
 }
 
-// src/utils/getScrollVelocity.ts
-var getScrollVelocity = (state) => {
-  const { scrollHistory } = state;
-  let velocity = 0;
-  if (scrollHistory.length >= 1) {
-    const newest = scrollHistory[scrollHistory.length - 1];
-    let oldest;
-    let start = 0;
-    for (let i = 0; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      const nextEntry = scrollHistory[i + 1];
-      if (i > 0) {
-        const prevEntry = scrollHistory[i - 1];
-        const prevDirection = entry.scroll - prevEntry.scroll;
-        const currentDirection = nextEntry.scroll - entry.scroll;
-        if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
-          start = i;
-          break;
-        }
-      }
-    }
-    for (let i = start; i < scrollHistory.length - 1; i++) {
-      const entry = scrollHistory[i];
-      if (newest.time - entry.time <= 1e3) {
-        oldest = entry;
-        break;
-      }
-    }
-    if (oldest) {
-      const scrollDiff = newest.scroll - oldest.scroll;
-      const timeDiff = newest.time - oldest.time;
-      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
-    }
-  }
-  return velocity;
-};
-
 // src/utils/updateSnapToOffsets.ts
 function updateSnapToOffsets(ctx, state) {
   const {
@@ -994,69 +1840,42 @@ function updateSnapToOffsets(ctx, state) {
 }
 
 // src/core/updateAllPositions.ts
-function updateAllPositions(ctx, state, dataChanged) {
-  var _a, _b, _c, _d, _e;
+function updateAllPositions(ctx, state, dataChanged, startIndex = 0) {
+  var _a, _b, _c, _d, _e, _f;
   const {
-    averageSizes,
     columns,
     indexByKey,
     positions,
-    firstFullyOnScreenIndex,
     idCache,
     sizesKnown,
-    props: { snapToIndices }
+    props: { getEstimatedItemSize, snapToIndices, enableAverages }
   } = state;
   const data = state.props.data;
   const numColumns = peek$(ctx, "numColumns");
   const indexByKeyForChecking = __DEV__ ? /* @__PURE__ */ new Map() : void 0;
-  const scrollVelocity = getScrollVelocity(state);
-  if (dataChanged) {
-    indexByKey.clear();
-    idCache.clear();
-  }
-  const itemType = "";
-  let averageSize = (_a = averageSizes[itemType]) == null ? void 0 : _a.avg;
-  if (averageSize !== void 0) {
-    averageSize = roundSize(averageSize);
-  }
-  const shouldUseBackwards = !dataChanged && scrollVelocity < 0 && firstFullyOnScreenIndex > 5 && firstFullyOnScreenIndex < data.length;
-  if (shouldUseBackwards && firstFullyOnScreenIndex !== void 0) {
-    const anchorId = getId(state, firstFullyOnScreenIndex);
-    const anchorPosition = positions.get(anchorId);
-    if (anchorPosition !== void 0) {
-      let currentRowTop2 = anchorPosition;
-      let maxSizeInRow2 = 0;
-      let bailout = false;
-      for (let i = firstFullyOnScreenIndex - 1; i >= 0; i--) {
-        const id = (_b = idCache.get(i)) != null ? _b : getId(state, i);
-        const size = (_c = sizesKnown.get(id)) != null ? _c : getItemSize(state, id, i, data[i], averageSize);
-        const itemColumn = columns.get(id);
-        maxSizeInRow2 = Math.max(maxSizeInRow2, size);
-        if (itemColumn === 1) {
-          currentRowTop2 -= maxSizeInRow2;
-          maxSizeInRow2 = 0;
-        }
-        if (currentRowTop2 < -2e3) {
-          bailout = true;
-          break;
-        }
-        positions.set(id, currentRowTop2);
-      }
-      if (!bailout) {
-        updateTotalSize(ctx, state);
-        return;
-      }
-    }
-  }
+  const useAverageSize = enableAverages && !getEstimatedItemSize;
   let currentRowTop = 0;
   let column = 1;
   let maxSizeInRow = 0;
   const hasColumns = numColumns > 1;
+  if (startIndex > 0) {
+    const prevIndex = startIndex - 1;
+    const prevId = (_a = idCache.get(prevIndex)) != null ? _a : getId(state, prevIndex);
+    const prevPosition = (_b = positions.get(prevId)) != null ? _b : 0;
+    if (hasColumns) {
+      const prevColumn = (_c = columns.get(prevId)) != null ? _c : 1;
+      currentRowTop = prevPosition;
+      column = prevColumn % numColumns + 1;
+    } else {
+      const prevSize = (_d = sizesKnown.get(prevId)) != null ? _d : getItemSize(state, prevId, prevIndex, data[prevIndex], useAverageSize);
+      currentRowTop = prevPosition + prevSize;
+    }
+  }
   const needsIndexByKey = dataChanged || indexByKey.size === 0;
   const dataLength = data.length;
-  for (let i = 0; i < dataLength; i++) {
-    const id = (_d = idCache.get(i)) != null ? _d : getId(state, i);
-    const size = (_e = sizesKnown.get(id)) != null ? _e : getItemSize(state, id, i, data[i], averageSize);
+  for (let i = startIndex; i < dataLength; i++) {
+    const id = (_e = idCache.get(i)) != null ? _e : getId(state, i);
+    const size = (_f = sizesKnown.get(id)) != null ? _f : getItemSize(state, id, i, data[i], useAverageSize);
     if (__DEV__ && needsIndexByKey) {
       if (indexByKeyForChecking.has(id)) {
         console.error(
@@ -1091,32 +1910,18 @@ function updateAllPositions(ctx, state, dataChanged) {
 }
 
 // src/core/viewability.ts
-var mapViewabilityConfigCallbackPairs = /* @__PURE__ */ new Map();
-function setupViewability(props) {
-  let { viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged } = props;
-  if (viewabilityConfig || onViewableItemsChanged) {
-    viewabilityConfigCallbackPairs = [
-      ...viewabilityConfigCallbackPairs || [],
-      {
-        onViewableItemsChanged,
-        viewabilityConfig: viewabilityConfig || {
-          viewAreaCoveragePercentThreshold: 0
-        }
-      }
-    ];
+function ensureViewabilityState(ctx, configId) {
+  let map = ctx.mapViewabilityConfigStates;
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    ctx.mapViewabilityConfigStates = map;
   }
-  if (viewabilityConfigCallbackPairs) {
-    for (const pair of viewabilityConfigCallbackPairs) {
-      mapViewabilityConfigCallbackPairs.set(pair.viewabilityConfig.id, {
-        end: -1,
-        previousEnd: -1,
-        previousStart: -1,
-        start: -1,
-        viewableItems: []
-      });
-    }
+  let state = map.get(configId);
+  if (!state) {
+    state = { end: -1, previousEnd: -1, previousStart: -1, start: -1, viewableItems: [] };
+    map.set(configId, state);
   }
-  return viewabilityConfigCallbackPairs;
+  return state;
 }
 function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollSize, start, end) {
   const {
@@ -1124,9 +1929,7 @@ function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollS
     props: { data }
   } = state;
   for (const viewabilityConfigCallbackPair of viewabilityConfigCallbackPairs) {
-    const viewabilityState = mapViewabilityConfigCallbackPairs.get(
-      viewabilityConfigCallbackPair.viewabilityConfig.id
-    );
+    const viewabilityState = ensureViewabilityState(ctx, viewabilityConfigCallbackPair.viewabilityConfig.id);
     viewabilityState.start = start;
     viewabilityState.end = end;
     if (viewabilityConfigCallbackPair.viewabilityConfig.minimumViewTime) {
@@ -1143,7 +1946,7 @@ function updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollS
 function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, state, ctx, scrollSize) {
   const { viewabilityConfig, onViewableItemsChanged } = viewabilityConfigCallbackPair;
   const configId = viewabilityConfig.id;
-  const viewabilityState = mapViewabilityConfigCallbackPairs.get(configId);
+  const viewabilityState = ensureViewabilityState(ctx, configId);
   const { viewableItems: previousViewableItems, start, end } = viewabilityState;
   const viewabilityTokens = /* @__PURE__ */ new Map();
   for (const [containerId, value] of ctx.mapViewabilityAmountValues) {
@@ -1222,6 +2025,15 @@ function updateViewableItemsWithConfig(data, viewabilityConfigCallbackPair, stat
     }
   }
 }
+function shallowEqual(prev, next) {
+  if (!prev) return false;
+  const keys = Object.keys(next);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    if (prev[k] !== next[k]) return false;
+  }
+  return true;
+}
 function computeViewability(state, ctx, viewabilityConfig, containerId, key, scrollSize, item, index) {
   const { sizes, positions, scroll: scrollState } = state;
   const topPad = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
@@ -1250,7 +2062,8 @@ function computeViewability(state, ctx, viewabilityConfig, containerId, key, scr
     size,
     sizeVisible
   };
-  if (JSON.stringify(value) !== JSON.stringify(ctx.mapViewabilityAmountValues.get(containerId))) {
+  const prev = ctx.mapViewabilityAmountValues.get(containerId);
+  if (!shallowEqual(prev, value)) {
     ctx.mapViewabilityAmountValues.set(containerId, value);
     const cb = ctx.mapViewabilityAmountCallbacks.get(containerId);
     if (cb) {
@@ -1280,10 +2093,13 @@ function maybeUpdateViewabilityCallback(ctx, configId, containerId, viewToken) {
   cb == null ? void 0 : cb(viewToken);
 }
 
+// src/platform/batchedUpdates.ts
+var import_react_dom = __toESM(require_react_dom());
+
 // src/utils/checkAllSizesKnown.ts
 function checkAllSizesKnown(state) {
   const { startBuffered, endBuffered, sizesKnown } = state;
-  if (endBuffered !== null) {
+  if (endBuffered !== null && startBuffered >= 0 && endBuffered >= 0) {
     let areAllKnown = true;
     for (let i = startBuffered; areAllKnown && i <= endBuffered; i++) {
       const key = getId(state, i);
@@ -1295,35 +2111,79 @@ function checkAllSizesKnown(state) {
 }
 
 // src/utils/findAvailableContainers.ts
-function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffered, pendingRemoval) {
+function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffered, pendingRemoval, requiredItemTypes, needNewContainers) {
   const numContainers = peek$(ctx, "numContainers");
+  const { stickyContainerPool, containerItemTypes } = state;
   const result = [];
   const availableContainers = [];
-  for (let u = 0; u < numContainers; u++) {
+  const stickyIndicesSet = state.props.stickyIndicesSet;
+  const stickyItemIndices = (needNewContainers == null ? void 0 : needNewContainers.filter((index) => stickyIndicesSet.has(index))) || [];
+  const canReuseContainer = (containerIndex, requiredType) => {
+    if (!requiredType) return true;
+    const existingType = containerItemTypes.get(containerIndex);
+    if (!existingType) return true;
+    return existingType === requiredType;
+  };
+  const neededTypes = requiredItemTypes ? [...requiredItemTypes] : [];
+  let typeIndex = 0;
+  for (let i = 0; i < stickyItemIndices.length; i++) {
+    const requiredType = neededTypes[typeIndex];
+    let foundContainer = false;
+    for (const containerIndex of stickyContainerPool) {
+      const key = peek$(ctx, `containerItemKey${containerIndex}`);
+      const isPendingRemoval = pendingRemoval.includes(containerIndex);
+      if ((key === void 0 || isPendingRemoval) && canReuseContainer(containerIndex, requiredType)) {
+        result.push(containerIndex);
+        if (isPendingRemoval) {
+          const index = pendingRemoval.indexOf(containerIndex);
+          pendingRemoval.splice(index, 1);
+        }
+        foundContainer = true;
+        if (requiredItemTypes) typeIndex++;
+        break;
+      }
+    }
+    if (!foundContainer) {
+      const newContainerIndex = numContainers + result.filter((index) => index >= numContainers).length;
+      result.push(newContainerIndex);
+      stickyContainerPool.add(newContainerIndex);
+      if (requiredItemTypes) typeIndex++;
+    }
+  }
+  for (let u = 0; u < numContainers && result.length < numNeeded; u++) {
+    if (stickyContainerPool.has(u)) {
+      continue;
+    }
     const key = peek$(ctx, `containerItemKey${u}`);
     let isOk = key === void 0;
     if (!isOk) {
       const index = pendingRemoval.indexOf(u);
       if (index !== -1) {
         pendingRemoval.splice(index, 1);
-        isOk = true;
+        const requiredType = neededTypes[typeIndex];
+        isOk = canReuseContainer(u, requiredType);
       }
     }
     if (isOk) {
       result.push(u);
-      if (result.length >= numNeeded) {
-        return result;
+      if (requiredItemTypes) {
+        typeIndex++;
       }
     }
   }
-  for (let u = 0; u < numContainers; u++) {
+  for (let u = 0; u < numContainers && result.length < numNeeded; u++) {
+    if (stickyContainerPool.has(u)) {
+      continue;
+    }
     const key = peek$(ctx, `containerItemKey${u}`);
     if (key === void 0) continue;
     const index = state.indexByKey.get(key);
-    if (index < startBuffered) {
-      availableContainers.push({ distance: startBuffered - index, index: u });
-    } else if (index > endBuffered) {
-      availableContainers.push({ distance: index - endBuffered, index: u });
+    const isOutOfView = index < startBuffered || index > endBuffered;
+    if (isOutOfView) {
+      const distance = index < startBuffered ? startBuffered - index : index - endBuffered;
+      if (!requiredItemTypes || typeIndex < neededTypes.length && canReuseContainer(u, neededTypes[typeIndex])) {
+        availableContainers.push({ distance, index: u });
+      }
     }
   }
   const remaining = numNeeded - result.length;
@@ -1335,6 +2195,9 @@ function findAvailableContainers(ctx, state, numNeeded, startBuffered, endBuffer
       }
       for (const container of availableContainers) {
         result.push(container.index);
+        if (requiredItemTypes) {
+          typeIndex++;
+        }
       }
     }
     const stillNeeded = numNeeded - result.length;
@@ -1363,37 +2226,44 @@ function comparatorByDistance(a, b) {
   return b.distance - a.distance;
 }
 
-// src/core/finishScrollTo.ts
-var finishScrollTo = (state) => {
-  if (state) {
-    state.scrollingTo = void 0;
-    state.scrollHistory.length = 0;
+// src/utils/getScrollVelocity.ts
+var getScrollVelocity = (state) => {
+  const { scrollHistory } = state;
+  let velocity = 0;
+  if (scrollHistory.length >= 1) {
+    const newest = scrollHistory[scrollHistory.length - 1];
+    let oldest;
+    let start = 0;
+    const now = Date.now();
+    for (let i = 0; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      const nextEntry = scrollHistory[i + 1];
+      if (i > 0) {
+        const prevEntry = scrollHistory[i - 1];
+        const prevDirection = entry.scroll - prevEntry.scroll;
+        const currentDirection = nextEntry.scroll - entry.scroll;
+        if (prevDirection > 0 && currentDirection < 0 || prevDirection < 0 && currentDirection > 0) {
+          start = i;
+          break;
+        }
+      }
+    }
+    for (let i = start; i < scrollHistory.length - 1; i++) {
+      const entry = scrollHistory[i];
+      if (now - entry.time <= 1e3) {
+        oldest = entry;
+        break;
+      }
+    }
+    if (oldest && oldest !== newest) {
+      const scrollDiff = newest.scroll - oldest.scroll;
+      const timeDiff = newest.time - oldest.time;
+      velocity = timeDiff > 0 ? scrollDiff / timeDiff : 0;
+    }
   }
+  return velocity;
 };
 
-// src/core/scrollTo.ts
-function scrollTo(state, params = {}) {
-  var _a;
-  const { animated } = params;
-  const {
-    refScroller,
-    props: { horizontal }
-  } = state;
-  const offset = calculateOffsetWithOffsetPosition(state, params.offset, params);
-  state.scrollHistory.length = 0;
-  state.scrollingTo = params;
-  state.scrollPending = offset;
-  (_a = refScroller.current) == null ? void 0 : _a.scrollTo({
-    animated: !!animated,
-    x: horizontal ? offset : 0,
-    y: horizontal ? 0 : offset
-  });
-  if (!animated) {
-    state.scroll = offset;
-    setTimeout(() => finishScrollTo(state), 100);
-  }
-}
-
 // src/core/scrollToIndex.ts
 function scrollToIndex(ctx, state, { index, viewOffset = 0, animated = true, viewPosition }) {
   if (index >= state.props.data.length) {
@@ -1481,33 +2351,101 @@ function setDidLayout(ctx, state) {
   } = state;
   state.queuedInitialLayout = true;
   checkAtBottom(ctx, state);
-  if (!IsNewArchitecture && initialScroll) {
-    scrollToIndex(ctx, state, { ...initialScroll, animated: false });
+  const setIt = () => {
+    set$(ctx, "containersDidLayout", true);
+    if (onLoad) {
+      onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+    }
+  };
+  {
+    setIt();
+  }
+}
+
+// src/core/calculateItemsInView.ts
+function findCurrentStickyIndex(stickyArray, scroll, state) {
+  var _a;
+  const idCache = state.idCache;
+  const positions = state.positions;
+  for (let i = stickyArray.length - 1; i >= 0; i--) {
+    const stickyId = (_a = idCache.get(stickyArray[i])) != null ? _a : getId(state, stickyArray[i]);
+    const stickyPos = stickyId ? positions.get(stickyId) : void 0;
+    if (stickyPos !== void 0 && scroll >= stickyPos) {
+      return i;
+    }
+  }
+  return -1;
+}
+function getActiveStickyIndices(ctx, state, stickyIndices) {
+  return new Set(
+    Array.from(state.stickyContainerPool).map((i) => peek$(ctx, `containerItemKey${i}`)).map((key) => key ? state.indexByKey.get(key) : void 0).filter((idx) => idx !== void 0 && stickyIndices.has(idx))
+  );
+}
+function handleStickyActivation(ctx, state, stickyIndices, stickyArray, scroll, needNewContainers, startBuffered, endBuffered) {
+  var _a;
+  const activeIndices = getActiveStickyIndices(ctx, state, stickyIndices);
+  const currentStickyIdx = findCurrentStickyIndex(stickyArray, scroll, state);
+  for (let offset = 0; offset <= 1; offset++) {
+    const idx = currentStickyIdx - offset;
+    if (idx < 0 || activeIndices.has(stickyArray[idx])) continue;
+    const stickyIndex = stickyArray[idx];
+    const stickyId = (_a = state.idCache.get(stickyIndex)) != null ? _a : getId(state, stickyIndex);
+    if (stickyId && !state.containerItemKeys.has(stickyId) && (stickyIndex < startBuffered || stickyIndex > endBuffered)) {
+      needNewContainers.push(stickyIndex);
+    }
   }
-  set$(ctx, "containersDidLayout", true);
-  if (onLoad) {
-    onLoad({ elapsedTimeInMs: Date.now() - loadStartTime });
+}
+function handleStickyRecycling(ctx, state, stickyArray, scroll, scrollBuffer, pendingRemoval) {
+  var _a, _b, _c;
+  const currentStickyIdx = findCurrentStickyIndex(stickyArray, scroll, state);
+  for (const containerIndex of state.stickyContainerPool) {
+    const itemKey = peek$(ctx, `containerItemKey${containerIndex}`);
+    const itemIndex = itemKey ? state.indexByKey.get(itemKey) : void 0;
+    if (itemIndex === void 0) continue;
+    const arrayIdx = stickyArray.indexOf(itemIndex);
+    if (arrayIdx === -1) continue;
+    const isRecentSticky = arrayIdx >= currentStickyIdx - 1 && arrayIdx <= currentStickyIdx + 1;
+    if (isRecentSticky) continue;
+    const nextIndex = stickyArray[arrayIdx + 1];
+    let shouldRecycle = false;
+    if (nextIndex) {
+      const nextId = (_a = state.idCache.get(nextIndex)) != null ? _a : getId(state, nextIndex);
+      const nextPos = nextId ? state.positions.get(nextId) : void 0;
+      shouldRecycle = nextPos !== void 0 && scroll > nextPos + scrollBuffer * 2;
+    } else {
+      const currentId = (_b = state.idCache.get(itemIndex)) != null ? _b : getId(state, itemIndex);
+      if (currentId) {
+        const currentPos = state.positions.get(currentId);
+        const currentSize = (_c = state.sizes.get(currentId)) != null ? _c : getItemSize(state, currentId, itemIndex, state.props.data[itemIndex]);
+        shouldRecycle = currentPos !== void 0 && scroll > currentPos + currentSize + scrollBuffer * 3;
+      }
+    }
+    if (shouldRecycle) {
+      pendingRemoval.push(containerIndex);
+    }
   }
 }
-
-// src/core/calculateItemsInView.ts
 function calculateItemsInView(ctx, state, params = {}) {
-  reactNative.unstable_batchedUpdates(() => {
+  (0, import_react_dom.unstable_batchedUpdates)(() => {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     const {
-      scrollLength,
-      startBufferedId: startBufferedIdOrig,
-      positions,
       columns,
       containerItemKeys,
+      enableScrollForNextCalculateItemsInView,
       idCache,
-      sizes,
       indexByKey,
+      minIndexSizeChanged,
+      positions,
       scrollForNextCalculateItemsInView,
-      enableScrollForNextCalculateItemsInView,
-      minIndexSizeChanged
+      scrollLength,
+      sizes,
+      startBufferedId: startBufferedIdOrig,
+      viewabilityConfigCallbackPairs,
+      props: { getItemType, initialScroll, itemsAreEqual, keyExtractor, scrollBuffer }
     } = state;
-    const data = state.props.data;
+    const { data } = state.props;
+    const stickyIndicesArr = state.props.stickyIndicesArr || [];
+    const stickyIndicesSet = state.props.stickyIndicesSet || /* @__PURE__ */ new Set();
     const prevNumContainers = peek$(ctx, "numContainers");
     if (!data || scrollLength === 0 || !prevNumContainers) {
       return;
@@ -1519,14 +2457,22 @@ function calculateItemsInView(ctx, state, params = {}) {
     const { dataChanged, doMVCP } = params;
     const speed = getScrollVelocity(state);
     if (doMVCP || dataChanged) {
-      const checkMVCP = doMVCP ? prepareMVCP(ctx, state) : void 0;
-      updateAllPositions(ctx, state, dataChanged);
+      const checkMVCP = doMVCP ? prepareMVCP(ctx, state, dataChanged) : void 0;
+      if (dataChanged) {
+        indexByKey.clear();
+        idCache.clear();
+        positions.clear();
+      }
+      const startIndex = dataChanged ? 0 : minIndexSizeChanged != null ? minIndexSizeChanged : 0;
+      updateAllPositions(ctx, state, dataChanged, startIndex);
+      if (minIndexSizeChanged !== void 0) {
+        state.minIndexSizeChanged = void 0;
+      }
       checkMVCP == null ? void 0 : checkMVCP();
     }
     const scrollExtra = 0;
     const { queuedInitialLayout } = state;
     let { scroll: scrollState } = state;
-    const initialScroll = state.props.initialScroll;
     if (!queuedInitialLayout && initialScroll) {
       const updatedOffset = calculateOffsetWithOffsetPosition(
         state,
@@ -1538,16 +2484,15 @@ function calculateItemsInView(ctx, state, params = {}) {
     const scrollAdjustPad = -previousScrollAdjust - topPad;
     let scroll = scrollState + scrollExtra + scrollAdjustPad;
     if (scroll + scrollLength > totalSize) {
-      scroll = totalSize - scrollLength;
+      scroll = Math.max(0, totalSize - scrollLength);
     }
     if (ENABLE_DEBUG_VIEW) {
       set$(ctx, "debugRawScroll", scrollState);
       set$(ctx, "debugComputedScroll", scroll);
     }
-    const scrollBuffer = state.props.scrollBuffer;
     let scrollBufferTop = scrollBuffer;
     let scrollBufferBottom = scrollBuffer;
-    if (speed > 0) {
+    if (speed > 0 || speed === 0 && scroll < Math.max(50, scrollBuffer)) {
       scrollBufferTop = scrollBuffer * 0.5;
       scrollBufferBottom = scrollBuffer * 1.5;
     } else {
@@ -1555,7 +2500,7 @@ function calculateItemsInView(ctx, state, params = {}) {
       scrollBufferBottom = scrollBuffer * 0.5;
     }
     const scrollTopBuffered = scroll - scrollBufferTop;
-    const scrollBottom = scroll + scrollLength;
+    const scrollBottom = scroll + scrollLength + (scroll < 0 ? -scroll : 0);
     const scrollBottomBuffered = scrollBottom + scrollBufferBottom;
     if (scrollForNextCalculateItemsInView) {
       const { top, bottom } = scrollForNextCalculateItemsInView;
@@ -1569,10 +2514,6 @@ function calculateItemsInView(ctx, state, params = {}) {
     let endNoBuffer = null;
     let endBuffered = null;
     let loopStart = startBufferedIdOrig ? indexByKey.get(startBufferedIdOrig) || 0 : 0;
-    if (minIndexSizeChanged !== void 0) {
-      loopStart = Math.min(minIndexSizeChanged, loopStart);
-      state.minIndexSizeChanged = void 0;
-    }
     for (let i = loopStart; i >= 0; i--) {
       const id = (_a = idCache.get(i)) != null ? _a : getId(state, i);
       const top = positions.get(id);
@@ -1655,7 +2596,7 @@ function calculateItemsInView(ctx, state, params = {}) {
     if (dataChanged) {
       for (let i = 0; i < numContainers; i++) {
         const itemKey = peek$(ctx, `containerItemKey${i}`);
-        if (!state.props.keyExtractor || itemKey && indexByKey.get(itemKey) === void 0) {
+        if (!keyExtractor || itemKey && indexByKey.get(itemKey) === void 0) {
           pendingRemoval.push(i);
         }
       }
@@ -1669,14 +2610,32 @@ function calculateItemsInView(ctx, state, params = {}) {
           needNewContainers.push(i);
         }
       }
+      if (stickyIndicesArr.length > 0) {
+        handleStickyActivation(
+          ctx,
+          state,
+          stickyIndicesSet,
+          stickyIndicesArr,
+          scroll,
+          needNewContainers,
+          startBuffered,
+          endBuffered
+        );
+      }
       if (needNewContainers.length > 0) {
+        const requiredItemTypes = getItemType ? needNewContainers.map((i) => {
+          const itemType = getItemType(data[i], i);
+          return itemType ? String(itemType) : "";
+        }) : void 0;
         const availableContainers = findAvailableContainers(
           ctx,
           state,
           needNewContainers.length,
           startBuffered,
           endBuffered,
-          pendingRemoval
+          pendingRemoval,
+          requiredItemTypes,
+          needNewContainers
         );
         for (let idx = 0; idx < needNewContainers.length; idx++) {
           const i = needNewContainers[idx];
@@ -1688,7 +2647,18 @@ function calculateItemsInView(ctx, state, params = {}) {
           }
           set$(ctx, `containerItemKey${containerIndex}`, id);
           set$(ctx, `containerItemData${containerIndex}`, data[i]);
+          if (requiredItemTypes) {
+            state.containerItemTypes.set(containerIndex, requiredItemTypes[idx]);
+          }
           containerItemKeys.add(id);
+          if (stickyIndicesSet.has(i)) {
+            set$(ctx, `containerSticky${containerIndex}`, true);
+            const topPadding = (peek$(ctx, "stylePaddingTop") || 0) + (peek$(ctx, "headerSize") || 0);
+            set$(ctx, `containerStickyOffset${containerIndex}`, createAnimatedValue(topPadding));
+            state.stickyContainerPool.add(containerIndex);
+          } else {
+            state.stickyContainerPool.delete(containerIndex);
+          }
           if (containerIndex >= numContainers2) {
             numContainers2 = containerIndex + 1;
           }
@@ -1701,12 +2671,22 @@ function calculateItemsInView(ctx, state, params = {}) {
         }
       }
     }
+    if (stickyIndicesArr.length > 0) {
+      handleStickyRecycling(ctx, state, stickyIndicesArr, scroll, scrollBuffer, pendingRemoval);
+    }
+    let didChangePositions = false;
     for (let i = 0; i < numContainers; i++) {
       const itemKey = peek$(ctx, `containerItemKey${i}`);
       if (pendingRemoval.includes(i)) {
         if (itemKey) {
           containerItemKeys.delete(itemKey);
         }
+        state.containerItemTypes.delete(i);
+        if (state.stickyContainerPool.has(i)) {
+          set$(ctx, `containerSticky${i}`, false);
+          set$(ctx, `containerStickyOffset${i}`, void 0);
+          state.stickyContainerPool.delete(i);
+        }
         set$(ctx, `containerItemKey${i}`, void 0);
         set$(ctx, `containerItemData${i}`, void 0);
         set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
@@ -1726,58 +2706,75 @@ function calculateItemsInView(ctx, state, params = {}) {
             const prevData = peek$(ctx, `containerItemData${i}`);
             if (position > POSITION_OUT_OF_VIEW && position !== prevPos) {
               set$(ctx, `containerPosition${i}`, position);
+              didChangePositions = true;
             }
             if (column >= 0 && column !== prevColumn) {
               set$(ctx, `containerColumn${i}`, column);
             }
-            if (prevData !== item) {
+            if (prevData !== item && (itemsAreEqual ? !itemsAreEqual(prevData, item, itemIndex, data) : true)) {
               set$(ctx, `containerItemData${i}`, data[itemIndex]);
             }
           }
         }
       }
     }
+    if (didChangePositions) {
+      set$(ctx, "lastPositionUpdate", Date.now());
+    }
     if (!queuedInitialLayout && endBuffered !== null) {
       if (checkAllSizesKnown(state)) {
         setDidLayout(ctx, state);
       }
     }
-    if (state.viewabilityConfigCallbackPairs) {
-      updateViewableItems(
-        state,
-        ctx,
-        state.viewabilityConfigCallbackPairs,
-        scrollLength,
-        startNoBuffer,
-        endNoBuffer
-      );
+    if (viewabilityConfigCallbackPairs) {
+      updateViewableItems(state, ctx, viewabilityConfigCallbackPairs, scrollLength, startNoBuffer, endNoBuffer);
     }
   });
 }
 
 // src/core/doInitialAllocateContainers.ts
 function doInitialAllocateContainers(ctx, state) {
-  const { scrollLength } = state;
-  const data = state.props.data;
-  if (scrollLength > 0 && data.length > 0 && !peek$(ctx, "numContainers")) {
-    const averageItemSize = state.props.getEstimatedItemSize ? state.props.getEstimatedItemSize(0, data[0]) : state.props.estimatedItemSize;
-    const Extra = 1.5;
-    const numContainers = Math.ceil(
-      (scrollLength + state.props.scrollBuffer * 2) / averageItemSize * state.props.numColumns * Extra
-    );
+  var _a;
+  const {
+    scrollLength,
+    props: {
+      data,
+      getEstimatedItemSize,
+      getFixedItemSize,
+      getItemType,
+      scrollBuffer,
+      numColumns,
+      estimatedItemSize
+    }
+  } = state;
+  const hasContainers = peek$(ctx, "numContainers");
+  if (scrollLength > 0 && data.length > 0 && !hasContainers) {
+    let averageItemSize;
+    const fn = getFixedItemSize || getEstimatedItemSize;
+    if (fn) {
+      let totalSize = 0;
+      const num = Math.min(20, data.length);
+      for (let i = 0; i < num; i++) {
+        totalSize += fn(0, data[0], getItemType ? (_a = getItemType(data[0], 0)) != null ? _a : "" : "");
+      }
+      averageItemSize = totalSize / num;
+    } else {
+      averageItemSize = estimatedItemSize;
+    }
+    const numContainers = Math.ceil((scrollLength + scrollBuffer * 2) / averageItemSize * numColumns);
     for (let i = 0; i < numContainers; i++) {
       set$(ctx, `containerPosition${i}`, POSITION_OUT_OF_VIEW);
       set$(ctx, `containerColumn${i}`, -1);
     }
     set$(ctx, "numContainers", numContainers);
     set$(ctx, "numContainersPooled", numContainers * state.props.initialContainerPoolRatio);
-    if (!IsNewArchitecture) {
+    if (state.lastLayout) {
       if (state.props.initialScroll) {
         requestAnimationFrame(() => {
-          calculateItemsInView(ctx, state);
+          calculateItemsInView(ctx, state, { dataChanged: true });
         });
       } else {
-        calculateItemsInView(ctx, state);
+        calculateItemsInView(ctx, state, { dataChanged: true });
       }
     }
     return true;
@@ -1797,16 +2794,18 @@ function doMaintainScrollAtEnd(ctx, state, animated) {
     }
     requestAnimationFrame(() => {
       var _a;
-      state.maintainingScrollAtEnd = true;
-      (_a = refScroller.current) == null ? void 0 : _a.scrollToEnd({
-        animated
-      });
-      setTimeout(
-        () => {
-          state.maintainingScrollAtEnd = false;
-        },
-        0
-      );
+      if (state == null ? void 0 : state.isAtEnd) {
+        state.maintainingScrollAtEnd = true;
+        (_a = refScroller.current) == null ? void 0 : _a.scrollToEnd({
+          animated
+        });
+        setTimeout(
+          () => {
+            state.maintainingScrollAtEnd = false;
+          },
+          0
+        );
+      }
     });
     return true;
   }
@@ -1843,44 +2842,57 @@ function checkAtTop(state) {
 // src/core/handleLayout.ts
 function handleLayout(ctx, state, layout, setCanRender) {
   const { maintainScrollAtEnd } = state.props;
-  const scrollLength = layout[state.props.horizontal ? "width" : "height"];
+  const measuredLength = layout[state.props.horizontal ? "width" : "height"];
+  const previousLength = state.scrollLength;
+  const scrollLength = measuredLength > 0 ? measuredLength : previousLength;
   const otherAxisSize = layout[state.props.horizontal ? "height" : "width"];
   const needsCalculate = !state.lastLayout || scrollLength > state.scrollLength || state.lastLayout.x !== layout.x || state.lastLayout.y !== layout.y;
   state.lastLayout = layout;
-  const didChange = scrollLength !== state.scrollLength;
   const prevOtherAxisSize = state.otherAxisSize;
-  state.scrollLength = scrollLength;
-  state.otherAxisSize = otherAxisSize;
-  state.lastBatchingAction = Date.now();
-  state.scrollForNextCalculateItemsInView = void 0;
-  doInitialAllocateContainers(ctx, state);
-  if (needsCalculate) {
-    calculateItemsInView(ctx, state, { doMVCP: true });
-  }
-  if (didChange || otherAxisSize !== prevOtherAxisSize) {
-    set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
-  }
-  if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
-    doMaintainScrollAtEnd(ctx, state, false);
-  }
-  updateAlignItemsPaddingTop(ctx, state);
-  checkAtBottom(ctx, state);
-  checkAtTop(state);
-  if (state) {
-    state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
-  }
-  if (__DEV__ && scrollLength === 0) {
-    warnDevOnce(
-      "height0",
-      `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
-    );
+  const didChange = scrollLength !== state.scrollLength || otherAxisSize !== prevOtherAxisSize;
+  if (didChange) {
+    state.scrollLength = scrollLength;
+    state.otherAxisSize = otherAxisSize;
+    state.lastBatchingAction = Date.now();
+    state.scrollForNextCalculateItemsInView = void 0;
+    if (scrollLength > 0) {
+      doInitialAllocateContainers(ctx, state);
+    }
+    if (needsCalculate) {
+      calculateItemsInView(ctx, state, { doMVCP: true });
+    }
+    if (didChange || otherAxisSize !== prevOtherAxisSize) {
+      set$(ctx, "scrollSize", { height: layout.height, width: layout.width });
+    }
+    if (maintainScrollAtEnd === true || maintainScrollAtEnd.onLayout) {
+      doMaintainScrollAtEnd(ctx, state, false);
+    }
+    updateAlignItemsPaddingTop(ctx, state);
+    checkAtBottom(ctx, state);
+    checkAtTop(state);
+    if (state) {
+      state.needsOtherAxisSize = otherAxisSize - (state.props.stylePaddingTop || 0) < 10;
+    }
+    if (__DEV__ && measuredLength === 0) {
+      warnDevOnce(
+        "height0",
+        `List ${state.props.horizontal ? "width" : "height"} is 0. You may need to set a style or \`flex: \` for the list, because children are absolutely positioned.`
+      );
+    }
+    setCanRender(true);
   }
-  setCanRender(true);
 }
 
 // src/core/onScroll.ts
 function onScroll(ctx, state, event) {
-  var _a, _b, _c, _d, _e;
+  var _a, _b, _c;
+  const {
+    scrollProcessingEnabled,
+    props: { onScroll: onScrollProp }
+  } = state;
+  if (scrollProcessingEnabled === false) {
+    return;
+  }
   if (((_b = (_a = event.nativeEvent) == null ? void 0 : _a.contentSize) == null ? void 0 : _b.height) === 0 && ((_c = event.nativeEvent.contentSize) == null ? void 0 : _c.width) === 0) {
     return;
   }
@@ -1893,16 +2905,25 @@ function onScroll(ctx, state, event) {
     }
   }
   state.scrollPending = newScroll;
-  updateScroll(ctx, state, newScroll);
-  (_e = (_d = state.props).onScroll) == null ? void 0 : _e.call(_d, event);
+  {
+    if (!state.onScrollRafScheduled) {
+      state.onScrollRafScheduled = true;
+      requestAnimationFrame(() => {
+        state.onScrollRafScheduled = false;
+        updateScroll(ctx, state, newScroll);
+      });
+    }
+  }
+  onScrollProp == null ? void 0 : onScrollProp(event);
 }
 function updateScroll(ctx, state, newScroll) {
   const scrollingTo = state.scrollingTo;
   state.hasScrolled = true;
   state.lastBatchingAction = Date.now();
-  const currentTime = performance.now();
+  const currentTime = Date.now();
   if (scrollingTo === void 0 && !(state.scrollHistory.length === 0 && newScroll === state.scroll)) {
-    state.scrollHistory.push({ scroll: newScroll, time: currentTime });
+    const adjust = state.scrollAdjustHandler.getAdjust();
+    state.scrollHistory.push({ scroll: newScroll - adjust, time: currentTime });
   }
   if (state.scrollHistory.length > 5) {
     state.scrollHistory.shift();
@@ -1911,9 +2932,11 @@ function updateScroll(ctx, state, newScroll) {
   state.scrollPrevTime = state.scrollTime;
   state.scroll = newScroll;
   state.scrollTime = currentTime;
-  calculateItemsInView(ctx, state);
-  checkAtBottom(ctx, state);
-  checkAtTop(state);
+  if (Math.abs(state.scroll - state.scrollPrev) > 2) {
+    calculateItemsInView(ctx, state);
+    checkAtBottom(ctx, state);
+    checkAtTop(state);
+  }
 }
 
 // src/core/ScrollAdjustHandler.ts
@@ -1936,13 +2959,19 @@ var ScrollAdjustHandler = class {
   setMounted() {
     this.mounted = true;
   }
+  getAdjust() {
+    return this.appliedAdjust;
+  }
 };
 
 // src/core/updateItemSize.ts
-function updateItemSizes(ctx, state, itemUpdates) {
-  var _a;
+function updateItemSize(ctx, state, itemKey, sizeObj) {
+  var _a, _b;
   const {
+    sizesKnown,
     props: {
+      getFixedItemSize,
+      getItemType,
       horizontal,
       maintainVisibleContentPosition,
       suggestEstimatedItemSize,
@@ -1952,47 +2981,60 @@ function updateItemSizes(ctx, state, itemUpdates) {
     }
   } = state;
   if (!data) return;
+  if (getFixedItemSize) {
+    const index2 = state.indexByKey.get(itemKey);
+    if (index2 === void 0) {
+      return;
+    }
+    const itemData = state.props.data[index2];
+    if (itemData === void 0) {
+      return;
+    }
+    const type = getItemType ? (_a = getItemType(itemData, index2)) != null ? _a : "" : "";
+    const size2 = getFixedItemSize(index2, itemData, type);
+    if (size2 !== void 0 && size2 === sizesKnown.get(itemKey)) {
+      return;
+    }
+  }
   const containersDidLayout = peek$(ctx, "containersDidLayout");
   let needsRecalculate = !containersDidLayout;
   let shouldMaintainScrollAtEnd = false;
   let minIndexSizeChanged;
   let maxOtherAxisSize = peek$(ctx, "otherAxisSize") || 0;
-  for (const { itemKey, sizeObj } of itemUpdates) {
-    const index = state.indexByKey.get(itemKey);
-    const prevSizeKnown = state.sizesKnown.get(itemKey);
-    const diff = updateOneItemSize(state, itemKey, sizeObj);
-    const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
-    if (diff !== 0) {
-      minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
-      if (((_a = state.scrollingTo) == null ? void 0 : _a.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index && diff > 0) {
-        requestAdjust(ctx, state, diff * state.scrollingTo.viewPosition);
-      }
-      const { startBuffered, endBuffered } = state;
-      needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
-      if (!needsRecalculate) {
-        const numContainers = ctx.values.get("numContainers");
-        for (let i = 0; i < numContainers; i++) {
-          if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
-            needsRecalculate = true;
-            break;
-          }
+  const index = state.indexByKey.get(itemKey);
+  const prevSizeKnown = state.sizesKnown.get(itemKey);
+  const diff = updateOneItemSize(state, itemKey, sizeObj);
+  const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+  if (diff !== 0) {
+    minIndexSizeChanged = minIndexSizeChanged !== void 0 ? Math.min(minIndexSizeChanged, index) : index;
+    if (((_b = state.scrollingTo) == null ? void 0 : _b.viewPosition) && maintainVisibleContentPosition && index === state.scrollingTo.index && diff > 0) {
+      requestAdjust(ctx, state, diff * state.scrollingTo.viewPosition);
+    }
+    const { startBuffered, endBuffered } = state;
+    needsRecalculate || (needsRecalculate = index >= startBuffered && index <= endBuffered);
+    if (!needsRecalculate) {
+      const numContainers = ctx.values.get("numContainers");
+      for (let i = 0; i < numContainers; i++) {
+        if (peek$(ctx, `containerItemKey${i}`) === itemKey) {
+          needsRecalculate = true;
+          break;
         }
       }
-      if (state.needsOtherAxisSize) {
-        const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
-        maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
-      }
-      if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
-        shouldMaintainScrollAtEnd = true;
-      }
-      onItemSizeChanged == null ? void 0 : onItemSizeChanged({
-        index,
-        itemData: state.props.data[index],
-        itemKey,
-        previous: size - diff,
-        size
-      });
     }
+    if (state.needsOtherAxisSize) {
+      const otherAxisSize = horizontal ? sizeObj.height : sizeObj.width;
+      maxOtherAxisSize = Math.max(maxOtherAxisSize, otherAxisSize);
+    }
+    if (prevSizeKnown !== void 0 && Math.abs(prevSizeKnown - size) > 5) {
+      shouldMaintainScrollAtEnd = true;
+    }
+    onItemSizeChanged == null ? void 0 : onItemSizeChanged({
+      index,
+      itemData: state.props.data[index],
+      itemKey,
+      previous: size - diff,
+      size
+    });
   }
   if (minIndexSizeChanged !== void 0) {
     state.minIndexSizeChanged = state.minIndexSizeChanged !== void 0 ? Math.min(state.minIndexSizeChanged, minIndexSizeChanged) : minIndexSizeChanged;
@@ -2025,43 +3067,30 @@ function updateItemSizes(ctx, state, itemUpdates) {
     }
   }
 }
-function updateItemSize(ctx, state, itemKey, sizeObj) {
-  const { queuedItemSizeUpdates, queuedItemSizeUpdatesWaiting } = state;
-  const containersDidLayout = peek$(ctx, "containersDidLayout");
-  if (!containersDidLayout || !queuedItemSizeUpdatesWaiting) {
-    updateItemSizes(ctx, state, [{ itemKey, sizeObj }]);
-    if (containersDidLayout) {
-      state.queuedItemSizeUpdatesWaiting = true;
-      requestAnimationFrame(() => {
-        state.queuedItemSizeUpdatesWaiting = false;
-        updateItemSizes(ctx, state, queuedItemSizeUpdates);
-        queuedItemSizeUpdates.length = 0;
-      });
-    }
-  } else {
-    queuedItemSizeUpdates.push({ itemKey, sizeObj });
-  }
-}
 function updateOneItemSize(state, itemKey, sizeObj) {
+  var _a;
   const {
     sizes,
     indexByKey,
     sizesKnown,
     averageSizes,
-    props: { data, horizontal }
+    props: { data, horizontal, getEstimatedItemSize, getItemType, getFixedItemSize }
   } = state;
   if (!data) return 0;
   const index = indexByKey.get(itemKey);
   const prevSize = getItemSize(state, itemKey, index, data);
-  const size = Math.floor((horizontal ? sizeObj.width : sizeObj.height) * 8) / 8;
+  const rawSize = horizontal ? sizeObj.width : sizeObj.height;
+  const size = Math.round(rawSize) ;
   sizesKnown.set(itemKey, size);
-  const itemType = "";
-  let averages = averageSizes[itemType];
-  if (!averages) {
-    averages = averageSizes[itemType] = { avg: 0, num: 0 };
+  if (!getEstimatedItemSize && !getFixedItemSize && size > 0) {
+    const itemType = getItemType ? (_a = getItemType(data[index], index)) != null ? _a : "" : "";
+    let averages = averageSizes[itemType];
+    if (!averages) {
+      averages = averageSizes[itemType] = { avg: 0, num: 0 };
+    }
+    averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
+    averages.num++;
   }
-  averages.avg = (averages.avg * averages.num + size) / (averages.num + 1);
-  averages.num++;
   if (!prevSize || Math.abs(prevSize - size) > 0.1) {
     sizes.set(itemKey, size);
     return size - prevSize;
@@ -2084,6 +3113,22 @@ var useCombinedRef = (...refs) => {
   return callback;
 };
 
+// src/platform/RefreshControl.tsx
+function RefreshControl(props) {
+  return null;
+}
+
+// src/platform/StyleSheet.tsx
+var StyleSheet = {
+  create: (styles) => styles,
+  flatten: (style) => style
+};
+
+// src/platform/useStickyScrollHandler.ts
+function useStickyScrollHandler(stickyIndices, horizontal, ctx, onScroll2) {
+  return onScroll2;
+}
+
 // src/utils/createColumnWrapperStyle.ts
 function createColumnWrapperStyle(contentContainerStyle) {
   const { gap, columnGap, rowGap } = contentContainerStyle;
@@ -2099,89 +3144,203 @@ function createColumnWrapperStyle(contentContainerStyle) {
   }
 }
 function getRenderedItem(ctx, state, key) {
+  var _a;
   if (!state) {
     return null;
   }
   const {
     indexByKey,
-    props: { data, renderItem: renderItem2 }
+    props: { data, getItemType, renderItem }
   } = state;
   const index = indexByKey.get(key);
   if (index === void 0) {
     return null;
   }
   let renderedItem = null;
-  if (renderItem2) {
+  if (renderItem && data[index]) {
     const itemProps = {
+      data,
       extraData: peek$(ctx, "extraData"),
       index,
-      item: data[index]
+      item: data[index],
+      type: getItemType ? (_a = getItemType(data[index], index)) != null ? _a : "" : ""
     };
-    renderedItem = React3__namespace.default.createElement(renderItem2, itemProps);
+    renderedItem = isFunction(renderItem) ? renderItem(itemProps) : React3__namespace.default.createElement(renderItem, itemProps);
   }
   return { index, item: data[index], renderedItem };
 }
+function useThrottleDebounce(mode) {
+  const timeoutRef = React3.useRef(null);
+  const lastCallTimeRef = React3.useRef(0);
+  const lastArgsRef = React3.useRef(null);
+  const clearTimeoutRef = () => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  };
+  const execute = React3.useCallback(
+    (callback, delay, ...args) => {
+      {
+        const now = Date.now();
+        lastArgsRef.current = args;
+        if (now - lastCallTimeRef.current >= delay) {
+          lastCallTimeRef.current = now;
+          callback(...args);
+          clearTimeoutRef();
+        } else {
+          clearTimeoutRef();
+          timeoutRef.current = setTimeout(
+            () => {
+              if (lastArgsRef.current) {
+                lastCallTimeRef.current = Date.now();
+                callback(...lastArgsRef.current);
+                timeoutRef.current = null;
+                lastArgsRef.current = null;
+              }
+            },
+            delay - (now - lastCallTimeRef.current)
+          );
+        }
+      }
+    },
+    [mode]
+  );
+  return execute;
+}
+
+// src/utils/throttledOnScroll.ts
+function useThrottledOnScroll(originalHandler, scrollEventThrottle) {
+  const throttle = useThrottleDebounce("throttle");
+  return (event) => throttle(originalHandler, scrollEventThrottle, { nativeEvent: event.nativeEvent });
+}
+
+// src/utils/updateAveragesOnDataChange.ts
+function updateAveragesOnDataChange(state, oldData, newData) {
+  var _a;
+  const {
+    averageSizes,
+    sizesKnown,
+    indexByKey,
+    props: { itemsAreEqual, getItemType, keyExtractor }
+  } = state;
+  if (!itemsAreEqual || !oldData.length || !newData.length) {
+    for (const key in averageSizes) {
+      delete averageSizes[key];
+    }
+    return;
+  }
+  const itemTypesToPreserve = {};
+  const newDataLength = newData.length;
+  const oldDataLength = oldData.length;
+  for (let newIndex = 0; newIndex < newDataLength; newIndex++) {
+    const newItem = newData[newIndex];
+    const id = keyExtractor ? keyExtractor(newItem, newIndex) : String(newIndex);
+    const oldIndex = indexByKey.get(id);
+    if (oldIndex !== void 0 && oldIndex < oldDataLength) {
+      const knownSize = sizesKnown.get(id);
+      if (knownSize === void 0) continue;
+      const oldItem = oldData[oldIndex];
+      const areEqual = itemsAreEqual(oldItem, newItem, newIndex, newData);
+      if (areEqual) {
+        const itemType = getItemType ? (_a = getItemType(newItem, newIndex)) != null ? _a : "" : "";
+        let typeData = itemTypesToPreserve[itemType];
+        if (!typeData) {
+          typeData = itemTypesToPreserve[itemType] = { count: 0, totalSize: 0 };
+        }
+        typeData.totalSize += knownSize;
+        typeData.count++;
+      }
+    }
+  }
+  for (const key in averageSizes) {
+    delete averageSizes[key];
+  }
+  for (const itemType in itemTypesToPreserve) {
+    const { totalSize, count } = itemTypesToPreserve[itemType];
+    if (count > 0) {
+      averageSizes[itemType] = {
+        avg: totalSize / count,
+        num: count
+      };
+    }
+  }
+}
 
 // src/components/LegendList.tsx
 var DEFAULT_DRAW_DISTANCE = 250;
 var DEFAULT_ITEM_SIZE = 100;
-var LegendList = typedForwardRef(function LegendList2(props, forwardedRef) {
-  return /* @__PURE__ */ React3__namespace.createElement(StateProvider, null, /* @__PURE__ */ React3__namespace.createElement(LegendListInner, { ...props, ref: forwardedRef }));
-});
+var LegendList = typedMemo(
+  typedForwardRef(function LegendList2(props, forwardedRef) {
+    const { children, data: dataProp, renderItem: renderItemProp, ...restProps } = props;
+    const isChildrenMode = children !== void 0 && dataProp === void 0;
+    const processedProps = isChildrenMode ? {
+      ...restProps,
+      data: (isArray(children) ? children : React3__namespace.Children.toArray(children)).flat(1),
+      renderItem: ({ item }) => item
+    } : {
+      ...restProps,
+      data: dataProp || [],
+      renderItem: renderItemProp
+    };
+    return /* @__PURE__ */ React3__namespace.createElement(StateProvider, null, /* @__PURE__ */ React3__namespace.createElement(LegendListInner, { ...processedProps, ref: forwardedRef }));
+  })
+);
 var LegendListInner = typedForwardRef(function LegendListInner2(props, forwardedRef) {
-  var _a;
   const {
-    data: dataProp = [],
-    initialScrollIndex: initialScrollIndexProp,
-    initialScrollOffset,
-    horizontal,
-    drawDistance = 250,
-    recycleItems = false,
-    onEndReachedThreshold = 0.5,
-    onStartReachedThreshold = 0.5,
-    maintainScrollAtEnd = false,
-    maintainScrollAtEndThreshold = 0.1,
     alignItemsAtEnd = false,
-    maintainVisibleContentPosition = false,
-    onScroll: onScrollProp,
-    onMomentumScrollEnd,
-    numColumns: numColumnsProp = 1,
     columnWrapperStyle,
-    keyExtractor: keyExtractorProp,
-    renderItem: renderItem2,
-    estimatedListSize,
+    contentContainerStyle: contentContainerStyleProp,
+    data: dataProp = [],
+    drawDistance = 250,
+    enableAverages = true,
     estimatedItemSize: estimatedItemSizeProp,
+    estimatedListSize,
+    extraData,
     getEstimatedItemSize,
-    suggestEstimatedItemSize,
-    ListHeaderComponent,
+    getFixedItemSize,
+    getItemType,
+    horizontal,
+    initialContainerPoolRatio = 2,
+    initialScrollIndex: initialScrollIndexProp,
+    initialScrollOffset: initialScrollOffsetProp,
+    itemsAreEqual,
+    keyExtractor: keyExtractorProp,
     ListEmptyComponent,
+    ListHeaderComponent,
+    maintainScrollAtEnd = false,
+    maintainScrollAtEndThreshold = 0.1,
+    maintainVisibleContentPosition = true,
+    numColumns: numColumnsProp = 1,
+    onEndReached,
+    onEndReachedThreshold = 0.5,
     onItemSizeChanged,
-    refScrollView,
-    waitForInitialLayout = true,
-    extraData,
-    contentContainerStyle: contentContainerStyleProp,
-    style: styleProp,
     onLayout: onLayoutProp,
+    onLoad,
+    onMomentumScrollEnd,
     onRefresh,
-    refreshing,
+    onScroll: onScrollProp,
+    onStartReached,
+    onStartReachedThreshold = 0.5,
     progressViewOffset,
+    recycleItems = false,
     refreshControl,
-    initialContainerPoolRatio = 2,
-    viewabilityConfig,
-    viewabilityConfigCallbackPairs,
+    refreshing,
+    refScrollView,
+    renderItem,
+    scrollEventThrottle,
     snapToIndices,
-    onViewableItemsChanged,
-    onStartReached,
-    onEndReached,
-    onLoad,
+    stickyIndices,
+    style: styleProp,
+    suggestEstimatedItemSize,
+    waitForInitialLayout = true,
     ...rest
   } = props;
   const [renderNum, setRenderNum] = React3.useState(0);
-  const initialScroll = typeof initialScrollIndexProp === "number" ? { index: initialScrollIndexProp } : initialScrollIndexProp;
-  const initialScrollIndex = initialScroll == null ? void 0 : initialScroll.index;
+  const initialScroll = initialScrollIndexProp || initialScrollOffsetProp ? typeof initialScrollIndexProp === "object" ? { index: initialScrollIndexProp.index || 0, viewOffset: initialScrollIndexProp.viewOffset || 0 } : { index: initialScrollIndexProp || 0, viewOffset: initialScrollOffsetProp || 0 } : void 0;
   const [canRender, setCanRender] = React3__namespace.useState(!IsNewArchitecture);
-  const contentContainerStyle = { ...reactNative.StyleSheet.flatten(contentContainerStyleProp) };
-  const style = { ...reactNative.StyleSheet.flatten(styleProp) };
+  const contentContainerStyle = { ...StyleSheet.flatten(contentContainerStyleProp) };
+  const style = { ...StyleSheet.flatten(styleProp) };
   const stylePaddingTopState = extractPadding(style, contentContainerStyle, "Top");
   const stylePaddingBottomState = extractPadding(style, contentContainerStyle, "Bottom");
   const ctx = useStateContext();
@@ -2193,68 +3352,82 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const keyExtractor = keyExtractorProp != null ? keyExtractorProp : (_item, index) => index.toString();
   const refState = React3.useRef();
   if (!refState.current) {
-    const initialScrollLength = (estimatedListSize != null ? estimatedListSize : IsNewArchitecture ? { height: 0, width: 0 } : reactNative.Dimensions.get("window"))[horizontal ? "width" : "height"];
-    refState.current = {
-      averageSizes: {},
-      columns: /* @__PURE__ */ new Map(),
-      containerItemKeys: /* @__PURE__ */ new Set(),
-      enableScrollForNextCalculateItemsInView: true,
-      endBuffered: -1,
-      endNoBuffer: -1,
-      endReachedBlockedByTimer: false,
-      firstFullyOnScreenIndex: -1,
-      idCache: /* @__PURE__ */ new Map(),
-      idsInView: [],
-      indexByKey: /* @__PURE__ */ new Map(),
-      initialScroll,
-      isAtEnd: false,
-      isAtStart: false,
-      isEndReached: false,
-      isStartReached: false,
-      lastBatchingAction: Date.now(),
-      lastLayout: void 0,
-      loadStartTime: Date.now(),
-      minIndexSizeChanged: 0,
-      nativeMarginTop: 0,
-      pendingAdjust: 0,
-      positions: /* @__PURE__ */ new Map(),
-      props: {},
-      queuedCalculateItemsInView: 0,
-      queuedItemSizeUpdates: [],
-      refScroller: void 0,
-      scroll: 0,
-      scrollAdjustHandler: new ScrollAdjustHandler(ctx),
-      scrollForNextCalculateItemsInView: void 0,
-      scrollHistory: [],
-      scrollLength: initialScrollLength,
-      scrollPending: 0,
-      scrollPrev: 0,
-      scrollPrevTime: 0,
-      scrollTime: 0,
-      sizes: /* @__PURE__ */ new Map(),
-      sizesKnown: /* @__PURE__ */ new Map(),
-      startBuffered: -1,
-      startNoBuffer: -1,
-      startReachedBlockedByTimer: false,
-      timeoutSizeMessage: 0,
-      timeouts: /* @__PURE__ */ new Set(),
-      totalSize: 0,
-      viewabilityConfigCallbackPairs: void 0
-    };
-    set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
-    set$(ctx, "extraData", extraData);
+    if (!ctx.internalState) {
+      const initialScrollLength = (estimatedListSize != null ? estimatedListSize : { height: 0, width: 0 } )[horizontal ? "width" : "height"];
+      ctx.internalState = {
+        activeStickyIndex: void 0,
+        averageSizes: {},
+        columns: /* @__PURE__ */ new Map(),
+        containerItemKeys: /* @__PURE__ */ new Set(),
+        containerItemTypes: /* @__PURE__ */ new Map(),
+        enableScrollForNextCalculateItemsInView: true,
+        endBuffered: -1,
+        endNoBuffer: -1,
+        endReachedBlockedByTimer: false,
+        firstFullyOnScreenIndex: -1,
+        idCache: /* @__PURE__ */ new Map(),
+        idsInView: [],
+        indexByKey: /* @__PURE__ */ new Map(),
+        initialScroll,
+        isAtEnd: false,
+        isAtStart: false,
+        isEndReached: false,
+        isStartReached: false,
+        lastBatchingAction: Date.now(),
+        lastLayout: void 0,
+        loadStartTime: Date.now(),
+        minIndexSizeChanged: 0,
+        nativeMarginTop: 0,
+        positions: /* @__PURE__ */ new Map(),
+        props: {},
+        queuedCalculateItemsInView: 0,
+        refScroller: void 0,
+        scroll: 0,
+        scrollAdjustHandler: new ScrollAdjustHandler(ctx),
+        scrollForNextCalculateItemsInView: void 0,
+        scrollHistory: [],
+        scrollLength: initialScrollLength,
+        scrollPending: 0,
+        scrollPrev: 0,
+        scrollPrevTime: 0,
+        scrollProcessingEnabled: true,
+        scrollTime: 0,
+        sizes: /* @__PURE__ */ new Map(),
+        sizesKnown: /* @__PURE__ */ new Map(),
+        startBuffered: -1,
+        startNoBuffer: -1,
+        startReachedBlockedByTimer: false,
+        stickyContainerPool: /* @__PURE__ */ new Set(),
+        stickyContainers: /* @__PURE__ */ new Map(),
+        timeoutSizeMessage: 0,
+        timeouts: /* @__PURE__ */ new Set(),
+        totalSize: 0,
+        viewabilityConfigCallbackPairs: void 0
+      };
+      set$(ctx, "maintainVisibleContentPosition", maintainVisibleContentPosition);
+      set$(ctx, "extraData", extraData);
+    }
+    refState.current = ctx.internalState;
   }
   const state = refState.current;
   const isFirst = !state.props.renderItem;
   const didDataChange = state.props.data !== dataProp;
+  const throttleScrollFn = (
+    // @ts-expect-error TODO Fix this
+    scrollEventThrottle && onScrollProp ? useThrottledOnScroll(onScrollProp, scrollEventThrottle) : onScrollProp
+  );
   state.props = {
     alignItemsAtEnd,
     data: dataProp,
+    enableAverages,
     estimatedItemSize,
     getEstimatedItemSize,
+    getFixedItemSize,
+    getItemType,
     horizontal: !!horizontal,
     initialContainerPoolRatio,
     initialScroll,
+    itemsAreEqual,
     keyExtractor,
     maintainScrollAtEnd,
     maintainScrollAtEndThreshold,
@@ -2264,12 +3437,15 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     onEndReachedThreshold,
     onItemSizeChanged,
     onLoad,
-    onScroll: onScrollProp,
+    onScroll: throttleScrollFn,
     onStartReached,
     onStartReachedThreshold,
-    renderItem: renderItem2,
+    recycleItems: !!recycleItems,
+    renderItem,
     scrollBuffer,
     snapToIndices,
+    stickyIndicesArr: stickyIndices != null ? stickyIndices : [],
+    stickyIndicesSet: React3.useMemo(() => new Set(stickyIndices != null ? stickyIndices : []), [stickyIndices == null ? void 0 : stickyIndices.join(",")]),
     stylePaddingBottom: stylePaddingBottomState,
     stylePaddingTop: stylePaddingTopState,
     suggestEstimatedItemSize: !!suggestEstimatedItemSize
@@ -2278,6 +3454,9 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const checkResetContainers = (isFirst2) => {
     const state2 = refState.current;
     if (state2) {
+      if (!isFirst2 && state2.props.data !== dataProp) {
+        updateAveragesOnDataChange(state2, state2.props.data, dataProp);
+      }
       state2.props.data = dataProp;
       if (!isFirst2) {
         calculateItemsInView(ctx, state2, { dataChanged: true, doMVCP: true });
@@ -2307,7 +3486,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     setPaddingTop(ctx, state, { stylePaddingTop: stylePaddingTopState });
     refState.current.props.stylePaddingBottom = stylePaddingBottomState;
     let paddingDiff = stylePaddingTopState - prevPaddingTop;
-    if (maintainVisibleContentPosition && paddingDiff && prevPaddingTop !== void 0 && reactNative.Platform.OS === "ios") {
+    if (maintainVisibleContentPosition && paddingDiff && prevPaddingTop !== void 0 && Platform.OS === "ios") {
       if (state.scroll < 0) {
         paddingDiff += state.scroll;
       }
@@ -2319,53 +3498,39 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     updateAllPositions(ctx, state);
   }
   const initialContentOffset = React3.useMemo(() => {
-    const initialContentOffset2 = initialScrollOffset || calculateOffsetForIndex(ctx, state, initialScrollIndex);
-    refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
-    if (initialContentOffset2 > 0) {
-      scrollTo(state, { animated: false, index: initialScrollIndex, offset: initialContentOffset2 });
+    if (initialScroll) {
+      const { index, viewOffset } = initialScroll;
+      let initialContentOffset2 = viewOffset || 0;
+      if (index !== void 0) {
+        initialContentOffset2 += calculateOffsetForIndex(ctx, state, index);
+      }
+      refState.current.isStartReached = initialContentOffset2 < refState.current.scrollLength * onStartReachedThreshold;
+      if (initialContentOffset2 > 0) {
+        scrollTo(state, { animated: false, index, offset: initialContentOffset2 });
+      }
+      return initialContentOffset2;
     }
-    return initialContentOffset2;
+    return 0;
   }, [renderNum]);
   if (isFirst || didDataChange || numColumnsProp !== peek$(ctx, "numColumns")) {
-    refState.current.lastBatchingAction = Date.now();
+    state.lastBatchingAction = Date.now();
     if (!keyExtractorProp && !isFirst && didDataChange) {
       __DEV__ && warnDevOnce(
         "keyExtractor",
         "Changing data without a keyExtractor can cause slow performance and resetting scroll. If your list data can change you should use a keyExtractor with a unique id for best performance and behavior."
       );
-      refState.current.sizes.clear();
-      refState.current.positions.clear();
+      state.sizes.clear();
+      state.positions.clear();
     }
   }
-  React3.useLayoutEffect(() => {
-    if (IsNewArchitecture) {
-      let measured;
-      refScroller.current.measure((x, y, width, height) => {
-        measured = { height, width, x, y };
-      });
-      if (measured) {
-        const size = Math.floor(measured[horizontal ? "width" : "height"] * 8) / 8;
-        if (size) {
-          handleLayout(ctx, state, measured, setCanRender);
-        }
-      }
-    }
-    if (!isFirst) {
-      calculateItemsInView(ctx, state, { doMVCP: true });
-    }
-  }, [dataProp]);
   const onLayoutHeader = React3.useCallback((rect, fromLayoutEffect) => {
     const size = rect[horizontal ? "width" : "height"];
     set$(ctx, "headerSize", size);
-    if (initialScroll) {
-      if (IsNewArchitecture && reactNative.Platform.OS !== "android") {
+    if ((initialScroll == null ? void 0 : initialScroll.index) !== void 0) {
+      {
         if (fromLayoutEffect) {
           setRenderNum((v) => v + 1);
         }
-      } else {
-        setTimeout(() => {
-          scrollToIndex(ctx, state, { ...initialScroll, animated: false });
-        }, 17);
       }
     }
   }, []);
@@ -2375,7 +3540,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }
   }, [snapToIndices]);
   React3.useLayoutEffect(() => {
-    const didAllocateContainers = doInitialAllocateContainersCallback();
+    const didAllocateContainers = dataProp.length > 0 && doInitialAllocateContainersCallback();
     if (!didAllocateContainers) {
       checkResetContainers(
         /*isFirst*/
@@ -2386,6 +3551,16 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   React3.useLayoutEffect(() => {
     set$(ctx, "extraData", extraData);
   }, [extraData]);
+  const { onLayout } = useSyncLayout({
+    onLayout: onLayoutProp,
+    onLayoutChange: React3.useCallback(
+      (rectangle) => {
+        handleLayout(ctx, state, rectangle, setCanRender);
+      },
+      [ctx, state, setCanRender]
+    ),
+    ref: refScroller
+  });
   React3.useLayoutEffect(initializeStateVars, [
     memoizedLastItemKeys.join(","),
     numColumnsProp,
@@ -2395,27 +3570,6 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
   const doInitialAllocateContainersCallback = () => {
     return doInitialAllocateContainers(ctx, state);
   };
-  React3.useEffect(() => {
-    const viewability = setupViewability({
-      onViewableItemsChanged,
-      viewabilityConfig,
-      viewabilityConfigCallbackPairs
-    });
-    state.viewabilityConfigCallbackPairs = viewability;
-    state.enableScrollForNextCalculateItemsInView = !viewability;
-  }, [viewabilityConfig, viewabilityConfigCallbackPairs, onViewableItemsChanged]);
-  if (!IsNewArchitecture) {
-    useInit(() => {
-      doInitialAllocateContainersCallback();
-    });
-  }
-  const onLayout = React3.useCallback((event) => {
-    const layout = event.nativeEvent.layout;
-    handleLayout(ctx, state, layout, setCanRender);
-    if (onLayoutProp) {
-      onLayoutProp(event);
-    }
-  }, []);
   React3.useImperativeHandle(forwardedRef, () => {
     const scrollIndexIntoView = (options) => {
       const state2 = refState.current;
@@ -2433,18 +3587,23 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       }
     };
     return {
-      flashScrollIndicators: () => refScroller.current.flashScrollIndicators(),
+      flashScrollIndicators: () => {
+        var _a, _b;
+        return (_b = (_a = refScroller.current) == null ? void 0 : _a.flashScrollIndicators) == null ? void 0 : _b.call(_a);
+      },
       getNativeScrollRef: () => refScroller.current,
-      getScrollableNode: () => refScroller.current.getScrollableNode(),
-      getScrollResponder: () => refScroller.current.getScrollResponder(),
+      getScrollableNode: () => refScroller.current,
+      getScrollResponder: () => refScroller.current,
       getState: () => {
         const state2 = refState.current;
         return state2 ? {
           contentLength: state2.totalSize,
+          data: state2.props.data,
           end: state2.endNoBuffer,
           endBuffered: state2.endBuffered,
           isAtEnd: state2.isAtEnd,
           isAtStart: state2.isAtStart,
+          positionAtIndex: (index) => state2.positions.get(getId(state2, index)),
           positions: state2.positions,
           scroll: state2.scroll,
           scrollLength: state2.scrollLength,
@@ -2471,7 +3630,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
           const footerSize = peek$(ctx, "footerSize") || 0;
           scrollToIndex(ctx, state, {
             index,
-            viewOffset: -paddingBottom - footerSize,
+            viewOffset: -paddingBottom - footerSize + ((options == null ? void 0 : options.viewOffset) || 0),
             viewPosition: 1,
             ...options
           });
@@ -2486,13 +3645,16 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         }
       },
       scrollToOffset: (params) => scrollTo(state, params),
+      setScrollProcessingEnabled: (enabled) => {
+        refState.current.scrollProcessingEnabled = enabled;
+      },
       setVisibleContentAnchorOffset: (value) => {
         const val = typeof value === "function" ? value(peek$(ctx, "scrollAdjustUserOffset") || 0) : value;
         set$(ctx, "scrollAdjustUserOffset", val);
       }
     };
   }, []);
-  if (reactNative.Platform.OS === "web") {
+  {
     React3.useEffect(() => {
       if (initialContentOffset) {
         scrollTo(state, { animated: false, offset: initialContentOffset });
@@ -2507,6 +3669,7 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
     }),
     []
   );
+  const onScrollHandler = useStickyScrollHandler(stickyIndices, horizontal, ctx, fns.onScroll);
   return /* @__PURE__ */ React3__namespace.createElement(React3__namespace.Fragment, null, /* @__PURE__ */ React3__namespace.createElement(
     ListComponent,
     {
@@ -2523,19 +3686,21 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
       onLayout,
       onLayoutHeader,
       onMomentumScrollEnd: (event) => {
-        requestAnimationFrame(() => {
-          finishScrollTo(refState.current);
-        });
+        {
+          requestAnimationFrame(() => {
+            finishScrollTo(refState.current);
+          });
+        }
         if (onMomentumScrollEnd) {
           onMomentumScrollEnd(event);
         }
       },
-      onScroll: fns.onScroll,
+      onScroll: onScrollHandler,
       recycleItems,
       refreshControl: refreshControl ? stylePaddingTopState > 0 ? React3__namespace.cloneElement(refreshControl, {
         progressViewOffset: (refreshControl.props.progressViewOffset || 0) + stylePaddingTopState
       }) : refreshControl : onRefresh && /* @__PURE__ */ React3__namespace.createElement(
-        reactNative.RefreshControl,
+        RefreshControl,
         {
           onRefresh,
           progressViewOffset: (progressViewOffset || 0) + stylePaddingTopState,
@@ -2543,34 +3708,45 @@ var LegendListInner = typedForwardRef(function LegendListInner2(props, forwarded
         }
       ),
       refScrollView: combinedRef,
-      scrollAdjustHandler: (_a = refState.current) == null ? void 0 : _a.scrollAdjustHandler,
-      scrollEventThrottle: reactNative.Platform.OS === "web" ? 16 : void 0,
+      scrollAdjustHandler: state.scrollAdjustHandler,
       snapToIndices,
+      stickyIndices,
       style,
       updateItemSize: fns.updateItemSize,
       waitForInitialLayout
     }
   ), __DEV__ && ENABLE_DEBUG_VIEW && /* @__PURE__ */ React3__namespace.createElement(DebugView, { state: refState.current }));
 });
+/*! Bundled license information:
 
-// src/components/LazyLegendList.tsx
-var typedForwardRef2 = React3.forwardRef;
-var renderItem = ({ item }) => item;
-var LazyLegendList = typedForwardRef2(function LazyLegendList2(props, forwardedRef) {
-  const { LegendList: LegendListProp, children, ...rest } = props;
-  const LegendListComponent = LegendListProp != null ? LegendListProp : LegendList;
-  const data = (isArray(children) ? children : React3__namespace.Children.toArray(children)).flat(1);
-  return (
-    // @ts-expect-error TODO: Fix this type
-    /* @__PURE__ */ React3__namespace.createElement(LegendListComponent, { ...rest, data, ref: forwardedRef, renderItem })
-  );
-});
+react-dom/cjs/react-dom.production.js:
+  (**
+   * @license React
+   * react-dom.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+react-dom/cjs/react-dom.development.js:
+  (**
+   * @license React
+   * react-dom.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/
 
-exports.LazyLegendList = LazyLegendList;
 exports.LegendList = LegendList;
 exports.useIsLastItem = useIsLastItem;
 exports.useListScrollSize = useListScrollSize;
 exports.useRecyclingEffect = useRecyclingEffect;
 exports.useRecyclingState = useRecyclingState;
+exports.useSyncLayout = useSyncLayout2;
 exports.useViewability = useViewability;
 exports.useViewabilityAmount = useViewabilityAmount;