Changeset 111041 in spip-zone


Ignore:
Timestamp:
Jul 9, 2018, 3:30:59 PM (17 months ago)
Author:
bruno@…
Message:

version 1.3.3 : maj des libs fullcalendar (3.9.0) et moment (2.22.2)

permet notamment de fixer le bug suivant https://github.com/fullcalendar/fullcalendar/issues/3856

Location:
_core_/plugins/organiseur
Files:
4 added
81 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/organiseur/lib/fullcalendar/fullcalendar.css

    r106690 r111041  
    11/*!
    2  * FullCalendar v3.5.1 Stylesheet
     2 * FullCalendar v3.9.0
    33 * Docs & License: https://fullcalendar.io/
    4  * (c) 2017 Adam Shaw
     4 * (c) 2018 Adam Shaw
    55 */
    6 
    7 
    86.fc {
    9         direction: ltr;
    10         text-align: left;
    11 }
     7  direction: ltr;
     8  text-align: left; }
    129
    1310.fc-rtl {
    14         text-align: right;
    15 }
    16 
    17 body .fc { /* extra precedence to overcome jqui */
    18         font-size: 1em;
    19 }
    20 
     11  text-align: right; }
     12
     13body .fc {
     14  /* extra precedence to overcome jqui */
     15  font-size: 1em; }
    2116
    2217/* Colors
    2318--------------------------------------------------------------------------------------------------*/
    24 
    25 
    26 .fc-highlight { /* when user is selecting cells */
    27         background: #bce8f1;
    28         opacity: .3;
    29 }
    30 
    31 .fc-bgevent { /* default look for background events */
    32         background: rgb(143, 223, 130);
    33         opacity: .3;
    34 }
    35 
    36 .fc-nonbusiness { /* default look for non-business-hours areas */
    37         /* will inherit .fc-bgevent's styles */
    38         background: #d7d7d7;
    39 }
    40 
     19.fc-highlight {
     20  /* when user is selecting cells */
     21  background: #bce8f1;
     22  opacity: .3; }
     23
     24.fc-bgevent {
     25  /* default look for background events */
     26  background: #8fdf82;
     27  opacity: .3; }
     28
     29.fc-nonbusiness {
     30  /* default look for non-business-hours areas */
     31  /* will inherit .fc-bgevent's styles */
     32  background: #d7d7d7; }
    4133
    4234/* Buttons (styled <button> tags, normalized to work cross-browser)
    4335--------------------------------------------------------------------------------------------------*/
    44 
    4536.fc button {
    46         /* force height to include the border and padding */
    47         -moz-box-sizing: border-box;
    48         -webkit-box-sizing: border-box;
    49         box-sizing: border-box;
    50 
    51         /* dimensions */
    52         margin: 0;
    53         height: 2.1em;
    54         padding: 0 .6em;
    55 
    56         /* text & cursor */
    57         font-size: 1em; /* normalize */
    58         white-space: nowrap;
    59         cursor: pointer;
    60 }
     37  /* force height to include the border and padding */
     38  -moz-box-sizing: border-box;
     39  -webkit-box-sizing: border-box;
     40  box-sizing: border-box;
     41  /* dimensions */
     42  margin: 0;
     43  height: 2.1em;
     44  padding: 0 .6em;
     45  /* text & cursor */
     46  font-size: 1em;
     47  /* normalize */
     48  white-space: nowrap;
     49  cursor: pointer; }
    6150
    6251/* Firefox has an annoying inner border */
    63 .fc button::-moz-focus-inner { margin: 0; padding: 0; }
    64        
    65 .fc-state-default { /* non-theme */
    66         border: 1px solid;
    67 }
    68 
    69 .fc-state-default.fc-corner-left { /* non-theme */
    70         border-top-left-radius: 4px;
    71         border-bottom-left-radius: 4px;
    72 }
    73 
    74 .fc-state-default.fc-corner-right { /* non-theme */
    75         border-top-right-radius: 4px;
    76         border-bottom-right-radius: 4px;
    77 }
     52.fc button::-moz-focus-inner {
     53  margin: 0;
     54  padding: 0; }
     55
     56.fc-state-default {
     57  /* non-theme */
     58  border: 1px solid; }
     59
     60.fc-state-default.fc-corner-left {
     61  /* non-theme */
     62  border-top-left-radius: 4px;
     63  border-bottom-left-radius: 4px; }
     64
     65.fc-state-default.fc-corner-right {
     66  /* non-theme */
     67  border-top-right-radius: 4px;
     68  border-bottom-right-radius: 4px; }
    7869
    7970/* icons in buttons */
    80 
    81 .fc button .fc-icon { /* non-theme */
    82         position: relative;
    83         top: -0.05em; /* seems to be a good adjustment across browsers */
    84         margin: 0 .2em;
    85         vertical-align: middle;
    86 }
    87        
     71.fc button .fc-icon {
     72  /* non-theme */
     73  position: relative;
     74  top: -0.05em;
     75  /* seems to be a good adjustment across browsers */
     76  margin: 0 .2em;
     77  vertical-align: middle; }
     78
    8879/*
    8980  button states
    9081  borrowed from twitter bootstrap (http://twitter.github.com/bootstrap/)
    9182*/
    92 
    9383.fc-state-default {
    94         background-color: #f5f5f5;
    95         background-image: -moz-linear-gradient(top, #ffffff, #e6e6e6);
    96         background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));
    97         background-image: -webkit-linear-gradient(top, #ffffff, #e6e6e6);
    98         background-image: -o-linear-gradient(top, #ffffff, #e6e6e6);
    99         background-image: linear-gradient(to bottom, #ffffff, #e6e6e6);
    100         background-repeat: repeat-x;
    101         border-color: #e6e6e6 #e6e6e6 #bfbfbf;
    102         border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
    103         color: #333;
    104         text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
    105         box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
    106 }
     84  background-color: #f5f5f5;
     85  background-image: -moz-linear-gradient(top, #ffffff, #e6e6e6);
     86  background-image: -webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));
     87  background-image: -webkit-linear-gradient(top, #ffffff, #e6e6e6);
     88  background-image: -o-linear-gradient(top, #ffffff, #e6e6e6);
     89  background-image: linear-gradient(to bottom, #ffffff, #e6e6e6);
     90  background-repeat: repeat-x;
     91  border-color: #e6e6e6 #e6e6e6 #bfbfbf;
     92  border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);
     93  color: #333;
     94  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
     95  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05); }
    10796
    10897.fc-state-hover,
     
    11099.fc-state-active,
    111100.fc-state-disabled {
    112         color: #333333;
    113         background-color: #e6e6e6;
    114 }
     101  color: #333333;
     102  background-color: #e6e6e6; }
    115103
    116104.fc-state-hover {
    117         color: #333333;
    118         text-decoration: none;
    119         background-position: 0 -15px;
    120         -webkit-transition: background-position 0.1s linear;
    121            -moz-transition: background-position 0.1s linear;
    122              -o-transition: background-position 0.1s linear;
    123                 transition: background-position 0.1s linear;
    124 }
     105  color: #333333;
     106  text-decoration: none;
     107  background-position: 0 -15px;
     108  -webkit-transition: background-position 0.1s linear;
     109  -moz-transition: background-position 0.1s linear;
     110  -o-transition: background-position 0.1s linear;
     111  transition: background-position 0.1s linear; }
    125112
    126113.fc-state-down,
    127114.fc-state-active {
    128         background-color: #cccccc;
    129         background-image: none;
    130         box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05);
    131 }
     115  background-color: #cccccc;
     116  background-image: none;
     117  box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.15), 0 1px 2px rgba(0, 0, 0, 0.05); }
    132118
    133119.fc-state-disabled {
    134         cursor: default;
    135         background-image: none;
    136         opacity: 0.65;
    137         box-shadow: none;
    138 }
    139 
     120  cursor: default;
     121  background-image: none;
     122  opacity: 0.65;
     123  box-shadow: none; }
    140124
    141125/* Buttons Groups
    142126--------------------------------------------------------------------------------------------------*/
    143 
    144127.fc-button-group {
    145         display: inline-block;
    146 }
     128  display: inline-block; }
    147129
    148130/*
     
    150132previous button's border...
    151133*/
    152 
    153 .fc .fc-button-group > * { /* extra precedence b/c buttons have margin set to zero */
    154         float: left;
    155         margin: 0 0 0 -1px;
    156 }
    157 
    158 .fc .fc-button-group > :first-child { /* same */
    159         margin-left: 0;
    160 }
    161 
     134.fc .fc-button-group > * {
     135  /* extra precedence b/c buttons have margin set to zero */
     136  float: left;
     137  margin: 0 0 0 -1px; }
     138
     139.fc .fc-button-group > :first-child {
     140  /* same */
     141  margin-left: 0; }
    162142
    163143/* Popover
    164144--------------------------------------------------------------------------------------------------*/
    165 
    166145.fc-popover {
    167         position: absolute;
    168         box-shadow: 0 2px 6px rgba(0,0,0,.15);
    169 }
    170 
    171 .fc-popover .fc-header { /* TODO: be more consistent with fc-head/fc-body */
    172         padding: 2px 4px;
    173 }
     146  position: absolute;
     147  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15); }
     148
     149.fc-popover .fc-header {
     150  /* TODO: be more consistent with fc-head/fc-body */
     151  padding: 2px 4px; }
    174152
    175153.fc-popover .fc-header .fc-title {
    176         margin: 0 2px;
    177 }
     154  margin: 0 2px; }
    178155
    179156.fc-popover .fc-header .fc-close {
    180         cursor: pointer;
    181 }
     157  cursor: pointer; }
    182158
    183159.fc-ltr .fc-popover .fc-header .fc-title,
    184160.fc-rtl .fc-popover .fc-header .fc-close {
    185         float: left;
    186 }
     161  float: left; }
    187162
    188163.fc-rtl .fc-popover .fc-header .fc-title,
    189164.fc-ltr .fc-popover .fc-header .fc-close {
    190         float: right;
    191 }
    192 
     165  float: right; }
    193166
    194167/* Misc Reusable Components
    195168--------------------------------------------------------------------------------------------------*/
    196 
    197169.fc-divider {
    198         border-style: solid;
    199         border-width: 1px;
    200 }
     170  border-style: solid;
     171  border-width: 1px; }
    201172
    202173hr.fc-divider {
    203         height: 0;
    204         margin: 0;
    205         padding: 0 0 2px; /* height is unreliable across browsers, so use padding */
    206         border-width: 1px 0;
    207 }
     174  height: 0;
     175  margin: 0;
     176  padding: 0 0 2px;
     177  /* height is unreliable across browsers, so use padding */
     178  border-width: 1px 0; }
    208179
    209180.fc-clear {
    210         clear: both;
    211 }
     181  clear: both; }
    212182
    213183.fc-bg,
     
    215185.fc-highlight-skeleton,
    216186.fc-helper-skeleton {
    217         /* these element should always cling to top-left/right corners */
    218         position: absolute;
    219         top: 0;
    220         left: 0;
    221         right: 0;
    222 }
     187  /* these element should always cling to top-left/right corners */
     188  position: absolute;
     189  top: 0;
     190  left: 0;
     191  right: 0; }
    223192
    224193.fc-bg {
    225         bottom: 0; /* strech bg to bottom edge */
    226 }
     194  bottom: 0;
     195  /* strech bg to bottom edge */ }
    227196
    228197.fc-bg table {
    229         height: 100%; /* strech bg to bottom edge */
    230 }
    231 
     198  height: 100%;
     199  /* strech bg to bottom edge */ }
    232200
    233201/* Tables
    234202--------------------------------------------------------------------------------------------------*/
    235 
    236203.fc table {
    237         width: 100%;
    238         box-sizing: border-box; /* fix scrollbar issue in firefox */
    239         table-layout: fixed;
    240         border-collapse: collapse;
    241         border-spacing: 0;
    242         font-size: 1em; /* normalize cross-browser */
    243 }
     204  width: 100%;
     205  box-sizing: border-box;
     206  /* fix scrollbar issue in firefox */
     207  table-layout: fixed;
     208  border-collapse: collapse;
     209  border-spacing: 0;
     210  font-size: 1em;
     211  /* normalize cross-browser */ }
    244212
    245213.fc th {
    246         text-align: center;
    247 }
     214  text-align: center; }
    248215
    249216.fc th,
    250217.fc td {
    251         border-style: solid;
    252         border-width: 1px;
    253         padding: 0;
    254         vertical-align: top;
    255 }
     218  border-style: solid;
     219  border-width: 1px;
     220  padding: 0;
     221  vertical-align: top; }
    256222
    257223.fc td.fc-today {
    258         border-style: double; /* overcome neighboring borders */
    259 }
    260 
     224  border-style: double;
     225  /* overcome neighboring borders */ }
    261226
    262227/* Internal Nav Links
    263228--------------------------------------------------------------------------------------------------*/
    264 
    265229a[data-goto] {
    266         cursor: pointer;
    267 }
     230  cursor: pointer; }
    268231
    269232a[data-goto]:hover {
    270         text-decoration: underline;
    271 }
    272 
     233  text-decoration: underline; }
    273234
    274235/* Fake Table Rows
    275236--------------------------------------------------------------------------------------------------*/
    276 
    277 .fc .fc-row { /* extra precedence to overcome themes w/ .ui-widget-content forcing a 1px border */
    278         /* no visible border by default. but make available if need be (scrollbar width compensation) */
    279         border-style: solid;
    280         border-width: 0;
    281 }
     237.fc .fc-row {
     238  /* extra precedence to overcome themes w/ .ui-widget-content forcing a 1px border */
     239  /* no visible border by default. but make available if need be (scrollbar width compensation) */
     240  border-style: solid;
     241  border-width: 0; }
    282242
    283243.fc-row table {
    284         /* don't put left/right border on anything within a fake row.
    285            the outer tbody will worry about this */
    286         border-left: 0 hidden transparent;
    287         border-right: 0 hidden transparent;
    288 
    289         /* no bottom borders on rows */
    290         border-bottom: 0 hidden transparent;
    291 }
     244  /* don't put left/right border on anything within a fake row.
     245     the outer tbody will worry about this */
     246  border-left: 0 hidden transparent;
     247  border-right: 0 hidden transparent;
     248  /* no bottom borders on rows */
     249  border-bottom: 0 hidden transparent; }
    292250
    293251.fc-row:first-child table {
    294         border-top: 0 hidden transparent; /* no top border on first row */
    295 }
    296 
     252  border-top: 0 hidden transparent;
     253  /* no top border on first row */ }
    297254
    298255/* Day Row (used within the header and the DayGrid)
    299256--------------------------------------------------------------------------------------------------*/
    300 
    301257.fc-row {
    302         position: relative;
    303 }
     258  position: relative; }
    304259
    305260.fc-row .fc-bg {
    306         z-index: 1;
    307 }
     261  z-index: 1; }
    308262
    309263/* highlighting cells & background event skeleton */
    310 
    311264.fc-row .fc-bgevent-skeleton,
    312265.fc-row .fc-highlight-skeleton {
    313         bottom: 0; /* stretch skeleton to bottom of row */
    314 }
     266  bottom: 0;
     267  /* stretch skeleton to bottom of row */ }
    315268
    316269.fc-row .fc-bgevent-skeleton table,
    317270.fc-row .fc-highlight-skeleton table {
    318         height: 100%; /* stretch skeleton to bottom of row */
    319 }
     271  height: 100%;
     272  /* stretch skeleton to bottom of row */ }
    320273
    321274.fc-row .fc-highlight-skeleton td,
    322275.fc-row .fc-bgevent-skeleton td {
    323         border-color: transparent;
    324 }
     276  border-color: transparent; }
    325277
    326278.fc-row .fc-bgevent-skeleton {
    327         z-index: 2;
    328 
    329 }
     279  z-index: 2; }
    330280
    331281.fc-row .fc-highlight-skeleton {
    332         z-index: 3;
    333 }
     282  z-index: 3; }
    334283
    335284/*
     
    337286temporary rendered events).
    338287*/
    339 
    340288.fc-row .fc-content-skeleton {
    341         position: relative;
    342         z-index: 4;
    343         padding-bottom: 2px; /* matches the space above the events */
    344 }
     289  position: relative;
     290  z-index: 4;
     291  padding-bottom: 2px;
     292  /* matches the space above the events */ }
    345293
    346294.fc-row .fc-helper-skeleton {
    347         z-index: 5;
    348 }
     295  z-index: 5; }
    349296
    350297.fc .fc-row .fc-content-skeleton table,
    351298.fc .fc-row .fc-content-skeleton td,
    352299.fc .fc-row .fc-helper-skeleton td {
    353         /* see-through to the background below */
    354         /* extra precedence to prevent theme-provided backgrounds */
    355         background: none; /* in case <td>s are globally styled */
    356         border-color: transparent;
    357 }
     300  /* see-through to the background below */
     301  /* extra precedence to prevent theme-provided backgrounds */
     302  background: none;
     303  /* in case <td>s are globally styled */
     304  border-color: transparent; }
    358305
    359306.fc-row .fc-content-skeleton td,
    360307.fc-row .fc-helper-skeleton td {
    361         /* don't put a border between events and/or the day number */
    362         border-bottom: 0;
    363 }
    364 
    365 .fc-row .fc-content-skeleton tbody td, /* cells with events inside (so NOT the day number cell) */
     308  /* don't put a border between events and/or the day number */
     309  border-bottom: 0; }
     310
     311.fc-row .fc-content-skeleton tbody td,
    366312.fc-row .fc-helper-skeleton tbody td {
    367         /* don't put a border between event cells */
    368         border-top: 0;
    369 }
    370 
     313  /* don't put a border between event cells */
     314  border-top: 0; }
    371315
    372316/* Scrolling Container
    373317--------------------------------------------------------------------------------------------------*/
    374 
    375318.fc-scroller {
    376         -webkit-overflow-scrolling: touch;
    377 }
     319  -webkit-overflow-scrolling: touch; }
    378320
    379321/* TODO: move to agenda/basic */
    380322.fc-scroller > .fc-day-grid,
    381323.fc-scroller > .fc-time-grid {
    382         position: relative; /* re-scope all positions */
    383         width: 100%; /* hack to force re-sizing this inner element when scrollbars appear/disappear */
    384 }
    385 
     324  position: relative;
     325  /* re-scope all positions */
     326  width: 100%;
     327  /* hack to force re-sizing this inner element when scrollbars appear/disappear */ }
    386328
    387329/* Global Event Styles
    388330--------------------------------------------------------------------------------------------------*/
    389 
    390331.fc-event {
    391         position: relative; /* for resize handle and other inner positioning */
    392         display: block; /* make the <a> tag block */
    393         font-size: .85em;
    394         line-height: 1.3;
    395         border-radius: 3px;
    396         border: 1px solid #3a87ad; /* default BORDER color */
    397 }
     332  position: relative;
     333  /* for resize handle and other inner positioning */
     334  display: block;
     335  /* make the <a> tag block */
     336  font-size: .85em;
     337  line-height: 1.3;
     338  border-radius: 3px;
     339  border: 1px solid #3a87ad;
     340  /* default BORDER color */ }
    398341
    399342.fc-event,
    400343.fc-event-dot {
    401         background-color: #3a87ad; /* default BACKGROUND color */
    402 }
     344  background-color: #3a87ad;
     345  /* default BACKGROUND color */ }
    403346
    404347.fc-event,
    405348.fc-event:hover {
    406         color: #fff; /* default TEXT color */
    407         text-decoration: none; /* if <a> has an href */
    408 }
     349  color: #fff;
     350  /* default TEXT color */
     351  text-decoration: none;
     352  /* if <a> has an href */ }
    409353
    410354.fc-event[href],
    411355.fc-event.fc-draggable {
    412         cursor: pointer; /* give events with links and draggable events a hand mouse pointer */
    413 }
    414 
    415 .fc-not-allowed, /* causes a "warning" cursor. applied on body */
    416 .fc-not-allowed .fc-event { /* to override an event's custom cursor */
    417         cursor: not-allowed;
    418 }
    419 
    420 .fc-event .fc-bg { /* the generic .fc-bg already does position */
    421         z-index: 1;
    422         background: #fff;
    423         opacity: .25;
    424 }
     356  cursor: pointer;
     357  /* give events with links and draggable events a hand mouse pointer */ }
     358
     359.fc-not-allowed,
     360.fc-not-allowed .fc-event {
     361  /* to override an event's custom cursor */
     362  cursor: not-allowed; }
     363
     364.fc-event .fc-bg {
     365  /* the generic .fc-bg already does position */
     366  z-index: 1;
     367  background: #fff;
     368  opacity: .25; }
    425369
    426370.fc-event .fc-content {
    427         position: relative;
    428         z-index: 2;
    429 }
     371  position: relative;
     372  z-index: 2; }
    430373
    431374/* resizer (cursor AND touch devices) */
    432 
    433375.fc-event .fc-resizer {
    434         position: absolute;
    435         z-index: 4;
    436 }
     376  position: absolute;
     377  z-index: 4; }
    437378
    438379/* resizer (touch devices) */
    439 
    440380.fc-event .fc-resizer {
    441         display: none;
    442 }
     381  display: none; }
    443382
    444383.fc-event.fc-allow-mouse-resize .fc-resizer,
    445384.fc-event.fc-selected .fc-resizer {
    446         /* only show when hovering or selected (with touch) */
    447         display: block;
    448 }
     385  /* only show when hovering or selected (with touch) */
     386  display: block; }
    449387
    450388/* hit area */
    451 
    452389.fc-event.fc-selected .fc-resizer:before {
    453         /* 40x40 touch area */
    454         content: "";
    455         position: absolute;
    456         z-index: 9999; /* user of this util can scope within a lower z-index */
    457         top: 50%;
    458         left: 50%;
    459         width: 40px;
    460         height: 40px;
    461         margin-left: -20px;
    462         margin-top: -20px;
    463 }
    464 
     390  /* 40x40 touch area */
     391  content: "";
     392  position: absolute;
     393  z-index: 9999;
     394  /* user of this util can scope within a lower z-index */
     395  top: 50%;
     396  left: 50%;
     397  width: 40px;
     398  height: 40px;
     399  margin-left: -20px;
     400  margin-top: -20px; }
    465401
    466402/* Event Selection (only for touch devices)
    467403--------------------------------------------------------------------------------------------------*/
    468 
    469404.fc-event.fc-selected {
    470         z-index: 9999 !important; /* overcomes inline z-index */
    471         box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
    472 }
     405  z-index: 9999 !important;
     406  /* overcomes inline z-index */
     407  box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); }
    473408
    474409.fc-event.fc-selected.fc-dragging {
    475         box-shadow: 0 2px 7px rgba(0, 0, 0, 0.3);
    476 }
    477 
     410  box-shadow: 0 2px 7px rgba(0, 0, 0, 0.3); }
    478411
    479412/* Horizontal Events
    480413--------------------------------------------------------------------------------------------------*/
    481 
    482414/* bigger touch area when selected */
    483415.fc-h-event.fc-selected:before {
    484         content: "";
    485         position: absolute;
    486         z-index: 3; /* below resizers */
    487         top: -10px;
    488         bottom: -10px;
    489         left: 0;
    490         right: 0;
    491 }
     416  content: "";
     417  position: absolute;
     418  z-index: 3;
     419  /* below resizers */
     420  top: -10px;
     421  bottom: -10px;
     422  left: 0;
     423  right: 0; }
    492424
    493425/* events that are continuing to/from another week. kill rounded corners and butt up against edge */
    494 
    495426.fc-ltr .fc-h-event.fc-not-start,
    496427.fc-rtl .fc-h-event.fc-not-end {
    497         margin-left: 0;
    498         border-left-width: 0;
    499         padding-left: 1px; /* replace the border with padding */
    500         border-top-left-radius: 0;
    501         border-bottom-left-radius: 0;
    502 }
     428  margin-left: 0;
     429  border-left-width: 0;
     430  padding-left: 1px;
     431  /* replace the border with padding */
     432  border-top-left-radius: 0;
     433  border-bottom-left-radius: 0; }
    503434
    504435.fc-ltr .fc-h-event.fc-not-end,
    505436.fc-rtl .fc-h-event.fc-not-start {
    506         margin-right: 0;
    507         border-right-width: 0;
    508         padding-right: 1px; /* replace the border with padding */
    509         border-top-right-radius: 0;
    510         border-bottom-right-radius: 0;
    511 }
     437  margin-right: 0;
     438  border-right-width: 0;
     439  padding-right: 1px;
     440  /* replace the border with padding */
     441  border-top-right-radius: 0;
     442  border-bottom-right-radius: 0; }
    512443
    513444/* resizer (cursor AND touch devices) */
    514 
    515445/* left resizer  */
    516446.fc-ltr .fc-h-event .fc-start-resizer,
    517447.fc-rtl .fc-h-event .fc-end-resizer {
    518         cursor: w-resize;
    519         left: -1px; /* overcome border */
    520 }
     448  cursor: w-resize;
     449  left: -1px;
     450  /* overcome border */ }
    521451
    522452/* right resizer */
    523453.fc-ltr .fc-h-event .fc-end-resizer,
    524454.fc-rtl .fc-h-event .fc-start-resizer {
    525         cursor: e-resize;
    526         right: -1px; /* overcome border */
    527 }
     455  cursor: e-resize;
     456  right: -1px;
     457  /* overcome border */ }
    528458
    529459/* resizer (mouse devices) */
    530 
    531460.fc-h-event.fc-allow-mouse-resize .fc-resizer {
    532         width: 7px;
    533         top: -1px; /* overcome top border */
    534         bottom: -1px; /* overcome bottom border */
    535 }
     461  width: 7px;
     462  top: -1px;
     463  /* overcome top border */
     464  bottom: -1px;
     465  /* overcome bottom border */ }
    536466
    537467/* resizer (touch devices) */
    538 
    539468.fc-h-event.fc-selected .fc-resizer {
    540         /* 8x8 little dot */
    541         border-radius: 4px;
    542         border-width: 1px;
    543         width: 6px;
    544         height: 6px;
    545         border-style: solid;
    546         border-color: inherit;
    547         background: #fff;
    548         /* vertically center */
    549         top: 50%;
    550         margin-top: -4px;
    551 }
     469  /* 8x8 little dot */
     470  border-radius: 4px;
     471  border-width: 1px;
     472  width: 6px;
     473  height: 6px;
     474  border-style: solid;
     475  border-color: inherit;
     476  background: #fff;
     477  /* vertically center */
     478  top: 50%;
     479  margin-top: -4px; }
    552480
    553481/* left resizer  */
    554482.fc-ltr .fc-h-event.fc-selected .fc-start-resizer,
    555483.fc-rtl .fc-h-event.fc-selected .fc-end-resizer {
    556         margin-left: -4px; /* centers the 8x8 dot on the left edge */
    557 }
     484  margin-left: -4px;
     485  /* centers the 8x8 dot on the left edge */ }
    558486
    559487/* right resizer */
    560488.fc-ltr .fc-h-event.fc-selected .fc-end-resizer,
    561489.fc-rtl .fc-h-event.fc-selected .fc-start-resizer {
    562         margin-right: -4px; /* centers the 8x8 dot on the right edge */
    563 }
    564 
     490  margin-right: -4px;
     491  /* centers the 8x8 dot on the right edge */ }
    565492
    566493/* DayGrid events
     
    569496be a descendant of the grid when it is being dragged.
    570497*/
    571 
    572498.fc-day-grid-event {
    573         margin: 1px 2px 0; /* spacing between events and edges */
    574         padding: 0 1px;
    575 }
     499  margin: 1px 2px 0;
     500  /* spacing between events and edges */
     501  padding: 0 1px; }
    576502
    577503tr:first-child > td > .fc-day-grid-event {
    578         margin-top: 2px; /* a little bit more space before the first event */
    579 }
     504  margin-top: 2px;
     505  /* a little bit more space before the first event */ }
    580506
    581507.fc-day-grid-event.fc-selected:after {
    582         content: "";
    583         position: absolute;
    584         z-index: 1; /* same z-index as fc-bg, behind text */
    585         /* overcome the borders */
    586         top: -1px;
    587         right: -1px;
    588         bottom: -1px;
    589         left: -1px;
    590         /* darkening effect */
    591         background: #000;
    592         opacity: .25;
    593 }
    594 
    595 .fc-day-grid-event .fc-content { /* force events to be one-line tall */
    596         white-space: nowrap;
    597         overflow: hidden;
    598 }
     508  content: "";
     509  position: absolute;
     510  z-index: 1;
     511  /* same z-index as fc-bg, behind text */
     512  /* overcome the borders */
     513  top: -1px;
     514  right: -1px;
     515  bottom: -1px;
     516  left: -1px;
     517  /* darkening effect */
     518  background: #000;
     519  opacity: .25; }
     520
     521.fc-day-grid-event .fc-content {
     522  /* force events to be one-line tall */
     523  white-space: nowrap;
     524  overflow: hidden; }
    599525
    600526.fc-day-grid-event .fc-time {
    601         font-weight: bold;
    602 }
     527  font-weight: bold; }
    603528
    604529/* resizer (cursor devices) */
    605 
    606530/* left resizer  */
    607531.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer,
    608532.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer {
    609         margin-left: -2px; /* to the day cell's edge */
    610 }
     533  margin-left: -2px;
     534  /* to the day cell's edge */ }
    611535
    612536/* right resizer */
    613537.fc-ltr .fc-day-grid-event.fc-allow-mouse-resize .fc-end-resizer,
    614538.fc-rtl .fc-day-grid-event.fc-allow-mouse-resize .fc-start-resizer {
    615         margin-right: -2px; /* to the day cell's edge */
    616 }
    617 
     539  margin-right: -2px;
     540  /* to the day cell's edge */ }
    618541
    619542/* Event Limiting
    620543--------------------------------------------------------------------------------------------------*/
    621 
    622544/* "more" link that represents hidden events */
    623 
    624545a.fc-more {
    625         margin: 1px 3px;
    626         font-size: .85em;
    627         cursor: pointer;
    628         text-decoration: none;
    629 }
     546  margin: 1px 3px;
     547  font-size: .85em;
     548  cursor: pointer;
     549  text-decoration: none; }
    630550
    631551a.fc-more:hover {
    632         text-decoration: underline;
    633 }
    634 
    635 .fc-limited { /* rows and cells that are hidden because of a "more" link */
    636         display: none;
    637 }
     552  text-decoration: underline; }
     553
     554.fc-limited {
     555  /* rows and cells that are hidden because of a "more" link */
     556  display: none; }
    638557
    639558/* popover that appears when "more" link is clicked */
    640 
    641559.fc-day-grid .fc-row {
    642         z-index: 1; /* make the "more" popover one higher than this */
    643 }
     560  z-index: 1;
     561  /* make the "more" popover one higher than this */ }
    644562
    645563.fc-more-popover {
    646         z-index: 2;
    647         width: 220px;
    648 }
     564  z-index: 2;
     565  width: 220px; }
    649566
    650567.fc-more-popover .fc-event-container {
    651         padding: 10px;
    652 }
    653 
     568  padding: 10px; }
    654569
    655570/* Now Indicator
    656571--------------------------------------------------------------------------------------------------*/
    657 
    658572.fc-now-indicator {
    659         position: absolute;
    660         border: 0 solid red;
    661 }
    662 
     573  position: absolute;
     574  border: 0 solid red; }
    663575
    664576/* Utilities
    665577--------------------------------------------------------------------------------------------------*/
    666 
    667578.fc-unselectable {
    668         -webkit-user-select: none;
    669          -khtml-user-select: none;
    670            -moz-user-select: none;
    671             -ms-user-select: none;
    672                 user-select: none;
    673         -webkit-touch-callout: none;
    674         -webkit-tap-highlight-color: rgba(0, 0, 0, 0);
    675 }
    676 
    677 
     579  -webkit-user-select: none;
     580  -khtml-user-select: none;
     581  -moz-user-select: none;
     582  -ms-user-select: none;
     583  user-select: none;
     584  -webkit-touch-callout: none;
     585  -webkit-tap-highlight-color: transparent; }
    678586
    679587/*
    680588TODO: more distinction between this file and common.css
    681589*/
    682 
    683590/* Colors
    684591--------------------------------------------------------------------------------------------------*/
    685 
    686592.fc-unthemed th,
    687593.fc-unthemed td,
     
    690596.fc-unthemed .fc-divider,
    691597.fc-unthemed .fc-row,
    692 .fc-unthemed .fc-content, /* for gutter border */
     598.fc-unthemed .fc-content,
    693599.fc-unthemed .fc-popover,
    694600.fc-unthemed .fc-list-view,
    695601.fc-unthemed .fc-list-heading td {
    696         border-color: #ddd;
    697 }
     602  border-color: #ddd; }
    698603
    699604.fc-unthemed .fc-popover {
    700         background-color: #fff;
    701 }
     605  background-color: #fff; }
    702606
    703607.fc-unthemed .fc-divider,
    704608.fc-unthemed .fc-popover .fc-header,
    705609.fc-unthemed .fc-list-heading td {
    706         background: #eee;
    707 }
     610  background: #eee; }
    708611
    709612.fc-unthemed .fc-popover .fc-header .fc-close {
    710         color: #666;
    711 }
     613  color: #666; }
    712614
    713615.fc-unthemed td.fc-today {
    714         background: #fcf8e3;
    715 }
     616  background: #fcf8e3; }
    716617
    717618.fc-unthemed .fc-disabled-day {
    718         background: #d7d7d7;
    719         opacity: .3;
    720 }
    721 
     619  background: #d7d7d7;
     620  opacity: .3; }
    722621
    723622/* Icons (inline elements with styled text that mock arrow icons)
    724623--------------------------------------------------------------------------------------------------*/
    725 
    726624.fc-icon {
    727         display: inline-block;
    728         height: 1em;
    729         line-height: 1em;
    730         font-size: 1em;
    731         text-align: center;
    732         overflow: hidden;
    733         font-family: "Courier New", Courier, monospace;
    734 
    735         /* don't allow browser text-selection */
    736         -webkit-touch-callout: none;
    737         -webkit-user-select: none;
    738         -khtml-user-select: none;
    739         -moz-user-select: none;
    740         -ms-user-select: none;
    741         user-select: none;
    742 }
     625  display: inline-block;
     626  height: 1em;
     627  line-height: 1em;
     628  font-size: 1em;
     629  text-align: center;
     630  overflow: hidden;
     631  font-family: "Courier New", Courier, monospace;
     632  /* don't allow browser text-selection */
     633  -webkit-touch-callout: none;
     634  -webkit-user-select: none;
     635  -khtml-user-select: none;
     636  -moz-user-select: none;
     637  -ms-user-select: none;
     638  user-select: none; }
    743639
    744640/*
    745641Acceptable font-family overrides for individual icons:
    746         "Arial", sans-serif
    747         "Times New Roman", serif
     642  "Arial", sans-serif
     643  "Times New Roman", serif
    748644
    749645NOTE: use percentage font sizes or else old IE chokes
    750646*/
    751 
    752647.fc-icon:after {
    753         position: relative;
    754 }
     648  position: relative; }
    755649
    756650.fc-icon-left-single-arrow:after {
    757         content: "\02039";
    758         font-weight: bold;
    759         font-size: 200%;
    760         top: -7%;
    761 }
     651  content: "\2039";
     652  font-weight: bold;
     653  font-size: 200%;
     654  top: -7%; }
    762655
    763656.fc-icon-right-single-arrow:after {
    764         content: "\0203A";
    765         font-weight: bold;
    766         font-size: 200%;
    767         top: -7%;
    768 }
     657  content: "\203A";
     658  font-weight: bold;
     659  font-size: 200%;
     660  top: -7%; }
    769661
    770662.fc-icon-left-double-arrow:after {
    771         content: "\000AB";
    772         font-size: 160%;
    773         top: -7%;
    774 }
     663  content: "\AB";
     664  font-size: 160%;
     665  top: -7%; }
    775666
    776667.fc-icon-right-double-arrow:after {
    777         content: "\000BB";
    778         font-size: 160%;
    779         top: -7%;
    780 }
     668  content: "\BB";
     669  font-size: 160%;
     670  top: -7%; }
    781671
    782672.fc-icon-left-triangle:after {
    783         content: "\25C4";
    784         font-size: 125%;
    785         top: 3%;
    786 }
     673  content: "\25C4";
     674  font-size: 125%;
     675  top: 3%; }
    787676
    788677.fc-icon-right-triangle:after {
    789         content: "\25BA";
    790         font-size: 125%;
    791         top: 3%;
    792 }
     678  content: "\25BA";
     679  font-size: 125%;
     680  top: 3%; }
    793681
    794682.fc-icon-down-triangle:after {
    795         content: "\25BC";
    796         font-size: 125%;
    797         top: 2%;
    798 }
     683  content: "\25BC";
     684  font-size: 125%;
     685  top: 2%; }
    799686
    800687.fc-icon-x:after {
    801         content: "\000D7";
    802         font-size: 200%;
    803         top: 6%;
    804 }
    805 
     688  content: "\D7";
     689  font-size: 200%;
     690  top: 6%; }
    806691
    807692/* Popover
    808693--------------------------------------------------------------------------------------------------*/
    809 
    810694.fc-unthemed .fc-popover {
    811         border-width: 1px;
    812         border-style: solid;
    813 }
     695  border-width: 1px;
     696  border-style: solid; }
    814697
    815698.fc-unthemed .fc-popover .fc-header .fc-close {
    816         font-size: .9em;
    817         margin-top: 2px;
    818 }
    819 
     699  font-size: .9em;
     700  margin-top: 2px; }
    820701
    821702/* List View
    822703--------------------------------------------------------------------------------------------------*/
    823 
    824704.fc-unthemed .fc-list-item:hover td {
    825         background-color: #f5f5f5;
    826 }
    827 
    828 
     705  background-color: #f5f5f5; }
    829706
    830707/* Colors
    831708--------------------------------------------------------------------------------------------------*/
    832 
    833709.ui-widget .fc-disabled-day {
    834         background-image: none;
    835 }
    836 
     710  background-image: none; }
    837711
    838712/* Popover
    839713--------------------------------------------------------------------------------------------------*/
    840 
    841714.fc-popover > .ui-widget-header + .ui-widget-content {
    842         border-top: 0; /* where they meet, let the header have the border */
    843 }
    844 
     715  border-top: 0;
     716  /* where they meet, let the header have the border */ }
    845717
    846718/* Global Event Styles
    847719--------------------------------------------------------------------------------------------------*/
    848 
    849720.ui-widget .fc-event {
    850         /* overpower jqui's styles on <a> tags. TODO: more DRY */
    851         color: #fff; /* default TEXT color */
    852         text-decoration: none; /* if <a> has an href */
    853 
    854         /* undo ui-widget-header bold */
    855         font-weight: normal;
    856 }
    857 
     721  /* overpower jqui's styles on <a> tags. TODO: more DRY */
     722  color: #fff;
     723  /* default TEXT color */
     724  text-decoration: none;
     725  /* if <a> has an href */
     726  /* undo ui-widget-header bold */
     727  font-weight: normal; }
    858728
    859729/* TimeGrid axis running down the side (for both the all-day area and the slot area)
    860730--------------------------------------------------------------------------------------------------*/
    861 
    862731.ui-widget td.fc-axis {
    863         font-weight: normal; /* overcome bold */
    864 }
    865 
     732  font-weight: normal;
     733  /* overcome bold */ }
    866734
    867735/* TimeGrid Slats (lines that run horizontally)
    868736--------------------------------------------------------------------------------------------------*/
    869 
    870 .fc-time-grid .fc-slats .ui-widget-content {
    871         background: none; /* see through to fc-bg */
    872 }
    873 
    874 
     737.fc-time-grid .fc-slats .ui-widget-content {
     738  background: none;
     739  /* see through to fc-bg */ }
    875740
    876741.fc.fc-bootstrap3 a {
    877         text-decoration: none;
    878 }
     742  text-decoration: none; }
    879743
    880744.fc.fc-bootstrap3 a[data-goto]:hover {
    881         text-decoration: underline;
    882 }
     745  text-decoration: underline; }
    883746
    884747.fc-bootstrap3 hr.fc-divider {
    885         border-color: inherit;
    886 }
     748  border-color: inherit; }
    887749
    888750.fc-bootstrap3 .fc-today.alert {
    889         border-radius: 0;
    890 }
    891 
     751  border-radius: 0; }
    892752
    893753/* Popover
    894754--------------------------------------------------------------------------------------------------*/
    895 
    896755.fc-bootstrap3 .fc-popover .panel-body {
    897         padding: 0; /* undo built-in padding */
    898 }
    899 
     756  padding: 0; }
    900757
    901758/* TimeGrid Slats (lines that run horizontally)
    902759--------------------------------------------------------------------------------------------------*/
    903 
    904760.fc-bootstrap3 .fc-time-grid .fc-slats table {
    905         /* some themes have background color. see through to slats */
    906         background: none;
    907 }
    908 
    909 
     761  /* some themes have background color. see through to slats */
     762  background: none; }
     763
     764.fc.fc-bootstrap4 a {
     765  text-decoration: none; }
     766
     767.fc.fc-bootstrap4 a[data-goto]:hover {
     768  text-decoration: underline; }
     769
     770.fc-bootstrap4 hr.fc-divider {
     771  border-color: inherit; }
     772
     773.fc-bootstrap4 .fc-today.alert {
     774  border-radius: 0; }
     775
     776.fc-bootstrap4 a.fc-event:not([href]):not([tabindex]) {
     777  color: #fff; }
     778
     779.fc-bootstrap4 .fc-popover.card {
     780  position: absolute; }
     781
     782/* Popover
     783--------------------------------------------------------------------------------------------------*/
     784.fc-bootstrap4 .fc-popover .card-body {
     785  padding: 0; }
     786
     787/* TimeGrid Slats (lines that run horizontally)
     788--------------------------------------------------------------------------------------------------*/
     789.fc-bootstrap4 .fc-time-grid .fc-slats table {
     790  /* some themes have background color. see through to slats */
     791  background: none; }
    910792
    911793/* Toolbar
    912794--------------------------------------------------------------------------------------------------*/
    913 
    914795.fc-toolbar {
    915         text-align: center;
    916 }
     796  text-align: center; }
    917797
    918798.fc-toolbar.fc-header-toolbar {
    919         margin-bottom: 1em;
    920 }
     799  margin-bottom: 1em; }
    921800
    922801.fc-toolbar.fc-footer-toolbar {
    923         margin-top: 1em;
    924 }
     802  margin-top: 1em; }
    925803
    926804.fc-toolbar .fc-left {
    927         float: left;
    928 }
     805  float: left; }
    929806
    930807.fc-toolbar .fc-right {
    931         float: right;
    932 }
     808  float: right; }
    933809
    934810.fc-toolbar .fc-center {
    935         display: inline-block;
    936 }
     811  display: inline-block; }
    937812
    938813/* the things within each left/right/center section */
    939 .fc .fc-toolbar > * > * { /* extra precedence to override button border margins */
    940         float: left;
    941         margin-left: .75em;
    942 }
     814.fc .fc-toolbar > * > * {
     815  /* extra precedence to override button border margins */
     816  float: left;
     817  margin-left: .75em; }
    943818
    944819/* the first thing within each left/center/right section */
    945 .fc .fc-toolbar > * > :first-child { /* extra precedence to override button border margins */
    946         margin-left: 0;
    947 }
    948        
     820.fc .fc-toolbar > * > :first-child {
     821  /* extra precedence to override button border margins */
     822  margin-left: 0; }
     823
    949824/* title text */
    950 
    951825.fc-toolbar h2 {
    952         margin: 0;
    953 }
     826  margin: 0; }
    954827
    955828/* button layering (for border precedence) */
    956 
    957829.fc-toolbar button {
    958         position: relative;
    959 }
     830  position: relative; }
    960831
    961832.fc-toolbar .fc-state-hover,
    962833.fc-toolbar .ui-state-hover {
    963         z-index: 2;
    964 }
    965        
     834  z-index: 2; }
     835
    966836.fc-toolbar .fc-state-down {
    967         z-index: 3;
    968 }
     837  z-index: 3; }
    969838
    970839.fc-toolbar .fc-state-active,
    971840.fc-toolbar .ui-state-active {
    972         z-index: 4;
    973 }
     841  z-index: 4; }
    974842
    975843.fc-toolbar button:focus {
    976         z-index: 5;
    977 }
    978 
     844  z-index: 5; }
    979845
    980846/* View Structure
    981847--------------------------------------------------------------------------------------------------*/
    982 
    983848/* undo twitter bootstrap's box-sizing rules. normalizes positioning techniques */
    984849/* don't do this for the toolbar because we'll want bootstrap to style those buttons as some pt */
     
    986851.fc-view-container *:before,
    987852.fc-view-container *:after {
    988         -webkit-box-sizing: content-box;
    989            -moz-box-sizing: content-box;
    990                 box-sizing: content-box;
    991 }
    992 
    993 .fc-view, /* scope positioning and z-index's for everything within the view */
    994 .fc-view > table { /* so dragged elements can be above the view's main element */
    995         position: relative;
    996         z-index: 1;
    997 }
    998 
    999 
     853  -webkit-box-sizing: content-box;
     854  -moz-box-sizing: content-box;
     855  box-sizing: content-box; }
     856
     857.fc-view,
     858.fc-view > table {
     859  /* so dragged elements can be above the view's main element */
     860  position: relative;
     861  z-index: 1; }
    1000862
    1001863/* BasicView
    1002864--------------------------------------------------------------------------------------------------*/
    1003 
    1004865/* day row structure */
    1005 
    1006866.fc-basicWeek-view .fc-content-skeleton,
    1007867.fc-basicDay-view .fc-content-skeleton {
    1008         /* there may be week numbers in these views, so no padding-top */
    1009         padding-bottom: 1em; /* ensure a space at bottom of cell for user selecting/clicking */
    1010 }
     868  /* there may be week numbers in these views, so no padding-top */
     869  padding-bottom: 1em;
     870  /* ensure a space at bottom of cell for user selecting/clicking */ }
    1011871
    1012872.fc-basic-view .fc-body .fc-row {
    1013         min-height: 4em; /* ensure that all rows are at least this tall */
    1014 }
     873  min-height: 4em;
     874  /* ensure that all rows are at least this tall */ }
    1015875
    1016876/* a "rigid" row will take up a constant amount of height because content-skeleton is absolute */
    1017 
    1018877.fc-row.fc-rigid {
    1019         overflow: hidden;
    1020 }
     878  overflow: hidden; }
    1021879
    1022880.fc-row.fc-rigid .fc-content-skeleton {
    1023         position: absolute;
    1024         top: 0;
    1025         left: 0;
    1026         right: 0;
    1027 }
     881  position: absolute;
     882  top: 0;
     883  left: 0;
     884  right: 0; }
    1028885
    1029886/* week and day number styling */
    1030 
    1031887.fc-day-top.fc-other-month {
    1032         opacity: 0.3;
    1033 }
     888  opacity: 0.3; }
    1034889
    1035890.fc-basic-view .fc-week-number,
    1036891.fc-basic-view .fc-day-number {
    1037         padding: 2px;
    1038 }
     892  padding: 2px; }
    1039893
    1040894.fc-basic-view th.fc-week-number,
    1041895.fc-basic-view th.fc-day-number {
    1042         padding: 0 2px; /* column headers can't have as much v space */
    1043 }
    1044 
    1045 .fc-ltr .fc-basic-view .fc-day-top .fc-day-number { float: right; }
    1046 .fc-rtl .fc-basic-view .fc-day-top .fc-day-number { float: left; }
    1047 
    1048 .fc-ltr .fc-basic-view .fc-day-top .fc-week-number { float: left; border-radius: 0 0 3px 0; }
    1049 .fc-rtl .fc-basic-view .fc-day-top .fc-week-number { float: right; border-radius: 0 0 0 3px; }
     896  padding: 0 2px;
     897  /* column headers can't have as much v space */ }
     898
     899.fc-ltr .fc-basic-view .fc-day-top .fc-day-number {
     900  float: right; }
     901
     902.fc-rtl .fc-basic-view .fc-day-top .fc-day-number {
     903  float: left; }
     904
     905.fc-ltr .fc-basic-view .fc-day-top .fc-week-number {
     906  float: left;
     907  border-radius: 0 0 3px 0; }
     908
     909.fc-rtl .fc-basic-view .fc-day-top .fc-week-number {
     910  float: right;
     911  border-radius: 0 0 0 3px; }
    1050912
    1051913.fc-basic-view .fc-day-top .fc-week-number {
    1052         min-width: 1.5em;
    1053         text-align: center;
    1054         background-color: #f2f2f2;
    1055         color: #808080;
    1056 }
     914  min-width: 1.5em;
     915  text-align: center;
     916  background-color: #f2f2f2;
     917  color: #808080; }
    1057918
    1058919/* when week/day number have own column */
    1059 
    1060920.fc-basic-view td.fc-week-number {
    1061         text-align: center;
    1062 }
     921  text-align: center; }
    1063922
    1064923.fc-basic-view td.fc-week-number > * {
    1065         /* work around the way we do column resizing and ensure a minimum width */
    1066         display: inline-block;
    1067         min-width: 1.25em;
    1068 }
    1069 
     924  /* work around the way we do column resizing and ensure a minimum width */
     925  display: inline-block;
     926  min-width: 1.25em; }
    1070927
    1071928/* AgendaView all-day area
    1072929--------------------------------------------------------------------------------------------------*/
    1073 
    1074930.fc-agenda-view .fc-day-grid {
    1075         position: relative;
    1076         z-index: 2; /* so the "more.." popover will be over the time grid */
    1077 }
     931  position: relative;
     932  z-index: 2;
     933  /* so the "more.." popover will be over the time grid */ }
    1078934
    1079935.fc-agenda-view .fc-day-grid .fc-row {
    1080         min-height: 3em; /* all-day section will never get shorter than this */
    1081 }
     936  min-height: 3em;
     937  /* all-day section will never get shorter than this */ }
    1082938
    1083939.fc-agenda-view .fc-day-grid .fc-row .fc-content-skeleton {
    1084         padding-bottom: 1em; /* give space underneath events for clicking/selecting days */
    1085 }
    1086 
     940  padding-bottom: 1em;
     941  /* give space underneath events for clicking/selecting days */ }
    1087942
    1088943/* TimeGrid axis running down the side (for both the all-day area and the slot area)
    1089944--------------------------------------------------------------------------------------------------*/
    1090 
    1091 .fc .fc-axis { /* .fc to overcome default cell styles */
    1092         vertical-align: middle;
    1093         padding: 0 4px;
    1094         white-space: nowrap;
    1095 }
     945.fc .fc-axis {
     946  /* .fc to overcome default cell styles */
     947  vertical-align: middle;
     948  padding: 0 4px;
     949  white-space: nowrap; }
    1096950
    1097951.fc-ltr .fc-axis {
    1098         text-align: right;
    1099 }
     952  text-align: right; }
    1100953
    1101954.fc-rtl .fc-axis {
    1102         text-align: left;
    1103 }
    1104 
     955  text-align: left; }
    1105956
    1106957/* TimeGrid Structure
    1107958--------------------------------------------------------------------------------------------------*/
    1108 
    1109 .fc-time-grid-container, /* so scroll container's z-index is below all-day */
    1110 .fc-time-grid { /* so slats/bg/content/etc positions get scoped within here */
    1111         position: relative;
    1112         z-index: 1;
    1113 }
    1114 
     959.fc-time-grid-container,
    1115960.fc-time-grid {
    1116         min-height: 100%; /* so if height setting is 'auto', .fc-bg stretches to fill height */
    1117 }
    1118 
    1119 .fc-time-grid table { /* don't put outer borders on slats/bg/content/etc */
    1120         border: 0 hidden transparent;
    1121 }
     961  /* so slats/bg/content/etc positions get scoped within here */
     962  position: relative;
     963  z-index: 1; }
     964
     965.fc-time-grid {
     966  min-height: 100%;
     967  /* so if height setting is 'auto', .fc-bg stretches to fill height */ }
     968
     969.fc-time-grid table {
     970  /* don't put outer borders on slats/bg/content/etc */
     971  border: 0 hidden transparent; }
    1122972
    1123973.fc-time-grid > .fc-bg {
    1124         z-index: 1;
    1125 }
     974  z-index: 1; }
    1126975
    1127976.fc-time-grid .fc-slats,
    1128 .fc-time-grid > hr { /* the <hr> AgendaView injects when grid is shorter than scroller */
    1129         position: relative;
    1130         z-index: 2;
    1131 }
     977.fc-time-grid > hr {
     978  /* the <hr> AgendaView injects when grid is shorter than scroller */
     979  position: relative;
     980  z-index: 2; }
    1132981
    1133982.fc-time-grid .fc-content-col {
    1134         position: relative; /* because now-indicator lives directly inside */
    1135 }
     983  position: relative;
     984  /* because now-indicator lives directly inside */ }
    1136985
    1137986.fc-time-grid .fc-content-skeleton {
    1138         position: absolute;
    1139         z-index: 3;
    1140         top: 0;
    1141         left: 0;
    1142         right: 0;
    1143 }
     987  position: absolute;
     988  z-index: 3;
     989  top: 0;
     990  left: 0;
     991  right: 0; }
    1144992
    1145993/* divs within a cell within the fc-content-skeleton */
    1146 
    1147994.fc-time-grid .fc-business-container {
    1148         position: relative;
    1149         z-index: 1;
    1150 }
     995  position: relative;
     996  z-index: 1; }
    1151997
    1152998.fc-time-grid .fc-bgevent-container {
    1153         position: relative;
    1154         z-index: 2;
    1155 }
     999  position: relative;
     1000  z-index: 2; }
    11561001
    11571002.fc-time-grid .fc-highlight-container {
    1158         position: relative;
    1159         z-index: 3;
    1160 }
     1003  position: relative;
     1004  z-index: 3; }
    11611005
    11621006.fc-time-grid .fc-event-container {
    1163         position: relative;
    1164         z-index: 4;
    1165 }
     1007  position: relative;
     1008  z-index: 4; }
    11661009
    11671010.fc-time-grid .fc-now-indicator-line {
    1168         z-index: 5;
    1169 }
    1170 
    1171 .fc-time-grid .fc-helper-container { /* also is fc-event-container */
    1172         position: relative;
    1173         z-index: 6;
    1174 }
    1175 
     1011  z-index: 5; }
     1012
     1013.fc-time-grid .fc-helper-container {
     1014  /* also is fc-event-container */
     1015  position: relative;
     1016  z-index: 6; }
    11761017
    11771018/* TimeGrid Slats (lines that run horizontally)
    11781019--------------------------------------------------------------------------------------------------*/
    1179 
    11801020.fc-time-grid .fc-slats td {
    1181         height: 1.5em;
    1182         border-bottom: 0; /* each cell is responsible for its top border */
    1183 }
     1021  height: 1.5em;
     1022  border-bottom: 0;
     1023  /* each cell is responsible for its top border */ }
    11841024
    11851025.fc-time-grid .fc-slats .fc-minor td {
    1186         border-top-style: dotted;
    1187 }
    1188 
     1026  border-top-style: dotted; }
    11891027
    11901028/* TimeGrid Highlighting Slots
    11911029--------------------------------------------------------------------------------------------------*/
    1192 
    1193 .fc-time-grid .fc-highlight-container { /* a div within a cell within the fc-highlight-skeleton */
    1194         position: relative; /* scopes the left/right of the fc-highlight to be in the column */
    1195 }
     1030.fc-time-grid .fc-highlight-container {
     1031  /* a div within a cell within the fc-highlight-skeleton */
     1032  position: relative;
     1033  /* scopes the left/right of the fc-highlight to be in the column */ }
    11961034
    11971035.fc-time-grid .fc-highlight {
    1198         position: absolute;
    1199         left: 0;
    1200         right: 0;
    1201         /* top and bottom will be in by JS */
    1202 }
    1203 
     1036  position: absolute;
     1037  left: 0;
     1038  right: 0;
     1039  /* top and bottom will be in by JS */ }
    12041040
    12051041/* TimeGrid Event Containment
    12061042--------------------------------------------------------------------------------------------------*/
    1207 
    1208 .fc-ltr .fc-time-grid .fc-event-container { /* space on the sides of events for LTR (default) */
    1209         margin: 0 2.5% 0 2px;
    1210 }
    1211 
    1212 .fc-rtl .fc-time-grid .fc-event-container { /* space on the sides of events for RTL */
    1213         margin: 0 2px 0 2.5%;
    1214 }
     1043.fc-ltr .fc-time-grid .fc-event-container {
     1044  /* space on the sides of events for LTR (default) */
     1045  margin: 0 2.5% 0 2px; }
     1046
     1047.fc-rtl .fc-time-grid .fc-event-container {
     1048  /* space on the sides of events for RTL */
     1049  margin: 0 2px 0 2.5%; }
    12151050
    12161051.fc-time-grid .fc-event,
    12171052.fc-time-grid .fc-bgevent {
    1218         position: absolute;
    1219         z-index: 1; /* scope inner z-index's */
    1220 }
     1053  position: absolute;
     1054  z-index: 1;
     1055  /* scope inner z-index's */ }
    12211056
    12221057.fc-time-grid .fc-bgevent {
    1223         /* background events always span full width */
    1224         left: 0;
    1225         right: 0;
    1226 }
    1227 
     1058  /* background events always span full width */
     1059  left: 0;
     1060  right: 0; }
    12281061
    12291062/* Generic Vertical Event
    12301063--------------------------------------------------------------------------------------------------*/
    1231 
    1232 .fc-v-event.fc-not-start { /* events that are continuing from another day */
    1233         /* replace space made by the top border with padding */
    1234         border-top-width: 0;
    1235         padding-top: 1px;
    1236 
    1237         /* remove top rounded corners */
    1238         border-top-left-radius: 0;
    1239         border-top-right-radius: 0;
    1240 }
     1064.fc-v-event.fc-not-start {
     1065  /* events that are continuing from another day */
     1066  /* replace space made by the top border with padding */
     1067  border-top-width: 0;
     1068  padding-top: 1px;
     1069  /* remove top rounded corners */
     1070  border-top-left-radius: 0;
     1071  border-top-right-radius: 0; }
    12411072
    12421073.fc-v-event.fc-not-end {
    1243         /* replace space made by the top border with padding */
    1244         border-bottom-width: 0;
    1245         padding-bottom: 1px;
    1246 
    1247         /* remove bottom rounded corners */
    1248         border-bottom-left-radius: 0;
    1249         border-bottom-right-radius: 0;
    1250 }
    1251 
     1074  /* replace space made by the top border with padding */
     1075  border-bottom-width: 0;
     1076  padding-bottom: 1px;
     1077  /* remove bottom rounded corners */
     1078  border-bottom-left-radius: 0;
     1079  border-bottom-right-radius: 0; }
    12521080
    12531081/* TimeGrid Event Styling
     
    12561084be a descendant of the grid when it is being dragged.
    12571085*/
    1258 
    12591086.fc-time-grid-event {
    1260         overflow: hidden; /* don't let the bg flow over rounded corners */
    1261 }
     1087  overflow: hidden;
     1088  /* don't let the bg flow over rounded corners */ }
    12621089
    12631090.fc-time-grid-event.fc-selected {
    1264         /* need to allow touch resizers to extend outside event's bounding box */
    1265         /* common fc-selected styles hide the fc-bg, so don't need this anyway */
    1266         overflow: visible;
    1267 }
     1091  /* need to allow touch resizers to extend outside event's bounding box */
     1092  /* common fc-selected styles hide the fc-bg, so don't need this anyway */
     1093  overflow: visible; }
    12681094
    12691095.fc-time-grid-event.fc-selected .fc-bg {
    1270         display: none; /* hide semi-white background, to appear darker */
    1271 }
     1096  display: none;
     1097  /* hide semi-white background, to appear darker */ }
    12721098
    12731099.fc-time-grid-event .fc-content {
    1274         overflow: hidden; /* for when .fc-selected */
    1275 }
     1100  overflow: hidden;
     1101  /* for when .fc-selected */ }
    12761102
    12771103.fc-time-grid-event .fc-time,
    12781104.fc-time-grid-event .fc-title {
    1279         padding: 0 1px;
    1280 }
     1105  padding: 0 1px; }
    12811106
    12821107.fc-time-grid-event .fc-time {
    1283         font-size: .85em;
    1284         white-space: nowrap;
    1285 }
     1108  font-size: .85em;
     1109  white-space: nowrap; }
    12861110
    12871111/* short mode, where time and title are on the same line */
    1288 
    12891112.fc-time-grid-event.fc-short .fc-content {
    1290         /* don't wrap to second line (now that contents will be inline) */
    1291         white-space: nowrap;
    1292 }
     1113  /* don't wrap to second line (now that contents will be inline) */
     1114  white-space: nowrap; }
    12931115
    12941116.fc-time-grid-event.fc-short .fc-time,
    12951117.fc-time-grid-event.fc-short .fc-title {
    1296         /* put the time and title on the same line */
    1297         display: inline-block;
    1298         vertical-align: top;
    1299 }
     1118  /* put the time and title on the same line */
     1119  display: inline-block;
     1120  vertical-align: top; }
    13001121
    13011122.fc-time-grid-event.fc-short .fc-time span {
    1302         display: none; /* don't display the full time text... */
    1303 }
     1123  display: none;
     1124  /* don't display the full time text... */ }
    13041125
    13051126.fc-time-grid-event.fc-short .fc-time:before {
    1306         content: attr(data-start); /* ...instead, display only the start time */
    1307 }
     1127  content: attr(data-start);
     1128  /* ...instead, display only the start time */ }
    13081129
    13091130.fc-time-grid-event.fc-short .fc-time:after {
    1310         content: "\000A0-\000A0"; /* seperate with a dash, wrapped in nbsp's */
    1311 }
     1131  content: "\A0-\A0";
     1132  /* seperate with a dash, wrapped in nbsp's */ }
    13121133
    13131134.fc-time-grid-event.fc-short .fc-title {
    1314         font-size: .85em; /* make the title text the same size as the time */
    1315         padding: 0; /* undo padding from above */
    1316 }
     1135  font-size: .85em;
     1136  /* make the title text the same size as the time */
     1137  padding: 0;
     1138  /* undo padding from above */ }
    13171139
    13181140/* resizer (cursor device) */
    1319 
    13201141.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer {
    1321         left: 0;
    1322         right: 0;
    1323         bottom: 0;
    1324         height: 8px;
    1325         overflow: hidden;
    1326         line-height: 8px;
    1327         font-size: 11px;
    1328         font-family: monospace;
    1329         text-align: center;
    1330         cursor: s-resize;
    1331 }
     1142  left: 0;
     1143  right: 0;
     1144  bottom: 0;
     1145  height: 8px;
     1146  overflow: hidden;
     1147  line-height: 8px;
     1148  font-size: 11px;
     1149  font-family: monospace;
     1150  text-align: center;
     1151  cursor: s-resize; }
    13321152
    13331153.fc-time-grid-event.fc-allow-mouse-resize .fc-resizer:after {
    1334         content: "=";
    1335 }
     1154  content: "="; }
    13361155
    13371156/* resizer (touch device) */
    1338 
    13391157.fc-time-grid-event.fc-selected .fc-resizer {
    1340         /* 10x10 dot */
    1341         border-radius: 5px;
    1342         border-width: 1px;
    1343         width: 8px;
    1344         height: 8px;
    1345         border-style: solid;
    1346         border-color: inherit;
    1347         background: #fff;
    1348         /* horizontally center */
    1349         left: 50%;
    1350         margin-left: -5px;
    1351         /* center on the bottom edge */
    1352         bottom: -5px;
    1353 }
    1354 
     1158  /* 10x10 dot */
     1159  border-radius: 5px;
     1160  border-width: 1px;
     1161  width: 8px;
     1162  height: 8px;
     1163  border-style: solid;
     1164  border-color: inherit;
     1165  background: #fff;
     1166  /* horizontally center */
     1167  left: 50%;
     1168  margin-left: -5px;
     1169  /* center on the bottom edge */
     1170  bottom: -5px; }
    13551171
    13561172/* Now Indicator
    13571173--------------------------------------------------------------------------------------------------*/
    1358 
    13591174.fc-time-grid .fc-now-indicator-line {
    1360         border-top-width: 1px;
    1361         left: 0;
    1362         right: 0;
    1363 }
     1175  border-top-width: 1px;
     1176  left: 0;
     1177  right: 0; }
    13641178
    13651179/* arrow on axis */
    1366 
    13671180.fc-time-grid .fc-now-indicator-arrow {
    1368         margin-top: -5px; /* vertically center on top coordinate */
    1369 }
     1181  margin-top: -5px;
     1182  /* vertically center on top coordinate */ }
    13701183
    13711184.fc-ltr .fc-time-grid .fc-now-indicator-arrow {
    1372         left: 0;
    1373         /* triangle pointing right... */
    1374         border-width: 5px 0 5px 6px;
    1375         border-top-color: transparent;
    1376         border-bottom-color: transparent;
    1377 }
     1185  left: 0;
     1186  /* triangle pointing right... */
     1187  border-width: 5px 0 5px 6px;
     1188  border-top-color: transparent;
     1189  border-bottom-color: transparent; }
    13781190
    13791191.fc-rtl .fc-time-grid .fc-now-indicator-arrow {
    1380         right: 0;
    1381         /* triangle pointing left... */
    1382         border-width: 5px 6px 5px 0;
    1383         border-top-color: transparent;
    1384         border-bottom-color: transparent;
    1385 }
    1386 
    1387 
     1192  right: 0;
     1193  /* triangle pointing left... */
     1194  border-width: 5px 6px 5px 0;
     1195  border-top-color: transparent;
     1196  border-bottom-color: transparent; }
    13881197
    13891198/* List View
    13901199--------------------------------------------------------------------------------------------------*/
    1391 
    13921200/* possibly reusable */
    1393 
    13941201.fc-event-dot {
    1395         display: inline-block;
    1396         width: 10px;
    1397         height: 10px;
    1398         border-radius: 5px;
    1399 }
     1202  display: inline-block;
     1203  width: 10px;
     1204  height: 10px;
     1205  border-radius: 5px; }
    14001206
    14011207/* view wrapper */
    1402 
    14031208.fc-rtl .fc-list-view {
    1404         direction: rtl; /* unlike core views, leverage browser RTL */
    1405 }
     1209  direction: rtl;
     1210  /* unlike core views, leverage browser RTL */ }
    14061211
    14071212.fc-list-view {
    1408         border-width: 1px;
    1409         border-style: solid;
    1410 }
     1213  border-width: 1px;
     1214  border-style: solid; }
    14111215
    14121216/* table resets */
    1413 
    14141217.fc .fc-list-table {
    1415         table-layout: auto; /* for shrinkwrapping cell content */
    1416 }
     1218  table-layout: auto;
     1219  /* for shrinkwrapping cell content */ }
    14171220
    14181221.fc-list-table td {
    1419         border-width: 1px 0 0;
    1420         padding: 8px 14px;
    1421 }
     1222  border-width: 1px 0 0;
     1223  padding: 8px 14px; }
    14221224
    14231225.fc-list-table tr:first-child td {
    1424         border-top-width: 0;
    1425 }
     1226  border-top-width: 0; }
    14261227
    14271228/* day headings with the list */
    1428 
    14291229.fc-list-heading {
    1430         border-bottom-width: 1px;
    1431 }
     1230  border-bottom-width: 1px; }
    14321231
    14331232.fc-list-heading td {
    1434         font-weight: bold;
    1435 }
    1436 
    1437 .fc-ltr .fc-list-heading-main { float: left; }
    1438 .fc-ltr .fc-list-heading-alt { float: right; }
    1439 
    1440 .fc-rtl .fc-list-heading-main { float: right; }
    1441 .fc-rtl .fc-list-heading-alt { float: left; }
     1233  font-weight: bold; }
     1234
     1235.fc-ltr .fc-list-heading-main {
     1236  float: left; }
     1237
     1238.fc-ltr .fc-list-heading-alt {
     1239  float: right; }
     1240
     1241.fc-rtl .fc-list-heading-main {
     1242  float: right; }
     1243
     1244.fc-rtl .fc-list-heading-alt {
     1245  float: left; }
    14421246
    14431247/* event list items */
    1444 
    14451248.fc-list-item.fc-has-url {
    1446         cursor: pointer; /* whole row will be clickable */
    1447 }
     1249  cursor: pointer;
     1250  /* whole row will be clickable */ }
    14481251
    14491252.fc-list-item-marker,
    14501253.fc-list-item-time {
    1451         white-space: nowrap;
    1452         width: 1px;
    1453 }
     1254  white-space: nowrap;
     1255  width: 1px; }
    14541256
    14551257/* make the dot closer to the event title */
    1456 .fc-ltr .fc-list-item-marker { padding-right: 0; }
    1457 .fc-rtl .fc-list-item-marker { padding-left: 0; }
     1258.fc-ltr .fc-list-item-marker {
     1259  padding-right: 0; }
     1260
     1261.fc-rtl .fc-list-item-marker {
     1262  padding-left: 0; }
    14581263
    14591264.fc-list-item-title a {
    1460         /* every event title cell has an <a> tag */
    1461         text-decoration: none;
    1462         color: inherit;
    1463 }
     1265  /* every event title cell has an <a> tag */
     1266  text-decoration: none;
     1267  color: inherit; }
    14641268
    14651269.fc-list-item-title a[href]:hover {
    1466         /* hover effect only on titles with hrefs */
    1467         text-decoration: underline;
    1468 }
     1270  /* hover effect only on titles with hrefs */
     1271  text-decoration: underline; }
    14691272
    14701273/* message when no events */
    1471 
    14721274.fc-list-empty-wrap2 {
    1473         position: absolute;
    1474         top: 0;
    1475         left: 0;
    1476         right: 0;
    1477         bottom: 0;
    1478 }
     1275  position: absolute;
     1276  top: 0;
     1277  left: 0;
     1278  right: 0;
     1279  bottom: 0; }
    14791280
    14801281.fc-list-empty-wrap1 {
    1481         width: 100%;
    1482         height: 100%;
    1483         display: table;
    1484 }
     1282  width: 100%;
     1283  height: 100%;
     1284  display: table; }
    14851285
    14861286.fc-list-empty {
    1487         display: table-cell;
    1488         vertical-align: middle;
    1489         text-align: center;
    1490 }
    1491 
    1492 .fc-unthemed .fc-list-empty { /* theme will provide own background */
    1493         background-color: #eee;
    1494 }
     1287  display: table-cell;
     1288  vertical-align: middle;
     1289  text-align: center; }
     1290
     1291.fc-unthemed .fc-list-empty {
     1292  /* theme will provide own background */
     1293  background-color: #eee; }
  • _core_/plugins/organiseur/lib/fullcalendar/fullcalendar.js

    r106690 r111041  
    11/*!
    2  * FullCalendar v3.5.1
     2 * FullCalendar v3.9.0
    33 * Docs & License: https://fullcalendar.io/
    4  * (c) 2017 Adam Shaw
     4 * (c) 2018 Adam Shaw
    55 */
    6 
    7 (function(factory) {
    8         if (typeof define === 'function' && define.amd) {
    9                 define([ 'jquery', 'moment' ], factory);
    10         }
    11         else if (typeof exports === 'object') { // Node/CommonJS
    12                 module.exports = factory(require('jquery'), require('moment'));
    13         }
    14         else {
    15                 factory(jQuery, moment);
    16         }
    17 })(function($, moment) {
    18 
    19 ;;
    20 
    21 var FC = $.fullCalendar = {
    22         version: "3.5.1",
    23         // When introducing internal API incompatibilities (where fullcalendar plugins would break),
    24         // the minor version of the calendar should be upped (ex: 2.7.2 -> 2.8.0)
    25         // and the below integer should be incremented.
    26         internalApiVersion: 10
     6(function webpackUniversalModuleDefinition(root, factory) {
     7        if(typeof exports === 'object' && typeof module === 'object')
     8                module.exports = factory(require("moment"), require("jquery"));
     9        else if(typeof define === 'function' && define.amd)
     10                define(["moment", "jquery"], factory);
     11        else if(typeof exports === 'object')
     12                exports["FullCalendar"] = factory(require("moment"), require("jquery"));
     13        else
     14                root["FullCalendar"] = factory(root["moment"], root["jQuery"]);
     15})(typeof self !== 'undefined' ? self : this, function(__WEBPACK_EXTERNAL_MODULE_0__, __WEBPACK_EXTERNAL_MODULE_3__) {
     16return /******/ (function(modules) { // webpackBootstrap
     17/******/        // The module cache
     18/******/        var installedModules = {};
     19/******/
     20/******/        // The require function
     21/******/        function __webpack_require__(moduleId) {
     22/******/
     23/******/                // Check if module is in cache
     24/******/                if(installedModules[moduleId]) {
     25/******/                        return installedModules[moduleId].exports;
     26/******/                }
     27/******/                // Create a new module (and put it into the cache)
     28/******/                var module = installedModules[moduleId] = {
     29/******/                        i: moduleId,
     30/******/                        l: false,
     31/******/                        exports: {}
     32/******/                };
     33/******/
     34/******/                // Execute the module function
     35/******/                modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
     36/******/
     37/******/                // Flag the module as loaded
     38/******/                module.l = true;
     39/******/
     40/******/                // Return the exports of the module
     41/******/                return module.exports;
     42/******/        }
     43/******/
     44/******/
     45/******/        // expose the modules object (__webpack_modules__)
     46/******/        __webpack_require__.m = modules;
     47/******/
     48/******/        // expose the module cache
     49/******/        __webpack_require__.c = installedModules;
     50/******/
     51/******/        // define getter function for harmony exports
     52/******/        __webpack_require__.d = function(exports, name, getter) {
     53/******/                if(!__webpack_require__.o(exports, name)) {
     54/******/                        Object.defineProperty(exports, name, {
     55/******/                                configurable: false,
     56/******/                                enumerable: true,
     57/******/                                get: getter
     58/******/                        });
     59/******/                }
     60/******/        };
     61/******/
     62/******/        // getDefaultExport function for compatibility with non-harmony modules
     63/******/        __webpack_require__.n = function(module) {
     64/******/                var getter = module && module.__esModule ?
     65/******/                        function getDefault() { return module['default']; } :
     66/******/                        function getModuleExports() { return module; };
     67/******/                __webpack_require__.d(getter, 'a', getter);
     68/******/                return getter;
     69/******/        };
     70/******/
     71/******/        // Object.prototype.hasOwnProperty.call
     72/******/        __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
     73/******/
     74/******/        // __webpack_public_path__
     75/******/        __webpack_require__.p = "";
     76/******/
     77/******/        // Load entry module and return exports
     78/******/        return __webpack_require__(__webpack_require__.s = 236);
     79/******/ })
     80/************************************************************************/
     81/******/ ([
     82/* 0 */
     83/***/ (function(module, exports) {
     84
     85module.exports = __WEBPACK_EXTERNAL_MODULE_0__;
     86
     87/***/ }),
     88/* 1 */,
     89/* 2 */
     90/***/ (function(module, exports) {
     91
     92/*
     93derived from:
     94https://github.com/Microsoft/tslib/blob/v1.6.0/tslib.js
     95
     96only include the helpers we need, to keep down filesize
     97*/
     98var extendStatics = Object.setPrototypeOf ||
     99    ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
     100    function (d, b) { for (var p in b)
     101        if (b.hasOwnProperty(p))
     102            d[p] = b[p]; };
     103exports.__extends = function (d, b) {
     104    extendStatics(d, b);
     105    function __() { this.constructor = d; }
     106    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    27107};
    28 var fcViews = FC.views = {};
    29 
    30 
    31 $.fn.fullCalendar = function(options) {
    32         var args = Array.prototype.slice.call(arguments, 1); // for a possible method call
    33         var res = this; // what this function will return (this jQuery object by default)
    34 
    35         this.each(function(i, _element) { // loop each DOM element involved
    36                 var element = $(_element);
    37                 var calendar = element.data('fullCalendar'); // get the existing calendar object (if any)
    38                 var singleRes; // the returned value of this single method call
    39 
    40                 // a method call
    41                 if (typeof options === 'string') {
    42 
    43                         if (options === 'getCalendar') {
    44                                 if (!i) { // first element only
    45                                         res = calendar;
    46                                 }
    47                         }
    48                         else if (options === 'destroy') { // don't warn if no calendar object
    49                                 if (calendar) {
    50                                         calendar.destroy();
    51                                         element.removeData('fullCalendar');
    52                                 }
    53                         }
    54                         else if (!calendar) {
    55                                 FC.warn("Attempting to call a FullCalendar method on an element with no calendar.");
    56                         }
    57                         else if ($.isFunction(calendar[options])) {
    58                                 singleRes = calendar[options].apply(calendar, args);
    59 
    60                                 if (!i) {
    61                                         res = singleRes; // record the first method call result
    62                                 }
    63                                 if (options === 'destroy') { // for the destroy method, must remove Calendar object data
    64                                         element.removeData('fullCalendar');
    65                                 }
    66                         }
    67                         else {
    68                                 FC.warn("'" + options + "' is an unknown FullCalendar method.");
    69                         }
    70                 }
    71                 // a new calendar initialization
    72                 else if (!calendar) { // don't initialize twice
    73                         calendar = new Calendar(element, options);
    74                         element.data('fullCalendar', calendar);
    75                         calendar.render();
    76                 }
    77         });
    78 
    79         return res;
    80 };
    81 
    82 
    83 var complexOptions = [ // names of options that are objects whose properties should be combined
    84         'header',
    85         'footer',
    86         'buttonText',
    87         'buttonIcons',
    88         'themeButtonIcons'
    89 ];
    90 
    91 
    92 // Merges an array of option objects into a single object
    93 function mergeOptions(optionObjs) {
    94         return mergeProps(optionObjs, complexOptions);
    95 }
    96 
    97 ;;
    98 
    99 // exports
    100 FC.applyAll = applyAll;
    101 FC.debounce = debounce;
    102 FC.isInt = isInt;
    103 FC.htmlEscape = htmlEscape;
    104 FC.cssToStr = cssToStr;
    105 FC.proxy = proxy;
    106 FC.capitaliseFirstLetter = capitaliseFirstLetter;
    107 
    108 
     108
     109
     110/***/ }),
     111/* 3 */
     112/***/ (function(module, exports) {
     113
     114module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
     115
     116/***/ }),
     117/* 4 */
     118/***/ (function(module, exports, __webpack_require__) {
     119
     120Object.defineProperty(exports, "__esModule", { value: true });
     121var moment = __webpack_require__(0);
     122var $ = __webpack_require__(3);
    109123/* FullCalendar-specific DOM Utilities
    110124----------------------------------------------------------------------------------------------------------------------*/
    111 
    112 
    113125// Given the scrollbar widths of some other container, create borders/margins on rowEls in order to match the left
    114126// and right space that was offset by the scrollbars. A 1-pixel border first, then margin beyond that.
    115127function compensateScroll(rowEls, scrollbarWidths) {
    116         if (scrollbarWidths.left) {
    117                 rowEls.css({
    118                         'border-left-width': 1,
    119                         'margin-left': scrollbarWidths.left - 1
    120                 });
    121         }
    122         if (scrollbarWidths.right) {
    123                 rowEls.css({
    124                         'border-right-width': 1,
    125                         'margin-right': scrollbarWidths.right - 1
    126                 });
    127         }
     128    if (scrollbarWidths.left) {
     129        rowEls.css({
     130            'border-left-width': 1,
     131            'margin-left': scrollbarWidths.left - 1
     132        });
     133    }
     134    if (scrollbarWidths.right) {
     135        rowEls.css({
     136            'border-right-width': 1,
     137            'margin-right': scrollbarWidths.right - 1
     138        });
     139    }
    128140}
    129 
    130 
     141exports.compensateScroll = compensateScroll;
    131142// Undoes compensateScroll and restores all borders/margins
    132143function uncompensateScroll(rowEls) {
    133         rowEls.css({
    134                 'margin-left': '',
    135                 'margin-right': '',
    136                 'border-left-width': '',
    137                 'border-right-width': ''
    138         });
     144    rowEls.css({
     145        'margin-left': '',
     146        'margin-right': '',
     147        'border-left-width': '',
     148        'border-right-width': ''
     149    });
    139150}
    140 
    141 
     151exports.uncompensateScroll = uncompensateScroll;
    142152// Make the mouse cursor express that an event is not allowed in the current area
    143153function disableCursor() {
    144         $('body').addClass('fc-not-allowed');
     154    $('body').addClass('fc-not-allowed');
    145155}
    146 
    147 
     156exports.disableCursor = disableCursor;
    148157// Returns the mouse cursor to its original look
    149158function enableCursor() {
    150         $('body').removeClass('fc-not-allowed');
     159    $('body').removeClass('fc-not-allowed');
    151160}
    152 
    153 
     161exports.enableCursor = enableCursor;
    154162// Given a total available height to fill, have `els` (essentially child rows) expand to accomodate.
    155163// By default, all elements that are shorter than the recommended height are expanded uniformly, not considering
    156 // any other els that are already too tall. if `shouldRedistribute` is on, it considers these tall rows and 
     164// any other els that are already too tall. if `shouldRedistribute` is on, it considers these tall rows and
    157165// reduces the available height.
    158166function distributeHeight(els, availableHeight, shouldRedistribute) {
    159 
    160         // *FLOORING NOTE*: we floor in certain places because zoom can give inaccurate floating-point dimensions,
    161         // and it is better to be shorter than taller, to avoid creating unnecessary scrollbars.
    162 
    163         var minOffset1 = Math.floor(availableHeight / els.length); // for non-last element
    164         var minOffset2 = Math.floor(availableHeight - minOffset1 * (els.length - 1)); // for last element *FLOORING NOTE*
    165         var flexEls = []; // elements that are allowed to expand. array of DOM nodes
    166         var flexOffsets = []; // amount of vertical space it takes up
    167         var flexHeights = []; // actual css height
    168         var usedHeight = 0;
    169 
    170         undistributeHeight(els); // give all elements their natural height
    171 
    172         // find elements that are below the recommended height (expandable).
    173         // important to query for heights in a single first pass (to avoid reflow oscillation).
    174         els.each(function(i, el) {
    175                 var minOffset = i === els.length - 1 ? minOffset2 : minOffset1;
    176                 var naturalOffset = $(el).outerHeight(true);
    177 
    178                 if (naturalOffset < minOffset) {
    179                         flexEls.push(el);
    180                         flexOffsets.push(naturalOffset);
    181                         flexHeights.push($(el).height());
    182                 }
    183                 else {
    184                         // this element stretches past recommended height (non-expandable). mark the space as occupied.
    185                         usedHeight += naturalOffset;
    186                 }
    187         });
    188 
    189         // readjust the recommended height to only consider the height available to non-maxed-out rows.
    190         if (shouldRedistribute) {
    191                 availableHeight -= usedHeight;
    192                 minOffset1 = Math.floor(availableHeight / flexEls.length);
    193                 minOffset2 = Math.floor(availableHeight - minOffset1 * (flexEls.length - 1)); // *FLOORING NOTE*
    194         }
    195 
    196         // assign heights to all expandable elements
    197         $(flexEls).each(function(i, el) {
    198                 var minOffset = i === flexEls.length - 1 ? minOffset2 : minOffset1;
    199                 var naturalOffset = flexOffsets[i];
    200                 var naturalHeight = flexHeights[i];
    201                 var newHeight = minOffset - (naturalOffset - naturalHeight); // subtract the margin/padding
    202 
    203                 if (naturalOffset < minOffset) { // we check this again because redistribution might have changed things
    204                         $(el).height(newHeight);
    205                 }
    206         });
     167    // *FLOORING NOTE*: we floor in certain places because zoom can give inaccurate floating-point dimensions,
     168    // and it is better to be shorter than taller, to avoid creating unnecessary scrollbars.
     169    var minOffset1 = Math.floor(availableHeight / els.length); // for non-last element
     170    var minOffset2 = Math.floor(availableHeight - minOffset1 * (els.length - 1)); // for last element *FLOORING NOTE*
     171    var flexEls = []; // elements that are allowed to expand. array of DOM nodes
     172    var flexOffsets = []; // amount of vertical space it takes up
     173    var flexHeights = []; // actual css height
     174    var usedHeight = 0;
     175    undistributeHeight(els); // give all elements their natural height
     176    // find elements that are below the recommended height (expandable).
     177    // important to query for heights in a single first pass (to avoid reflow oscillation).
     178    els.each(function (i, el) {
     179        var minOffset = i === els.length - 1 ? minOffset2 : minOffset1;
     180        var naturalOffset = $(el).outerHeight(true);
     181        if (naturalOffset < minOffset) {
     182            flexEls.push(el);
     183            flexOffsets.push(naturalOffset);
     184            flexHeights.push($(el).height());
     185        }
     186        else {
     187            // this element stretches past recommended height (non-expandable). mark the space as occupied.
     188            usedHeight += naturalOffset;
     189        }
     190    });
     191    // readjust the recommended height to only consider the height available to non-maxed-out rows.
     192    if (shouldRedistribute) {
     193        availableHeight -= usedHeight;
     194        minOffset1 = Math.floor(availableHeight / flexEls.length);
     195        minOffset2 = Math.floor(availableHeight - minOffset1 * (flexEls.length - 1)); // *FLOORING NOTE*
     196    }
     197    // assign heights to all expandable elements
     198    $(flexEls).each(function (i, el) {
     199        var minOffset = i === flexEls.length - 1 ? minOffset2 : minOffset1;
     200        var naturalOffset = flexOffsets[i];
     201        var naturalHeight = flexHeights[i];
     202        var newHeight = minOffset - (naturalOffset - naturalHeight); // subtract the margin/padding
     203        if (naturalOffset < minOffset) {
     204            $(el).height(newHeight);
     205        }
     206    });
    207207}
    208 
    209 
     208exports.distributeHeight = distributeHeight;
    210209// Undoes distrubuteHeight, restoring all els to their natural height
    211210function undistributeHeight(els) {
    212         els.height('');
     211    els.height('');
    213212}
    214 
    215 
     213exports.undistributeHeight = undistributeHeight;
    216214// Given `els`, a jQuery set of <td> cells, find the cell with the largest natural width and set the widths of all the
    217215// cells to be that width.
    218216// PREREQUISITE: if you want a cell to take up width, it needs to have a single inner element w/ display:inline
    219217function matchCellWidths(els) {
    220         var maxInnerWidth = 0;
    221 
    222         els.find('> *').each(function(i, innerEl) {
    223                 var innerWidth = $(innerEl).outerWidth();
    224                 if (innerWidth > maxInnerWidth) {
    225                         maxInnerWidth = innerWidth;
    226                 }
    227         });
    228 
    229         maxInnerWidth++; // sometimes not accurate of width the text needs to stay on one line. insurance
    230 
    231         els.width(maxInnerWidth);
    232 
    233         return maxInnerWidth;
     218    var maxInnerWidth = 0;
     219    els.find('> *').each(function (i, innerEl) {
     220        var innerWidth = $(innerEl).outerWidth();
     221        if (innerWidth > maxInnerWidth) {
     222            maxInnerWidth = innerWidth;
     223        }
     224    });
     225    maxInnerWidth++; // sometimes not accurate of width the text needs to stay on one line. insurance
     226    els.width(maxInnerWidth);
     227    return maxInnerWidth;
    234228}
    235 
    236 
     229exports.matchCellWidths = matchCellWidths;
    237230// Given one element that resides inside another,
    238231// Subtracts the height of the inner element from the outer element.
    239232function subtractInnerElHeight(outerEl, innerEl) {
    240         var both = outerEl.add(innerEl);
    241         var diff;
    242 
    243         // effin' IE8/9/10/11 sometimes returns 0 for dimensions. this weird hack was the only thing that worked
    244         both.css({
    245                 position: 'relative', // cause a reflow, which will force fresh dimension recalculation
    246                 left: -1 // ensure reflow in case the el was already relative. negative is less likely to cause new scroll
    247         });
    248         diff = outerEl.outerHeight() - innerEl.outerHeight(); // grab the dimensions
    249         both.css({ position: '', left: '' }); // undo hack
    250 
    251         return diff;
     233    var both = outerEl.add(innerEl);
     234    var diff;
     235    // effin' IE8/9/10/11 sometimes returns 0 for dimensions. this weird hack was the only thing that worked
     236    both.css({
     237        position: 'relative',
     238        left: -1 // ensure reflow in case the el was already relative. negative is less likely to cause new scroll
     239    });
     240    diff = outerEl.outerHeight() - innerEl.outerHeight(); // grab the dimensions
     241    both.css({ position: '', left: '' }); // undo hack
     242    return diff;
    252243}
    253 
    254 
     244exports.subtractInnerElHeight = subtractInnerElHeight;
    255245/* Element Geom Utilities
    256246----------------------------------------------------------------------------------------------------------------------*/
    257 
    258 FC.getOuterRect = getOuterRect;
    259 FC.getClientRect = getClientRect;
    260 FC.getContentRect = getContentRect;
    261 FC.getScrollbarWidths = getScrollbarWidths;
    262 
    263 
    264247// borrowed from https://github.com/jquery/jquery-ui/blob/1.11.0/ui/core.js#L51
    265248function getScrollParent(el) {
    266         var position = el.css('position'),
    267                 scrollParent = el.parents().filter(function() {
    268                         var parent = $(this);
    269                         return (/(auto|scroll)/).test(
    270                                 parent.css('overflow') + parent.css('overflow-y') + parent.css('overflow-x')
    271                         );
    272                 }).eq(0);
    273 
    274         return position === 'fixed' || !scrollParent.length ? $(el[0].ownerDocument || document) : scrollParent;
     249    var position = el.css('position');
     250    var scrollParent = el.parents().filter(function () {
     251        var parent = $(this);
     252        return (/(auto|scroll)/).test(parent.css('overflow') + parent.css('overflow-y') + parent.css('overflow-x'));
     253    }).eq(0);
     254    return position === 'fixed' || !scrollParent.length ? $(el[0].ownerDocument || document) : scrollParent;
    275255}
    276 
    277 
     256exports.getScrollParent = getScrollParent;
    278257// Queries the outer bounding area of a jQuery element.
    279258// Returns a rectangle with absolute coordinates: left, right (exclusive), top, bottom (exclusive).
    280259// Origin is optional.
    281260function getOuterRect(el, origin) {
    282         var offset = el.offset();
    283         var left = offset.left - (origin ? origin.left : 0);
    284         var top = offset.top - (origin ? origin.top : 0);
    285 
    286         return {
    287                 left: left,
    288                 right: left + el.outerWidth(),
    289                 top: top,
    290                 bottom: top + el.outerHeight()
    291         };
     261    var offset = el.offset();
     262    var left = offset.left - (origin ? origin.left : 0);
     263    var top = offset.top - (origin ? origin.top : 0);
     264    return {
     265        left: left,
     266        right: left + el.outerWidth(),
     267        top: top,
     268        bottom: top + el.outerHeight()
     269    };
    292270}
    293 
    294 
     271exports.getOuterRect = getOuterRect;
    295272// Queries the area within the margin/border/scrollbars of a jQuery element. Does not go within the padding.
    296273// Returns a rectangle with absolute coordinates: left, right (exclusive), top, bottom (exclusive).
     
    299276// NOTE: should use clientLeft/clientTop, but very unreliable cross-browser.
    300277function getClientRect(el, origin) {
    301         var offset = el.offset();
    302         var scrollbarWidths = getScrollbarWidths(el);
    303         var left = offset.left + getCssFloat(el, 'border-left-width') + scrollbarWidths.left - (origin ? origin.left : 0);
    304         var top = offset.top + getCssFloat(el, 'border-top-width') + scrollbarWidths.top - (origin ? origin.top : 0);
    305 
    306         return {
    307                 left: left,
    308                 right: left + el[0].clientWidth, // clientWidth includes padding but NOT scrollbars
    309                 top: top,
    310                 bottom: top + el[0].clientHeight // clientHeight includes padding but NOT scrollbars
    311         };
     278    var offset = el.offset();
     279    var scrollbarWidths = getScrollbarWidths(el);
     280    var left = offset.left + getCssFloat(el, 'border-left-width') + scrollbarWidths.left - (origin ? origin.left : 0);
     281    var top = offset.top + getCssFloat(el, 'border-top-width') + scrollbarWidths.top - (origin ? origin.top : 0);
     282    return {
     283        left: left,
     284        right: left + el[0].clientWidth,
     285        top: top,
     286        bottom: top + el[0].clientHeight // clientHeight includes padding but NOT scrollbars
     287    };
    312288}
    313 
    314 
     289exports.getClientRect = getClientRect;
    315290// Queries the area within the margin/border/padding of a jQuery element. Assumed not to have scrollbars.
    316291// Returns a rectangle with absolute coordinates: left, right (exclusive), top, bottom (exclusive).
    317292// Origin is optional.
    318293function getContentRect(el, origin) {
    319         var offset = el.offset(); // just outside of border, margin not included
    320         var left = offset.left + getCssFloat(el, 'border-left-width') + getCssFloat(el, 'padding-left') -
    321                 (origin ? origin.left : 0);
    322         var top = offset.top + getCssFloat(el, 'border-top-width') + getCssFloat(el, 'padding-top') -
    323                 (origin ? origin.top : 0);
    324 
    325         return {
    326                 left: left,
    327                 right: left + el.width(),
    328                 top: top,
    329                 bottom: top + el.height()
    330         };
     294    var offset = el.offset(); // just outside of border, margin not included
     295    var left = offset.left + getCssFloat(el, 'border-left-width') + getCssFloat(el, 'padding-left') -
     296        (origin ? origin.left : 0);
     297    var top = offset.top + getCssFloat(el, 'border-top-width') + getCssFloat(el, 'padding-top') -
     298        (origin ? origin.top : 0);
     299    return {
     300        left: left,
     301        right: left + el.width(),
     302        top: top,
     303        bottom: top + el.height()
     304    };
    331305}
    332 
    333 
     306exports.getContentRect = getContentRect;
    334307// Returns the computed left/right/top/bottom scrollbar widths for the given jQuery element.
    335308// WARNING: given element can't have borders (which will cause offsetWidth/offsetHeight to be larger).
    336309// NOTE: should use clientLeft/clientTop, but very unreliable cross-browser.
    337310function getScrollbarWidths(el) {
    338         var leftRightWidth = el[0].offsetWidth - el[0].clientWidth;
    339         var bottomWidth = el[0].offsetHeight - el[0].clientHeight;
    340         var widths;
    341 
    342         leftRightWidth = sanitizeScrollbarWidth(leftRightWidth);
    343         bottomWidth = sanitizeScrollbarWidth(bottomWidth);
    344 
    345         widths = { left: 0, right: 0, top: 0, bottom: bottomWidth };
    346 
    347         if (getIsLeftRtlScrollbars() && el.css('direction') == 'rtl') { // is the scrollbar on the left side?
    348                 widths.left = leftRightWidth;
    349         }
    350         else {
    351                 widths.right = leftRightWidth;
    352         }
    353 
    354         return widths;
     311    var leftRightWidth = el[0].offsetWidth - el[0].clientWidth;
     312    var bottomWidth = el[0].offsetHeight - el[0].clientHeight;
     313    var widths;
     314    leftRightWidth = sanitizeScrollbarWidth(leftRightWidth);
     315    bottomWidth = sanitizeScrollbarWidth(bottomWidth);
     316    widths = { left: 0, right: 0, top: 0, bottom: bottomWidth };
     317    if (getIsLeftRtlScrollbars() && el.css('direction') === 'rtl') {
     318        widths.left = leftRightWidth;
     319    }
     320    else {
     321        widths.right = leftRightWidth;
     322    }
     323    return widths;
    355324}
    356 
    357 
     325exports.getScrollbarWidths = getScrollbarWidths;
    358326// The scrollbar width computations in getScrollbarWidths are sometimes flawed when it comes to
    359327// retina displays, rounding, and IE11. Massage them into a usable value.
    360328function sanitizeScrollbarWidth(width) {
    361         width = Math.max(0, width); // no negatives
    362         width = Math.round(width);
    363         return width;
     329    width = Math.max(0, width); // no negatives
     330    width = Math.round(width);
     331    return width;
    364332}
    365 
    366 
    367333// Logic for determining if, when the element is right-to-left, the scrollbar appears on the left side
    368 
    369334var _isLeftRtlScrollbars = null;
    370 
    371 function getIsLeftRtlScrollbars() { // responsible for caching the computation
    372         if (_isLeftRtlScrollbars === null) {
    373                 _isLeftRtlScrollbars = computeIsLeftRtlScrollbars();
    374         }
    375         return _isLeftRtlScrollbars;
     335function getIsLeftRtlScrollbars() {
     336    if (_isLeftRtlScrollbars === null) {
     337        _isLeftRtlScrollbars = computeIsLeftRtlScrollbars();
     338    }
     339    return _isLeftRtlScrollbars;
    376340}
    377 
    378 function computeIsLeftRtlScrollbars() { // creates an offscreen test element, then removes it
    379         var el = $('<div><div/></div>')
    380                 .css({
    381                         position: 'absolute',
    382                         top: -1000,
    383                         left: 0,
    384                         border: 0,
    385                         padding: 0,
    386                         overflow: 'scroll',
    387                         direction: 'rtl'
    388                 })
    389                 .appendTo('body');
    390         var innerEl = el.children();
    391         var res = innerEl.offset().left > el.offset().left; // is the inner div shifted to accommodate a left scrollbar?
    392         el.remove();
    393         return res;
     341function computeIsLeftRtlScrollbars() {
     342    var el = $('<div><div/></div>')
     343        .css({
     344        position: 'absolute',
     345        top: -1000,
     346        left: 0,
     347        border: 0,
     348        padding: 0,
     349        overflow: 'scroll',
     350        direction: 'rtl'
     351    })
     352        .appendTo('body');
     353    var innerEl = el.children();
     354    var res = innerEl.offset().left > el.offset().left; // is the inner div shifted to accommodate a left scrollbar?
     355    el.remove();
     356    return res;
    394357}
    395 
    396 
    397358// Retrieves a jQuery element's computed CSS value as a floating-point number.
    398359// If the queried value is non-numeric (ex: IE can return "medium" for border width), will just return zero.
    399360function getCssFloat(el, prop) {
    400         return parseFloat(el.css(prop)) || 0;
     361    return parseFloat(el.css(prop)) || 0;
    401362}
    402 
    403 
    404363/* Mouse / Touch Utilities
    405364----------------------------------------------------------------------------------------------------------------------*/
    406 
    407 FC.preventDefault = preventDefault;
    408 
    409 
    410365// Returns a boolean whether this was a left mouse click and no ctrl key (which means right click on Mac)
    411366function isPrimaryMouseButton(ev) {
    412         return ev.which == 1 && !ev.ctrlKey;
     367    return ev.which === 1 && !ev.ctrlKey;
    413368}
    414 
    415 
     369exports.isPrimaryMouseButton = isPrimaryMouseButton;
    416370function getEvX(ev) {
    417         var touches = ev.originalEvent.touches;
    418 
    419         // on mobile FF, pageX for touch events is present, but incorrect,
    420         // so, look at touch coordinates first.
    421         if (touches && touches.length) {
    422                 return touches[0].pageX;
    423         }
    424 
    425         return ev.pageX;
     371    var touches = ev.originalEvent.touches;
     372    // on mobile FF, pageX for touch events is present, but incorrect,
     373    // so, look at touch coordinates first.
     374    if (touches && touches.length) {
     375        return touches[0].pageX;
     376    }
     377    return ev.pageX;
    426378}
    427 
    428 
     379exports.getEvX = getEvX;
    429380function getEvY(ev) {
    430         var touches = ev.originalEvent.touches;
    431 
    432         // on mobile FF, pageX for touch events is present, but incorrect,
    433         // so, look at touch coordinates first.
    434         if (touches && touches.length) {
    435                 return touches[0].pageY;
    436         }
    437 
    438         return ev.pageY;
     381    var touches = ev.originalEvent.touches;
     382    // on mobile FF, pageX for touch events is present, but incorrect,
     383    // so, look at touch coordinates first.
     384    if (touches && touches.length) {
     385        return touches[0].pageY;
     386    }
     387    return ev.pageY;
    439388}
    440 
    441 
     389exports.getEvY = getEvY;
    442390function getEvIsTouch(ev) {
    443         return /^touch/.test(ev.type);
     391    return /^touch/.test(ev.type);
    444392}
    445 
    446 
     393exports.getEvIsTouch = getEvIsTouch;
    447394function preventSelection(el) {
    448         el.addClass('fc-unselectable')
    449                 .on('selectstart', preventDefault);
     395    el.addClass('fc-unselectable')
     396        .on('selectstart', preventDefault);
    450397}
    451 
    452 
     398exports.preventSelection = preventSelection;
    453399function allowSelection(el) {
    454         el.removeClass('fc-unselectable')
    455                 .off('selectstart', preventDefault);
     400    el.removeClass('fc-unselectable')
     401        .off('selectstart', preventDefault);
    456402}
    457 
    458 
     403exports.allowSelection = allowSelection;
    459404// Stops a mouse/touch event from doing it's native browser action
    460405function preventDefault(ev) {
    461         ev.preventDefault();
     406    ev.preventDefault();
    462407}
    463 
    464 
     408exports.preventDefault = preventDefault;
    465409/* General Geometry Utils
    466410----------------------------------------------------------------------------------------------------------------------*/
    467 
    468 FC.intersectRects = intersectRects;
    469 
    470411// Returns a new rectangle that is the intersection of the two rectangles. If they don't intersect, returns false
    471412function intersectRects(rect1, rect2) {
    472         var res = {
    473                 left: Math.max(rect1.left, rect2.left),
    474                 right: Math.min(rect1.right, rect2.right),
    475                 top: Math.max(rect1.top, rect2.top),
    476                 bottom: Math.min(rect1.bottom, rect2.bottom)
    477         };
    478 
    479         if (res.left < res.right && res.top < res.bottom) {
    480                 return res;
    481         }
    482         return false;
     413    var res = {
     414        left: Math.max(rect1.left, rect2.left),
     415        right: Math.min(rect1.right, rect2.right),
     416        top: Math.max(rect1.top, rect2.top),
     417        bottom: Math.min(rect1.bottom, rect2.bottom)
     418    };
     419    if (res.left < res.right && res.top < res.bottom) {
     420        return res;
     421    }
     422    return false;
    483423}
    484 
    485 
     424exports.intersectRects = intersectRects;
    486425// Returns a new point that will have been moved to reside within the given rectangle
    487426function constrainPoint(point, rect) {
    488         return {
    489                 left: Math.min(Math.max(point.left, rect.left), rect.right),
    490                 top: Math.min(Math.max(point.top, rect.top), rect.bottom)
    491         };
     427    return {
     428        left: Math.min(Math.max(point.left, rect.left), rect.right),
     429        top: Math.min(Math.max(point.top, rect.top), rect.bottom)
     430    };
    492431}
    493 
    494 
     432exports.constrainPoint = constrainPoint;
    495433// Returns a point that is the center of the given rectangle
    496434function getRectCenter(rect) {
    497         return {
    498                 left: (rect.left + rect.right) / 2,
    499                 top: (rect.top + rect.bottom) / 2
    500         };
     435    return {
     436        left: (rect.left + rect.right) / 2,
     437        top: (rect.top + rect.bottom) / 2
     438    };
    501439}
    502 
    503 
     440exports.getRectCenter = getRectCenter;
    504441// Subtracts point2's coordinates from point1's coordinates, returning a delta
    505442function diffPoints(point1, point2) {
    506         return {
    507                 left: point1.left - point2.left,
    508                 top: point1.top - point2.top
    509         };
     443    return {
     444        left: point1.left - point2.left,
     445        top: point1.top - point2.top
     446    };
    510447}
    511 
    512 
     448exports.diffPoints = diffPoints;
    513449/* Object Ordering by Field
    514450----------------------------------------------------------------------------------------------------------------------*/
    515 
    516 FC.parseFieldSpecs = parseFieldSpecs;
    517 FC.compareByFieldSpecs = compareByFieldSpecs;
    518 FC.compareByFieldSpec = compareByFieldSpec;
    519 FC.flexibleCompare = flexibleCompare;
    520 
    521 
    522451function parseFieldSpecs(input) {
    523         var specs = [];
    524         var tokens = [];
    525         var i, token;
    526 
    527         if (typeof input === 'string') {
    528                 tokens = input.split(/\s*,\s*/);
    529         }
    530         else if (typeof input === 'function') {
    531                 tokens = [ input ];
    532         }
    533         else if ($.isArray(input)) {
    534                 tokens = input;
    535         }
    536 
    537         for (i = 0; i < tokens.length; i++) {
    538                 token = tokens[i];
    539 
    540                 if (typeof token === 'string') {
    541                         specs.push(
    542                                 token.charAt(0) == '-' ?
    543                                         { field: token.substring(1), order: -1 } :
    544                                         { field: token, order: 1 }
    545                         );
    546                 }
    547                 else if (typeof token === 'function') {
    548                         specs.push({ func: token });
    549                 }
    550         }
    551 
    552         return specs;
     452    var specs = [];
     453    var tokens = [];
     454    var i;
     455    var token;
     456    if (typeof input === 'string') {
     457        tokens = input.split(/\s*,\s*/);
     458    }
     459    else if (typeof input === 'function') {
     460        tokens = [input];
     461    }
     462    else if ($.isArray(input)) {
     463        tokens = input;
     464    }
     465    for (i = 0; i < tokens.length; i++) {
     466        token = tokens[i];
     467        if (typeof token === 'string') {
     468            specs.push(token.charAt(0) === '-' ?
     469                { field: token.substring(1), order: -1 } :
     470                { field: token, order: 1 });
     471        }
     472        else if (typeof token === 'function') {
     473            specs.push({ func: token });
     474        }
     475    }
     476    return specs;
    553477}
    554 
    555 
    556 function compareByFieldSpecs(obj1, obj2, fieldSpecs) {
    557         var i;
    558         var cmp;
    559 
    560         for (i = 0; i < fieldSpecs.length; i++) {
    561                 cmp = compareByFieldSpec(obj1, obj2, fieldSpecs[i]);
    562                 if (cmp) {
    563                         return cmp;
    564                 }
    565         }
    566 
    567         return 0;
     478exports.parseFieldSpecs = parseFieldSpecs;
     479function compareByFieldSpecs(obj1, obj2, fieldSpecs, obj1fallback, obj2fallback) {
     480    var i;
     481    var cmp;
     482    for (i = 0; i < fieldSpecs.length; i++) {
     483        cmp = compareByFieldSpec(obj1, obj2, fieldSpecs[i], obj1fallback, obj2fallback);
     484        if (cmp) {
     485            return cmp;
     486        }
     487    }
     488    return 0;
    568489}
    569 
    570 
    571 function compareByFieldSpec(obj1, obj2, fieldSpec) {
    572         if (fieldSpec.func) {
    573                 return fieldSpec.func(obj1, obj2);
    574         }
    575         return flexibleCompare(obj1[fieldSpec.field], obj2[fieldSpec.field]) *
    576                 (fieldSpec.order || 1);
     490exports.compareByFieldSpecs = compareByFieldSpecs;
     491function compareByFieldSpec(obj1, obj2, fieldSpec, obj1fallback, obj2fallback) {
     492    if (fieldSpec.func) {
     493        return fieldSpec.func(obj1, obj2);
     494    }
     495    var val1 = obj1[fieldSpec.field];
     496    var val2 = obj2[fieldSpec.field];
     497    if (val1 == null && obj1fallback) {
     498        val1 = obj1fallback[fieldSpec.field];
     499    }
     500    if (val2 == null && obj2fallback) {
     501        val2 = obj2fallback[fieldSpec.field];
     502    }
     503    return flexibleCompare(val1, val2) * (fieldSpec.order || 1);
    577504}
    578 
    579 
     505exports.compareByFieldSpec = compareByFieldSpec;
    580506function flexibleCompare(a, b) {
    581         if (!a && !b) {
    582                 return 0;
    583         }
    584         if (b == null) {
    585                 return -1;
    586         }
    587         if (a == null) {
    588                 return 1;
    589         }
    590         if ($.type(a) === 'string' || $.type(b) === 'string') {
    591                 return String(a).localeCompare(String(b));
    592         }
    593         return a - b;
     507    if (!a && !b) {
     508        return 0;
     509    }
     510    if (b == null) {
     511        return -1;
     512    }
     513    if (a == null) {
     514        return 1;
     515    }
     516    if ($.type(a) === 'string' || $.type(b) === 'string') {
     517        return String(a).localeCompare(String(b));
     518    }
     519    return a - b;
    594520}
    595 
    596 
     521exports.flexibleCompare = flexibleCompare;
    597522/* Date Utilities
    598523----------------------------------------------------------------------------------------------------------------------*/
    599 
    600 FC.computeGreatestUnit = computeGreatestUnit;
    601 FC.divideRangeByDuration = divideRangeByDuration;
    602 FC.divideDurationByDuration = divideDurationByDuration;
    603 FC.multiplyDuration = multiplyDuration;
    604 FC.durationHasTime = durationHasTime;
    605 
    606 var dayIDs = [ 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat' ];
    607 var unitsDesc = [ 'year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond' ]; // descending
    608 
    609 
     524exports.dayIDs = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
     525exports.unitsDesc = ['year', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond']; // descending
    610526// Diffs the two moments into a Duration where full-days are recorded first, then the remaining time.
    611527// Moments will have their timezones normalized.
    612528function diffDayTime(a, b) {
    613         return moment.duration({
    614                 days: a.clone().stripTime().diff(b.clone().stripTime(), 'days'),
    615                 ms: a.time() - b.time() // time-of-day from day start. disregards timezone
    616         });
     529    return moment.duration({
     530        days: a.clone().stripTime().diff(b.clone().stripTime(), 'days'),
     531        ms: a.time() - b.time() // time-of-day from day start. disregards timezone
     532    });
    617533}
    618 
    619 
     534exports.diffDayTime = diffDayTime;
    620535// Diffs the two moments via their start-of-day (regardless of timezone). Produces whole-day durations.
    621536function diffDay(a, b) {
    622         return moment.duration({
    623                 days: a.clone().stripTime().diff(b.clone().stripTime(), 'days')
    624         });
     537    return moment.duration({
     538        days: a.clone().stripTime().diff(b.clone().stripTime(), 'days')
     539    });
    625540}
    626 
    627 
     541exports.diffDay = diffDay;
    628542// Diffs two moments, producing a duration, made of a whole-unit-increment of the given unit. Uses rounding.
    629543function diffByUnit(a, b, unit) {
    630         return moment.duration(
    631                 Math.round(a.diff(b, unit, true)), // returnFloat=true
    632                 unit
    633         );
     544    return moment.duration(Math.round(a.diff(b, unit, true)), // returnFloat=true
     545    unit);
    634546}
    635 
    636 
     547exports.diffByUnit = diffByUnit;
    637548// Computes the unit name of the largest whole-unit period of time.
    638549// For example, 48 hours will be "days" whereas 49 hours will be "hours".
    639550// Accepts start/end, a range object, or an original duration object.
    640551function computeGreatestUnit(start, end) {
    641         var i, unit;
    642         var val;
    643 
    644         for (i = 0; i < unitsDesc.length; i++) {
    645                 unit = unitsDesc[i];
    646                 val = computeRangeAs(unit, start, end);
    647 
    648                 if (val >= 1 && isInt(val)) {
    649                         break;
    650                 }
    651         }
    652 
    653         return unit; // will be "milliseconds" if nothing else matches
     552    var i;
     553    var unit;
     554    var val;
     555    for (i = 0; i < exports.unitsDesc.length; i++) {
     556        unit = exports.unitsDesc[i];
     557        val = computeRangeAs(unit, start, end);
     558        if (val >= 1 && isInt(val)) {
     559            break;
     560        }
     561    }
     562    return unit; // will be "milliseconds" if nothing else matches
    654563}
    655 
    656 
     564exports.computeGreatestUnit = computeGreatestUnit;
    657565// like computeGreatestUnit, but has special abilities to interpret the source input for clues
    658566function computeDurationGreatestUnit(duration, durationInput) {
    659         var unit = computeGreatestUnit(duration);
    660 
    661         // prevent days:7 from being interpreted as a week
    662         if (unit === 'week' && typeof durationInput === 'object' && durationInput.days) {
    663                 unit = 'day';
    664         }
    665 
    666         return unit;
     567    var unit = computeGreatestUnit(duration);
     568    // prevent days:7 from being interpreted as a week
     569    if (unit === 'week' && typeof durationInput === 'object' && durationInput.days) {
     570        unit = 'day';
     571    }
     572    return unit;
    667573}
    668 
    669 
     574exports.computeDurationGreatestUnit = computeDurationGreatestUnit;
    670575// Computes the number of units (like "hours") in the given range.
    671576// Range can be a {start,end} object, separate start/end args, or a Duration.
     
    673578// of month-diffing logic (which tends to vary from version to version).
    674579function computeRangeAs(unit, start, end) {
    675 
    676         if (end != null) { // given start, end
    677                 return end.diff(start, unit, true);
    678         }
    679         else if (moment.isDuration(start)) { // given duration
    680                 return start.as(unit);
    681         }
    682         else { // given { start, end } range object
    683                 return start.end.diff(start.start, unit, true);
    684         }
     580    if (end != null) {
     581        return end.diff(start, unit, true);
     582    }
     583    else if (moment.isDuration(start)) {
     584        return start.as(unit);
     585    }
     586    else {
     587        return start.end.diff(start.start, unit, true);
     588    }
    685589}
    686 
    687 
    688590// Intelligently divides a range (specified by a start/end params) by a duration
    689591function divideRangeByDuration(start, end, dur) {
    690         var months;
    691 
    692         if (durationHasTime(dur)) {
    693                 return (end - start) / dur;
    694         }
    695         months = dur.asMonths();
    696         if (Math.abs(months) >= 1 && isInt(months)) {
    697                 return end.diff(start, 'months', true) / months;
    698         }
    699         return end.diff(start, 'days', true) / dur.asDays();
     592    var months;
     593    if (durationHasTime(dur)) {
     594        return (end - start) / dur;
     595    }
     596    months = dur.asMonths();
     597    if (Math.abs(months) >= 1 && isInt(months)) {
     598        return end.diff(start, 'months', true) / months;
     599    }
     600    return end.diff(start, 'days', true) / dur.asDays();
    700601}
    701 
    702 
     602exports.divideRangeByDuration = divideRangeByDuration;
    703603// Intelligently divides one duration by another
    704604function divideDurationByDuration(dur1, dur2) {
    705         var months1, months2;
    706 
    707         if (durationHasTime(dur1) || durationHasTime(dur2)) {
    708                 return dur1 / dur2;
    709         }
    710         months1 = dur1.asMonths();
    711         months2 = dur2.asMonths();
    712         if (
    713                 Math.abs(months1) >= 1 && isInt(months1) &&
    714                 Math.abs(months2) >= 1 && isInt(months2)
    715         ) {
    716                 return months1 / months2;
    717         }
    718         return dur1.asDays() / dur2.asDays();
     605    var months1;
     606    var months2;
     607    if (durationHasTime(dur1) || durationHasTime(dur2)) {
     608        return dur1 / dur2;
     609    }
     610    months1 = dur1.asMonths();
     611    months2 = dur2.asMonths();
     612    if (Math.abs(months1) >= 1 && isInt(months1) &&
     613        Math.abs(months2) >= 1 && isInt(months2)) {
     614        return months1 / months2;
     615    }
     616    return dur1.asDays() / dur2.asDays();
    719617}
    720 
    721 
     618exports.divideDurationByDuration = divideDurationByDuration;
    722619// Intelligently multiplies a duration by a number
    723620function multiplyDuration(dur, n) {
    724         var months;
    725 
    726         if (durationHasTime(dur)) {
    727                 return moment.duration(dur * n);
    728         }
    729         months = dur.asMonths();
    730         if (Math.abs(months) >= 1 && isInt(months)) {
    731                 return moment.duration({ months: months * n });
    732         }
    733         return moment.duration({ days: dur.asDays() * n });
     621    var months;
     622    if (durationHasTime(dur)) {
     623        return moment.duration(dur * n);
     624    }
     625    months = dur.asMonths();
     626    if (Math.abs(months) >= 1 && isInt(months)) {
     627        return moment.duration({ months: months * n });
     628    }
     629    return moment.duration({ days: dur.asDays() * n });
    734630}
    735 
    736 
     631exports.multiplyDuration = multiplyDuration;
    737632// Returns a boolean about whether the given duration has any time parts (hours/minutes/seconds/ms)
    738633function durationHasTime(dur) {
    739         return Boolean(dur.hours() || dur.minutes() || dur.seconds() || dur.milliseconds());
     634    return Boolean(dur.hours() || dur.minutes() || dur.seconds() || dur.milliseconds());
    740635}
    741 
    742 
     636exports.durationHasTime = durationHasTime;
    743637function isNativeDate(input) {
    744         return Object.prototype.toString.call(input) === '[object Date]' || input instanceof Date;
     638    return Object.prototype.toString.call(input) === '[object Date]' || input instanceof Date;
    745639}
    746 
    747 
     640exports.isNativeDate = isNativeDate;
    748641// Returns a boolean about whether the given input is a time string, like "06:40:00" or "06:00"
    749642function isTimeString(str) {
    750         return typeof str === 'string' &&
    751                 /^\d+\:\d+(?:\:\d+\.?(?:\d{3})?)?$/.test(str);
     643    return typeof str === 'string' &&
     644        /^\d+\:\d+(?:\:\d+\.?(?:\d{3})?)?$/.test(str);
    752645}
    753 
    754 
     646exports.isTimeString = isTimeString;
    755647/* Logging and Debug
    756648----------------------------------------------------------------------------------------------------------------------*/
    757 
    758 FC.log = function() {
    759         var console = window.console;
    760 
    761         if (console && console.log) {
    762                 return console.log.apply(console, arguments);
    763         }
    764 };
    765 
    766 FC.warn = function() {
    767         var console = window.console;
    768 
    769         if (console && console.warn) {
    770                 return console.warn.apply(console, arguments);
    771         }
    772         else {
    773                 return FC.log.apply(FC, arguments);
    774         }
    775 };
    776 
    777 
     649function log() {
     650    var args = [];
     651    for (var _i = 0; _i < arguments.length; _i++) {
     652        args[_i] = arguments[_i];
     653    }
     654    var console = window.console;
     655    if (console && console.log) {
     656        return console.log.apply(console, args);
     657    }
     658}
     659exports.log = log;
     660function warn() {
     661    var args = [];
     662    for (var _i = 0; _i < arguments.length; _i++) {
     663        args[_i] = arguments[_i];
     664    }
     665    var console = window.console;
     666    if (console && console.warn) {
     667        return console.warn.apply(console, args);
     668    }
     669    else {
     670        return log.apply(null, args);
     671    }
     672}
     673exports.warn = warn;
    778674/* General Utilities
    779675----------------------------------------------------------------------------------------------------------------------*/
    780 
    781676var hasOwnPropMethod = {}.hasOwnProperty;
    782 
    783 
    784677// Merges an array of objects into a single object.
    785678// The second argument allows for an array of property names who's object values will be merged together.
    786679function mergeProps(propObjs, complexProps) {
    787         var dest = {};
    788         var i, name;
    789         var complexObjs;
    790         var j, val;
    791         var props;
    792 
    793         if (complexProps) {
    794                 for (i = 0; i < complexProps.length; i++) {
    795                         name = complexProps[i];
    796                         complexObjs = [];
    797 
    798                         // collect the trailing object values, stopping when a non-object is discovered
    799                         for (j = propObjs.length - 1; j >= 0; j--) {
    800                                 val = propObjs[j][name];
    801 
    802                                 if (typeof val === 'object') {
    803                                         complexObjs.unshift(val);
    804                                 }
    805                                 else if (val !== undefined) {
    806                                         dest[name] = val; // if there were no objects, this value will be used
    807                                         break;
    808                                 }
    809                         }
    810 
    811                         // if the trailing values were objects, use the merged value
    812                         if (complexObjs.length) {
    813                                 dest[name] = mergeProps(complexObjs);
    814                         }
    815                 }
    816         }
    817 
    818         // copy values into the destination, going from last to first
    819         for (i = propObjs.length - 1; i >= 0; i--) {
    820                 props = propObjs[i];
    821 
    822                 for (name in props) {
    823                         if (!(name in dest)) { // if already assigned by previous props or complex props, don't reassign
    824                                 dest[name] = props[name];
    825                         }
    826                 }
    827         }
    828 
    829         return dest;
     680    var dest = {};
     681    var i;
     682    var name;
     683    var complexObjs;
     684    var j;
     685    var val;
     686    var props;
     687    if (complexProps) {
     688        for (i = 0; i < complexProps.length; i++) {
     689            name = complexProps[i];
     690            complexObjs = [];
     691            // collect the trailing object values, stopping when a non-object is discovered
     692            for (j = propObjs.length - 1; j >= 0; j--) {
     693                val = propObjs[j][name];
     694                if (typeof val === 'object') {
     695                    complexObjs.unshift(val);
     696                }
     697                else if (val !== undefined) {
     698                    dest[name] = val; // if there were no objects, this value will be used
     699                    break;
     700                }
     701            }
     702            // if the trailing values were objects, use the merged value
     703            if (complexObjs.length) {
     704                dest[name] = mergeProps(complexObjs);
     705            }
     706        }
     707    }
     708    // copy values into the destination, going from last to first
     709    for (i = propObjs.length - 1; i >= 0; i--) {
     710        props = propObjs[i];
     711        for (name in props) {
     712            if (!(name in dest)) {
     713                dest[name] = props[name];
     714            }
     715        }
     716    }
     717    return dest;
    830718}
    831 
    832 
     719exports.mergeProps = mergeProps;
    833720function copyOwnProps(src, dest) {
    834         for (var name in src) {
    835                 if (hasOwnProp(src, name)) {
    836                         dest[name] = src[name];
    837                 }
    838         }
     721    for (var name_1 in src) {
     722        if (hasOwnProp(src, name_1)) {
     723            dest[name_1] = src[name_1];
     724        }
     725    }
    839726}
    840 
    841 
     727exports.copyOwnProps = copyOwnProps;
    842728function hasOwnProp(obj, name) {
    843         return hasOwnPropMethod.call(obj, name);
     729    return hasOwnPropMethod.call(obj, name);
    844730}
    845 
    846 
     731exports.hasOwnProp = hasOwnProp;
    847732function applyAll(functions, thisObj, args) {
    848         if ($.isFunction(functions)) {
    849                 functions = [ functions ];
    850         }
    851         if (functions) {
    852                 var i;
    853                 var ret;
    854                 for (i=0; i<functions.length; i++) {
    855                         ret = functions[i].apply(thisObj, args) || ret;
    856                 }
    857                 return ret;
    858         }
     733    if ($.isFunction(functions)) {
     734        functions = [functions];
     735    }
     736    if (functions) {
     737        var i = void 0;
     738        var ret = void 0;
     739        for (i = 0; i < functions.length; i++) {
     740            ret = functions[i].apply(thisObj, args) || ret;
     741        }
     742        return ret;
     743    }
    859744}
    860 
    861 
     745exports.applyAll = applyAll;
    862746function removeMatching(array, testFunc) {
    863         var removeCnt = 0;
    864         var i = 0;
    865 
    866         while (i < array.length) {
    867                 if (testFunc(array[i])) { // truthy value means *remove*
    868                         array.splice(i, 1);
    869                         removeCnt++;
    870                 }
    871                 else {
    872                         i++;
    873                 }
    874         }
    875 
    876         return removeCnt;
     747    var removeCnt = 0;
     748    var i = 0;
     749    while (i < array.length) {
     750        if (testFunc(array[i])) {
     751            array.splice(i, 1);
     752            removeCnt++;
     753        }
     754        else {
     755            i++;
     756        }
     757    }
     758    return removeCnt;
    877759}
    878 
    879 
     760exports.removeMatching = removeMatching;
    880761function removeExact(array, exactVal) {
    881         var removeCnt = 0;
    882         var i = 0;
    883 
    884         while (i < array.length) {
    885                 if (array[i] === exactVal) {
    886                         array.splice(i, 1);
    887                         removeCnt++;
    888                 }
    889                 else {
    890                         i++;
    891                 }
    892         }
    893 
    894         return removeCnt;
     762    var removeCnt = 0;
     763    var i = 0;
     764    while (i < array.length) {
     765        if (array[i] === exactVal) {
     766            array.splice(i, 1);
     767            removeCnt++;
     768        }
     769        else {
     770            i++;
     771        }
     772    }
     773    return removeCnt;
    895774}
    896 FC.removeExact = removeExact;
    897 
    898 
    899 
     775exports.removeExact = removeExact;
     776function isArraysEqual(a0, a1) {
     777    var len = a0.length;
     778    var i;
     779    if (len == null || len !== a1.length) {
     780        return false;
     781    }
     782    for (i = 0; i < len; i++) {
     783        if (a0[i] !== a1[i]) {
     784            return false;
     785        }
     786    }
     787    return true;
     788}
     789exports.isArraysEqual = isArraysEqual;
    900790function firstDefined() {
    901         for (var i=0; i<arguments.length; i++) {
    902                 if (arguments[i] !== undefined) {
    903                         return arguments[i];
    904                 }
    905         }
     791    var args = [];
     792    for (var _i = 0; _i < arguments.length; _i++) {
     793        args[_i] = arguments[_i];
     794    }
     795    for (var i = 0; i < args.length; i++) {
     796        if (args[i] !== undefined) {
     797            return args[i];
     798        }
     799    }
    906800}
    907 
    908 
     801exports.firstDefined = firstDefined;
    909802function htmlEscape(s) {
    910         return (s + '').replace(/&/g, '&amp;')
    911                 .replace(/</g, '&lt;')
    912                 .replace(/>/g, '&gt;')
    913                 .replace(/'/g, '&#039;')
    914                 .replace(/"/g, '&quot;')
    915                 .replace(/\n/g, '<br />');
     803    return (s + '').replace(/&/g, '&amp;')
     804        .replace(/</g, '&lt;')
     805        .replace(/>/g, '&gt;')
     806        .replace(/'/g, '&#039;')
     807        .replace(/"/g, '&quot;')
     808        .replace(/\n/g, '<br />');
    916809}
    917 
    918 
     810exports.htmlEscape = htmlEscape;
    919811function stripHtmlEntities(text) {
    920         return text.replace(/&.*?;/g, '');
     812    return text.replace(/&.*?;/g, '');
    921813}
    922 
    923 
     814exports.stripHtmlEntities = stripHtmlEntities;
    924815// Given a hash of CSS properties, returns a string of CSS.
    925816// Uses property names as-is (no camel-case conversion). Will not make statements for null/undefined values.
    926817function cssToStr(cssProps) {
    927         var statements = [];
    928 
    929         $.each(cssProps, function(name, val) {
    930                 if (val != null) {
    931                         statements.push(name + ':' + val);
    932                 }
    933         });
    934 
    935         return statements.join(';');
     818    var statements = [];
     819    $.each(cssProps, function (name, val) {
     820        if (val != null) {
     821            statements.push(name + ':' + val);
     822        }
     823    });
     824    return statements.join(';');
    936825}
    937 
    938 
     826exports.cssToStr = cssToStr;
    939827// Given an object hash of HTML attribute names to values,
    940828// generates a string that can be injected between < > in HTML
    941829function attrsToStr(attrs) {
    942         var parts = [];
    943 
    944         $.each(attrs, function(name, val) {
    945                 if (val != null) {
    946                         parts.push(name + '="' + htmlEscape(val) + '"');
    947                 }
    948         });
    949 
    950         return parts.join(' ');
     830    var parts = [];
     831    $.each(attrs, function (name, val) {
     832        if (val != null) {
     833            parts.push(name + '="' + htmlEscape(val) + '"');
     834        }
     835    });
     836    return parts.join(' ');
    951837}
    952 
    953 
     838exports.attrsToStr = attrsToStr;
    954839function capitaliseFirstLetter(str) {
    955         return str.charAt(0).toUpperCase() + str.slice(1);
     840    return str.charAt(0).toUpperCase() + str.slice(1);
    956841}
    957 
    958 
    959 function compareNumbers(a, b) { // for .sort()
    960         return a - b;
     842exports.capitaliseFirstLetter = capitaliseFirstLetter;
     843function compareNumbers(a, b) {
     844    return a - b;
    961845}
    962 
    963 
     846exports.compareNumbers = compareNumbers;
    964847function isInt(n) {
    965         return n % 1 === 0;
     848    return n % 1 === 0;
    966849}
    967 
    968 
     850exports.isInt = isInt;
    969851// Returns a method bound to the given object context.
    970852// Just like one of the jQuery.proxy signatures, but without the undesired behavior of treating the same method with
    971853// different contexts as identical when binding/unbinding events.
    972854function proxy(obj, methodName) {
    973         var method = obj[methodName];
    974 
    975         return function() {
    976                 return method.apply(obj, arguments);
    977         };
     855    var method = obj[methodName];
     856    return function () {
     857        return method.apply(obj, arguments);
     858    };
    978859}
    979 
    980 
     860exports.proxy = proxy;
    981861// Returns a function, that, as long as it continues to be invoked, will not
    982862// be triggered. The function will be called after it stops being called for
     
    985865// https://github.com/jashkenas/underscore/blob/1.6.0/underscore.js#L714
    986866function debounce(func, wait, immediate) {
    987         var timeout, args, context, timestamp, result;
    988 
    989         var later = function() {
    990                 var last = +new Date() - timestamp;
    991                 if (last < wait) {
    992                         timeout = setTimeout(later, wait - last);
    993                 }
    994                 else {
    995                         timeout = null;
    996                         if (!immediate) {
    997                                 result = func.apply(context, args);
    998                                 context = args = null;
    999                         }
    1000                 }
    1001         };
    1002 
    1003         return function() {
    1004                 context = this;
    1005                 args = arguments;
    1006                 timestamp = +new Date();
    1007                 var callNow = immediate && !timeout;
    1008                 if (!timeout) {
    1009                         timeout = setTimeout(later, wait);
    1010                 }
    1011                 if (callNow) {
    1012                         result = func.apply(context, args);
    1013                         context = args = null;
    1014                 }
    1015                 return result;
    1016         };
     867    if (immediate === void 0) { immediate = false; }
     868    var timeout;
     869    var args;
     870    var context;
     871    var timestamp;
     872    var result;
     873    var later = function () {
     874        var last = +new Date() - timestamp;
     875        if (last < wait) {
     876            timeout = setTimeout(later, wait - last);
     877        }
     878        else {
     879            timeout = null;
     880            if (!immediate) {
     881                result = func.apply(context, args);
     882                context = args = null;
     883            }
     884        }
     885    };
     886    return function () {
     887        context = this;
     888        args = arguments;
     889        timestamp = +new Date();
     890        var callNow = immediate && !timeout;
     891        if (!timeout) {
     892            timeout = setTimeout(later, wait);
     893        }
     894        if (callNow) {
     895            result = func.apply(context, args);
     896            context = args = null;
     897        }
     898        return result;
     899    };
    1017900}
    1018 
    1019 ;;
    1020 
     901exports.debounce = debounce;
     902
     903
     904/***/ }),
     905/* 5 */
     906/***/ (function(module, exports, __webpack_require__) {
     907
     908Object.defineProperty(exports, "__esModule", { value: true });
     909var moment = __webpack_require__(0);
     910var moment_ext_1 = __webpack_require__(10);
     911var UnzonedRange = /** @class */ (function () {
     912    function UnzonedRange(startInput, endInput) {
     913        // TODO: move these into footprint.
     914        // Especially, doesn't make sense for null startMs/endMs.
     915        this.isStart = true;
     916        this.isEnd = true;
     917        if (moment.isMoment(startInput)) {
     918            startInput = startInput.clone().stripZone();
     919        }
     920        if (moment.isMoment(endInput)) {
     921            endInput = endInput.clone().stripZone();
     922        }
     923        if (startInput) {
     924            this.startMs = startInput.valueOf();
     925        }
     926        if (endInput) {
     927            this.endMs = endInput.valueOf();
     928        }
     929    }
     930    /*
     931    SIDEEFFECT: will mutate eventRanges.
     932    Will return a new array result.
     933    Only works for non-open-ended ranges.
     934    */
     935    UnzonedRange.invertRanges = function (ranges, constraintRange) {
     936        var invertedRanges = [];
     937        var startMs = constraintRange.startMs; // the end of the previous range. the start of the new range
     938        var i;
     939        var dateRange;
     940        // ranges need to be in order. required for our date-walking algorithm
     941        ranges.sort(compareUnzonedRanges);
     942        for (i = 0; i < ranges.length; i++) {
     943            dateRange = ranges[i];
     944            // add the span of time before the event (if there is any)
     945            if (dateRange.startMs > startMs) {
     946                invertedRanges.push(new UnzonedRange(startMs, dateRange.startMs));
     947            }
     948            if (dateRange.endMs > startMs) {
     949                startMs = dateRange.endMs;
     950            }
     951        }
     952        // add the span of time after the last event (if there is any)
     953        if (startMs < constraintRange.endMs) {
     954            invertedRanges.push(new UnzonedRange(startMs, constraintRange.endMs));
     955        }
     956        return invertedRanges;
     957    };
     958    UnzonedRange.prototype.intersect = function (otherRange) {
     959        var startMs = this.startMs;
     960        var endMs = this.endMs;
     961        var newRange = null;
     962        if (otherRange.startMs != null) {
     963            if (startMs == null) {
     964                startMs = otherRange.startMs;
     965            }
     966            else {
     967                startMs = Math.max(startMs, otherRange.startMs);
     968            }
     969        }
     970        if (otherRange.endMs != null) {
     971            if (endMs == null) {
     972                endMs = otherRange.endMs;
     973            }
     974            else {
     975                endMs = Math.min(endMs, otherRange.endMs);
     976            }
     977        }
     978        if (startMs == null || endMs == null || startMs < endMs) {
     979            newRange = new UnzonedRange(startMs, endMs);
     980            newRange.isStart = this.isStart && startMs === this.startMs;
     981            newRange.isEnd = this.isEnd && endMs === this.endMs;
     982        }
     983        return newRange;
     984    };
     985    UnzonedRange.prototype.intersectsWith = function (otherRange) {
     986        return (this.endMs == null || otherRange.startMs == null || this.endMs > otherRange.startMs) &&
     987            (this.startMs == null || otherRange.endMs == null || this.startMs < otherRange.endMs);
     988    };
     989    UnzonedRange.prototype.containsRange = function (innerRange) {
     990        return (this.startMs == null || (innerRange.startMs != null && innerRange.startMs >= this.startMs)) &&
     991            (this.endMs == null || (innerRange.endMs != null && innerRange.endMs <= this.endMs));
     992    };
     993    // `date` can be a moment, a Date, or a millisecond time.
     994    UnzonedRange.prototype.containsDate = function (date) {
     995        var ms = date.valueOf();
     996        return (this.startMs == null || ms >= this.startMs) &&
     997            (this.endMs == null || ms < this.endMs);
     998    };
     999    // If the given date is not within the given range, move it inside.
     1000    // (If it's past the end, make it one millisecond before the end).
     1001    // `date` can be a moment, a Date, or a millisecond time.
     1002    // Returns a MS-time.
     1003    UnzonedRange.prototype.constrainDate = function (date) {
     1004        var ms = date.valueOf();
     1005        if (this.startMs != null && ms < this.startMs) {
     1006            ms = this.startMs;
     1007        }
     1008        if (this.endMs != null && ms >= this.endMs) {
     1009            ms = this.endMs - 1;
     1010        }
     1011        return ms;
     1012    };
     1013    UnzonedRange.prototype.equals = function (otherRange) {
     1014        return this.startMs === otherRange.startMs && this.endMs === otherRange.endMs;
     1015    };
     1016    UnzonedRange.prototype.clone = function () {
     1017        var range = new UnzonedRange(this.startMs, this.endMs);
     1018        range.isStart = this.isStart;
     1019        range.isEnd = this.isEnd;
     1020        return range;
     1021    };
     1022    // Returns an ambig-zoned moment from startMs.
     1023    // BEWARE: returned moment is not localized.
     1024    // Formatting and start-of-week will be default.
     1025    UnzonedRange.prototype.getStart = function () {
     1026        if (this.startMs != null) {
     1027            return moment_ext_1.default.utc(this.startMs).stripZone();
     1028        }
     1029        return null;
     1030    };
     1031    // Returns an ambig-zoned moment from startMs.
     1032    // BEWARE: returned moment is not localized.
     1033    // Formatting and start-of-week will be default.
     1034    UnzonedRange.prototype.getEnd = function () {
     1035        if (this.endMs != null) {
     1036            return moment_ext_1.default.utc(this.endMs).stripZone();
     1037        }
     1038        return null;
     1039    };
     1040    UnzonedRange.prototype.as = function (unit) {
     1041        return moment.utc(this.endMs).diff(moment.utc(this.startMs), unit, true);
     1042    };
     1043    return UnzonedRange;
     1044}());
     1045exports.default = UnzonedRange;
    10211046/*
    1022 GENERAL NOTE on moments throughout the *entire rest* of the codebase:
    1023 All moments are assumed to be ambiguously-zoned unless otherwise noted,
    1024 with the NOTABLE EXCEOPTION of start/end dates that live on *Event Objects*.
    1025 Ambiguously-TIMED moments are assumed to be ambiguously-zoned by nature.
     1047Only works for non-open-ended ranges.
    10261048*/
    1027 
     1049function compareUnzonedRanges(range1, range2) {
     1050    return range1.startMs - range2.startMs; // earlier ranges go first
     1051}
     1052
     1053
     1054/***/ }),
     1055/* 6 */
     1056/***/ (function(module, exports, __webpack_require__) {
     1057
     1058Object.defineProperty(exports, "__esModule", { value: true });
     1059var tslib_1 = __webpack_require__(2);
     1060var $ = __webpack_require__(3);
     1061var ParsableModelMixin_1 = __webpack_require__(208);
     1062var Class_1 = __webpack_require__(33);
     1063var EventDefParser_1 = __webpack_require__(49);
     1064var EventSource = /** @class */ (function (_super) {
     1065    tslib_1.__extends(EventSource, _super);
     1066    // can we do away with calendar? at least for the abstract?
     1067    // useful for buildEventDef
     1068    function EventSource(calendar) {
     1069        var _this = _super.call(this) || this;
     1070        _this.calendar = calendar;
     1071        _this.className = [];
     1072        _this.uid = String(EventSource.uuid++);
     1073        return _this;
     1074    }
     1075    /*
     1076    rawInput can be any data type!
     1077    */
     1078    EventSource.parse = function (rawInput, calendar) {
     1079        var source = new this(calendar);
     1080        if (typeof rawInput === 'object') {
     1081            if (source.applyProps(rawInput)) {
     1082                return source;
     1083            }
     1084        }
     1085        return false;
     1086    };
     1087    EventSource.normalizeId = function (id) {
     1088        if (id) {
     1089            return String(id);
     1090        }
     1091        return null;
     1092    };
     1093    EventSource.prototype.fetch = function (start, end, timezone) {
     1094        // subclasses must implement. must return a promise.
     1095    };
     1096    EventSource.prototype.removeEventDefsById = function (eventDefId) {
     1097        // optional for subclasses to implement
     1098    };
     1099    EventSource.prototype.removeAllEventDefs = function () {
     1100        // optional for subclasses to implement
     1101    };
     1102    /*
     1103    For compairing/matching
     1104    */
     1105    EventSource.prototype.getPrimitive = function (otherSource) {
     1106        // subclasses must implement
     1107    };
     1108    EventSource.prototype.parseEventDefs = function (rawEventDefs) {
     1109        var i;
     1110        var eventDef;
     1111        var eventDefs = [];
     1112        for (i = 0; i < rawEventDefs.length; i++) {
     1113            eventDef = this.parseEventDef(rawEventDefs[i]);
     1114            if (eventDef) {
     1115                eventDefs.push(eventDef);
     1116            }
     1117        }
     1118        return eventDefs;
     1119    };
     1120    EventSource.prototype.parseEventDef = function (rawInput) {
     1121        var calendarTransform = this.calendar.opt('eventDataTransform');
     1122        var sourceTransform = this.eventDataTransform;
     1123        if (calendarTransform) {
     1124            rawInput = calendarTransform(rawInput, this.calendar);
     1125        }
     1126        if (sourceTransform) {
     1127            rawInput = sourceTransform(rawInput, this.calendar);
     1128        }
     1129        return EventDefParser_1.default.parse(rawInput, this);
     1130    };
     1131    EventSource.prototype.applyManualStandardProps = function (rawProps) {
     1132        if (rawProps.id != null) {
     1133            this.id = EventSource.normalizeId(rawProps.id);
     1134        }
     1135        // TODO: converge with EventDef
     1136        if ($.isArray(rawProps.className)) {
     1137            this.className = rawProps.className;
     1138        }
     1139        else if (typeof rawProps.className === 'string') {
     1140            this.className = rawProps.className.split(/\s+/);
     1141        }
     1142        return true;
     1143    };
     1144    EventSource.uuid = 0;
     1145    EventSource.defineStandardProps = ParsableModelMixin_1.default.defineStandardProps;
     1146    EventSource.copyVerbatimStandardProps = ParsableModelMixin_1.default.copyVerbatimStandardProps;
     1147    return EventSource;
     1148}(Class_1.default));
     1149exports.default = EventSource;
     1150ParsableModelMixin_1.default.mixInto(EventSource);
     1151// Parsing
     1152// ---------------------------------------------------------------------------------------------------------------------
     1153EventSource.defineStandardProps({
     1154    // manually process...
     1155    id: false,
     1156    className: false,
     1157    // automatically transfer...
     1158    color: true,
     1159    backgroundColor: true,
     1160    borderColor: true,
     1161    textColor: true,
     1162    editable: true,
     1163    startEditable: true,
     1164    durationEditable: true,
     1165    rendering: true,
     1166    overlap: true,
     1167    constraint: true,
     1168    allDayDefault: true,
     1169    eventDataTransform: true
     1170});
     1171
     1172
     1173/***/ }),
     1174/* 7 */
     1175/***/ (function(module, exports, __webpack_require__) {
     1176
     1177/*
     1178Utility methods for easily listening to events on another object,
     1179and more importantly, easily unlistening from them.
     1180
     1181USAGE:
     1182  import { default as ListenerMixin, ListenerInterface } from './ListenerMixin'
     1183in class:
     1184  listenTo: ListenerInterface['listenTo']
     1185  stopListeningTo: ListenerInterface['stopListeningTo']
     1186after class:
     1187  ListenerMixin.mixInto(TheClass)
     1188*/
     1189Object.defineProperty(exports, "__esModule", { value: true });
     1190var tslib_1 = __webpack_require__(2);
     1191var $ = __webpack_require__(3);
     1192var Mixin_1 = __webpack_require__(14);
     1193var guid = 0;
     1194var ListenerMixin = /** @class */ (function (_super) {
     1195    tslib_1.__extends(ListenerMixin, _super);
     1196    function ListenerMixin() {
     1197        return _super !== null && _super.apply(this, arguments) || this;
     1198    }
     1199    /*
     1200    Given an `other` object that has on/off methods, bind the given `callback` to an event by the given name.
     1201    The `callback` will be called with the `this` context of the object that .listenTo is being called on.
     1202    Can be called:
     1203      .listenTo(other, eventName, callback)
     1204    OR
     1205      .listenTo(other, {
     1206        eventName1: callback1,
     1207        eventName2: callback2
     1208      })
     1209    */
     1210    ListenerMixin.prototype.listenTo = function (other, arg, callback) {
     1211        if (typeof arg === 'object') {
     1212            for (var eventName in arg) {
     1213                if (arg.hasOwnProperty(eventName)) {
     1214                    this.listenTo(other, eventName, arg[eventName]);
     1215                }
     1216            }
     1217        }
     1218        else if (typeof arg === 'string') {
     1219            other.on(arg + '.' + this.getListenerNamespace(), // use event namespacing to identify this object
     1220            $.proxy(callback, this) // always use `this` context
     1221            // the usually-undesired jQuery guid behavior doesn't matter,
     1222            // because we always unbind via namespace
     1223            );
     1224        }
     1225    };
     1226    /*
     1227    Causes the current object to stop listening to events on the `other` object.
     1228    `eventName` is optional. If omitted, will stop listening to ALL events on `other`.
     1229    */
     1230    ListenerMixin.prototype.stopListeningTo = function (other, eventName) {
     1231        other.off((eventName || '') + '.' + this.getListenerNamespace());
     1232    };
     1233    /*
     1234    Returns a string, unique to this object, to be used for event namespacing
     1235    */
     1236    ListenerMixin.prototype.getListenerNamespace = function () {
     1237        if (this.listenerId == null) {
     1238            this.listenerId = guid++;
     1239        }
     1240        return '_listener' + this.listenerId;
     1241    };
     1242    return ListenerMixin;
     1243}(Mixin_1.default));
     1244exports.default = ListenerMixin;
     1245
     1246
     1247/***/ }),
     1248/* 8 */,
     1249/* 9 */,
     1250/* 10 */
     1251/***/ (function(module, exports, __webpack_require__) {
     1252
     1253Object.defineProperty(exports, "__esModule", { value: true });
     1254var moment = __webpack_require__(0);
     1255var $ = __webpack_require__(3);
     1256var util_1 = __webpack_require__(4);
    10281257var ambigDateOfMonthRegex = /^\s*\d{4}-\d\d$/;
    1029 var ambigTimeOrZoneRegex =
    1030         /^\s*\d{4}-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?)?$/;
     1258var ambigTimeOrZoneRegex = /^\s*\d{4}-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?)?$/;
    10311259var newMomentProto = moment.fn; // where we will attach our new methods
     1260exports.newMomentProto = newMomentProto;
    10321261var oldMomentProto = $.extend({}, newMomentProto); // copy of original moment methods
    1033 
     1262exports.oldMomentProto = oldMomentProto;
    10341263// tell momentjs to transfer these properties upon clone
    10351264var momentProperties = moment.momentProperties;
     
    10371266momentProperties.push('_ambigTime');
    10381267momentProperties.push('_ambigZone');
    1039 
    1040 
     1268/*
     1269Call this if you want Moment's original format method to be used
     1270*/
     1271function oldMomentFormat(mom, formatStr) {
     1272    return oldMomentProto.format.call(mom, formatStr); // oldMomentProto defined in moment-ext.js
     1273}
     1274exports.oldMomentFormat = oldMomentFormat;
    10411275// Creating
    10421276// -------------------------------------------------------------------------------------------------
    1043 
    10441277// Creates a new moment, similar to the vanilla moment(...) constructor, but with
    10451278// extra features (ambiguous time, enhanced formatting). When given an existing moment,
    10461279// it will function as a clone (and retain the zone of the moment). Anything else will
    10471280// result in a moment in the local zone.
    1048 FC.moment = function() {
    1049         return makeMoment(arguments);
     1281var momentExt = function () {
     1282    return makeMoment(arguments);
    10501283};
    1051 
    1052 // Sames as FC.moment, but forces the resulting moment to be in the UTC timezone.
    1053 FC.moment.utc = function() {
    1054         var mom = makeMoment(arguments, true);
    1055 
    1056         // Force it into UTC because makeMoment doesn't guarantee it
    1057         // (if given a pre-existing moment for example)
    1058         if (mom.hasTime()) { // don't give ambiguously-timed moments a UTC zone
    1059                 mom.utc();
    1060         }
    1061 
    1062         return mom;
     1284exports.default = momentExt;
     1285// Sames as momentExt, but forces the resulting moment to be in the UTC timezone.
     1286momentExt.utc = function () {
     1287    var mom = makeMoment(arguments, true);
     1288    // Force it into UTC because makeMoment doesn't guarantee it
     1289    // (if given a pre-existing moment for example)
     1290    if (mom.hasTime()) {
     1291        mom.utc();
     1292    }
     1293    return mom;
    10631294};
    1064 
    1065 // Same as FC.moment, but when given an ISO8601 string, the timezone offset is preserved.
     1295// Same as momentExt, but when given an ISO8601 string, the timezone offset is preserved.
    10661296// ISO8601 strings with no timezone offset will become ambiguously zoned.
    1067 FC.moment.parseZone = function() {
    1068         return makeMoment(arguments, true, true);
     1297momentExt.parseZone = function () {
     1298    return makeMoment(arguments, true, true);
    10691299};
    1070 
    10711300// Builds an enhanced moment from args. When given an existing moment, it clones. When given a
    10721301// native Date, or called with no arguments (the current time), the resulting moment will be local.
     
    10751304//    parseZone - if there is zone information, should we force the zone of the moment?
    10761305function makeMoment(args, parseAsUTC, parseZone) {
    1077         var input = args[0];
    1078         var isSingleString = args.length == 1 && typeof input === 'string';
    1079         var isAmbigTime;
    1080         var isAmbigZone;
    1081         var ambigMatch;
    1082         var mom;
    1083 
    1084         if (moment.isMoment(input) || isNativeDate(input) || input === undefined) {
    1085                 mom = moment.apply(null, args);
    1086         }
    1087         else { // "parsing" is required
    1088                 isAmbigTime = false;
    1089                 isAmbigZone = false;
    1090 
    1091                 if (isSingleString) {
    1092                         if (ambigDateOfMonthRegex.test(input)) {
    1093                                 // accept strings like '2014-05', but convert to the first of the month
    1094                                 input += '-01';
    1095                                 args = [ input ]; // for when we pass it on to moment's constructor
    1096                                 isAmbigTime = true;
    1097                                 isAmbigZone = true;
    1098                         }
    1099                         else if ((ambigMatch = ambigTimeOrZoneRegex.exec(input))) {
    1100                                 isAmbigTime = !ambigMatch[5]; // no time part?
    1101                                 isAmbigZone = true;
    1102                         }
    1103                 }
    1104                 else if ($.isArray(input)) {
    1105                         // arrays have no timezone information, so assume ambiguous zone
    1106                         isAmbigZone = true;
    1107                 }
    1108                 // otherwise, probably a string with a format
    1109 
    1110                 if (parseAsUTC || isAmbigTime) {
    1111                         mom = moment.utc.apply(moment, args);
    1112                 }
    1113                 else {
    1114                         mom = moment.apply(null, args);
    1115                 }
    1116 
    1117                 if (isAmbigTime) {
    1118                         mom._ambigTime = true;
    1119                         mom._ambigZone = true; // ambiguous time always means ambiguous zone
    1120                 }
    1121                 else if (parseZone) { // let's record the inputted zone somehow
    1122                         if (isAmbigZone) {
    1123                                 mom._ambigZone = true;
    1124                         }
    1125                         else if (isSingleString) {
    1126                                 mom.utcOffset(input); // if not a valid zone, will assign UTC
    1127                         }
    1128                 }
    1129         }
    1130 
    1131         mom._fullCalendar = true; // flag for extended functionality
    1132 
    1133         return mom;
     1306    if (parseAsUTC === void 0) { parseAsUTC = false; }
     1307    if (parseZone === void 0) { parseZone = false; }
     1308    var input = args[0];
     1309    var isSingleString = args.length === 1 && typeof input === 'string';
     1310    var isAmbigTime;
     1311    var isAmbigZone;
     1312    var ambigMatch;
     1313    var mom;
     1314    if (moment.isMoment(input) || util_1.isNativeDate(input) || input === undefined) {
     1315        mom = moment.apply(null, args);
     1316    }
     1317    else {
     1318        isAmbigTime = false;
     1319        isAmbigZone = false;
     1320        if (isSingleString) {
     1321            if (ambigDateOfMonthRegex.test(input)) {
     1322                // accept strings like '2014-05', but convert to the first of the month
     1323                input += '-01';
     1324                args = [input]; // for when we pass it on to moment's constructor
     1325                isAmbigTime = true;
     1326                isAmbigZone = true;
     1327            }
     1328            else if ((ambigMatch = ambigTimeOrZoneRegex.exec(input))) {
     1329                isAmbigTime = !ambigMatch[5]; // no time part?
     1330                isAmbigZone = true;
     1331            }
     1332        }
     1333        else if ($.isArray(input)) {
     1334            // arrays have no timezone information, so assume ambiguous zone
     1335            isAmbigZone = true;
     1336        }
     1337        // otherwise, probably a string with a format
     1338        if (parseAsUTC || isAmbigTime) {
     1339            mom = moment.utc.apply(moment, args);
     1340        }
     1341        else {
     1342            mom = moment.apply(null, args);
     1343        }
     1344        if (isAmbigTime) {
     1345            mom._ambigTime = true;
     1346            mom._ambigZone = true; // ambiguous time always means ambiguous zone
     1347        }
     1348        else if (parseZone) {
     1349            if (isAmbigZone) {
     1350                mom._ambigZone = true;
     1351            }
     1352            else if (isSingleString) {
     1353                mom.utcOffset(input); // if not a valid zone, will assign UTC
     1354            }
     1355        }
     1356    }
     1357    mom._fullCalendar = true; // flag for extended functionality
     1358    return mom;
    11341359}
    1135 
    1136 
    11371360// Week Number
    11381361// -------------------------------------------------------------------------------------------------
    1139 
    1140 
    11411362// Returns the week number, considering the locale's custom week number calcuation
    11421363// `weeks` is an alias for `week`
    1143 newMomentProto.week = newMomentProto.weeks = function(input) {
    1144         var weekCalc = this._locale._fullCalendar_weekCalc;
    1145 
    1146         if (input == null && typeof weekCalc === 'function') { // custom function only works for getter
    1147                 return weekCalc(this);
    1148         }
    1149         else if (weekCalc === 'ISO') {
    1150                 return oldMomentProto.isoWeek.apply(this, arguments); // ISO getter/setter
    1151         }
    1152 
    1153         return oldMomentProto.week.apply(this, arguments); // local getter/setter
     1364newMomentProto.week = newMomentProto.weeks = function (input) {
     1365    var weekCalc = this._locale._fullCalendar_weekCalc;
     1366    if (input == null && typeof weekCalc === 'function') {
     1367        return weekCalc(this);
     1368    }
     1369    else if (weekCalc === 'ISO') {
     1370        return oldMomentProto.isoWeek.apply(this, arguments); // ISO getter/setter
     1371    }
     1372    return oldMomentProto.week.apply(this, arguments); // local getter/setter
    11541373};
    1155 
    1156 
    11571374// Time-of-day
    11581375// -------------------------------------------------------------------------------------------------
    1159 
    11601376// GETTER
    11611377// Returns a Duration with the hours/minutes/seconds/ms values of the moment.
     
    11651381// You can supply a Duration, a Moment, or a Duration-like argument.
    11661382// When setting the time, and the moment has an ambiguous time, it then becomes unambiguous.
    1167 newMomentProto.time = function(time) {
    1168 
    1169         // Fallback to the original method (if there is one) if this moment wasn't created via FullCalendar.
    1170         // `time` is a generic enough method name where this precaution is necessary to avoid collisions w/ other plugins.
    1171         if (!this._fullCalendar) {
    1172                 return oldMomentProto.time.apply(this, arguments);
    1173         }
    1174 
    1175         if (time == null) { // getter
    1176                 return moment.duration({
    1177                         hours: this.hours(),
    1178                         minutes: this.minutes(),
    1179                         seconds: this.seconds(),
    1180                         milliseconds: this.milliseconds()
    1181                 });
    1182         }
    1183         else { // setter
    1184 
    1185                 this._ambigTime = false; // mark that the moment now has a time
    1186 
    1187                 if (!moment.isDuration(time) && !moment.isMoment(time)) {
    1188                         time = moment.duration(time);
    1189                 }
    1190 
    1191                 // The day value should cause overflow (so 24 hours becomes 00:00:00 of next day).
    1192                 // Only for Duration times, not Moment times.
    1193                 var dayHours = 0;
    1194                 if (moment.isDuration(time)) {
    1195                         dayHours = Math.floor(time.asDays()) * 24;
    1196                 }
    1197 
    1198                 // We need to set the individual fields.
    1199                 // Can't use startOf('day') then add duration. In case of DST at start of day.
    1200                 return this.hours(dayHours + time.hours())
    1201                         .minutes(time.minutes())
    1202                         .seconds(time.seconds())
    1203                         .milliseconds(time.milliseconds());
    1204         }
     1383newMomentProto.time = function (time) {
     1384    // Fallback to the original method (if there is one) if this moment wasn't created via FullCalendar.
     1385    // `time` is a generic enough method name where this precaution is necessary to avoid collisions w/ other plugins.
     1386    if (!this._fullCalendar) {
     1387        return oldMomentProto.time.apply(this, arguments);
     1388    }
     1389    if (time == null) {
     1390        return moment.duration({
     1391            hours: this.hours(),
     1392            minutes: this.minutes(),
     1393            seconds: this.seconds(),
     1394            milliseconds: this.milliseconds()
     1395        });
     1396    }
     1397    else {
     1398        this._ambigTime = false; // mark that the moment now has a time
     1399        if (!moment.isDuration(time) && !moment.isMoment(time)) {
     1400            time = moment.duration(time);
     1401        }
     1402        // The day value should cause overflow (so 24 hours becomes 00:00:00 of next day).
     1403        // Only for Duration times, not Moment times.
     1404        var dayHours = 0;
     1405        if (moment.isDuration(time)) {
     1406            dayHours = Math.floor(time.asDays()) * 24;
     1407        }
     1408        // We need to set the individual fields.
     1409        // Can't use startOf('day') then add duration. In case of DST at start of day.
     1410        return this.hours(dayHours + time.hours())
     1411            .minutes(time.minutes())
     1412            .seconds(time.seconds())
     1413            .milliseconds(time.milliseconds());
     1414    }
    12051415};
    1206 
    12071416// Converts the moment to UTC, stripping out its time-of-day and timezone offset,
    12081417// but preserving its YMD. A moment with a stripped time will display no time
    12091418// nor timezone offset when .format() is called.
    1210 newMomentProto.stripTime = function() {
    1211 
    1212         if (!this._ambigTime) {
    1213 
    1214                 this.utc(true); // keepLocalTime=true (for keeping *date* value)
    1215 
    1216                 // set time to zero
    1217                 this.set({
    1218                         hours: 0,
    1219                         minutes: 0,
    1220                         seconds: 0,
    1221                         ms: 0
    1222                 });
    1223 
    1224                 // Mark the time as ambiguous. This needs to happen after the .utc() call, which might call .utcOffset(),
    1225                 // which clears all ambig flags.
    1226                 this._ambigTime = true;
    1227                 this._ambigZone = true; // if ambiguous time, also ambiguous timezone offset
    1228         }
    1229 
    1230         return this; // for chaining
     1419newMomentProto.stripTime = function () {
     1420    if (!this._ambigTime) {
     1421        this.utc(true); // keepLocalTime=true (for keeping *date* value)
     1422        // set time to zero
     1423        this.set({
     1424            hours: 0,
     1425            minutes: 0,
     1426            seconds: 0,
     1427            ms: 0
     1428        });
     1429        // Mark the time as ambiguous. This needs to happen after the .utc() call, which might call .utcOffset(),
     1430        // which clears all ambig flags.
     1431        this._ambigTime = true;
     1432        this._ambigZone = true; // if ambiguous time, also ambiguous timezone offset
     1433    }
     1434    return this; // for chaining
    12311435};
    1232 
    12331436// Returns if the moment has a non-ambiguous time (boolean)
    1234 newMomentProto.hasTime = function() {
    1235         return !this._ambigTime;
     1437newMomentProto.hasTime = function () {
     1438    return !this._ambigTime;
    12361439};
    1237 
    1238 
    12391440// Timezone
    12401441// -------------------------------------------------------------------------------------------------
    1241 
    12421442// Converts the moment to UTC, stripping out its timezone offset, but preserving its
    12431443// YMD and time-of-day. A moment with a stripped timezone offset will display no
    12441444// timezone offset when .format() is called.
    1245 newMomentProto.stripZone = function() {
    1246         var wasAmbigTime;
    1247 
    1248         if (!this._ambigZone) {
    1249 
    1250                 wasAmbigTime = this._ambigTime;
    1251 
    1252                 this.utc(true); // keepLocalTime=true (for keeping date and time values)
    1253 
    1254                 // the above call to .utc()/.utcOffset() unfortunately might clear the ambig flags, so restore
    1255                 this._ambigTime = wasAmbigTime || false;
    1256 
    1257                 // Mark the zone as ambiguous. This needs to happen after the .utc() call, which might call .utcOffset(),
    1258                 // which clears the ambig flags.
    1259                 this._ambigZone = true;
    1260         }
    1261 
    1262         return this; // for chaining
     1445newMomentProto.stripZone = function () {
     1446    var wasAmbigTime;
     1447    if (!this._ambigZone) {
     1448        wasAmbigTime = this._ambigTime;
     1449        this.utc(true); // keepLocalTime=true (for keeping date and time values)
     1450        // the above call to .utc()/.utcOffset() unfortunately might clear the ambig flags, so restore
     1451        this._ambigTime = wasAmbigTime || false;
     1452        // Mark the zone as ambiguous. This needs to happen after the .utc() call, which might call .utcOffset(),
     1453        // which clears the ambig flags.
     1454        this._ambigZone = true;
     1455    }
     1456    return this; // for chaining
    12631457};
    1264 
    12651458// Returns of the moment has a non-ambiguous timezone offset (boolean)
    1266 newMomentProto.hasZone = function() {
    1267         return !this._ambigZone;
     1459newMomentProto.hasZone = function () {
     1460    return !this._ambigZone;
    12681461};
    1269 
    1270 
    12711462// implicitly marks a zone
    1272 newMomentProto.local = function(keepLocalTime) {
    1273 
    1274         // for when converting from ambiguously-zoned to local,
    1275         // keep the time values when converting from UTC -> local
    1276         oldMomentProto.local.call(this, this._ambigZone || keepLocalTime);
    1277 
    1278         // ensure non-ambiguous
    1279         // this probably already happened via local() -> utcOffset(), but don't rely on Moment's internals
    1280         this._ambigTime = false;
    1281         this._ambigZone = false;
    1282 
    1283         return this; // for chaining
     1463newMomentProto.local = function (keepLocalTime) {
     1464    // for when converting from ambiguously-zoned to local,
     1465    // keep the time values when converting from UTC -> local
     1466    oldMomentProto.local.call(this, this._ambigZone || keepLocalTime);
     1467    // ensure non-ambiguous
     1468    // this probably already happened via local() -> utcOffset(), but don't rely on Moment's internals
     1469    this._ambigTime = false;
     1470    this._ambigZone = false;
     1471    return this; // for chaining
    12841472};
    1285 
    1286 
    12871473// implicitly marks a zone
    1288 newMomentProto.utc = function(keepLocalTime) {
    1289 
    1290         oldMomentProto.utc.call(this, keepLocalTime);
    1291 
    1292         // ensure non-ambiguous
    1293         // this probably already happened via utc() -> utcOffset(), but don't rely on Moment's internals
    1294         this._ambigTime = false;
    1295         this._ambigZone = false;
    1296 
    1297         return this;
     1474newMomentProto.utc = function (keepLocalTime) {
     1475    oldMomentProto.utc.call(this, keepLocalTime);
     1476    // ensure non-ambiguous
     1477    // this probably already happened via utc() -> utcOffset(), but don't rely on Moment's internals
     1478    this._ambigTime = false;
     1479    this._ambigZone = false;
     1480    return this;
    12981481};
    1299 
    1300 
    13011482// implicitly marks a zone (will probably get called upon .utc() and .local())
    1302 newMomentProto.utcOffset = function(tzo) {
    1303 
    1304         if (tzo != null) { // setter
    1305                 // these assignments needs to happen before the original zone method is called.
    1306                 // I forget why, something to do with a browser crash.
    1307                 this._ambigTime = false;
    1308                 this._ambigZone = false;
    1309         }
    1310 
    1311         return oldMomentProto.utcOffset.apply(this, arguments);
     1483newMomentProto.utcOffset = function (tzo) {
     1484    if (tzo != null) {
     1485        // these assignments needs to happen before the original zone method is called.
     1486        // I forget why, something to do with a browser crash.
     1487        this._ambigTime = false;
     1488        this._ambigZone = false;
     1489    }
     1490    return oldMomentProto.utcOffset.apply(this, arguments);
    13121491};
    13131492
    13141493
    1315 // Formatting
     1494/***/ }),
     1495/* 11 */
     1496/***/ (function(module, exports, __webpack_require__) {
     1497
     1498/*
     1499USAGE:
     1500  import { default as EmitterMixin, EmitterInterface } from './EmitterMixin'
     1501in class:
     1502  on: EmitterInterface['on']
     1503  one: EmitterInterface['one']
     1504  off: EmitterInterface['off']
     1505  trigger: EmitterInterface['trigger']
     1506  triggerWith: EmitterInterface['triggerWith']
     1507  hasHandlers: EmitterInterface['hasHandlers']
     1508after class:
     1509  EmitterMixin.mixInto(TheClass)
     1510*/
     1511Object.defineProperty(exports, "__esModule", { value: true });
     1512var tslib_1 = __webpack_require__(2);
     1513var $ = __webpack_require__(3);
     1514var Mixin_1 = __webpack_require__(14);
     1515var EmitterMixin = /** @class */ (function (_super) {
     1516    tslib_1.__extends(EmitterMixin, _super);
     1517    function EmitterMixin() {
     1518        return _super !== null && _super.apply(this, arguments) || this;
     1519    }
     1520    // jQuery-ification via $(this) allows a non-DOM object to have
     1521    // the same event handling capabilities (including namespaces).
     1522    EmitterMixin.prototype.on = function (types, handler) {
     1523        $(this).on(types, this._prepareIntercept(handler));
     1524        return this; // for chaining
     1525    };
     1526    EmitterMixin.prototype.one = function (types, handler) {
     1527        $(this).one(types, this._prepareIntercept(handler));
     1528        return this; // for chaining
     1529    };
     1530    EmitterMixin.prototype._prepareIntercept = function (handler) {
     1531        // handlers are always called with an "event" object as their first param.
     1532        // sneak the `this` context and arguments into the extra parameter object
     1533        // and forward them on to the original handler.
     1534        var intercept = function (ev, extra) {
     1535            return handler.apply(extra.context || this, extra.args || []);
     1536        };
     1537        // mimick jQuery's internal "proxy" system (risky, I know)
     1538        // causing all functions with the same .guid to appear to be the same.
     1539        // https://github.com/jquery/jquery/blob/2.2.4/src/core.js#L448
     1540        // this is needed for calling .off with the original non-intercept handler.
     1541        if (!handler.guid) {
     1542            handler.guid = $.guid++;
     1543        }
     1544        intercept.guid = handler.guid;
     1545        return intercept;
     1546    };
     1547    EmitterMixin.prototype.off = function (types, handler) {
     1548        $(this).off(types, handler);
     1549        return this; // for chaining
     1550    };
     1551    EmitterMixin.prototype.trigger = function (types) {
     1552        var args = [];
     1553        for (var _i = 1; _i < arguments.length; _i++) {
     1554            args[_i - 1] = arguments[_i];
     1555        }
     1556        // pass in "extra" info to the intercept
     1557        $(this).triggerHandler(types, { args: args });
     1558        return this; // for chaining
     1559    };
     1560    EmitterMixin.prototype.triggerWith = function (types, context, args) {
     1561        // `triggerHandler` is less reliant on the DOM compared to `trigger`.
     1562        // pass in "extra" info to the intercept.
     1563        $(this).triggerHandler(types, { context: context, args: args });
     1564        return this; // for chaining
     1565    };
     1566    EmitterMixin.prototype.hasHandlers = function (type) {
     1567        var hash = $._data(this, 'events'); // http://blog.jquery.com/2012/08/09/jquery-1-8-released/
     1568        return hash && hash[type] && hash[type].length > 0;
     1569    };
     1570    return EmitterMixin;
     1571}(Mixin_1.default));
     1572exports.default = EmitterMixin;
     1573
     1574
     1575/***/ }),
     1576/* 12 */
     1577/***/ (function(module, exports) {
     1578
     1579Object.defineProperty(exports, "__esModule", { value: true });
     1580/*
     1581Meant to be immutable
     1582*/
     1583var ComponentFootprint = /** @class */ (function () {
     1584    function ComponentFootprint(unzonedRange, isAllDay) {
     1585        this.isAllDay = false; // component can choose to ignore this
     1586        this.unzonedRange = unzonedRange;
     1587        this.isAllDay = isAllDay;
     1588    }
     1589    /*
     1590    Only works for non-open-ended ranges.
     1591    */
     1592    ComponentFootprint.prototype.toLegacy = function (calendar) {
     1593        return {
     1594            start: calendar.msToMoment(this.unzonedRange.startMs, this.isAllDay),
     1595            end: calendar.msToMoment(this.unzonedRange.endMs, this.isAllDay)
     1596        };
     1597    };
     1598    return ComponentFootprint;
     1599}());
     1600exports.default = ComponentFootprint;
     1601
     1602
     1603/***/ }),
     1604/* 13 */
     1605/***/ (function(module, exports, __webpack_require__) {
     1606
     1607Object.defineProperty(exports, "__esModule", { value: true });
     1608var tslib_1 = __webpack_require__(2);
     1609var EventDef_1 = __webpack_require__(34);
     1610var EventInstance_1 = __webpack_require__(209);
     1611var EventDateProfile_1 = __webpack_require__(17);
     1612var SingleEventDef = /** @class */ (function (_super) {
     1613    tslib_1.__extends(SingleEventDef, _super);
     1614    function SingleEventDef() {
     1615        return _super !== null && _super.apply(this, arguments) || this;
     1616    }
     1617    /*
     1618    Will receive start/end params, but will be ignored.
     1619    */
     1620    SingleEventDef.prototype.buildInstances = function () {
     1621        return [this.buildInstance()];
     1622    };
     1623    SingleEventDef.prototype.buildInstance = function () {
     1624        return new EventInstance_1.default(this, // definition
     1625        this.dateProfile);
     1626    };
     1627    SingleEventDef.prototype.isAllDay = function () {
     1628        return this.dateProfile.isAllDay();
     1629    };
     1630    SingleEventDef.prototype.clone = function () {
     1631        var def = _super.prototype.clone.call(this);
     1632        def.dateProfile = this.dateProfile;
     1633        return def;
     1634    };
     1635    SingleEventDef.prototype.rezone = function () {
     1636        var calendar = this.source.calendar;
     1637        var dateProfile = this.dateProfile;
     1638        this.dateProfile = new EventDateProfile_1.default(calendar.moment(dateProfile.start), dateProfile.end ? calendar.moment(dateProfile.end) : null, calendar);
     1639    };
     1640    /*
     1641    NOTE: if super-method fails, should still attempt to apply
     1642    */
     1643    SingleEventDef.prototype.applyManualStandardProps = function (rawProps) {
     1644        var superSuccess = _super.prototype.applyManualStandardProps.call(this, rawProps);
     1645        var dateProfile = EventDateProfile_1.default.parse(rawProps, this.source); // returns null on failure
     1646        if (dateProfile) {
     1647            this.dateProfile = dateProfile;
     1648            // make sure `date` shows up in the legacy event objects as-is
     1649            if (rawProps.date != null) {
     1650                this.miscProps.date = rawProps.date;
     1651            }
     1652            return superSuccess;
     1653        }
     1654        else {
     1655            return false;
     1656        }
     1657    };
     1658    return SingleEventDef;
     1659}(EventDef_1.default));
     1660exports.default = SingleEventDef;
     1661// Parsing
     1662// ---------------------------------------------------------------------------------------------------------------------
     1663SingleEventDef.defineStandardProps({
     1664    start: false,
     1665    date: false,
     1666    end: false,
     1667    allDay: false
     1668});
     1669
     1670
     1671/***/ }),
     1672/* 14 */
     1673/***/ (function(module, exports) {
     1674
     1675Object.defineProperty(exports, "__esModule", { value: true });
     1676var Mixin = /** @class */ (function () {
     1677    function Mixin() {
     1678    }
     1679    Mixin.mixInto = function (destClass) {
     1680        var _this = this;
     1681        Object.getOwnPropertyNames(this.prototype).forEach(function (name) {
     1682            if (!destClass.prototype[name]) {
     1683                destClass.prototype[name] = _this.prototype[name];
     1684            }
     1685        });
     1686    };
     1687    /*
     1688    will override existing methods
     1689    TODO: remove! not used anymore
     1690    */
     1691    Mixin.mixOver = function (destClass) {
     1692        var _this = this;
     1693        Object.getOwnPropertyNames(this.prototype).forEach(function (name) {
     1694            destClass.prototype[name] = _this.prototype[name];
     1695        });
     1696    };
     1697    return Mixin;
     1698}());
     1699exports.default = Mixin;
     1700
     1701
     1702/***/ }),
     1703/* 15 */
     1704/***/ (function(module, exports) {
     1705
     1706Object.defineProperty(exports, "__esModule", { value: true });
     1707var Interaction = /** @class */ (function () {
     1708    function Interaction(component) {
     1709        this.view = component._getView();
     1710        this.component = component;
     1711    }
     1712    Interaction.prototype.opt = function (name) {
     1713        return this.view.opt(name);
     1714    };
     1715    Interaction.prototype.end = function () {
     1716        // subclasses can implement
     1717    };
     1718    return Interaction;
     1719}());
     1720exports.default = Interaction;
     1721
     1722
     1723/***/ }),
     1724/* 16 */
     1725/***/ (function(module, exports, __webpack_require__) {
     1726
     1727Object.defineProperty(exports, "__esModule", { value: true });
     1728exports.version = '3.9.0';
     1729// When introducing internal API incompatibilities (where fullcalendar plugins would break),
     1730// the minor version of the calendar should be upped (ex: 2.7.2 -> 2.8.0)
     1731// and the below integer should be incremented.
     1732exports.internalApiVersion = 12;
     1733var util_1 = __webpack_require__(4);
     1734exports.applyAll = util_1.applyAll;
     1735exports.debounce = util_1.debounce;
     1736exports.isInt = util_1.isInt;
     1737exports.htmlEscape = util_1.htmlEscape;
     1738exports.cssToStr = util_1.cssToStr;
     1739exports.proxy = util_1.proxy;
     1740exports.capitaliseFirstLetter = util_1.capitaliseFirstLetter;
     1741exports.getOuterRect = util_1.getOuterRect;
     1742exports.getClientRect = util_1.getClientRect;
     1743exports.getContentRect = util_1.getContentRect;
     1744exports.getScrollbarWidths = util_1.getScrollbarWidths;
     1745exports.preventDefault = util_1.preventDefault;
     1746exports.parseFieldSpecs = util_1.parseFieldSpecs;
     1747exports.compareByFieldSpecs = util_1.compareByFieldSpecs;
     1748exports.compareByFieldSpec = util_1.compareByFieldSpec;
     1749exports.flexibleCompare = util_1.flexibleCompare;
     1750exports.computeGreatestUnit = util_1.computeGreatestUnit;
     1751exports.divideRangeByDuration = util_1.divideRangeByDuration;
     1752exports.divideDurationByDuration = util_1.divideDurationByDuration;
     1753exports.multiplyDuration = util_1.multiplyDuration;
     1754exports.durationHasTime = util_1.durationHasTime;
     1755exports.log = util_1.log;
     1756exports.warn = util_1.warn;
     1757exports.removeExact = util_1.removeExact;
     1758exports.intersectRects = util_1.intersectRects;
     1759var date_formatting_1 = __webpack_require__(47);
     1760exports.formatDate = date_formatting_1.formatDate;
     1761exports.formatRange = date_formatting_1.formatRange;
     1762exports.queryMostGranularFormatUnit = date_formatting_1.queryMostGranularFormatUnit;
     1763var locale_1 = __webpack_require__(31);
     1764exports.datepickerLocale = locale_1.datepickerLocale;
     1765exports.locale = locale_1.locale;
     1766var moment_ext_1 = __webpack_require__(10);
     1767exports.moment = moment_ext_1.default;
     1768var EmitterMixin_1 = __webpack_require__(11);
     1769exports.EmitterMixin = EmitterMixin_1.default;
     1770var ListenerMixin_1 = __webpack_require__(7);
     1771exports.ListenerMixin = ListenerMixin_1.default;
     1772var Model_1 = __webpack_require__(48);
     1773exports.Model = Model_1.default;
     1774var Constraints_1 = __webpack_require__(207);
     1775exports.Constraints = Constraints_1.default;
     1776var UnzonedRange_1 = __webpack_require__(5);
     1777exports.UnzonedRange = UnzonedRange_1.default;
     1778var ComponentFootprint_1 = __webpack_require__(12);
     1779exports.ComponentFootprint = ComponentFootprint_1.default;
     1780var BusinessHourGenerator_1 = __webpack_require__(212);
     1781exports.BusinessHourGenerator = BusinessHourGenerator_1.default;
     1782var EventDef_1 = __webpack_require__(34);
     1783exports.EventDef = EventDef_1.default;
     1784var EventDefMutation_1 = __webpack_require__(37);
     1785exports.EventDefMutation = EventDefMutation_1.default;
     1786var EventSourceParser_1 = __webpack_require__(38);
     1787exports.EventSourceParser = EventSourceParser_1.default;
     1788var EventSource_1 = __webpack_require__(6);
     1789exports.EventSource = EventSource_1.default;
     1790var ThemeRegistry_1 = __webpack_require__(51);
     1791exports.defineThemeSystem = ThemeRegistry_1.defineThemeSystem;
     1792var EventInstanceGroup_1 = __webpack_require__(18);
     1793exports.EventInstanceGroup = EventInstanceGroup_1.default;
     1794var ArrayEventSource_1 = __webpack_require__(52);
     1795exports.ArrayEventSource = ArrayEventSource_1.default;
     1796var FuncEventSource_1 = __webpack_require__(215);
     1797exports.FuncEventSource = FuncEventSource_1.default;
     1798var JsonFeedEventSource_1 = __webpack_require__(216);
     1799exports.JsonFeedEventSource = JsonFeedEventSource_1.default;
     1800var EventFootprint_1 = __webpack_require__(36);
     1801exports.EventFootprint = EventFootprint_1.default;
     1802var Class_1 = __webpack_require__(33);
     1803exports.Class = Class_1.default;
     1804var Mixin_1 = __webpack_require__(14);
     1805exports.Mixin = Mixin_1.default;
     1806var CoordCache_1 = __webpack_require__(53);
     1807exports.CoordCache = CoordCache_1.default;
     1808var DragListener_1 = __webpack_require__(54);
     1809exports.DragListener = DragListener_1.default;
     1810var Promise_1 = __webpack_require__(20);
     1811exports.Promise = Promise_1.default;
     1812var TaskQueue_1 = __webpack_require__(217);
     1813exports.TaskQueue = TaskQueue_1.default;
     1814var RenderQueue_1 = __webpack_require__(218);
     1815exports.RenderQueue = RenderQueue_1.default;
     1816var Scroller_1 = __webpack_require__(39);
     1817exports.Scroller = Scroller_1.default;
     1818var Theme_1 = __webpack_require__(19);
     1819exports.Theme = Theme_1.default;
     1820var DateComponent_1 = __webpack_require__(219);
     1821exports.DateComponent = DateComponent_1.default;
     1822var InteractiveDateComponent_1 = __webpack_require__(40);
     1823exports.InteractiveDateComponent = InteractiveDateComponent_1.default;
     1824var Calendar_1 = __webpack_require__(220);
     1825exports.Calendar = Calendar_1.default;
     1826var View_1 = __webpack_require__(41);
     1827exports.View = View_1.default;
     1828var ViewRegistry_1 = __webpack_require__(22);
     1829exports.defineView = ViewRegistry_1.defineView;
     1830exports.getViewConfig = ViewRegistry_1.getViewConfig;
     1831var DayTableMixin_1 = __webpack_require__(55);
     1832exports.DayTableMixin = DayTableMixin_1.default;
     1833var BusinessHourRenderer_1 = __webpack_require__(56);
     1834exports.BusinessHourRenderer = BusinessHourRenderer_1.default;
     1835var EventRenderer_1 = __webpack_require__(42);
     1836exports.EventRenderer = EventRenderer_1.default;
     1837var FillRenderer_1 = __webpack_require__(57);
     1838exports.FillRenderer = FillRenderer_1.default;
     1839var HelperRenderer_1 = __webpack_require__(58);
     1840exports.HelperRenderer = HelperRenderer_1.default;
     1841var ExternalDropping_1 = __webpack_require__(222);
     1842exports.ExternalDropping = ExternalDropping_1.default;
     1843var EventResizing_1 = __webpack_require__(223);
     1844exports.EventResizing = EventResizing_1.default;
     1845var EventPointing_1 = __webpack_require__(59);
     1846exports.EventPointing = EventPointing_1.default;
     1847var EventDragging_1 = __webpack_require__(224);
     1848exports.EventDragging = EventDragging_1.default;
     1849var DateSelecting_1 = __webpack_require__(225);
     1850exports.DateSelecting = DateSelecting_1.default;
     1851var StandardInteractionsMixin_1 = __webpack_require__(60);
     1852exports.StandardInteractionsMixin = StandardInteractionsMixin_1.default;
     1853var AgendaView_1 = __webpack_require__(226);
     1854exports.AgendaView = AgendaView_1.default;
     1855var TimeGrid_1 = __webpack_require__(227);
     1856exports.TimeGrid = TimeGrid_1.default;
     1857var DayGrid_1 = __webpack_require__(61);
     1858exports.DayGrid = DayGrid_1.default;
     1859var BasicView_1 = __webpack_require__(62);
     1860exports.BasicView = BasicView_1.default;
     1861var MonthView_1 = __webpack_require__(229);
     1862exports.MonthView = MonthView_1.default;
     1863var ListView_1 = __webpack_require__(230);
     1864exports.ListView = ListView_1.default;
     1865
     1866
     1867/***/ }),
     1868/* 17 */
     1869/***/ (function(module, exports, __webpack_require__) {
     1870
     1871Object.defineProperty(exports, "__esModule", { value: true });
     1872var UnzonedRange_1 = __webpack_require__(5);
     1873/*
     1874Meant to be immutable
     1875*/
     1876var EventDateProfile = /** @class */ (function () {
     1877    function EventDateProfile(start, end, calendar) {
     1878        this.start = start;
     1879        this.end = end || null;
     1880        this.unzonedRange = this.buildUnzonedRange(calendar);
     1881    }
     1882    /*
     1883    Needs an EventSource object
     1884    */
     1885    EventDateProfile.parse = function (rawProps, source) {
     1886        var startInput = rawProps.start || rawProps.date;
     1887        var endInput = rawProps.end;
     1888        if (!startInput) {
     1889            return false;
     1890        }
     1891        var calendar = source.calendar;
     1892        var start = calendar.moment(startInput);
     1893        var end = endInput ? calendar.moment(endInput) : null;
     1894        var forcedAllDay = rawProps.allDay;
     1895        var forceEventDuration = calendar.opt('forceEventDuration');
     1896        if (!start.isValid()) {
     1897            return false;
     1898        }
     1899        if (end && (!end.isValid() || !end.isAfter(start))) {
     1900            end = null;
     1901        }
     1902        if (forcedAllDay == null) {
     1903            forcedAllDay = source.allDayDefault;
     1904            if (forcedAllDay == null) {
     1905                forcedAllDay = calendar.opt('allDayDefault');
     1906            }
     1907        }
     1908        if (forcedAllDay === true) {
     1909            start.stripTime();
     1910            if (end) {
     1911                end.stripTime();
     1912            }
     1913        }
     1914        else if (forcedAllDay === false) {
     1915            if (!start.hasTime()) {
     1916                start.time(0);
     1917            }
     1918            if (end && !end.hasTime()) {
     1919                end.time(0);
     1920            }
     1921        }
     1922        if (!end && forceEventDuration) {
     1923            end = calendar.getDefaultEventEnd(!start.hasTime(), start);
     1924        }
     1925        return new EventDateProfile(start, end, calendar);
     1926    };
     1927    EventDateProfile.isStandardProp = function (propName) {
     1928        return propName === 'start' || propName === 'date' || propName === 'end' || propName === 'allDay';
     1929    };
     1930    EventDateProfile.prototype.isAllDay = function () {
     1931        return !(this.start.hasTime() || (this.end && this.end.hasTime()));
     1932    };
     1933    /*
     1934    Needs a Calendar object
     1935    */
     1936    EventDateProfile.prototype.buildUnzonedRange = function (calendar) {
     1937        var startMs = this.start.clone().stripZone().valueOf();
     1938        var endMs = this.getEnd(calendar).stripZone().valueOf();
     1939        return new UnzonedRange_1.default(startMs, endMs);
     1940    };
     1941    /*
     1942    Needs a Calendar object
     1943    */
     1944    EventDateProfile.prototype.getEnd = function (calendar) {
     1945        return this.end ?
     1946            this.end.clone() :
     1947            // derive the end from the start and allDay. compute allDay if necessary
     1948            calendar.getDefaultEventEnd(this.isAllDay(), this.start);
     1949    };
     1950    return EventDateProfile;
     1951}());
     1952exports.default = EventDateProfile;
     1953
     1954
     1955/***/ }),
     1956/* 18 */
     1957/***/ (function(module, exports, __webpack_require__) {
     1958
     1959Object.defineProperty(exports, "__esModule", { value: true });
     1960var UnzonedRange_1 = __webpack_require__(5);
     1961var util_1 = __webpack_require__(35);
     1962var EventRange_1 = __webpack_require__(211);
     1963/*
     1964It's expected that there will be at least one EventInstance,
     1965OR that an explicitEventDef is assigned.
     1966*/
     1967var EventInstanceGroup = /** @class */ (function () {
     1968    function EventInstanceGroup(eventInstances) {
     1969        this.eventInstances = eventInstances || [];
     1970    }
     1971    EventInstanceGroup.prototype.getAllEventRanges = function (constraintRange) {
     1972        if (constraintRange) {
     1973            return this.sliceNormalRenderRanges(constraintRange);
     1974        }
     1975        else {
     1976            return this.eventInstances.map(util_1.eventInstanceToEventRange);
     1977        }
     1978    };
     1979    EventInstanceGroup.prototype.sliceRenderRanges = function (constraintRange) {
     1980        if (this.isInverse()) {
     1981            return this.sliceInverseRenderRanges(constraintRange);
     1982        }
     1983        else {
     1984            return this.sliceNormalRenderRanges(constraintRange);
     1985        }
     1986    };
     1987    EventInstanceGroup.prototype.sliceNormalRenderRanges = function (constraintRange) {
     1988        var eventInstances = this.eventInstances;
     1989        var i;
     1990        var eventInstance;
     1991        var slicedRange;
     1992        var slicedEventRanges = [];
     1993        for (i = 0; i < eventInstances.length; i++) {
     1994            eventInstance = eventInstances[i];
     1995            slicedRange = eventInstance.dateProfile.unzonedRange.intersect(constraintRange);
     1996            if (slicedRange) {
     1997                slicedEventRanges.push(new EventRange_1.default(slicedRange, eventInstance.def, eventInstance));
     1998            }
     1999        }
     2000        return slicedEventRanges;
     2001    };
     2002    EventInstanceGroup.prototype.sliceInverseRenderRanges = function (constraintRange) {
     2003        var unzonedRanges = this.eventInstances.map(util_1.eventInstanceToUnzonedRange);
     2004        var ownerDef = this.getEventDef();
     2005        unzonedRanges = UnzonedRange_1.default.invertRanges(unzonedRanges, constraintRange);
     2006        return unzonedRanges.map(function (unzonedRange) {
     2007            return new EventRange_1.default(unzonedRange, ownerDef); // don't give an EventInstance
     2008        });
     2009    };
     2010    EventInstanceGroup.prototype.isInverse = function () {
     2011        return this.getEventDef().hasInverseRendering();
     2012    };
     2013    EventInstanceGroup.prototype.getEventDef = function () {
     2014        return this.explicitEventDef || this.eventInstances[0].def;
     2015    };
     2016    return EventInstanceGroup;
     2017}());
     2018exports.default = EventInstanceGroup;
     2019
     2020
     2021/***/ }),
     2022/* 19 */
     2023/***/ (function(module, exports, __webpack_require__) {
     2024
     2025Object.defineProperty(exports, "__esModule", { value: true });
     2026var $ = __webpack_require__(3);
     2027var Theme = /** @class */ (function () {
     2028    function Theme(optionsManager) {
     2029        this.optionsManager = optionsManager;
     2030        this.processIconOverride();
     2031    }
     2032    Theme.prototype.processIconOverride = function () {
     2033        if (this.iconOverrideOption) {
     2034            this.setIconOverride(this.optionsManager.get(this.iconOverrideOption));
     2035        }
     2036    };
     2037    Theme.prototype.setIconOverride = function (iconOverrideHash) {
     2038        var iconClassesCopy;
     2039        var buttonName;
     2040        if ($.isPlainObject(iconOverrideHash)) {
     2041            iconClassesCopy = $.extend({}, this.iconClasses);
     2042            for (buttonName in iconOverrideHash) {
     2043                iconClassesCopy[buttonName] = this.applyIconOverridePrefix(iconOverrideHash[buttonName]);
     2044            }
     2045            this.iconClasses = iconClassesCopy;
     2046        }
     2047        else if (iconOverrideHash === false) {
     2048            this.iconClasses = {};
     2049        }
     2050    };
     2051    Theme.prototype.applyIconOverridePrefix = function (className) {
     2052        var prefix = this.iconOverridePrefix;
     2053        if (prefix && className.indexOf(prefix) !== 0) {
     2054            className = prefix + className;
     2055        }
     2056        return className;
     2057    };
     2058    Theme.prototype.getClass = function (key) {
     2059        return this.classes[key] || '';
     2060    };
     2061    Theme.prototype.getIconClass = function (buttonName) {
     2062        var className = this.iconClasses[buttonName];
     2063        if (className) {
     2064            return this.baseIconClass + ' ' + className;
     2065        }
     2066        return '';
     2067    };
     2068    Theme.prototype.getCustomButtonIconClass = function (customButtonProps) {
     2069        var className;
     2070        if (this.iconOverrideCustomButtonOption) {
     2071            className = customButtonProps[this.iconOverrideCustomButtonOption];
     2072            if (className) {
     2073                return this.baseIconClass + ' ' + this.applyIconOverridePrefix(className);
     2074            }
     2075        }
     2076        return '';
     2077    };
     2078    return Theme;
     2079}());
     2080exports.default = Theme;
     2081Theme.prototype.classes = {};
     2082Theme.prototype.iconClasses = {};
     2083Theme.prototype.baseIconClass = '';
     2084Theme.prototype.iconOverridePrefix = '';
     2085
     2086
     2087/***/ }),
     2088/* 20 */
     2089/***/ (function(module, exports, __webpack_require__) {
     2090
     2091Object.defineProperty(exports, "__esModule", { value: true });
     2092var $ = __webpack_require__(3);
     2093var PromiseStub = {
     2094    construct: function (executor) {
     2095        var deferred = $.Deferred();
     2096        var promise = deferred.promise();
     2097        if (typeof executor === 'function') {
     2098            executor(function (val) {
     2099                deferred.resolve(val);
     2100                attachImmediatelyResolvingThen(promise, val);
     2101            }, function () {
     2102                deferred.reject();
     2103                attachImmediatelyRejectingThen(promise);
     2104            });
     2105        }
     2106        return promise;
     2107    },
     2108    resolve: function (val) {
     2109        var deferred = $.Deferred().resolve(val);
     2110        var promise = deferred.promise();
     2111        attachImmediatelyResolvingThen(promise, val);
     2112        return promise;
     2113    },
     2114    reject: function () {
     2115        var deferred = $.Deferred().reject();
     2116        var promise = deferred.promise();
     2117        attachImmediatelyRejectingThen(promise);
     2118        return promise;
     2119    }
     2120};
     2121exports.default = PromiseStub;
     2122function attachImmediatelyResolvingThen(promise, val) {
     2123    promise.then = function (onResolve) {
     2124        if (typeof onResolve === 'function') {
     2125            return PromiseStub.resolve(onResolve(val));
     2126        }
     2127        return promise;
     2128    };
     2129}
     2130function attachImmediatelyRejectingThen(promise) {
     2131    promise.then = function (onResolve, onReject) {
     2132        if (typeof onReject === 'function') {
     2133            onReject();
     2134        }
     2135        return promise;
     2136    };
     2137}
     2138
     2139
     2140/***/ }),
     2141/* 21 */
     2142/***/ (function(module, exports, __webpack_require__) {
     2143
     2144Object.defineProperty(exports, "__esModule", { value: true });
     2145var $ = __webpack_require__(3);
     2146var exportHooks = __webpack_require__(16);
     2147var EmitterMixin_1 = __webpack_require__(11);
     2148var ListenerMixin_1 = __webpack_require__(7);
     2149exportHooks.touchMouseIgnoreWait = 500;
     2150var globalEmitter = null;
     2151var neededCount = 0;
     2152/*
     2153Listens to document and window-level user-interaction events, like touch events and mouse events,
     2154and fires these events as-is to whoever is observing a GlobalEmitter.
     2155Best when used as a singleton via GlobalEmitter.get()
     2156
     2157Normalizes mouse/touch events. For examples:
     2158- ignores the the simulated mouse events that happen after a quick tap: mousemove+mousedown+mouseup+click
     2159- compensates for various buggy scenarios where a touchend does not fire
     2160*/
     2161var GlobalEmitter = /** @class */ (function () {
     2162    function GlobalEmitter() {
     2163        this.isTouching = false;
     2164        this.mouseIgnoreDepth = 0;
     2165    }
     2166    // gets the singleton
     2167    GlobalEmitter.get = function () {
     2168        if (!globalEmitter) {
     2169            globalEmitter = new GlobalEmitter();
     2170            globalEmitter.bind();
     2171        }
     2172        return globalEmitter;
     2173    };
     2174    // called when an object knows it will need a GlobalEmitter in the near future.
     2175    GlobalEmitter.needed = function () {
     2176        GlobalEmitter.get(); // ensures globalEmitter
     2177        neededCount++;
     2178    };
     2179    // called when the object that originally called needed() doesn't need a GlobalEmitter anymore.
     2180    GlobalEmitter.unneeded = function () {
     2181        neededCount--;
     2182        if (!neededCount) {
     2183            globalEmitter.unbind();
     2184            globalEmitter = null;
     2185        }
     2186    };
     2187    GlobalEmitter.prototype.bind = function () {
     2188        var _this = this;
     2189        this.listenTo($(document), {
     2190            touchstart: this.handleTouchStart,
     2191            touchcancel: this.handleTouchCancel,
     2192            touchend: this.handleTouchEnd,
     2193            mousedown: this.handleMouseDown,
     2194            mousemove: this.handleMouseMove,
     2195            mouseup: this.handleMouseUp,
     2196            click: this.handleClick,
     2197            selectstart: this.handleSelectStart,
     2198            contextmenu: this.handleContextMenu
     2199        });
     2200        // because we need to call preventDefault
     2201        // because https://www.chromestatus.com/features/5093566007214080
     2202        // TODO: investigate performance because this is a global handler
     2203        window.addEventListener('touchmove', this.handleTouchMoveProxy = function (ev) {
     2204            _this.handleTouchMove($.Event(ev));
     2205        }, { passive: false } // allows preventDefault()
     2206        );
     2207        // attach a handler to get called when ANY scroll action happens on the page.
     2208        // this was impossible to do with normal on/off because 'scroll' doesn't bubble.
     2209        // http://stackoverflow.com/a/32954565/96342
     2210        window.addEventListener('scroll', this.handleScrollProxy = function (ev) {
     2211            _this.handleScroll($.Event(ev));
     2212        }, true // useCapture
     2213        );
     2214    };
     2215    GlobalEmitter.prototype.unbind = function () {
     2216        this.stopListeningTo($(document));
     2217        window.removeEventListener('touchmove', this.handleTouchMoveProxy);
     2218        window.removeEventListener('scroll', this.handleScrollProxy, true // useCapture
     2219        );
     2220    };
     2221    // Touch Handlers
     2222    // -----------------------------------------------------------------------------------------------------------------
     2223    GlobalEmitter.prototype.handleTouchStart = function (ev) {
     2224        // if a previous touch interaction never ended with a touchend, then implicitly end it,
     2225        // but since a new touch interaction is about to begin, don't start the mouse ignore period.
     2226        this.stopTouch(ev, true); // skipMouseIgnore=true
     2227        this.isTouching = true;
     2228        this.trigger('touchstart', ev);
     2229    };
     2230    GlobalEmitter.prototype.handleTouchMove = function (ev) {
     2231        if (this.isTouching) {
     2232            this.trigger('touchmove', ev);
     2233        }
     2234    };
     2235    GlobalEmitter.prototype.handleTouchCancel = function (ev) {
     2236        if (this.isTouching) {
     2237            this.trigger('touchcancel', ev);
     2238            // Have touchcancel fire an artificial touchend. That way, handlers won't need to listen to both.
     2239            // If touchend fires later, it won't have any effect b/c isTouching will be false.
     2240            this.stopTouch(ev);
     2241        }
     2242    };
     2243    GlobalEmitter.prototype.handleTouchEnd = function (ev) {
     2244        this.stopTouch(ev);
     2245    };
     2246    // Mouse Handlers
     2247    // -----------------------------------------------------------------------------------------------------------------
     2248    GlobalEmitter.prototype.handleMouseDown = function (ev) {
     2249        if (!this.shouldIgnoreMouse()) {
     2250            this.trigger('mousedown', ev);
     2251        }
     2252    };
     2253    GlobalEmitter.prototype.handleMouseMove = function (ev) {
     2254        if (!this.shouldIgnoreMouse()) {
     2255            this.trigger('mousemove', ev);
     2256        }
     2257    };
     2258    GlobalEmitter.prototype.handleMouseUp = function (ev) {
     2259        if (!this.shouldIgnoreMouse()) {
     2260            this.trigger('mouseup', ev);
     2261        }
     2262    };
     2263    GlobalEmitter.prototype.handleClick = function (ev) {
     2264        if (!this.shouldIgnoreMouse()) {
     2265            this.trigger('click', ev);
     2266        }
     2267    };
     2268    // Misc Handlers
     2269    // -----------------------------------------------------------------------------------------------------------------
     2270    GlobalEmitter.prototype.handleSelectStart = function (ev) {
     2271        this.trigger('selectstart', ev);
     2272    };
     2273    GlobalEmitter.prototype.handleContextMenu = function (ev) {
     2274        this.trigger('contextmenu', ev);
     2275    };
     2276    GlobalEmitter.prototype.handleScroll = function (ev) {
     2277        this.trigger('scroll', ev);
     2278    };
     2279    // Utils
     2280    // -----------------------------------------------------------------------------------------------------------------
     2281    GlobalEmitter.prototype.stopTouch = function (ev, skipMouseIgnore) {
     2282        if (skipMouseIgnore === void 0) { skipMouseIgnore = false; }
     2283        if (this.isTouching) {
     2284            this.isTouching = false;
     2285            this.trigger('touchend', ev);
     2286            if (!skipMouseIgnore) {
     2287                this.startTouchMouseIgnore();
     2288            }
     2289        }
     2290    };
     2291    GlobalEmitter.prototype.startTouchMouseIgnore = function () {
     2292        var _this = this;
     2293        var wait = exportHooks.touchMouseIgnoreWait;
     2294        if (wait) {
     2295            this.mouseIgnoreDepth++;
     2296            setTimeout(function () {
     2297                _this.mouseIgnoreDepth--;
     2298            }, wait);
     2299        }
     2300    };
     2301    GlobalEmitter.prototype.shouldIgnoreMouse = function () {
     2302        return this.isTouching || Boolean(this.mouseIgnoreDepth);
     2303    };
     2304    return GlobalEmitter;
     2305}());
     2306exports.default = GlobalEmitter;
     2307ListenerMixin_1.default.mixInto(GlobalEmitter);
     2308EmitterMixin_1.default.mixInto(GlobalEmitter);
     2309
     2310
     2311/***/ }),
     2312/* 22 */
     2313/***/ (function(module, exports, __webpack_require__) {
     2314
     2315Object.defineProperty(exports, "__esModule", { value: true });
     2316var exportHooks = __webpack_require__(16);
     2317exports.viewHash = {};
     2318exportHooks.views = exports.viewHash;
     2319function defineView(viewName, viewConfig) {
     2320    exports.viewHash[viewName] = viewConfig;
     2321}
     2322exports.defineView = defineView;
     2323function getViewConfig(viewName) {
     2324    return exports.viewHash[viewName];
     2325}
     2326exports.getViewConfig = getViewConfig;
     2327
     2328
     2329/***/ }),
     2330/* 23 */
     2331/***/ (function(module, exports, __webpack_require__) {
     2332
     2333Object.defineProperty(exports, "__esModule", { value: true });
     2334var tslib_1 = __webpack_require__(2);
     2335var util_1 = __webpack_require__(4);
     2336var DragListener_1 = __webpack_require__(54);
     2337/* Tracks mouse movements over a component and raises events about which hit the mouse is over.
     2338------------------------------------------------------------------------------------------------------------------------
     2339options:
     2340- subjectEl
     2341- subjectCenter
     2342*/
     2343var HitDragListener = /** @class */ (function (_super) {
     2344    tslib_1.__extends(HitDragListener, _super);
     2345    function HitDragListener(component, options) {
     2346        var _this = _super.call(this, options) || this;
     2347        _this.component = component;
     2348        return _this;
     2349    }
     2350    // Called when drag listening starts (but a real drag has not necessarily began).
     2351    // ev might be undefined if dragging was started manually.
     2352    HitDragListener.prototype.handleInteractionStart = function (ev) {
     2353        var subjectEl = this.subjectEl;
     2354        var subjectRect;
     2355        var origPoint;
     2356        var point;
     2357        this.component.hitsNeeded();
     2358        this.computeScrollBounds(); // for autoscroll
     2359        if (ev) {
     2360            origPoint = { left: util_1.getEvX(ev), top: util_1.getEvY(ev) };
     2361            point = origPoint;
     2362            // constrain the point to bounds of the element being dragged
     2363            if (subjectEl) {
     2364                subjectRect = util_1.getOuterRect(subjectEl); // used for centering as well
     2365                point = util_1.constrainPoint(point, subjectRect);
     2366            }
     2367            this.origHit = this.queryHit(point.left, point.top);
     2368            // treat the center of the subject as the collision point?
     2369            if (subjectEl && this.options.subjectCenter) {
     2370                // only consider the area the subject overlaps the hit. best for large subjects.
     2371                // TODO: skip this if hit didn't supply left/right/top/bottom
     2372                if (this.origHit) {
     2373                    subjectRect = util_1.intersectRects(this.origHit, subjectRect) ||
     2374                        subjectRect; // in case there is no intersection
     2375                }
     2376                point = util_1.getRectCenter(subjectRect);
     2377            }
     2378            this.coordAdjust = util_1.diffPoints(point, origPoint); // point - origPoint
     2379        }
     2380        else {
     2381            this.origHit = null;
     2382            this.coordAdjust = null;
     2383        }
     2384        // call the super-method. do it after origHit has been computed
     2385        _super.prototype.handleInteractionStart.call(this, ev);
     2386    };
     2387    // Called when the actual drag has started
     2388    HitDragListener.prototype.handleDragStart = function (ev) {
     2389        var hit;
     2390        _super.prototype.handleDragStart.call(this, ev);
     2391        // might be different from this.origHit if the min-distance is large
     2392        hit = this.queryHit(util_1.getEvX(ev), util_1.getEvY(ev));
     2393        // report the initial hit the mouse is over
     2394        // especially important if no min-distance and drag starts immediately
     2395        if (hit) {
     2396            this.handleHitOver(hit);
     2397        }
     2398    };
     2399    // Called when the drag moves
     2400    HitDragListener.prototype.handleDrag = function (dx, dy, ev) {
     2401        var hit;
     2402        _super.prototype.handleDrag.call(this, dx, dy, ev);
     2403        hit = this.queryHit(util_1.getEvX(ev), util_1.getEvY(ev));
     2404        if (!isHitsEqual(hit, this.hit)) {
     2405            if (this.hit) {
     2406                this.handleHitOut();
     2407            }
     2408            if (hit) {
     2409                this.handleHitOver(hit);
     2410            }
     2411        }
     2412    };
     2413    // Called when dragging has been stopped
     2414    HitDragListener.prototype.handleDragEnd = function (ev) {
     2415        this.handleHitDone();
     2416        _super.prototype.handleDragEnd.call(this, ev);
     2417    };
     2418    // Called when a the mouse has just moved over a new hit
     2419    HitDragListener.prototype.handleHitOver = function (hit) {
     2420        var isOrig = isHitsEqual(hit, this.origHit);
     2421        this.hit = hit;
     2422        this.trigger('hitOver', this.hit, isOrig, this.origHit);
     2423    };
     2424    // Called when the mouse has just moved out of a hit
     2425    HitDragListener.prototype.handleHitOut = function () {
     2426        if (this.hit) {
     2427            this.trigger('hitOut', this.hit);
     2428            this.handleHitDone();
     2429            this.hit = null;
     2430        }
     2431    };
     2432    // Called after a hitOut. Also called before a dragStop
     2433    HitDragListener.prototype.handleHitDone = function () {
     2434        if (this.hit) {
     2435            this.trigger('hitDone', this.hit);
     2436        }
     2437    };
     2438    // Called when the interaction ends, whether there was a real drag or not
     2439    HitDragListener.prototype.handleInteractionEnd = function (ev, isCancelled) {
     2440        _super.prototype.handleInteractionEnd.call(this, ev, isCancelled);
     2441        this.origHit = null;
     2442        this.hit = null;
     2443        this.component.hitsNotNeeded();
     2444    };
     2445    // Called when scrolling has stopped, whether through auto scroll, or the user scrolling
     2446    HitDragListener.prototype.handleScrollEnd = function () {
     2447        _super.prototype.handleScrollEnd.call(this);
     2448        // hits' absolute positions will be in new places after a user's scroll.
     2449        // HACK for recomputing.
     2450        if (this.isDragging) {
     2451            this.component.releaseHits();
     2452            this.component.prepareHits();
     2453        }
     2454    };
     2455    // Gets the hit underneath the coordinates for the given mouse event
     2456    HitDragListener.prototype.queryHit = function (left, top) {
     2457        if (this.coordAdjust) {
     2458            left += this.coordAdjust.left;
     2459            top += this.coordAdjust.top;
     2460        }
     2461        return this.component.queryHit(left, top);
     2462    };
     2463    return HitDragListener;
     2464}(DragListener_1.default));
     2465exports.default = HitDragListener;
     2466// Returns `true` if the hits are identically equal. `false` otherwise. Must be from the same component.
     2467// Two null values will be considered equal, as two "out of the component" states are the same.
     2468function isHitsEqual(hit0, hit1) {
     2469    if (!hit0 && !hit1) {
     2470        return true;
     2471    }
     2472    if (hit0 && hit1) {
     2473        return hit0.component === hit1.component &&
     2474            isHitPropsWithin(hit0, hit1) &&
     2475            isHitPropsWithin(hit1, hit0); // ensures all props are identical
     2476    }
     2477    return false;
     2478}
     2479// Returns true if all of subHit's non-standard properties are within superHit
     2480function isHitPropsWithin(subHit, superHit) {
     2481    for (var propName in subHit) {
     2482        if (!/^(component|left|right|top|bottom)$/.test(propName)) {
     2483            if (subHit[propName] !== superHit[propName]) {
     2484                return false;
     2485            }
     2486        }
     2487    }
     2488    return true;
     2489}
     2490
     2491
     2492/***/ }),
     2493/* 24 */,
     2494/* 25 */,
     2495/* 26 */,
     2496/* 27 */,
     2497/* 28 */,
     2498/* 29 */,
     2499/* 30 */,
     2500/* 31 */
     2501/***/ (function(module, exports, __webpack_require__) {
     2502
     2503Object.defineProperty(exports, "__esModule", { value: true });
     2504var $ = __webpack_require__(3);
     2505var moment = __webpack_require__(0);
     2506var exportHooks = __webpack_require__(16);
     2507var options_1 = __webpack_require__(32);
     2508var util_1 = __webpack_require__(4);
     2509exports.localeOptionHash = {};
     2510exportHooks.locales = exports.localeOptionHash;
     2511// NOTE: can't guarantee any of these computations will run because not every locale has datepicker
     2512// configs, so make sure there are English fallbacks for these in the defaults file.
     2513var dpComputableOptions = {
     2514    buttonText: function (dpOptions) {
     2515        return {
     2516            // the translations sometimes wrongly contain HTML entities
     2517            prev: util_1.stripHtmlEntities(dpOptions.prevText),
     2518            next: util_1.stripHtmlEntities(dpOptions.nextText),
     2519            today: util_1.stripHtmlEntities(dpOptions.currentText)
     2520        };
     2521    },
     2522    // Produces format strings like "MMMM YYYY" -> "September 2014"
     2523    monthYearFormat: function (dpOptions) {
     2524        return dpOptions.showMonthAfterYear ?
     2525            'YYYY[' + dpOptions.yearSuffix + '] MMMM' :
     2526            'MMMM YYYY[' + dpOptions.yearSuffix + ']';
     2527    }
     2528};
     2529var momComputableOptions = {
     2530    // Produces format strings like "ddd M/D" -> "Fri 9/15"
     2531    dayOfMonthFormat: function (momOptions, fcOptions) {
     2532        var format = momOptions.longDateFormat('l'); // for the format like "M/D/YYYY"
     2533        // strip the year off the edge, as well as other misc non-whitespace chars
     2534        format = format.replace(/^Y+[^\w\s]*|[^\w\s]*Y+$/g, '');
     2535        if (fcOptions.isRTL) {
     2536            format += ' ddd'; // for RTL, add day-of-week to end
     2537        }
     2538        else {
     2539            format = 'ddd ' + format; // for LTR, add day-of-week to beginning
     2540        }
     2541        return format;
     2542    },
     2543    // Produces format strings like "h:mma" -> "6:00pm"
     2544    mediumTimeFormat: function (momOptions) {
     2545        return momOptions.longDateFormat('LT')
     2546            .replace(/\s*a$/i, 'a'); // convert AM/PM/am/pm to lowercase. remove any spaces beforehand
     2547    },
     2548    // Produces format strings like "h(:mm)a" -> "6pm" / "6:30pm"
     2549    smallTimeFormat: function (momOptions) {
     2550        return momOptions.longDateFormat('LT')
     2551            .replace(':mm', '(:mm)')
     2552            .replace(/(\Wmm)$/, '($1)') // like above, but for foreign locales
     2553            .replace(/\s*a$/i, 'a'); // convert AM/PM/am/pm to lowercase. remove any spaces beforehand
     2554    },
     2555    // Produces format strings like "h(:mm)t" -> "6p" / "6:30p"
     2556    extraSmallTimeFormat: function (momOptions) {
     2557        return momOptions.longDateFormat('LT')
     2558            .replace(':mm', '(:mm)')
     2559            .replace(/(\Wmm)$/, '($1)') // like above, but for foreign locales
     2560            .replace(/\s*a$/i, 't'); // convert to AM/PM/am/pm to lowercase one-letter. remove any spaces beforehand
     2561    },
     2562    // Produces format strings like "ha" / "H" -> "6pm" / "18"
     2563    hourFormat: function (momOptions) {
     2564        return momOptions.longDateFormat('LT')
     2565            .replace(':mm', '')
     2566            .replace(/(\Wmm)$/, '') // like above, but for foreign locales
     2567            .replace(/\s*a$/i, 'a'); // convert AM/PM/am/pm to lowercase. remove any spaces beforehand
     2568    },
     2569    // Produces format strings like "h:mm" -> "6:30" (with no AM/PM)
     2570    noMeridiemTimeFormat: function (momOptions) {
     2571        return momOptions.longDateFormat('LT')
     2572            .replace(/\s*a$/i, ''); // remove trailing AM/PM
     2573    }
     2574};
     2575// options that should be computed off live calendar options (considers override options)
     2576// TODO: best place for this? related to locale?
     2577// TODO: flipping text based on isRTL is a bad idea because the CSS `direction` might want to handle it
     2578var instanceComputableOptions = {
     2579    // Produces format strings for results like "Mo 16"
     2580    smallDayDateFormat: function (options) {
     2581        return options.isRTL ?
     2582            'D dd' :
     2583            'dd D';
     2584    },
     2585    // Produces format strings for results like "Wk 5"
     2586    weekFormat: function (options) {
     2587        return options.isRTL ?
     2588            'w[ ' + options.weekNumberTitle + ']' :
     2589            '[' + options.weekNumberTitle + ' ]w';
     2590    },
     2591    // Produces format strings for results like "Wk5"
     2592    smallWeekFormat: function (options) {
     2593        return options.isRTL ?
     2594            'w[' + options.weekNumberTitle + ']' :
     2595            '[' + options.weekNumberTitle + ']w';
     2596    }
     2597};
     2598// TODO: make these computable properties in optionsManager
     2599function populateInstanceComputableOptions(options) {
     2600    $.each(instanceComputableOptions, function (name, func) {
     2601        if (options[name] == null) {
     2602            options[name] = func(options);
     2603        }
     2604    });
     2605}
     2606exports.populateInstanceComputableOptions = populateInstanceComputableOptions;
     2607// Initialize jQuery UI datepicker translations while using some of the translations
     2608// Will set this as the default locales for datepicker.
     2609function datepickerLocale(localeCode, dpLocaleCode, dpOptions) {
     2610    // get the FullCalendar internal option hash for this locale. create if necessary
     2611    var fcOptions = exports.localeOptionHash[localeCode] || (exports.localeOptionHash[localeCode] = {});
     2612    // transfer some simple options from datepicker to fc
     2613    fcOptions.isRTL = dpOptions.isRTL;
     2614    fcOptions.weekNumberTitle = dpOptions.weekHeader;
     2615    // compute some more complex options from datepicker
     2616    $.each(dpComputableOptions, function (name, func) {
     2617        fcOptions[name] = func(dpOptions);
     2618    });
     2619    var jqDatePicker = $.datepicker;
     2620    // is jQuery UI Datepicker is on the page?
     2621    if (jqDatePicker) {
     2622        // Register the locale data.
     2623        // FullCalendar and MomentJS use locale codes like "pt-br" but Datepicker
     2624        // does it like "pt-BR" or if it doesn't have the locale, maybe just "pt".
     2625        // Make an alias so the locale can be referenced either way.
     2626        jqDatePicker.regional[dpLocaleCode] =
     2627            jqDatePicker.regional[localeCode] = // alias
     2628                dpOptions;
     2629        // Alias 'en' to the default locale data. Do this every time.
     2630        jqDatePicker.regional.en = jqDatePicker.regional[''];
     2631        // Set as Datepicker's global defaults.
     2632        jqDatePicker.setDefaults(dpOptions);
     2633    }
     2634}
     2635exports.datepickerLocale = datepickerLocale;
     2636// Sets FullCalendar-specific translations. Will set the locales as the global default.
     2637function locale(localeCode, newFcOptions) {
     2638    var fcOptions;
     2639    var momOptions;
     2640    // get the FullCalendar internal option hash for this locale. create if necessary
     2641    fcOptions = exports.localeOptionHash[localeCode] || (exports.localeOptionHash[localeCode] = {});
     2642    // provided new options for this locales? merge them in
     2643    if (newFcOptions) {
     2644        fcOptions = exports.localeOptionHash[localeCode] = options_1.mergeOptions([fcOptions, newFcOptions]);
     2645    }
     2646    // compute locale options that weren't defined.
     2647    // always do this. newFcOptions can be undefined when initializing from i18n file,
     2648    // so no way to tell if this is an initialization or a default-setting.
     2649    momOptions = getMomentLocaleData(localeCode); // will fall back to en
     2650    $.each(momComputableOptions, function (name, func) {
     2651        if (fcOptions[name] == null) {
     2652            fcOptions[name] = (func)(momOptions, fcOptions);
     2653        }
     2654    });
     2655    // set it as the default locale for FullCalendar
     2656    options_1.globalDefaults.locale = localeCode;
     2657}
     2658exports.locale = locale;
     2659// Returns moment's internal locale data. If doesn't exist, returns English.
     2660function getMomentLocaleData(localeCode) {
     2661    return moment.localeData(localeCode) || moment.localeData('en');
     2662}
     2663exports.getMomentLocaleData = getMomentLocaleData;
     2664// Initialize English by forcing computation of moment-derived options.
     2665// Also, sets it as the default.
     2666locale('en', options_1.englishDefaults);
     2667
     2668
     2669/***/ }),
     2670/* 32 */
     2671/***/ (function(module, exports, __webpack_require__) {
     2672
     2673Object.defineProperty(exports, "__esModule", { value: true });
     2674var util_1 = __webpack_require__(4);
     2675exports.globalDefaults = {
     2676    titleRangeSeparator: ' \u2013 ',
     2677    monthYearFormat: 'MMMM YYYY',
     2678    defaultTimedEventDuration: '02:00:00',
     2679    defaultAllDayEventDuration: { days: 1 },
     2680    forceEventDuration: false,
     2681    nextDayThreshold: '09:00:00',
     2682    // display
     2683    columnHeader: true,
     2684    defaultView: 'month',
     2685    aspectRatio: 1.35,
     2686    header: {
     2687