vite-plugin-vue-devtools 0.0.1-alpha.9 → 0.0.2

package/dist/client/assets/timeline-3b917d7d.js

@@ -0,0 +1,1500 @@
+import { g, M, _ as _sfc_main$2 } from './splitpanes.es-39cc6ffd.js';
+import { _ as __unplugin_components_0 } from './VPanelGrids-aa63351b.js';
+import { _ as __unplugin_components_7 } from './VCard-bd163775.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, A as onMounted, B as onUnmounted, C as timelineLayer, D as activeTimelineEvents, E as activeTimelineEventIndex, G as toggleTimelineEventIndex, H as timelineEventDetails, I as activeLayerId, J as toggleTimelineLayer } from './index-46e82560.js';
+import './VIcon.vue_vue_type_script_setup_true_lang-ace21790.js';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/* Injected with object hook! */
+
+var dayjs_min = {exports: {}};/* Injected with object hook! */
+
+(function (module, exports) {
+	!function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",f="month",h="quarter",c="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return "["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return -t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,f),s=n-i<0,u=e.clone().add(r+(s?-1:1),f);return +(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return {M:f,y:c,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:h}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},g="en",D={};D[g]=M;var p=function(t){return t instanceof _},S=function t(e,n,r){var i;if(!e)return g;if("string"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split("-");if(!i&&u.length>1)return t(u[0])}else {var a=e.name;D[a]=e,i=a;}return !r&&i&&(g=i),i||!r&&g},w=function(t,e){if(p(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},O=v;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=S(t.locale,null,!0),this.parse(t);}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return O},m.isValid=function(){return !(this.$d.toString()===l)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,h=O.p(t),l=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return O.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v="set"+(this.$u?"UTC":"");switch(h){case c:return r?l(1,0):l(31,11);case f:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+"Hours",0);case u:return $(v+"Minutes",1);case s:return $(v+"Seconds",2);case i:return $(v+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=O.p(t),h="set"+(this.$u?"UTC":""),l=(n={},n[a]=h+"Date",n[d]=h+"Date",n[f]=h+"Month",n[c]=h+"FullYear",n[u]=h+"Hours",n[s]=h+"Minutes",n[i]=h+"Seconds",n[r]=h+"Milliseconds",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===f||o===c){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d;}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,h){var d,l=this;r=Number(r);var $=O.p(h),y=function(t){var e=w(l);return O.w(e.date(e.date()+Math.round(t*r)),l)};if($===f)return this.set(f,this.$M+r);if($===c)return this.set(c,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,f=n.months,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},c=function(t){return O.s(s%12||12,t,"0")},d=n.meridiem||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r},$={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:O.s(a+1,2,"0"),MMM:h(n.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:O.s(this.$D,2,"0"),d:String(this.$W),dd:h(n.weekdaysMin,this.$W,o,2),ddd:h(n.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:O.s(s,2,"0"),h:c(1),hh:c(2),a:d(s,u,!0),A:d(s,u,!1),m:String(u),mm:O.s(u,2,"0"),s:String(this.$s),ss:O.s(this.$s,2,"0"),SSS:O.s(this.$ms,3,"0"),Z:i};return r.replace(y,(function(t,e){return e||$[t]||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=O.p(d),M=w(r),m=(M.utcOffset()-this.utcOffset())*e,v=this-M,g=O.m(this,M);return g=($={},$[c]=g/12,$[f]=g,$[h]=g/3,$[o]=(v-m)/6048e5,$[a]=(v-m)/864e5,$[u]=v/n,$[s]=v/e,$[i]=v/t,$)[y]||v,l?g:O.a(g)},m.daysInMonth=function(){return this.endOf(f).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),T=_.prototype;return w.prototype=T,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",f],["$y",c],["$D",d]].forEach((function(t){T[t[1]]=function(e){return this.$g(e,t[0],t[1])};})),w.extend=function(t,e){return t.$i||(t(e,_,w),t.$i=!0),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=D[g],w.Ls=D,w.p={},w})); 
+} (dayjs_min));
+
+var dayjs_minExports = dayjs_min.exports;
+const dayjs = /*@__PURE__*/getDefaultExportFromCjs(dayjs_minExports);
+/* Injected with object hook! */
+
+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: null,
+    selected: null
+  },
+  emits: ["update-selected"],
+  setup(__props, { emit: emits }) {
+    return (_ctx, _cache) => {
+      const _component_VCard = __unplugin_components_7;
+      const _component_VPanelGrids = __unplugin_components_0;
+      return __props.data.length ? (openBlock(), createElementBlock("ul", _hoisted_1$1, [
+        createVNode(unref(script$2), {
+          items: __props.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 === __props.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 === __props.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_VPanelGrids, {
+        key: 1,
+        px5: ""
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_VCard, {
+            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) {
+    onMounted(() => {
+    });
+    onUnmounted(() => {
+    });
+    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" : "vue-block-text"])
+                        }, 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 };