vite-plugin-vue-devtools 1.0.0-rc.8 → 7.0.0

package/dist/client/assets/timeline-20d79e43.js

@@ -1,1480 +0,0 @@
-import { _ as _sfc_main$2 } from './StateFields.vue_vue_type_script_setup_true_lang-48cf50ad.js';
-import { _ as __unplugin_components_0 } from './PanelGrids-664603ce.js';
-import { p as pushScopeId, a as popScopeId, n as nextTick, o as openBlock, c as createBlock, w as withScopeId, m as markRaw, s as shallowReactive, r as resolveComponent, b as resolveDirective, d as withDirectives, e as createElementBlock, f as renderSlot, g as createCommentVNode, h as withCtx, F as Fragment, i as renderList, j as resolveDynamicComponent, k as mergeProps, t as toHandlers, l as normalizeStyle, q as normalizeClass, u as createVNode, v as defineComponent, x as createBaseVNode, y as toDisplayString, z as unref, _ as __unplugin_components_7, A as timelineLayer, B as activeTimelineEvents, C as activeTimelineEventIndex, D as toggleTimelineEventIndex, E as timelineEventDetails, G as activeLayerId, H as toggleTimelineLayer } from './index-77d53487.js';
-import { d as dayjs } from './dayjs.min-f03ccd82.js';
-import { g, M } from './splitpanes.es-26cdc434.js';
-import './IconButton.vue_vue_type_script_setup_true_lang-48a6bea2.js';
-import './_commonjsHelpers-7e83dbf2.js';
-
-function getInternetExplorerVersion() {
-  var ua = window.navigator.userAgent;
-  var msie = ua.indexOf('MSIE ');
-
-  if (msie > 0) {
-    // IE 10 or older => return version number
-    return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
-  }
-
-  var trident = ua.indexOf('Trident/');
-
-  if (trident > 0) {
-    // IE 11 => return version number
-    var rv = ua.indexOf('rv:');
-    return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
-  }
-
-  var edge = ua.indexOf('Edge/');
-
-  if (edge > 0) {
-    // Edge (IE 12+) => return version number
-    return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
-  } // other browser
-
-
-  return -1;
-}
-
-let isIE;
-
-function initCompat () {
-  if (!initCompat.init) {
-    initCompat.init = true;
-    isIE = getInternetExplorerVersion() !== -1;
-  }
-}
-
-var script = {
-  name: 'ResizeObserver',
-
-  props: {
-    emitOnMount: {
-      type: Boolean,
-      default: false,
-    },
-
-    ignoreWidth: {
-      type: Boolean,
-      default: false,
-    },
-
-    ignoreHeight: {
-      type: Boolean,
-      default: false,
-    },
-  },
-
-  emits: [
-    'notify',
-  ],
-
-  mounted () {
-    initCompat();
-    nextTick(() => {
-      this._w = this.$el.offsetWidth;
-      this._h = this.$el.offsetHeight;
-      if (this.emitOnMount) {
-        this.emitSize();
-      }
-    });
-    const object = document.createElement('object');
-    this._resizeObject = object;
-    object.setAttribute('aria-hidden', 'true');
-    object.setAttribute('tabindex', -1);
-    object.onload = this.addResizeHandlers;
-    object.type = 'text/html';
-    if (isIE) {
-      this.$el.appendChild(object);
-    }
-    object.data = 'about:blank';
-    if (!isIE) {
-      this.$el.appendChild(object);
-    }
-  },
-
-  beforeUnmount () {
-    this.removeResizeHandlers();
-  },
-
-  methods: {
-    compareAndNotify () {
-      if ((!this.ignoreWidth && this._w !== this.$el.offsetWidth) || (!this.ignoreHeight && this._h !== this.$el.offsetHeight)) {
-        this._w = this.$el.offsetWidth;
-        this._h = this.$el.offsetHeight;
-        this.emitSize();
-      }
-    },
-
-    emitSize () {
-      this.$emit('notify', {
-        width: this._w,
-        height: this._h,
-      });
-    },
-
-    addResizeHandlers () {
-      this._resizeObject.contentDocument.defaultView.addEventListener('resize', this.compareAndNotify);
-      this.compareAndNotify();
-    },
-
-    removeResizeHandlers () {
-      if (this._resizeObject && this._resizeObject.onload) {
-        if (!isIE && this._resizeObject.contentDocument) {
-          this._resizeObject.contentDocument.defaultView.removeEventListener('resize', this.compareAndNotify);
-        }
-        this.$el.removeChild(this._resizeObject);
-        this._resizeObject.onload = null;
-        this._resizeObject = null;
-      }
-    },
-  },
-};
-
-const _withId = /*#__PURE__*/withScopeId();
-
-pushScopeId("data-v-b329ee4c");
-const _hoisted_1$3 = {
-  class: "resize-observer",
-  tabindex: "-1"
-};
-popScopeId();
-
-const render = /*#__PURE__*/_withId((_ctx, _cache, $props, $setup, $data, $options) => {
-  return (openBlock(), createBlock("div", _hoisted_1$3))
-});
-
-script.render = render;
-script.__scopeId = "data-v-b329ee4c";
-script.__file = "src/components/ResizeObserver.vue";
-
-
-/* Injected with object hook! */
-
-function _typeof$1(obj) {
-  "@babel/helpers - typeof";
-
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof$1 = function (obj) {
-      return typeof obj;
-    };
-  } else {
-    _typeof$1 = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
-  }
-
-  return _typeof$1(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);
-  return Constructor;
-}
-
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(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(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _arrayLikeToArray(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 _nonIterableSpread() {
-  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 processOptions(value) {
-  var options;
-
-  if (typeof value === 'function') {
-    // Simple options (callback-only)
-    options = {
-      callback: value
-    };
-  } else {
-    // Options object
-    options = value;
-  }
-
-  return options;
-}
-function throttle(callback, delay) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var timeout;
-  var lastState;
-  var currentArgs;
-
-  var throttled = function throttled(state) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
-
-    currentArgs = args;
-    if (timeout && state === lastState) return;
-    var leading = options.leading;
-
-    if (typeof leading === 'function') {
-      leading = leading(state, lastState);
-    }
-
-    if ((!timeout || state !== lastState) && leading) {
-      callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));
-    }
-
-    lastState = state;
-    clearTimeout(timeout);
-    timeout = setTimeout(function () {
-      callback.apply(void 0, [state].concat(_toConsumableArray(currentArgs)));
-      timeout = 0;
-    }, delay);
-  };
-
-  throttled._clear = function () {
-    clearTimeout(timeout);
-    timeout = null;
-  };
-
-  return throttled;
-}
-function deepEqual(val1, val2) {
-  if (val1 === val2) return true;
-
-  if (_typeof$1(val1) === 'object') {
-    for (var key in val1) {
-      if (!deepEqual(val1[key], val2[key])) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  return false;
-}
-
-var VisibilityState = /*#__PURE__*/function () {
-  function VisibilityState(el, options, vnode) {
-    _classCallCheck(this, VisibilityState);
-
-    this.el = el;
-    this.observer = null;
-    this.frozen = false;
-    this.createObserver(options, vnode);
-  }
-
-  _createClass(VisibilityState, [{
-    key: "createObserver",
-    value: function createObserver(options, vnode) {
-      var _this = this;
-
-      if (this.observer) {
-        this.destroyObserver();
-      }
-
-      if (this.frozen) return;
-      this.options = processOptions(options);
-
-      this.callback = function (result, entry) {
-        _this.options.callback(result, entry);
-
-        if (result && _this.options.once) {
-          _this.frozen = true;
-
-          _this.destroyObserver();
-        }
-      }; // Throttle
-
-
-      if (this.callback && this.options.throttle) {
-        var _ref = this.options.throttleOptions || {},
-            _leading = _ref.leading;
-
-        this.callback = throttle(this.callback, this.options.throttle, {
-          leading: function leading(state) {
-            return _leading === 'both' || _leading === 'visible' && state || _leading === 'hidden' && !state;
-          }
-        });
-      }
-
-      this.oldResult = undefined;
-      this.observer = new IntersectionObserver(function (entries) {
-        var entry = entries[0];
-
-        if (entries.length > 1) {
-          var intersectingEntry = entries.find(function (e) {
-            return e.isIntersecting;
-          });
-
-          if (intersectingEntry) {
-            entry = intersectingEntry;
-          }
-        }
-
-        if (_this.callback) {
-          // Use isIntersecting if possible because browsers can report isIntersecting as true, but intersectionRatio as 0, when something very slowly enters the viewport.
-          var result = entry.isIntersecting && entry.intersectionRatio >= _this.threshold;
-          if (result === _this.oldResult) return;
-          _this.oldResult = result;
-
-          _this.callback(result, entry);
-        }
-      }, this.options.intersection); // Wait for the element to be in document
-
-      nextTick(function () {
-        if (_this.observer) {
-          _this.observer.observe(_this.el);
-        }
-      });
-    }
-  }, {
-    key: "destroyObserver",
-    value: function destroyObserver() {
-      if (this.observer) {
-        this.observer.disconnect();
-        this.observer = null;
-      } // Cancel throttled call
-
-
-      if (this.callback && this.callback._clear) {
-        this.callback._clear();
-
-        this.callback = null;
-      }
-    }
-  }, {
-    key: "threshold",
-    get: function get() {
-      return this.options.intersection && typeof this.options.intersection.threshold === 'number' ? this.options.intersection.threshold : 0;
-    }
-  }]);
-
-  return VisibilityState;
-}();
-
-function beforeMount(el, _ref2, vnode) {
-  var value = _ref2.value;
-  if (!value) return;
-
-  if (typeof IntersectionObserver === 'undefined') {
-    console.warn('[vue-observe-visibility] IntersectionObserver API is not available in your browser. Please install this polyfill: https://github.com/w3c/IntersectionObserver/tree/master/polyfill');
-  } else {
-    var state = new VisibilityState(el, value, vnode);
-    el._vue_visibilityState = state;
-  }
-}
-
-function updated(el, _ref3, vnode) {
-  var value = _ref3.value,
-      oldValue = _ref3.oldValue;
-  if (deepEqual(value, oldValue)) return;
-  var state = el._vue_visibilityState;
-
-  if (!value) {
-    unmounted(el);
-    return;
-  }
-
-  if (state) {
-    state.createObserver(value, vnode);
-  } else {
-    beforeMount(el, {
-      value: value
-    }, vnode);
-  }
-}
-
-function unmounted(el) {
-  var state = el._vue_visibilityState;
-
-  if (state) {
-    state.destroyObserver();
-    delete el._vue_visibilityState;
-  }
-}
-
-var ObserveVisibility = {
-  beforeMount: beforeMount,
-  updated: updated,
-  unmounted: unmounted
-};
-
-/* Injected with object hook! */
-
-var config = {
-  itemsLimit: 1000
-};
-
-// Fork of https://github.com/olahol/scrollparent.js to be able to build with Rollup
-
-var regex = /(auto|scroll)/;
-function parents(node, ps) {
-  if (node.parentNode === null) {
-    return ps;
-  }
-  return parents(node.parentNode, ps.concat([node]));
-}
-var style = function style(node, prop) {
-  return getComputedStyle(node, null).getPropertyValue(prop);
-};
-var overflow = function overflow(node) {
-  return style(node, 'overflow') + style(node, 'overflow-y') + style(node, 'overflow-x');
-};
-var scroll = function scroll(node) {
-  return regex.test(overflow(node));
-};
-function getScrollParent(node) {
-  if (!(node instanceof HTMLElement || node instanceof SVGElement)) {
-    return;
-  }
-  var ps = parents(node.parentNode, []);
-  for (var i = 0; i < ps.length; i += 1) {
-    if (scroll(ps[i])) {
-      return ps[i];
-    }
-  }
-  return document.scrollingElement || document.documentElement;
-}
-
-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);
-}
-
-var props = {
-  items: {
-    type: Array,
-    required: true
-  },
-  keyField: {
-    type: String,
-    default: 'id'
-  },
-  direction: {
-    type: String,
-    default: 'vertical',
-    validator: function validator(value) {
-      return ['vertical', 'horizontal'].includes(value);
-    }
-  },
-  listTag: {
-    type: String,
-    default: 'div'
-  },
-  itemTag: {
-    type: String,
-    default: 'div'
-  }
-};
-function simpleArray() {
-  return this.items.length && _typeof(this.items[0]) !== 'object';
-}
-
-var supportsPassive = false;
-if (typeof window !== 'undefined') {
-  supportsPassive = false;
-  try {
-    var opts = Object.defineProperty({}, 'passive', {
-      get: function get() {
-        supportsPassive = true;
-      }
-    });
-    window.addEventListener('test', null, opts);
-  } catch (e) {}
-}
-
-let uid = 0;
-
-var script$2 = {
-  name: 'RecycleScroller',
-
-  components: {
-    ResizeObserver: script,
-  },
-
-  directives: {
-    ObserveVisibility,
-  },
-
-  props: {
-    ...props,
-
-    itemSize: {
-      type: Number,
-      default: null,
-    },
-
-    gridItems: {
-      type: Number,
-      default: undefined,
-    },
-
-    itemSecondarySize: {
-      type: Number,
-      default: undefined,
-    },
-
-    minItemSize: {
-      type: [Number, String],
-      default: null,
-    },
-
-    sizeField: {
-      type: String,
-      default: 'size',
-    },
-
-    typeField: {
-      type: String,
-      default: 'type',
-    },
-
-    buffer: {
-      type: Number,
-      default: 200,
-    },
-
-    pageMode: {
-      type: Boolean,
-      default: false,
-    },
-
-    prerender: {
-      type: Number,
-      default: 0,
-    },
-
-    emitUpdate: {
-      type: Boolean,
-      default: false,
-    },
-
-    updateInterval: {
-      type: Number,
-      default: 0,
-    },
-
-    skipHover: {
-      type: Boolean,
-      default: false,
-    },
-
-    listTag: {
-      type: String,
-      default: 'div',
-    },
-
-    itemTag: {
-      type: String,
-      default: 'div',
-    },
-
-    listClass: {
-      type: [String, Object, Array],
-      default: '',
-    },
-
-    itemClass: {
-      type: [String, Object, Array],
-      default: '',
-    },
-  },
-
-  emits: [
-    'resize',
-    'visible',
-    'hidden',
-    'update',
-    'scroll-start',
-    'scroll-end',
-  ],
-
-  data () {
-    return {
-      pool: [],
-      totalSize: 0,
-      ready: false,
-      hoverKey: null,
-    }
-  },
-
-  computed: {
-    sizes () {
-      if (this.itemSize === null) {
-        const sizes = {
-          '-1': { accumulator: 0 },
-        };
-        const items = this.items;
-        const field = this.sizeField;
-        const minItemSize = this.minItemSize;
-        let computedMinSize = 10000;
-        let accumulator = 0;
-        let current;
-        for (let i = 0, l = items.length; i < l; i++) {
-          current = items[i][field] || minItemSize;
-          if (current < computedMinSize) {
-            computedMinSize = current;
-          }
-          accumulator += current;
-          sizes[i] = { accumulator, size: current };
-        }
-        // eslint-disable-next-line
-        this.$_computedMinItemSize = computedMinSize;
-        return sizes
-      }
-      return []
-    },
-
-    simpleArray,
-
-    itemIndexByKey () {
-      const { keyField, items } = this;
-      const result = {};
-      for (let i = 0, l = items.length; i < l; i++) {
-        result[items[i][keyField]] = i;
-      }
-      return result
-    },
-  },
-
-  watch: {
-    items () {
-      this.updateVisibleItems(true);
-    },
-
-    pageMode () {
-      this.applyPageMode();
-      this.updateVisibleItems(false);
-    },
-
-    sizes: {
-      handler () {
-        this.updateVisibleItems(false);
-      },
-      deep: true,
-    },
-
-    gridItems () {
-      this.updateVisibleItems(true);
-    },
-
-    itemSecondarySize () {
-      this.updateVisibleItems(true);
-    },
-  },
-
-  created () {
-    this.$_startIndex = 0;
-    this.$_endIndex = 0;
-    this.$_views = new Map();
-    this.$_unusedViews = new Map();
-    this.$_scrollDirty = false;
-    this.$_lastUpdateScrollPosition = 0;
-
-    // In SSR mode, we also prerender the same number of item for the first render
-    // to avoir mismatch between server and client templates
-    if (this.prerender) {
-      this.$_prerender = true;
-      this.updateVisibleItems(false);
-    }
-
-    if (this.gridItems && !this.itemSize) {
-      console.error('[vue-recycle-scroller] You must provide an itemSize when using gridItems');
-    }
-  },
-
-  mounted () {
-    this.applyPageMode();
-    this.$nextTick(() => {
-      // In SSR mode, render the real number of visible items
-      this.$_prerender = false;
-      this.updateVisibleItems(true);
-      this.ready = true;
-    });
-  },
-
-  activated () {
-    const lastPosition = this.$_lastUpdateScrollPosition;
-    if (typeof lastPosition === 'number') {
-      this.$nextTick(() => {
-        this.scrollToPosition(lastPosition);
-      });
-    }
-  },
-
-  beforeUnmount () {
-    this.removeListeners();
-  },
-
-  methods: {
-    addView (pool, index, item, key, type) {
-      const nr = markRaw({
-        id: uid++,
-        index,
-        used: true,
-        key,
-        type,
-      });
-      const view = shallowReactive({
-        item,
-        position: 0,
-        nr,
-      });
-      pool.push(view);
-      return view
-    },
-
-    unuseView (view, fake = false) {
-      const unusedViews = this.$_unusedViews;
-      const type = view.nr.type;
-      let unusedPool = unusedViews.get(type);
-      if (!unusedPool) {
-        unusedPool = [];
-        unusedViews.set(type, unusedPool);
-      }
-      unusedPool.push(view);
-      if (!fake) {
-        view.nr.used = false;
-        view.position = -9999;
-      }
-    },
-
-    handleResize () {
-      this.$emit('resize');
-      if (this.ready) this.updateVisibleItems(false);
-    },
-
-    handleScroll (event) {
-      if (!this.$_scrollDirty) {
-        this.$_scrollDirty = true;
-        if (this.$_updateTimeout) return
-
-        const requestUpdate = () => requestAnimationFrame(() => {
-          this.$_scrollDirty = false;
-          const { continuous } = this.updateVisibleItems(false, true);
-
-          // It seems sometimes chrome doesn't fire scroll event :/
-          // When non continous scrolling is ending, we force a refresh
-          if (!continuous) {
-            clearTimeout(this.$_refreshTimout);
-            this.$_refreshTimout = setTimeout(this.handleScroll, this.updateInterval + 100);
-          }
-        });
-
-        requestUpdate();
-
-        // Schedule the next update with throttling
-        if (this.updateInterval) {
-          this.$_updateTimeout = setTimeout(() => {
-            this.$_updateTimeout = 0;
-            if (this.$_scrollDirty) requestUpdate();
-          }, this.updateInterval);
-        }
-      }
-    },
-
-    handleVisibilityChange (isVisible, entry) {
-      if (this.ready) {
-        if (isVisible || entry.boundingClientRect.width !== 0 || entry.boundingClientRect.height !== 0) {
-          this.$emit('visible');
-          requestAnimationFrame(() => {
-            this.updateVisibleItems(false);
-          });
-        } else {
-          this.$emit('hidden');
-        }
-      }
-    },
-
-    updateVisibleItems (checkItem, checkPositionDiff = false) {
-      const itemSize = this.itemSize;
-      const gridItems = this.gridItems || 1;
-      const itemSecondarySize = this.itemSecondarySize || itemSize;
-      const minItemSize = this.$_computedMinItemSize;
-      const typeField = this.typeField;
-      const keyField = this.simpleArray ? null : this.keyField;
-      const items = this.items;
-      const count = items.length;
-      const sizes = this.sizes;
-      const views = this.$_views;
-      const unusedViews = this.$_unusedViews;
-      const pool = this.pool;
-      const itemIndexByKey = this.itemIndexByKey;
-      let startIndex, endIndex;
-      let totalSize;
-      let visibleStartIndex, visibleEndIndex;
-
-      if (!count) {
-        startIndex = endIndex = visibleStartIndex = visibleEndIndex = totalSize = 0;
-      } else if (this.$_prerender) {
-        startIndex = visibleStartIndex = 0;
-        endIndex = visibleEndIndex = Math.min(this.prerender, items.length);
-        totalSize = null;
-      } else {
-        const scroll = this.getScroll();
-
-        // Skip update if use hasn't scrolled enough
-        if (checkPositionDiff) {
-          let positionDiff = scroll.start - this.$_lastUpdateScrollPosition;
-          if (positionDiff < 0) positionDiff = -positionDiff;
-          if ((itemSize === null && positionDiff < minItemSize) || positionDiff < itemSize) {
-            return {
-              continuous: true,
-            }
-          }
-        }
-        this.$_lastUpdateScrollPosition = scroll.start;
-
-        const buffer = this.buffer;
-        scroll.start -= buffer;
-        scroll.end += buffer;
-
-        // account for leading slot
-        let beforeSize = 0;
-        if (this.$refs.before) {
-          beforeSize = this.$refs.before.scrollHeight;
-          scroll.start -= beforeSize;
-        }
-
-        // account for trailing slot
-        if (this.$refs.after) {
-          const afterSize = this.$refs.after.scrollHeight;
-          scroll.end += afterSize;
-        }
-
-        // Variable size mode
-        if (itemSize === null) {
-          let h;
-          let a = 0;
-          let b = count - 1;
-          let i = ~~(count / 2);
-          let oldI;
-
-          // Searching for startIndex
-          do {
-            oldI = i;
-            h = sizes[i].accumulator;
-            if (h < scroll.start) {
-              a = i;
-            } else if (i < count - 1 && sizes[i + 1].accumulator > scroll.start) {
-              b = i;
-            }
-            i = ~~((a + b) / 2);
-          } while (i !== oldI)
-          i < 0 && (i = 0);
-          startIndex = i;
-
-          // For container style
-          totalSize = sizes[count - 1].accumulator;
-
-          // Searching for endIndex
-          for (endIndex = i; endIndex < count && sizes[endIndex].accumulator < scroll.end; endIndex++);
-          if (endIndex === -1) {
-            endIndex = items.length - 1;
-          } else {
-            endIndex++;
-            // Bounds
-            endIndex > count && (endIndex = count);
-          }
-
-          // search visible startIndex
-          for (visibleStartIndex = startIndex; visibleStartIndex < count && (beforeSize + sizes[visibleStartIndex].accumulator) < scroll.start; visibleStartIndex++);
-
-          // search visible endIndex
-          for (visibleEndIndex = visibleStartIndex; visibleEndIndex < count && (beforeSize + sizes[visibleEndIndex].accumulator) < scroll.end; visibleEndIndex++);
-        } else {
-          // Fixed size mode
-          startIndex = ~~(scroll.start / itemSize * gridItems);
-          const remainer = startIndex % gridItems;
-          startIndex -= remainer;
-          endIndex = Math.ceil(scroll.end / itemSize * gridItems);
-          visibleStartIndex = Math.max(0, Math.floor((scroll.start - beforeSize) / itemSize * gridItems));
-          visibleEndIndex = Math.floor((scroll.end - beforeSize) / itemSize * gridItems);
-
-          // Bounds
-          startIndex < 0 && (startIndex = 0);
-          endIndex > count && (endIndex = count);
-          visibleStartIndex < 0 && (visibleStartIndex = 0);
-          visibleEndIndex > count && (visibleEndIndex = count);
-
-          totalSize = Math.ceil(count / gridItems) * itemSize;
-        }
-      }
-
-      if (endIndex - startIndex > config.itemsLimit) {
-        this.itemsLimitError();
-      }
-
-      this.totalSize = totalSize;
-
-      let view;
-
-      const continuous = startIndex <= this.$_endIndex && endIndex >= this.$_startIndex;
-
-      // Unuse views that are no longer visible
-      if (continuous) {
-        for (let i = 0, l = pool.length; i < l; i++) {
-          view = pool[i];
-          if (view.nr.used) {
-            // Update view item index
-            if (checkItem) {
-              view.nr.index = itemIndexByKey[view.item[keyField]];
-            }
-
-            // Check if index is still in visible range
-            if (
-              view.nr.index == null ||
-              view.nr.index < startIndex ||
-              view.nr.index >= endIndex
-            ) {
-              this.unuseView(view);
-            }
-          }
-        }
-      }
-
-      const unusedIndex = continuous ? null : new Map();
-
-      let item, type;
-      let v;
-      for (let i = startIndex; i < endIndex; i++) {
-        item = items[i];
-        const key = keyField ? item[keyField] : item;
-        if (key == null) {
-          throw new Error(`Key is ${key} on item (keyField is '${keyField}')`)
-        }
-        view = views.get(key);
-
-        if (!itemSize && !sizes[i].size) {
-          if (view) this.unuseView(view);
-          continue
-        }
-
-        type = item[typeField];
-
-        let unusedPool = unusedViews.get(type);
-        let newlyUsedView = false;
-
-        // No view assigned to item
-        if (!view) {
-          if (continuous) {
-            // Reuse existing view
-            if (unusedPool && unusedPool.length) {
-              view = unusedPool.pop();
-            } else {
-              view = this.addView(pool, i, item, key, type);
-            }
-          } else {
-            // Use existing view
-            // We don't care if they are already used
-            // because we are not in continous scrolling
-            v = unusedIndex.get(type) || 0;
-
-            if (!unusedPool || v >= unusedPool.length) {
-              view = this.addView(pool, i, item, key, type);
-              this.unuseView(view, true);
-              unusedPool = unusedViews.get(type);
-            }
-
-            view = unusedPool[v];
-            unusedIndex.set(type, v + 1);
-          }
-
-          // Assign view to item
-          views.delete(view.nr.key);
-          view.nr.used = true;
-          view.nr.index = i;
-          view.nr.key = key;
-          view.nr.type = type;
-          views.set(key, view);
-
-          newlyUsedView = true;
-        } else {
-          // View already assigned to item
-          if (!view.nr.used) {
-            view.nr.used = true;
-            newlyUsedView = true;
-            if (unusedPool) {
-              const index = unusedPool.indexOf(view);
-              if (index !== -1) unusedPool.splice(index, 1);
-            }
-          }
-        }
-
-        // Always set item in case it's a new object with the same key
-        view.item = item;
-
-        if (newlyUsedView) {
-          if (i === items.length - 1) this.$emit('scroll-end');
-          if (i === 0) this.$emit('scroll-start');
-        }
-
-        // Update position
-        if (itemSize === null) {
-          view.position = sizes[i - 1].accumulator;
-          view.offset = 0;
-        } else {
-          view.position = Math.floor(i / gridItems) * itemSize;
-          view.offset = (i % gridItems) * itemSecondarySize;
-        }
-      }
-
-      this.$_startIndex = startIndex;
-      this.$_endIndex = endIndex;
-
-      if (this.emitUpdate) this.$emit('update', startIndex, endIndex, visibleStartIndex, visibleEndIndex);
-
-      // After the user has finished scrolling
-      // Sort views so text selection is correct
-      clearTimeout(this.$_sortTimer);
-      this.$_sortTimer = setTimeout(this.sortViews, this.updateInterval + 300);
-
-      return {
-        continuous,
-      }
-    },
-
-    getListenerTarget () {
-      let target = getScrollParent(this.$el);
-      // Fix global scroll target for Chrome and Safari
-      if (window.document && (target === window.document.documentElement || target === window.document.body)) {
-        target = window;
-      }
-      return target
-    },
-
-    getScroll () {
-      const { $el: el, direction } = this;
-      const isVertical = direction === 'vertical';
-      let scrollState;
-
-      if (this.pageMode) {
-        const bounds = el.getBoundingClientRect();
-        const boundsSize = isVertical ? bounds.height : bounds.width;
-        let start = -(isVertical ? bounds.top : bounds.left);
-        let size = isVertical ? window.innerHeight : window.innerWidth;
-        if (start < 0) {
-          size += start;
-          start = 0;
-        }
-        if (start + size > boundsSize) {
-          size = boundsSize - start;
-        }
-        scrollState = {
-          start,
-          end: start + size,
-        };
-      } else if (isVertical) {
-        scrollState = {
-          start: el.scrollTop,
-          end: el.scrollTop + el.clientHeight,
-        };
-      } else {
-        scrollState = {
-          start: el.scrollLeft,
-          end: el.scrollLeft + el.clientWidth,
-        };
-      }
-
-      return scrollState
-    },
-
-    applyPageMode () {
-      if (this.pageMode) {
-        this.addListeners();
-      } else {
-        this.removeListeners();
-      }
-    },
-
-    addListeners () {
-      this.listenerTarget = this.getListenerTarget();
-      this.listenerTarget.addEventListener('scroll', this.handleScroll, supportsPassive
-        ? {
-            passive: true,
-          }
-        : false);
-      this.listenerTarget.addEventListener('resize', this.handleResize);
-    },
-
-    removeListeners () {
-      if (!this.listenerTarget) {
-        return
-      }
-
-      this.listenerTarget.removeEventListener('scroll', this.handleScroll);
-      this.listenerTarget.removeEventListener('resize', this.handleResize);
-
-      this.listenerTarget = null;
-    },
-
-    scrollToItem (index) {
-      let scroll;
-      const gridItems = this.gridItems || 1;
-      if (this.itemSize === null) {
-        scroll = index > 0 ? this.sizes[index - 1].accumulator : 0;
-      } else {
-        scroll = Math.floor(index / gridItems) * this.itemSize;
-      }
-      this.scrollToPosition(scroll);
-    },
-
-    scrollToPosition (position) {
-      const direction = this.direction === 'vertical'
-        ? { scroll: 'scrollTop', start: 'top' }
-        : { scroll: 'scrollLeft', start: 'left' };
-
-      let viewport;
-      let scrollDirection;
-      let scrollDistance;
-
-      if (this.pageMode) {
-        const viewportEl = getScrollParent(this.$el);
-        // HTML doesn't overflow like other elements
-        const scrollTop = viewportEl.tagName === 'HTML' ? 0 : viewportEl[direction.scroll];
-        const bounds = viewportEl.getBoundingClientRect();
-
-        const scroller = this.$el.getBoundingClientRect();
-        const scrollerPosition = scroller[direction.start] - bounds[direction.start];
-
-        viewport = viewportEl;
-        scrollDirection = direction.scroll;
-        scrollDistance = position + scrollTop + scrollerPosition;
-      } else {
-        viewport = this.$el;
-        scrollDirection = direction.scroll;
-        scrollDistance = position;
-      }
-
-      viewport[scrollDirection] = scrollDistance;
-    },
-
-    itemsLimitError () {
-      setTimeout(() => {
-        console.log('It seems the scroller element isn\'t scrolling, so it tries to render all the items at once.', 'Scroller:', this.$el);
-        console.log('Make sure the scroller has a fixed height (or width) and \'overflow-y\' (or \'overflow-x\') set to \'auto\' so it can scroll correctly and only render the items visible in the scroll viewport.');
-      });
-      throw new Error('Rendered items limit reached')
-    },
-
-    sortViews () {
-      this.pool.sort((viewA, viewB) => viewA.nr.index - viewB.nr.index);
-    },
-  },
-};
-
-const _hoisted_1$2 = {
-  key: 0,
-  ref: "before",
-  class: "vue-recycle-scroller__slot"
-};
-const _hoisted_2$2 = {
-  key: 1,
-  ref: "after",
-  class: "vue-recycle-scroller__slot"
-};
-
-function render$1(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_ResizeObserver = resolveComponent("ResizeObserver");
-  const _directive_observe_visibility = resolveDirective("observe-visibility");
-
-  return withDirectives((openBlock(), createElementBlock("div", {
-    class: normalizeClass(["vue-recycle-scroller", {
-      ready: $data.ready,
-      'page-mode': $props.pageMode,
-      [`direction-${_ctx.direction}`]: true,
-    }]),
-    onScrollPassive: _cache[0] || (_cache[0] = (...args) => ($options.handleScroll && $options.handleScroll(...args)))
-  }, [
-    (_ctx.$slots.before)
-      ? (openBlock(), createElementBlock("div", _hoisted_1$2, [
-          renderSlot(_ctx.$slots, "before")
-        ], 512 /* NEED_PATCH */))
-      : createCommentVNode("v-if", true),
-    (openBlock(), createBlock(resolveDynamicComponent($props.listTag), {
-      ref: "wrapper",
-      style: normalizeStyle({ [_ctx.direction === 'vertical' ? 'minHeight' : 'minWidth']: $data.totalSize + 'px' }),
-      class: normalizeClass(["vue-recycle-scroller__item-wrapper", $props.listClass])
-    }, {
-      default: withCtx(() => [
-        (openBlock(true), createElementBlock(Fragment, null, renderList($data.pool, (view) => {
-          return (openBlock(), createBlock(resolveDynamicComponent($props.itemTag), mergeProps({
-            key: view.nr.id,
-            style: $data.ready ? {
-          transform: `translate${_ctx.direction === 'vertical' ? 'Y' : 'X'}(${view.position}px) translate${_ctx.direction === 'vertical' ? 'X' : 'Y'}(${view.offset}px)`,
-          width: $props.gridItems ? `${_ctx.direction === 'vertical' ? $props.itemSecondarySize || $props.itemSize : $props.itemSize}px` : undefined,
-          height: $props.gridItems ? `${_ctx.direction === 'horizontal' ? $props.itemSecondarySize || $props.itemSize : $props.itemSize}px` : undefined,
-        } : null,
-            class: ["vue-recycle-scroller__item-view", [
-          $props.itemClass,
-          {
-            hover: !$props.skipHover && $data.hoverKey === view.nr.key
-          },
-        ]]
-          }, toHandlers($props.skipHover ? {} : {
-          mouseenter: () => { $data.hoverKey = view.nr.key; },
-          mouseleave: () => { $data.hoverKey = null; },
-        })), {
-            default: withCtx(() => [
-              renderSlot(_ctx.$slots, "default", {
-                item: view.item,
-                index: view.nr.index,
-                active: view.nr.used
-              })
-            ]),
-            _: 2 /* DYNAMIC */
-          }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["style", "class"]))
-        }), 128 /* KEYED_FRAGMENT */)),
-        renderSlot(_ctx.$slots, "empty")
-      ]),
-      _: 3 /* FORWARDED */
-    }, 8 /* PROPS */, ["style", "class"])),
-    (_ctx.$slots.after)
-      ? (openBlock(), createElementBlock("div", _hoisted_2$2, [
-          renderSlot(_ctx.$slots, "after")
-        ], 512 /* NEED_PATCH */))
-      : createCommentVNode("v-if", true),
-    createVNode(_component_ResizeObserver, { onNotify: $options.handleResize }, null, 8 /* PROPS */, ["onNotify"])
-  ], 34 /* CLASS, HYDRATE_EVENTS */)), [
-    [_directive_observe_visibility, $options.handleVisibilityChange]
-  ])
-}
-
-script$2.render = render$1;
-script$2.__file = "src/components/RecycleScroller.vue";
-
-
-/* Injected with object hook! */
-
-const vueVirtualScroller = '';
-/* Injected with object hook! */
-
-const _hoisted_1$1 = { key: 0 };
-const _hoisted_2$1 = ["onClick"];
-const _hoisted_3$1 = {
-  "flex-1": "",
-  truncate: "",
-  "font-mono": "",
-  "space-x-1": ""
-};
-const _hoisted_4$1 = { "opacity-75": "" };
-const _hoisted_5$1 = {
-  "flex-none": "",
-  "font-mono": "",
-  "opacity-50": ""
-};
-const _hoisted_6$1 = /* @__PURE__ */ createBaseVNode("h1", {
-  "text-sm": "",
-  italic: "",
-  op50: ""
-}, " No Events ", -1);
-const _sfc_main$1 = /* @__PURE__ */ defineComponent({
-  __name: "TimelineEvent",
-  props: {
-    data: {},
-    selected: {}
-  },
-  emits: ["update-selected"],
-  setup(__props, { emit: emits }) {
-    return (_ctx, _cache) => {
-      const _component_VDCard = __unplugin_components_7;
-      const _component_VDPanelGrids = __unplugin_components_0;
-      return _ctx.data.length ? (openBlock(), createElementBlock("ul", _hoisted_1$1, [
-        createVNode(unref(script$2), {
-          items: _ctx.data,
-          "min-item-size": 40,
-          "key-field": "id",
-          "page-mode": ""
-        }, {
-          default: withCtx(({ item, index }) => [
-            createBaseVNode("li", {
-              border: "b base",
-              "h-10": "",
-              flex: "",
-              "cursor-pointer": "",
-              "select-none": "",
-              "items-center": "",
-              "pl-3": "",
-              "pr-2": "",
-              "text-xs": "",
-              "space-x-2": "",
-              class: normalizeClass([index === _ctx.selected ? "vue-block-active" : "vue-block-hover"]),
-              onClick: ($event) => emits("update-selected", index)
-            }, [
-              createBaseVNode("span", _hoisted_3$1, [
-                createBaseVNode("span", {
-                  "font-medium": "",
-                  class: normalizeClass([index === _ctx.selected ? "text-white" : "text-purple-600 dark:text-purple-400"])
-                }, toDisplayString(item.event.title), 3),
-                createBaseVNode("span", _hoisted_4$1, toDisplayString(item.event.subtitle), 1)
-              ]),
-              createBaseVNode("span", _hoisted_5$1, toDisplayString(unref(dayjs)(item.event.now).format("HH:mm:ss")), 1)
-            ], 10, _hoisted_2$1)
-          ]),
-          _: 1
-        }, 8, ["items"])
-      ])) : (openBlock(), createBlock(_component_VDPanelGrids, {
-        key: 1,
-        px5: ""
-      }, {
-        default: withCtx(() => [
-          createVNode(_component_VDCard, {
-            flex: "~ col gap2",
-            "min-w-30": "",
-            "items-center": "",
-            p3: ""
-          }, {
-            default: withCtx(() => [
-              _hoisted_6$1
-            ]),
-            _: 1
-          })
-        ]),
-        _: 1
-      }));
-    };
-  }
-});
-
-/* Injected with object hook! */
-
-const _hoisted_1 = {
-  "h-screen": "",
-  "n-panel-grids": ""
-};
-const _hoisted_2 = {
-  "h-screen": "",
-  "select-none": "",
-  "overflow-scroll": "",
-  "p-2": "",
-  class: "no-scrollbar"
-};
-const _hoisted_3 = ["onClick"];
-const _hoisted_4 = { "vue-block-title": "" };
-const _hoisted_5 = {
-  "h-screen": "",
-  "select-none": "",
-  "overflow-scroll": "",
-  class: "no-scrollbar"
-};
-const _hoisted_6 = {
-  "h-screen": "",
-  "select-none": "",
-  "overflow-scroll": "",
-  "p-2": "",
-  class: "no-scrollbar"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "timeline",
-  setup(__props) {
-    return (_ctx, _cache) => {
-      const _component_TimelineEvent = _sfc_main$1;
-      const _component_StateFields = _sfc_main$2;
-      return openBlock(), createElementBlock("div", _hoisted_1, [
-        createVNode(unref(M), null, {
-          default: withCtx(() => [
-            createVNode(unref(g), {
-              border: "r base",
-              size: "20"
-            }, {
-              default: withCtx(() => [
-                createBaseVNode("div", _hoisted_2, [
-                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(timelineLayer), (item) => {
-                    return openBlock(), createElementBlock("div", {
-                      key: item.id,
-                      "vue-block": "",
-                      class: normalizeClass([unref(activeLayerId) === item.id ? "vue-block-active" : "vue-block-hover"]),
-                      onClick: ($event) => unref(toggleTimelineLayer)(item.id)
-                    }, [
-                      createBaseVNode("h3", _hoisted_4, [
-                        createBaseVNode("span", {
-                          truncate: "",
-                          class: normalizeClass([unref(activeLayerId) === item.id && "text-white"])
-                        }, toDisplayString(item.label), 3)
-                      ])
-                    ], 10, _hoisted_3);
-                  }), 128))
-                ])
-              ]),
-              _: 1
-            }),
-            createVNode(unref(g), {
-              border: "r base",
-              size: "45"
-            }, {
-              default: withCtx(() => [
-                createBaseVNode("div", _hoisted_5, [
-                  createVNode(_component_TimelineEvent, {
-                    data: unref(activeTimelineEvents),
-                    selected: unref(activeTimelineEventIndex),
-                    onUpdateSelected: unref(toggleTimelineEventIndex)
-                  }, null, 8, ["data", "selected", "onUpdateSelected"])
-                ])
-              ]),
-              _: 1
-            }),
-            unref(timelineEventDetails).value ? (openBlock(), createBlock(unref(g), {
-              key: 0,
-              size: "35"
-            }, {
-              default: withCtx(() => [
-                createBaseVNode("div", _hoisted_6, [
-                  createVNode(_component_StateFields, { data: unref(timelineEventDetails) }, null, 8, ["data"])
-                ])
-              ]),
-              _: 1
-            })) : createCommentVNode("", true)
-          ]),
-          _: 1
-        })
-      ]);
-    };
-  }
-});
-
-/* Injected with object hook! */
-
-/* Injected with object hook! */
-
-export { _sfc_main as default };