virtual-scroller 1.7.9 → 1.9.0

package/commonjs/BeforeResize.js

@@ -0,0 +1,315 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanUpBeforeResizeState = cleanUpBeforeResizeState;
+exports["default"] = void 0;
+
+var _debug = _interopRequireDefault(require("./utility/debug.js"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+var BeforeResize = /*#__PURE__*/function () {
+  function BeforeResize(_ref) {
+    var getState = _ref.getState,
+        getVerticalSpacing = _ref.getVerticalSpacing,
+        getColumnsCount = _ref.getColumnsCount;
+
+    _classCallCheck(this, BeforeResize);
+
+    this.getState = getState;
+    this.getVerticalSpacing = getVerticalSpacing;
+    this.getColumnsCount = getColumnsCount;
+  }
+
+  _createClass(BeforeResize, [{
+    key: "initializeFromState",
+    value: function initializeFromState(state) {
+      this._includesBeforeResizeInState = Boolean(state.beforeResize);
+    } // Cleans up "before resize" item heights and adjusts the scroll position accordingly.
+    //
+    // Hypothetically, it could also wait for the user to stop scrolling and only then
+    // adjust the scroll position. The rationale is that if `window.scrollTo()` is called
+    // while the user is scrolling, the user would occasionally experience "lost" mouse wheel
+    // events when scrolling with a mouse wheel.
+    //
+    // Seems like Twitter's website waits for the user to stop scrolling before applying
+    // the scroll position correction after a window resize. This library could do that too,
+    // but that would require rewriting "before items height" top padding calculation
+    // so that it doesn't re-calculate it on every re-render and instead does so incrementally,
+    // and then, when the user stops, it re-calculates it from scratch removing the error
+    // and adjusting the scroll position accordingly so that there's no "jump of content".
+    //
+    // But, seems like it works fine as it is and there's no need to rewrite anything.
+    //
+
+  }, {
+    key: "cleanUpBeforeResizeItemHeights",
+    value: function cleanUpBeforeResizeItemHeights() {
+      var _this$getState = this.getState(),
+          firstShownItemIndex = _this$getState.firstShownItemIndex,
+          lastShownItemIndex = _this$getState.lastShownItemIndex,
+          itemHeights = _this$getState.itemHeights,
+          beforeResize = _this$getState.beforeResize; // If there're "before resize" properties in `state`
+      // then it means that the corresponding items are waiting to be
+      // re-measured after container resize. Since the resize,
+      // some of those non-re-measured items might have just been measured,
+      // so see if that's true, and if it is, remove those now-obsolete
+      // "before resize" item heights and ajust the scroll position
+      // so that there's no "content jumping".
+
+
+      if (beforeResize) {
+        // If the user has scrolled up to reveal a previously hidden item
+        // that has not yet been re-measured after a previous resize.
+        if (firstShownItemIndex < beforeResize.itemHeights.length) {
+          (0, _debug["default"])('~ Clean up "before resize" item heights and correct scroll position ~'); // Some of the "before" items have been un-hidden and re-measured.
+          // Un-hiding those items would result in a "jump of content"
+          // because "before resize" heights of those un-hidden items
+          // could (and most likely will) be different from the current ones,
+          // or because "before resize" columns count is different from
+          // the current one.
+          // To prevent a "jump of content", calculate the scroll position
+          // difference and adjust the scroll position.
+          // The height of the item rows that have transitioned
+          // from hidden to shown.
+
+          var newlyShownItemRowsHeight = 0; // Some of the `itemHeights` between the current `firstShownItemIndex` and
+          // the previous `firstShownItemIndex` could stay `undefined` if the user
+          // scrolled "abruptly": for example, by using a `window.scrollTo()` call.
+          // In that case, the items below the visible ones won't be rendered and measured.
+          // In such case, limit the items being iterated over to the current `lastShownItemIndex`
+          // rather than the previous `firstShownItemIndex`.
+
+          var prevFirstReMeasuredItemsRowIndex = Math.floor(beforeResize.itemHeights.length / this.getColumnsCount());
+          var newlyShownItemsToIndex = Math.min(prevFirstReMeasuredItemsRowIndex * this.getColumnsCount() - 1, lastShownItemIndex);
+          var i = firstShownItemIndex;
+
+          while (i <= newlyShownItemsToIndex) {
+            // Calculate newly shown row height.
+            var rowHeight = 0;
+            var columnIndex = 0;
+
+            while (columnIndex < this.getColumnsCount() && i <= newlyShownItemsToIndex) {
+              var itemHeight = itemHeights[i];
+
+              if (itemHeight === undefined) {
+                // `itemHeight` can only be `undefined` when not `beforeResize`.
+                // Use the current "average item height" as a substitute.
+                itemHeight = this.getAverageItemHeight();
+              }
+
+              rowHeight = Math.max(rowHeight, itemHeight);
+              i++;
+              columnIndex++;
+            } // Append to the total "newly shown item rows height".
+
+
+            newlyShownItemRowsHeight += rowHeight;
+            newlyShownItemRowsHeight += this.getVerticalSpacing();
+          } // The height of the "before resize" item rows
+          // that will be "cleaned up" in this function call.
+
+
+          var cleanedUpBeforeResizeItemRowsHeight = 0; // Some of the `beforeResize` item rows might have been skipped if the user
+          // scrolled up "abruptly": for example, by using a `window.scrollTo()` call.
+          // In that case, the "before resize" items below the bottom border of the screen
+          // shouldn't be accounted for when calculating the scrollbar adjustment shift
+          // because items after `lastShownItemIndex` aren't participating in the calculation
+          // of `newlyShownItemRowsHeight`.
+
+          var maxParticipatingBeforeResizeItemsCount = Math.min(beforeResize.itemHeights.length, lastShownItemIndex + 1);
+          var participatingBeforeResizeItemRowsCount = Math.ceil(maxParticipatingBeforeResizeItemsCount / beforeResize.columnsCount);
+          var firstCleanedUpBeforeResizeItemsRowIndex = firstShownItemIndex === 0 ? 0 : Math.floor((firstShownItemIndex - 1) / beforeResize.columnsCount) + 1;
+          var k = firstCleanedUpBeforeResizeItemsRowIndex;
+
+          while (k < participatingBeforeResizeItemRowsCount) {
+            var _rowHeight = beforeResize.itemHeights[k * beforeResize.columnsCount];
+            cleanedUpBeforeResizeItemRowsHeight += _rowHeight;
+            cleanedUpBeforeResizeItemRowsHeight += beforeResize.verticalSpacing;
+            k++;
+          } // Schedule an asynchronous `this.updateState()` call that will update
+          // `beforeResize` property of `state`. Ideally, it should be updated
+          // immediately, but since `this.updateState()` calls are asynchronous,
+          // the code updates just the underlying `beforeResize.itemHeights`
+          // array immediately instead, which is still a hack but still a lesser one.
+
+
+          if (firstShownItemIndex === 0) {
+            (0, _debug["default"])('Drop all "before resize" item heights');
+          } else {
+            var firstDroppedBeforeResizeItemIndex = firstShownItemIndex;
+            var lastDroppedBeforeResizeItemIndex = beforeResize.itemHeights.length - 1;
+
+            if (firstDroppedBeforeResizeItemIndex === lastDroppedBeforeResizeItemIndex) {
+              (0, _debug["default"])('For item index', firstDroppedBeforeResizeItemIndex, '— drop "before resize" height', beforeResize.itemHeights[firstDroppedBeforeResizeItemIndex]);
+            } else {
+              (0, _debug["default"])('For item indexes from', firstDroppedBeforeResizeItemIndex, 'to', lastDroppedBeforeResizeItemIndex, '— drop "before resize" heights', beforeResize.itemHeights.slice(firstDroppedBeforeResizeItemIndex));
+            }
+          } // Immediately update `beforeResize.itemHeights`
+          // so that the component isn't left in an inconsistent state
+          // before a `this.updateState()` call below is applied.
+
+
+          beforeResize.itemHeights.splice(firstShownItemIndex, beforeResize.itemHeights.length - firstShownItemIndex); // Return the "scroll by" amount that would correct the scroll position.
+          // Also return a state update.
+
+          return {
+            scrollBy: newlyShownItemRowsHeight - cleanedUpBeforeResizeItemRowsHeight,
+            beforeResize: firstShownItemIndex === 0 ? undefined : _objectSpread({}, beforeResize)
+          };
+        }
+      }
+    } // Snapshots "before resize" values in order to preserve the currently
+    // shown items' vertical position on screen so that there's no "content jumping".
+    //
+    // `newFirstShownItemIndex` is `> 0`.
+    //
+
+  }, {
+    key: "snapshotBeforeResizeItemHeights",
+    value: function snapshotBeforeResizeItemHeights(_ref2) {
+      var firstShownItemIndex = _ref2.firstShownItemIndex,
+          newFirstShownItemIndex = _ref2.newFirstShownItemIndex,
+          newColumnsCount = _ref2.newColumnsCount;
+      var columnsCount = this.getColumnsCount();
+      var verticalSpacing = this.getVerticalSpacing();
+      this._includesBeforeResizeInState = true;
+
+      var _this$getState2 = this.getState(),
+          prevBeforeResize = _this$getState2.beforeResize,
+          itemHeights = _this$getState2.itemHeights;
+
+      var prevBeforeResizeItemsCount = prevBeforeResize ? prevBeforeResize.itemHeights.length : 0; // If there already are "before resize" values in `state`
+      // then it means that those should be merged with the new ones.
+      //
+      // `beforeResize.itemHeights` could be empty in an edge case
+      // when there's a pending state update that sets `beforeResize`
+      // to `undefined`, and in that case empty `beforeResize.itemHeights`
+      // signals about that type of a situation.
+      //
+
+      if (prevBeforeResizeItemsCount > 0) {
+        // Because the "previous" before resize values might have been captured
+        // for a window width corresponding to a layout with a different columns count
+        // and different vertical spacing, re-calculate those item heights as if
+        // they corresponded to the current columns count and current vertical spacing,
+        // since "previous" and "new" before resize item heights are gonna be merged.
+        if (prevBeforeResize.columnsCount !== columnsCount || prevBeforeResize.verticalSpacing !== verticalSpacing) {
+          var prevBeforeResizeBeforeItemsHeight = 0;
+          var prevBeforeResizeItemRowsCount = Math.ceil(prevBeforeResizeItemsCount / prevBeforeResize.columnsCount);
+          var rowIndex = 0;
+
+          while (rowIndex < prevBeforeResizeItemRowsCount) {
+            // Since all "before resize" item heights are equal within a row,
+            // the height of the first "before resize" item in a row is that row's height.
+            var rowHeight = prevBeforeResize.itemHeights[rowIndex * prevBeforeResize.columnsCount];
+            prevBeforeResizeBeforeItemsHeight += rowHeight;
+            prevBeforeResizeBeforeItemsHeight += prevBeforeResize.verticalSpacing;
+            rowIndex++;
+          }
+
+          var newBeforeResizeAdditionalBeforeItemsHeight = 0;
+          var i = firstShownItemIndex;
+
+          while (i < newFirstShownItemIndex) {
+            var _rowHeight2 = 0;
+            var k = 0;
+
+            while (k < columnsCount && i < newFirstShownItemIndex) {
+              _rowHeight2 = Math.max(_rowHeight2, itemHeights[i]);
+              k++;
+              i++;
+            }
+
+            newBeforeResizeAdditionalBeforeItemsHeight += _rowHeight2;
+            newBeforeResizeAdditionalBeforeItemsHeight += verticalSpacing;
+          }
+
+          var newBeforeResizeBeforeItemsHeight = prevBeforeResizeBeforeItemsHeight + newBeforeResizeAdditionalBeforeItemsHeight;
+          var newBeforeResizeBeforeItemRowsCount = Math.ceil(newFirstShownItemIndex / columnsCount);
+          return new Array(newFirstShownItemIndex).fill( // Re-calculate "before resize" item heights so that "previous" and "new" ones
+          // correspond to the same (new) columns count.
+          // Also don't occasionally set item heights to `< 0`.
+          Math.max(0, newBeforeResizeBeforeItemsHeight / newBeforeResizeBeforeItemRowsCount - verticalSpacing));
+        } else {
+          // Add new item heights to the previously snapshotted ones.
+          return prevBeforeResize.itemHeights.concat(equalizeItemHeights(itemHeights, newFirstShownItemIndex, columnsCount).slice(prevBeforeResize.itemHeights.length));
+        }
+      } else {
+        return equalizeItemHeights(itemHeights, newFirstShownItemIndex, columnsCount);
+      }
+    }
+  }, {
+    key: "shouldIncludeBeforeResizeValuesInState",
+    value: function shouldIncludeBeforeResizeValuesInState() {
+      return this._includesBeforeResizeInState;
+    }
+  }]);
+
+  return BeforeResize;
+}(); // Equalizes all item heights within a given row, for each row.
+//
+// The reason is that `beforeResize.itemHeights` is not necessarily divisible by
+// `beforeResize.columnsCount`, which would result in varying last row height
+// as items get removed from `beforeResize.itemHeights` as the user scrolls up.
+//
+// By equalizing all item heights within a given row, for each row, such "jumping"
+// last "before resize" row height is prevented when the user scrolls up.
+//
+
+
+exports["default"] = BeforeResize;
+
+function equalizeItemHeights(itemHeights, maxItemsCount, columnsCount) {
+  itemHeights = itemHeights.slice(0, Math.ceil(maxItemsCount / columnsCount) * columnsCount);
+  var rowIndex = 0;
+
+  while (rowIndex * columnsCount < maxItemsCount) {
+    // Calculate row height.
+    var rowHeight = 0;
+    var k = 0;
+
+    while (k < columnsCount) {
+      rowHeight = Math.max(rowHeight, itemHeights[rowIndex * columnsCount + k]);
+      k++;
+    } // Equalize all item heights within the row.
+
+
+    k = 0;
+
+    while (k < columnsCount) {
+      itemHeights[rowIndex * columnsCount + k] = rowHeight;
+      k++;
+    } // Proceed with the next row.
+
+
+    rowIndex++;
+  }
+
+  return itemHeights.slice(0, maxItemsCount);
+}
+
+function cleanUpBeforeResizeState(state) {
+  if (state.beforeResize) {
+    if (state.beforeResize.itemHeights.length === 0) {
+      state.beforeResize = undefined;
+    }
+  }
+
+  return state;
+}
+//# sourceMappingURL=BeforeResize.js.map

package/commonjs/BeforeResize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeforeResize.js","names":["BeforeResize","getState","getVerticalSpacing","getColumnsCount","state","_includesBeforeResizeInState","Boolean","beforeResize","firstShownItemIndex","lastShownItemIndex","itemHeights","length","log","newlyShownItemRowsHeight","prevFirstReMeasuredItemsRowIndex","Math","floor","newlyShownItemsToIndex","min","i","rowHeight","columnIndex","itemHeight","undefined","getAverageItemHeight","max","cleanedUpBeforeResizeItemRowsHeight","maxParticipatingBeforeResizeItemsCount","participatingBeforeResizeItemRowsCount","ceil","columnsCount","firstCleanedUpBeforeResizeItemsRowIndex","k","verticalSpacing","firstDroppedBeforeResizeItemIndex","lastDroppedBeforeResizeItemIndex","slice","splice","scrollBy","newFirstShownItemIndex","newColumnsCount","prevBeforeResize","prevBeforeResizeItemsCount","prevBeforeResizeBeforeItemsHeight","prevBeforeResizeItemRowsCount","rowIndex","newBeforeResizeAdditionalBeforeItemsHeight","newBeforeResizeBeforeItemsHeight","newBeforeResizeBeforeItemRowsCount","Array","fill","concat","equalizeItemHeights","maxItemsCount","cleanUpBeforeResizeState"],"sources":["../source/BeforeResize.js"],"sourcesContent":["import log from './utility/debug.js'\r\n\r\nexport default class BeforeResize {\r\n\tconstructor({\r\n\t\tgetState,\r\n\t\tgetVerticalSpacing,\r\n\t\tgetColumnsCount\r\n\t}) {\r\n\t\tthis.getState = getState\r\n\t\tthis.getVerticalSpacing = getVerticalSpacing\r\n\t\tthis.getColumnsCount = getColumnsCount\r\n\t}\r\n\r\n\tinitializeFromState(state) {\r\n\t\tthis._includesBeforeResizeInState = Boolean(state.beforeResize)\r\n\t}\r\n\r\n\t// Cleans up \"before resize\" item heights and adjusts the scroll position accordingly.\r\n\t//\r\n\t// Hypothetically, it could also wait for the user to stop scrolling and only then\r\n\t// adjust the scroll position. The rationale is that if `window.scrollTo()` is called\r\n\t// while the user is scrolling, the user would occasionally experience \"lost\" mouse wheel\r\n\t// events when scrolling with a mouse wheel.\r\n\t//\r\n\t// Seems like Twitter's website waits for the user to stop scrolling before applying\r\n\t// the scroll position correction after a window resize. This library could do that too,\r\n\t// but that would require rewriting \"before items height\" top padding calculation\r\n\t// so that it doesn't re-calculate it on every re-render and instead does so incrementally,\r\n\t// and then, when the user stops, it re-calculates it from scratch removing the error\r\n\t// and adjusting the scroll position accordingly so that there's no \"jump of content\".\r\n\t//\r\n\t// But, seems like it works fine as it is and there's no need to rewrite anything.\r\n\t//\r\n\tcleanUpBeforeResizeItemHeights() {\r\n\t\tconst {\r\n\t\t\tfirstShownItemIndex,\r\n\t\t\tlastShownItemIndex,\r\n\t\t\titemHeights,\r\n\t\t\tbeforeResize\r\n\t\t} = this.getState()\r\n\r\n\t\t// If there're \"before resize\" properties in `state`\r\n\t\t// then it means that the corresponding items are waiting to be\r\n\t\t// re-measured after container resize. Since the resize,\r\n\t\t// some of those non-re-measured items might have just been measured,\r\n\t\t// so see if that's true, and if it is, remove those now-obsolete\r\n\t\t// \"before resize\" item heights and ajust the scroll position\r\n\t\t// so that there's no \"content jumping\".\r\n\r\n\t\tif (beforeResize) {\r\n\t\t\t// If the user has scrolled up to reveal a previously hidden item\r\n\t\t\t// that has not yet been re-measured after a previous resize.\r\n\t\t\tif (firstShownItemIndex < beforeResize.itemHeights.length) {\r\n\t\t\t\tlog('~ Clean up \"before resize\" item heights and correct scroll position ~')\r\n\r\n\t\t\t\t// Some of the \"before\" items have been un-hidden and re-measured.\r\n\t\t\t\t// Un-hiding those items would result in a \"jump of content\"\r\n\t\t\t\t// because \"before resize\" heights of those un-hidden items\r\n\t\t\t\t// could (and most likely will) be different from the current ones,\r\n\t\t\t\t// or because \"before resize\" columns count is different from\r\n\t\t\t\t// the current one.\r\n\t\t\t\t// To prevent a \"jump of content\", calculate the scroll position\r\n\t\t\t\t// difference and adjust the scroll position.\r\n\r\n\t\t\t\t// The height of the item rows that have transitioned\r\n\t\t\t\t// from hidden to shown.\r\n\t\t\t\tlet newlyShownItemRowsHeight = 0\r\n\r\n\t\t\t\t// Some of the `itemHeights` between the current `firstShownItemIndex` and\r\n\t\t\t\t// the previous `firstShownItemIndex` could stay `undefined` if the user\r\n\t\t\t\t// scrolled \"abruptly\": for example, by using a `window.scrollTo()` call.\r\n\t\t\t\t// In that case, the items below the visible ones won't be rendered and measured.\r\n\t\t\t\t// In such case, limit the items being iterated over to the current `lastShownItemIndex`\r\n\t\t\t\t// rather than the previous `firstShownItemIndex`.\r\n\t\t\t\tconst prevFirstReMeasuredItemsRowIndex = Math.floor(beforeResize.itemHeights.length / this.getColumnsCount())\r\n\t\t\t\tconst newlyShownItemsToIndex = Math.min(\r\n\t\t\t\t\tprevFirstReMeasuredItemsRowIndex * this.getColumnsCount() - 1,\r\n\t\t\t\t\tlastShownItemIndex\r\n\t\t\t\t)\r\n\r\n\t\t\t\tlet i = firstShownItemIndex\r\n\t\t\t\twhile (i <= newlyShownItemsToIndex) {\r\n\t\t\t\t\t// Calculate newly shown row height.\r\n\t\t\t\t\tlet rowHeight = 0\r\n\t\t\t\t\tlet columnIndex = 0\r\n\t\t\t\t\twhile (columnIndex < this.getColumnsCount() && i <= newlyShownItemsToIndex) {\r\n\t\t\t\t\t\tlet itemHeight = itemHeights[i]\r\n\t\t\t\t\t\tif (itemHeight === undefined) {\r\n\t\t\t\t\t\t\t// `itemHeight` can only be `undefined` when not `beforeResize`.\r\n\t\t\t\t\t\t\t// Use the current \"average item height\" as a substitute.\r\n\t\t\t\t\t\t\titemHeight = this.getAverageItemHeight()\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\trowHeight = Math.max(rowHeight, itemHeight)\r\n\t\t\t\t\t\ti++\r\n\t\t\t\t\t\tcolumnIndex++\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// Append to the total \"newly shown item rows height\".\r\n\t\t\t\t\tnewlyShownItemRowsHeight += rowHeight\r\n\t\t\t\t\tnewlyShownItemRowsHeight += this.getVerticalSpacing()\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// The height of the \"before resize\" item rows\r\n\t\t\t\t// that will be \"cleaned up\" in this function call.\r\n\t\t\t\tlet cleanedUpBeforeResizeItemRowsHeight = 0\r\n\r\n\t\t\t\t// Some of the `beforeResize` item rows might have been skipped if the user\r\n\t\t\t\t// scrolled up \"abruptly\": for example, by using a `window.scrollTo()` call.\r\n\t\t\t\t// In that case, the \"before resize\" items below the bottom border of the screen\r\n\t\t\t\t// shouldn't be accounted for when calculating the scrollbar adjustment shift\r\n\t\t\t\t// because items after `lastShownItemIndex` aren't participating in the calculation\r\n\t\t\t\t// of `newlyShownItemRowsHeight`.\r\n\t\t\t\tconst maxParticipatingBeforeResizeItemsCount = Math.min(beforeResize.itemHeights.length, lastShownItemIndex + 1)\r\n\t\t\t\tconst participatingBeforeResizeItemRowsCount = Math.ceil(maxParticipatingBeforeResizeItemsCount / beforeResize.columnsCount)\r\n\r\n\t\t\t\tconst firstCleanedUpBeforeResizeItemsRowIndex = firstShownItemIndex === 0\r\n\t\t\t\t\t? 0\r\n\t\t\t\t\t: Math.floor((firstShownItemIndex - 1) / beforeResize.columnsCount) + 1\r\n\r\n\t\t\t\tlet k = firstCleanedUpBeforeResizeItemsRowIndex\r\n\t\t\t\twhile (k < participatingBeforeResizeItemRowsCount) {\r\n\t\t\t\t\tconst rowHeight = beforeResize.itemHeights[k * beforeResize.columnsCount]\r\n\t\t\t\t\tcleanedUpBeforeResizeItemRowsHeight += rowHeight\r\n\t\t\t\t\tcleanedUpBeforeResizeItemRowsHeight += beforeResize.verticalSpacing\r\n\t\t\t\t\tk++\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Schedule an asynchronous `this.updateState()` call that will update\r\n\t\t\t\t// `beforeResize` property of `state`. Ideally, it should be updated\r\n\t\t\t\t// immediately, but since `this.updateState()` calls are asynchronous,\r\n\t\t\t\t// the code updates just the underlying `beforeResize.itemHeights`\r\n\t\t\t\t// array immediately instead, which is still a hack but still a lesser one.\r\n\t\t\t\tif (firstShownItemIndex === 0) {\r\n\t\t\t\t\tlog('Drop all \"before resize\" item heights')\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconst firstDroppedBeforeResizeItemIndex = firstShownItemIndex\r\n\t\t\t\t\tconst lastDroppedBeforeResizeItemIndex = beforeResize.itemHeights.length - 1\r\n\t\t\t\t\tif (firstDroppedBeforeResizeItemIndex === lastDroppedBeforeResizeItemIndex) {\r\n\t\t\t\t\t\tlog('For item index', firstDroppedBeforeResizeItemIndex, '— drop \"before resize\" height', beforeResize.itemHeights[firstDroppedBeforeResizeItemIndex], )\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tlog('For item indexes from', firstDroppedBeforeResizeItemIndex, 'to', lastDroppedBeforeResizeItemIndex, '— drop \"before resize\" heights', beforeResize.itemHeights.slice(firstDroppedBeforeResizeItemIndex))\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Immediately update `beforeResize.itemHeights`\r\n\t\t\t\t// so that the component isn't left in an inconsistent state\r\n\t\t\t\t// before a `this.updateState()` call below is applied.\r\n\t\t\t\tbeforeResize.itemHeights.splice(\r\n\t\t\t\t\tfirstShownItemIndex,\r\n\t\t\t\t\tbeforeResize.itemHeights.length - firstShownItemIndex\r\n\t\t\t\t)\r\n\r\n\t\t\t\t// Return the \"scroll by\" amount that would correct the scroll position.\r\n\t\t\t\t// Also return a state update.\r\n\t\t\t\treturn {\r\n\t\t\t\t\tscrollBy: newlyShownItemRowsHeight - cleanedUpBeforeResizeItemRowsHeight,\r\n\t\t\t\t\tbeforeResize: firstShownItemIndex === 0 ? undefined : {\r\n\t\t\t\t\t\t// Simply change the \"reference\" to `beforeResize` while leaving\r\n\t\t\t\t\t\t// its contents unchanged. That simply indicates that it has been updated:\r\n\t\t\t\t\t\t// `beforeResize.itemHeights` array length has been changed \"directly\".\r\n\t\t\t\t\t\t...beforeResize\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// Snapshots \"before resize\" values in order to preserve the currently\r\n\t// shown items' vertical position on screen so that there's no \"content jumping\".\r\n\t//\r\n\t// `newFirstShownItemIndex` is `> 0`.\r\n\t//\r\n\tsnapshotBeforeResizeItemHeights({\r\n\t\tfirstShownItemIndex,\r\n\t\tnewFirstShownItemIndex,\r\n\t\tnewColumnsCount\r\n\t}) {\r\n\t\tconst columnsCount = this.getColumnsCount()\r\n\t\tconst verticalSpacing = this.getVerticalSpacing()\r\n\r\n\t\tthis._includesBeforeResizeInState = true\r\n\r\n\t\tconst {\r\n\t\t\tbeforeResize: prevBeforeResize,\r\n\t\t\titemHeights\r\n\t\t} = this.getState()\r\n\r\n\t\tconst prevBeforeResizeItemsCount = prevBeforeResize\r\n\t\t\t? prevBeforeResize.itemHeights.length\r\n\t\t\t: 0\r\n\r\n\t\t// If there already are \"before resize\" values in `state`\r\n\t\t// then it means that those should be merged with the new ones.\r\n\t\t//\r\n\t\t// `beforeResize.itemHeights` could be empty in an edge case\r\n\t\t// when there's a pending state update that sets `beforeResize`\r\n\t\t// to `undefined`, and in that case empty `beforeResize.itemHeights`\r\n\t\t// signals about that type of a situation.\r\n\t\t//\r\n\t\tif (prevBeforeResizeItemsCount > 0) {\r\n\t\t\t// Because the \"previous\" before resize values might have been captured\r\n\t\t\t// for a window width corresponding to a layout with a different columns count\r\n\t\t\t// and different vertical spacing, re-calculate those item heights as if\r\n\t\t\t// they corresponded to the current columns count and current vertical spacing,\r\n\t\t\t// since \"previous\" and \"new\" before resize item heights are gonna be merged.\r\n\t\t\tif (\r\n\t\t\t\tprevBeforeResize.columnsCount !== columnsCount ||\r\n\t\t\t\tprevBeforeResize.verticalSpacing !== verticalSpacing\r\n\t\t\t) {\r\n\t\t\t\tlet prevBeforeResizeBeforeItemsHeight = 0\r\n\r\n\t\t\t\tconst prevBeforeResizeItemRowsCount = Math.ceil(prevBeforeResizeItemsCount / prevBeforeResize.columnsCount)\r\n\t\t\t\tlet rowIndex = 0\r\n\t\t\t\twhile (rowIndex < prevBeforeResizeItemRowsCount) {\r\n\t\t\t\t\t// Since all \"before resize\" item heights are equal within a row,\r\n\t\t\t\t\t// the height of the first \"before resize\" item in a row is that row's height.\r\n\t\t\t\t\tconst rowHeight = prevBeforeResize.itemHeights[rowIndex * prevBeforeResize.columnsCount]\r\n\t\t\t\t\tprevBeforeResizeBeforeItemsHeight += rowHeight\r\n\t\t\t\t\tprevBeforeResizeBeforeItemsHeight += prevBeforeResize.verticalSpacing\r\n\t\t\t\t\trowIndex++\r\n\t\t\t\t}\r\n\r\n\t\t\t\tlet newBeforeResizeAdditionalBeforeItemsHeight = 0\r\n\t\t\t\tlet i = firstShownItemIndex\r\n\t\t\t\twhile (i < newFirstShownItemIndex) {\r\n\t\t\t\t\tlet rowHeight = 0\r\n\t\t\t\t\tlet k = 0\r\n\t\t\t\t\twhile (k < columnsCount && i < newFirstShownItemIndex) {\r\n\t\t\t\t\t\trowHeight = Math.max(rowHeight, itemHeights[i])\r\n\t\t\t\t\t\tk++\r\n\t\t\t\t\t\ti++\r\n\t\t\t\t\t}\r\n\t\t\t\t\tnewBeforeResizeAdditionalBeforeItemsHeight += rowHeight\r\n\t\t\t\t\tnewBeforeResizeAdditionalBeforeItemsHeight += verticalSpacing\r\n\t\t\t\t}\r\n\r\n\t\t\t\tconst newBeforeResizeBeforeItemsHeight = prevBeforeResizeBeforeItemsHeight + newBeforeResizeAdditionalBeforeItemsHeight\r\n\t\t\t\tconst newBeforeResizeBeforeItemRowsCount = Math.ceil(newFirstShownItemIndex / columnsCount)\r\n\r\n\t\t\t\treturn new Array(newFirstShownItemIndex).fill(\r\n\t\t\t\t\t// Re-calculate \"before resize\" item heights so that \"previous\" and \"new\" ones\r\n\t\t\t\t\t// correspond to the same (new) columns count.\r\n\t\t\t\t\t// Also don't occasionally set item heights to `< 0`.\r\n\t\t\t\t\tMath.max(0, newBeforeResizeBeforeItemsHeight / newBeforeResizeBeforeItemRowsCount - verticalSpacing)\r\n\t\t\t\t)\r\n\t\t\t} else {\r\n\t\t\t\t// Add new item heights to the previously snapshotted ones.\r\n\t\t\t\treturn prevBeforeResize.itemHeights.concat(\r\n\t\t\t\t\tequalizeItemHeights(\r\n\t\t\t\t\t\titemHeights,\r\n\t\t\t\t\t\tnewFirstShownItemIndex,\r\n\t\t\t\t\t\tcolumnsCount\r\n\t\t\t\t\t).slice(prevBeforeResize.itemHeights.length)\r\n\t\t\t\t)\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\treturn equalizeItemHeights(\r\n\t\t\t\titemHeights,\r\n\t\t\t\tnewFirstShownItemIndex,\r\n\t\t\t\tcolumnsCount\r\n\t\t\t)\r\n\t\t}\r\n\t}\r\n\r\n\tshouldIncludeBeforeResizeValuesInState() {\r\n\t\treturn this._includesBeforeResizeInState\r\n\t}\r\n}\r\n\r\n// Equalizes all item heights within a given row, for each row.\r\n//\r\n// The reason is that `beforeResize.itemHeights` is not necessarily divisible by\r\n// `beforeResize.columnsCount`, which would result in varying last row height\r\n// as items get removed from `beforeResize.itemHeights` as the user scrolls up.\r\n//\r\n// By equalizing all item heights within a given row, for each row, such \"jumping\"\r\n// last \"before resize\" row height is prevented when the user scrolls up.\r\n//\r\nfunction equalizeItemHeights(itemHeights, maxItemsCount, columnsCount) {\r\n\titemHeights = itemHeights.slice(0, Math.ceil(maxItemsCount / columnsCount) * columnsCount)\r\n\r\n\tlet rowIndex = 0\r\n\twhile (rowIndex * columnsCount < maxItemsCount) {\r\n\t\t// Calculate row height.\r\n\t\tlet rowHeight = 0\r\n\t\tlet k = 0\r\n\t\twhile (k < columnsCount) {\r\n\t\t\trowHeight = Math.max(rowHeight, itemHeights[rowIndex * columnsCount + k])\r\n\t\t\tk++\r\n\t\t}\r\n\r\n\t\t// Equalize all item heights within the row.\r\n\t\tk = 0\r\n\t\twhile (k < columnsCount) {\r\n\t\t\titemHeights[rowIndex * columnsCount + k] = rowHeight\r\n\t\t\tk++\r\n\t\t}\r\n\r\n\t\t// Proceed with the next row.\r\n\t\trowIndex++\r\n\t}\r\n\r\n\treturn itemHeights.slice(0, maxItemsCount)\r\n}\r\n\r\nexport function cleanUpBeforeResizeState(state) {\r\n\tif (state.beforeResize) {\r\n\t\tif (state.beforeResize.itemHeights.length === 0) {\r\n\t\t\tstate.beforeResize = undefined\r\n\t\t}\r\n\t}\r\n\treturn state\r\n}"],"mappings":"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"}

package/commonjs/DOM/Engine.js

@@ -0,0 +1,46 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _ItemsContainer = _interopRequireDefault(require("./ItemsContainer.js"));
+
+var _ScrollableContainer = _interopRequireWildcard(require("./ScrollableContainer.js"));
+
+var _ListTopOffsetWatcher = _interopRequireDefault(require("./ListTopOffsetWatcher.js"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var _default = {
+  createItemsContainer: function createItemsContainer(getItemsContainerElement) {
+    return new _ItemsContainer["default"](getItemsContainerElement);
+  },
+  // Creates a `scrollableContainer`.
+  // On client side, `scrollableContainer` is always created.
+  // On server side, `scrollableContainer` is not created (and not used).
+  createScrollableContainer: function createScrollableContainer(getScrollableContainerElement, getItemsContainerElement) {
+    if (getScrollableContainerElement) {
+      return new _ScrollableContainer["default"](getScrollableContainerElement, getItemsContainerElement);
+    } else if (typeof window !== 'undefined') {
+      return new _ScrollableContainer.ScrollableWindowContainer(getItemsContainerElement);
+    }
+  },
+  watchListTopOffset: function watchListTopOffset(_ref) {
+    var getListTopOffset = _ref.getListTopOffset,
+        onListTopOffsetChange = _ref.onListTopOffsetChange;
+    return new _ListTopOffsetWatcher["default"]({
+      getListTopOffset: getListTopOffset,
+      onListTopOffsetChange: onListTopOffsetChange
+    });
+  }
+};
+exports["default"] = _default;
+//# sourceMappingURL=Engine.js.map

package/commonjs/DOM/Engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Engine.js","names":["createItemsContainer","getItemsContainerElement","ItemsContainer","createScrollableContainer","getScrollableContainerElement","ScrollableContainer","window","ScrollableWindowContainer","watchListTopOffset","getListTopOffset","onListTopOffsetChange","ListTopOffsetWatcher"],"sources":["../../source/DOM/Engine.js"],"sourcesContent":["import ItemsContainer from './ItemsContainer.js'\r\nimport ScrollableContainer, { ScrollableWindowContainer } from './ScrollableContainer.js'\r\nimport ListTopOffsetWatcher from './ListTopOffsetWatcher.js'\r\n\r\nexport default {\r\n\tcreateItemsContainer(getItemsContainerElement) {\r\n\t\treturn new ItemsContainer(getItemsContainerElement)\r\n\t},\r\n\r\n\t// Creates a `scrollableContainer`.\r\n\t// On client side, `scrollableContainer` is always created.\r\n\t// On server side, `scrollableContainer` is not created (and not used).\r\n\tcreateScrollableContainer(getScrollableContainerElement, getItemsContainerElement) {\r\n\t\tif (getScrollableContainerElement) {\r\n\t\t\treturn new ScrollableContainer(getScrollableContainerElement, getItemsContainerElement)\r\n\t\t} else if (typeof window !== 'undefined') {\r\n\t\t\treturn new ScrollableWindowContainer(getItemsContainerElement)\r\n\t\t}\r\n\t},\r\n\r\n\twatchListTopOffset({\r\n\t\tgetListTopOffset,\r\n\t\tonListTopOffsetChange\r\n\t}) {\r\n\t\treturn new ListTopOffsetWatcher({\r\n\t\t\tgetListTopOffset,\r\n\t\t\tonListTopOffsetChange\r\n\t\t})\r\n\t}\r\n}"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;;;;;;;eAEe;EACdA,oBADc,gCACOC,wBADP,EACiC;IAC9C,OAAO,IAAIC,0BAAJ,CAAmBD,wBAAnB,CAAP;EACA,CAHa;EAKd;EACA;EACA;EACAE,yBARc,qCAQYC,6BARZ,EAQ2CH,wBAR3C,EAQqE;IAClF,IAAIG,6BAAJ,EAAmC;MAClC,OAAO,IAAIC,+BAAJ,CAAwBD,6BAAxB,EAAuDH,wBAAvD,CAAP;IACA,CAFD,MAEO,IAAI,OAAOK,MAAP,KAAkB,WAAtB,EAAmC;MACzC,OAAO,IAAIC,8CAAJ,CAA8BN,wBAA9B,CAAP;IACA;EACD,CAda;EAgBdO,kBAhBc,oCAmBX;IAAA,IAFFC,gBAEE,QAFFA,gBAEE;IAAA,IADFC,qBACE,QADFA,qBACE;IACF,OAAO,IAAIC,gCAAJ,CAAyB;MAC/BF,gBAAgB,EAAhBA,gBAD+B;MAE/BC,qBAAqB,EAArBA;IAF+B,CAAzB,CAAP;EAIA;AAxBa,C"}

package/commonjs/DOM/ItemsContainer.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+var ItemsContainer = /*#__PURE__*/function () {
+  /**
+   * Constructs a new "container" from an element.
+   * @param {function} getElement
+   */
+  function ItemsContainer(getElement) {
+    _classCallCheck(this, ItemsContainer);
+
+    this.getElement = getElement;
+  }
+  /**
+   * Returns an item element's "top offset", relative to the items `container`'s top edge.
+   * @param  {number} renderedElementIndex — An index of an item relative to the "first shown item index". For example, if the list is showing items from index 8 to index 12 then `renderedElementIndex = 0` would mean the item at index `8`.
+   * @return {number}
+   */
+
+
+  _createClass(ItemsContainer, [{
+    key: "getNthRenderedItemTopOffset",
+    value: function getNthRenderedItemTopOffset(renderedElementIndex) {
+      return this.getElement().childNodes[renderedElementIndex].getBoundingClientRect().top - this.getElement().getBoundingClientRect().top;
+    }
+    /**
+     * Returns an item element's height.
+     * @param  {number} renderedElementIndex — An index of an item relative to the "first shown item index". For example, if the list is showing items from index 8 to index 12 then `renderedElementIndex = 0` would mean the item at index `8`.
+     * @return {number}
+     */
+
+  }, {
+    key: "getNthRenderedItemHeight",
+    value: function getNthRenderedItemHeight(renderedElementIndex) {
+      // `offsetHeight` is not precise enough (doesn't return fractional pixels).
+      // return this.getElement().childNodes[renderedElementIndex].offsetHeight
+      return this.getElement().childNodes[renderedElementIndex].getBoundingClientRect().height;
+    }
+    /**
+     * Returns items container height.
+     * @return {number}
+     */
+
+  }, {
+    key: "getHeight",
+    value: function getHeight() {
+      // `offsetHeight` is not precise enough (doesn't return fractional pixels).
+      // return this.getElement().offsetHeight
+      return this.getElement().getBoundingClientRect().height;
+    }
+    /**
+     * Removes all item elements of an items container.
+     */
+
+  }, {
+    key: "clear",
+    value: function clear() {
+      while (this.getElement().firstChild) {
+        this.getElement().removeChild(this.getElement().firstChild);
+      }
+    }
+  }]);
+
+  return ItemsContainer;
+}();
+
+exports["default"] = ItemsContainer;
+//# sourceMappingURL=ItemsContainer.js.map

package/commonjs/DOM/ItemsContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ItemsContainer.js","names":["ItemsContainer","getElement","renderedElementIndex","childNodes","getBoundingClientRect","top","height","firstChild","removeChild"],"sources":["../../source/DOM/ItemsContainer.js"],"sourcesContent":["export default class ItemsContainer {\r\n\t/**\r\n\t * Constructs a new \"container\" from an element.\r\n\t * @param {function} getElement\r\n\t */\r\n\tconstructor(getElement) {\r\n\t\tthis.getElement = getElement\r\n\t}\r\n\r\n\t/**\r\n\t * Returns an item element's \"top offset\", relative to the items `container`'s top edge.\r\n\t * @param  {number} renderedElementIndex — An index of an item relative to the \"first shown item index\". For example, if the list is showing items from index 8 to index 12 then `renderedElementIndex = 0` would mean the item at index `8`.\r\n\t * @return {number}\r\n\t */\r\n\tgetNthRenderedItemTopOffset(renderedElementIndex) {\r\n\t\treturn this.getElement().childNodes[renderedElementIndex].getBoundingClientRect().top - this.getElement().getBoundingClientRect().top\r\n\t}\r\n\r\n\t/**\r\n\t * Returns an item element's height.\r\n\t * @param  {number} renderedElementIndex — An index of an item relative to the \"first shown item index\". For example, if the list is showing items from index 8 to index 12 then `renderedElementIndex = 0` would mean the item at index `8`.\r\n\t * @return {number}\r\n\t */\r\n\tgetNthRenderedItemHeight(renderedElementIndex) {\r\n\t\t// `offsetHeight` is not precise enough (doesn't return fractional pixels).\r\n\t\t// return this.getElement().childNodes[renderedElementIndex].offsetHeight\r\n\t\treturn this.getElement().childNodes[renderedElementIndex].getBoundingClientRect().height\r\n\t}\r\n\r\n\t/**\r\n\t * Returns items container height.\r\n\t * @return {number}\r\n\t */\r\n\tgetHeight() {\r\n\t\t// `offsetHeight` is not precise enough (doesn't return fractional pixels).\r\n\t\t// return this.getElement().offsetHeight\r\n\t\treturn this.getElement().getBoundingClientRect().height\r\n\t}\r\n\r\n\t/**\r\n\t * Removes all item elements of an items container.\r\n\t */\r\n\tclear() {\r\n\t\twhile (this.getElement().firstChild) {\r\n\t\t\tthis.getElement().removeChild(this.getElement().firstChild)\r\n\t\t}\r\n\t}\r\n}"],"mappings":";;;;;;;;;;;;;IAAqBA,c;EACpB;AACD;AACA;AACA;EACC,wBAAYC,UAAZ,EAAwB;IAAA;;IACvB,KAAKA,UAAL,GAAkBA,UAAlB;EACA;EAED;AACD;AACA;AACA;AACA;;;;;WACC,qCAA4BC,oBAA5B,EAAkD;MACjD,OAAO,KAAKD,UAAL,GAAkBE,UAAlB,CAA6BD,oBAA7B,EAAmDE,qBAAnD,GAA2EC,GAA3E,GAAiF,KAAKJ,UAAL,GAAkBG,qBAAlB,GAA0CC,GAAlI;IACA;IAED;AACD;AACA;AACA;AACA;;;;WACC,kCAAyBH,oBAAzB,EAA+C;MAC9C;MACA;MACA,OAAO,KAAKD,UAAL,GAAkBE,UAAlB,CAA6BD,oBAA7B,EAAmDE,qBAAnD,GAA2EE,MAAlF;IACA;IAED;AACD;AACA;AACA;;;;WACC,qBAAY;MACX;MACA;MACA,OAAO,KAAKL,UAAL,GAAkBG,qBAAlB,GAA0CE,MAAjD;IACA;IAED;AACD;AACA;;;;WACC,iBAAQ;MACP,OAAO,KAAKL,UAAL,GAAkBM,UAAzB,EAAqC;QACpC,KAAKN,UAAL,GAAkBO,WAAlB,CAA8B,KAAKP,UAAL,GAAkBM,UAAhD;MACA;IACD"}