{"version":3,"sources":["webpack:///./node_modules/@fullcalendar/timegrid/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@fullcalendar/timegrid/main.js"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","this","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","_super","AllDaySplitter","getKeyInfo","allDay","timed","getKeysForDateSpan","dateSpan","getKeysForEventDef","eventDef","DEFAULT_SLAT_LABEL_FORMAT","hour","minute","omitZeroMinute","meridiem","TimeColsAxisCell","props","classNames","isLabeled","Consumer","context","className","join","isoTimeStr","dateEnv","options","viewApi","labelFormat","slotLabelFormat","isArray","hookProps","level","time","date","toDate","view","text","format","slotLabelClassNames","content","slotLabelContent","defaultContent","renderInnerContent","didMount","slotLabelDidMount","willUnmount","slotLabelWillUnmount","rootElRef","customClassNames","innerElRef","innerContent","ref","concat","TimeBodyAxis","render","slatMetas","map","slatMeta","key","DEFAULT_WEEK_NUM_FORMAT","week","AUTO_ALL_DAY_MAX_EVENT_ROWS","TimeColsView","_this","allDaySplitter","headerElRef","scrollerElRef","state","slatCoords","handleScrollTopRequest","scrollTop","scrollerEl","current","renderHeadAxis","rowKey","frameHeight","dateProfile","range","renderRange","dayCnt","start","end","navLinkAttrs","navLinks","tabIndex","weekNumbers","defaultFormat","style","height","renderTableRowAxis","rowHeight","_a","allDayText","allDayClassNames","allDayContent","renderAllDayInner","allDayDidMount","allDayWillUnmount","handleSlatCoords","setState","renderSimpleLayout","headerRowContent","timeContent","sections","stickyHeaderDates","push","type","isSticky","chunk","elRef","tableClassName","rowContent","outerContent","theme","getClass","liquid","expandRows","Boolean","viewSpec","isHeightAuto","forPrint","collapsibleWidth","cols","width","renderHScrollLayout","colCnt","dayMinWidth","ScrollGrid","pluginHooks","scrollGridImpl","Error","stickyFooterScrollbar","syncRowHeights","chunks","arg","rowSyncHeights","contentArg","colSpan","isNowIndicator","nowIndicator","clientHeight","tableColGroupNode","unit","nowDate","nowIndicatorTop","safeComputeTop","isAxis","top","colGroups","span","minWidth","getAllDayMaxEventProps","dayMaxEvents","dayMaxEventRows","undefined","TimeColsSlatsCoords","positions","slotDuration","currentRange","startOfDayDate","timeMs","valueOf","slotMinTime","slotMaxTime","computeTimeTop","computeDateTop","when","duration","slatIndex","slatRemainder","len","els","slatCoverage","milliseconds","Math","max","min","floor","tops","getHeight","TimeColsSlatsBody","slatElRefs","createRef","axis","slotLaneClassNames","slotLaneContent","slotLaneDidMount","slotLaneWillUnmount","TimeColsSlats","tableMinWidth","clientWidth","minHeight","componentDidMount","updateSizing","componentDidUpdate","componentWillUnmount","onCoords","rootEl","offsetHeight","collectSlatEls","currentMap","elMap","splitSegsByCol","segs","segsByCol","col","splitInteractionByCol","ui","byRow","affectedInstances","isEvent","_i","seg","computeSegCoords","dayDate","eventMinHeight","eventOrderSpecs","computeSegVerticals","computeSegHorizontals","segs_1","bottom","segs_2","forwardCoord","backwardCoord","forwardPressure","level0","levels","buildSlotSegLevels","computeForwardSlotSegs","level0_1","computeSlotSegPressures","_b","level0_2","computeSegForwardBack","j","computeSlotSegCollisions","otherSegs","results","isSlotSegCollision","seg1","seg2","k","forwardSegs","forwardSeg","seriesBackwardPressure","seriesBackwardCoord","sortForwardSegs","objs","buildTimeGridSegCompareObj","specs","field","order","sort","obj0","obj1","c","_seg","obj","DEFAULT_TIME_FORMAT","TimeColEvent","isCondensed","defaultTimeFormat","extraClassNames","TimeColMisc","todayRange","extraHookProps","timeGridEventCondensedHeight","TimeCol","isSelectMirror","selectMirror","mirrorSegs","eventDrag","eventResize","dateSelectionSegs","interactionAffectedInstances","dataAttrs","extraDataAttrs","renderFillSegs","businessHourSegs","bgEventSegs","renderFgSegs","fgEventSegs","renderNowIndicator","nowIndicatorSegs","segIsInvisible","isDragging","isResizing","isDateSelecting","renderPrintFgSegs","renderPositionedFgSegs","eventOrder","eventRange","instance","instanceId","isSelected","isMirror","positionCss","left","right","computeSegTopBottomCss","computeFgSegPositionCss","visibility","eventSelection","fillType","children","isRtl","shouldOverlap","slotEventOverlap","zIndex","TimeColsContent","splitFgEventSegs","splitBgEventSegs","splitBusinessHourSegs","splitNowIndicatorSegs","splitDateSelectionSegs","splitEventDrag","splitEventResize","cellElRefs","cells","fgEventSegsByRow","bgEventSegsByRow","businessHourSegsByRow","nowIndicatorSegsByRow","dateSelectionSegsByRow","eventDragByRow","eventResizeByRow","cell","updateCoords","onColCoords","collectCellEls","TimeCols","processSlotOptions","handleScrollRequest","request","onScrollTopRequest","top_1","ceil","handleColCoords","colCoords","onSlatCoords","scrollResponder","createScrollResponder","prevProps","update","detach","positionToHit","positionLeft","positionTop","snapDuration","snapsPerSlot","colIndex","leftToIndex","topToIndex","slatTop","slatHeight","partial","localSnapIndex","snapIndex","add","dayEl","relativeRect","lefts","rights","snapDurationOverride","DayTimeColsSlicer","sliceRange","dayRanges","segRange","isStart","isEnd","DayTimeCols","buildDayRanges","slicer","timeColsRef","handleRootEl","registerInteractiveComponent","el","unregisterInteractiveComponent","dayTableModel","sliceProps","sliceNowDate","queryHit","rawHit","component","rect","layer","ranges","headerDates","STOCK_SUB_DURATIONS","hours","minutes","seconds","buildSlatMetas","explicitLabelInterval","dayStart","Date","slatTime","slatIterator","labelInterval","computeLabelInterval","metas","toISOString","slotsPerLabel","DayTimeColsView","buildTimeColsModel","dateProfileGenerator","splitProps","slotLabelInterval","hasAttachedAxis","hasDetachedAxis","headerContent","dayHeaders","dates","datesRepDistinctDays","renderIntro","allDaySlot","nextDayThreshold","colGroupNode","renderRowIntro","showWeekNumbers","headerAlignElRef","timeGridContent","daySeries","OPTION_REFINERS","initialView","optionRefiners","views","timeGrid","usesMinMaxTime","timeGridDay","days","timeGridWeek","weeks"],"mappings":"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","file":"js/chunk-0b55807a.8431c9aa.js","sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","/*!\nFullCalendar v5.6.0\nDocs & License: https://fullcalendar.io/\n(c) 2020 Adam Shaw\n*/\nimport './main.css';\n\nimport { hasBgRendering, Splitter, createFormatter, createElement, ViewContextType, RenderHook, BaseComponent, createRef, diffDays, buildNavLinkData, WeekNumberRoot, getStickyHeaderDates, ViewRoot, SimpleScrollGrid, getStickyFooterScrollbar, NowTimer, NowIndicatorRoot, DateComponent, renderScrollShim, rangeContainsMarker, startOfDay, asRoughMs, createDuration, RefMap, PositionCache, sortEventSegs, compareByFieldSpecs, buildSegCompareObj, StandardEvent, DayCellContent, config, DayCellRoot, getSegMeta, buildEventRangeKey, BgEvent, renderFill, Fragment, memoize, addDurations, multiplyDuration, wholeDivideDurations, intersectRanges, Slicer, formatIsoTimeString, DayHeader, DaySeriesModel, DayTableModel, createPlugin } from '@fullcalendar/common';\nimport { __extends, __assign } from 'tslib';\nimport { DayTable } from '@fullcalendar/daygrid';\n\nvar AllDaySplitter = /** @class */ (function (_super) {\n    __extends(AllDaySplitter, _super);\n    function AllDaySplitter() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    AllDaySplitter.prototype.getKeyInfo = function () {\n        return {\n            allDay: {},\n            timed: {},\n        };\n    };\n    AllDaySplitter.prototype.getKeysForDateSpan = function (dateSpan) {\n        if (dateSpan.allDay) {\n            return ['allDay'];\n        }\n        return ['timed'];\n    };\n    AllDaySplitter.prototype.getKeysForEventDef = function (eventDef) {\n        if (!eventDef.allDay) {\n            return ['timed'];\n        }\n        if (hasBgRendering(eventDef)) {\n            return ['timed', 'allDay'];\n        }\n        return ['allDay'];\n    };\n    return AllDaySplitter;\n}(Splitter));\n\nvar DEFAULT_SLAT_LABEL_FORMAT = createFormatter({\n    hour: 'numeric',\n    minute: '2-digit',\n    omitZeroMinute: true,\n    meridiem: 'short',\n});\nfunction TimeColsAxisCell(props) {\n    var classNames = [\n        'fc-timegrid-slot',\n        'fc-timegrid-slot-label',\n        props.isLabeled ? 'fc-scrollgrid-shrink' : 'fc-timegrid-slot-minor',\n    ];\n    return (createElement(ViewContextType.Consumer, null, function (context) {\n        if (!props.isLabeled) {\n            return (createElement(\"td\", { className: classNames.join(' '), \"data-time\": props.isoTimeStr }));\n        }\n        var dateEnv = context.dateEnv, options = context.options, viewApi = context.viewApi;\n        var labelFormat = // TODO: fully pre-parse\n         options.slotLabelFormat == null ? DEFAULT_SLAT_LABEL_FORMAT :\n            Array.isArray(options.slotLabelFormat) ? createFormatter(options.slotLabelFormat[0]) :\n                createFormatter(options.slotLabelFormat);\n        var hookProps = {\n            level: 0,\n            time: props.time,\n            date: dateEnv.toDate(props.date),\n            view: viewApi,\n            text: dateEnv.format(props.date, labelFormat),\n        };\n        return (createElement(RenderHook, { hookProps: hookProps, classNames: options.slotLabelClassNames, content: options.slotLabelContent, defaultContent: renderInnerContent, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, function (rootElRef, customClassNames, innerElRef, innerContent) { return (createElement(\"td\", { ref: rootElRef, className: classNames.concat(customClassNames).join(' '), \"data-time\": props.isoTimeStr },\n            createElement(\"div\", { className: \"fc-timegrid-slot-label-frame fc-scrollgrid-shrink-frame\" },\n                createElement(\"div\", { className: \"fc-timegrid-slot-label-cushion fc-scrollgrid-shrink-cushion\", ref: innerElRef }, innerContent)))); }));\n    }));\n}\nfunction renderInnerContent(props) {\n    return props.text;\n}\n\nvar TimeBodyAxis = /** @class */ (function (_super) {\n    __extends(TimeBodyAxis, _super);\n    function TimeBodyAxis() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    TimeBodyAxis.prototype.render = function () {\n        return this.props.slatMetas.map(function (slatMeta) { return (createElement(\"tr\", { key: slatMeta.key },\n            createElement(TimeColsAxisCell, __assign({}, slatMeta)))); });\n    };\n    return TimeBodyAxis;\n}(BaseComponent));\n\nvar DEFAULT_WEEK_NUM_FORMAT = createFormatter({ week: 'short' });\nvar AUTO_ALL_DAY_MAX_EVENT_ROWS = 5;\nvar TimeColsView = /** @class */ (function (_super) {\n    __extends(TimeColsView, _super);\n    function TimeColsView() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.allDaySplitter = new AllDaySplitter(); // for use by subclasses\n        _this.headerElRef = createRef();\n        _this.rootElRef = createRef();\n        _this.scrollerElRef = createRef();\n        _this.state = {\n            slatCoords: null,\n        };\n        _this.handleScrollTopRequest = function (scrollTop) {\n            var scrollerEl = _this.scrollerElRef.current;\n            if (scrollerEl) { // TODO: not sure how this could ever be null. weirdness with the reducer\n                scrollerEl.scrollTop = scrollTop;\n            }\n        };\n        /* Header Render Methods\n        ------------------------------------------------------------------------------------------------------------------*/\n        _this.renderHeadAxis = function (rowKey, frameHeight) {\n            if (frameHeight === void 0) { frameHeight = ''; }\n            var options = _this.context.options;\n            var dateProfile = _this.props.dateProfile;\n            var range = dateProfile.renderRange;\n            var dayCnt = diffDays(range.start, range.end);\n            var navLinkAttrs = (options.navLinks && dayCnt === 1) // only do in day views (to avoid doing in week views that dont need it)\n                ? { 'data-navlink': buildNavLinkData(range.start, 'week'), tabIndex: 0 }\n                : {};\n            if (options.weekNumbers && rowKey === 'day') {\n                return (createElement(WeekNumberRoot, { date: range.start, defaultFormat: DEFAULT_WEEK_NUM_FORMAT }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement(\"th\", { ref: rootElRef, className: [\n                        'fc-timegrid-axis',\n                        'fc-scrollgrid-shrink',\n                    ].concat(classNames).join(' ') },\n                    createElement(\"div\", { className: \"fc-timegrid-axis-frame fc-scrollgrid-shrink-frame fc-timegrid-axis-frame-liquid\", style: { height: frameHeight } },\n                        createElement(\"a\", __assign({ ref: innerElRef, className: \"fc-timegrid-axis-cushion fc-scrollgrid-shrink-cushion fc-scrollgrid-sync-inner\" }, navLinkAttrs), innerContent)))); }));\n            }\n            return (createElement(\"th\", { className: \"fc-timegrid-axis\" },\n                createElement(\"div\", { className: \"fc-timegrid-axis-frame\", style: { height: frameHeight } })));\n        };\n        /* Table Component Render Methods\n        ------------------------------------------------------------------------------------------------------------------*/\n        // only a one-way height sync. we don't send the axis inner-content height to the DayGrid,\n        // but DayGrid still needs to have classNames on inner elements in order to measure.\n        _this.renderTableRowAxis = function (rowHeight) {\n            var _a = _this.context, options = _a.options, viewApi = _a.viewApi;\n            var hookProps = {\n                text: options.allDayText,\n                view: viewApi,\n            };\n            return (\n            // TODO: make reusable hook. used in list view too\n            createElement(RenderHook, { hookProps: hookProps, classNames: options.allDayClassNames, content: options.allDayContent, defaultContent: renderAllDayInner, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement(\"td\", { ref: rootElRef, className: [\n                    'fc-timegrid-axis',\n                    'fc-scrollgrid-shrink',\n                ].concat(classNames).join(' ') },\n                createElement(\"div\", { className: 'fc-timegrid-axis-frame fc-scrollgrid-shrink-frame' + (rowHeight == null ? ' fc-timegrid-axis-frame-liquid' : ''), style: { height: rowHeight } },\n                    createElement(\"span\", { className: \"fc-timegrid-axis-cushion fc-scrollgrid-shrink-cushion fc-scrollgrid-sync-inner\", ref: innerElRef }, innerContent)))); }));\n        };\n        _this.handleSlatCoords = function (slatCoords) {\n            _this.setState({ slatCoords: slatCoords });\n        };\n        return _this;\n    }\n    // rendering\n    // ----------------------------------------------------------------------------------------------------\n    TimeColsView.prototype.renderSimpleLayout = function (headerRowContent, allDayContent, timeContent) {\n        var _a = this, context = _a.context, props = _a.props;\n        var sections = [];\n        var stickyHeaderDates = getStickyHeaderDates(context.options);\n        if (headerRowContent) {\n            sections.push({\n                type: 'header',\n                key: 'header',\n                isSticky: stickyHeaderDates,\n                chunk: {\n                    elRef: this.headerElRef,\n                    tableClassName: 'fc-col-header',\n                    rowContent: headerRowContent,\n                },\n            });\n        }\n        if (allDayContent) {\n            sections.push({\n                type: 'body',\n                key: 'all-day',\n                chunk: { content: allDayContent },\n            });\n            sections.push({\n                type: 'body',\n                key: 'all-day-divider',\n                outerContent: ( // TODO: rename to cellContent so don't need to define <tr>?\n                createElement(\"tr\", { className: \"fc-scrollgrid-section\" },\n                    createElement(\"td\", { className: 'fc-timegrid-divider ' + context.theme.getClass('tableCellShaded') }))),\n            });\n        }\n        sections.push({\n            type: 'body',\n            key: 'body',\n            liquid: true,\n            expandRows: Boolean(context.options.expandRows),\n            chunk: {\n                scrollerElRef: this.scrollerElRef,\n                content: timeContent,\n            },\n        });\n        return (createElement(ViewRoot, { viewSpec: context.viewSpec, elRef: this.rootElRef }, function (rootElRef, classNames) { return (createElement(\"div\", { className: ['fc-timegrid'].concat(classNames).join(' '), ref: rootElRef },\n            createElement(SimpleScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: props.forPrint, cols: [{ width: 'shrink' }], sections: sections }))); }));\n    };\n    TimeColsView.prototype.renderHScrollLayout = function (headerRowContent, allDayContent, timeContent, colCnt, dayMinWidth, slatMetas, slatCoords) {\n        var _this = this;\n        var ScrollGrid = this.context.pluginHooks.scrollGridImpl;\n        if (!ScrollGrid) {\n            throw new Error('No ScrollGrid implementation');\n        }\n        var _a = this, context = _a.context, props = _a.props;\n        var stickyHeaderDates = !props.forPrint && getStickyHeaderDates(context.options);\n        var stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(context.options);\n        var sections = [];\n        if (headerRowContent) {\n            sections.push({\n                type: 'header',\n                key: 'header',\n                isSticky: stickyHeaderDates,\n                syncRowHeights: true,\n                chunks: [\n                    {\n                        key: 'axis',\n                        rowContent: function (arg) { return (createElement(\"tr\", null, _this.renderHeadAxis('day', arg.rowSyncHeights[0]))); },\n                    },\n                    {\n                        key: 'cols',\n                        elRef: this.headerElRef,\n                        tableClassName: 'fc-col-header',\n                        rowContent: headerRowContent,\n                    },\n                ],\n            });\n        }\n        if (allDayContent) {\n            sections.push({\n                type: 'body',\n                key: 'all-day',\n                syncRowHeights: true,\n                chunks: [\n                    {\n                        key: 'axis',\n                        rowContent: function (contentArg) { return (createElement(\"tr\", null, _this.renderTableRowAxis(contentArg.rowSyncHeights[0]))); },\n                    },\n                    {\n                        key: 'cols',\n                        content: allDayContent,\n                    },\n                ],\n            });\n            sections.push({\n                key: 'all-day-divider',\n                type: 'body',\n                outerContent: ( // TODO: rename to cellContent so don't need to define <tr>?\n                createElement(\"tr\", { className: \"fc-scrollgrid-section\" },\n                    createElement(\"td\", { colSpan: 2, className: 'fc-timegrid-divider ' + context.theme.getClass('tableCellShaded') }))),\n            });\n        }\n        var isNowIndicator = context.options.nowIndicator;\n        sections.push({\n            type: 'body',\n            key: 'body',\n            liquid: true,\n            expandRows: Boolean(context.options.expandRows),\n            chunks: [\n                {\n                    key: 'axis',\n                    content: function (arg) { return (\n                    // TODO: make this now-indicator arrow more DRY with TimeColsContent\n                    createElement(\"div\", { className: \"fc-timegrid-axis-chunk\" },\n                        createElement(\"table\", { style: { height: arg.expandRows ? arg.clientHeight : '' } },\n                            arg.tableColGroupNode,\n                            createElement(\"tbody\", null,\n                                createElement(TimeBodyAxis, { slatMetas: slatMetas }))),\n                        createElement(\"div\", { className: \"fc-timegrid-now-indicator-container\" },\n                            createElement(NowTimer, { unit: isNowIndicator ? 'minute' : 'day' /* hacky */ }, function (nowDate) {\n                                var nowIndicatorTop = isNowIndicator &&\n                                    slatCoords &&\n                                    slatCoords.safeComputeTop(nowDate); // might return void\n                                if (typeof nowIndicatorTop === 'number') {\n                                    return (createElement(NowIndicatorRoot, { isAxis: true, date: nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement(\"div\", { ref: rootElRef, className: ['fc-timegrid-now-indicator-arrow'].concat(classNames).join(' '), style: { top: nowIndicatorTop } }, innerContent)); }));\n                                }\n                                return null;\n                            })))); },\n                },\n                {\n                    key: 'cols',\n                    scrollerElRef: this.scrollerElRef,\n                    content: timeContent,\n                },\n            ],\n        });\n        if (stickyFooterScrollbar) {\n            sections.push({\n                key: 'footer',\n                type: 'footer',\n                isSticky: true,\n                chunks: [\n                    {\n                        key: 'axis',\n                        content: renderScrollShim,\n                    },\n                    {\n                        key: 'cols',\n                        content: renderScrollShim,\n                    },\n                ],\n            });\n        }\n        return (createElement(ViewRoot, { viewSpec: context.viewSpec, elRef: this.rootElRef }, function (rootElRef, classNames) { return (createElement(\"div\", { className: ['fc-timegrid'].concat(classNames).join(' '), ref: rootElRef },\n            createElement(ScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: false, colGroups: [\n                    { width: 'shrink', cols: [{ width: 'shrink' }] },\n                    { cols: [{ span: colCnt, minWidth: dayMinWidth }] },\n                ], sections: sections }))); }));\n    };\n    /* Dimensions\n    ------------------------------------------------------------------------------------------------------------------*/\n    TimeColsView.prototype.getAllDayMaxEventProps = function () {\n        var _a = this.context.options, dayMaxEvents = _a.dayMaxEvents, dayMaxEventRows = _a.dayMaxEventRows;\n        if (dayMaxEvents === true || dayMaxEventRows === true) { // is auto?\n            dayMaxEvents = undefined;\n            dayMaxEventRows = AUTO_ALL_DAY_MAX_EVENT_ROWS; // make sure \"auto\" goes to a real number\n        }\n        return { dayMaxEvents: dayMaxEvents, dayMaxEventRows: dayMaxEventRows };\n    };\n    return TimeColsView;\n}(DateComponent));\nfunction renderAllDayInner(hookProps) {\n    return hookProps.text;\n}\n\nvar TimeColsSlatsCoords = /** @class */ (function () {\n    function TimeColsSlatsCoords(positions, dateProfile, slotDuration) {\n        this.positions = positions;\n        this.dateProfile = dateProfile;\n        this.slotDuration = slotDuration;\n    }\n    TimeColsSlatsCoords.prototype.safeComputeTop = function (date) {\n        var dateProfile = this.dateProfile;\n        if (rangeContainsMarker(dateProfile.currentRange, date)) {\n            var startOfDayDate = startOfDay(date);\n            var timeMs = date.valueOf() - startOfDayDate.valueOf();\n            if (timeMs >= asRoughMs(dateProfile.slotMinTime) &&\n                timeMs < asRoughMs(dateProfile.slotMaxTime)) {\n                return this.computeTimeTop(createDuration(timeMs));\n            }\n        }\n        return null;\n    };\n    // Computes the top coordinate, relative to the bounds of the grid, of the given date.\n    // A `startOfDayDate` must be given for avoiding ambiguity over how to treat midnight.\n    TimeColsSlatsCoords.prototype.computeDateTop = function (when, startOfDayDate) {\n        if (!startOfDayDate) {\n            startOfDayDate = startOfDay(when);\n        }\n        return this.computeTimeTop(createDuration(when.valueOf() - startOfDayDate.valueOf()));\n    };\n    // Computes the top coordinate, relative to the bounds of the grid, of the given time (a Duration).\n    // This is a makeshify way to compute the time-top. Assumes all slatMetas dates are uniform.\n    // Eventually allow computation with arbirary slat dates.\n    TimeColsSlatsCoords.prototype.computeTimeTop = function (duration) {\n        var _a = this, positions = _a.positions, dateProfile = _a.dateProfile;\n        var len = positions.els.length;\n        // floating-point value of # of slots covered\n        var slatCoverage = (duration.milliseconds - asRoughMs(dateProfile.slotMinTime)) / asRoughMs(this.slotDuration);\n        var slatIndex;\n        var slatRemainder;\n        // compute a floating-point number for how many slats should be progressed through.\n        // from 0 to number of slats (inclusive)\n        // constrained because slotMinTime/slotMaxTime might be customized.\n        slatCoverage = Math.max(0, slatCoverage);\n        slatCoverage = Math.min(len, slatCoverage);\n        // an integer index of the furthest whole slat\n        // from 0 to number slats (*exclusive*, so len-1)\n        slatIndex = Math.floor(slatCoverage);\n        slatIndex = Math.min(slatIndex, len - 1);\n        // how much further through the slatIndex slat (from 0.0-1.0) must be covered in addition.\n        // could be 1.0 if slatCoverage is covering *all* the slots\n        slatRemainder = slatCoverage - slatIndex;\n        return positions.tops[slatIndex] +\n            positions.getHeight(slatIndex) * slatRemainder;\n    };\n    return TimeColsSlatsCoords;\n}());\n\nvar TimeColsSlatsBody = /** @class */ (function (_super) {\n    __extends(TimeColsSlatsBody, _super);\n    function TimeColsSlatsBody() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    TimeColsSlatsBody.prototype.render = function () {\n        var _a = this, props = _a.props, context = _a.context;\n        var options = context.options;\n        var slatElRefs = props.slatElRefs;\n        return (createElement(\"tbody\", null, props.slatMetas.map(function (slatMeta, i) {\n            var hookProps = {\n                time: slatMeta.time,\n                date: context.dateEnv.toDate(slatMeta.date),\n                view: context.viewApi,\n            };\n            var classNames = [\n                'fc-timegrid-slot',\n                'fc-timegrid-slot-lane',\n                slatMeta.isLabeled ? '' : 'fc-timegrid-slot-minor',\n            ];\n            return (createElement(\"tr\", { key: slatMeta.key, ref: slatElRefs.createRef(slatMeta.key) },\n                props.axis && (createElement(TimeColsAxisCell, __assign({}, slatMeta))),\n                createElement(RenderHook, { hookProps: hookProps, classNames: options.slotLaneClassNames, content: options.slotLaneContent, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount }, function (rootElRef, customClassNames, innerElRef, innerContent) { return (createElement(\"td\", { ref: rootElRef, className: classNames.concat(customClassNames).join(' '), \"data-time\": slatMeta.isoTimeStr }, innerContent)); })));\n        })));\n    };\n    return TimeColsSlatsBody;\n}(BaseComponent));\n\n/*\nfor the horizontal \"slats\" that run width-wise. Has a time axis on a side. Depends on RTL.\n*/\nvar TimeColsSlats = /** @class */ (function (_super) {\n    __extends(TimeColsSlats, _super);\n    function TimeColsSlats() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.rootElRef = createRef();\n        _this.slatElRefs = new RefMap();\n        return _this;\n    }\n    TimeColsSlats.prototype.render = function () {\n        var _a = this, props = _a.props, context = _a.context;\n        return (createElement(\"div\", { className: \"fc-timegrid-slots\", ref: this.rootElRef },\n            createElement(\"table\", { className: context.theme.getClass('table'), style: {\n                    minWidth: props.tableMinWidth,\n                    width: props.clientWidth,\n                    height: props.minHeight,\n                } },\n                props.tableColGroupNode /* relies on there only being a single <col> for the axis */,\n                createElement(TimeColsSlatsBody, { slatElRefs: this.slatElRefs, axis: props.axis, slatMetas: props.slatMetas }))));\n    };\n    TimeColsSlats.prototype.componentDidMount = function () {\n        this.updateSizing();\n    };\n    TimeColsSlats.prototype.componentDidUpdate = function () {\n        this.updateSizing();\n    };\n    TimeColsSlats.prototype.componentWillUnmount = function () {\n        if (this.props.onCoords) {\n            this.props.onCoords(null);\n        }\n    };\n    TimeColsSlats.prototype.updateSizing = function () {\n        var _a = this, context = _a.context, props = _a.props;\n        if (props.onCoords &&\n            props.clientWidth !== null // means sizing has stabilized\n        ) {\n            var rootEl = this.rootElRef.current;\n            if (rootEl.offsetHeight) { // not hidden by css\n                props.onCoords(new TimeColsSlatsCoords(new PositionCache(this.rootElRef.current, collectSlatEls(this.slatElRefs.currentMap, props.slatMetas), false, true), this.props.dateProfile, context.options.slotDuration));\n            }\n        }\n    };\n    return TimeColsSlats;\n}(BaseComponent));\nfunction collectSlatEls(elMap, slatMetas) {\n    return slatMetas.map(function (slatMeta) { return elMap[slatMeta.key]; });\n}\n\nfunction splitSegsByCol(segs, colCnt) {\n    var segsByCol = [];\n    var i;\n    for (i = 0; i < colCnt; i += 1) {\n        segsByCol.push([]);\n    }\n    if (segs) {\n        for (i = 0; i < segs.length; i += 1) {\n            segsByCol[segs[i].col].push(segs[i]);\n        }\n    }\n    return segsByCol;\n}\nfunction splitInteractionByCol(ui, colCnt) {\n    var byRow = [];\n    if (!ui) {\n        for (var i = 0; i < colCnt; i += 1) {\n            byRow[i] = null;\n        }\n    }\n    else {\n        for (var i = 0; i < colCnt; i += 1) {\n            byRow[i] = {\n                affectedInstances: ui.affectedInstances,\n                isEvent: ui.isEvent,\n                segs: [],\n            };\n        }\n        for (var _i = 0, _a = ui.segs; _i < _a.length; _i++) {\n            var seg = _a[_i];\n            byRow[seg.col].segs.push(seg);\n        }\n    }\n    return byRow;\n}\n\n// UNFORTUNATELY, assigns results to the top/bottom/level/forwardCoord/backwardCoord props of the actual segs.\n// TODO: return hash (by instanceId) of results\nfunction computeSegCoords(segs, dayDate, slatCoords, eventMinHeight, eventOrderSpecs) {\n    computeSegVerticals(segs, dayDate, slatCoords, eventMinHeight);\n    return computeSegHorizontals(segs, eventOrderSpecs); // requires top/bottom from computeSegVerticals\n}\n// For each segment in an array, computes and assigns its top and bottom properties\nfunction computeSegVerticals(segs, dayDate, slatCoords, eventMinHeight) {\n    for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {\n        var seg = segs_1[_i];\n        seg.top = slatCoords.computeDateTop(seg.start, dayDate);\n        seg.bottom = Math.max(seg.top + (eventMinHeight || 0), // yuck\n        slatCoords.computeDateTop(seg.end, dayDate));\n    }\n}\n// Given an array of segments that are all in the same column, sets the backwardCoord and forwardCoord on each.\n// Assumed the segs are already ordered.\n// NOTE: Also reorders the given array by date!\nfunction computeSegHorizontals(segs, eventOrderSpecs) {\n    // IMPORTANT TO CLEAR OLD RESULTS :(\n    for (var _i = 0, segs_2 = segs; _i < segs_2.length; _i++) {\n        var seg = segs_2[_i];\n        seg.level = null;\n        seg.forwardCoord = null;\n        seg.backwardCoord = null;\n        seg.forwardPressure = null;\n    }\n    segs = sortEventSegs(segs, eventOrderSpecs);\n    var level0;\n    var levels = buildSlotSegLevels(segs);\n    computeForwardSlotSegs(levels);\n    if ((level0 = levels[0])) {\n        for (var _a = 0, level0_1 = level0; _a < level0_1.length; _a++) {\n            var seg = level0_1[_a];\n            computeSlotSegPressures(seg);\n        }\n        for (var _b = 0, level0_2 = level0; _b < level0_2.length; _b++) {\n            var seg = level0_2[_b];\n            computeSegForwardBack(seg, 0, 0, eventOrderSpecs);\n        }\n    }\n    return segs;\n}\n// Builds an array of segments \"levels\". The first level will be the leftmost tier of segments if the calendar is\n// left-to-right, or the rightmost if the calendar is right-to-left. Assumes the segments are already ordered by date.\nfunction buildSlotSegLevels(segs) {\n    var levels = [];\n    var i;\n    var seg;\n    var j;\n    for (i = 0; i < segs.length; i += 1) {\n        seg = segs[i];\n        // go through all the levels and stop on the first level where there are no collisions\n        for (j = 0; j < levels.length; j += 1) {\n            if (!computeSlotSegCollisions(seg, levels[j]).length) {\n                break;\n            }\n        }\n        seg.level = j;\n        (levels[j] || (levels[j] = [])).push(seg);\n    }\n    return levels;\n}\n// Find all the segments in `otherSegs` that vertically collide with `seg`.\n// Append into an optionally-supplied `results` array and return.\nfunction computeSlotSegCollisions(seg, otherSegs, results) {\n    if (results === void 0) { results = []; }\n    for (var i = 0; i < otherSegs.length; i += 1) {\n        if (isSlotSegCollision(seg, otherSegs[i])) {\n            results.push(otherSegs[i]);\n        }\n    }\n    return results;\n}\n// Do these segments occupy the same vertical space?\nfunction isSlotSegCollision(seg1, seg2) {\n    return seg1.bottom > seg2.top && seg1.top < seg2.bottom;\n}\n// For every segment, figure out the other segments that are in subsequent\n// levels that also occupy the same vertical space. Accumulate in seg.forwardSegs\nfunction computeForwardSlotSegs(levels) {\n    var i;\n    var level;\n    var j;\n    var seg;\n    var k;\n    for (i = 0; i < levels.length; i += 1) {\n        level = levels[i];\n        for (j = 0; j < level.length; j += 1) {\n            seg = level[j];\n            seg.forwardSegs = [];\n            for (k = i + 1; k < levels.length; k += 1) {\n                computeSlotSegCollisions(seg, levels[k], seg.forwardSegs);\n            }\n        }\n    }\n}\n// Figure out which path forward (via seg.forwardSegs) results in the longest path until\n// the furthest edge is reached. The number of segments in this path will be seg.forwardPressure\nfunction computeSlotSegPressures(seg) {\n    var forwardSegs = seg.forwardSegs;\n    var forwardPressure = 0;\n    var i;\n    var forwardSeg;\n    if (seg.forwardPressure == null) { // not already computed\n        for (i = 0; i < forwardSegs.length; i += 1) {\n            forwardSeg = forwardSegs[i];\n            // figure out the child's maximum forward path\n            computeSlotSegPressures(forwardSeg);\n            // either use the existing maximum, or use the child's forward pressure\n            // plus one (for the forwardSeg itself)\n            forwardPressure = Math.max(forwardPressure, 1 + forwardSeg.forwardPressure);\n        }\n        seg.forwardPressure = forwardPressure;\n    }\n}\n// Calculate seg.forwardCoord and seg.backwardCoord for the segment, where both values range\n// from 0 to 1. If the calendar is left-to-right, the seg.backwardCoord maps to \"left\" and\n// seg.forwardCoord maps to \"right\" (via percentage). Vice-versa if the calendar is right-to-left.\n//\n// The segment might be part of a \"series\", which means consecutive segments with the same pressure\n// who's width is unknown until an edge has been hit. `seriesBackwardPressure` is the number of\n// segments behind this one in the current series, and `seriesBackwardCoord` is the starting\n// coordinate of the first segment in the series.\nfunction computeSegForwardBack(seg, seriesBackwardPressure, seriesBackwardCoord, eventOrderSpecs) {\n    var forwardSegs = seg.forwardSegs;\n    var i;\n    if (seg.forwardCoord == null) { // not already computed\n        if (!forwardSegs.length) {\n            // if there are no forward segments, this segment should butt up against the edge\n            seg.forwardCoord = 1;\n        }\n        else {\n            // sort highest pressure first\n            sortForwardSegs(forwardSegs, eventOrderSpecs);\n            // this segment's forwardCoord will be calculated from the backwardCoord of the\n            // highest-pressure forward segment.\n            computeSegForwardBack(forwardSegs[0], seriesBackwardPressure + 1, seriesBackwardCoord, eventOrderSpecs);\n            seg.forwardCoord = forwardSegs[0].backwardCoord;\n        }\n        // calculate the backwardCoord from the forwardCoord. consider the series\n        seg.backwardCoord = seg.forwardCoord -\n            (seg.forwardCoord - seriesBackwardCoord) / // available width for series\n                (seriesBackwardPressure + 1); // # of segments in the series\n        // use this segment's coordinates to computed the coordinates of the less-pressurized\n        // forward segments\n        for (i = 0; i < forwardSegs.length; i += 1) {\n            computeSegForwardBack(forwardSegs[i], 0, seg.forwardCoord, eventOrderSpecs);\n        }\n    }\n}\nfunction sortForwardSegs(forwardSegs, eventOrderSpecs) {\n    var objs = forwardSegs.map(buildTimeGridSegCompareObj);\n    var specs = [\n        // put higher-pressure first\n        { field: 'forwardPressure', order: -1 },\n        // put segments that are closer to initial edge first (and favor ones with no coords yet)\n        { field: 'backwardCoord', order: 1 },\n    ].concat(eventOrderSpecs);\n    objs.sort(function (obj0, obj1) { return compareByFieldSpecs(obj0, obj1, specs); });\n    return objs.map(function (c) { return c._seg; });\n}\nfunction buildTimeGridSegCompareObj(seg) {\n    var obj = buildSegCompareObj(seg);\n    obj.forwardPressure = seg.forwardPressure;\n    obj.backwardCoord = seg.backwardCoord;\n    return obj;\n}\n\nvar DEFAULT_TIME_FORMAT = createFormatter({\n    hour: 'numeric',\n    minute: '2-digit',\n    meridiem: false,\n});\nvar TimeColEvent = /** @class */ (function (_super) {\n    __extends(TimeColEvent, _super);\n    function TimeColEvent() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    TimeColEvent.prototype.render = function () {\n        var classNames = [\n            'fc-timegrid-event',\n            'fc-v-event',\n        ];\n        if (this.props.isCondensed) {\n            classNames.push('fc-timegrid-event-condensed');\n        }\n        return (createElement(StandardEvent, __assign({}, this.props, { defaultTimeFormat: DEFAULT_TIME_FORMAT, extraClassNames: classNames })));\n    };\n    return TimeColEvent;\n}(BaseComponent));\n\nvar TimeColMisc = /** @class */ (function (_super) {\n    __extends(TimeColMisc, _super);\n    function TimeColMisc() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    TimeColMisc.prototype.render = function () {\n        var props = this.props;\n        return (createElement(DayCellContent, { date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraHookProps: props.extraHookProps }, function (innerElRef, innerContent) { return (innerContent &&\n            createElement(\"div\", { className: \"fc-timegrid-col-misc\", ref: innerElRef }, innerContent)); }));\n    };\n    return TimeColMisc;\n}(BaseComponent));\n\nconfig.timeGridEventCondensedHeight = 30;\nvar TimeCol = /** @class */ (function (_super) {\n    __extends(TimeCol, _super);\n    function TimeCol() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    TimeCol.prototype.render = function () {\n        var _this = this;\n        var _a = this, props = _a.props, context = _a.context;\n        var isSelectMirror = context.options.selectMirror;\n        var mirrorSegs = (props.eventDrag && props.eventDrag.segs) ||\n            (props.eventResize && props.eventResize.segs) ||\n            (isSelectMirror && props.dateSelectionSegs) ||\n            [];\n        var interactionAffectedInstances = // TODO: messy way to compute this\n         (props.eventDrag && props.eventDrag.affectedInstances) ||\n            (props.eventResize && props.eventResize.affectedInstances) ||\n            {};\n        return (createElement(DayCellRoot, { elRef: props.elRef, date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraHookProps: props.extraHookProps }, function (rootElRef, classNames, dataAttrs) { return (createElement(\"td\", __assign({ ref: rootElRef, className: ['fc-timegrid-col'].concat(classNames, props.extraClassNames || []).join(' ') }, dataAttrs, props.extraDataAttrs),\n            createElement(\"div\", { className: \"fc-timegrid-col-frame\" },\n                createElement(\"div\", { className: \"fc-timegrid-col-bg\" },\n                    _this.renderFillSegs(props.businessHourSegs, 'non-business'),\n                    _this.renderFillSegs(props.bgEventSegs, 'bg-event'),\n                    _this.renderFillSegs(props.dateSelectionSegs, 'highlight')),\n                createElement(\"div\", { className: \"fc-timegrid-col-events\" }, _this.renderFgSegs(props.fgEventSegs, interactionAffectedInstances)),\n                createElement(\"div\", { className: \"fc-timegrid-col-events\" }, _this.renderFgSegs(mirrorSegs, {}, Boolean(props.eventDrag), Boolean(props.eventResize), Boolean(isSelectMirror))),\n                createElement(\"div\", { className: \"fc-timegrid-now-indicator-container\" }, _this.renderNowIndicator(props.nowIndicatorSegs)),\n                createElement(TimeColMisc, { date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraHookProps: props.extraHookProps })))); }));\n    };\n    TimeCol.prototype.renderFgSegs = function (segs, segIsInvisible, isDragging, isResizing, isDateSelecting) {\n        var props = this.props;\n        if (props.forPrint) {\n            return this.renderPrintFgSegs(segs);\n        }\n        if (props.slatCoords) {\n            return this.renderPositionedFgSegs(segs, segIsInvisible, isDragging, isResizing, isDateSelecting);\n        }\n        return null;\n    };\n    TimeCol.prototype.renderPrintFgSegs = function (segs) {\n        var _a = this, props = _a.props, context = _a.context;\n        // not DRY\n        segs = sortEventSegs(segs, context.options.eventOrder);\n        return segs.map(function (seg) { return (createElement(\"div\", { className: \"fc-timegrid-event-harness\", key: seg.eventRange.instance.instanceId },\n            createElement(TimeColEvent, __assign({ seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isCondensed: false }, getSegMeta(seg, props.todayRange, props.nowDate))))); });\n    };\n    TimeCol.prototype.renderPositionedFgSegs = function (segs, segIsInvisible, isDragging, isResizing, isDateSelecting) {\n        var _this = this;\n        var _a = this, context = _a.context, props = _a.props;\n        // assigns TO THE SEGS THEMSELVES\n        // also, receives resorted array\n        segs = computeSegCoords(segs, props.date, props.slatCoords, context.options.eventMinHeight, context.options.eventOrder);\n        return segs.map(function (seg) {\n            var instanceId = seg.eventRange.instance.instanceId;\n            var isMirror = isDragging || isResizing || isDateSelecting;\n            var positionCss = isMirror\n                // will span entire column width\n                // also, won't assign z-index, which is good, fc-event-mirror will overpower other harnesses\n                ? __assign({ left: 0, right: 0 }, _this.computeSegTopBottomCss(seg)) : _this.computeFgSegPositionCss(seg);\n            return (createElement(\"div\", { className: 'fc-timegrid-event-harness' + (seg.level > 0 ? ' fc-timegrid-event-harness-inset' : ''), key: instanceId, style: __assign({ visibility: segIsInvisible[instanceId] ? 'hidden' : '' }, positionCss) },\n                createElement(TimeColEvent, __assign({ seg: seg, isDragging: isDragging, isResizing: isResizing, isDateSelecting: isDateSelecting, isSelected: instanceId === props.eventSelection, isCondensed: (seg.bottom - seg.top) < config.timeGridEventCondensedHeight }, getSegMeta(seg, props.todayRange, props.nowDate)))));\n        });\n    };\n    TimeCol.prototype.renderFillSegs = function (segs, fillType) {\n        var _this = this;\n        var _a = this, context = _a.context, props = _a.props;\n        if (!props.slatCoords) {\n            return null;\n        }\n        // BAD: assigns TO THE SEGS THEMSELVES\n        computeSegVerticals(segs, props.date, props.slatCoords, context.options.eventMinHeight);\n        var children = segs.map(function (seg) { return (createElement(\"div\", { key: buildEventRangeKey(seg.eventRange), className: \"fc-timegrid-bg-harness\", style: _this.computeSegTopBottomCss(seg) }, fillType === 'bg-event' ?\n            createElement(BgEvent, __assign({ seg: seg }, getSegMeta(seg, props.todayRange, props.nowDate))) :\n            renderFill(fillType))); });\n        return createElement(Fragment, null, children);\n    };\n    TimeCol.prototype.renderNowIndicator = function (segs) {\n        var _a = this.props, slatCoords = _a.slatCoords, date = _a.date;\n        if (!slatCoords) {\n            return null;\n        }\n        return segs.map(function (seg, i) { return (createElement(NowIndicatorRoot, { isAxis: false, date: date, \n            // key doesn't matter. will only ever be one\n            key: i }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement(\"div\", { ref: rootElRef, className: ['fc-timegrid-now-indicator-line'].concat(classNames).join(' '), style: { top: slatCoords.computeDateTop(seg.start, date) } }, innerContent)); })); });\n    };\n    TimeCol.prototype.computeFgSegPositionCss = function (seg) {\n        var _a = this.context, isRtl = _a.isRtl, options = _a.options;\n        var shouldOverlap = options.slotEventOverlap;\n        var backwardCoord = seg.backwardCoord; // the left side if LTR. the right side if RTL. floating-point\n        var forwardCoord = seg.forwardCoord; // the right side if LTR. the left side if RTL. floating-point\n        var left; // amount of space from left edge, a fraction of the total width\n        var right; // amount of space from right edge, a fraction of the total width\n        if (shouldOverlap) {\n            // double the width, but don't go beyond the maximum forward coordinate (1.0)\n            forwardCoord = Math.min(1, backwardCoord + (forwardCoord - backwardCoord) * 2);\n        }\n        if (isRtl) {\n            left = 1 - forwardCoord;\n            right = backwardCoord;\n        }\n        else {\n            left = backwardCoord;\n            right = 1 - forwardCoord;\n        }\n        var props = {\n            zIndex: seg.level + 1,\n            left: left * 100 + '%',\n            right: right * 100 + '%',\n        };\n        if (shouldOverlap && seg.forwardPressure) {\n            // add padding to the edge so that forward stacked events don't cover the resizer's icon\n            props[isRtl ? 'marginLeft' : 'marginRight'] = 10 * 2; // 10 is a guesstimate of the icon's width\n        }\n        return __assign(__assign({}, props), this.computeSegTopBottomCss(seg));\n    };\n    TimeCol.prototype.computeSegTopBottomCss = function (seg) {\n        return {\n            top: seg.top,\n            bottom: -seg.bottom,\n        };\n    };\n    return TimeCol;\n}(BaseComponent));\n\nvar TimeColsContent = /** @class */ (function (_super) {\n    __extends(TimeColsContent, _super);\n    function TimeColsContent() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.splitFgEventSegs = memoize(splitSegsByCol);\n        _this.splitBgEventSegs = memoize(splitSegsByCol);\n        _this.splitBusinessHourSegs = memoize(splitSegsByCol);\n        _this.splitNowIndicatorSegs = memoize(splitSegsByCol);\n        _this.splitDateSelectionSegs = memoize(splitSegsByCol);\n        _this.splitEventDrag = memoize(splitInteractionByCol);\n        _this.splitEventResize = memoize(splitInteractionByCol);\n        _this.rootElRef = createRef();\n        _this.cellElRefs = new RefMap();\n        return _this;\n    }\n    TimeColsContent.prototype.render = function () {\n        var _this = this;\n        var _a = this, props = _a.props, context = _a.context;\n        var nowIndicatorTop = context.options.nowIndicator &&\n            props.slatCoords &&\n            props.slatCoords.safeComputeTop(props.nowDate); // might return void\n        var colCnt = props.cells.length;\n        var fgEventSegsByRow = this.splitFgEventSegs(props.fgEventSegs, colCnt);\n        var bgEventSegsByRow = this.splitBgEventSegs(props.bgEventSegs, colCnt);\n        var businessHourSegsByRow = this.splitBusinessHourSegs(props.businessHourSegs, colCnt);\n        var nowIndicatorSegsByRow = this.splitNowIndicatorSegs(props.nowIndicatorSegs, colCnt);\n        var dateSelectionSegsByRow = this.splitDateSelectionSegs(props.dateSelectionSegs, colCnt);\n        var eventDragByRow = this.splitEventDrag(props.eventDrag, colCnt);\n        var eventResizeByRow = this.splitEventResize(props.eventResize, colCnt);\n        return (createElement(\"div\", { className: \"fc-timegrid-cols\", ref: this.rootElRef },\n            createElement(\"table\", { style: {\n                    minWidth: props.tableMinWidth,\n                    width: props.clientWidth,\n                } },\n                props.tableColGroupNode,\n                createElement(\"tbody\", null,\n                    createElement(\"tr\", null,\n                        props.axis && (createElement(\"td\", { className: \"fc-timegrid-col fc-timegrid-axis\" },\n                            createElement(\"div\", { className: \"fc-timegrid-col-frame\" },\n                                createElement(\"div\", { className: \"fc-timegrid-now-indicator-container\" }, typeof nowIndicatorTop === 'number' && (createElement(NowIndicatorRoot, { isAxis: true, date: props.nowDate }, function (rootElRef, classNames, innerElRef, innerContent) { return (createElement(\"div\", { ref: rootElRef, className: ['fc-timegrid-now-indicator-arrow'].concat(classNames).join(' '), style: { top: nowIndicatorTop } }, innerContent)); })))))),\n                        props.cells.map(function (cell, i) { return (createElement(TimeCol, { key: cell.key, elRef: _this.cellElRefs.createRef(cell.key), dateProfile: props.dateProfile, date: cell.date, nowDate: props.nowDate, todayRange: props.todayRange, extraHookProps: cell.extraHookProps, extraDataAttrs: cell.extraDataAttrs, extraClassNames: cell.extraClassNames, fgEventSegs: fgEventSegsByRow[i], bgEventSegs: bgEventSegsByRow[i], businessHourSegs: businessHourSegsByRow[i], nowIndicatorSegs: nowIndicatorSegsByRow[i], dateSelectionSegs: dateSelectionSegsByRow[i], eventDrag: eventDragByRow[i], eventResize: eventResizeByRow[i], slatCoords: props.slatCoords, eventSelection: props.eventSelection, forPrint: props.forPrint })); }))))));\n    };\n    TimeColsContent.prototype.componentDidMount = function () {\n        this.updateCoords();\n    };\n    TimeColsContent.prototype.componentDidUpdate = function () {\n        this.updateCoords();\n    };\n    TimeColsContent.prototype.updateCoords = function () {\n        var props = this.props;\n        if (props.onColCoords &&\n            props.clientWidth !== null // means sizing has stabilized\n        ) {\n            props.onColCoords(new PositionCache(this.rootElRef.current, collectCellEls(this.cellElRefs.currentMap, props.cells), true, // horizontal\n            false));\n        }\n    };\n    return TimeColsContent;\n}(BaseComponent));\nfunction collectCellEls(elMap, cells) {\n    return cells.map(function (cell) { return elMap[cell.key]; });\n}\n\n/* A component that renders one or more columns of vertical time slots\n----------------------------------------------------------------------------------------------------------------------*/\nvar TimeCols = /** @class */ (function (_super) {\n    __extends(TimeCols, _super);\n    function TimeCols() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.processSlotOptions = memoize(processSlotOptions);\n        _this.state = {\n            slatCoords: null,\n        };\n        _this.handleScrollRequest = function (request) {\n            var onScrollTopRequest = _this.props.onScrollTopRequest;\n            var slatCoords = _this.state.slatCoords;\n            if (onScrollTopRequest && slatCoords) {\n                if (request.time) {\n                    var top_1 = slatCoords.computeTimeTop(request.time);\n                    top_1 = Math.ceil(top_1); // zoom can give weird floating-point values. rather scroll a little bit further\n                    if (top_1) {\n                        top_1 += 1; // to overcome top border that slots beyond the first have. looks better\n                    }\n                    onScrollTopRequest(top_1);\n                }\n                return true;\n            }\n            return false;\n        };\n        _this.handleColCoords = function (colCoords) {\n            _this.colCoords = colCoords;\n        };\n        _this.handleSlatCoords = function (slatCoords) {\n            _this.setState({ slatCoords: slatCoords });\n            if (_this.props.onSlatCoords) {\n                _this.props.onSlatCoords(slatCoords);\n            }\n        };\n        return _this;\n    }\n    TimeCols.prototype.render = function () {\n        var _a = this, props = _a.props, state = _a.state;\n        return (createElement(\"div\", { className: \"fc-timegrid-body\", ref: props.rootElRef, style: {\n                // these props are important to give this wrapper correct dimensions for interactions\n                // TODO: if we set it here, can we avoid giving to inner tables?\n                width: props.clientWidth,\n                minWidth: props.tableMinWidth,\n            } },\n            createElement(TimeColsSlats, { axis: props.axis, dateProfile: props.dateProfile, slatMetas: props.slatMetas, clientWidth: props.clientWidth, minHeight: props.expandRows ? props.clientHeight : '', tableMinWidth: props.tableMinWidth, tableColGroupNode: props.axis ? props.tableColGroupNode : null /* axis depends on the colgroup's shrinking */, onCoords: this.handleSlatCoords }),\n            createElement(TimeColsContent, { cells: props.cells, axis: props.axis, dateProfile: props.dateProfile, businessHourSegs: props.businessHourSegs, bgEventSegs: props.bgEventSegs, fgEventSegs: props.fgEventSegs, dateSelectionSegs: props.dateSelectionSegs, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, todayRange: props.todayRange, nowDate: props.nowDate, nowIndicatorSegs: props.nowIndicatorSegs, clientWidth: props.clientWidth, tableMinWidth: props.tableMinWidth, tableColGroupNode: props.tableColGroupNode, slatCoords: state.slatCoords, onColCoords: this.handleColCoords, forPrint: props.forPrint })));\n    };\n    TimeCols.prototype.componentDidMount = function () {\n        this.scrollResponder = this.context.createScrollResponder(this.handleScrollRequest);\n    };\n    TimeCols.prototype.componentDidUpdate = function (prevProps) {\n        this.scrollResponder.update(prevProps.dateProfile !== this.props.dateProfile);\n    };\n    TimeCols.prototype.componentWillUnmount = function () {\n        this.scrollResponder.detach();\n    };\n    TimeCols.prototype.positionToHit = function (positionLeft, positionTop) {\n        var _a = this.context, dateEnv = _a.dateEnv, options = _a.options;\n        var colCoords = this.colCoords;\n        var dateProfile = this.props.dateProfile;\n        var slatCoords = this.state.slatCoords;\n        var _b = this.processSlotOptions(this.props.slotDuration, options.snapDuration), snapDuration = _b.snapDuration, snapsPerSlot = _b.snapsPerSlot;\n        var colIndex = colCoords.leftToIndex(positionLeft);\n        var slatIndex = slatCoords.positions.topToIndex(positionTop);\n        if (colIndex != null && slatIndex != null) {\n            var slatTop = slatCoords.positions.tops[slatIndex];\n            var slatHeight = slatCoords.positions.getHeight(slatIndex);\n            var partial = (positionTop - slatTop) / slatHeight; // floating point number between 0 and 1\n            var localSnapIndex = Math.floor(partial * snapsPerSlot); // the snap # relative to start of slat\n            var snapIndex = slatIndex * snapsPerSlot + localSnapIndex;\n            var dayDate = this.props.cells[colIndex].date;\n            var time = addDurations(dateProfile.slotMinTime, multiplyDuration(snapDuration, snapIndex));\n            var start = dateEnv.add(dayDate, time);\n            var end = dateEnv.add(start, snapDuration);\n            return {\n                col: colIndex,\n                dateSpan: {\n                    range: { start: start, end: end },\n                    allDay: false,\n                },\n                dayEl: colCoords.els[colIndex],\n                relativeRect: {\n                    left: colCoords.lefts[colIndex],\n                    right: colCoords.rights[colIndex],\n                    top: slatTop,\n                    bottom: slatTop + slatHeight,\n                },\n            };\n        }\n        return null;\n    };\n    return TimeCols;\n}(BaseComponent));\nfunction processSlotOptions(slotDuration, snapDurationOverride) {\n    var snapDuration = snapDurationOverride || slotDuration;\n    var snapsPerSlot = wholeDivideDurations(slotDuration, snapDuration);\n    if (snapsPerSlot === null) {\n        snapDuration = slotDuration;\n        snapsPerSlot = 1;\n        // TODO: say warning?\n    }\n    return { snapDuration: snapDuration, snapsPerSlot: snapsPerSlot };\n}\n\nvar DayTimeColsSlicer = /** @class */ (function (_super) {\n    __extends(DayTimeColsSlicer, _super);\n    function DayTimeColsSlicer() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    DayTimeColsSlicer.prototype.sliceRange = function (range, dayRanges) {\n        var segs = [];\n        for (var col = 0; col < dayRanges.length; col += 1) {\n            var segRange = intersectRanges(range, dayRanges[col]);\n            if (segRange) {\n                segs.push({\n                    start: segRange.start,\n                    end: segRange.end,\n                    isStart: segRange.start.valueOf() === range.start.valueOf(),\n                    isEnd: segRange.end.valueOf() === range.end.valueOf(),\n                    col: col,\n                });\n            }\n        }\n        return segs;\n    };\n    return DayTimeColsSlicer;\n}(Slicer));\n\nvar DayTimeCols = /** @class */ (function (_super) {\n    __extends(DayTimeCols, _super);\n    function DayTimeCols() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.buildDayRanges = memoize(buildDayRanges);\n        _this.slicer = new DayTimeColsSlicer();\n        _this.timeColsRef = createRef();\n        _this.handleRootEl = function (rootEl) {\n            if (rootEl) {\n                _this.context.registerInteractiveComponent(_this, { el: rootEl });\n            }\n            else {\n                _this.context.unregisterInteractiveComponent(_this);\n            }\n        };\n        return _this;\n    }\n    DayTimeCols.prototype.render = function () {\n        var _this = this;\n        var _a = this, props = _a.props, context = _a.context;\n        var dateProfile = props.dateProfile, dayTableModel = props.dayTableModel;\n        var isNowIndicator = context.options.nowIndicator;\n        var dayRanges = this.buildDayRanges(dayTableModel, dateProfile, context.dateEnv);\n        // give it the first row of cells\n        // TODO: would move this further down hierarchy, but sliceNowDate needs it\n        return (createElement(NowTimer, { unit: isNowIndicator ? 'minute' : 'day' }, function (nowDate, todayRange) { return (createElement(TimeCols, __assign({ ref: _this.timeColsRef, rootElRef: _this.handleRootEl }, _this.slicer.sliceProps(props, dateProfile, null, context, dayRanges), { forPrint: props.forPrint, axis: props.axis, dateProfile: dateProfile, slatMetas: props.slatMetas, slotDuration: props.slotDuration, cells: dayTableModel.cells[0], tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, clientWidth: props.clientWidth, clientHeight: props.clientHeight, expandRows: props.expandRows, nowDate: nowDate, nowIndicatorSegs: isNowIndicator && _this.slicer.sliceNowDate(nowDate, context, dayRanges), todayRange: todayRange, onScrollTopRequest: props.onScrollTopRequest, onSlatCoords: props.onSlatCoords }))); }));\n    };\n    DayTimeCols.prototype.queryHit = function (positionLeft, positionTop) {\n        var rawHit = this.timeColsRef.current.positionToHit(positionLeft, positionTop);\n        if (rawHit) {\n            return {\n                component: this,\n                dateSpan: rawHit.dateSpan,\n                dayEl: rawHit.dayEl,\n                rect: {\n                    left: rawHit.relativeRect.left,\n                    right: rawHit.relativeRect.right,\n                    top: rawHit.relativeRect.top,\n                    bottom: rawHit.relativeRect.bottom,\n                },\n                layer: 0,\n            };\n        }\n        return null;\n    };\n    return DayTimeCols;\n}(DateComponent));\nfunction buildDayRanges(dayTableModel, dateProfile, dateEnv) {\n    var ranges = [];\n    for (var _i = 0, _a = dayTableModel.headerDates; _i < _a.length; _i++) {\n        var date = _a[_i];\n        ranges.push({\n            start: dateEnv.add(date, dateProfile.slotMinTime),\n            end: dateEnv.add(date, dateProfile.slotMaxTime),\n        });\n    }\n    return ranges;\n}\n\n// potential nice values for the slot-duration and interval-duration\n// from largest to smallest\nvar STOCK_SUB_DURATIONS = [\n    { hours: 1 },\n    { minutes: 30 },\n    { minutes: 15 },\n    { seconds: 30 },\n    { seconds: 15 },\n];\nfunction buildSlatMetas(slotMinTime, slotMaxTime, explicitLabelInterval, slotDuration, dateEnv) {\n    var dayStart = new Date(0);\n    var slatTime = slotMinTime;\n    var slatIterator = createDuration(0);\n    var labelInterval = explicitLabelInterval || computeLabelInterval(slotDuration);\n    var metas = [];\n    while (asRoughMs(slatTime) < asRoughMs(slotMaxTime)) {\n        var date = dateEnv.add(dayStart, slatTime);\n        var isLabeled = wholeDivideDurations(slatIterator, labelInterval) !== null;\n        metas.push({\n            date: date,\n            time: slatTime,\n            key: date.toISOString(),\n            isoTimeStr: formatIsoTimeString(date),\n            isLabeled: isLabeled,\n        });\n        slatTime = addDurations(slatTime, slotDuration);\n        slatIterator = addDurations(slatIterator, slotDuration);\n    }\n    return metas;\n}\n// Computes an automatic value for slotLabelInterval\nfunction computeLabelInterval(slotDuration) {\n    var i;\n    var labelInterval;\n    var slotsPerLabel;\n    // find the smallest stock label interval that results in more than one slots-per-label\n    for (i = STOCK_SUB_DURATIONS.length - 1; i >= 0; i -= 1) {\n        labelInterval = createDuration(STOCK_SUB_DURATIONS[i]);\n        slotsPerLabel = wholeDivideDurations(labelInterval, slotDuration);\n        if (slotsPerLabel !== null && slotsPerLabel > 1) {\n            return labelInterval;\n        }\n    }\n    return slotDuration; // fall back\n}\n\nvar DayTimeColsView = /** @class */ (function (_super) {\n    __extends(DayTimeColsView, _super);\n    function DayTimeColsView() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.buildTimeColsModel = memoize(buildTimeColsModel);\n        _this.buildSlatMetas = memoize(buildSlatMetas);\n        return _this;\n    }\n    DayTimeColsView.prototype.render = function () {\n        var _this = this;\n        var _a = this.context, options = _a.options, dateEnv = _a.dateEnv, dateProfileGenerator = _a.dateProfileGenerator;\n        var props = this.props;\n        var dateProfile = props.dateProfile;\n        var dayTableModel = this.buildTimeColsModel(dateProfile, dateProfileGenerator);\n        var splitProps = this.allDaySplitter.splitProps(props);\n        var slatMetas = this.buildSlatMetas(dateProfile.slotMinTime, dateProfile.slotMaxTime, options.slotLabelInterval, options.slotDuration, dateEnv);\n        var dayMinWidth = options.dayMinWidth;\n        var hasAttachedAxis = !dayMinWidth;\n        var hasDetachedAxis = dayMinWidth;\n        var headerContent = options.dayHeaders && (createElement(DayHeader, { dates: dayTableModel.headerDates, dateProfile: dateProfile, datesRepDistinctDays: true, renderIntro: hasAttachedAxis ? this.renderHeadAxis : null }));\n        var allDayContent = (options.allDaySlot !== false) && (function (contentArg) { return (createElement(DayTable, __assign({}, splitProps.allDay, { dateProfile: dateProfile, dayTableModel: dayTableModel, nextDayThreshold: options.nextDayThreshold, tableMinWidth: contentArg.tableMinWidth, colGroupNode: contentArg.tableColGroupNode, renderRowIntro: hasAttachedAxis ? _this.renderTableRowAxis : null, showWeekNumbers: false, expandRows: false, headerAlignElRef: _this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint }, _this.getAllDayMaxEventProps()))); });\n        var timeGridContent = function (contentArg) { return (createElement(DayTimeCols, __assign({}, splitProps.timed, { dayTableModel: dayTableModel, dateProfile: dateProfile, axis: hasAttachedAxis, slotDuration: options.slotDuration, slatMetas: slatMetas, forPrint: props.forPrint, tableColGroupNode: contentArg.tableColGroupNode, tableMinWidth: contentArg.tableMinWidth, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, onSlatCoords: _this.handleSlatCoords, expandRows: contentArg.expandRows, onScrollTopRequest: _this.handleScrollTopRequest }))); };\n        return hasDetachedAxis\n            ? this.renderHScrollLayout(headerContent, allDayContent, timeGridContent, dayTableModel.colCnt, dayMinWidth, slatMetas, this.state.slatCoords)\n            : this.renderSimpleLayout(headerContent, allDayContent, timeGridContent);\n    };\n    return DayTimeColsView;\n}(TimeColsView));\nfunction buildTimeColsModel(dateProfile, dateProfileGenerator) {\n    var daySeries = new DaySeriesModel(dateProfile.renderRange, dateProfileGenerator);\n    return new DayTableModel(daySeries, false);\n}\n\nvar OPTION_REFINERS = {\n    allDaySlot: Boolean,\n};\n\nvar main = createPlugin({\n    initialView: 'timeGridWeek',\n    optionRefiners: OPTION_REFINERS,\n    views: {\n        timeGrid: {\n            component: DayTimeColsView,\n            usesMinMaxTime: true,\n            allDaySlot: true,\n            slotDuration: '00:30:00',\n            slotEventOverlap: true,\n        },\n        timeGridDay: {\n            type: 'timeGrid',\n            duration: { days: 1 },\n        },\n        timeGridWeek: {\n            type: 'timeGrid',\n            duration: { weeks: 1 },\n        },\n    },\n});\n\nexport default main;\nexport { DayTimeCols, DayTimeColsSlicer, DayTimeColsView, TimeCols, TimeColsSlatsCoords, TimeColsView, buildDayRanges, buildSlatMetas, buildTimeColsModel };\n//# sourceMappingURL=main.js.map\n"],"sourceRoot":""}