/ajax/libs/later/1.2.0/later.js

https://gitlab.com/Mirros/cdnjs · JavaScript · 1480 lines · 1464 code · 16 blank · 0 comment · 295 complexity · 5c30f2c601c53e7db912e2d1fd1df1a0 MD5 · raw file 

    

  1. later = function() {
    2. 

  2.   "use strict";
    3. 

  3.   var later = {
    4. 

  4.     version: "1.2.0"
    5. 

  5.   };
    6. 

  6.   if (!Array.prototype.indexOf) {
    7. 

  7.     Array.prototype.indexOf = function(searchElement) {
    8. 

  8.       "use strict";
    9. 

  9.       if (this == null) {
    10. 

  10.         throw new TypeError();
    11. 

  11.       }
    12. 

  12.       var t = Object(this);
    13. 

  13.       var len = t.length >>> 0;
    14. 

  14.       if (len === 0) {
    15. 

  15.         return -1;
    16. 

  16.       }
    17. 

  17.       var n = 0;
    18. 

  18.       if (arguments.length > 1) {
    19. 

  19.         n = Number(arguments[1]);
    20. 

  20.         if (n != n) {
    21. 

  21.           n = 0;
    22. 

  22.         } else if (n != 0 && n != Infinity && n != -Infinity) {
    23. 

  23.           n = (n > 0 || -1) * Math.floor(Math.abs(n));
    24. 

  24.         }
    25. 

  25.       }
    26. 

  26.       if (n >= len) {
    27. 

  27.         return -1;
    28. 

  28.       }
    29. 

  29.       var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
    30. 

  30.       for (;k < len; k++) {
    31. 

  31.         if (k in t && t[k] === searchElement) {
    32. 

  32.           return k;
    33. 

  33.         }
    34. 

  34.       }
    35. 

  35.       return -1;
    36. 

  36.     };
    37. 

  37.   }
    38. 

  38.   if (!String.prototype.trim) {
    39. 

  39.     String.prototype.trim = function() {
    40. 

  40.       return this.replace(/^\s+|\s+$/g, "");
    41. 

  41.     };
    42. 

  42.   }
    43. 

  43.   later.array = {};
    44. 

  44.   later.array.sort = function(arr, zeroIsLast) {
    45. 

  45.     arr.sort(function(a, b) {
    46. 

  46.       return +a - +b;
    47. 

  47.     });
    48. 

  48.     if (zeroIsLast && arr[0] === 0) {
    49. 

  49.       arr.push(arr.shift());
    50. 

  50.     }
    51. 

  51.   };
    52. 

  52.   later.array.next = function(val, values, extent) {
    53. 

  53.     var cur, zeroIsLargest = extent[0] !== 0, nextIdx = 0;
    54. 

  54.     for (var i = values.length - 1; i > -1; --i) {
    55. 

  55.       cur = values[i];
    56. 

  56.       if (cur === val) {
    57. 

  57.         return cur;
    58. 

  58.       }
    59. 

  59.       if (cur > val || cur === 0 && zeroIsLargest && extent[1] > val) {
    60. 

  60.         nextIdx = i;
    61. 

  61.         continue;
    62. 

  62.       }
    63. 

  63.       break;
    64. 

  64.     }
    65. 

  65.     return values[nextIdx];
    66. 

  66.   };
    67. 

  67.   later.array.nextInvalid = function(val, values, extent) {
    68. 

  68.     var min = extent[0], max = extent[1], len = values.length, zeroVal = values[len - 1] === 0 && min !== 0 ? max : 0, next = val, i = values.indexOf(val), start = next;
    69. 

  69.     while (next === (values[i] || zeroVal)) {
    70. 

  70.       next++;
    71. 

  71.       if (next > max) {
    72. 

  72.         next = min;
    73. 

  73.       }
    74. 

  74.       i++;
    75. 

  75.       if (i === len) {
    76. 

  76.         i = 0;
    77. 

  77.       }
    78. 

  78.       if (next === start) {
    79. 

  79.         return undefined;
    80. 

  80.       }
    81. 

  81.     }
    82. 

  82.     return next;
    83. 

  83.   };
    84. 

  84.   later.array.prev = function(val, values, extent) {
    85. 

  85.     var cur, len = values.length, zeroIsLargest = extent[0] !== 0, prevIdx = len - 1;
    86. 

  86.     for (var i = 0; i < len; i++) {
    87. 

  87.       cur = values[i];
    88. 

  88.       if (cur === val) {
    89. 

  89.         return cur;
    90. 

  90.       }
    91. 

  91.       if (cur < val || cur === 0 && zeroIsLargest && extent[1] < val) {
    92. 

  92.         prevIdx = i;
    93. 

  93.         continue;
    94. 

  94.       }
    95. 

  95.       break;
    96. 

  96.     }
    97. 

  97.     return values[prevIdx];
    98. 

  98.   };
    99. 

  99.   later.array.prevInvalid = function(val, values, extent) {
    100. 

  100.     var min = extent[0], max = extent[1], len = values.length, zeroVal = values[len - 1] === 0 && min !== 0 ? max : 0, next = val, i = values.indexOf(val), start = next;
    101. 

  101.     while (next === (values[i] || zeroVal)) {
    102. 

  102.       next--;
    103. 

  103.       if (next < min) {
    104. 

  104.         next = max;
    105. 

  105.       }
    106. 

  106.       i--;
    107. 

  107.       if (i === -1) {
    108. 

  108.         i = len - 1;
    109. 

  109.       }
    110. 

  110.       if (next === start) {
    111. 

  111.         return undefined;
    112. 

  112.       }
    113. 

  113.     }
    114. 

  114.     return next;
    115. 

  115.   };
    116. 

  116.   later.day = later.D = {
    117. 

  117.     name: "day",
    118. 

  118.     range: 86400,
    119. 

  119.     val: function(d) {
    120. 

  120.       return d.D || (d.D = later.date.getDate.call(d));
    121. 

  121.     },
    122. 

  122.     isValid: function(d, val) {
    123. 

  123.       return later.D.val(d) === (val || later.D.extent(d)[1]);
    124. 

  124.     },
    125. 

  125.     extent: function(d) {
    126. 

  126.       if (d.DExtent) return d.DExtent;
    127. 

  127.       var month = later.M.val(d), max = later.DAYS_IN_MONTH[month - 1];
    128. 

  128.       if (month === 2 && later.dy.extent(d)[1] === 366) {
    129. 

  129.         max = max + 1;
    130. 

  130.       }
    131. 

  131.       return d.DExtent = [ 1, max ];
    132. 

  132.     },
    133. 

  133.     start: function(d) {
    134. 

  134.       return d.DStart || (d.DStart = later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d)));
    135. 

  135.     },
    136. 

  136.     end: function(d) {
    137. 

  137.       return d.DEnd || (d.DEnd = later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d)));
    138. 

  138.     },
    139. 

  139.     next: function(d, val) {
    140. 

  140.       val = val > later.D.extent(d)[1] ? 1 : val;
    141. 

  141.       var month = later.date.nextRollover(d, val, later.D, later.M), DMax = later.D.extent(month)[1];
    142. 

  142.       val = val > DMax ? 1 : val || DMax;
    143. 

  143.       return later.date.next(later.Y.val(month), later.M.val(month), val);
    144. 

  144.     },
    145. 

  145.     prev: function(d, val) {
    146. 

  146.       var month = later.date.prevRollover(d, val, later.D, later.M), DMax = later.D.extent(month)[1];
    147. 

  147.       return later.date.prev(later.Y.val(month), later.M.val(month), val > DMax ? DMax : val || DMax);
    148. 

  148.     }
    149. 

  149.   };
    150. 

  150.   later.dayOfWeekCount = later.dc = {
    151. 

  151.     name: "day of week count",
    152. 

  152.     range: 604800,
    153. 

  153.     val: function(d) {
    154. 

  154.       return d.dc || (d.dc = Math.floor((later.D.val(d) - 1) / 7) + 1);
    155. 

  155.     },
    156. 

  156.     isValid: function(d, val) {
    157. 

  157.       return later.dc.val(d) === val || val === 0 && later.D.val(d) > later.D.extent(d)[1] - 7;
    158. 

  158.     },
    159. 

  159.     extent: function(d) {
    160. 

  160.       return d.dcExtent || (d.dcExtent = [ 1, Math.ceil(later.D.extent(d)[1] / 7) ]);
    161. 

  161.     },
    162. 

  162.     start: function(d) {
    163. 

  163.       return d.dcStart || (d.dcStart = later.date.next(later.Y.val(d), later.M.val(d), Math.max(1, (later.dc.val(d) - 1) * 7 + 1 || 1)));
    164. 

  164.     },
    165. 

  165.     end: function(d) {
    166. 

  166.       return d.dcEnd || (d.dcEnd = later.date.prev(later.Y.val(d), later.M.val(d), Math.min(later.dc.val(d) * 7, later.D.extent(d)[1])));
    167. 

  167.     },
    168. 

  168.     next: function(d, val) {
    169. 

  169.       val = val > later.dc.extent(d)[1] ? 1 : val;
    170. 

  170.       var month = later.date.nextRollover(d, val, later.dc, later.M), dcMax = later.dc.extent(month)[1];
    171. 

  171.       val = val > dcMax ? 1 : val;
    172. 

  172.       var next = later.date.next(later.Y.val(month), later.M.val(month), val === 0 ? later.D.extent(month)[1] - 6 : 1 + 7 * (val - 1));
    173. 

  173.       if (next.getTime() <= d.getTime()) {
    174. 

  174.         month = later.M.next(d, later.M.val(d) + 1);
    175. 

  175.         return later.date.next(later.Y.val(month), later.M.val(month), val === 0 ? later.D.extent(month)[1] - 6 : 1 + 7 * (val - 1));
    176. 

  176.       }
    177. 

  177.       return next;
    178. 

  178.     },
    179. 

  179.     prev: function(d, val) {
    180. 

  180.       var month = later.date.prevRollover(d, val, later.dc, later.M), dcMax = later.dc.extent(month)[1];
    181. 

  181.       val = val > dcMax ? dcMax : val || dcMax;
    182. 

  182.       return later.dc.end(later.date.prev(later.Y.val(month), later.M.val(month), 1 + 7 * (val - 1)));
    183. 

  183.     }
    184. 

  184.   };
    185. 

  185.   later.dayOfWeek = later.dw = later.d = {
    186. 

  186.     name: "day of week",
    187. 

  187.     range: 86400,
    188. 

  188.     val: function(d) {
    189. 

  189.       return d.dw || (d.dw = later.date.getDay.call(d) + 1);
    190. 

  190.     },
    191. 

  191.     isValid: function(d, val) {
    192. 

  192.       return later.dw.val(d) === (val || 7);
    193. 

  193.     },
    194. 

  194.     extent: function() {
    195. 

  195.       return [ 1, 7 ];
    196. 

  196.     },
    197. 

  197.     start: function(d) {
    198. 

  198.       return later.D.start(d);
    199. 

  199.     },
    200. 

  200.     end: function(d) {
    201. 

  201.       return later.D.end(d);
    202. 

  202.     },
    203. 

  203.     next: function(d, val) {
    204. 

  204.       val = val > 7 ? 1 : val || 7;
    205. 

  205.       return later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d) + (val - later.dw.val(d)) + (val <= later.dw.val(d) ? 7 : 0));
    206. 

  206.     },
    207. 

  207.     prev: function(d, val) {
    208. 

  208.       val = val > 7 ? 7 : val || 7;
    209. 

  209.       return later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d) + (val - later.dw.val(d)) + (val >= later.dw.val(d) ? -7 : 0));
    210. 

  210.     }
    211. 

  211.   };
    212. 

  212.   later.dayOfYear = later.dy = {
    213. 

  213.     name: "day of year",
    214. 

  214.     range: 86400,
    215. 

  215.     val: function(d) {
    216. 

  216.       return d.dy || (d.dy = Math.ceil(1 + (later.D.start(d).getTime() - later.Y.start(d).getTime()) / later.DAY));
    217. 

  217.     },
    218. 

  218.     isValid: function(d, val) {
    219. 

  219.       return later.dy.val(d) === (val || later.dy.extent(d)[1]);
    220. 

  220.     },
    221. 

  221.     extent: function(d) {
    222. 

  222.       var year = later.Y.val(d);
    223. 

  223.       return d.dyExtent || (d.dyExtent = [ 1, year % 4 ? 365 : 366 ]);
    224. 

  224.     },
    225. 

  225.     start: function(d) {
    226. 

  226.       return later.D.start(d);
    227. 

  227.     },
    228. 

  228.     end: function(d) {
    229. 

  229.       return later.D.end(d);
    230. 

  230.     },
    231. 

  231.     next: function(d, val) {
    232. 

  232.       val = val > later.dy.extent(d)[1] ? 1 : val;
    233. 

  233.       var year = later.date.nextRollover(d, val, later.dy, later.Y), dyMax = later.dy.extent(year)[1];
    234. 

  234.       val = val > dyMax ? 1 : val || dyMax;
    235. 

  235.       return later.date.next(later.Y.val(year), later.M.val(year), val);
    236. 

  236.     },
    237. 

  237.     prev: function(d, val) {
    238. 

  238.       var year = later.date.prevRollover(d, val, later.dy, later.Y), dyMax = later.dy.extent(year)[1];
    239. 

  239.       val = val > dyMax ? dyMax : val || dyMax;
    240. 

  240.       return later.date.prev(later.Y.val(year), later.M.val(year), val);
    241. 

  241.     }
    242. 

  242.   };
    243. 

  243.   later.hour = later.h = {
    244. 

  244.     name: "hour",
    245. 

  245.     range: 3600,
    246. 

  246.     val: function(d) {
    247. 

  247.       return d.h || (d.h = later.date.getHour.call(d));
    248. 

  248.     },
    249. 

  249.     isValid: function(d, val) {
    250. 

  250.       return later.h.val(d) === val;
    251. 

  251.     },
    252. 

  252.     extent: function() {
    253. 

  253.       return [ 0, 23 ];
    254. 

  254.     },
    255. 

  255.     start: function(d) {
    256. 

  256.       return d.hStart || (d.hStart = later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d), later.h.val(d)));
    257. 

  257.     },
    258. 

  258.     end: function(d) {
    259. 

  259.       return d.hEnd || (d.hEnd = later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d), later.h.val(d)));
    260. 

  260.     },
    261. 

  261.     next: function(d, val) {
    262. 

  262.       val = val > 23 ? 0 : val;
    263. 

  263.       var next = later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d) + (val <= later.h.val(d) ? 1 : 0), val);
    264. 

  264.       if (!later.date.isUTC && next.getTime() <= d.getTime()) {
    265. 

  265.         next = later.date.next(later.Y.val(next), later.M.val(next), later.D.val(next), val + 1);
    266. 

  266.       }
    267. 

  267.       return next;
    268. 

  268.     },
    269. 

  269.     prev: function(d, val) {
    270. 

  270.       val = val > 23 ? 23 : val;
    271. 

  271.       return later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d) + (val >= later.h.val(d) ? -1 : 0), val);
    272. 

  272.     }
    273. 

  273.   };
    274. 

  274.   later.minute = later.m = {
    275. 

  275.     name: "minute",
    276. 

  276.     range: 60,
    277. 

  277.     val: function(d) {
    278. 

  278.       return d.m || (d.m = later.date.getMin.call(d));
    279. 

  279.     },
    280. 

  280.     isValid: function(d, val) {
    281. 

  281.       return later.m.val(d) === val;
    282. 

  282.     },
    283. 

  283.     extent: function(d) {
    284. 

  284.       return [ 0, 59 ];
    285. 

  285.     },
    286. 

  286.     start: function(d) {
    287. 

  287.       return d.mStart || (d.mStart = later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d), later.h.val(d), later.m.val(d)));
    288. 

  288.     },
    289. 

  289.     end: function(d) {
    290. 

  290.       return d.mEnd || (d.mEnd = later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d), later.h.val(d), later.m.val(d)));
    291. 

  291.     },
    292. 

  292.     next: function(d, val) {
    293. 

  293.       var m = later.m.val(d), s = later.s.val(d), inc = val > 59 ? 60 - m : val <= m ? 60 - m + val : val - m, next = new Date(d.getTime() + inc * later.MIN - s * later.SEC);
    294. 

  294.       if (!later.date.isUTC && next.getTime() <= d.getTime()) {
    295. 

  295.         next = new Date(d.getTime() + (inc + 120) * later.MIN - s * later.SEC);
    296. 

  296.       }
    297. 

  297.       return next;
    298. 

  298.     },
    299. 

  299.     prev: function(d, val) {
    300. 

  300.       val = val > 59 ? 59 : val;
    301. 

  301.       return later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d), later.h.val(d) + (val >= later.m.val(d) ? -1 : 0), val);
    302. 

  302.     }
    303. 

  303.   };
    304. 

  304.   later.month = later.M = {
    305. 

  305.     name: "month",
    306. 

  306.     range: 2629740,
    307. 

  307.     val: function(d) {
    308. 

  308.       return d.M || (d.M = later.date.getMonth.call(d) + 1);
    309. 

  309.     },
    310. 

  310.     isValid: function(d, val) {
    311. 

  311.       return later.M.val(d) === (val || 12);
    312. 

  312.     },
    313. 

  313.     extent: function() {
    314. 

  314.       return [ 1, 12 ];
    315. 

  315.     },
    316. 

  316.     start: function(d) {
    317. 

  317.       return d.MStart || (d.MStart = later.date.next(later.Y.val(d), later.M.val(d)));
    318. 

  318.     },
    319. 

  319.     end: function(d) {
    320. 

  320.       return d.MEnd || (d.MEnd = later.date.prev(later.Y.val(d), later.M.val(d)));
    321. 

  321.     },
    322. 

  322.     next: function(d, val) {
    323. 

  323.       val = val > 12 ? 1 : val || 12;
    324. 

  324.       return later.date.next(later.Y.val(d) + (val > later.M.val(d) ? 0 : 1), val);
    325. 

  325.     },
    326. 

  326.     prev: function(d, val) {
    327. 

  327.       val = val > 12 ? 12 : val || 12;
    328. 

  328.       return later.date.prev(later.Y.val(d) - (val >= later.M.val(d) ? 1 : 0), val);
    329. 

  329.     }
    330. 

  330.   };
    331. 

  331.   later.second = later.s = {
    332. 

  332.     name: "second",
    333. 

  333.     range: 1,
    334. 

  334.     val: function(d) {
    335. 

  335.       return d.s || (d.s = later.date.getSec.call(d));
    336. 

  336.     },
    337. 

  337.     isValid: function(d, val) {
    338. 

  338.       return later.s.val(d) === val;
    339. 

  339.     },
    340. 

  340.     extent: function() {
    341. 

  341.       return [ 0, 59 ];
    342. 

  342.     },
    343. 

  343.     start: function(d) {
    344. 

  344.       return d;
    345. 

  345.     },
    346. 

  346.     end: function(d) {
    347. 

  347.       return d;
    348. 

  348.     },
    349. 

  349.     next: function(d, val) {
    350. 

  350.       var s = later.s.val(d), inc = val > 59 ? 60 - s : val <= s ? 60 - s + val : val - s, next = new Date(d.getTime() + inc * later.SEC);
    351. 

  351.       if (!later.date.isUTC && next.getTime() <= d.getTime()) {
    352. 

  352.         next = new Date(d.getTime() + (inc + 7200) * later.SEC);
    353. 

  353.       }
    354. 

  354.       return next;
    355. 

  355.     },
    356. 

  356.     prev: function(d, val, cache) {
    357. 

  357.       val = val > 59 ? 59 : val;
    358. 

  358.       return later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d), later.h.val(d), later.m.val(d) + (val >= later.s.val(d) ? -1 : 0), val);
    359. 

  359.     }
    360. 

  360.   };
    361. 

  361.   later.time = later.t = {
    362. 

  362.     name: "time",
    363. 

  363.     range: 1,
    364. 

  364.     val: function(d) {
    365. 

  365.       return d.t || (d.t = later.h.val(d) * 3600 + later.m.val(d) * 60 + later.s.val(d));
    366. 

  366.     },
    367. 

  367.     isValid: function(d, val) {
    368. 

  368.       return later.t.val(d) === val;
    369. 

  369.     },
    370. 

  370.     extent: function() {
    371. 

  371.       return [ 0, 86399 ];
    372. 

  372.     },
    373. 

  373.     start: function(d) {
    374. 

  374.       return d;
    375. 

  375.     },
    376. 

  376.     end: function(d) {
    377. 

  377.       return d;
    378. 

  378.     },
    379. 

  379.     next: function(d, val) {
    380. 

  380.       val = val > 86399 ? 0 : val;
    381. 

  381.       var next = later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d) + (val <= later.t.val(d) ? 1 : 0), 0, 0, val);
    382. 

  382.       if (!later.date.isUTC && next.getTime() < d.getTime()) {
    383. 

  383.         next = later.date.next(later.Y.val(next), later.M.val(next), later.D.val(next), later.h.val(next), later.m.val(next), val + 7200);
    384. 

  384.       }
    385. 

  385.       return next;
    386. 

  386.     },
    387. 

  387.     prev: function(d, val) {
    388. 

  388.       val = val > 86399 ? 86399 : val;
    389. 

  389.       return later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d) + (val >= later.t.val(d) ? -1 : 0), 0, 0, val);
    390. 

  390.     }
    391. 

  391.   };
    392. 

  392.   later.weekOfMonth = later.wm = {
    393. 

  393.     name: "week of month",
    394. 

  394.     range: 604800,
    395. 

  395.     val: function(d) {
    396. 

  396.       return d.wm || (d.wm = (later.D.val(d) + (later.dw.val(later.M.start(d)) - 1) + (7 - later.dw.val(d))) / 7);
    397. 

  397.     },
    398. 

  398.     isValid: function(d, val) {
    399. 

  399.       return later.wm.val(d) === (val || later.wm.extent(d)[1]);
    400. 

  400.     },
    401. 

  401.     extent: function(d) {
    402. 

  402.       return d.wmExtent || (d.wmExtent = [ 1, (later.D.extent(d)[1] + (later.dw.val(later.M.start(d)) - 1) + (7 - later.dw.val(later.M.end(d)))) / 7 ]);
    403. 

  403.     },
    404. 

  404.     start: function(d) {
    405. 

  405.       return d.wmStart || (d.wmStart = later.date.next(later.Y.val(d), later.M.val(d), Math.max(later.D.val(d) - later.dw.val(d) + 1, 1)));
    406. 

  406.     },
    407. 

  407.     end: function(d) {
    408. 

  408.       return d.wmEnd || (d.wmEnd = later.date.prev(later.Y.val(d), later.M.val(d), Math.min(later.D.val(d) + (7 - later.dw.val(d)), later.D.extent(d)[1])));
    409. 

  409.     },
    410. 

  410.     next: function(d, val) {
    411. 

  411.       val = val > later.wm.extent(d)[1] ? 1 : val;
    412. 

  412.       var month = later.date.nextRollover(d, val, later.wm, later.M), wmMax = later.wm.extent(month)[1];
    413. 

  413.       val = val > wmMax ? 1 : val || wmMax;
    414. 

  414.       return later.date.next(later.Y.val(month), later.M.val(month), Math.max(1, (val - 1) * 7 - (later.dw.val(month) - 2)));
    415. 

  415.     },
    416. 

  416.     prev: function(d, val) {
    417. 

  417.       var month = later.date.prevRollover(d, val, later.wm, later.M), wmMax = later.wm.extent(month)[1];
    418. 

  418.       val = val > wmMax ? wmMax : val || wmMax;
    419. 

  419.       return later.wm.end(later.date.next(later.Y.val(month), later.M.val(month), Math.max(1, (val - 1) * 7 - (later.dw.val(month) - 2))));
    420. 

  420.     }
    421. 

  421.   };
    422. 

  422.   later.weekOfYear = later.wy = {
    423. 

  423.     name: "week of year (ISO)",
    424. 

  424.     range: 604800,
    425. 

  425.     val: function(d) {
    426. 

  426.       if (d.wy) return d.wy;
    427. 

  427.       var wThur = later.dw.next(later.wy.start(d), 5), YThur = later.dw.next(later.Y.prev(wThur, later.Y.val(wThur) - 1), 5);
    428. 

  428.       return d.wy = 1 + Math.ceil((wThur.getTime() - YThur.getTime()) / later.WEEK);
    429. 

  429.     },
    430. 

  430.     isValid: function(d, val) {
    431. 

  431.       return later.wy.val(d) === (val || later.wy.extent(d)[1]);
    432. 

  432.     },
    433. 

  433.     extent: function(d) {
    434. 

  434.       if (d.wyExtent) return d.wyExtent;
    435. 

  435.       var year = later.dw.next(later.wy.start(d), 5), dwFirst = later.dw.val(later.Y.start(year)), dwLast = later.dw.val(later.Y.end(year));
    436. 

  436.       return d.wyExtent = [ 1, dwFirst === 5 || dwLast === 5 ? 53 : 52 ];
    437. 

  437.     },
    438. 

  438.     start: function(d) {
    439. 

  439.       return d.wyStart || (d.wyStart = later.date.next(later.Y.val(d), later.M.val(d), later.D.val(d) - (later.dw.val(d) > 1 ? later.dw.val(d) - 2 : 6)));
    440. 

  440.     },
    441. 

  441.     end: function(d) {
    442. 

  442.       return d.wyEnd || (d.wyEnd = later.date.prev(later.Y.val(d), later.M.val(d), later.D.val(d) + (later.dw.val(d) > 1 ? 8 - later.dw.val(d) : 0)));
    443. 

  443.     },
    444. 

  444.     next: function(d, val) {
    445. 

  445.       val = val > later.wy.extent(d)[1] ? 1 : val;
    446. 

  446.       var wyThur = later.dw.next(later.wy.start(d), 5), year = later.date.nextRollover(wyThur, val, later.wy, later.Y);
    447. 

  447.       if (later.wy.val(year) !== 1) {
    448. 

  448.         year = later.dw.next(year, 2);
    449. 

  449.       }
    450. 

  450.       var wyMax = later.wy.extent(year)[1], wyStart = later.wy.start(year);
    451. 

  451.       val = val > wyMax ? 1 : val || wyMax;
    452. 

  452.       return later.date.next(later.Y.val(wyStart), later.M.val(wyStart), later.D.val(wyStart) + 7 * (val - 1));
    453. 

  453.     },
    454. 

  454.     prev: function(d, val) {
    455. 

  455.       var wyThur = later.dw.next(later.wy.start(d), 5), year = later.date.prevRollover(wyThur, val, later.wy, later.Y);
    456. 

  456.       if (later.wy.val(year) !== 1) {
    457. 

  457.         year = later.dw.next(year, 2);
    458. 

  458.       }
    459. 

  459.       var wyMax = later.wy.extent(year)[1], wyEnd = later.wy.end(year);
    460. 

  460.       val = val > wyMax ? wyMax : val || wyMax;
    461. 

  461.       return later.wy.end(later.date.next(later.Y.val(wyEnd), later.M.val(wyEnd), later.D.val(wyEnd) + 7 * (val - 1)));
    462. 

  462.     }
    463. 

  463.   };
    464. 

  464.   later.year = later.Y = {
    465. 

  465.     name: "year",
    466. 

  466.     range: 31556900,
    467. 

  467.     val: function(d) {
    468. 

  468.       return d.Y || (d.Y = later.date.getYear.call(d));
    469. 

  469.     },
    470. 

  470.     isValid: function(d, val) {
    471. 

  471.       return later.Y.val(d) === val;
    472. 

  472.     },
    473. 

  473.     extent: function() {
    474. 

  474.       return [ 1970, 2099 ];
    475. 

  475.     },
    476. 

  476.     start: function(d) {
    477. 

  477.       return d.YStart || (d.YStart = later.date.next(later.Y.val(d)));
    478. 

  478.     },
    479. 

  479.     end: function(d) {
    480. 

  480.       return d.YEnd || (d.YEnd = later.date.prev(later.Y.val(d)));
    481. 

  481.     },
    482. 

  482.     next: function(d, val) {
    483. 

  483.       return val > later.Y.val(d) && val <= later.Y.extent()[1] ? later.date.next(val) : later.NEVER;
    484. 

  484.     },
    485. 

  485.     prev: function(d, val) {
    486. 

  486.       return val < later.Y.val(d) && val >= later.Y.extent()[0] ? later.date.prev(val) : later.NEVER;
    487. 

  487.     }
    488. 

  488.   };
    489. 

  489.   later.fullDate = later.fd = {
    490. 

  490.     name: "full date",
    491. 

  491.     range: 1,
    492. 

  492.     val: function(d) {
    493. 

  493.       return d.fd || (d.fd = d.getTime());
    494. 

  494.     },
    495. 

  495.     isValid: function(d, val) {
    496. 

  496.       return later.fd.val(d) === val;
    497. 

  497.     },
    498. 

  498.     extent: function() {
    499. 

  499.       return [ 0, 3250368e7 ];
    500. 

  500.     },
    501. 

  501.     start: function(d) {
    502. 

  502.       return d;
    503. 

  503.     },
    504. 

  504.     end: function(d) {
    505. 

  505.       return d;
    506. 

  506.     },
    507. 

  507.     next: function(d, val) {
    508. 

  508.       return later.fd.val(d) < val ? new Date(val) : later.NEVER;
    509. 

  509.     },
    510. 

  510.     prev: function(d, val) {
    511. 

  511.       return later.fd.val(d) > val ? new Date(val) : later.NEVER;
    512. 

  512.     }
    513. 

  513.   };
    514. 

  514.   later.modifier = {};
    515. 

  515.   later.modifier.after = later.modifier.a = function(constraint, values) {
    516. 

  516.     var value = values[0];
    517. 

  517.     return {
    518. 

  518.       name: "after " + constraint.name,
    519. 

  519.       range: (constraint.extent(new Date())[1] - value) * constraint.range,
    520. 

  520.       val: constraint.val,
    521. 

  521.       isValid: function(d, val) {
    522. 

  522.         return this.val(d) >= value;
    523. 

  523.       },
    524. 

  524.       extent: constraint.extent,
    525. 

  525.       start: constraint.start,
    526. 

  526.       end: constraint.end,
    527. 

  527.       next: function(startDate, val) {
    528. 

  528.         if (val != value) val = constraint.extent(startDate)[0];
    529. 

  529.         return constraint.next(startDate, val);
    530. 

  530.       },
    531. 

  531.       prev: function(startDate, val) {
    532. 

  532.         val = val === value ? constraint.extent(startDate)[1] : value - 1;
    533. 

  533.         return constraint.prev(startDate, val);
    534. 

  534.       }
    535. 

  535.     };
    536. 

  536.   };
    537. 

  537.   later.modifier.before = later.modifier.b = function(constraint, values) {
    538. 

  538.     var value = values[values.length - 1];
    539. 

  539.     return {
    540. 

  540.       name: "before " + constraint.name,
    541. 

  541.       range: constraint.range * (value - 1),
    542. 

  542.       val: constraint.val,
    543. 

  543.       isValid: function(d, val) {
    544. 

  544.         return this.val(d) < value;
    545. 

  545.       },
    546. 

  546.       extent: constraint.extent,
    547. 

  547.       start: constraint.start,
    548. 

  548.       end: constraint.end,
    549. 

  549.       next: function(startDate, val) {
    550. 

  550.         val = val === value ? constraint.extent(startDate)[0] : value;
    551. 

  551.         return constraint.next(startDate, val);
    552. 

  552.       },
    553. 

  553.       prev: function(startDate, val) {
    554. 

  554.         val = val === value ? value - 1 : constraint.extent(startDate)[1];
    555. 

  555.         return constraint.prev(startDate, val);
    556. 

  556.       }
    557. 

  557.     };
    558. 

  558.   };
    559. 

  559.   later.compile = function(schedDef) {
    560. 

  560.     var constraints = [], constraintsLen = 0, tickConstraint;
    561. 

  561.     for (var key in schedDef) {
    562. 

  562.       var nameParts = key.split("_"), name = nameParts[0], mod = nameParts[1], vals = schedDef[key], constraint = mod ? later.modifier[mod](later[name], vals) : later[name];
    563. 

  563.       constraints.push({
    564. 

  564.         constraint: constraint,
    565. 

  565.         vals: vals
    566. 

  566.       });
    567. 

  567.       constraintsLen++;
    568. 

  568.     }
    569. 

  569.     constraints.sort(function(a, b) {
    570. 

  570.       var ra = a.constraint.range, rb = b.constraint.range;
    571. 

  571.       return rb < ra ? -1 : rb > ra ? 1 : 0;
    572. 

  572.     });
    573. 

  573.     tickConstraint = constraints[constraintsLen - 1].constraint;
    574. 

  574.     function compareFn(dir) {
    575. 

  575.       return dir === "next" ? function(a, b) {
    576. 

  576.         return a.getTime() > b.getTime();
    577. 

  577.       } : function(a, b) {
    578. 

  578.         return b.getTime() > a.getTime();
    579. 

  579.       };
    580. 

  580.     }
    581. 

  581.     return {
    582. 

  582.       start: function(dir, startDate) {
    583. 

  583.         var next = startDate, nextVal = later.array[dir], maxAttempts = 1e3, done;
    584. 

  584.         while (maxAttempts-- && !done && next) {
    585. 

  585.           done = true;
    586. 

  586.           for (var i = 0; i < constraintsLen; i++) {
    587. 

  587.             var constraint = constraints[i].constraint, curVal = constraint.val(next), extent = constraint.extent(next), newVal = nextVal(curVal, constraints[i].vals, extent);
    588. 

  588.             if (!constraint.isValid(next, newVal)) {
    589. 

  589.               next = constraint[dir](next, newVal);
    590. 

  590.               done = false;
    591. 

  591.               break;
    592. 

  592.             }
    593. 

  593.           }
    594. 

  594.         }
    595. 

  595.         if (next !== later.NEVER) {
    596. 

  596.           next = dir === "next" ? tickConstraint.start(next) : tickConstraint.end(next);
    597. 

  597.         }
    598. 

  598.         return next;
    599. 

  599.       },
    600. 

  600.       end: function(dir, startDate) {
    601. 

  601.         var result, nextVal = later.array[dir + "Invalid"], compare = compareFn(dir);
    602. 

  602.         for (var i = constraintsLen - 1; i >= 0; i--) {
    603. 

  603.           var constraint = constraints[i].constraint, curVal = constraint.val(startDate), extent = constraint.extent(startDate), newVal = nextVal(curVal, constraints[i].vals, extent), next;
    604. 

  604.           if (newVal !== undefined) {
    605. 

  605.             next = constraint[dir](startDate, newVal);
    606. 

  606.             if (next && (!result || compare(result, next))) {
    607. 

  607.               result = next;
    608. 

  608.             }
    609. 

  609.           }
    610. 

  610.         }
    611. 

  611.         return result;
    612. 

  612.       },
    613. 

  613.       tick: function(dir, date) {
    614. 

  614.         return new Date(dir === "next" ? tickConstraint.end(date).getTime() + later.SEC : tickConstraint.start(date).getTime() - later.SEC);
    615. 

  615.       },
    616. 

  616.       tickStart: function(date) {
    617. 

  617.         return tickConstraint.start(date);
    618. 

  618.       }
    619. 

  619.     };
    620. 

  620.   };
    621. 

  621.   later.schedule = function(sched) {
    622. 

  622.     if (!sched) throw new Error("Missing schedule definition.");
    623. 

  623.     if (!sched.schedules) throw new Error("Definition must include at least one schedule.");
    624. 

  624.     var schedules = [], schedulesLen = sched.schedules.length, exceptions = [], exceptionsLen = sched.exceptions ? sched.exceptions.length : 0;
    625. 

  625.     for (var i = 0; i < schedulesLen; i++) {
    626. 

  626.       schedules.push(later.compile(sched.schedules[i]));
    627. 

  627.     }
    628. 

  628.     for (var j = 0; j < exceptionsLen; j++) {
    629. 

  629.       exceptions.push(later.compile(sched.exceptions[j]));
    630. 

  630.     }
    631. 

  631.     function getInstances(dir, count, startDate, endDate, isRange) {
    632. 

  632.       var compare = compareFn(dir), loopCount = count, maxAttempts = 1e3, schedStarts = [], exceptStarts = [], next, end, results = [], isForward = dir === "next", lastResult, rStart = isForward ? 0 : 1, rEnd = isForward ? 1 : 0;
    633. 

  633.       startDate = startDate ? new Date(startDate) : new Date();
    634. 

  634.       if (!startDate || !startDate.getTime()) throw new Error("Invalid start date.");
    635. 

  635.       setNextStarts(dir, schedules, schedStarts, startDate);
    636. 

  636.       setRangeStarts(dir, exceptions, exceptStarts, startDate);
    637. 

  637.       while (maxAttempts-- && loopCount && (next = findNext(schedStarts, compare))) {
    638. 

  638.         if (endDate && compare(next, endDate)) {
    639. 

  639.           break;
    640. 

  640.         }
    641. 

  641.         if (exceptionsLen) {
    642. 

  642.           updateRangeStarts(dir, exceptions, exceptStarts, next);
    643. 

  643.           if (end = calcRangeOverlap(dir, exceptStarts, next)) {
    644. 

  644.             updateNextStarts(dir, schedules, schedStarts, end);
    645. 

  645.             continue;
    646. 

  646.           }
    647. 

  647.         }
    648. 

  648.         if (isRange) {
    649. 

  649.           var maxEndDate = calcMaxEndDate(exceptStarts, compare);
    650. 

  650.           end = calcEnd(dir, schedules, schedStarts, next, maxEndDate);
    651. 

  651.           var r = isForward ? [ new Date(Math.max(startDate, next)), end ? new Date(endDate ? Math.min(end, endDate) : end) : undefined ] : [ end ? new Date(endDate ? Math.max(endDate, end.getTime() + later.SEC) : end.getTime() + later.SEC) : undefined, new Date(Math.min(startDate, next.getTime() + later.SEC)) ];
    652. 

  652.           if (lastResult && r[rStart].getTime() === lastResult[rEnd].getTime()) {
    653. 

  653.             lastResult[rEnd] = r[rEnd];
    654. 

  654.             loopCount++;
    655. 

  655.           } else {
    656. 

  656.             lastResult = r;
    657. 

  657.             results.push(lastResult);
    658. 

  658.           }
    659. 

  659.           if (!end) break;
    660. 

  660.           updateNextStarts(dir, schedules, schedStarts, end);
    661. 

  661.         } else {
    662. 

  662.           results.push(isForward ? new Date(Math.max(startDate, next)) : getStart(schedules, schedStarts, next, endDate));
    663. 

  663.           tickStarts(dir, schedules, schedStarts, next);
    664. 

  664.         }
    665. 

  665.         loopCount--;
    666. 

  666.       }
    667. 

  667.       for (var i = 0, len = results.length; i < len; i++) {
    668. 

  668.         var result = results[i];
    669. 

  669.         results[i] = Object.prototype.toString.call(result) === "[object Array]" ? [ cleanDate(result[0]), cleanDate(result[1]) ] : cleanDate(result);
    670. 

  670.       }
    671. 

  671.       return results.length === 0 ? later.NEVER : count === 1 ? results[0] : results;
    672. 

  672.     }
    673. 

  673.     function cleanDate(d) {
    674. 

  674.       if (d instanceof Date && !isNaN(d.valueOf())) {
    675. 

  675.         return new Date(d);
    676. 

  676.       }
    677. 

  677.       return undefined;
    678. 

  678.     }
    679. 

  679.     function setNextStarts(dir, schedArr, startsArr, startDate) {
    680. 

  680.       for (var i = 0, len = schedArr.length; i < len; i++) {
    681. 

  681.         startsArr[i] = schedArr[i].start(dir, startDate);
    682. 

  682.       }
    683. 

  683.     }
    684. 

  684.     function updateNextStarts(dir, schedArr, startsArr, startDate) {
    685. 

  685.       var compare = compareFn(dir);
    686. 

  686.       for (var i = 0, len = schedArr.length; i < len; i++) {
    687. 

  687.         if (startsArr[i] && !compare(startsArr[i], startDate)) {
    688. 

  688.           startsArr[i] = schedArr[i].start(dir, startDate);
    689. 

  689.         }
    690. 

  690.       }
    691. 

  691.     }
    692. 

  692.     function setRangeStarts(dir, schedArr, rangesArr, startDate) {
    693. 

  693.       var compare = compareFn(dir);
    694. 

  694.       for (var i = 0, len = schedArr.length; i < len; i++) {
    695. 

  695.         var nextStart = schedArr[i].start(dir, startDate);
    696. 

  696.         if (!nextStart) {
    697. 

  697.           rangesArr[i] = later.NEVER;
    698. 

  698.         } else {
    699. 

  699.           rangesArr[i] = [ nextStart, schedArr[i].end(dir, nextStart) ];
    700. 

  700.         }
    701. 

  701.       }
    702. 

  702.     }
    703. 

  703.     function updateRangeStarts(dir, schedArr, rangesArr, startDate) {
    704. 

  704.       var compare = compareFn(dir);
    705. 

  705.       for (var i = 0, len = schedArr.length; i < len; i++) {
    706. 

  706.         if (rangesArr[i] && !compare(rangesArr[i][0], startDate)) {
    707. 

  707.           var nextStart = schedArr[i].start(dir, startDate);
    708. 

  708.           if (!nextStart) {
    709. 

  709.             rangesArr[i] = later.NEVER;
    710. 

  710.           } else {
    711. 

  711.             rangesArr[i] = [ nextStart, schedArr[i].end(dir, nextStart) ];
    712. 

  712.           }
    713. 

  713.         }
    714. 

  714.       }
    715. 

  715.     }
    716. 

  716.     function tickStarts(dir, schedArr, startsArr, startDate) {
    717. 

  717.       for (var i = 0, len = schedArr.length; i < len; i++) {
    718. 

  718.         if (startsArr[i] && startsArr[i].getTime() === startDate.getTime()) {
    719. 

  719.           startsArr[i] = schedArr[i].start(dir, schedArr[i].tick(dir, startDate));
    720. 

  720.         }
    721. 

  721.       }
    722. 

  722.     }
    723. 

  723.     function getStart(schedArr, startsArr, startDate, minEndDate) {
    724. 

  724.       var result;
    725. 

  725.       for (var i = 0, len = startsArr.length; i < len; i++) {
    726. 

  726.         if (startsArr[i] && startsArr[i].getTime() === startDate.getTime()) {
    727. 

  727.           var start = schedArr[i].tickStart(startDate);
    728. 

  728.           if (minEndDate && start < minEndDate) {
    729. 

  729.             return minEndDate;
    730. 

  730.           }
    731. 

  731.           if (!result || start > result) {
    732. 

  732.             result = start;
    733. 

  733.           }
    734. 

  734.         }
    735. 

  735.       }
    736. 

  736.       return result;
    737. 

  737.     }
    738. 

  738.     function calcRangeOverlap(dir, rangesArr, startDate) {
    739. 

  739.       var compare = compareFn(dir), result;
    740. 

  740.       for (var i = 0, len = rangesArr.length; i < len; i++) {
    741. 

  741.         var range = rangesArr[i];
    742. 

  742.         if (range && !compare(range[0], startDate) && (!range[1] || compare(range[1], startDate))) {
    743. 

  743.           if (!result || compare(range[1], result)) {
    744. 

  744.             result = range[1];
    745. 

  745.           }
    746. 

  746.         }
    747. 

  747.       }
    748. 

  748.       return result;
    749. 

  749.     }
    750. 

  750.     function calcMaxEndDate(exceptsArr, compare) {
    751. 

  751.       var result;
    752. 

  752.       for (var i = 0, len = exceptsArr.length; i < len; i++) {
    753. 

  753.         if (exceptsArr[i] && (!result || compare(result, exceptsArr[i][0]))) {
    754. 

  754.           result = exceptsArr[i][0];
    755. 

  755.         }
    756. 

  756.       }
    757. 

  757.       return result;
    758. 

  758.     }
    759. 

  759.     function calcEnd(dir, schedArr, startsArr, startDate, maxEndDate) {
    760. 

  760.       var compare = compareFn(dir), result;
    761. 

  761.       for (var i = 0, len = schedArr.length; i < len; i++) {
    762. 

  762.         var start = startsArr[i];
    763. 

  763.         if (start && start.getTime() === startDate.getTime()) {
    764. 

  764.           var end = schedArr[i].end(dir, start);
    765. 

  765.           if (maxEndDate && (!end || compare(end, maxEndDate))) {
    766. 

  766.             return maxEndDate;
    767. 

  767.           }
    768. 

  768.           if (!result || compare(end, result)) {
    769. 

  769.             result = end;
    770. 

  770.           }
    771. 

  771.         }
    772. 

  772.       }
    773. 

  773.       return result;
    774. 

  774.     }
    775. 

  775.     function compareFn(dir) {
    776. 

  776.       return dir === "next" ? function(a, b) {
    777. 

  777.         return !b || a.getTime() > b.getTime();
    778. 

  778.       } : function(a, b) {
    779. 

  779.         return !a || b.getTime() > a.getTime();
    780. 

  780.       };
    781. 

  781.     }
    782. 

  782.     function findNext(arr, compare) {
    783. 

  783.       var next = arr[0];
    784. 

  784.       for (var i = 1, len = arr.length; i < len; i++) {
    785. 

  785.         if (arr[i] && compare(next, arr[i])) {
    786. 

  786.           next = arr[i];
    787. 

  787.         }
    788. 

  788.       }
    789. 

  789.       return next;
    790. 

  790.     }
    791. 

  791.     return {
    792. 

  792.       isValid: function(d) {
    793. 

  793.         return getInstances("next", 1, d, d) !== later.NEVER;
    794. 

  794.       },
    795. 

  795.       next: function(count, startDate, endDate) {
    796. 

  796.         return getInstances("next", count || 1, startDate, endDate);
    797. 

  797.       },
    798. 

  798.       prev: function(count, startDate, endDate) {
    799. 

  799.         return getInstances("prev", count || 1, startDate, endDate);
    800. 

  800.       },
    801. 

  801.       nextRange: function(count, startDate, endDate) {
    802. 

  802.         return getInstances("next", count || 1, startDate, endDate, true);
    803. 

  803.       },
    804. 

  804.       prevRange: function(count, startDate, endDate) {
    805. 

  805.         return getInstances("prev", count || 1, startDate, endDate, true);
    806. 

  806.       }
    807. 

  807.     };
    808. 

  808.   };
    809. 

  809.   later.setTimeout = function(fn, sched) {
    810. 

  810.     var s = later.schedule(sched), t;
    811. 

  811.     if (fn) {
    812. 

  812.       scheduleTimeout();
    813. 

  813.     }
    814. 

  814.     function scheduleTimeout() {
    815. 

  815.       var now = Date.now(), next = s.next(2, now);
    816. 

  816.       if (!next[0]) {
    817. 

  817.         t = undefined;
    818. 

  818.         return;
    819. 

  819.       }
    820. 

  820.       var diff = next[0].getTime() - now;
    821. 

  821.       if (diff < 1e3) {
    822. 

  822.         diff = next[1] ? next[1].getTime() - now : 1e3;
    823. 

  823.       }
    824. 

  824.       if (diff < 2147483647) {
    825. 

  825.         t = setTimeout(fn, diff);
    826. 

  826.       } else {
    827. 

  827.         t = setTimeout(scheduleTimeout, 2147483647);
    828. 

  828.       }
    829. 

  829.     }
    830. 

  830.     return {
    831. 

  831.       isDone: function() {
    832. 

  832.         return !t;
    833. 

  833.       },
    834. 

  834.       clear: function() {
    835. 

  835.         clearTimeout(t);
    836. 

  836.       }
    837. 

  837.     };
    838. 

  838.   };
    839. 

  839.   later.setInterval = function(fn, sched) {
    840. 

  840.     if (!fn) {
    841. 

  841.       return;
    842. 

  842.     }
    843. 

  843.     var t = later.setTimeout(scheduleTimeout, sched), done = t.isDone();
    844. 

  844.     function scheduleTimeout() {
    845. 

  845.       if (!done) {
    846. 

  846.         fn();
    847. 

  847.         t = later.setTimeout(scheduleTimeout, sched);
    848. 

  848.       }
    849. 

  849.     }
    850. 

  850.     return {
    851. 

  851.       isDone: function() {
    852. 

  852.         return t.isDone();
    853. 

  853.       },
    854. 

  854.       clear: function() {
    855. 

  855.         done = true;
    856. 

  856.         t.clear();
    857. 

  857.       }
    858. 

  858.     };
    859. 

  859.   };
    860. 

  860.   later.date = {};
    861. 

  861.   later.date.timezone = function(useLocalTime) {
    862. 

  862.     later.date.build = useLocalTime ? function(Y, M, D, h, m, s) {
    863. 

  863.       return new Date(Y, M, D, h, m, s);
    864. 

  864.     } : function(Y, M, D, h, m, s) {
    865. 

  865.       return new Date(Date.UTC(Y, M, D, h, m, s));
    866. 

  866.     };
    867. 

  867.     var get = useLocalTime ? "get" : "getUTC", d = Date.prototype;
    868. 

  868.     later.date.getYear = d[get + "FullYear"];
    869. 

  869.     later.date.getMonth = d[get + "Month"];
    870. 

  870.     later.date.getDate = d[get + "Date"];
    871. 

  871.     later.date.getDay = d[get + "Day"];
    872. 

  872.     later.date.getHour = d[get + "Hours"];
    873. 

  873.     later.date.getMin = d[get + "Minutes"];
    874. 

  874.     later.date.getSec = d[get + "Seconds"];
    875. 

  875.     later.date.isUTC = !useLocalTime;
    876. 

  876.   };
    877. 

  877.   later.date.UTC = function() {
    878. 

  878.     later.date.timezone(false);
    879. 

  879.   };
    880. 

  880.   later.date.localTime = function() {
    881. 

  881.     later.date.timezone(true);
    882. 

  882.   };
    883. 

  883.   later.date.UTC();
    884. 

  884.   later.SEC = 1e3;
    885. 

  885.   later.MIN = later.SEC * 60;
    886. 

  886.   later.HOUR = later.MIN * 60;
    887. 

  887.   later.DAY = later.HOUR * 24;
    888. 

  888.   later.WEEK = later.DAY * 7;
    889. 

  889.   later.DAYS_IN_MONTH = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ];
    890. 

  890.   later.NEVER = 0;
    891. 

  891.   later.date.next = function(Y, M, D, h, m, s) {
    892. 

  892.     return later.date.build(Y, M !== undefined ? M - 1 : 0, D !== undefined ? D : 1, h || 0, m || 0, s || 0);
    893. 

  893.   };
    894. 

  894.   later.date.nextRollover = function(d, val, constraint, period) {
    895. 

  895.     var cur = constraint.val(d), max = constraint.extent(d)[1];
    896. 

  896.     return (val || max) <= cur || val > max ? new Date(period.end(d).getTime() + later.SEC) : period.start(d);
    897. 

  897.   };
    898. 

  898.   later.date.prev = function(Y, M, D, h, m, s) {
    899. 

  899.     var len = arguments.length;
    900. 

  900.     M = len < 2 ? 11 : M - 1;
    901. 

  901.     D = len < 3 ? later.D.extent(later.date.next(Y, M + 1))[1] : D;
    902. 

  902.     h = len < 4 ? 23 : h;
    903. 

  903.     m = len < 5 ? 59 : m;
    904. 

  904.     s = len < 6 ? 59 : s;
    905. 

  905.     return later.date.build(Y, M, D, h, m, s);
    906. 

  906.   };
    907. 

  907.   later.date.prevRollover = function(d, val, constraint, period) {
    908. 

  908.     var cur = constraint.val(d);
    909. 

  909.     return val >= cur || !val ? period.start(period.prev(d, period.val(d) - 1)) : period.start(d);
    910. 

  910.   };
    911. 

  911.   later.parse = {};
    912. 

  912.   later.parse.cron = function(expr, hasSeconds) {
    913. 

  913.     var NAMES = {
    914. 

  914.       JAN: 1,
    915. 

  915.       FEB: 2,
    916. 

  916.       MAR: 3,
    917. 

  917.       APR: 4,
    918. 

  918.       MAY: 5,
    919. 

  919.       JUN: 6,
    920. 

  920.       JUL: 7,
    921. 

  921.       AUG: 8,
    922. 

  922.       SEP: 9,
    923. 

  923.       OCT: 10,
    924. 

  924.       NOV: 11,
    925. 

  925.       DEC: 12,
    926. 

  926.       SUN: 1,
    927. 

  927.       MON: 2,
    928. 

  928.       TUE: 3,
    929. 

  929.       WED: 4,
    930. 

  930.       THU: 5,
    931. 

  931.       FRI: 6,
    932. 

  932.       SAT: 7
    933. 

  933.     };
    934. 

  934.     var REPLACEMENTS = {
    935. 

  935.       "* * * * * *": "0/1 * * * * *",
    936. 

  936.       "@YEARLY": "0 0 1 1 *",
    937. 

  937.       "@ANNUALLY": "0 0 1 1 *",
    938. 

  938.       "@MONTHLY": "0 0 1 * *",
    939. 

  939.       "@WEEKLY": "0 0 * * 0",
    940. 

  940.       "@DAILY": "0 0 * * *",
    941. 

  941.       "@HOURLY": "0 * * * *"
    942. 

  942.     };
    943. 

  943.     var FIELDS = {
    944. 

  944.       s: [ 0, 0, 59 ],
    945. 

  945.       m: [ 1, 0, 59 ],
    946. 

  946.       h: [ 2, 0, 23 ],
    947. 

  947.       D: [ 3, 1, 31 ],
    948. 

  948.       M: [ 4, 1, 12 ],
    949. 

  949.       Y: [ 6, 1970, 2099 ],
    950. 

  950.       d: [ 5, 1, 7, 1 ]
    951. 

  951.     };
    952. 

  952.     function getValue(value, offset, max) {
    953. 

  953.       return isNaN(value) ? NAMES[value] || null : Math.min(+value + (offset || 0), max || 9999);
    954. 

  954.     }
    955. 

  955.     function cloneSchedule(sched) {
    956. 

  956.       var clone = {}, field;
    957. 

  957.       for (field in sched) {
    958. 

  958.         if (field !== "dc" && field !== "d") {
    959. 

  959.           clone[field] = sched[field].slice(0);
    960. 

  960.         }
    961. 

  961.       }
    962. 

  962.       return clone;
    963. 

  963.     }
    964. 

  964.     function add(sched, name, min, max, inc) {
    965. 

  965.       var i = min;
    966. 

  966.       if (!sched[name]) {
    967. 

  967.         sched[name] = [];
    968. 

  968.       }
    969. 

  969.       while (i <= max) {
    970. 

  970.         if (sched[name].indexOf(i) < 0) {
    971. 

  971.           sched[name].push(i);
    972. 

  972.         }
    973. 

  973.         i += inc || 1;
    974. 

  974.       }
    975. 

  975.       sched[name].sort(function(a, b) {
    976. 

  976.         return a - b;
    977. 

  977.       });
    978. 

  978.     }
    979. 

  979.     function addHash(schedules, curSched, value, hash) {
    980. 

  980.       if (curSched.d && !curSched.dc || curSched.dc && curSched.dc.indexOf(hash) < 0) {
    981. 

  981.         schedules.push(cloneSchedule(curSched));
    982. 

  982.         curSched = schedules[schedules.length - 1];
    983. 

  983.       }
    984. 

  984.       add(curSched, "d", value, value);
    985. 

  985.       add(curSched, "dc", hash, hash);
    986. 

  986.     }
    987. 

  987.     function addWeekday(s, curSched, value) {
    988. 

  988.       var except1 = {}, except2 = {};
    989. 

  989.       if (value === 1) {
    990. 

  990.         add(curSched, "D", 1, 3);
    991. 

  991.         add(curSched, "d", NAMES.MON, NAMES.FRI);
    992. 

  992.         add(except1, "D", 2, 2);
    993. 

  993.         add(except1, "d", NAMES.TUE, NAMES.FRI);
    994. 

  994.         add(except2, "D", 3, 3);
    995. 

  995.         add(except2, "d", NAMES.TUE, NAMES.FRI);
    996. 

  996.       } else {
    997. 

  997.         add(curSched, "D", value - 1, value + 1);
    998. 

  998.         add(curSched, "d", NAMES.MON, NAMES.FRI);
    999. 

  999.         add(except1, "D", value - 1, value - 1);
    1000. 

  1000.         add(except1, "d", NAMES.MON, NAMES.THU);
    1001. 

  1001.         add(except2, "D", value + 1, value + 1);
    1002. 

  1002.         add(except2, "d", NAMES.TUE, NAMES.FRI);
    1003. 

  1003.       }
    1004. 

  1004.       s.exceptions.push(except1);
    1005. 

  1005.       s.exceptions.push(except2);
    1006. 

  1006.     }
    1007. 

  1007.     function addRange(item, curSched, name, min, max, offset) {
    1008. 

  1008.       var incSplit = item.split("/"), inc = +incSplit[1], range = incSplit[0];
    1009. 

  1009.       if (range !== "*" && range !== "0") {
    1010. 

  1010.         var rangeSplit = range.split("-");
    1011. 

  1011.         min = getValue(rangeSplit[0], offset, max);
    1012. 

  1012.         max = getValue(rangeSplit[1], offset, max) || max;
    1013. 

  1013.       }
    1014. 

  1014.       add(curSched, name, min, max, inc);
    1015. 

  1015.     }
    1016. 

  1016.     function parse(item, s, name, min, max, offset) {
    1017. 

  1017.       var value, split, schedules = s.schedules, curSched = schedules[schedules.length - 1];
    1018. 

  1018.       if (item === "L") {
    1019. 

  1019.         item = min - 1;
    1020. 

  1020.       }
    1021. 

  1021.       if ((value = getValue(item, offset, max)) !== null) {
    1022. 

  1022.         add(curSched, name, value, value);
    1023. 

  1023.       } else if ((value = getValue(item.replace("W", ""), offset, max)) !== null) {
    1024. 

  1024.         addWeekday(s, curSched, value);
    1025. 

  1025.       } else if ((value = getValue(item.replace("L", ""), offset, max)) !== null) {
    1026. 

  1026.         addHash(schedules, curSched, value, min - 1);
    1027. 

  1027.       } else if ((split = item.split("#")).length === 2) {
    1028. 

  1028.         value = getValue(split[0], offset, max);
    1029. 

  1029.         addHash(schedules, curSched, value, getValue(split[1]));
    1030. 

  1030.       } else {
    1031. 

  1031.         addRange(item, curSched, name, min, max, offset);
    1032. 

  1032.       }
    1033. 

  1033.     }
    1034. 

  1034.     function isHash(item) {
    1035. 

  1035.       return item.indexOf("#") > -1 || item.indexOf("L") > 0;
    1036. 

  1036.     }
    1037. 

  1037.     function itemSorter(a, b) {
    1038. 

  1038.       return isHash(a) && !isHash(b) ? 1 : a - b;
    1039. 

  1039.     }
    1040. 

  1040.     function parseExpr(expr) {
    1041. 

  1041.       var schedule = {
    1042. 

  1042.         schedules: [ {} ],
    1043. 

  1043.         exceptions: []
    1044. 

  1044.       }, components = expr.replace(/(\s)+/g, " ").split(" "), field, f, component, items;
    1045. 

  1045.       for (field in FIELDS) {
    1046. 

  1046.         f = FIELDS[field];
    1047. 

  1047.         component = components[f[0]];
    1048. 

  1048.         if (component && component !== "*" && component !== "?") {
    1049. 

  1049.           items = component.split(",").sort(itemSorter);
    1050. 

  1050.           var i, length = items.length;
    1051. 

  1051.           for (i = 0; i < length; i++) {
    1052. 

  1052.             parse(items[i], schedule, field, f[1], f[2], f[3]);
    1053. 

  1053.           }
    1054. 

  1054.         }
    1055. 

  1055.       }
    1056. 

  1056.       return schedule;
    1057. 

  1057.     }
    1058. 

  1058.     function prepareExpr(expr) {
    1059. 

  1059.       var prepared = expr.toUpperCase();
    1060. 

  1060.       return REPLACEMENTS[prepared] || prepared;
    1061. 

  1061.     }
    1062. 

  1062.     var e = prepareExpr(expr);
    1063. 

  1063.     return parseExpr(hasSeconds ? e : "0 " + e);
    1064. 

  1064.   };
    1065. 

  1065.   later.parse.recur = function() {
    1066. 

  1066.     var schedules = [], exceptions = [], cur, curArr = schedules, curName, values, every, modifier, applyMin, applyMax, i, last;
    1067. 

  1067.     function add(name, min, max) {
    1068. 

  1068.       name = modifier ? name + "_" + modifier : name;
    1069. 

  1069.       if (!cur) {
    1070. 

  1070.         curArr.push({});
    1071. 

  1071.         cur = curArr[0];
    1072. 

  1072.       }
    1073. 

  1073.       if (!cur[name]) {
    1074. 

  1074.         cur[name] = [];
    1075. 

  1075.       }
    1076. 

  1076.       curName = cur[name];
    1077. 

  1077.       if (every) {
    1078. 

  1078.         values = [];
    1079. 

  1079.         for (i = min; i <= max; i += every) {
    1080. 

  1080.           values.push(i);
    1081. 

  1081.         }
    1082. 

  1082.         last = {
    1083. 

  1083.           n: name,
    1084. 

  1084.           x: every,
    1085. 

  1085.           c: curName.length,
    1086. 

  1086.           m: max
    1087. 

  1087.         };
    1088. 

  1088.       }
    1089. 

  1089.       values = applyMin ? [ min ] : applyMax ? [ max ] : values;
    1090. 

  1090.       var length = values.length;
    1091. 

  1091.       for (i = 0; i < length; i += 1) {
    1092. 

  1092.         var val = values[i];
    1093. 

  1093.         if (curName.indexOf(val) < 0) {
    1094. 

  1094.           curName.push(val);
    1095. 

  1095.         }
    1096. 

  1096.       }
    1097. 

  1097.       values = every = modifier = applyMin = applyMax = 0;
    1098. 

  1098.     }
    1099. 

  1099.     return {
    1100. 

  1100.       schedules: schedules,
    1101. 

  1101.       exceptions: exceptions,
    1102. 

  1102.       on: function() {
    1103. 

  1103.         values = arguments[0] instanceof Array ? arguments[0] : arguments;
    1104. 

  1104.         return this;
    1105. 

  1105.       },
    1106. 

  1106.       every: function(x) {
    1107. 

  1107.         every = x || 1;
    1108. 

  1108.         return this;
    1109. 

  1109.       },
    1110. 

  1110.       after: function(x) {
    1111. 

  1111.         modifier = "a";
    1112. 

  1112.         values = [ x ];
    1113. 

  1113.         return this;
    1114. 

  1114.       },
    1115. 

  1115.       before: function(x) {
    1116. 

  1116.         modifier = "b";
    1117. 

  1117.         values = [ x ];
    1118. 

  1118.         return this;
    1119. 

  1119.       },
    1120. 

  1120.       first: function() {
    1121. 

  1121.         applyMin = 1;
    1122. 

  1122.         return this;
    1123. 

  1123.       },
    1124. 

  1124.       last: function() {
    1125. 

  1125.         applyMax = 1;
    1126. 

  1126.         return this;
    1127. 

  1127.       },
    1128. 

  1128.       time: function() {
    1129. 

  1129.         for (var i = 0, len = values.length; i < len; i++) {
    1130. 

  1130.           var split = values[i].split(":");
    1131. 

  1131.           if (split.length < 3) split.push(0);
    1132. 

  1132.           values[i] = +split[0] * 3600 + +split[1] * 60 + +split[2];
    1133. 

  1133.         }
    1134. 

  1134.         add("t");
    1135. 

  1135.         return this;
    1136. 

  1136.       },
    1137. 

  1137.       second: function() {
    1138. 

  1138.         add("s", 0, 59);
    1139. 

  1139.         return this;
    1140. 

  1140.       },
    1141. 

  1141.       minute: function() {
    1142. 

  1142.         add("m", 0, 59);
    1143. 

  1143.         return this;
    1144. 

  1144.       },
    1145. 

  1145.       hour: function() {
    1146. 

  1146.         add("h", 0, 23);
    1147. 

  1147.         return this;
    1148. 

  1148.       },
    1149. 

  1149.       dayOfMonth: function() {
    1150. 

  1150.         add("D", 1, applyMax ? 0 : 31);
    1151. 

  1151.         return this;
    1152. 

  1152.       },
    1153. 

  1153.       dayOfWeek: function() {
    1154. 

  1154.         add("d", 1, 7);
    1155. 

  1155.         return this;
    1156. 

  1156.       },
    1157. 

  1157.       onWeekend: function() {
    1158. 

  1158.         values = [ 1, 7 ];
    1159. 

  1159.         return this.dayOfWeek();
    1160. 

  1160.       },
    1161. 

  1161.       onWeekday: function() {
    1162. 

  1162.         values = [ 2, 3, 4, 5, 6 ];
    1163. 

  1163.         return this.dayOfWeek();
    1164. 

  1164.       },
    1165. 

  1165.       dayOfWeekCount: function() {
    1166. 

  1166.         add("dc", 1, applyMax ? 0 : 5);
    1167. 

  1167.         return this;
    1168. 

  1168.       },
    1169. 

  1169.       dayOfYear: function() {
    1170. 

  1170.         add("dy", 1, applyMax ? 0 : 366);
    1171. 

  1171.         return this;
    1172. 

  1172.       },
    1173. 

  1173.       weekOfMonth: function() {
    1174. 

  1174.         add("wm", 1, applyMax ? 0 : 5);
    1175. 

  1175.         return this;
    1176. 

  1176.       },
    1177. 

  1177.       weekOfYear: function() {
    1178. 

  1178.         add("wy", 1, applyMax ? 0 : 53);
    1179. 

  1179.         return this;
    1180. 

  1180.       },
    1181. 

  1181.       month: function() {
    1182. 

  1182.         add("M", 1, 12);
    1183. 

  1183.         return this;
    1184. 

  1184.       },
    1185. 

  1185.       year: function() {
    1186. 

  1186.         add("Y", 1970, 2450);
    1187. 

  1187.         return this;
    1188. 

  1188.       },
    1189. 

  1189.       fullDate: function() {
    1190. 

  1190.         for (var i = 0, len = values.length; i < len; i++) {
    1191. 

  1191.           values[i] = values[i].getTime();
    1192. 

  1192.         }
    1193. 

  1193.         add("fd");
    1194. 

  1194.         return this;
    1195. 

  1195.       },
    1196. 

  1196.       customModifier: function(id, vals) {
    1197. 

  1197.         var custom = later.modifier[id];
    1198. 

  1198.         if (!custom) throw new Error("Custom modifier " + id + " not recognized!");
    1199. 

  1199.         modifier = id;
    1200. 

  1200.         values = arguments[1] instanceof Array ? arguments[1] : [ arguments[1] ];
    1201. 

  1201.         return this;
    1202. 

  1202.       },
    1203. 

  1203.       customPeriod: function(id) {
    1204. 

  1204.         var custom = later[id];
    1205. 

  1205.         if (!custom) throw new Error("Custom time period " + id + " not recognized!");
    1206. 

  1206.         add(id, custom.extent(new Date())[0], custom.extent(new Date())[1]);
    1207. 

  1207.         return this;
    1208. 

  1208.       },
    1209. 

  1209.       startingOn: function(start) {
    1210. 

  1210.         return this.between(start, last.m);
    1211. 

  1211.       },
    1212. 

  1212.       between: function(start, end) {
    1213. 

  1213.         cur[last.n] = cur[last.n].splice(0, last.c);
    1214. 

  1214.         every = last.x;
    1215. 

  1215.         add(last.n, start, end);
    1216. 

  1216.         return this;
    1217. 

  1217.       },
    1218. 

  1218.       and: function() {
    1219. 

  1219.         cur = curArr[curArr.push({}) - 1];
    1220. 

  1220.         return this;
    1221. 

  1221.       },
    1222. 

  1222.       except: function() {
    1223. 

  1223.         curArr = exceptions;
    1224. 

  1224.         cur = null;
    1225. 

  1225.         return this;
    1226. 

  1226.       }
    1227. 

  1227.     };
    1228. 

  1228.   };
    1229. 

  1229.   later.parse.text = function(str) {
    1230. 

  1230.     var recur = later.parse.recur, pos = 0, input = "", error;
    1231. 

  1231.     var TOKENTYPES = {
    1232. 

  1232.       eof: /^$/,
    1233. 

  1233.       rank: /^((\d\d\d\d)|([2-5]?1(st)?|[2-5]?2(nd)?|[2-5]?3(rd)?|(0|[1-5]?[4-9]|[1-5]0|1[1-3])(th)?))\b/,
    1234. 

  1234.       time: /^((([0]?[1-9]|1[0-2]):[0-5]\d(\s)?(am|pm))|(([0]?\d|1\d|2[0-3]):[0-5]\d))\b/,
    1235. 

  1235.       dayName: /^((sun|mon|tue(s)?|wed(nes)?|thu(r(s)?)?|fri|sat(ur)?)(day)?)\b/,
    1236. 

  1236.       monthName: /^(jan(uary)?|feb(ruary)?|ma((r(ch)?)?|y)|apr(il)?|ju(ly|ne)|aug(ust)?|oct(ober)?|(sept|nov|dec)(ember)?)\b/,
    1237. 

  1237.       yearIndex: /^(\d\d\d\d)\b/,
    1238. 

  1238.       every: /^every\b/,
    1239. 

  1239.       after: /^after\b/,
    1240. 

  1240.       before: /^before\b/,
    1241. 

  1241.       second: /^(s|sec(ond)?(s)?)\b/,
    1242. 

  1242.       minute: /^(m|min(ute)?(s)?)\b/,
    1243. 

  1243.       hour: /^(h|hour(s)?)\b/,
    1244. 

  1244.       day: /^(day(s)?( of the month)?)\b/,
    1245. 

  1245.       dayInstance: /^day instance\b/,
    1246. 

  1246.       dayOfWeek: /^day(s)? of the week\b/,
    1247. 

  1247.       dayOfYear: /^day(s)? of the year\b/,
    1248. 

  1248.       weekOfYear: /^week(s)?( of the year)?\b/,
    1249. 

  1249.       weekOfMonth: /^week(s)? of the month\b/,
    1250. 

  1250.       weekday: /^weekday\b/,
    1251. 

  1251.       weekend: /^weekend\b/,
    1252. 

  1252.       month: /^month(s)?\b/,
    1253. 

  1253.       year: /^year(s)?\b/,
    1254. 

  1254.       between: /^between (the)?\b/,
    1255. 

  1255.       start: /^(start(ing)? (at|on( the)?)?)\b/,
    1256. 

  1256.       at: /^(at|@)\b/,
    1257. 

  1257.       and: /^(,|and\b)/,
    1258. 

  1258.       except: /^(except\b)/,
    1259. 

  1259.       also: /(also)\b/,
    1260. 

  1260.       first: /^(first)\b/,
    1261. 

  1261.       last: /^last\b/,
    1262. 

  1262.       "in": /^in\b/,
    1263. 

  1263.       of: /^of\b/,
    1264. 

  1264.       onthe: /^on the\b/,
    1265. 

  1265.       on: /^on\b/,
    1266. 

  1266.       through: /(-|^(to|through)\b)/
    1267. 

  1267.     };
    1268. 

  1268.     var NAMES = {
    1269. 

  1269.       jan: 1,
    1270. 

  1270.       feb: 2,
    1271. 

  1271.       mar: 3,
    1272. 

  1272.       apr: 4,
    1273. 

  1273.       may: 5,
    1274. 

  1274.       jun: 6,
    1275. 

  1275.       jul: 7,
    1276. 

  1276.       aug: 8,
    1277. 

  1277.       sep: 9,
    1278. 

  1278.       oct: 10,
    1279. 

  1279.       nov: 11,
    1280. 

  1280.       dec: 12,
    1281. 

  1281.       sun: 1,
    1282. 

  1282.       mon: 2,
    1283. 

  1283.       tue: 3,
    1284. 

  1284.       wed: 4,
    1285. 

  1285.       thu: 5,
    1286. 

  1286.       fri: 6,
    1287. 

  1287.       sat: 7,
    1288. 

  1288.       "1st": 1,
    1289. 

  1289.       fir: 1,
    1290. 

  1290.       "2nd": 2,
    1291. 

  1291.       sec: 2,
    1292. 

  1292.       "3rd": 3,
    1293. 

  1293.       thi: 3,
    1294. 

  1294.       "4th": 4,
    1295. 

  1295.       "for": 4
    1296. 

  1296.     };
    1297. 

  1297.     function t(start, end, text, type) {
    1298. 

  1298.       return {
    1299. 

  1299.         startPos: start,
    1300. 

  1300.         endPos: end,
    1301. 

  1301.         text: text,
    1302. 

  1302.         type: type
    1303. 

  1303.       };
    1304. 

  1304.     }
    1305. 

  1305.     function peek(expected) {
    1306. 

  1306.       var scanTokens = expected instanceof Array ? expected : [ expected ], whiteSpace = /\s+/, token, curInput, m, scanToken, start, len;
    1307. 

  1307.       scanTokens.push(whiteSpace);
    1308. 

  1308.       start = pos;
    1309. 

  1309.       while (!token || token.type === whiteSpace) {
    1310. 

  1310.         len = -1;
    1311. 

  1311.         curInput = input.substring(start);
    1312. 

  1312.         token = t(start, start, input.split(whiteSpace)[0]);
    1313. 

  1313.         var i, length = scanTokens.length;
    1314. 

  1314.         for (i = 0; i < length; i++) {
    1315. 

  1315.           scanToken = scanTokens[i];
    1316. 

  1316.           m = scanToken.exec(curInput);
    1317. 

  1317.           if (m && m.index === 0 && m[0].length > len) {
    1318. 

  1318.             len = m[0].length;
    1319. 

  1319.             token = t(start, start + len, curInput.substring(0, len), scanToken);
    1320. 

  1320.           }
    1321. 

  1321.         }
    1322. 

  1322.         if (token.type === whiteSpace) {
    1323. 

  1323.           start = token.endPos;
    1324. 

  1324.         }
    1325. 

  1325.       }
    1326. 

  1326.       return token;
    1327. 

  1327.     }
    1328. 

  1328.     function scan(expectedToken) {
    1329. 

  1329.       var token = peek(expectedToken);
    1330. 

  1330.       pos = token.endPos;
    1331. 

  1331.       return token;
    1332. 

  1332.     }
    1333. 

  1333.     function parseThroughExpr(tokenType) {
    1334. 

  1334.       var start = +parseTokenValue(tokenType), end = checkAndParse(TOKENTYPES.through) ? +parseTokenValue(tokenType) : start, nums = [];
    1335. 

  1335.       for (var i = start; i <= end; i++) {
    1336. 

  1336.         nums.push(i);
    1337. 

  1337.       }
    1338. 

  1338.       return nums;
    1339. 

  1339.     }
    1340. 

  1340.     function parseRanges(tokenType) {
    1341. 

  1341.       var nums = parseThroughExpr(tokenType);
    1342. 

  1342.       while (checkAndParse(TOKENTYPES.and)) {
    1343. 

  1343.         nums = nums.concat(parseThroughExpr(tokenType));
    1344. 

  1344.       }
    1345. 

  1345.       return nums;
    1346. 

  1346.     }
    1347. 

  1347.     function parseEvery(r) {
    1348. 

  1348.       var num, period, start, end;
    1349. 

  1349.       if (checkAndParse(TOKENTYPES.weekend)) {
    1350. 

  1350.         r.on(NAMES.sun, NAMES.sat).dayOfWeek();
    1351. 

  1351.       } else if (checkAndParse(TOKENTYPES.weekday)) {
    1352. 

  1352.         r.on(NAMES.mon, NAMES.tue, NAMES.wed, NAMES.thu, NAMES.fri).dayOfWeek();
    1353. 

  1353.       } else {
    1354. 

  1354.         num = parseTokenValue(TOKENTYPES.rank);
    1355. 

  1355.         r.every(num);
    1356. 

  1356.         period = parseTimePeriod(r);
    1357. 

  1357.         if (checkAndParse(TOKENTYPES.start)) {
    1358. 

  1358.           num = parseTokenValue(TOKENTYPES.rank);
    1359. 

  1359.           r.startingOn(num);
    1360. 

  1360.           parseToken(period.type);
    1361. 

  1361.         } else if (checkAndParse(TOKENTYPES.between)) {
    1362. 

  1362.           start = parseTokenValue(TOKENTYPES.rank);
    1363. 

  1363.           if (checkAndParse(TOKENTYPES.and)) {
    1364. 

  1364.             end = parseTokenValue(TOKENTYPES.rank);
    1365. 

  1365.             r.between(start, end);
    1366. 

  1366.           }
    1367. 

  1367.         }
    1368. 

  1368.       }
    1369. 

  1369.     }
    1370. 

  1370.     function parseOnThe(r) {
    1371. 

  1371.       if (checkAndParse(TOKENTYPES.first)) {
    1372. 

  1372.         r.first();
    1373. 

  1373.       } else if (checkAndParse(TOKENTYPES.last)) {
    1374. 

  1374.         r.last();
    1375. 

  1375.       } else {
    1376. 

  1376.         r.on(parseRanges(TOKENTYPES.rank));
    1377. 

  1377.       }
    1378. 

  1378.       parseTimePeriod(r);
    1379. 

  1379.     }
    1380. 

  1380.     function parseScheduleExpr(str) {
    1381. 

  1381.       pos = 0;
    1382. 

  1382.       input = str;
    1383. 

  1383.       error = -1;
    1384. 

  1384.       var r = recur();
    1385. 

  1385.       while (pos < input.length && error < 0) {
    1386. 

  1386.         var token = parseToken([ TOKENTYPES.every, TOKENTYPES.after, TOKENTYPES.before, TOKENTYPES.onthe, TOKENTYPES.on, TOKENTYPES.of, TOKENTYPES["in"], TOKENTYPES.at, TOKENTYPES.and, TOKENTYPES.except, TOKENTYPES.also ]);
    1387. 

  1387.         switch (token.type) {
    1388. 

  1388.          case TOKENTYPES.every:
    1389. 

  1389.           parseEvery(r);
    1390. 

  1390.           break;
    1391. 

  1391. 

  1392.          case TOKENTYPES.after:
    1393. 

  1393.           if (peek(TOKENTYPES.time).type !== undefined) {
    1394. 

  1394.             r.after(parseTokenValue(TOKENTYPES.time));
    1395. 

  1395.             r.time();
    1396. 

  1396.           } else {
    1397. 

  1397.             r.after(parseTokenValue(TOKENTYPES.rank));
    1398. 

  1398.             parseTimePeriod(r);
    1399. 

  1399.           }
    1400. 

  1400.           break;
    1401. 

  1401. 

  1402.          case TOKENTYPES.before:
    1403. 

  1403.           if (peek(TOKENTYPES.time).type !== undefined) {
    1404. 

  1404.             r.before(parseTokenValue(TOKENTYPES.time));
    1405. 

  1405.             r.time();
    1406. 

  1406.           } else {
    1407. 

  1407.             r.before(parseTokenValue(TOKENTYPES.rank));
    1408. 

  1408.             parseTimePeriod(r);
    1409. 

  1409.           }
    1410. 

  1410.           break;
    1411. 

  1411. 

  1412.          case TOKENTYPES.onthe:
    1413. 

  1413.           parseOnThe(r);
    1414. 

  1414.           break;
    1415. 

  1415. 

  1416.          case TOKENTYPES.on:
    1417. 

  1417.           r.on(parseRanges(TOKENTYPES.dayName)).dayOfWeek();
    1418. 

  1418.           break;
    1419. 

  1419. 

  1420.          case TOKENTYPES.of:
    1421. 

  1421.           r.on(parseRanges(TOKENTYPES.monthName)).month();
    1422. 

  1422.           break;
    1423. 

  1423. 

  1424.          case TOKENTYPES["in"]:
    1425. 

  1425.           r.on(parseRanges(TOKENTYPES.yearIndex)).year();
    1426. 

  1426.           break;
    1427. 

  1427. 

  1428.          case TOKENTYPES.at:
    1429. 

  1429.           r.on(parseTokenValue(TOKENTYPES.time)).time();
    1430. 

  1430.           while (checkAndParse(TOKENTYPES.and)) {
    1431. 

  1431.             r.on(parseTokenValue(TOKENTYPES.time)).time();
    1432. 

  1432.           }
    1433. 

  1433.           break;
    1434. 

  1434. 

  1435.          case TOKENTYPES.and:
    1436. 

  1436.           break;
    1437. 

  1437. 

  1438.          case TOKENTYPES.also:
    1439. 

  1439.           r.and();
    1440. 

  1440.           break;
    1441. 

  1441. 

  1442.          case TOKENTYPES.except:
    1443. 

  1443.           r.except();
    1444. 

  1444.           break;
    1445. 

  1445. 

  1446.          default:
    1447. 

  1447.           error = pos;
    1448. 

  1448.         }
    1449. 

  1449.       }
    1450. 

  1450.       return {
    1451. 

  1451.         schedules: r.schedules,
    1452. 

  1452.         exceptions: r.exceptions,
    1453. 

  1453.         error: error
    1454. 

  1454.       };
    1455. 

  1455.     }
    1456. 

  1456.     function parseTimePeriod(r) {
    1457. 

  1457.       var timePeriod = parseToken([ TOKENTYPES.second, TOKENTYPES.minute, TOKENTYPES.hour, TOKENTYPES.dayOfYear, TOKENTYPES.dayOfWeek, TOKENTYPES.dayInstance, TOKENTYPES.day, TOKENTYPES.month, TOKENTYPES.year, TOKENTYPES.weekOfMonth, TOKENTYPES.weekOfYear ]);
    1458. 

  1458.       switch (timePeriod.type) {
    1459. 

  1459.        case TOKENTYPES.second:
    1460. 

  1460.         r.second();
    1461. 

  1461.         break;
    1462. 

  1462. 

  1463.        case TOKENTYPES.minute:
    1464. 

  1464.         r.minute();
    1465. 

  1465.         break;
    1466. 

  1466. 

  1467.        case TOKENTYPES.hour:
    1468. 

  1468.         r.hour();
    1469. 

  1469.         break;
    1470. 

  1470. 

  1471.        case TOKENTYPES.dayOfYear:
    1472. 

  1472.         r.dayOfYear();
    1473. 

  1473.         break;
    1474. 

  1474. 

  1475.        case TOKENTYPES.dayOfWeek:
    1476. 

  1476.         r.dayOfWeek();
    1477. 

  1477.         break;
    1478. 

  1478. 

  1479.        case TOKENTYPES.dayInstance:
    1480. 

  1480.         r.dayOfWeekCo
    1481.