@digipair/skill-web-spectrum 0.89.0 → 0.91.0-0

package/flow.esm.js

@@ -1,1254 +0,0 @@
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */ function _class_call_check$2(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties$2(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 _create_class$2(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$2(Constructor, staticProps);
-    return Constructor;
-}
-var SizeCache = /*#__PURE__*/ function() {
-    function SizeCache(config) {
-        _class_call_check$2(this, SizeCache);
-        this._map = new Map();
-        this._roundAverageSize = false;
-        this.totalSize = 0;
-        if ((config === null || config === void 0 ? void 0 : config.roundAverageSize) === true) {
-            this._roundAverageSize = true;
-        }
-    }
-    _create_class$2(SizeCache, [
-        {
-            key: "set",
-            value: function set(index, value) {
-                var prev = this._map.get(index) || 0;
-                this._map.set(index, value);
-                this.totalSize += value - prev;
-            }
-        },
-        {
-            key: "averageSize",
-            get: function get() {
-                if (this._map.size > 0) {
-                    var average = this.totalSize / this._map.size;
-                    return this._roundAverageSize ? Math.round(average) : average;
-                }
-                return 0;
-            }
-        },
-        {
-            key: "getSize",
-            value: function getSize(index) {
-                return this._map.get(index);
-            }
-        },
-        {
-            key: "clear",
-            value: function clear() {
-                this._map.clear();
-                this.totalSize = 0;
-            }
-        }
-    ]);
-    return SizeCache;
-} 
-();
-
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */ function _class_call_check$1(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties$1(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 _create_class$1(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties$1(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property$1(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 dim1(direction) {
-    return direction === "horizontal" ? "width" : "height";
-}
-var BaseLayout = /*#__PURE__*/ function() {
-    function BaseLayout(hostSink, config) {
-        var _this = this;
-        _class_call_check$1(this, BaseLayout);
-        /**
-         * The last set viewport scroll position.
-         */ this._latestCoords = {
-            left: 0,
-            top: 0
-        };
-        /**
-         * Scrolling direction.
-         */ this._direction = null;
-        /**
-         * Dimensions of the viewport.
-         */ this._viewportSize = {
-            width: 0,
-            height: 0
-        };
-        this.totalScrollSize = {
-            width: 0,
-            height: 0
-        };
-        this.offsetWithinScroller = {
-            left: 0,
-            top: 0
-        };
-        /**
-         * Flag for debouncing asynchronous reflow requests.
-         */ this._pendingReflow = false;
-        this._pendingLayoutUpdate = false;
-        this._pin = null;
-        /**
-         * The index of the first item intersecting the viewport.
-         */ this._firstVisible = 0;
-        /**
-         * The index of the last item intersecting the viewport.
-         */ this._lastVisible = 0;
-        /**
-         * Pixel offset in the scroll direction of the first child.
-         */ this._physicalMin = 0;
-        /**
-         * Pixel offset in the scroll direction of the last child.
-         */ this._physicalMax = 0;
-        /**
-         * Index of the first child.
-         */ this._first = -1;
-        /**
-         * Index of the last child.
-         */ this._last = -1;
-        /**
-         * Length in the scrolling direction.
-         */ this._sizeDim = "height";
-        /**
-         * Length in the non-scrolling direction.
-         */ this._secondarySizeDim = "width";
-        /**
-         * Position in the scrolling direction.
-         */ this._positionDim = "top";
-        /**
-         * Position in the non-scrolling direction.
-         */ this._secondaryPositionDim = "left";
-        /**
-         * Current scroll offset in pixels.
-         */ this._scrollPosition = 0;
-        /**
-         * Difference between current scroll offset and scroll offset calculated due
-         * to a reflow.
-         */ this._scrollError = 0;
-        /**
-         * Total number of items that could possibly be displayed. Used to help
-         * calculate the scroll size.
-         */ this._items = [];
-        /**
-         * The total (estimated) length of all items in the scrolling direction.
-         */ this._scrollSize = 1;
-        /**
-         * Number of pixels beyond the viewport to still include
-         * in the active range of items.
-         */ // TODO (graynorton): Probably want to make this something we calculate based
-        // on viewport size, item size, other factors, possibly still with a dial of some kind
-        this._overhang = 1000;
-        this._hostSink = hostSink;
-        // Delay setting config so that subclasses do setup work first
-        Promise.resolve().then(function() {
-            return _this.config = config || _this._getDefaultConfig();
-        });
-    }
-    _create_class$1(BaseLayout, [
-        {
-            key: "_getDefaultConfig",
-            value: function _getDefaultConfig() {
-                return {
-                    direction: "vertical"
-                };
-            }
-        },
-        {
-            key: "config",
-            get: function get() {
-                return {
-                    direction: this.direction
-                };
-            },
-            set: function set(config) {
-                Object.assign(this, Object.assign({}, this._getDefaultConfig(), config));
-            }
-        },
-        {
-            key: "items",
-            get: /**
-     * Maximum index of children + 1, to help estimate total height of the scroll
-     * space.
-     */ function get() {
-                return this._items;
-            },
-            set: function set(items) {
-                this._setItems(items);
-            }
-        },
-        {
-            key: "_setItems",
-            value: function _setItems(items) {
-                if (items !== this._items) {
-                    this._items = items;
-                    this._scheduleReflow();
-                }
-            }
-        },
-        {
-            key: "direction",
-            get: /**
-     * Primary scrolling direction.
-     */ function get() {
-                return this._direction;
-            },
-            set: function set(dir) {
-                // Force it to be either horizontal or vertical.
-                dir = dir === "horizontal" ? dir : "vertical";
-                if (dir !== this._direction) {
-                    this._direction = dir;
-                    this._sizeDim = dir === "horizontal" ? "width" : "height";
-                    this._secondarySizeDim = dir === "horizontal" ? "height" : "width";
-                    this._positionDim = dir === "horizontal" ? "left" : "top";
-                    this._secondaryPositionDim = dir === "horizontal" ? "top" : "left";
-                    this._triggerReflow();
-                }
-            }
-        },
-        {
-            key: "viewportSize",
-            get: /**
-     * Height and width of the viewport.
-     */ function get() {
-                return this._viewportSize;
-            },
-            set: function set(dims) {
-                var _this = this, _viewDim1 = _this._viewDim1, _viewDim2 = _this._viewDim2;
-                Object.assign(this._viewportSize, dims);
-                if (_viewDim2 !== this._viewDim2) {
-                    // this._viewDim2Changed();
-                    this._scheduleLayoutUpdate();
-                } else if (_viewDim1 !== this._viewDim1) {
-                    this._checkThresholds();
-                }
-            }
-        },
-        {
-            key: "viewportScroll",
-            get: /**
-     * Scroll offset of the viewport.
-     */ function get() {
-                return this._latestCoords;
-            },
-            set: function set(coords) {
-                Object.assign(this._latestCoords, coords);
-                var oldPos = this._scrollPosition;
-                this._scrollPosition = this._latestCoords[this._positionDim];
-                var change = Math.abs(oldPos - this._scrollPosition);
-                if (change >= 1) {
-                    this._checkThresholds();
-                }
-            }
-        },
-        {
-            /**
-     * Perform a reflow if one has been scheduled.
-     */ key: "reflowIfNeeded",
-            value: function reflowIfNeeded() {
-                var force = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
-                if (force || this._pendingReflow) {
-                    this._pendingReflow = false;
-                    this._reflow();
-                }
-            }
-        },
-        {
-            key: "pin",
-            get: function get() {
-                if (this._pin !== null) {
-                    var _this__pin = this._pin, index = _this__pin.index, block = _this__pin.block;
-                    return {
-                        index: Math.max(0, Math.min(index, this.items.length - 1)),
-                        block: block
-                    };
-                }
-                return null;
-            },
-            set: function set(options) {
-                this._pin = options;
-                this._triggerReflow();
-            }
-        },
-        {
-            key: "_clampScrollPosition",
-            value: function _clampScrollPosition(val) {
-                return Math.max(-this.offsetWithinScroller[this._positionDim], Math.min(val, this.totalScrollSize[dim1(this.direction)] - this._viewDim1));
-            }
-        },
-        {
-            key: "unpin",
-            value: function unpin() {
-                if (this._pin !== null) {
-                    this._sendUnpinnedMessage();
-                    this._pin = null;
-                }
-            }
-        },
-        {
-            key: "_updateLayout",
-            value: function _updateLayout() {
-            // Override
-            }
-        },
-        {
-            key: "_viewDim1",
-            get: // protected _viewDim2Changed(): void {
-            //   this._scheduleLayoutUpdate();
-            // }
-            /**
-     * The height or width of the viewport, whichever corresponds to the scrolling direction.
-     */ function get() {
-                return this._viewportSize[this._sizeDim];
-            }
-        },
-        {
-            key: "_viewDim2",
-            get: /**
-     * The height or width of the viewport, whichever does NOT correspond to the scrolling direction.
-     */ function get() {
-                return this._viewportSize[this._secondarySizeDim];
-            }
-        },
-        {
-            key: "_scheduleReflow",
-            value: function _scheduleReflow() {
-                this._pendingReflow = true;
-            }
-        },
-        {
-            key: "_scheduleLayoutUpdate",
-            value: function _scheduleLayoutUpdate() {
-                this._pendingLayoutUpdate = true;
-                this._scheduleReflow();
-            }
-        },
-        {
-            // For triggering a reflow based on incoming changes to
-            // the layout config.
-            key: "_triggerReflow",
-            value: function _triggerReflow() {
-                var _this = this;
-                this._scheduleLayoutUpdate();
-                // TODO graynorton@: reflowIfNeeded() isn't really supposed
-                // to be called internally. Address in larger cleanup
-                // of virtualizer / layout interaction pattern.
-                // this.reflowIfNeeded(true);
-                Promise.resolve().then(function() {
-                    return _this.reflowIfNeeded();
-                });
-            }
-        },
-        {
-            key: "_reflow",
-            value: function _reflow() {
-                if (this._pendingLayoutUpdate) {
-                    this._updateLayout();
-                    this._pendingLayoutUpdate = false;
-                }
-                this._updateScrollSize();
-                this._setPositionFromPin();
-                this._getActiveItems();
-                this._updateVisibleIndices();
-                this._sendStateChangedMessage();
-            }
-        },
-        {
-            /**
-     * If we are supposed to be pinned to a particular
-     * item or set of coordinates, we set `_scrollPosition`
-     * accordingly and adjust `_scrollError` as needed
-     * so that the virtualizer can keep the scroll
-     * position in the DOM in sync
-     */ key: "_setPositionFromPin",
-            value: function _setPositionFromPin() {
-                if (this.pin !== null) {
-                    var lastScrollPosition = this._scrollPosition;
-                    var _this_pin = this.pin, index = _this_pin.index, block = _this_pin.block;
-                    this._scrollPosition = this._calculateScrollIntoViewPosition({
-                        index: index,
-                        block: block || "start"
-                    }) - this.offsetWithinScroller[this._positionDim];
-                    this._scrollError = lastScrollPosition - this._scrollPosition;
-                }
-            }
-        },
-        {
-            /**
-     * Calculate the coordinates to scroll to, given
-     * a request to scroll to the element at a specific
-     * index.
-     *
-     * Supports the same positioning options (`start`,
-     * `center`, `end`, `nearest`) as the standard
-     * `Element.scrollIntoView()` method, but currently
-     * only considers the provided value in the `block`
-     * dimension, since we don't yet have any layouts
-     * that support virtualization in two dimensions.
-     */ key: "_calculateScrollIntoViewPosition",
-            value: function _calculateScrollIntoViewPosition(options) {
-                var block = options.block;
-                var index = Math.min(this.items.length, Math.max(0, options.index));
-                var itemStartPosition = this._getItemPosition(index)[this._positionDim];
-                var scrollPosition = itemStartPosition;
-                if (block !== "start") {
-                    var itemSize = this._getItemSize(index)[this._sizeDim];
-                    if (block === "center") {
-                        scrollPosition = itemStartPosition - 0.5 * this._viewDim1 + 0.5 * itemSize;
-                    } else {
-                        var itemEndPosition = itemStartPosition - this._viewDim1 + itemSize;
-                        if (block === "end") {
-                            scrollPosition = itemEndPosition;
-                        } else {
-                            // block === 'nearest'
-                            var currentScrollPosition = this._scrollPosition;
-                            scrollPosition = Math.abs(currentScrollPosition - itemStartPosition) < Math.abs(currentScrollPosition - itemEndPosition) ? itemStartPosition : itemEndPosition;
-                        }
-                    }
-                }
-                scrollPosition += this.offsetWithinScroller[this._positionDim];
-                return this._clampScrollPosition(scrollPosition);
-            }
-        },
-        {
-            key: "getScrollIntoViewCoordinates",
-            value: function getScrollIntoViewCoordinates(options) {
-                return _define_property$1({}, this._positionDim, this._calculateScrollIntoViewPosition(options));
-            }
-        },
-        {
-            key: "_sendUnpinnedMessage",
-            value: function _sendUnpinnedMessage() {
-                this._hostSink({
-                    type: "unpinned"
-                });
-            }
-        },
-        {
-            key: "_sendVisibilityChangedMessage",
-            value: function _sendVisibilityChangedMessage() {
-                this._hostSink({
-                    type: "visibilityChanged",
-                    firstVisible: this._firstVisible,
-                    lastVisible: this._lastVisible
-                });
-            }
-        },
-        {
-            key: "_sendStateChangedMessage",
-            value: function _sendStateChangedMessage() {
-                var childPositions = new Map();
-                if (this._first !== -1 && this._last !== -1) {
-                    for(var idx = this._first; idx <= this._last; idx++){
-                        childPositions.set(idx, this._getItemPosition(idx));
-                    }
-                }
-                var _obj;
-                var message = {
-                    type: "stateChanged",
-                    scrollSize: (_obj = {}, _define_property$1(_obj, this._sizeDim, this._scrollSize), _define_property$1(_obj, this._secondarySizeDim, null), _obj),
-                    range: {
-                        first: this._first,
-                        last: this._last,
-                        firstVisible: this._firstVisible,
-                        lastVisible: this._lastVisible
-                    },
-                    childPositions: childPositions
-                };
-                if (this._scrollError) {
-                    var _obj1;
-                    message.scrollError = (_obj1 = {}, _define_property$1(_obj1, this._positionDim, this._scrollError), _define_property$1(_obj1, this._secondaryPositionDim, 0), _obj1);
-                    this._scrollError = 0;
-                }
-                this._hostSink(message);
-            }
-        },
-        {
-            key: "_num",
-            get: /**
-     * Number of items to display.
-     */ function get() {
-                if (this._first === -1 || this._last === -1) {
-                    return 0;
-                }
-                return this._last - this._first + 1;
-            }
-        },
-        {
-            key: "_checkThresholds",
-            value: function _checkThresholds() {
-                if (this._viewDim1 === 0 && this._num > 0 || this._pin !== null) {
-                    this._scheduleReflow();
-                } else {
-                    var min = Math.max(0, this._scrollPosition - this._overhang);
-                    var max = Math.min(this._scrollSize, this._scrollPosition + this._viewDim1 + this._overhang);
-                    if (this._physicalMin > min || this._physicalMax < max) {
-                        this._scheduleReflow();
-                    } else {
-                        this._updateVisibleIndices({
-                            emit: true
-                        });
-                    }
-                }
-            }
-        },
-        {
-            /**
-     * Find the indices of the first and last items to intersect the viewport.
-     * Emit a visibleindiceschange event when either index changes.
-     */ key: "_updateVisibleIndices",
-            value: function _updateVisibleIndices(options) {
-                if (this._first === -1 || this._last === -1) return;
-                var firstVisible = this._first;
-                while(firstVisible < this._last && Math.round(this._getItemPosition(firstVisible)[this._positionDim] + this._getItemSize(firstVisible)[this._sizeDim]) <= Math.round(this._scrollPosition)){
-                    firstVisible++;
-                }
-                var lastVisible = this._last;
-                while(lastVisible > this._first && Math.round(this._getItemPosition(lastVisible)[this._positionDim]) >= Math.round(this._scrollPosition + this._viewDim1)){
-                    lastVisible--;
-                }
-                if (firstVisible !== this._firstVisible || lastVisible !== this._lastVisible) {
-                    this._firstVisible = firstVisible;
-                    this._lastVisible = lastVisible;
-                    if (options && options.emit) {
-                        this._sendVisibilityChangedMessage();
-                    }
-                }
-            }
-        }
-    ]);
-    return BaseLayout;
-} 
-();
-
-/**
- * @license
- * Copyright 2021 Google LLC
- * SPDX-License-Identifier: BSD-3-Clause
- */ function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function _assert_this_initialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _class_call_check(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 _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(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 _get(target, property, receiver) {
-    if (typeof Reflect !== "undefined" && Reflect.get) {
-        _get = Reflect.get;
-    } else {
-        _get = function get(target, property, receiver) {
-            var base = _super_prop_base(target, property);
-            if (!base) return;
-            var desc = Object.getOwnPropertyDescriptor(base, property);
-            if (desc.get) {
-                return desc.get.call(receiver || target);
-            }
-            return desc.value;
-        };
-    }
-    return _get(target, property, receiver || target);
-}
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assert_this_initialized(self);
-}
-function _set_prototype_of(o, p) {
-    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of(o, p);
-}
-function _super_prop_base(object, property) {
-    while(!Object.prototype.hasOwnProperty.call(object, property)){
-        object = _get_prototype_of(object);
-        if (object === null) break;
-    }
-    return object;
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-function _is_native_reflect_construct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _create_super(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct();
-    return function _createSuperInternal() {
-        var Super = _get_prototype_of(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possible_constructor_return(this, result);
-    };
-}
-var flow = function(config) {
-    return Object.assign({
-        type: FlowLayout
-    }, config);
-};
-function leadingMargin(direction) {
-    return direction === "horizontal" ? "marginLeft" : "marginTop";
-}
-function trailingMargin(direction) {
-    return direction === "horizontal" ? "marginRight" : "marginBottom";
-}
-function offset(direction) {
-    return direction === "horizontal" ? "xOffset" : "yOffset";
-}
-function collapseMargins(a, b) {
-    var _Math, _Math1;
-    var m = [
-        a,
-        b
-    ].sort();
-    return m[1] <= 0 ? (_Math = Math).min.apply(_Math, _to_consumable_array(m)) : m[0] >= 0 ? (_Math1 = Math).max.apply(_Math1, _to_consumable_array(m)) : m[0] + m[1];
-}
-var MetricsCache = /*#__PURE__*/ function() {
-    function MetricsCache() {
-        _class_call_check(this, MetricsCache);
-        this._childSizeCache = new SizeCache();
-        this._marginSizeCache = new SizeCache();
-        this._metricsCache = new Map();
-    }
-    _create_class(MetricsCache, [
-        {
-            key: "update",
-            value: function update(metrics, direction) {
-                var _this = this;
-                var marginsToUpdate = new Set();
-                Object.keys(metrics).forEach(function(key) {
-                    var k = Number(key);
-                    _this._metricsCache.set(k, metrics[k]);
-                    _this._childSizeCache.set(k, metrics[k][dim1(direction)]);
-                    marginsToUpdate.add(k);
-                    marginsToUpdate.add(k + 1);
-                });
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = marginsToUpdate[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var k = _step.value;
-                        var _this__metricsCache_get, _this__metricsCache_get1;
-                        var a = ((_this__metricsCache_get = this._metricsCache.get(k)) === null || _this__metricsCache_get === void 0 ? void 0 : _this__metricsCache_get[leadingMargin(direction)]) || 0;
-                        var b = ((_this__metricsCache_get1 = this._metricsCache.get(k - 1)) === null || _this__metricsCache_get1 === void 0 ? void 0 : _this__metricsCache_get1[trailingMargin(direction)]) || 0;
-                        this._marginSizeCache.set(k, collapseMargins(a, b));
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
-                }
-            }
-        },
-        {
-            key: "averageChildSize",
-            get: function get() {
-                return this._childSizeCache.averageSize;
-            }
-        },
-        {
-            key: "totalChildSize",
-            get: function get() {
-                return this._childSizeCache.totalSize;
-            }
-        },
-        {
-            key: "averageMarginSize",
-            get: function get() {
-                return this._marginSizeCache.averageSize;
-            }
-        },
-        {
-            key: "totalMarginSize",
-            get: function get() {
-                return this._marginSizeCache.totalSize;
-            }
-        },
-        {
-            key: "getLeadingMarginValue",
-            value: function getLeadingMarginValue(index, direction) {
-                var _this__metricsCache_get;
-                return ((_this__metricsCache_get = this._metricsCache.get(index)) === null || _this__metricsCache_get === void 0 ? void 0 : _this__metricsCache_get[leadingMargin(direction)]) || 0;
-            }
-        },
-        {
-            key: "getChildSize",
-            value: function getChildSize(index) {
-                return this._childSizeCache.getSize(index);
-            }
-        },
-        {
-            key: "getMarginSize",
-            value: function getMarginSize(index) {
-                return this._marginSizeCache.getSize(index);
-            }
-        },
-        {
-            key: "clear",
-            value: function clear() {
-                this._childSizeCache.clear();
-                this._marginSizeCache.clear();
-                this._metricsCache.clear();
-            }
-        }
-    ]);
-    return MetricsCache;
-}();
-var FlowLayout = /*#__PURE__*/ function(BaseLayout) {
-    _inherits(FlowLayout, BaseLayout);
-    var _super = _create_super(FlowLayout);
-    function FlowLayout() {
-        _class_call_check(this, FlowLayout);
-        var _this;
-        _this = _super.call.apply(_super, [
-            this
-        ].concat(Array.prototype.slice.call(arguments)));
-        /**
-         * Initial estimate of item size
-         */ _this._itemSize = {
-            width: 100,
-            height: 100
-        };
-        /**
-         * Indices of children mapped to their (position and length) in the scrolling
-         * direction. Used to keep track of children that are in range.
-         */ _this._physicalItems = new Map();
-        /**
-         * Used in tandem with _physicalItems to track children in range across
-         * reflows.
-         */ _this._newPhysicalItems = new Map();
-        /**
-         * Width and height of children by their index.
-         */ _this._metricsCache = new MetricsCache();
-        /**
-         * anchorIdx is the anchor around which we reflow. It is designed to allow
-         * jumping to any point of the scroll size. We choose it once and stick with
-         * it until stable. _first and _last are deduced around it.
-         */ _this._anchorIdx = null;
-        /**
-         * Position in the scrolling direction of the anchor child.
-         */ _this._anchorPos = null;
-        /**
-         * Whether all children in range were in range during the previous reflow.
-         */ _this._stable = true;
-        _this._measureChildren = true;
-        _this._estimate = true;
-        return _this;
-    }
-    _create_class(FlowLayout, [
-        {
-            key: "measureChildren",
-            get: // protected _defaultConfig: BaseLayoutConfig = Object.assign({}, super._defaultConfig, {
-            // })
-            // constructor(config: Layout1dConfig) {
-            //   super(config);
-            // }
-            function get() {
-                return this._measureChildren;
-            }
-        },
-        {
-            /**
-     * Determine the average size of all children represented in the sizes
-     * argument.
-     */ key: "updateItemSizes",
-            value: function updateItemSizes(sizes) {
-                this._metricsCache.update(sizes, this.direction);
-                // if (this._nMeasured) {
-                // this._updateItemSize();
-                this._scheduleReflow();
-            // }
-            }
-        },
-        {
-            /**
-     * Set the average item size based on the total length and number of children
-     * in range.
-     */ // _updateItemSize() {
-            //   // Keep integer values.
-            //   this._itemSize[this._sizeDim] = this._metricsCache.averageChildSize;
-            // }
-            key: "_getPhysicalItem",
-            value: function _getPhysicalItem(idx) {
-                var _this__newPhysicalItems_get;
-                return (_this__newPhysicalItems_get = this._newPhysicalItems.get(idx)) !== null && _this__newPhysicalItems_get !== void 0 ? _this__newPhysicalItems_get : this._physicalItems.get(idx);
-            }
-        },
-        {
-            key: "_getSize",
-            value: function _getSize(idx) {
-                var item = this._getPhysicalItem(idx);
-                return item && this._metricsCache.getChildSize(idx);
-            }
-        },
-        {
-            key: "_getAverageSize",
-            value: function _getAverageSize() {
-                return this._metricsCache.averageChildSize || this._itemSize[this._sizeDim];
-            }
-        },
-        {
-            key: "_estimatePosition",
-            value: function _estimatePosition(idx) {
-                var c = this._metricsCache;
-                if (this._first === -1 || this._last === -1) {
-                    return c.averageMarginSize + idx * (c.averageMarginSize + this._getAverageSize());
-                } else {
-                    if (idx < this._first) {
-                        var delta = this._first - idx;
-                        var refItem = this._getPhysicalItem(this._first);
-                        return refItem.pos - (c.getMarginSize(this._first - 1) || c.averageMarginSize) - (delta * c.averageChildSize + (delta - 1) * c.averageMarginSize);
-                    } else {
-                        var delta1 = idx - this._last;
-                        var refItem1 = this._getPhysicalItem(this._last);
-                        return refItem1.pos + (c.getChildSize(this._last) || c.averageChildSize) + (c.getMarginSize(this._last) || c.averageMarginSize) + delta1 * (c.averageChildSize + c.averageMarginSize);
-                    }
-                }
-            }
-        },
-        {
-            /**
-     * Returns the position in the scrolling direction of the item at idx.
-     * Estimates it if the item at idx is not in the DOM.
-     */ key: "_getPosition",
-            value: function _getPosition(idx) {
-                var item = this._getPhysicalItem(idx);
-                var averageMarginSize = this._metricsCache.averageMarginSize;
-                var _this__metricsCache_getMarginSize;
-                return idx === 0 ? (_this__metricsCache_getMarginSize = this._metricsCache.getMarginSize(0)) !== null && _this__metricsCache_getMarginSize !== void 0 ? _this__metricsCache_getMarginSize : averageMarginSize : item ? item.pos : this._estimatePosition(idx);
-            }
-        },
-        {
-            key: "_calculateAnchor",
-            value: function _calculateAnchor(lower, upper) {
-                if (lower <= 0) {
-                    return 0;
-                }
-                if (upper > this._scrollSize - this._viewDim1) {
-                    return this.items.length - 1;
-                }
-                return Math.max(0, Math.min(this.items.length - 1, Math.floor((lower + upper) / 2 / this._delta)));
-            }
-        },
-        {
-            key: "_getAnchor",
-            value: function _getAnchor(lower, upper) {
-                if (this._physicalItems.size === 0) {
-                    return this._calculateAnchor(lower, upper);
-                }
-                if (this._first < 0) {
-                    return this._calculateAnchor(lower, upper);
-                }
-                if (this._last < 0) {
-                    return this._calculateAnchor(lower, upper);
-                }
-                var firstItem = this._getPhysicalItem(this._first), lastItem = this._getPhysicalItem(this._last), firstMin = firstItem.pos, lastMin = lastItem.pos, lastMax = lastMin + this._metricsCache.getChildSize(this._last);
-                if (lastMax < lower) {
-                    // Window is entirely past physical items, calculate new anchor
-                    return this._calculateAnchor(lower, upper);
-                }
-                if (firstMin > upper) {
-                    // Window is entirely before physical items, calculate new anchor
-                    return this._calculateAnchor(lower, upper);
-                }
-                // Window contains a physical item
-                // Find one, starting with the one that was previously first visible
-                var candidateIdx = this._firstVisible - 1;
-                var cMax = -Infinity;
-                while(cMax < lower){
-                    var candidate = this._getPhysicalItem(++candidateIdx);
-                    cMax = candidate.pos + this._metricsCache.getChildSize(candidateIdx);
-                }
-                return candidateIdx;
-            }
-        },
-        {
-            /**
-     * Updates _first and _last based on items that should be in the current
-     * viewed range.
-     */ key: "_getActiveItems",
-            value: function _getActiveItems() {
-                if (this._viewDim1 === 0 || this.items.length === 0) {
-                    this._clearItems();
-                } else {
-                    this._getItems();
-                }
-            }
-        },
-        {
-            /**
-     * Sets the range to empty.
-     */ key: "_clearItems",
-            value: function _clearItems() {
-                this._first = -1;
-                this._last = -1;
-                this._physicalMin = 0;
-                this._physicalMax = 0;
-                var items = this._newPhysicalItems;
-                this._newPhysicalItems = this._physicalItems;
-                this._newPhysicalItems.clear();
-                this._physicalItems = items;
-                this._stable = true;
-            }
-        },
-        {
-            /*
-     * Updates _first and _last based on items that should be in the given range.
-     */ key: "_getItems",
-            value: function _getItems() {
-                var items = this._newPhysicalItems;
-                this._stable = true;
-                var lower, upper;
-                // The anchorIdx is the anchor around which we reflow. It is designed to
-                // allow jumping to any point of the scroll size. We choose it once and
-                // stick with it until stable. first and last are deduced around it.
-                // If we have a pinned item, we anchor on it
-                if (this.pin !== null) {
-                    var index = this.pin.index;
-                    this._anchorIdx = index;
-                    this._anchorPos = this._getPosition(index);
-                }
-                // Determine the lower and upper bounds of the region to be
-                // rendered, relative to the viewport
-                lower = this._scrollPosition - this._overhang; //leadingOverhang;
-                upper = this._scrollPosition + this._viewDim1 + this._overhang; // trailingOverhang;
-                if (upper < 0 || lower > this._scrollSize) {
-                    this._clearItems();
-                    return;
-                }
-                // If we are scrolling to a specific index or if we are doing another
-                // pass to stabilize a previously started reflow, we will already
-                // have an anchor. If not, establish an anchor now.
-                if (this._anchorIdx === null || this._anchorPos === null) {
-                    this._anchorIdx = this._getAnchor(lower, upper);
-                    this._anchorPos = this._getPosition(this._anchorIdx);
-                }
-                var anchorSize = this._getSize(this._anchorIdx);
-                if (anchorSize === undefined) {
-                    this._stable = false;
-                    anchorSize = this._getAverageSize();
-                }
-                var _this__metricsCache_getMarginSize;
-                var anchorLeadingMargin = (_this__metricsCache_getMarginSize = this._metricsCache.getMarginSize(this._anchorIdx)) !== null && _this__metricsCache_getMarginSize !== void 0 ? _this__metricsCache_getMarginSize : this._metricsCache.averageMarginSize;
-                var _this__metricsCache_getMarginSize1;
-                var anchorTrailingMargin = (_this__metricsCache_getMarginSize1 = this._metricsCache.getMarginSize(this._anchorIdx + 1)) !== null && _this__metricsCache_getMarginSize1 !== void 0 ? _this__metricsCache_getMarginSize1 : this._metricsCache.averageMarginSize;
-                if (this._anchorIdx === 0) {
-                    this._anchorPos = anchorLeadingMargin;
-                }
-                if (this._anchorIdx === this.items.length - 1) {
-                    this._anchorPos = this._scrollSize - anchorTrailingMargin - anchorSize;
-                }
-                // Anchor might be outside bounds, so prefer correcting the error and keep
-                // that anchorIdx.
-                var anchorErr = 0;
-                if (this._anchorPos + anchorSize + anchorTrailingMargin < lower) {
-                    anchorErr = lower - (this._anchorPos + anchorSize + anchorTrailingMargin);
-                }
-                if (this._anchorPos - anchorLeadingMargin > upper) {
-                    anchorErr = upper - (this._anchorPos - anchorLeadingMargin);
-                }
-                if (anchorErr) {
-                    this._scrollPosition -= anchorErr;
-                    lower -= anchorErr;
-                    upper -= anchorErr;
-                    this._scrollError += anchorErr;
-                }
-                items.set(this._anchorIdx, {
-                    pos: this._anchorPos,
-                    size: anchorSize
-                });
-                this._first = this._last = this._anchorIdx;
-                this._physicalMin = this._anchorPos - anchorLeadingMargin;
-                this._physicalMax = this._anchorPos + anchorSize + anchorTrailingMargin;
-                while(this._physicalMin > lower && this._first > 0){
-                    var size = this._getSize(--this._first);
-                    if (size === undefined) {
-                        this._stable = false;
-                        size = this._getAverageSize();
-                    }
-                    var margin = this._metricsCache.getMarginSize(this._first);
-                    if (margin === undefined) {
-                        this._stable = false;
-                        margin = this._metricsCache.averageMarginSize;
-                    }
-                    this._physicalMin -= size;
-                    var pos = this._physicalMin;
-                    items.set(this._first, {
-                        pos: pos,
-                        size: size
-                    });
-                    this._physicalMin -= margin;
-                    if (this._stable === false && this._estimate === false) {
-                        break;
-                    }
-                }
-                while(this._physicalMax < upper && this._last < this.items.length - 1){
-                    var size1 = this._getSize(++this._last);
-                    if (size1 === undefined) {
-                        this._stable = false;
-                        size1 = this._getAverageSize();
-                    }
-                    var margin1 = this._metricsCache.getMarginSize(this._last);
-                    if (margin1 === undefined) {
-                        this._stable = false;
-                        margin1 = this._metricsCache.averageMarginSize;
-                    }
-                    var pos1 = this._physicalMax;
-                    items.set(this._last, {
-                        pos: pos1,
-                        size: size1
-                    });
-                    this._physicalMax += size1 + margin1;
-                    if (!this._stable && !this._estimate) {
-                        break;
-                    }
-                }
-                // This handles the cases where we were relying on estimated sizes.
-                var extentErr = this._calculateError();
-                if (extentErr) {
-                    this._physicalMin -= extentErr;
-                    this._physicalMax -= extentErr;
-                    this._anchorPos -= extentErr;
-                    this._scrollPosition -= extentErr;
-                    items.forEach(function(item) {
-                        return item.pos -= extentErr;
-                    });
-                    this._scrollError += extentErr;
-                }
-                if (this._stable) {
-                    this._newPhysicalItems = this._physicalItems;
-                    this._newPhysicalItems.clear();
-                    this._physicalItems = items;
-                }
-            }
-        },
-        {
-            key: "_calculateError",
-            value: function _calculateError() {
-                if (this._first === 0) {
-                    return this._physicalMin;
-                } else if (this._physicalMin <= 0) {
-                    return this._physicalMin - this._first * this._delta;
-                } else if (this._last === this.items.length - 1) {
-                    return this._physicalMax - this._scrollSize;
-                } else if (this._physicalMax >= this._scrollSize) {
-                    return this._physicalMax - this._scrollSize + (this.items.length - 1 - this._last) * this._delta;
-                }
-                return 0;
-            }
-        },
-        {
-            key: "_reflow",
-            value: function _reflow() {
-                var _this = this, _first = _this._first, _last = _this._last;
-                _get(_get_prototype_of(FlowLayout.prototype), "_reflow", this).call(this);
-                if (this._first === -1 && this._last == -1 || this._first === _first && this._last === _last) {
-                    this._resetReflowState();
-                }
-            }
-        },
-        {
-            key: "_resetReflowState",
-            value: function _resetReflowState() {
-                this._anchorIdx = null;
-                this._anchorPos = null;
-                this._stable = true;
-            }
-        },
-        {
-            key: "_updateScrollSize",
-            value: function _updateScrollSize() {
-                var averageMarginSize = this._metricsCache.averageMarginSize;
-                this._scrollSize = Math.max(1, this.items.length * (averageMarginSize + this._getAverageSize()) + averageMarginSize);
-            }
-        },
-        {
-            key: "_delta",
-            get: /**
-     * Returns the average size (precise or estimated) of an item in the scrolling direction,
-     * including any surrounding space.
-     */ function get() {
-                var averageMarginSize = this._metricsCache.averageMarginSize;
-                return this._getAverageSize() + averageMarginSize;
-            }
-        },
-        {
-            /**
-     * Returns the top and left positioning of the item at idx.
-     */ key: "_getItemPosition",
-            value: function _getItemPosition(idx) {
-                var _this__metricsCache_getLeadingMarginValue;
-                var _obj;
-                return _obj = {}, _define_property(_obj, this._positionDim, this._getPosition(idx)), _define_property(_obj, this._secondaryPositionDim, 0), _define_property(_obj, offset(this.direction), -((_this__metricsCache_getLeadingMarginValue = this._metricsCache.getLeadingMarginValue(idx, this.direction)) !== null && _this__metricsCache_getLeadingMarginValue !== void 0 ? _this__metricsCache_getLeadingMarginValue : this._metricsCache.averageMarginSize)), _obj;
-            }
-        },
-        {
-            /**
-     * Returns the height and width of the item at idx.
-     */ key: "_getItemSize",
-            value: function _getItemSize(idx) {
-                var _obj;
-                return _obj = {}, _define_property(_obj, this._sizeDim, this._getSize(idx) || this._getAverageSize()), _define_property(_obj, this._secondarySizeDim, this._itemSize[this._secondarySizeDim]), _obj;
-            }
-        },
-        {
-            key: "_viewDim2Changed",
-            value: function _viewDim2Changed() {
-                this._metricsCache.clear();
-                this._scheduleReflow();
-            }
-        }
-    ]);
-    return FlowLayout;
-} 
-(BaseLayout);
-
-export { FlowLayout, flow };