add file

node_modules/vuetify/es5/components/VCalendar/modes/column.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.column = void 0;
+
+var _common = require("./common");
+
+var FULL_WIDTH = 100;
+
+var column = function column(events, firstWeekday, overlapThreshold) {
+  var handler = (0, _common.getOverlapGroupHandler)(firstWeekday);
+  return function (day, dayEvents, timed, reset) {
+    var visuals = handler.getVisuals(day, dayEvents, timed, reset);
+
+    if (timed) {
+      visuals.forEach(function (visual) {
+        visual.left = visual.column * FULL_WIDTH / visual.columnCount;
+        visual.width = FULL_WIDTH / visual.columnCount;
+      });
+    }
+
+    return visuals;
+  };
+};
+
+exports.column = column;
+//# sourceMappingURL=column.js.map

node_modules/vuetify/es5/components/VCalendar/modes/column.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/modes/column.ts"],"names":[],"mappings":";;;;;;;AACA;;AAEA,IAAM,UAAU,GAAG,GAAnB;;AAEO,IAAM,MAAM,GAA6B,SAAnC,MAAmC,CAAC,MAAD,EAAS,YAAT,EAAuB,gBAAvB,EAA2C;AACzF,MAAM,OAAO,GAAG,oCAAuB,YAAvB,CAAhB;AAEA,SAAO,UAAC,GAAD,EAAM,SAAN,EAAiB,KAAjB,EAAwB,KAAxB,EAAiC;AACtC,QAAM,OAAO,GAAG,OAAO,CAAC,UAAR,CAAmB,GAAnB,EAAwB,SAAxB,EAAmC,KAAnC,EAA0C,KAA1C,CAAhB;;AAEA,QAAI,KAAJ,EAAW;AACT,MAAA,OAAO,CAAC,OAAR,CAAgB,UAAA,MAAM,EAAG;AACvB,QAAA,MAAM,CAAC,IAAP,GAAc,MAAM,CAAC,MAAP,GAAgB,UAAhB,GAA6B,MAAM,CAAC,WAAlD;AACA,QAAA,MAAM,CAAC,KAAP,GAAe,UAAU,GAAG,MAAM,CAAC,WAAnC;AACD,OAHD;AAID;;AAED,WAAO,OAAP;AACD,GAXD;AAYD,CAfM","sourcesContent":["import { CalendarEventOverlapMode } from 'vuetify/types'\nimport { getOverlapGroupHandler } from './common'\n\nconst FULL_WIDTH = 100\n\nexport const column: CalendarEventOverlapMode = (events, firstWeekday, overlapThreshold) => {\n  const handler = getOverlapGroupHandler(firstWeekday)\n\n  return (day, dayEvents, timed, reset) => {\n    const visuals = handler.getVisuals(day, dayEvents, timed, reset)\n\n    if (timed) {\n      visuals.forEach(visual => {\n        visual.left = visual.column * FULL_WIDTH / visual.columnCount\n        visual.width = FULL_WIDTH / visual.columnCount\n      })\n    }\n\n    return visuals\n  }\n}\n"],"sourceRoot":"","file":"column.js"}

node_modules/vuetify/es5/components/VCalendar/modes/common.js

@@ -0,0 +1,165 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVisuals = _getVisuals;
+exports.hasOverlap = hasOverlap;
+exports.setColumnCount = setColumnCount;
+exports.getRange = getRange;
+exports.getDayRange = getDayRange;
+exports.getNormalizedRange = getNormalizedRange;
+exports.getOpenGroup = getOpenGroup;
+exports.getOverlapGroupHandler = getOverlapGroupHandler;
+
+var _timestamp = require("../util/timestamp");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var MILLIS_IN_DAY = 86400000;
+
+function _getVisuals(events) {
+  var minStart = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var visuals = events.map(function (event) {
+    return {
+      event: event,
+      columnCount: 0,
+      column: 0,
+      left: 0,
+      width: 100
+    };
+  });
+  visuals.sort(function (a, b) {
+    return Math.max(minStart, a.event.startTimestampIdentifier) - Math.max(minStart, b.event.startTimestampIdentifier) || b.event.endTimestampIdentifier - a.event.endTimestampIdentifier;
+  });
+  return visuals;
+}
+
+function hasOverlap(s0, e0, s1, e1) {
+  var exclude = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  return exclude ? !(s0 >= e1 || e0 <= s1) : !(s0 > e1 || e0 < s1);
+}
+
+function setColumnCount(groups) {
+  groups.forEach(function (group) {
+    group.visuals.forEach(function (groupVisual) {
+      groupVisual.columnCount = groups.length;
+    });
+  });
+}
+
+function getRange(event) {
+  return [event.startTimestampIdentifier, event.endTimestampIdentifier];
+}
+
+function getDayRange(event) {
+  return [event.startIdentifier, event.endIdentifier];
+}
+
+function getNormalizedRange(event, dayStart) {
+  return [Math.max(dayStart, event.startTimestampIdentifier), Math.min(dayStart + MILLIS_IN_DAY, event.endTimestampIdentifier)];
+}
+
+function getOpenGroup(groups, start, end, timed) {
+  for (var i = 0; i < groups.length; i++) {
+    var group = groups[i];
+    var intersected = false;
+
+    if (hasOverlap(start, end, group.start, group.end, timed)) {
+      for (var k = 0; k < group.visuals.length; k++) {
+        var groupVisual = group.visuals[k];
+
+        var _ref = timed ? getRange(groupVisual.event) : getDayRange(groupVisual.event),
+            _ref2 = _slicedToArray(_ref, 2),
+            groupStart = _ref2[0],
+            groupEnd = _ref2[1];
+
+        if (hasOverlap(start, end, groupStart, groupEnd, timed)) {
+          intersected = true;
+          break;
+        }
+      }
+    }
+
+    if (!intersected) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+function getOverlapGroupHandler(firstWeekday) {
+  var handler = {
+    groups: [],
+    min: -1,
+    max: -1,
+    reset: function reset() {
+      handler.groups = [];
+      handler.min = handler.max = -1;
+    },
+    getVisuals: function getVisuals(day, dayEvents, timed) {
+      var reset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+      if (day.weekday === firstWeekday || reset) {
+        handler.reset();
+      }
+
+      var dayStart = (0, _timestamp.getTimestampIdentifier)(day);
+
+      var visuals = _getVisuals(dayEvents, dayStart);
+
+      visuals.forEach(function (visual) {
+        var _ref3 = timed ? getRange(visual.event) : getDayRange(visual.event),
+            _ref4 = _slicedToArray(_ref3, 2),
+            start = _ref4[0],
+            end = _ref4[1];
+
+        if (handler.groups.length > 0 && !hasOverlap(start, end, handler.min, handler.max, timed)) {
+          setColumnCount(handler.groups);
+          handler.reset();
+        }
+
+        var targetGroup = getOpenGroup(handler.groups, start, end, timed);
+
+        if (targetGroup === -1) {
+          targetGroup = handler.groups.length;
+          handler.groups.push({
+            start: start,
+            end: end,
+            visuals: []
+          });
+        }
+
+        var target = handler.groups[targetGroup];
+        target.visuals.push(visual);
+        target.start = Math.min(target.start, start);
+        target.end = Math.max(target.end, end);
+        visual.column = targetGroup;
+
+        if (handler.min === -1) {
+          handler.min = start;
+          handler.max = end;
+        } else {
+          handler.min = Math.min(handler.min, start);
+          handler.max = Math.max(handler.max, end);
+        }
+      });
+      setColumnCount(handler.groups);
+
+      if (timed) {
+        handler.reset();
+      }
+
+      return visuals;
+    }
+  };
+  return handler;
+}
+//# sourceMappingURL=common.js.map

node_modules/vuetify/es5/components/VCalendar/modes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CalendarEventOverlapModes = void 0;
+
+var _stack = require("./stack");
+
+var _column = require("./column");
+
+var CalendarEventOverlapModes = {
+  stack: _stack.stack,
+  column: _column.column
+};
+exports.CalendarEventOverlapModes = CalendarEventOverlapModes;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VCalendar/modes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VCalendar/modes/index.ts"],"names":[],"mappings":";;;;;;;AACA;;AACA;;AAEO,IAAM,yBAAyB,GAA6C;AACjF,EAAA,KAAK,EAAL,YADiF;AAEjF,EAAA,MAAM,EAAN;AAFiF,CAA5E","sourcesContent":["import { CalendarEventOverlapMode } from 'vuetify/types'\nimport { stack } from './stack'\nimport { column } from './column'\n\nexport const CalendarEventOverlapModes: Record<string, CalendarEventOverlapMode> = {\n  stack,\n  column,\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VCalendar/modes/stack.js

@@ -0,0 +1,481 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stack = void 0;
+
+var _common = require("./common");
+
+var _timestamp = require("../util/timestamp");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var FULL_WIDTH = 100;
+var DEFAULT_OFFSET = 5;
+var WIDTH_MULTIPLIER = 1.7;
+/**
+ * Variation of column mode where events can be stacked. The priority of this
+ * mode is to stack events together taking up the least amount of space while
+ * trying to ensure the content of the event is always visible as well as its
+ * start and end. A sibling column has intersecting event content and must be
+ * placed beside each other. Non-sibling columns are offset by 5% from the
+ * previous column. The width is scaled by 1.7 so the events overlap and
+ * whitespace is reduced. If there is a hole in columns the event width is
+ * scaled up so it intersects with the next column. The columns have equal
+ * width in the space they are given. If the event doesn't have any to the
+ * right of it that intersect with it's content it's right side is extended
+ * to the right side.
+ */
+
+var stack = function stack(events, firstWeekday, overlapThreshold) {
+  var handler = (0, _common.getOverlapGroupHandler)(firstWeekday); // eslint-disable-next-line max-statements
+
+  return function (day, dayEvents, timed, reset) {
+    if (!timed) {
+      return handler.getVisuals(day, dayEvents, timed, reset);
+    }
+
+    var dayStart = (0, _timestamp.getTimestampIdentifier)(day);
+    var visuals = (0, _common.getVisuals)(dayEvents, dayStart);
+    var groups = getGroups(visuals, dayStart);
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = groups[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var group = _step.value;
+        var nodes = [];
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = group.visuals[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            var visual = _step2.value;
+            var child = getNode(visual, dayStart);
+            var index = getNextIndex(child, nodes);
+
+            if (index === false) {
+              var parent = getParent(child, nodes);
+
+              if (parent) {
+                child.parent = parent;
+                child.sibling = (0, _common.hasOverlap)(child.start, child.end, parent.start, addTime(parent.start, overlapThreshold));
+                child.index = parent.index + 1;
+                parent.children.push(child);
+              }
+            } else {
+              var _getOverlappingRange = getOverlappingRange(child, nodes, index - 1, index - 1),
+                  _getOverlappingRange2 = _slicedToArray(_getOverlappingRange, 1),
+                  _parent = _getOverlappingRange2[0];
+
+              var children = getOverlappingRange(child, nodes, index + 1, index + nodes.length, true);
+              child.children = children;
+              child.index = index;
+
+              if (_parent) {
+                child.parent = _parent;
+                child.sibling = (0, _common.hasOverlap)(child.start, child.end, _parent.start, addTime(_parent.start, overlapThreshold));
+
+                _parent.children.push(child);
+              }
+
+              var _iteratorNormalCompletion3 = true;
+              var _didIteratorError3 = false;
+              var _iteratorError3 = undefined;
+
+              try {
+                for (var _iterator3 = children[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                  var grand = _step3.value;
+
+                  if (grand.parent === _parent) {
+                    grand.parent = child;
+                  }
+
+                  var grandNext = grand.index - child.index <= 1;
+
+                  if (grandNext && child.sibling && (0, _common.hasOverlap)(child.start, addTime(child.start, overlapThreshold), grand.start, grand.end)) {
+                    grand.sibling = true;
+                  }
+                }
+              } catch (err) {
+                _didIteratorError3 = true;
+                _iteratorError3 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                    _iterator3.return();
+                  }
+                } finally {
+                  if (_didIteratorError3) {
+                    throw _iteratorError3;
+                  }
+                }
+              }
+            }
+
+            nodes.push(child);
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+
+        calculateBounds(nodes, overlapThreshold);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    visuals.sort(function (a, b) {
+      return a.left - b.left || a.event.startTimestampIdentifier - b.event.startTimestampIdentifier;
+    });
+    return visuals;
+  };
+};
+
+exports.stack = stack;
+
+function calculateBounds(nodes, overlapThreshold) {
+  var _iteratorNormalCompletion4 = true;
+  var _didIteratorError4 = false;
+  var _iteratorError4 = undefined;
+
+  try {
+    for (var _iterator4 = nodes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+      var node = _step4.value;
+      var visual = node.visual,
+          parent = node.parent;
+      var columns = getMaxChildIndex(node) + 1;
+      var spaceLeft = parent ? parent.visual.left : 0;
+      var spaceWidth = FULL_WIDTH - spaceLeft;
+      var offset = Math.min(DEFAULT_OFFSET, FULL_WIDTH / columns);
+      var columnWidthMultiplier = getColumnWidthMultiplier(node, nodes);
+      var columnOffset = spaceWidth / (columns - node.index + 1);
+      var columnWidth = spaceWidth / (columns - node.index + (node.sibling ? 1 : 0)) * columnWidthMultiplier;
+
+      if (parent) {
+        visual.left = node.sibling ? spaceLeft + columnOffset : spaceLeft + offset;
+      }
+
+      visual.width = hasFullWidth(node, nodes, overlapThreshold) ? FULL_WIDTH - visual.left : Math.min(FULL_WIDTH - visual.left, columnWidth * WIDTH_MULTIPLIER);
+    }
+  } catch (err) {
+    _didIteratorError4 = true;
+    _iteratorError4 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+        _iterator4.return();
+      }
+    } finally {
+      if (_didIteratorError4) {
+        throw _iteratorError4;
+      }
+    }
+  }
+}
+
+function getColumnWidthMultiplier(node, nodes) {
+  if (!node.children.length) {
+    return 1;
+  }
+
+  var maxColumn = node.index + nodes.length;
+  var minColumn = node.children.reduce(function (min, c) {
+    return Math.min(min, c.index);
+  }, maxColumn);
+  return minColumn - node.index;
+}
+
+function getOverlappingIndices(node, nodes) {
+  var indices = [];
+  var _iteratorNormalCompletion5 = true;
+  var _didIteratorError5 = false;
+  var _iteratorError5 = undefined;
+
+  try {
+    for (var _iterator5 = nodes[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+      var other = _step5.value;
+
+      if ((0, _common.hasOverlap)(node.start, node.end, other.start, other.end)) {
+        indices.push(other.index);
+      }
+    }
+  } catch (err) {
+    _didIteratorError5 = true;
+    _iteratorError5 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+        _iterator5.return();
+      }
+    } finally {
+      if (_didIteratorError5) {
+        throw _iteratorError5;
+      }
+    }
+  }
+
+  return indices;
+}
+
+function getNextIndex(node, nodes) {
+  var indices = getOverlappingIndices(node, nodes);
+  indices.sort();
+
+  for (var i = 0; i < indices.length; i++) {
+    if (i < indices[i]) {
+      return i;
+    }
+  }
+
+  return false;
+}
+
+function getOverlappingRange(node, nodes, indexMin, indexMax) {
+  var returnFirstColumn = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+  var overlapping = [];
+  var _iteratorNormalCompletion6 = true;
+  var _didIteratorError6 = false;
+  var _iteratorError6 = undefined;
+
+  try {
+    for (var _iterator6 = nodes[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+      var other = _step6.value;
+
+      if (other.index >= indexMin && other.index <= indexMax && (0, _common.hasOverlap)(node.start, node.end, other.start, other.end)) {
+        overlapping.push(other);
+      }
+    }
+  } catch (err) {
+    _didIteratorError6 = true;
+    _iteratorError6 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+        _iterator6.return();
+      }
+    } finally {
+      if (_didIteratorError6) {
+        throw _iteratorError6;
+      }
+    }
+  }
+
+  if (returnFirstColumn && overlapping.length > 0) {
+    var first = overlapping.reduce(function (min, n) {
+      return Math.min(min, n.index);
+    }, overlapping[0].index);
+    return overlapping.filter(function (n) {
+      return n.index === first;
+    });
+  }
+
+  return overlapping;
+}
+
+function getParent(node, nodes) {
+  var parent = null;
+  var _iteratorNormalCompletion7 = true;
+  var _didIteratorError7 = false;
+  var _iteratorError7 = undefined;
+
+  try {
+    for (var _iterator7 = nodes[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+      var other = _step7.value;
+
+      if ((0, _common.hasOverlap)(node.start, node.end, other.start, other.end) && (parent === null || other.index > parent.index)) {
+        parent = other;
+      }
+    }
+  } catch (err) {
+    _didIteratorError7 = true;
+    _iteratorError7 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+        _iterator7.return();
+      }
+    } finally {
+      if (_didIteratorError7) {
+        throw _iteratorError7;
+      }
+    }
+  }
+
+  return parent;
+}
+
+function hasFullWidth(node, nodes, overlapThreshold) {
+  var _iteratorNormalCompletion8 = true;
+  var _didIteratorError8 = false;
+  var _iteratorError8 = undefined;
+
+  try {
+    for (var _iterator8 = nodes[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+      var other = _step8.value;
+
+      if (other !== node && other.index > node.index && (0, _common.hasOverlap)(node.start, addTime(node.start, overlapThreshold), other.start, other.end)) {
+        return false;
+      }
+    }
+  } catch (err) {
+    _didIteratorError8 = true;
+    _iteratorError8 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+        _iterator8.return();
+      }
+    } finally {
+      if (_didIteratorError8) {
+        throw _iteratorError8;
+      }
+    }
+  }
+
+  return true;
+}
+
+function getGroups(visuals, dayStart) {
+  var groups = [];
+  var _iteratorNormalCompletion9 = true;
+  var _didIteratorError9 = false;
+  var _iteratorError9 = undefined;
+
+  try {
+    for (var _iterator9 = visuals[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
+      var visual = _step9.value;
+
+      var _getNormalizedRange = (0, _common.getNormalizedRange)(visual.event, dayStart),
+          _getNormalizedRange2 = _slicedToArray(_getNormalizedRange, 2),
+          start = _getNormalizedRange2[0],
+          end = _getNormalizedRange2[1];
+
+      var added = false;
+
+      for (var _i2 = 0, _groups = groups; _i2 < _groups.length; _i2++) {
+        var group = _groups[_i2];
+
+        if ((0, _common.hasOverlap)(start, end, group.start, group.end)) {
+          group.visuals.push(visual);
+          group.end = Math.max(group.end, end);
+          added = true;
+          break;
+        }
+      }
+
+      if (!added) {
+        groups.push({
+          start: start,
+          end: end,
+          visuals: [visual]
+        });
+      }
+    }
+  } catch (err) {
+    _didIteratorError9 = true;
+    _iteratorError9 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+        _iterator9.return();
+      }
+    } finally {
+      if (_didIteratorError9) {
+        throw _iteratorError9;
+      }
+    }
+  }
+
+  return groups;
+}
+
+function getNode(visual, dayStart) {
+  var _getNormalizedRange3 = (0, _common.getNormalizedRange)(visual.event, dayStart),
+      _getNormalizedRange4 = _slicedToArray(_getNormalizedRange3, 2),
+      start = _getNormalizedRange4[0],
+      end = _getNormalizedRange4[1];
+
+  return {
+    parent: null,
+    sibling: true,
+    index: 0,
+    visual: visual,
+    start: start,
+    end: end,
+    children: []
+  };
+}
+
+function getMaxChildIndex(node) {
+  var max = node.index;
+  var _iteratorNormalCompletion10 = true;
+  var _didIteratorError10 = false;
+  var _iteratorError10 = undefined;
+
+  try {
+    for (var _iterator10 = node.children[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
+      var child = _step10.value;
+      var childMax = getMaxChildIndex(child);
+
+      if (childMax > max) {
+        max = childMax;
+      }
+    }
+  } catch (err) {
+    _didIteratorError10 = true;
+    _iteratorError10 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+        _iterator10.return();
+      }
+    } finally {
+      if (_didIteratorError10) {
+        throw _iteratorError10;
+      }
+    }
+  }
+
+  return max;
+}
+
+function addTime(identifier, minutes) {
+  var removeMinutes = identifier % 100;
+  var totalMinutes = removeMinutes + minutes;
+  var addHours = Math.floor(totalMinutes / 60);
+  var addMinutes = totalMinutes % 60;
+  return identifier - removeMinutes + addHours * 100 + addMinutes;
+}
+//# sourceMappingURL=stack.js.map