rome-rails 2.1.22

data/vendor/assets/javascripts/rome.standalone.js

@@ -0,0 +1,2658 @@
+/**
+ * rome - Customizable date (and time) picker. Opt-in UI, no jQuery!
+ * @version v2.1.22
+ * @link https://github.com/bevacqua/rome
+ * @license MIT
+ */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.rome = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+'use strict';
+
+var crossvent = require('crossvent');
+var throttle = require('./throttle');
+var tailormade = require('./tailormade');
+
+function bullseye (el, target, options) {
+  var o = options;
+  var domTarget = target && target.tagName;
+
+  if (!domTarget && arguments.length === 2) {
+    o = target;
+  }
+  if (!domTarget) {
+    target = el;
+  }
+  if (!o) { o = {}; }
+
+  var destroyed = false;
+  var throttledWrite = throttle(write, 30);
+  var tailorOptions = { update: o.autoupdateToCaret !== false && update };
+  var tailor = o.caret && tailormade(target, tailorOptions);
+
+  write();
+
+  if (o.tracking !== false) {
+    crossvent.add(window, 'resize', throttledWrite);
+  }
+
+  return {
+    read: readNull,
+    refresh: write,
+    destroy: destroy,
+    sleep: sleep
+  };
+
+  function sleep () {
+    tailorOptions.sleeping = true;
+  }
+
+  function readNull () { return read(); }
+
+  function read (readings) {
+    var bounds = target.getBoundingClientRect();
+    var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
+    if (tailor) {
+      readings = tailor.read();
+      return {
+        x: (readings.absolute ? 0 : bounds.left) + readings.x,
+        y: (readings.absolute ? 0 : bounds.top) + scrollTop + readings.y + 20
+      };
+    }
+    return {
+      x: bounds.left,
+      y: bounds.top + scrollTop
+    };
+  }
+
+  function update (readings) {
+    write(readings);
+  }
+
+  function write (readings) {
+    if (destroyed) {
+      throw new Error('Bullseye can\'t refresh after being destroyed. Create another instance instead.');
+    }
+    if (tailor && !readings) {
+      tailorOptions.sleeping = false;
+      tailor.refresh(); return;
+    }
+    var p = read(readings);
+    if (!tailor && target !== el) {
+      p.y += target.offsetHeight;
+    }
+    el.style.left = p.x + 'px';
+    el.style.top = p.y + 'px';
+  }
+
+  function destroy () {
+    if (tailor) { tailor.destroy(); }
+    crossvent.remove(window, 'resize', throttledWrite);
+    destroyed = true;
+  }
+}
+
+module.exports = bullseye;
+
+},{"./tailormade":11,"./throttle":12,"crossvent":18}],2:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var getSelection;
+var doc = global.document;
+var getSelectionRaw = require('./getSelectionRaw');
+var getSelectionNullOp = require('./getSelectionNullOp');
+var getSelectionSynthetic = require('./getSelectionSynthetic');
+var isHost = require('./isHost');
+if (isHost.method(global, 'getSelection')) {
+  getSelection = getSelectionRaw;
+} else if (typeof doc.selection === 'object' && doc.selection) {
+  getSelection = getSelectionSynthetic;
+} else {
+  getSelection = getSelectionNullOp;
+}
+
+module.exports = getSelection;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./getSelectionNullOp":3,"./getSelectionRaw":4,"./getSelectionSynthetic":5,"./isHost":6}],3:[function(require,module,exports){
+'use strict';
+
+function noop () {}
+
+function getSelectionNullOp () {
+  return {
+    removeAllRanges: noop,
+    addRange: noop
+  };
+}
+
+module.exports = getSelectionNullOp;
+
+},{}],4:[function(require,module,exports){
+(function (global){
+'use strict';
+
+function getSelectionRaw () {
+  return global.getSelection();
+}
+
+module.exports = getSelectionRaw;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],5:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var rangeToTextRange = require('./rangeToTextRange');
+var doc = global.document;
+var body = doc.body;
+var GetSelectionProto = GetSelection.prototype;
+
+function GetSelection (selection) {
+  var self = this;
+  var range = selection.createRange();
+
+  this._selection = selection;
+  this._ranges = [];
+
+  if (selection.type === 'Control') {
+    updateControlSelection(self);
+  } else if (isTextRange(range)) {
+    updateFromTextRange(self, range);
+  } else {
+    updateEmptySelection(self);
+  }
+}
+
+GetSelectionProto.removeAllRanges = function () {
+  var textRange;
+  try {
+    this._selection.empty();
+    if (this._selection.type !== 'None') {
+      textRange = body.createTextRange();
+      textRange.select();
+      this._selection.empty();
+    }
+  } catch (e) {
+  }
+  updateEmptySelection(this);
+};
+
+GetSelectionProto.addRange = function (range) {
+  if (this._selection.type === 'Control') {
+    addRangeToControlSelection(this, range);
+  } else {
+    rangeToTextRange(range).select();
+    this._ranges[0] = range;
+    this.rangeCount = 1;
+    this.isCollapsed = this._ranges[0].collapsed;
+    updateAnchorAndFocusFromRange(this, range, false);
+  }
+};
+
+GetSelectionProto.setRanges = function (ranges) {
+  this.removeAllRanges();
+  var rangeCount = ranges.length;
+  if (rangeCount > 1) {
+    createControlSelection(this, ranges);
+  } else if (rangeCount) {
+    this.addRange(ranges[0]);
+  }
+};
+
+GetSelectionProto.getRangeAt = function (index) {
+  if (index < 0 || index >= this.rangeCount) {
+    throw new Error('getRangeAt(): index out of bounds');
+  } else {
+    return this._ranges[index].cloneRange();
+  }
+};
+
+GetSelectionProto.removeRange = function (range) {
+  if (this._selection.type !== 'Control') {
+    removeRangeManually(this, range);
+    return;
+  }
+  var controlRange = this._selection.createRange();
+  var rangeElement = getSingleElementFromRange(range);
+  var newControlRange = body.createControlRange();
+  var el;
+  var removed = false;
+  for (var i = 0, len = controlRange.length; i < len; ++i) {
+    el = controlRange.item(i);
+    if (el !== rangeElement || removed) {
+      newControlRange.add(controlRange.item(i));
+    } else {
+      removed = true;
+    }
+  }
+  newControlRange.select();
+  updateControlSelection(this);
+};
+
+GetSelectionProto.eachRange = function (fn, returnValue) {
+  var i = 0;
+  var len = this._ranges.length;
+  for (i = 0; i < len; ++i) {
+    if (fn(this.getRangeAt(i))) {
+      return returnValue;
+    }
+  }
+};
+
+GetSelectionProto.getAllRanges = function () {
+  var ranges = [];
+  this.eachRange(function (range) {
+    ranges.push(range);
+  });
+  return ranges;
+};
+
+GetSelectionProto.setSingleRange = function (range) {
+  this.removeAllRanges();
+  this.addRange(range);
+};
+
+function createControlSelection (sel, ranges) {
+  var controlRange = body.createControlRange();
+  for (var i = 0, el, len = ranges.length; i < len; ++i) {
+    el = getSingleElementFromRange(ranges[i]);
+    try {
+      controlRange.add(el);
+    } catch (e) {
+      throw new Error('setRanges(): Element could not be added to control selection');
+    }
+  }
+  controlRange.select();
+  updateControlSelection(sel);
+}
+
+function removeRangeManually (sel, range) {
+  var ranges = sel.getAllRanges();
+  sel.removeAllRanges();
+  for (var i = 0, len = ranges.length; i < len; ++i) {
+    if (!isSameRange(range, ranges[i])) {
+      sel.addRange(ranges[i]);
+    }
+  }
+  if (!sel.rangeCount) {
+    updateEmptySelection(sel);
+  }
+}
+
+function updateAnchorAndFocusFromRange (sel, range) {
+  var anchorPrefix = 'start';
+  var focusPrefix = 'end';
+  sel.anchorNode = range[anchorPrefix + 'Container'];
+  sel.anchorOffset = range[anchorPrefix + 'Offset'];
+  sel.focusNode = range[focusPrefix + 'Container'];
+  sel.focusOffset = range[focusPrefix + 'Offset'];
+}
+
+function updateEmptySelection (sel) {
+  sel.anchorNode = sel.focusNode = null;
+  sel.anchorOffset = sel.focusOffset = 0;
+  sel.rangeCount = 0;
+  sel.isCollapsed = true;
+  sel._ranges.length = 0;
+}
+
+function rangeContainsSingleElement (rangeNodes) {
+  if (!rangeNodes.length || rangeNodes[0].nodeType !== 1) {
+    return false;
+  }
+  for (var i = 1, len = rangeNodes.length; i < len; ++i) {
+    if (!isAncestorOf(rangeNodes[0], rangeNodes[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function getSingleElementFromRange (range) {
+  var nodes = range.getNodes();
+  if (!rangeContainsSingleElement(nodes)) {
+    throw new Error('getSingleElementFromRange(): range did not consist of a single element');
+  }
+  return nodes[0];
+}
+
+function isTextRange (range) {
+  return range && range.text !== void 0;
+}
+
+function updateFromTextRange (sel, range) {
+  sel._ranges = [range];
+  updateAnchorAndFocusFromRange(sel, range, false);
+  sel.rangeCount = 1;
+  sel.isCollapsed = range.collapsed;
+}
+
+function updateControlSelection (sel) {
+  sel._ranges.length = 0;
+  if (sel._selection.type === 'None') {
+    updateEmptySelection(sel);
+  } else {
+    var controlRange = sel._selection.createRange();
+    if (isTextRange(controlRange)) {
+      updateFromTextRange(sel, controlRange);
+    } else {
+      sel.rangeCount = controlRange.length;
+      var range;
+      for (var i = 0; i < sel.rangeCount; ++i) {
+        range = doc.createRange();
+        range.selectNode(controlRange.item(i));
+        sel._ranges.push(range);
+      }
+      sel.isCollapsed = sel.rangeCount === 1 && sel._ranges[0].collapsed;
+      updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);
+    }
+  }
+}
+
+function addRangeToControlSelection (sel, range) {
+  var controlRange = sel._selection.createRange();
+  var rangeElement = getSingleElementFromRange(range);
+  var newControlRange = body.createControlRange();
+  for (var i = 0, len = controlRange.length; i < len; ++i) {
+    newControlRange.add(controlRange.item(i));
+  }
+  try {
+    newControlRange.add(rangeElement);
+  } catch (e) {
+    throw new Error('addRange(): Element could not be added to control selection');
+  }
+  newControlRange.select();
+  updateControlSelection(sel);
+}
+
+function isSameRange (left, right) {
+  return (
+    left.startContainer === right.startContainer &&
+    left.startOffset === right.startOffset &&
+    left.endContainer === right.endContainer &&
+    left.endOffset === right.endOffset
+  );
+}
+
+function isAncestorOf (ancestor, descendant) {
+  var node = descendant;
+  while (node.parentNode) {
+    if (node.parentNode === ancestor) {
+      return true;
+    }
+    node = node.parentNode;
+  }
+  return false;
+}
+
+function getSelection () {
+  return new GetSelection(global.document.selection);
+}
+
+module.exports = getSelection;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./rangeToTextRange":7}],6:[function(require,module,exports){
+'use strict';
+
+function isHostMethod (host, prop) {
+  var type = typeof host[prop];
+  return type === 'function' || !!(type === 'object' && host[prop]) || type === 'unknown';
+}
+
+function isHostProperty (host, prop) {
+  return typeof host[prop] !== 'undefined';
+}
+
+function many (fn) {
+  return function areHosted (host, props) {
+    var i = props.length;
+    while (i--) {
+      if (!fn(host, props[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+
+module.exports = {
+  method: isHostMethod,
+  methods: many(isHostMethod),
+  property: isHostProperty,
+  properties: many(isHostProperty)
+};
+
+},{}],7:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var doc = global.document;
+var body = doc.body;
+
+function rangeToTextRange (p) {
+  if (p.collapsed) {
+    return createBoundaryTextRange({ node: p.startContainer, offset: p.startOffset }, true);
+  }
+  var startRange = createBoundaryTextRange({ node: p.startContainer, offset: p.startOffset }, true);
+  var endRange = createBoundaryTextRange({ node: p.endContainer, offset: p.endOffset }, false);
+  var textRange = body.createTextRange();
+  textRange.setEndPoint('StartToStart', startRange);
+  textRange.setEndPoint('EndToEnd', endRange);
+  return textRange;
+}
+
+function isCharacterDataNode (node) {
+  var t = node.nodeType;
+  return t === 3 || t === 4 || t === 8 ;
+}
+
+function createBoundaryTextRange (p, starting) {
+  var bound;
+  var parent;
+  var offset = p.offset;
+  var workingNode;
+  var childNodes;
+  var range = body.createTextRange();
+  var data = isCharacterDataNode(p.node);
+
+  if (data) {
+    bound = p.node;
+    parent = bound.parentNode;
+  } else {
+    childNodes = p.node.childNodes;
+    bound = offset < childNodes.length ? childNodes[offset] : null;
+    parent = p.node;
+  }
+
+  workingNode = doc.createElement('span');
+  workingNode.innerHTML = '&#feff;';
+
+  if (bound) {
+    parent.insertBefore(workingNode, bound);
+  } else {
+    parent.appendChild(workingNode);
+  }
+
+  range.moveToElementText(workingNode);
+  range.collapse(!starting);
+  parent.removeChild(workingNode);
+
+  if (data) {
+    range[starting ? 'moveStart' : 'moveEnd']('character', offset);
+  }
+  return range;
+}
+
+module.exports = rangeToTextRange;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],8:[function(require,module,exports){
+'use strict';
+
+var getSelection = require('./getSelection');
+var setSelection = require('./setSelection');
+
+module.exports = {
+  get: getSelection,
+  set: setSelection
+};
+
+},{"./getSelection":2,"./setSelection":9}],9:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var getSelection = require('./getSelection');
+var rangeToTextRange = require('./rangeToTextRange');
+var doc = global.document;
+
+function setSelection (p) {
+  if (doc.createRange) {
+    modernSelection();
+  } else {
+    oldSelection();
+  }
+
+  function modernSelection () {
+    var sel = getSelection();
+    var range = doc.createRange();
+    if (!p.startContainer) {
+      return;
+    }
+    if (p.endContainer) {
+      range.setEnd(p.endContainer, p.endOffset);
+    } else {
+      range.setEnd(p.startContainer, p.startOffset);
+    }
+    range.setStart(p.startContainer, p.startOffset);
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+
+  function oldSelection () {
+    rangeToTextRange(p).select();
+  }
+}
+
+module.exports = setSelection;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./getSelection":2,"./rangeToTextRange":7}],10:[function(require,module,exports){
+'use strict';
+
+var get = easyGet;
+var set = easySet;
+
+if (document.selection && document.selection.createRange) {
+  get = hardGet;
+  set = hardSet;
+}
+
+function easyGet (el) {
+  return {
+    start: el.selectionStart,
+    end: el.selectionEnd
+  };
+}
+
+function hardGet (el) {
+  var active = document.activeElement;
+  if (active !== el) {
+    el.focus();
+  }
+
+  var range = document.selection.createRange();
+  var bookmark = range.getBookmark();
+  var original = el.value;
+  var marker = getUniqueMarker(original);
+  var parent = range.parentElement();
+  if (parent === null || !inputs(parent)) {
+    return result(0, 0);
+  }
+  range.text = marker + range.text + marker;
+
+  var contents = el.value;
+
+  el.value = original;
+  range.moveToBookmark(bookmark);
+  range.select();
+
+  return result(contents.indexOf(marker), contents.lastIndexOf(marker) - marker.length);
+
+  function result (start, end) {
+    if (active !== el) { // don't disrupt pre-existing state
+      if (active) {
+        active.focus();
+      } else {
+        el.blur();
+      }
+    }
+    return { start: start, end: end };
+  }
+}
+
+function getUniqueMarker (contents) {
+  var marker;
+  do {
+    marker = '@@marker.' + Math.random() * new Date();
+  } while (contents.indexOf(marker) !== -1);
+  return marker;
+}
+
+function inputs (el) {
+  return ((el.tagName === 'INPUT' && el.type === 'text') || el.tagName === 'TEXTAREA');
+}
+
+function easySet (el, p) {
+  el.selectionStart = parse(el, p.start);
+  el.selectionEnd = parse(el, p.end);
+}
+
+function hardSet (el, p) {
+  var range = el.createTextRange();
+
+  if (p.start === 'end' && p.end === 'end') {
+    range.collapse(false);
+    range.select();
+  } else {
+    range.collapse(true);
+    range.moveEnd('character', parse(el, p.end));
+    range.moveStart('character', parse(el, p.start));
+    range.select();
+  }
+}
+
+function parse (el, value) {
+  return value === 'end' ? el.value.length : value || 0;
+}
+
+function sell (el, p) {
+  if (arguments.length === 2) {
+    set(el, p);
+  }
+  return get(el);
+}
+
+module.exports = sell;
+
+},{}],11:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var sell = require('sell');
+var crossvent = require('crossvent');
+var seleccion = require('seleccion');
+var throttle = require('./throttle');
+var getSelection = seleccion.get;
+var props = [
+  'direction',
+  'boxSizing',
+  'width',
+  'height',
+  'overflowX',
+  'overflowY',
+  'borderTopWidth',
+  'borderRightWidth',
+  'borderBottomWidth',
+  'borderLeftWidth',
+  'paddingTop',
+  'paddingRight',
+  'paddingBottom',
+  'paddingLeft',
+  'fontStyle',
+  'fontVariant',
+  'fontWeight',
+  'fontStretch',
+  'fontSize',
+  'fontSizeAdjust',
+  'lineHeight',
+  'fontFamily',
+  'textAlign',
+  'textTransform',
+  'textIndent',
+  'textDecoration',
+  'letterSpacing',
+  'wordSpacing'
+];
+var win = global;
+var doc = document;
+var ff = win.mozInnerScreenX !== null && win.mozInnerScreenX !== void 0;
+
+function tailormade (el, options) {
+  var textInput = el.tagName === 'INPUT' || el.tagName === 'TEXTAREA';
+  var throttledRefresh = throttle(refresh, 30);
+  var o = options || {};
+
+  bind();
+
+  return {
+    read: readPosition,
+    refresh: throttledRefresh,
+    destroy: destroy
+  };
+
+  function noop () {}
+  function readPosition () { return (textInput ? coordsText : coordsHTML)(); }
+
+  function refresh () {
+    if (o.sleeping) {
+      return;
+    }
+    return (o.update || noop)(readPosition());
+  }
+
+  function coordsText () {
+    var p = sell(el);
+    var context = prepare();
+    var readings = readTextCoords(context, p.start);
+    doc.body.removeChild(context.mirror);
+    return readings;
+  }
+
+  function coordsHTML () {
+    var sel = getSelection();
+    if (sel.rangeCount) {
+      var range = sel.getRangeAt(0);
+      var needsToWorkAroundNewlineBug = range.startContainer.nodeName === 'P' && range.startOffset === 0;
+      if (needsToWorkAroundNewlineBug) {
+        return {
+          x: range.startContainer.offsetLeft,
+          y: range.startContainer.offsetTop,
+          absolute: true
+        };
+      }
+      if (range.getClientRects) {
+        var rects = range.getClientRects();
+        if (rects.length > 0) {
+          return {
+            x: rects[0].left,
+            y: rects[0].top,
+            absolute: true
+          };
+        }
+      }
+    }
+    return { x: 0, y: 0 };
+  }
+
+  function readTextCoords (context, p) {
+    var rest = doc.createElement('span');
+    var mirror = context.mirror;
+    var computed = context.computed;
+
+    write(mirror, read(el).substring(0, p));
+
+    if (el.tagName === 'INPUT') {
+      mirror.textContent = mirror.textContent.replace(/\s/g, '\u00a0');
+    }
+
+    write(rest, read(el).substring(p) || '.');
+
+    mirror.appendChild(rest);
+
+    return {
+      x: rest.offsetLeft + parseInt(computed['borderLeftWidth']),
+      y: rest.offsetTop + parseInt(computed['borderTopWidth'])
+    };
+  }
+
+  function read (el) {
+    return textInput ? el.value : el.innerHTML;
+  }
+
+  function prepare () {
+    var computed = win.getComputedStyle ? getComputedStyle(el) : el.currentStyle;
+    var mirror = doc.createElement('div');
+    var style = mirror.style;
+
+    doc.body.appendChild(mirror);
+
+    if (el.tagName !== 'INPUT') {
+      style.wordWrap = 'break-word';
+    }
+    style.whiteSpace = 'pre-wrap';
+    style.position = 'absolute';
+    style.visibility = 'hidden';
+    props.forEach(copy);
+
+    if (ff) {
+      style.width = parseInt(computed.width) - 2 + 'px';
+      if (el.scrollHeight > parseInt(computed.height)) {
+        style.overflowY = 'scroll';
+      }
+    } else {
+      style.overflow = 'hidden';
+    }
+    return { mirror: mirror, computed: computed };
+
+    function copy (prop) {
+      style[prop] = computed[prop];
+    }
+  }
+
+  function write (el, value) {
+    if (textInput) {
+      el.textContent = value;
+    } else {
+      el.innerHTML = value;
+    }
+  }
+
+  function bind (remove) {
+    var op = remove ? 'remove' : 'add';
+    crossvent[op](el, 'keydown', throttledRefresh);
+    crossvent[op](el, 'keyup', throttledRefresh);
+    crossvent[op](el, 'input', throttledRefresh);
+    crossvent[op](el, 'paste', throttledRefresh);
+    crossvent[op](el, 'change', throttledRefresh);
+  }
+
+  function destroy () {
+    bind(true);
+  }
+}
+
+module.exports = tailormade;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./throttle":12,"crossvent":18,"seleccion":8,"sell":10}],12:[function(require,module,exports){
+'use strict';
+
+function throttle (fn, boundary) {
+  var last = -Infinity;
+  var timer;
+  return function bounced () {
+    if (timer) {
+      return;
+    }
+    unbound();
+
+    function unbound () {
+      clearTimeout(timer);
+      timer = null;
+      var next = last + boundary;
+      var now = Date.now();
+      if (now > next) {
+        last = now;
+        fn();
+      } else {
+        timer = setTimeout(unbound, next - now);
+      }
+    }
+  };
+}
+
+module.exports = throttle;
+
+},{}],13:[function(require,module,exports){
+'use strict';
+
+var ticky = require('ticky');
+
+module.exports = function debounce (fn, args, ctx) {
+  if (!fn) { return; }
+  ticky(function run () {
+    fn.apply(ctx || null, args || []);
+  });
+};
+
+},{"ticky":16}],14:[function(require,module,exports){
+'use strict';
+
+var atoa = require('atoa');
+var debounce = require('./debounce');
+
+module.exports = function emitter (thing, options) {
+  var opts = options || {};
+  var evt = {};
+  if (thing === undefined) { thing = {}; }
+  thing.on = function (type, fn) {
+    if (!evt[type]) {
+      evt[type] = [fn];
+    } else {
+      evt[type].push(fn);
+    }
+    return thing;
+  };
+  thing.once = function (type, fn) {
+    fn._once = true; // thing.off(fn) still works!
+    thing.on(type, fn);
+    return thing;
+  };
+  thing.off = function (type, fn) {
+    var c = arguments.length;
+    if (c === 1) {
+      delete evt[type];
+    } else if (c === 0) {
+      evt = {};
+    } else {
+      var et = evt[type];
+      if (!et) { return thing; }
+      et.splice(et.indexOf(fn), 1);
+    }
+    return thing;
+  };
+  thing.emit = function () {
+    var args = atoa(arguments);
+    return thing.emitterSnapshot(args.shift()).apply(this, args);
+  };
+  thing.emitterSnapshot = function (type) {
+    var et = (evt[type] || []).slice(0);
+    return function () {
+      var args = atoa(arguments);
+      var ctx = this || thing;
+      if (type === 'error' && opts.throws !== false && !et.length) { throw args.length === 1 ? args[0] : args; }
+      et.forEach(function emitter (listen) {
+        if (opts.async) { debounce(listen, args, ctx); } else { listen.apply(ctx, args); }
+        if (listen._once) { thing.off(type, listen); }
+      });
+      return thing;
+    };
+  };
+  return thing;
+};
+
+},{"./debounce":13,"atoa":15}],15:[function(require,module,exports){
+module.exports = function atoa (a, n) { return Array.prototype.slice.call(a, n); }
+
+},{}],16:[function(require,module,exports){
+var si = typeof setImmediate === 'function', tick;
+if (si) {
+  tick = function (fn) { setImmediate(fn); };
+} else {
+  tick = function (fn) { setTimeout(fn, 0); };
+}
+
+module.exports = tick;
+},{}],17:[function(require,module,exports){
+(function (global){
+
+var NativeCustomEvent = global.CustomEvent;
+
+function useNative () {
+  try {
+    var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });
+    return  'cat' === p.type && 'bar' === p.detail.foo;
+  } catch (e) {
+  }
+  return false;
+}
+
+/**
+ * Cross-browser `CustomEvent` constructor.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent
+ *
+ * @public
+ */
+
+module.exports = useNative() ? NativeCustomEvent :
+
+// IE >= 9
+'function' === typeof document.createEvent ? function CustomEvent (type, params) {
+  var e = document.createEvent('CustomEvent');
+  if (params) {
+    e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);
+  } else {
+    e.initCustomEvent(type, false, false, void 0);
+  }
+  return e;
+} :
+
+// IE <= 8
+function CustomEvent (type, params) {
+  var e = document.createEventObject();
+  e.type = type;
+  if (params) {
+    e.bubbles = Boolean(params.bubbles);
+    e.cancelable = Boolean(params.cancelable);
+    e.detail = params.detail;
+  } else {
+    e.bubbles = false;
+    e.cancelable = false;
+    e.detail = void 0;
+  }
+  return e;
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],18:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var customEvent = require('custom-event');
+var eventmap = require('./eventmap');
+var doc = document;
+var addEvent = addEventEasy;
+var removeEvent = removeEventEasy;
+var hardCache = [];
+
+if (!global.addEventListener) {
+  addEvent = addEventHard;
+  removeEvent = removeEventHard;
+}
+
+function addEventEasy (el, type, fn, capturing) {
+  return el.addEventListener(type, fn, capturing);
+}
+
+function addEventHard (el, type, fn) {
+  return el.attachEvent('on' + type, wrap(el, type, fn));
+}
+
+function removeEventEasy (el, type, fn, capturing) {
+  return el.removeEventListener(type, fn, capturing);
+}
+
+function removeEventHard (el, type, fn) {
+  return el.detachEvent('on' + type, unwrap(el, type, fn));
+}
+
+function fabricateEvent (el, type, model) {
+  var e = eventmap.indexOf(type) === -1 ? makeCustomEvent() : makeClassicEvent();
+  if (el.dispatchEvent) {
+    el.dispatchEvent(e);
+  } else {
+    el.fireEvent('on' + type, e);
+  }
+  function makeClassicEvent () {
+    var e;
+    if (doc.createEvent) {
+      e = doc.createEvent('Event');
+      e.initEvent(type, true, true);
+    } else if (doc.createEventObject) {
+      e = doc.createEventObject();
+    }
+    return e;
+  }
+  function makeCustomEvent () {
+    return new customEvent(type, { detail: model });
+  }
+}
+
+function wrapperFactory (el, type, fn) {
+  return function wrapper (originalEvent) {
+    var e = originalEvent || global.event;
+    e.target = e.target || e.srcElement;
+    e.preventDefault = e.preventDefault || function preventDefault () { e.returnValue = false; };
+    e.stopPropagation = e.stopPropagation || function stopPropagation () { e.cancelBubble = true; };
+    e.which = e.which || e.keyCode;
+    fn.call(el, e);
+  };
+}
+
+function wrap (el, type, fn) {
+  var wrapper = unwrap(el, type, fn) || wrapperFactory(el, type, fn);
+  hardCache.push({
+    wrapper: wrapper,
+    element: el,
+    type: type,
+    fn: fn
+  });
+  return wrapper;
+}
+
+function unwrap (el, type, fn) {
+  var i = find(el, type, fn);
+  if (i) {
+    var wrapper = hardCache[i].wrapper;
+    hardCache.splice(i, 1); // free up a tad of memory
+    return wrapper;
+  }
+}
+
+function find (el, type, fn) {
+  var i, item;
+  for (i = 0; i < hardCache.length; i++) {
+    item = hardCache[i];
+    if (item.element === el && item.type === type && item.fn === fn) {
+      return i;
+    }
+  }
+}
+
+module.exports = {
+  add: addEvent,
+  remove: removeEvent,
+  fabricate: fabricateEvent
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./eventmap":19,"custom-event":17}],19:[function(require,module,exports){
+(function (global){
+'use strict';
+
+var eventmap = [];
+var eventname = '';
+var ron = /^on/;
+
+for (eventname in global) {
+  if (ron.test(eventname)) {
+    eventmap.push(eventname.slice(2));
+  }
+}
+
+module.exports = eventmap;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],20:[function(require,module,exports){
+'use strict';
+
+var isInput = require('./isInput');
+var bindings = {};
+
+function has (source, target) {
+  var binding = bindings[source.id];
+  return binding && binding[target.id];
+}
+
+function insert (source, target) {
+  var binding = bindings[source.id];
+  if (!binding) {
+    binding = bindings[source.id] = {};
+  }
+  var invalidate = invalidator(target);
+  binding[target.id] = invalidate;
+  source.on('data', invalidate);
+  source.on('destroyed', remove.bind(null, source, target));
+}
+
+function remove (source, target) {
+  var binding = bindings[source.id];
+  if (!binding) {
+    return;
+  }
+  var invalidate = binding[target.id];
+  source.off('data', invalidate);
+  delete binding[target.id];
+}
+
+function invalidator (target) {
+  return function invalidate () {
+    target.refresh();
+  };
+}
+
+function add (source, target) {
+  if (isInput(target.associated) || has(source, target)) {
+    return;
+  }
+  insert(source, target);
+}
+
+module.exports = {
+  add: add,
+  remove: remove
+};
+
+},{"./isInput":30}],21:[function(require,module,exports){
+'use strict';
+
+var crossvent = require('crossvent');
+var emitter = require('contra/emitter');
+var dom = require('./dom');
+var text = require('./text');
+var parse = require('./parse');
+var clone = require('./clone');
+var defaults = require('./defaults');
+var momentum = require('./momentum');
+var classes = require('./classes');
+var noop = require('./noop');
+var no;
+
+function calendar (calendarOptions) {
+  var o;
+  var ref;
+  var refCal;
+  var container;
+  var rendered = false;
+
+  // date variables
+  var monthOffsetAttribute = 'data-rome-offset';
+  var weekdays;
+  var weekdayCount;
+  var calendarMonths = [];
+  var lastYear;
+  var lastMonth;
+  var lastDay;
+  var lastDayElement;
+  var datewrapper;
+  var back;
+  var next;
+
+  // time variables
+  var secondsInDay = 60 * 60 * 24;
+  var time;
+  var timelist;
+
+  var api = emitter({
+    associated: calendarOptions.associated
+  });
+
+  init();
+  setTimeout(ready, 0);
+
+  return api;
+
+  function napi () { return api; }
+
+  function init (initOptions) {
+    o = defaults(initOptions || calendarOptions, api);
+    if (!container) { container = dom({ className: o.styles.container }); }
+    weekdays = o.weekdayFormat;
+    weekdayCount = weekdays.length;
+    lastMonth = no;
+    lastYear = no;
+    lastDay = no;
+    lastDayElement = no;
+    o.appendTo.appendChild(container);
+
+    removeChildren(container);
+    rendered = false;
+    ref = o.initialValue ? o.initialValue : momentum.moment();
+    refCal = ref.clone();
+
+    api.back = subtractMonth;
+    api.container = container;
+    api.destroyed = false;
+    api.destroy = destroy.bind(api, false);
+    api.emitValues = emitValues;
+    api.getDate = getDate;
+    api.getDateString = getDateString;
+    api.getMoment = getMoment;
+    api.hide = hide;
+    api.next = addMonth;
+    api.options = changeOptions;
+    api.options.reset = resetOptions;
+    api.refresh = refresh;
+    api.restore = napi;
+    api.setValue = setValue;
+    api.show = show;
+
+    eventListening();
+    ready();
+
+    return api;
+  }
+
+  function ready () {
+    api.emit('ready', clone(o));
+  }
+
+  function destroy (silent) {
+    if (container && container.parentNode) {
+      container.parentNode.removeChild(container);
+    }
+
+    if (o) {
+      eventListening(true);
+    }
+
+    var destroyed = api.emitterSnapshot('destroyed');
+    api.back = noop;
+    api.destroyed = true;
+    api.destroy = napi;
+    api.emitValues = napi;
+    api.getDate = noop;
+    api.getDateString = noop;
+    api.getMoment = noop;
+    api.hide = napi;
+    api.next = noop;
+    api.options = napi;
+    api.options.reset = napi;
+    api.refresh = napi;
+    api.restore = init;
+    api.setValue = napi;
+    api.show = napi;
+    api.off();
+
+    if (silent !== true) {
+      destroyed();
+    }
+
+    return api;
+  }
+
+  function eventListening (remove) {
+    var op = remove ? 'remove' : 'add';
+    if (o.autoHideOnBlur) { crossvent[op](document.documentElement, 'focus', hideOnBlur, true); }
+    if (o.autoHideOnClick) { crossvent[op](document, 'click', hideOnClick); }
+  }
+
+  function changeOptions (options) {
+    if (arguments.length === 0) {
+      return clone(o);
+    }
+    destroy();
+    init(options);
+    return api;
+  }
+
+  function resetOptions () {
+    return changeOptions({ appendTo: o.appendTo });
+  }
+
+  function render () {
+    if (rendered) {
+      return;
+    }
+    rendered = true;
+    renderDates();
+    renderTime();
+    api.emit('render');
+  }
+
+  function renderDates () {
+    if (!o.date) {
+      return;
+    }
+    var i;
+    calendarMonths = [];
+
+    datewrapper = dom({ className: o.styles.date, parent: container });
+
+    for (i = 0; i < o.monthsInCalendar; i++) {
+      renderMonth(i);
+    }
+
+    crossvent.add(back, 'click', subtractMonth);
+    crossvent.add(next, 'click', addMonth);
+    crossvent.add(datewrapper, 'click', pickDay);
+
+    function renderMonth (i) {
+      var month = dom({ className: o.styles.month, parent: datewrapper });
+      if (i === 0) {
+        back = dom({ type: 'button', className: o.styles.back, attributes: { type: 'button' }, parent: month });
+      }
+      if (i === o.monthsInCalendar -1) {
+        next = dom({ type: 'button', className: o.styles.next, attributes: { type: 'button' }, parent: month });
+      }
+      var label = dom({ className: o.styles.monthLabel, parent: month });
+      var date = dom({ type: 'table', className: o.styles.dayTable, parent: month });
+      var datehead = dom({ type: 'thead', className: o.styles.dayHead, parent: date });
+      var dateheadrow = dom({ type: 'tr', className: o.styles.dayRow, parent: datehead });
+      var datebody = dom({ type: 'tbody', className: o.styles.dayBody, parent: date });
+      var j;
+
+      for (j = 0; j < weekdayCount; j++) {
+        dom({ type: 'th', className: o.styles.dayHeadElem, parent: dateheadrow, text: weekdays[weekday(j)] });
+      }
+
+      datebody.setAttribute(monthOffsetAttribute, i);
+      calendarMonths.push({
+        label: label,
+        body: datebody
+      });
+    }
+  }
+
+  function renderTime () {
+    if (!o.time || !o.timeInterval) {
+      return;
+    }
+    var timewrapper = dom({ className: o.styles.time, parent: container });
+    time = dom({ className: o.styles.selectedTime, parent: timewrapper, text: ref.format(o.timeFormat) });
+    crossvent.add(time, 'click', toggleTimeList);
+    timelist = dom({ className: o.styles.timeList, parent: timewrapper });
+    crossvent.add(timelist, 'click', pickTime);
+    var next = momentum.moment('00:00:00', 'HH:mm:ss');
+    var latest = next.clone().add(1, 'days');
+    while (next.isBefore(latest)) {
+      dom({ className: o.styles.timeOption, parent: timelist, text: next.format(o.timeFormat) });
+      next.add(o.timeInterval, 'seconds');
+    }
+  }
+
+  function weekday (index, backwards) {
+    var factor = backwards ? -1 : 1;
+    var offset = index + o.weekStart * factor;
+    if (offset >= weekdayCount || offset < 0) {
+      offset += weekdayCount * -factor;
+    }
+    return offset;
+  }
+
+  function displayValidTimesOnly () {
+    if (!o.time || !rendered) {
+      return;
+    }
+    var times = timelist.children;
+    var length = times.length;
+    var date;
+    var time;
+    var item;
+    var i;
+    for (i = 0; i < length; i++) {
+      item = times[i];
+      time = momentum.moment(text(item), o.timeFormat);
+      date = setTime(ref.clone(), time);
+      item.style.display = isInRange(date, false, o.timeValidator) ? 'block' : 'none';
+    }
+  }
+
+  function toggleTimeList (show) {
+    var display = typeof show === 'boolean' ? show : timelist.style.display === 'none';
+    if (display) {
+      showTimeList();
+    } else {
+      hideTimeList();
+    }
+  }
+
+  function showTimeList () { if (timelist) { timelist.style.display = 'block'; } }
+  function hideTimeList () { if (timelist) { timelist.style.display = 'none'; } }
+  function showCalendar () { container.style.display = 'inline-block'; api.emit('show'); }
+  function hideCalendar () {
+    if (container.style.display !== 'none') {
+      container.style.display = 'none';
+      api.emit('hide');
+    }
+  }
+
+  function show () {
+    render();
+    refresh();
+    toggleTimeList(!o.date);
+    showCalendar();
+    return api;
+  }
+
+  function hide () {
+    hideTimeList();
+    setTimeout(hideCalendar, 0);
+    return api;
+  }
+
+  function hideConditionally () {
+    hideTimeList();
+
+    var pos = classes.contains(container, o.styles.positioned);
+    if (pos) {
+      setTimeout(hideCalendar, 0);
+    }
+    return api;
+  }
+
+  function calendarEventTarget (e) {
+    var target = e.target;
+    if (target === api.associated) {
+      return true;
+    }
+    while (target) {
+      if (target === container) {
+        return true;
+      }
+      target = target.parentNode;
+    }
+  }
+
+  function hideOnBlur (e) {
+    if (calendarEventTarget(e)) {
+      return;
+    }
+    hideConditionally();
+  }
+
+  function hideOnClick (e) {
+    if (calendarEventTarget(e)) {
+      return;
+    }
+    hideConditionally();
+  }
+
+  function subtractMonth () { changeMonth('subtract'); }
+  function addMonth () { changeMonth('add'); }
+  function changeMonth (op) {
+    var bound;
+    var direction = op === 'add' ? -1 : 1;
+    var offset = o.monthsInCalendar + direction * getMonthOffset(lastDayElement);
+    refCal[op](offset, 'months');
+    bound = inRange(refCal.clone());
+    ref = bound || ref;
+    if (bound) { refCal = bound.clone(); }
+    update();
+    api.emit(op === 'add' ? 'next' : 'back', ref.month());
+  }
+
+  function update (silent) {
+    updateCalendar();
+    updateTime();
+    if (silent !== true) { emitValues(); }
+    displayValidTimesOnly();
+  }
+
+  function updateCalendar () {
+    if (!o.date || !rendered) {
+      return;
+    }
+    var y = refCal.year();
+    var m = refCal.month();
+    var d = refCal.date();
+    if (d === lastDay && m === lastMonth && y === lastYear) {
+      return;
+    }
+    var canStay = isDisplayed();
+    lastDay = refCal.date();
+    lastMonth = refCal.month();
+    lastYear = refCal.year();
+    if (canStay) { updateCalendarSelection(); return; }
+    calendarMonths.forEach(updateMonth);
+    renderAllDays();
+
+    function updateMonth (month, i) {
+      var offsetCal = refCal.clone().add(i, 'months');
+      text(month.label, offsetCal.format(o.monthFormat));
+      removeChildren(month.body);
+    }
+  }
+
+  function updateCalendarSelection () {
+    var day = refCal.date() - 1;
+    selectDayElement(false);
+    calendarMonths.forEach(function (cal) {
+      var days;
+      if (sameCalendarMonth(cal.date, refCal)) {
+        days = cast(cal.body.children).map(aggregate);
+        days = Array.prototype.concat.apply([], days).filter(inside);
+        selectDayElement(days[day]);
+      }
+    });
+
+    function cast (like) {
+      var dest = [];
+      var i;
+      for (i = 0; i < like.length; i++) {
+        dest.push(like[i]);
+      }
+      return dest;
+    }
+
+    function aggregate (child) {
+      return cast(child.children);
+    }
+
+    function inside (child) {
+      return !classes.contains(child, o.styles.dayPrevMonth) &&
+             !classes.contains(child, o.styles.dayNextMonth);
+    }
+  }
+
+  function isDisplayed () {
+    return calendarMonths.some(matches);
+
+    function matches (cal) {
+      if (!lastYear) { return false; }
+      return sameCalendarMonth(cal.date, refCal);
+    }
+  }
+
+  function sameCalendarMonth (left, right) {
+    return left && right && left.year() === right.year() && left.month() === right.month();
+  }
+
+  function updateTime () {
+    if (!o.time || !rendered) {
+      return;
+    }
+    text(time, ref.format(o.timeFormat));
+  }
+
+  function emitValues () {
+    api.emit('data', getDateString());
+    api.emit('year', ref.year());
+    api.emit('month', ref.month());
+    api.emit('day', ref.day());
+    api.emit('time', ref.format(o.timeFormat));
+    return api;
+  }
+
+  function refresh () {
+    lastYear = false;
+    lastMonth = false;
+    lastDay = false;
+    update(true);
+    return api;
+  }
+
+  function setValue (value) {
+    var date = parse(value, o.inputFormat);
+    if (date === null) {
+      return;
+    }
+    ref = inRange(date) || ref;
+    refCal = ref.clone();
+    update(true);
+
+    return api;
+  }
+
+  function removeChildren (elem, self) {
+    while (elem && elem.firstChild) {
+      elem.removeChild(elem.firstChild);
+    }
+    if (self === true) {
+      elem.parentNode.removeChild(elem);
+    }
+  }
+
+  function renderAllDays () {
+    var i;
+    for (i = 0; i < o.monthsInCalendar; i++) {
+      renderDays(i);
+    }
+  }
+
+  function renderDays (offset) {
+    var month = calendarMonths[offset];
+    var offsetCal = refCal.clone().add(offset, 'months');
+    var total = offsetCal.daysInMonth();
+    var current = offsetCal.month() !== ref.month() ? -1 : ref.date(); // -1 : 1..31
+    var first = offsetCal.clone().date(1);
+    var firstDay = weekday(first.day(), true); // 0..6
+    var tr = dom({ type: 'tr', className: o.styles.dayRow, parent: month.body });
+    var prevMonth = hiddenWhen(offset !== 0, [o.styles.dayBodyElem, o.styles.dayPrevMonth]);
+    var nextMonth = hiddenWhen(offset !== o.monthsInCalendar - 1, [o.styles.dayBodyElem, o.styles.dayNextMonth]);
+    var disabled = o.styles.dayDisabled;
+    var lastDay;
+
+    part({
+      base: first.clone().subtract(firstDay, 'days'),
+      length: firstDay,
+      cell: prevMonth
+    });
+
+    part({
+      base: first.clone(),
+      length: total,
+      cell: [o.styles.dayBodyElem],
+      selectable: true
+    });
+
+    lastDay = first.clone().add(total, 'days');
+
+    part({
+      base: lastDay,
+      length: weekdayCount - tr.children.length,
+      cell: nextMonth
+    });
+
+    back.disabled = !isInRangeLeft(first, true);
+    next.disabled = !isInRangeRight(lastDay, true);
+    month.date = offsetCal.clone();
+
+    function part (data) {
+      var i, day, node;
+      for (i = 0; i < data.length; i++) {
+        if (tr.children.length === weekdayCount) {
+          tr = dom({ type: 'tr', className: o.styles.dayRow, parent: month.body });
+        }
+        day = data.base.clone().add(i, 'days');
+        node = dom({
+          type: 'td',
+          parent: tr,
+          text: day.format(o.dayFormat),
+          className: validationTest(day, data.cell.join(' ').split(' ')).join(' ')
+        });
+        if (data.selectable && day.date() === current) {
+          selectDayElement(node);
+        }
+      }
+    }
+
+    function validationTest (day, cell) {
+      if (!isInRange(day, true, o.dateValidator)) { cell.push(disabled); }
+      return cell;
+    }
+
+    function hiddenWhen (value, cell) {
+      if (value) { cell.push(o.styles.dayConcealed); }
+      return cell;
+    }
+  }
+
+  function isInRange (date, allday, validator) {
+    if (!isInRangeLeft(date, allday)) {
+      return false;
+    }
+    if (!isInRangeRight(date, allday)) {
+      return false;
+    }
+    var valid = (validator || Function.prototype).call(api, date.toDate());
+    return valid !== false;
+  }
+
+  function isInRangeLeft (date, allday) {
+    var min = !o.min ? false : (allday ? o.min.clone().startOf('day') : o.min);
+    return !min || !date.isBefore(min);
+  }
+
+  function isInRangeRight (date, allday) {
+    var max = !o.max ? false : (allday ? o.max.clone().endOf('day') : o.max);
+    return !max || !date.isAfter(max);
+  }
+
+  function inRange (date) {
+    if (o.min && date.isBefore(o.min)) {
+      return inRange(o.min.clone());
+    } else if (o.max && date.isAfter(o.max)) {
+      return inRange(o.max.clone());
+    }
+    var value = date.clone().subtract(1, 'days');
+    if (validateTowards(value, date, 'add')) {
+      return inTimeRange(value);
+    }
+    value = date.clone();
+    if (validateTowards(value, date, 'subtract')) {
+      return inTimeRange(value);
+    }
+  }
+
+  function inTimeRange (value) {
+    var copy = value.clone().subtract(o.timeInterval, 'seconds');
+    var times = Math.ceil(secondsInDay / o.timeInterval);
+    var i;
+    for (i = 0; i < times; i++) {
+      copy.add(o.timeInterval, 'seconds');
+      if (copy.date() > value.date()) {
+        copy.subtract(1, 'days');
+      }
+      if (o.timeValidator.call(api, copy.toDate()) !== false) {
+        return copy;
+      }
+    }
+  }
+
+  function validateTowards (value, date, op) {
+    var valid = false;
+    while (valid === false) {
+      value[op](1, 'days');
+      if (value.month() !== date.month()) {
+        break;
+      }
+      valid = o.dateValidator.call(api, value.toDate());
+    }
+    return valid !== false;
+  }
+
+  function pickDay (e) {
+    var target = e.target;
+    if (classes.contains(target, o.styles.dayDisabled) || !classes.contains(target, o.styles.dayBodyElem)) {
+      return;
+    }
+    var day = parseInt(text(target), 10);
+    var prev = classes.contains(target, o.styles.dayPrevMonth);
+    var next = classes.contains(target, o.styles.dayNextMonth);
+    var offset = getMonthOffset(target) - getMonthOffset(lastDayElement);
+    ref.add(offset, 'months');
+    if (prev || next) {
+      ref.add(prev ? -1 : 1, 'months');
+    }
+    selectDayElement(target);
+    ref.date(day); // must run after setting the month
+    setTime(ref, inRange(ref) || ref);
+    refCal = ref.clone();
+    if (o.autoClose === true) { hideConditionally(); }
+    update();
+  }
+
+  function selectDayElement (node) {
+    if (lastDayElement) {
+      classes.remove(lastDayElement, o.styles.selectedDay);
+    }
+    if (node) {
+      classes.add(node, o.styles.selectedDay);
+    }
+    lastDayElement = node;
+  }
+
+  function getMonthOffset (elem) {
+    var offset;
+    while (elem && elem.getAttribute) {
+      offset = elem.getAttribute(monthOffsetAttribute);
+      if (typeof offset === 'string') {
+        return parseInt(offset, 10);
+      }
+      elem = elem.parentNode;
+    }
+    return 0;
+  }
+
+  function setTime (to, from) {
+    to.hour(from.hour()).minute(from.minute()).second(from.second());
+    return to;
+  }
+
+  function pickTime (e) {
+    var target = e.target;
+    if (!classes.contains(target, o.styles.timeOption)) {
+      return;
+    }
+    var value = momentum.moment(text(target), o.timeFormat);
+    setTime(ref, value);
+    refCal = ref.clone();
+    emitValues();
+    updateTime();
+    if ((!o.date && o.autoClose === true) || o.autoClose === 'time') {
+      hideConditionally();
+    } else {
+      hideTimeList();
+    }
+  }
+
+  function getDate () {
+    return ref.toDate();
+  }
+
+  function getDateString (format) {
+    return ref.format(format || o.inputFormat);
+  }
+
+  function getMoment () {
+    return ref.clone();
+  }
+}
+
+module.exports = calendar;
+
+},{"./classes":22,"./clone":23,"./defaults":25,"./dom":26,"./momentum":31,"./noop":32,"./parse":33,"./text":45,"contra/emitter":14,"crossvent":18}],22:[function(require,module,exports){
+'use strict';
+
+var trim = /^\s+|\s+$/g;
+var whitespace = /\s+/;
+
+function classes (node) {
+  return node.className.replace(trim, '').split(whitespace);
+}
+
+function set (node, value) {
+  node.className = value.join(' ');
+}
+
+function add (node, value) {
+  var values = remove(node, value);
+  values.push(value);
+  set(node, values);
+}
+
+function remove (node, value) {
+  var values = classes(node);
+  var i = values.indexOf(value);
+  if (i !== -1) {
+    values.splice(i, 1);
+    set(node, values);
+  }
+  return values;
+}
+
+function contains (node, value) {
+  return classes(node).indexOf(value) !== -1;
+}
+
+module.exports = {
+  add: add,
+  remove: remove,
+  contains: contains
+};
+
+},{}],23:[function(require,module,exports){
+'use strict';
+
+var momentum = require('./momentum');
+
+// naïve implementation, specifically meant to clone `options` objects
+function clone (thing) {
+  var copy = {};
+  var value;
+
+  for (var key in thing) {
+    value = thing[key];
+
+    if (!value) {
+      copy[key] = value;
+    } else if (momentum.isMoment(value)) {
+      copy[key] = value.clone();
+    } else if (value._isStylesConfiguration) {
+      copy[key] = clone(value);
+    } else {
+      copy[key] = value;
+    }
+  }
+
+  return copy;
+}
+
+module.exports = clone;
+
+},{"./momentum":31}],24:[function(require,module,exports){
+'use strict';
+
+var index = require('./index');
+var input = require('./input');
+var inline = require('./inline');
+var isInput = require('./isInput');
+
+function core (elem, options) {
+  var cal;
+  var existing = index.find(elem);
+  if (existing) {
+    return existing;
+  }
+
+  if (isInput(elem)) {
+    cal = input(elem, options);
+  } else {
+    cal = inline(elem, options);
+  }
+  index.assign(elem, cal);
+
+  return cal;
+}
+
+module.exports = core;
+
+},{"./index":27,"./inline":28,"./input":29,"./isInput":30}],25:[function(require,module,exports){
+'use strict';
+
+var parse = require('./parse');
+var isInput = require('./isInput');
+var momentum = require('./momentum');
+
+function defaults (options, cal) {
+  var temp;
+  var no;
+  var o = options || {};
+  if (o.autoHideOnClick === no) { o.autoHideOnClick = true; }
+  if (o.autoHideOnBlur === no) { o.autoHideOnBlur = true; }
+  if (o.autoClose === no) { o.autoClose = true; }
+  if (o.appendTo === no) { o.appendTo = document.body; }
+  if (o.appendTo === 'parent') {
+    if (isInput(cal.associated)) {
+      o.appendTo = cal.associated.parentNode;
+    } else {
+      throw new Error('Inline calendars must be appended to a parent node explicitly.');
+    }
+  }
+  if (o.invalidate === no) { o.invalidate = true; }
+  if (o.required === no) { o.required = false; }
+  if (o.date === no) { o.date = true; }
+  if (o.time === no) { o.time = true; }
+  if (o.date === false && o.time === false) { throw new Error('At least one of `date` or `time` must be `true`.'); }
+  if (o.inputFormat === no) {
+    if (o.date && o.time) {
+      o.inputFormat = 'YYYY-MM-DD HH:mm';
+    } else if (o.date) {
+      o.inputFormat = 'YYYY-MM-DD';
+    } else {
+      o.inputFormat = 'HH:mm';
+    }
+  }
+  if (o.initialValue === no) {
+    o.initialValue = null;
+  } else {
+    o.initialValue = parse(o.initialValue, o.inputFormat);
+  }
+  if (o.min === no) { o.min = null; } else { o.min = parse(o.min, o.inputFormat); }
+  if (o.max === no) { o.max = null; } else { o.max = parse(o.max, o.inputFormat); }
+  if (o.timeInterval === no) { o.timeInterval = 60 * 30; } // 30 minutes by default
+  if (o.min && o.max) {
+    if (o.max.isBefore(o.min)) {
+      temp = o.max;
+      o.max = o.min;
+      o.min = temp;
+    }
+    if (o.date === true) {
+      if (o.max.clone().subtract(1, 'days').isBefore(o.min)) {
+        throw new Error('`max` must be at least one day after `min`');
+      }
+    } else if (o.timeInterval * 1000 - o.min % (o.timeInterval * 1000) > o.max - o.min) {
+      throw new Error('`min` to `max` range must allow for at least one time option that matches `timeInterval`');
+    }
+  }
+  if (o.dateValidator === no) { o.dateValidator = Function.prototype; }
+  if (o.timeValidator === no) { o.timeValidator = Function.prototype; }
+  if (o.timeFormat === no) { o.timeFormat = 'HH:mm'; }
+  if (o.weekStart === no) { o.weekStart = momentum.moment().weekday(0).day(); }
+  if (o.weekdayFormat === no) { o.weekdayFormat = 'min'; }
+  if (o.weekdayFormat === 'long') {
+    o.weekdayFormat = momentum.moment.weekdays();
+  } else if (o.weekdayFormat === 'short') {
+    o.weekdayFormat = momentum.moment.weekdaysShort();
+  } else if (o.weekdayFormat === 'min') {
+    o.weekdayFormat = momentum.moment.weekdaysMin();
+  } else if (!Array.isArray(o.weekdayFormat) || o.weekdayFormat.length < 7) {
+    throw new Error('`weekdays` must be `min`, `short`, or `long`');
+  }
+  if (o.monthsInCalendar === no) { o.monthsInCalendar = 1; }
+  if (o.monthFormat === no) { o.monthFormat = 'MMMM YYYY'; }
+  if (o.dayFormat === no) { o.dayFormat = 'DD'; }
+  if (o.styles === no) { o.styles = {}; }
+
+  o.styles._isStylesConfiguration = true;
+
+  var styl = o.styles;
+  if (styl.back === no) { styl.back = 'rd-back'; }
+  if (styl.container === no) { styl.container = 'rd-container'; }
+  if (styl.positioned === no) { styl.positioned = 'rd-container-attachment'; }
+  if (styl.date === no) { styl.date = 'rd-date'; }
+  if (styl.dayBody === no) { styl.dayBody = 'rd-days-body'; }
+  if (styl.dayBodyElem === no) { styl.dayBodyElem = 'rd-day-body'; }
+  if (styl.dayPrevMonth === no) { styl.dayPrevMonth = 'rd-day-prev-month'; }
+  if (styl.dayNextMonth === no) { styl.dayNextMonth = 'rd-day-next-month'; }
+  if (styl.dayDisabled === no) { styl.dayDisabled = 'rd-day-disabled'; }
+  if (styl.dayConcealed === no) { styl.dayConcealed = 'rd-day-concealed'; }
+  if (styl.dayHead === no) { styl.dayHead = 'rd-days-head'; }
+  if (styl.dayHeadElem === no) { styl.dayHeadElem = 'rd-day-head'; }
+  if (styl.dayRow === no) { styl.dayRow = 'rd-days-row'; }
+  if (styl.dayTable === no) { styl.dayTable = 'rd-days'; }
+  if (styl.month === no) { styl.month = 'rd-month'; }
+  if (styl.monthLabel === no) { styl.monthLabel = 'rd-month-label'; }
+  if (styl.next === no) { styl.next = 'rd-next'; }
+  if (styl.selectedDay === no) { styl.selectedDay = 'rd-day-selected'; }
+  if (styl.selectedTime === no) { styl.selectedTime = 'rd-time-selected'; }
+  if (styl.time === no) { styl.time = 'rd-time'; }
+  if (styl.timeList === no) { styl.timeList = 'rd-time-list'; }
+  if (styl.timeOption === no) { styl.timeOption = 'rd-time-option'; }
+
+  return o;
+}
+
+module.exports = defaults;
+
+},{"./isInput":30,"./momentum":31,"./parse":33}],26:[function(require,module,exports){
+'use strict';
+
+function dom (options) {
+  var o = options || {};
+  if (!o.type) { o.type = 'div'; }
+  var elem = document.createElement(o.type);
+  if (o.className) { elem.className = o.className; }
+  if (o.text) { elem.innerText = elem.textContent = o.text; }
+  if (o.attributes) {
+    Object.keys(o.attributes).forEach(function(key) {
+      elem.setAttribute(key, o.attributes[key]);
+    });
+  }
+  if (o.parent) { o.parent.appendChild(elem); }
+  return elem;
+}
+
+module.exports = dom;
+
+},{}],27:[function(require,module,exports){
+'use strict';
+var no;
+var ikey = 'data-rome-id';
+var index = [];
+
+function find (thing) { // can be a DOM element or a number
+  if (typeof thing !== 'number' && thing && thing.getAttribute) {
+    return find(thing.getAttribute(ikey));
+  }
+  var existing = index[thing];
+  if (existing !== no) {
+    return existing;
+  }
+  return null;
+}
+
+function assign (elem, instance) {
+  elem.setAttribute(ikey, instance.id = index.push(instance) - 1);
+}
+
+module.exports = {
+  find: find,
+  assign: assign
+};
+
+},{}],28:[function(require,module,exports){
+'use strict';
+
+var calendar = require('./calendar');
+
+function inline (elem, calendarOptions) {
+  var o = calendarOptions || {};
+
+  o.appendTo = elem;
+  o.associated = elem;
+
+  var cal = calendar(o);
+  cal.show();
+  return cal;
+}
+
+module.exports = inline;
+
+},{"./calendar":21}],29:[function(require,module,exports){
+'use strict';
+
+var crossvent = require('crossvent');
+var bullseye = require('bullseye');
+var throttle = require('./throttle');
+var clone = require('./clone');
+var defaults = require('./defaults');
+var calendar = require('./calendar');
+var momentum = require('./momentum');
+var classes = require('./classes');
+
+function inputCalendar (input, calendarOptions) {
+  var o = calendarOptions || {};
+
+  o.associated = input;
+
+  var api = calendar(o);
+  var throttledTakeInput = throttle(takeInput, 30);
+  var ignoreInvalidation;
+  var ignoreShow;
+  var eye;
+
+  init(o);
+
+  return api;
+
+  function init (initOptions) {
+    o = defaults(initOptions || o, api);
+
+    classes.add(api.container, o.styles.positioned);
+    crossvent.add(api.container, 'mousedown', containerMouseDown);
+    crossvent.add(api.container, 'click', containerClick);
+
+    api.getDate = unrequire(api.getDate);
+    api.getDateString = unrequire(api.getDateString);
+    api.getMoment = unrequire(api.getMoment);
+
+    if (o.initialValue) {
+      input.value = o.initialValue.format(o.inputFormat);
+    }
+
+    eye = bullseye(api.container, input);
+    api.on('data', updateInput);
+    api.on('show', eye.refresh);
+
+    eventListening();
+    throttledTakeInput();
+  }
+
+  function destroy () {
+    eventListening(true);
+    eye.destroy();
+    eye = null;
+  }
+
+  function eventListening (remove) {
+    var op = remove ? 'remove' : 'add';
+    crossvent[op](input, 'click', show);
+    crossvent[op](input, 'touchend', show);
+    crossvent[op](input, 'focusin', show);
+    crossvent[op](input, 'change', throttledTakeInput);
+    crossvent[op](input, 'keypress', throttledTakeInput);
+    crossvent[op](input, 'keydown', throttledTakeInput);
+    crossvent[op](input, 'input', throttledTakeInput);
+    if (o.invalidate) { crossvent[op](input, 'blur', invalidateInput); }
+
+    if (remove) {
+      api.once('ready', init);
+      api.off('destroyed', destroy);
+    } else {
+      api.off('ready', init);
+      api.once('destroyed', destroy);
+    }
+  }
+
+  function containerClick () {
+    ignoreShow = true;
+    input.focus();
+    ignoreShow = false;
+  }
+
+  function containerMouseDown () {
+    ignoreInvalidation = true;
+    setTimeout(unignore, 0);
+
+    function unignore () {
+      ignoreInvalidation = false;
+    }
+  }
+
+  function invalidateInput () {
+    if (!ignoreInvalidation && !isEmpty()) {
+      api.emitValues();
+    }
+  }
+
+  function show () {
+    if (ignoreShow) {
+      return;
+    }
+    api.show();
+  }
+
+  function takeInput () {
+    var value = input.value.trim();
+    if (isEmpty()) {
+      return;
+    }
+    var date = momentum.moment(value, o.inputFormat, o.strictParse);
+    api.setValue(date);
+  }
+
+  function updateInput (data) {
+    input.value = data;
+  }
+
+  function isEmpty () {
+    return o.required === false && input.value.trim() === '';
+  }
+
+  function unrequire (fn) {
+    return function maybe () {
+      return isEmpty() ? null : fn.apply(this, arguments);
+    };
+  }
+}
+
+module.exports = inputCalendar;
+
+},{"./calendar":21,"./classes":22,"./clone":23,"./defaults":25,"./momentum":31,"./throttle":46,"bullseye":1,"crossvent":18}],30:[function(require,module,exports){
+'use strict';
+
+function isInput (elem) {
+  return elem && elem.nodeName && elem.nodeName.toLowerCase() === 'input';
+}
+
+module.exports = isInput;
+
+},{}],31:[function(require,module,exports){
+'use strict';
+
+function isMoment (value) {
+  return value && Object.prototype.hasOwnProperty.call(value, '_isAMomentObject');
+}
+
+var api = {
+  moment: null,
+  isMoment: isMoment
+};
+
+module.exports = api;
+
+},{}],32:[function(require,module,exports){
+'use strict';
+
+function noop () {}
+
+module.exports = noop;
+
+},{}],33:[function(require,module,exports){
+'use strict';
+
+var momentum = require('./momentum');
+
+function raw (date, format) {
+  if (typeof date === 'string') {
+    return momentum.moment(date, format);
+  }
+  if (Object.prototype.toString.call(date) === '[object Date]') {
+    return momentum.moment(date);
+  }
+  if (momentum.isMoment(date)) {
+    return date.clone();
+  }
+}
+
+function parse (date, format) {
+  var m = raw(date, typeof format === 'string' ? format : null);
+  return m && m.isValid() ? m : null;
+}
+
+module.exports = parse;
+
+},{"./momentum":31}],34:[function(require,module,exports){
+'use strict';
+
+if (!Array.prototype.filter) {
+  Array.prototype.filter = function (fn, ctx) {
+    var f = [];
+    this.forEach(function (v, i, t) {
+      if (fn.call(ctx, v, i, t)) { f.push(v); }
+    }, ctx);
+    return f;
+  };
+}
+
+},{}],35:[function(require,module,exports){
+'use strict';
+
+if (!Array.prototype.forEach) {
+  Array.prototype.forEach = function (fn, ctx) {
+    if (this === void 0 || this === null || typeof fn !== 'function') {
+      throw new TypeError();
+    }
+    var t = this;
+    var len = t.length;
+    for (var i = 0; i < len; i++) {
+      if (i in t) { fn.call(ctx, t[i], i, t); }
+    }
+  };
+}
+
+},{}],36:[function(require,module,exports){
+'use strict';
+
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function (what, start) {
+    if (this === undefined || this === null) {
+      throw new TypeError();
+    }
+    var length = this.length;
+    start = +start || 0;
+    if (Math.abs(start) === Infinity) {
+      start = 0;
+    } else if (start < 0) {
+      start += length;
+      if (start < 0) { start = 0; }
+    }
+    for (; start < length; start++) {
+      if (this[start] === what) {
+        return start;
+      }
+    }
+    return -1;
+  };
+}
+
+},{}],37:[function(require,module,exports){
+'use strict';
+
+Array.isArray || (Array.isArray = function (a) {
+  return '' + a !== a && Object.prototype.toString.call(a) === '[object Array]';
+});
+
+},{}],38:[function(require,module,exports){
+'use strict';
+
+if (!Array.prototype.map) {
+  Array.prototype.map = function (fn, ctx) {
+    var context, result, i;
+
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    var source = Object(this);
+    var len = source.length >>> 0;
+
+    if (typeof fn !== 'function') {
+      throw new TypeError(fn + ' is not a function');
+    }
+
+    if (arguments.length > 1) {
+      context = ctx;
+    }
+
+    result = new Array(len);
+    i = 0;
+
+    while (i < len) {
+      if (i in source) {
+        result[i] = fn.call(context, source[i], i, source);
+      }
+      i++;
+    }
+    return result;
+  };
+}
+
+},{}],39:[function(require,module,exports){
+'use strict';
+
+if (!Array.prototype.some) {
+  Array.prototype.some = function (fn, ctx) {
+    var context, i;
+
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    var source = Object(this);
+    var len = source.length >>> 0;
+
+    if (typeof fn !== 'function') {
+      throw new TypeError(fn + ' is not a function');
+    }
+
+    if (arguments.length > 1) {
+      context = ctx;
+    }
+
+    i = 0;
+
+    while (i < len) {
+      if (i in source) {
+        var test = fn.call(context, source[i], i, source);
+        if (test) {
+          return true;
+        }
+      }
+      i++;
+    }
+    return false;
+  };
+}
+
+},{}],40:[function(require,module,exports){
+'use strict';
+
+if (!Function.prototype.bind) {
+  Function.prototype.bind = function (context) {
+    if (typeof this !== 'function') {
+      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
+    }
+    var curried = Array.prototype.slice.call(arguments, 1);
+    var original = this;
+    var NoOp = function () {};
+    var bound = function () {
+      var ctx = this instanceof NoOp && context ? this : context;
+      var args = curried.concat(Array.prototype.slice.call(arguments));
+      return original.apply(ctx, args);
+    };
+    NoOp.prototype = this.prototype;
+    bound.prototype = new NoOp();
+    return bound;
+  };
+}
+
+},{}],41:[function(require,module,exports){
+'use strict';
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString');
+var dontEnums = [
+  'toString',
+  'toLocaleString',
+  'valueOf',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'constructor'
+];
+var dontEnumsLength = dontEnums.length;
+
+if (!Object.keys) {
+  Object.keys = function(obj) {
+    if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
+      throw new TypeError('Object.keys called on non-object');
+    }
+
+    var result = [], prop, i;
+
+    for (prop in obj) {
+      if (hasOwn.call(obj, prop)) {
+        result.push(prop);
+      }
+    }
+
+    if (hasDontEnumBug) {
+      for (i = 0; i < dontEnumsLength; i++) {
+        if (hasOwn.call(obj, dontEnums[i])) {
+          result.push(dontEnums[i]);
+        }
+      }
+    }
+    return result;
+  };
+}
+
+},{}],42:[function(require,module,exports){
+'use strict';
+
+if (!String.prototype.trim) {
+  String.prototype.trim = function () {
+    return this.replace(/^\s+|\s+$/g, '');
+  };
+}
+
+},{}],43:[function(require,module,exports){
+'use strict';
+
+// these are only required for IE < 9
+// maybe move to IE-specific distro?
+require('./polyfills/function.bind');
+require('./polyfills/array.foreach');
+require('./polyfills/array.map');
+require('./polyfills/array.filter');
+require('./polyfills/array.isarray');
+require('./polyfills/array.indexof');
+require('./polyfills/array.some');
+require('./polyfills/string.trim');
+require('./polyfills/object.keys');
+
+var core = require('./core');
+var index = require('./index');
+var use = require('./use');
+
+core.use = use.bind(core);
+core.find = index.find;
+core.val = require('./validators');
+
+module.exports = core;
+
+},{"./core":24,"./index":27,"./polyfills/array.filter":34,"./polyfills/array.foreach":35,"./polyfills/array.indexof":36,"./polyfills/array.isarray":37,"./polyfills/array.map":38,"./polyfills/array.some":39,"./polyfills/function.bind":40,"./polyfills/object.keys":41,"./polyfills/string.trim":42,"./use":47,"./validators":48}],44:[function(require,module,exports){
+(function (global){
+var rome = require('./rome');
+var momentum = require('./momentum');
+
+rome.use(global.moment);
+
+if (momentum.moment === void 0) {
+  throw new Error('rome depends on moment.js, you can get it at http://momentjs.com, or you could use the bundled distribution file instead.');
+}
+
+module.exports = rome;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./momentum":31,"./rome":43}],45:[function(require,module,exports){
+'use strict';
+
+function text (elem, value) {
+  if (arguments.length === 2) {
+    elem.innerText = elem.textContent = value;
+  }
+  return elem.innerText || elem.textContent;
+}
+
+module.exports = text;
+
+},{}],46:[function(require,module,exports){
+'use strict';
+
+module.exports = function throttle (fn, boundary) {
+  var last = -Infinity;
+  var timer;
+  return function bounced () {
+    if (timer) {
+      return;
+    }
+    unbound();
+
+    function unbound () {
+      clearTimeout(timer);
+      timer = null;
+      var next = last + boundary;
+      var now = +new Date();
+      if (now > next) {
+        last = now;
+        fn.apply(this, arguments);
+      } else {
+        timer = setTimeout(unbound, next - now);
+      }
+    }
+  };
+};
+
+},{}],47:[function(require,module,exports){
+'use strict';
+
+var momentum = require('./momentum');
+
+function use (moment) {
+  this.moment = momentum.moment = moment;
+}
+
+module.exports = use;
+
+},{"./momentum":31}],48:[function(require,module,exports){
+'use strict';
+
+var index = require('./index');
+var parse = require('./parse');
+var association = require('./association');
+
+function compareBuilder (compare) {
+  return function factory (value) {
+    var fixed = parse(value);
+
+    return function validate (date) {
+      var cal = index.find(value);
+      var left = parse(date);
+      var right = fixed || cal && cal.getMoment();
+      if (!right) {
+        return true;
+      }
+      if (cal) {
+        association.add(this, cal);
+      }
+      return compare(left, right);
+    };
+  };
+}
+
+function rangeBuilder (how, compare) {
+  return function factory (start, end) {
+    var dates;
+    var len = arguments.length;
+
+    if (Array.isArray(start)) {
+      dates = start;
+    } else {
+      if (len === 1) {
+        dates = [start];
+      } else if (len === 2) {
+        dates = [[start, end]];
+      }
+    }
+
+    return function validate (date) {
+      return dates.map(expand.bind(this))[how](compare.bind(this, date));
+    };
+
+    function expand (value) {
+      var start, end;
+      var cal = index.find(value);
+      if (cal) {
+        start = end = cal.getMoment();
+      } else if (Array.isArray(value)) {
+        start = value[0]; end = value[1];
+      } else {
+        start = end = value;
+      }
+      if (cal) {
+        association.add(cal, this);
+      }
+      return {
+        start: parse(start).startOf('day').toDate(),
+        end: parse(end).endOf('day').toDate()
+      };
+    }
+  };
+}
+
+var afterEq  = compareBuilder(function (left, right) { return left >= right; });
+var after    = compareBuilder(function (left, right) { return left  > right; });
+var beforeEq = compareBuilder(function (left, right) { return left <= right; });
+var before   = compareBuilder(function (left, right) { return left  < right; });
+
+var except   = rangeBuilder('every', function (left, right) { return right.start  > left || right.end  < left; });
+var only     = rangeBuilder('some',  function (left, right) { return right.start <= left && right.end >= left; });
+
+module.exports = {
+  afterEq: afterEq,
+  after: after,
+  beforeEq: beforeEq,
+  before: before,
+  except: except,
+  only: only
+};
+
+},{"./association":20,"./index":27,"./parse":33}]},{},[44])(44)
+});
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/bullseye/bullseye.js","node_modules/bullseye/node_modules/seleccion/src/getSelection.js","node_modules/bullseye/node_modules/seleccion/src/getSelectionNullOp.js","node_modules/bullseye/node_modules/seleccion/src/getSelectionRaw.js","node_modules/bullseye/node_modules/seleccion/src/getSelectionSynthetic.js","node_modules/bullseye/node_modules/seleccion/src/isHost.js","node_modules/bullseye/node_modules/seleccion/src/rangeToTextRange.js","node_modules/bullseye/node_modules/seleccion/src/seleccion.js","node_modules/bullseye/node_modules/seleccion/src/setSelection.js","node_modules/bullseye/node_modules/sell/sell.js","node_modules/bullseye/tailormade.js","node_modules/bullseye/throttle.js","node_modules/contra/debounce.js","node_modules/contra/emitter.js","node_modules/contra/node_modules/atoa/atoa.js","node_modules/contra/node_modules/ticky/ticky-browser.js","node_modules/crossvent/node_modules/custom-event/index.js","node_modules/crossvent/src/crossvent.js","node_modules/crossvent/src/eventmap.js","src/association.js","src/calendar.js","src/classes.js","src/clone.js","src/core.js","src/defaults.js","src/dom.js","src/index.js","src/inline.js","src/input.js","src/isInput.js","src/momentum.js","src/noop.js","src/parse.js","src/polyfills/array.filter.js","src/polyfills/array.foreach.js","src/polyfills/array.indexof.js","src/polyfills/array.isarray.js","src/polyfills/array.map.js","src/polyfills/array.some.js","src/polyfills/function.bind.js","src/polyfills/object.keys.js","src/polyfills/string.trim.js","src/rome.js","src/rome.standalone.js","src/text.js","src/throttle.js","src/use.js","src/validators.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACj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nCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3pBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nvar crossvent = require('crossvent');\nvar throttle = require('./throttle');\nvar tailormade = require('./tailormade');\n\nfunction bullseye (el, target, options) {\n  var o = options;\n  var domTarget = target && target.tagName;\n\n  if (!domTarget && arguments.length === 2) {\n    o = target;\n  }\n  if (!domTarget) {\n    target = el;\n  }\n  if (!o) { o = {}; }\n\n  var destroyed = false;\n  var throttledWrite = throttle(write, 30);\n  var tailorOptions = { update: o.autoupdateToCaret !== false && update };\n  var tailor = o.caret && tailormade(target, tailorOptions);\n\n  write();\n\n  if (o.tracking !== false) {\n    crossvent.add(window, 'resize', throttledWrite);\n  }\n\n  return {\n    read: readNull,\n    refresh: write,\n    destroy: destroy,\n    sleep: sleep\n  };\n\n  function sleep () {\n    tailorOptions.sleeping = true;\n  }\n\n  function readNull () { return read(); }\n\n  function read (readings) {\n    var bounds = target.getBoundingClientRect();\n    var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;\n    if (tailor) {\n      readings = tailor.read();\n      return {\n        x: (readings.absolute ? 0 : bounds.left) + readings.x,\n        y: (readings.absolute ? 0 : bounds.top) + scrollTop + readings.y + 20\n      };\n    }\n    return {\n      x: bounds.left,\n      y: bounds.top + scrollTop\n    };\n  }\n\n  function update (readings) {\n    write(readings);\n  }\n\n  function write (readings) {\n    if (destroyed) {\n      throw new Error('Bullseye can\\'t refresh after being destroyed. Create another instance instead.');\n    }\n    if (tailor && !readings) {\n      tailorOptions.sleeping = false;\n      tailor.refresh(); return;\n    }\n    var p = read(readings);\n    if (!tailor && target !== el) {\n      p.y += target.offsetHeight;\n    }\n    el.style.left = p.x + 'px';\n    el.style.top = p.y + 'px';\n  }\n\n  function destroy () {\n    if (tailor) { tailor.destroy(); }\n    crossvent.remove(window, 'resize', throttledWrite);\n    destroyed = true;\n  }\n}\n\nmodule.exports = bullseye;\n","'use strict';\n\nvar getSelection;\nvar doc = global.document;\nvar getSelectionRaw = require('./getSelectionRaw');\nvar getSelectionNullOp = require('./getSelectionNullOp');\nvar getSelectionSynthetic = require('./getSelectionSynthetic');\nvar isHost = require('./isHost');\nif (isHost.method(global, 'getSelection')) {\n  getSelection = getSelectionRaw;\n} else if (typeof doc.selection === 'object' && doc.selection) {\n  getSelection = getSelectionSynthetic;\n} else {\n  getSelection = getSelectionNullOp;\n}\n\nmodule.exports = getSelection;\n","'use strict';\n\nfunction noop () {}\n\nfunction getSelectionNullOp () {\n  return {\n    removeAllRanges: noop,\n    addRange: noop\n  };\n}\n\nmodule.exports = getSelectionNullOp;\n","'use strict';\n\nfunction getSelectionRaw () {\n  return global.getSelection();\n}\n\nmodule.exports = getSelectionRaw;\n","'use strict';\n\nvar rangeToTextRange = require('./rangeToTextRange');\nvar doc = global.document;\nvar body = doc.body;\nvar GetSelectionProto = GetSelection.prototype;\n\nfunction GetSelection (selection) {\n  var self = this;\n  var range = selection.createRange();\n\n  this._selection = selection;\n  this._ranges = [];\n\n  if (selection.type === 'Control') {\n    updateControlSelection(self);\n  } else if (isTextRange(range)) {\n    updateFromTextRange(self, range);\n  } else {\n    updateEmptySelection(self);\n  }\n}\n\nGetSelectionProto.removeAllRanges = function () {\n  var textRange;\n  try {\n    this._selection.empty();\n    if (this._selection.type !== 'None') {\n      textRange = body.createTextRange();\n      textRange.select();\n      this._selection.empty();\n    }\n  } catch (e) {\n  }\n  updateEmptySelection(this);\n};\n\nGetSelectionProto.addRange = function (range) {\n  if (this._selection.type === 'Control') {\n    addRangeToControlSelection(this, range);\n  } else {\n    rangeToTextRange(range).select();\n    this._ranges[0] = range;\n    this.rangeCount = 1;\n    this.isCollapsed = this._ranges[0].collapsed;\n    updateAnchorAndFocusFromRange(this, range, false);\n  }\n};\n\nGetSelectionProto.setRanges = function (ranges) {\n  this.removeAllRanges();\n  var rangeCount = ranges.length;\n  if (rangeCount > 1) {\n    createControlSelection(this, ranges);\n  } else if (rangeCount) {\n    this.addRange(ranges[0]);\n  }\n};\n\nGetSelectionProto.getRangeAt = function (index) {\n  if (index < 0 || index >= this.rangeCount) {\n    throw new Error('getRangeAt(): index out of bounds');\n  } else {\n    return this._ranges[index].cloneRange();\n  }\n};\n\nGetSelectionProto.removeRange = function (range) {\n  if (this._selection.type !== 'Control') {\n    removeRangeManually(this, range);\n    return;\n  }\n  var controlRange = this._selection.createRange();\n  var rangeElement = getSingleElementFromRange(range);\n  var newControlRange = body.createControlRange();\n  var el;\n  var removed = false;\n  for (var i = 0, len = controlRange.length; i < len; ++i) {\n    el = controlRange.item(i);\n    if (el !== rangeElement || removed) {\n      newControlRange.add(controlRange.item(i));\n    } else {\n      removed = true;\n    }\n  }\n  newControlRange.select();\n  updateControlSelection(this);\n};\n\nGetSelectionProto.eachRange = function (fn, returnValue) {\n  var i = 0;\n  var len = this._ranges.length;\n  for (i = 0; i < len; ++i) {\n    if (fn(this.getRangeAt(i))) {\n      return returnValue;\n    }\n  }\n};\n\nGetSelectionProto.getAllRanges = function () {\n  var ranges = [];\n  this.eachRange(function (range) {\n    ranges.push(range);\n  });\n  return ranges;\n};\n\nGetSelectionProto.setSingleRange = function (range) {\n  this.removeAllRanges();\n  this.addRange(range);\n};\n\nfunction createControlSelection (sel, ranges) {\n  var controlRange = body.createControlRange();\n  for (var i = 0, el, len = ranges.length; i < len; ++i) {\n    el = getSingleElementFromRange(ranges[i]);\n    try {\n      controlRange.add(el);\n    } catch (e) {\n      throw new Error('setRanges(): Element could not be added to control selection');\n    }\n  }\n  controlRange.select();\n  updateControlSelection(sel);\n}\n\nfunction removeRangeManually (sel, range) {\n  var ranges = sel.getAllRanges();\n  sel.removeAllRanges();\n  for (var i = 0, len = ranges.length; i < len; ++i) {\n    if (!isSameRange(range, ranges[i])) {\n      sel.addRange(ranges[i]);\n    }\n  }\n  if (!sel.rangeCount) {\n    updateEmptySelection(sel);\n  }\n}\n\nfunction updateAnchorAndFocusFromRange (sel, range) {\n  var anchorPrefix = 'start';\n  var focusPrefix = 'end';\n  sel.anchorNode = range[anchorPrefix + 'Container'];\n  sel.anchorOffset = range[anchorPrefix + 'Offset'];\n  sel.focusNode = range[focusPrefix + 'Container'];\n  sel.focusOffset = range[focusPrefix + 'Offset'];\n}\n\nfunction updateEmptySelection (sel) {\n  sel.anchorNode = sel.focusNode = null;\n  sel.anchorOffset = sel.focusOffset = 0;\n  sel.rangeCount = 0;\n  sel.isCollapsed = true;\n  sel._ranges.length = 0;\n}\n\nfunction rangeContainsSingleElement (rangeNodes) {\n  if (!rangeNodes.length || rangeNodes[0].nodeType !== 1) {\n    return false;\n  }\n  for (var i = 1, len = rangeNodes.length; i < len; ++i) {\n    if (!isAncestorOf(rangeNodes[0], rangeNodes[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction getSingleElementFromRange (range) {\n  var nodes = range.getNodes();\n  if (!rangeContainsSingleElement(nodes)) {\n    throw new Error('getSingleElementFromRange(): range did not consist of a single element');\n  }\n  return nodes[0];\n}\n\nfunction isTextRange (range) {\n  return range && range.text !== void 0;\n}\n\nfunction updateFromTextRange (sel, range) {\n  sel._ranges = [range];\n  updateAnchorAndFocusFromRange(sel, range, false);\n  sel.rangeCount = 1;\n  sel.isCollapsed = range.collapsed;\n}\n\nfunction updateControlSelection (sel) {\n  sel._ranges.length = 0;\n  if (sel._selection.type === 'None') {\n    updateEmptySelection(sel);\n  } else {\n    var controlRange = sel._selection.createRange();\n    if (isTextRange(controlRange)) {\n      updateFromTextRange(sel, controlRange);\n    } else {\n      sel.rangeCount = controlRange.length;\n      var range;\n      for (var i = 0; i < sel.rangeCount; ++i) {\n        range = doc.createRange();\n        range.selectNode(controlRange.item(i));\n        sel._ranges.push(range);\n      }\n      sel.isCollapsed = sel.rangeCount === 1 && sel._ranges[0].collapsed;\n      updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);\n    }\n  }\n}\n\nfunction addRangeToControlSelection (sel, range) {\n  var controlRange = sel._selection.createRange();\n  var rangeElement = getSingleElementFromRange(range);\n  var newControlRange = body.createControlRange();\n  for (var i = 0, len = controlRange.length; i < len; ++i) {\n    newControlRange.add(controlRange.item(i));\n  }\n  try {\n    newControlRange.add(rangeElement);\n  } catch (e) {\n    throw new Error('addRange(): Element could not be added to control selection');\n  }\n  newControlRange.select();\n  updateControlSelection(sel);\n}\n\nfunction isSameRange (left, right) {\n  return (\n    left.startContainer === right.startContainer &&\n    left.startOffset === right.startOffset &&\n    left.endContainer === right.endContainer &&\n    left.endOffset === right.endOffset\n  );\n}\n\nfunction isAncestorOf (ancestor, descendant) {\n  var node = descendant;\n  while (node.parentNode) {\n    if (node.parentNode === ancestor) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n  return false;\n}\n\nfunction getSelection () {\n  return new GetSelection(global.document.selection);\n}\n\nmodule.exports = getSelection;\n","'use strict';\n\nfunction isHostMethod (host, prop) {\n  var type = typeof host[prop];\n  return type === 'function' || !!(type === 'object' && host[prop]) || type === 'unknown';\n}\n\nfunction isHostProperty (host, prop) {\n  return typeof host[prop] !== 'undefined';\n}\n\nfunction many (fn) {\n  return function areHosted (host, props) {\n    var i = props.length;\n    while (i--) {\n      if (!fn(host, props[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n}\n\nmodule.exports = {\n  method: isHostMethod,\n  methods: many(isHostMethod),\n  property: isHostProperty,\n  properties: many(isHostProperty)\n};\n","'use strict';\n\nvar doc = global.document;\nvar body = doc.body;\n\nfunction rangeToTextRange (p) {\n  if (p.collapsed) {\n    return createBoundaryTextRange({ node: p.startContainer, offset: p.startOffset }, true);\n  }\n  var startRange = createBoundaryTextRange({ node: p.startContainer, offset: p.startOffset }, true);\n  var endRange = createBoundaryTextRange({ node: p.endContainer, offset: p.endOffset }, false);\n  var textRange = body.createTextRange();\n  textRange.setEndPoint('StartToStart', startRange);\n  textRange.setEndPoint('EndToEnd', endRange);\n  return textRange;\n}\n\nfunction isCharacterDataNode (node) {\n  var t = node.nodeType;\n  return t === 3 || t === 4 || t === 8 ;\n}\n\nfunction createBoundaryTextRange (p, starting) {\n  var bound;\n  var parent;\n  var offset = p.offset;\n  var workingNode;\n  var childNodes;\n  var range = body.createTextRange();\n  var data = isCharacterDataNode(p.node);\n\n  if (data) {\n    bound = p.node;\n    parent = bound.parentNode;\n  } else {\n    childNodes = p.node.childNodes;\n    bound = offset < childNodes.length ? childNodes[offset] : null;\n    parent = p.node;\n  }\n\n  workingNode = doc.createElement('span');\n  workingNode.innerHTML = '&#feff;';\n\n  if (bound) {\n    parent.insertBefore(workingNode, bound);\n  } else {\n    parent.appendChild(workingNode);\n  }\n\n  range.moveToElementText(workingNode);\n  range.collapse(!starting);\n  parent.removeChild(workingNode);\n\n  if (data) {\n    range[starting ? 'moveStart' : 'moveEnd']('character', offset);\n  }\n  return range;\n}\n\nmodule.exports = rangeToTextRange;\n","'use strict';\n\nvar getSelection = require('./getSelection');\nvar setSelection = require('./setSelection');\n\nmodule.exports = {\n  get: getSelection,\n  set: setSelection\n};\n","'use strict';\n\nvar getSelection = require('./getSelection');\nvar rangeToTextRange = require('./rangeToTextRange');\nvar doc = global.document;\n\nfunction setSelection (p) {\n  if (doc.createRange) {\n    modernSelection();\n  } else {\n    oldSelection();\n  }\n\n  function modernSelection () {\n    var sel = getSelection();\n    var range = doc.createRange();\n    if (!p.startContainer) {\n      return;\n    }\n    if (p.endContainer) {\n      range.setEnd(p.endContainer, p.endOffset);\n    } else {\n      range.setEnd(p.startContainer, p.startOffset);\n    }\n    range.setStart(p.startContainer, p.startOffset);\n    sel.removeAllRanges();\n    sel.addRange(range);\n  }\n\n  function oldSelection () {\n    rangeToTextRange(p).select();\n  }\n}\n\nmodule.exports = setSelection;\n","'use strict';\n\nvar get = easyGet;\nvar set = easySet;\n\nif (document.selection && document.selection.createRange) {\n  get = hardGet;\n  set = hardSet;\n}\n\nfunction easyGet (el) {\n  return {\n    start: el.selectionStart,\n    end: el.selectionEnd\n  };\n}\n\nfunction hardGet (el) {\n  var active = document.activeElement;\n  if (active !== el) {\n    el.focus();\n  }\n\n  var range = document.selection.createRange();\n  var bookmark = range.getBookmark();\n  var original = el.value;\n  var marker = getUniqueMarker(original);\n  var parent = range.parentElement();\n  if (parent === null || !inputs(parent)) {\n    return result(0, 0);\n  }\n  range.text = marker + range.text + marker;\n\n  var contents = el.value;\n\n  el.value = original;\n  range.moveToBookmark(bookmark);\n  range.select();\n\n  return result(contents.indexOf(marker), contents.lastIndexOf(marker) - marker.length);\n\n  function result (start, end) {\n    if (active !== el) { // don't disrupt pre-existing state\n      if (active) {\n        active.focus();\n      } else {\n        el.blur();\n      }\n    }\n    return { start: start, end: end };\n  }\n}\n\nfunction getUniqueMarker (contents) {\n  var marker;\n  do {\n    marker = '@@marker.' + Math.random() * new Date();\n  } while (contents.indexOf(marker) !== -1);\n  return marker;\n}\n\nfunction inputs (el) {\n  return ((el.tagName === 'INPUT' && el.type === 'text') || el.tagName === 'TEXTAREA');\n}\n\nfunction easySet (el, p) {\n  el.selectionStart = parse(el, p.start);\n  el.selectionEnd = parse(el, p.end);\n}\n\nfunction hardSet (el, p) {\n  var range = el.createTextRange();\n\n  if (p.start === 'end' && p.end === 'end') {\n    range.collapse(false);\n    range.select();\n  } else {\n    range.collapse(true);\n    range.moveEnd('character', parse(el, p.end));\n    range.moveStart('character', parse(el, p.start));\n    range.select();\n  }\n}\n\nfunction parse (el, value) {\n  return value === 'end' ? el.value.length : value || 0;\n}\n\nfunction sell (el, p) {\n  if (arguments.length === 2) {\n    set(el, p);\n  }\n  return get(el);\n}\n\nmodule.exports = sell;\n","'use strict';\n\nvar sell = require('sell');\nvar crossvent = require('crossvent');\nvar seleccion = require('seleccion');\nvar throttle = require('./throttle');\nvar getSelection = seleccion.get;\nvar props = [\n  'direction',\n  'boxSizing',\n  'width',\n  'height',\n  'overflowX',\n  'overflowY',\n  'borderTopWidth',\n  'borderRightWidth',\n  'borderBottomWidth',\n  'borderLeftWidth',\n  'paddingTop',\n  'paddingRight',\n  'paddingBottom',\n  'paddingLeft',\n  'fontStyle',\n  'fontVariant',\n  'fontWeight',\n  'fontStretch',\n  'fontSize',\n  'fontSizeAdjust',\n  'lineHeight',\n  'fontFamily',\n  'textAlign',\n  'textTransform',\n  'textIndent',\n  'textDecoration',\n  'letterSpacing',\n  'wordSpacing'\n];\nvar win = global;\nvar doc = document;\nvar ff = win.mozInnerScreenX !== null && win.mozInnerScreenX !== void 0;\n\nfunction tailormade (el, options) {\n  var textInput = el.tagName === 'INPUT' || el.tagName === 'TEXTAREA';\n  var throttledRefresh = throttle(refresh, 30);\n  var o = options || {};\n\n  bind();\n\n  return {\n    read: readPosition,\n    refresh: throttledRefresh,\n    destroy: destroy\n  };\n\n  function noop () {}\n  function readPosition () { return (textInput ? coordsText : coordsHTML)(); }\n\n  function refresh () {\n    if (o.sleeping) {\n      return;\n    }\n    return (o.update || noop)(readPosition());\n  }\n\n  function coordsText () {\n    var p = sell(el);\n    var context = prepare();\n    var readings = readTextCoords(context, p.start);\n    doc.body.removeChild(context.mirror);\n    return readings;\n  }\n\n  function coordsHTML () {\n    var sel = getSelection();\n    if (sel.rangeCount) {\n      var range = sel.getRangeAt(0);\n      var needsToWorkAroundNewlineBug = range.startContainer.nodeName === 'P' && range.startOffset === 0;\n      if (needsToWorkAroundNewlineBug) {\n        return {\n          x: range.startContainer.offsetLeft,\n          y: range.startContainer.offsetTop,\n          absolute: true\n        };\n      }\n      if (range.getClientRects) {\n        var rects = range.getClientRects();\n        if (rects.length > 0) {\n          return {\n            x: rects[0].left,\n            y: rects[0].top,\n            absolute: true\n          };\n        }\n      }\n    }\n    return { x: 0, y: 0 };\n  }\n\n  function readTextCoords (context, p) {\n    var rest = doc.createElement('span');\n    var mirror = context.mirror;\n    var computed = context.computed;\n\n    write(mirror, read(el).substring(0, p));\n\n    if (el.tagName === 'INPUT') {\n      mirror.textContent = mirror.textContent.replace(/\\s/g, '\\u00a0');\n    }\n\n    write(rest, read(el).substring(p) || '.');\n\n    mirror.appendChild(rest);\n\n    return {\n      x: rest.offsetLeft + parseInt(computed['borderLeftWidth']),\n      y: rest.offsetTop + parseInt(computed['borderTopWidth'])\n    };\n  }\n\n  function read (el) {\n    return textInput ? el.value : el.innerHTML;\n  }\n\n  function prepare () {\n    var computed = win.getComputedStyle ? getComputedStyle(el) : el.currentStyle;\n    var mirror = doc.createElement('div');\n    var style = mirror.style;\n\n    doc.body.appendChild(mirror);\n\n    if (el.tagName !== 'INPUT') {\n      style.wordWrap = 'break-word';\n    }\n    style.whiteSpace = 'pre-wrap';\n    style.position = 'absolute';\n    style.visibility = 'hidden';\n    props.forEach(copy);\n\n    if (ff) {\n      style.width = parseInt(computed.width) - 2 + 'px';\n      if (el.scrollHeight > parseInt(computed.height)) {\n        style.overflowY = 'scroll';\n      }\n    } else {\n      style.overflow = 'hidden';\n    }\n    return { mirror: mirror, computed: computed };\n\n    function copy (prop) {\n      style[prop] = computed[prop];\n    }\n  }\n\n  function write (el, value) {\n    if (textInput) {\n      el.textContent = value;\n    } else {\n      el.innerHTML = value;\n    }\n  }\n\n  function bind (remove) {\n    var op = remove ? 'remove' : 'add';\n    crossvent[op](el, 'keydown', throttledRefresh);\n    crossvent[op](el, 'keyup', throttledRefresh);\n    crossvent[op](el, 'input', throttledRefresh);\n    crossvent[op](el, 'paste', throttledRefresh);\n    crossvent[op](el, 'change', throttledRefresh);\n  }\n\n  function destroy () {\n    bind(true);\n  }\n}\n\nmodule.exports = tailormade;\n","'use strict';\n\nfunction throttle (fn, boundary) {\n  var last = -Infinity;\n  var timer;\n  return function bounced () {\n    if (timer) {\n      return;\n    }\n    unbound();\n\n    function unbound () {\n      clearTimeout(timer);\n      timer = null;\n      var next = last + boundary;\n      var now = Date.now();\n      if (now > next) {\n        last = now;\n        fn();\n      } else {\n        timer = setTimeout(unbound, next - now);\n      }\n    }\n  };\n}\n\nmodule.exports = throttle;\n","'use strict';\n\nvar ticky = require('ticky');\n\nmodule.exports = function debounce (fn, args, ctx) {\n  if (!fn) { return; }\n  ticky(function run () {\n    fn.apply(ctx || null, args || []);\n  });\n};\n","'use strict';\n\nvar atoa = require('atoa');\nvar debounce = require('./debounce');\n\nmodule.exports = function emitter (thing, options) {\n  var opts = options || {};\n  var evt = {};\n  if (thing === undefined) { thing = {}; }\n  thing.on = function (type, fn) {\n    if (!evt[type]) {\n      evt[type] = [fn];\n    } else {\n      evt[type].push(fn);\n    }\n    return thing;\n  };\n  thing.once = function (type, fn) {\n    fn._once = true; // thing.off(fn) still works!\n    thing.on(type, fn);\n    return thing;\n  };\n  thing.off = function (type, fn) {\n    var c = arguments.length;\n    if (c === 1) {\n      delete evt[type];\n    } else if (c === 0) {\n      evt = {};\n    } else {\n      var et = evt[type];\n      if (!et) { return thing; }\n      et.splice(et.indexOf(fn), 1);\n    }\n    return thing;\n  };\n  thing.emit = function () {\n    var args = atoa(arguments);\n    return thing.emitterSnapshot(args.shift()).apply(this, args);\n  };\n  thing.emitterSnapshot = function (type) {\n    var et = (evt[type] || []).slice(0);\n    return function () {\n      var args = atoa(arguments);\n      var ctx = this || thing;\n      if (type === 'error' && opts.throws !== false && !et.length) { throw args.length === 1 ? args[0] : args; }\n      et.forEach(function emitter (listen) {\n        if (opts.async) { debounce(listen, args, ctx); } else { listen.apply(ctx, args); }\n        if (listen._once) { thing.off(type, listen); }\n      });\n      return thing;\n    };\n  };\n  return thing;\n};\n","module.exports = function atoa (a, n) { return Array.prototype.slice.call(a, n); }\n","var si = typeof setImmediate === 'function', tick;\nif (si) {\n  tick = function (fn) { setImmediate(fn); };\n} else {\n  tick = function (fn) { setTimeout(fn, 0); };\n}\n\nmodule.exports = tick;","\nvar NativeCustomEvent = global.CustomEvent;\n\nfunction useNative () {\n  try {\n    var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });\n    return  'cat' === p.type && 'bar' === p.detail.foo;\n  } catch (e) {\n  }\n  return false;\n}\n\n/**\n * Cross-browser `CustomEvent` constructor.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent\n *\n * @public\n */\n\nmodule.exports = useNative() ? NativeCustomEvent :\n\n// IE >= 9\n'function' === typeof document.createEvent ? function CustomEvent (type, params) {\n  var e = document.createEvent('CustomEvent');\n  if (params) {\n    e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);\n  } else {\n    e.initCustomEvent(type, false, false, void 0);\n  }\n  return e;\n} :\n\n// IE <= 8\nfunction CustomEvent (type, params) {\n  var e = document.createEventObject();\n  e.type = type;\n  if (params) {\n    e.bubbles = Boolean(params.bubbles);\n    e.cancelable = Boolean(params.cancelable);\n    e.detail = params.detail;\n  } else {\n    e.bubbles = false;\n    e.cancelable = false;\n    e.detail = void 0;\n  }\n  return e;\n}\n","'use strict';\n\nvar customEvent = require('custom-event');\nvar eventmap = require('./eventmap');\nvar doc = document;\nvar addEvent = addEventEasy;\nvar removeEvent = removeEventEasy;\nvar hardCache = [];\n\nif (!global.addEventListener) {\n  addEvent = addEventHard;\n  removeEvent = removeEventHard;\n}\n\nfunction addEventEasy (el, type, fn, capturing) {\n  return el.addEventListener(type, fn, capturing);\n}\n\nfunction addEventHard (el, type, fn) {\n  return el.attachEvent('on' + type, wrap(el, type, fn));\n}\n\nfunction removeEventEasy (el, type, fn, capturing) {\n  return el.removeEventListener(type, fn, capturing);\n}\n\nfunction removeEventHard (el, type, fn) {\n  return el.detachEvent('on' + type, unwrap(el, type, fn));\n}\n\nfunction fabricateEvent (el, type, model) {\n  var e = eventmap.indexOf(type) === -1 ? makeCustomEvent() : makeClassicEvent();\n  if (el.dispatchEvent) {\n    el.dispatchEvent(e);\n  } else {\n    el.fireEvent('on' + type, e);\n  }\n  function makeClassicEvent () {\n    var e;\n    if (doc.createEvent) {\n      e = doc.createEvent('Event');\n      e.initEvent(type, true, true);\n    } else if (doc.createEventObject) {\n      e = doc.createEventObject();\n    }\n    return e;\n  }\n  function makeCustomEvent () {\n    return new customEvent(type, { detail: model });\n  }\n}\n\nfunction wrapperFactory (el, type, fn) {\n  return function wrapper (originalEvent) {\n    var e = originalEvent || global.event;\n    e.target = e.target || e.srcElement;\n    e.preventDefault = e.preventDefault || function preventDefault () { e.returnValue = false; };\n    e.stopPropagation = e.stopPropagation || function stopPropagation () { e.cancelBubble = true; };\n    e.which = e.which || e.keyCode;\n    fn.call(el, e);\n  };\n}\n\nfunction wrap (el, type, fn) {\n  var wrapper = unwrap(el, type, fn) || wrapperFactory(el, type, fn);\n  hardCache.push({\n    wrapper: wrapper,\n    element: el,\n    type: type,\n    fn: fn\n  });\n  return wrapper;\n}\n\nfunction unwrap (el, type, fn) {\n  var i = find(el, type, fn);\n  if (i) {\n    var wrapper = hardCache[i].wrapper;\n    hardCache.splice(i, 1); // free up a tad of memory\n    return wrapper;\n  }\n}\n\nfunction find (el, type, fn) {\n  var i, item;\n  for (i = 0; i < hardCache.length; i++) {\n    item = hardCache[i];\n    if (item.element === el && item.type === type && item.fn === fn) {\n      return i;\n    }\n  }\n}\n\nmodule.exports = {\n  add: addEvent,\n  remove: removeEvent,\n  fabricate: fabricateEvent\n};\n","'use strict';\n\nvar eventmap = [];\nvar eventname = '';\nvar ron = /^on/;\n\nfor (eventname in global) {\n  if (ron.test(eventname)) {\n    eventmap.push(eventname.slice(2));\n  }\n}\n\nmodule.exports = eventmap;\n","'use strict';\n\nvar isInput = require('./isInput');\nvar bindings = {};\n\nfunction has (source, target) {\n  var binding = bindings[source.id];\n  return binding && binding[target.id];\n}\n\nfunction insert (source, target) {\n  var binding = bindings[source.id];\n  if (!binding) {\n    binding = bindings[source.id] = {};\n  }\n  var invalidate = invalidator(target);\n  binding[target.id] = invalidate;\n  source.on('data', invalidate);\n  source.on('destroyed', remove.bind(null, source, target));\n}\n\nfunction remove (source, target) {\n  var binding = bindings[source.id];\n  if (!binding) {\n    return;\n  }\n  var invalidate = binding[target.id];\n  source.off('data', invalidate);\n  delete binding[target.id];\n}\n\nfunction invalidator (target) {\n  return function invalidate () {\n    target.refresh();\n  };\n}\n\nfunction add (source, target) {\n  if (isInput(target.associated) || has(source, target)) {\n    return;\n  }\n  insert(source, target);\n}\n\nmodule.exports = {\n  add: add,\n  remove: remove\n};\n","'use strict';\n\nvar crossvent = require('crossvent');\nvar emitter = require('contra/emitter');\nvar dom = require('./dom');\nvar text = require('./text');\nvar parse = require('./parse');\nvar clone = require('./clone');\nvar defaults = require('./defaults');\nvar momentum = require('./momentum');\nvar classes = require('./classes');\nvar noop = require('./noop');\nvar no;\n\nfunction calendar (calendarOptions) {\n  var o;\n  var ref;\n  var refCal;\n  var container;\n  var rendered = false;\n\n  // date variables\n  var monthOffsetAttribute = 'data-rome-offset';\n  var weekdays;\n  var weekdayCount;\n  var calendarMonths = [];\n  var lastYear;\n  var lastMonth;\n  var lastDay;\n  var lastDayElement;\n  var datewrapper;\n  var back;\n  var next;\n\n  // time variables\n  var secondsInDay = 60 * 60 * 24;\n  var time;\n  var timelist;\n\n  var api = emitter({\n    associated: calendarOptions.associated\n  });\n\n  init();\n  setTimeout(ready, 0);\n\n  return api;\n\n  function napi () { return api; }\n\n  function init (initOptions) {\n    o = defaults(initOptions || calendarOptions, api);\n    if (!container) { container = dom({ className: o.styles.container }); }\n    weekdays = o.weekdayFormat;\n    weekdayCount = weekdays.length;\n    lastMonth = no;\n    lastYear = no;\n    lastDay = no;\n    lastDayElement = no;\n    o.appendTo.appendChild(container);\n\n    removeChildren(container);\n    rendered = false;\n    ref = o.initialValue ? o.initialValue : momentum.moment();\n    refCal = ref.clone();\n\n    api.back = subtractMonth;\n    api.container = container;\n    api.destroyed = false;\n    api.destroy = destroy.bind(api, false);\n    api.emitValues = emitValues;\n    api.getDate = getDate;\n    api.getDateString = getDateString;\n    api.getMoment = getMoment;\n    api.hide = hide;\n    api.next = addMonth;\n    api.options = changeOptions;\n    api.options.reset = resetOptions;\n    api.refresh = refresh;\n    api.restore = napi;\n    api.setValue = setValue;\n    api.show = show;\n\n    eventListening();\n    ready();\n\n    return api;\n  }\n\n  function ready () {\n    api.emit('ready', clone(o));\n  }\n\n  function destroy (silent) {\n    if (container && container.parentNode) {\n      container.parentNode.removeChild(container);\n    }\n\n    if (o) {\n      eventListening(true);\n    }\n\n    var destroyed = api.emitterSnapshot('destroyed');\n    api.back = noop;\n    api.destroyed = true;\n    api.destroy = napi;\n    api.emitValues = napi;\n    api.getDate = noop;\n    api.getDateString = noop;\n    api.getMoment = noop;\n    api.hide = napi;\n    api.next = noop;\n    api.options = napi;\n    api.options.reset = napi;\n    api.refresh = napi;\n    api.restore = init;\n    api.setValue = napi;\n    api.show = napi;\n    api.off();\n\n    if (silent !== true) {\n      destroyed();\n    }\n\n    return api;\n  }\n\n  function eventListening (remove) {\n    var op = remove ? 'remove' : 'add';\n    if (o.autoHideOnBlur) { crossvent[op](document.documentElement, 'focus', hideOnBlur, true); }\n    if (o.autoHideOnClick) { crossvent[op](document, 'click', hideOnClick); }\n  }\n\n  function changeOptions (options) {\n    if (arguments.length === 0) {\n      return clone(o);\n    }\n    destroy();\n    init(options);\n    return api;\n  }\n\n  function resetOptions () {\n    return changeOptions({ appendTo: o.appendTo });\n  }\n\n  function render () {\n    if (rendered) {\n      return;\n    }\n    rendered = true;\n    renderDates();\n    renderTime();\n    api.emit('render');\n  }\n\n  function renderDates () {\n    if (!o.date) {\n      return;\n    }\n    var i;\n    calendarMonths = [];\n\n    datewrapper = dom({ className: o.styles.date, parent: container });\n\n    for (i = 0; i < o.monthsInCalendar; i++) {\n      renderMonth(i);\n    }\n\n    crossvent.add(back, 'click', subtractMonth);\n    crossvent.add(next, 'click', addMonth);\n    crossvent.add(datewrapper, 'click', pickDay);\n\n    function renderMonth (i) {\n      var month = dom({ className: o.styles.month, parent: datewrapper });\n      if (i === 0) {\n        back = dom({ type: 'button', className: o.styles.back, attributes: { type: 'button' }, parent: month });\n      }\n      if (i === o.monthsInCalendar -1) {\n        next = dom({ type: 'button', className: o.styles.next, attributes: { type: 'button' }, parent: month });\n      }\n      var label = dom({ className: o.styles.monthLabel, parent: month });\n      var date = dom({ type: 'table', className: o.styles.dayTable, parent: month });\n      var datehead = dom({ type: 'thead', className: o.styles.dayHead, parent: date });\n      var dateheadrow = dom({ type: 'tr', className: o.styles.dayRow, parent: datehead });\n      var datebody = dom({ type: 'tbody', className: o.styles.dayBody, parent: date });\n      var j;\n\n      for (j = 0; j < weekdayCount; j++) {\n        dom({ type: 'th', className: o.styles.dayHeadElem, parent: dateheadrow, text: weekdays[weekday(j)] });\n      }\n\n      datebody.setAttribute(monthOffsetAttribute, i);\n      calendarMonths.push({\n        label: label,\n        body: datebody\n      });\n    }\n  }\n\n  function renderTime () {\n    if (!o.time || !o.timeInterval) {\n      return;\n    }\n    var timewrapper = dom({ className: o.styles.time, parent: container });\n    time = dom({ className: o.styles.selectedTime, parent: timewrapper, text: ref.format(o.timeFormat) });\n    crossvent.add(time, 'click', toggleTimeList);\n    timelist = dom({ className: o.styles.timeList, parent: timewrapper });\n    crossvent.add(timelist, 'click', pickTime);\n    var next = momentum.moment('00:00:00', 'HH:mm:ss');\n    var latest = next.clone().add(1, 'days');\n    while (next.isBefore(latest)) {\n      dom({ className: o.styles.timeOption, parent: timelist, text: next.format(o.timeFormat) });\n      next.add(o.timeInterval, 'seconds');\n    }\n  }\n\n  function weekday (index, backwards) {\n    var factor = backwards ? -1 : 1;\n    var offset = index + o.weekStart * factor;\n    if (offset >= weekdayCount || offset < 0) {\n      offset += weekdayCount * -factor;\n    }\n    return offset;\n  }\n\n  function displayValidTimesOnly () {\n    if (!o.time || !rendered) {\n      return;\n    }\n    var times = timelist.children;\n    var length = times.length;\n    var date;\n    var time;\n    var item;\n    var i;\n    for (i = 0; i < length; i++) {\n      item = times[i];\n      time = momentum.moment(text(item), o.timeFormat);\n      date = setTime(ref.clone(), time);\n      item.style.display = isInRange(date, false, o.timeValidator) ? 'block' : 'none';\n    }\n  }\n\n  function toggleTimeList (show) {\n    var display = typeof show === 'boolean' ? show : timelist.style.display === 'none';\n    if (display) {\n      showTimeList();\n    } else {\n      hideTimeList();\n    }\n  }\n\n  function showTimeList () { if (timelist) { timelist.style.display = 'block'; } }\n  function hideTimeList () { if (timelist) { timelist.style.display = 'none'; } }\n  function showCalendar () { container.style.display = 'inline-block'; api.emit('show'); }\n  function hideCalendar () {\n    if (container.style.display !== 'none') {\n      container.style.display = 'none';\n      api.emit('hide');\n    }\n  }\n\n  function show () {\n    render();\n    refresh();\n    toggleTimeList(!o.date);\n    showCalendar();\n    return api;\n  }\n\n  function hide () {\n    hideTimeList();\n    setTimeout(hideCalendar, 0);\n    return api;\n  }\n\n  function hideConditionally () {\n    hideTimeList();\n\n    var pos = classes.contains(container, o.styles.positioned);\n    if (pos) {\n      setTimeout(hideCalendar, 0);\n    }\n    return api;\n  }\n\n  function calendarEventTarget (e) {\n    var target = e.target;\n    if (target === api.associated) {\n      return true;\n    }\n    while (target) {\n      if (target === container) {\n        return true;\n      }\n      target = target.parentNode;\n    }\n  }\n\n  function hideOnBlur (e) {\n    if (calendarEventTarget(e)) {\n      return;\n    }\n    hideConditionally();\n  }\n\n  function hideOnClick (e) {\n    if (calendarEventTarget(e)) {\n      return;\n    }\n    hideConditionally();\n  }\n\n  function subtractMonth () { changeMonth('subtract'); }\n  function addMonth () { changeMonth('add'); }\n  function changeMonth (op) {\n    var bound;\n    var direction = op === 'add' ? -1 : 1;\n    var offset = o.monthsInCalendar + direction * getMonthOffset(lastDayElement);\n    refCal[op](offset, 'months');\n    bound = inRange(refCal.clone());\n    ref = bound || ref;\n    if (bound) { refCal = bound.clone(); }\n    update();\n    api.emit(op === 'add' ? 'next' : 'back', ref.month());\n  }\n\n  function update (silent) {\n    updateCalendar();\n    updateTime();\n    if (silent !== true) { emitValues(); }\n    displayValidTimesOnly();\n  }\n\n  function updateCalendar () {\n    if (!o.date || !rendered) {\n      return;\n    }\n    var y = refCal.year();\n    var m = refCal.month();\n    var d = refCal.date();\n    if (d === lastDay && m === lastMonth && y === lastYear) {\n      return;\n    }\n    var canStay = isDisplayed();\n    lastDay = refCal.date();\n    lastMonth = refCal.month();\n    lastYear = refCal.year();\n    if (canStay) { updateCalendarSelection(); return; }\n    calendarMonths.forEach(updateMonth);\n    renderAllDays();\n\n    function updateMonth (month, i) {\n      var offsetCal = refCal.clone().add(i, 'months');\n      text(month.label, offsetCal.format(o.monthFormat));\n      removeChildren(month.body);\n    }\n  }\n\n  function updateCalendarSelection () {\n    var day = refCal.date() - 1;\n    selectDayElement(false);\n    calendarMonths.forEach(function (cal) {\n      var days;\n      if (sameCalendarMonth(cal.date, refCal)) {\n        days = cast(cal.body.children).map(aggregate);\n        days = Array.prototype.concat.apply([], days).filter(inside);\n        selectDayElement(days[day]);\n      }\n    });\n\n    function cast (like) {\n      var dest = [];\n      var i;\n      for (i = 0; i < like.length; i++) {\n        dest.push(like[i]);\n      }\n      return dest;\n    }\n\n    function aggregate (child) {\n      return cast(child.children);\n    }\n\n    function inside (child) {\n      return !classes.contains(child, o.styles.dayPrevMonth) &&\n             !classes.contains(child, o.styles.dayNextMonth);\n    }\n  }\n\n  function isDisplayed () {\n    return calendarMonths.some(matches);\n\n    function matches (cal) {\n      if (!lastYear) { return false; }\n      return sameCalendarMonth(cal.date, refCal);\n    }\n  }\n\n  function sameCalendarMonth (left, right) {\n    return left && right && left.year() === right.year() && left.month() === right.month();\n  }\n\n  function updateTime () {\n    if (!o.time || !rendered) {\n      return;\n    }\n    text(time, ref.format(o.timeFormat));\n  }\n\n  function emitValues () {\n    api.emit('data', getDateString());\n    api.emit('year', ref.year());\n    api.emit('month', ref.month());\n    api.emit('day', ref.day());\n    api.emit('time', ref.format(o.timeFormat));\n    return api;\n  }\n\n  function refresh () {\n    lastYear = false;\n    lastMonth = false;\n    lastDay = false;\n    update(true);\n    return api;\n  }\n\n  function setValue (value) {\n    var date = parse(value, o.inputFormat);\n    if (date === null) {\n      return;\n    }\n    ref = inRange(date) || ref;\n    refCal = ref.clone();\n    update(true);\n\n    return api;\n  }\n\n  function removeChildren (elem, self) {\n    while (elem && elem.firstChild) {\n      elem.removeChild(elem.firstChild);\n    }\n    if (self === true) {\n      elem.parentNode.removeChild(elem);\n    }\n  }\n\n  function renderAllDays () {\n    var i;\n    for (i = 0; i < o.monthsInCalendar; i++) {\n      renderDays(i);\n    }\n  }\n\n  function renderDays (offset) {\n    var month = calendarMonths[offset];\n    var offsetCal = refCal.clone().add(offset, 'months');\n    var total = offsetCal.daysInMonth();\n    var current = offsetCal.month() !== ref.month() ? -1 : ref.date(); // -1 : 1..31\n    var first = offsetCal.clone().date(1);\n    var firstDay = weekday(first.day(), true); // 0..6\n    var tr = dom({ type: 'tr', className: o.styles.dayRow, parent: month.body });\n    var prevMonth = hiddenWhen(offset !== 0, [o.styles.dayBodyElem, o.styles.dayPrevMonth]);\n    var nextMonth = hiddenWhen(offset !== o.monthsInCalendar - 1, [o.styles.dayBodyElem, o.styles.dayNextMonth]);\n    var disabled = o.styles.dayDisabled;\n    var lastDay;\n\n    part({\n      base: first.clone().subtract(firstDay, 'days'),\n      length: firstDay,\n      cell: prevMonth\n    });\n\n    part({\n      base: first.clone(),\n      length: total,\n      cell: [o.styles.dayBodyElem],\n      selectable: true\n    });\n\n    lastDay = first.clone().add(total, 'days');\n\n    part({\n      base: lastDay,\n      length: weekdayCount - tr.children.length,\n      cell: nextMonth\n    });\n\n    back.disabled = !isInRangeLeft(first, true);\n    next.disabled = !isInRangeRight(lastDay, true);\n    month.date = offsetCal.clone();\n\n    function part (data) {\n      var i, day, node;\n      for (i = 0; i < data.length; i++) {\n        if (tr.children.length === weekdayCount) {\n          tr = dom({ type: 'tr', className: o.styles.dayRow, parent: month.body });\n        }\n        day = data.base.clone().add(i, 'days');\n        node = dom({\n          type: 'td',\n          parent: tr,\n          text: day.format(o.dayFormat),\n          className: validationTest(day, data.cell.join(' ').split(' ')).join(' ')\n        });\n        if (data.selectable && day.date() === current) {\n          selectDayElement(node);\n        }\n      }\n    }\n\n    function validationTest (day, cell) {\n      if (!isInRange(day, true, o.dateValidator)) { cell.push(disabled); }\n      return cell;\n    }\n\n    function hiddenWhen (value, cell) {\n      if (value) { cell.push(o.styles.dayConcealed); }\n      return cell;\n    }\n  }\n\n  function isInRange (date, allday, validator) {\n    if (!isInRangeLeft(date, allday)) {\n      return false;\n    }\n    if (!isInRangeRight(date, allday)) {\n      return false;\n    }\n    var valid = (validator || Function.prototype).call(api, date.toDate());\n    return valid !== false;\n  }\n\n  function isInRangeLeft (date, allday) {\n    var min = !o.min ? false : (allday ? o.min.clone().startOf('day') : o.min);\n    return !min || !date.isBefore(min);\n  }\n\n  function isInRangeRight (date, allday) {\n    var max = !o.max ? false : (allday ? o.max.clone().endOf('day') : o.max);\n    return !max || !date.isAfter(max);\n  }\n\n  function inRange (date) {\n    if (o.min && date.isBefore(o.min)) {\n      return inRange(o.min.clone());\n    } else if (o.max && date.isAfter(o.max)) {\n      return inRange(o.max.clone());\n    }\n    var value = date.clone().subtract(1, 'days');\n    if (validateTowards(value, date, 'add')) {\n      return inTimeRange(value);\n    }\n    value = date.clone();\n    if (validateTowards(value, date, 'subtract')) {\n      return inTimeRange(value);\n    }\n  }\n\n  function inTimeRange (value) {\n    var copy = value.clone().subtract(o.timeInterval, 'seconds');\n    var times = Math.ceil(secondsInDay / o.timeInterval);\n    var i;\n    for (i = 0; i < times; i++) {\n      copy.add(o.timeInterval, 'seconds');\n      if (copy.date() > value.date()) {\n        copy.subtract(1, 'days');\n      }\n      if (o.timeValidator.call(api, copy.toDate()) !== false) {\n        return copy;\n      }\n    }\n  }\n\n  function validateTowards (value, date, op) {\n    var valid = false;\n    while (valid === false) {\n      value[op](1, 'days');\n      if (value.month() !== date.month()) {\n        break;\n      }\n      valid = o.dateValidator.call(api, value.toDate());\n    }\n    return valid !== false;\n  }\n\n  function pickDay (e) {\n    var target = e.target;\n    if (classes.contains(target, o.styles.dayDisabled) || !classes.contains(target, o.styles.dayBodyElem)) {\n      return;\n    }\n    var day = parseInt(text(target), 10);\n    var prev = classes.contains(target, o.styles.dayPrevMonth);\n    var next = classes.contains(target, o.styles.dayNextMonth);\n    var offset = getMonthOffset(target) - getMonthOffset(lastDayElement);\n    ref.add(offset, 'months');\n    if (prev || next) {\n      ref.add(prev ? -1 : 1, 'months');\n    }\n    selectDayElement(target);\n    ref.date(day); // must run after setting the month\n    setTime(ref, inRange(ref) || ref);\n    refCal = ref.clone();\n    if (o.autoClose === true) { hideConditionally(); }\n    update();\n  }\n\n  function selectDayElement (node) {\n    if (lastDayElement) {\n      classes.remove(lastDayElement, o.styles.selectedDay);\n    }\n    if (node) {\n      classes.add(node, o.styles.selectedDay);\n    }\n    lastDayElement = node;\n  }\n\n  function getMonthOffset (elem) {\n    var offset;\n    while (elem && elem.getAttribute) {\n      offset = elem.getAttribute(monthOffsetAttribute);\n      if (typeof offset === 'string') {\n        return parseInt(offset, 10);\n      }\n      elem = elem.parentNode;\n    }\n    return 0;\n  }\n\n  function setTime (to, from) {\n    to.hour(from.hour()).minute(from.minute()).second(from.second());\n    return to;\n  }\n\n  function pickTime (e) {\n    var target = e.target;\n    if (!classes.contains(target, o.styles.timeOption)) {\n      return;\n    }\n    var value = momentum.moment(text(target), o.timeFormat);\n    setTime(ref, value);\n    refCal = ref.clone();\n    emitValues();\n    updateTime();\n    if ((!o.date && o.autoClose === true) || o.autoClose === 'time') {\n      hideConditionally();\n    } else {\n      hideTimeList();\n    }\n  }\n\n  function getDate () {\n    return ref.toDate();\n  }\n\n  function getDateString (format) {\n    return ref.format(format || o.inputFormat);\n  }\n\n  function getMoment () {\n    return ref.clone();\n  }\n}\n\nmodule.exports = calendar;\n","'use strict';\n\nvar trim = /^\\s+|\\s+$/g;\nvar whitespace = /\\s+/;\n\nfunction classes (node) {\n  return node.className.replace(trim, '').split(whitespace);\n}\n\nfunction set (node, value) {\n  node.className = value.join(' ');\n}\n\nfunction add (node, value) {\n  var values = remove(node, value);\n  values.push(value);\n  set(node, values);\n}\n\nfunction remove (node, value) {\n  var values = classes(node);\n  var i = values.indexOf(value);\n  if (i !== -1) {\n    values.splice(i, 1);\n    set(node, values);\n  }\n  return values;\n}\n\nfunction contains (node, value) {\n  return classes(node).indexOf(value) !== -1;\n}\n\nmodule.exports = {\n  add: add,\n  remove: remove,\n  contains: contains\n};\n","'use strict';\n\nvar momentum = require('./momentum');\n\n// naïve implementation, specifically meant to clone `options` objects\nfunction clone (thing) {\n  var copy = {};\n  var value;\n\n  for (var key in thing) {\n    value = thing[key];\n\n    if (!value) {\n      copy[key] = value;\n    } else if (momentum.isMoment(value)) {\n      copy[key] = value.clone();\n    } else if (value._isStylesConfiguration) {\n      copy[key] = clone(value);\n    } else {\n      copy[key] = value;\n    }\n  }\n\n  return copy;\n}\n\nmodule.exports = clone;\n","'use strict';\n\nvar index = require('./index');\nvar input = require('./input');\nvar inline = require('./inline');\nvar isInput = require('./isInput');\n\nfunction core (elem, options) {\n  var cal;\n  var existing = index.find(elem);\n  if (existing) {\n    return existing;\n  }\n\n  if (isInput(elem)) {\n    cal = input(elem, options);\n  } else {\n    cal = inline(elem, options);\n  }\n  index.assign(elem, cal);\n\n  return cal;\n}\n\nmodule.exports = core;\n","'use strict';\n\nvar parse = require('./parse');\nvar isInput = require('./isInput');\nvar momentum = require('./momentum');\n\nfunction defaults (options, cal) {\n  var temp;\n  var no;\n  var o = options || {};\n  if (o.autoHideOnClick === no) { o.autoHideOnClick = true; }\n  if (o.autoHideOnBlur === no) { o.autoHideOnBlur = true; }\n  if (o.autoClose === no) { o.autoClose = true; }\n  if (o.appendTo === no) { o.appendTo = document.body; }\n  if (o.appendTo === 'parent') {\n    if (isInput(cal.associated)) {\n      o.appendTo = cal.associated.parentNode;\n    } else {\n      throw new Error('Inline calendars must be appended to a parent node explicitly.');\n    }\n  }\n  if (o.invalidate === no) { o.invalidate = true; }\n  if (o.required === no) { o.required = false; }\n  if (o.date === no) { o.date = true; }\n  if (o.time === no) { o.time = true; }\n  if (o.date === false && o.time === false) { throw new Error('At least one of `date` or `time` must be `true`.'); }\n  if (o.inputFormat === no) {\n    if (o.date && o.time) {\n      o.inputFormat = 'YYYY-MM-DD HH:mm';\n    } else if (o.date) {\n      o.inputFormat = 'YYYY-MM-DD';\n    } else {\n      o.inputFormat = 'HH:mm';\n    }\n  }\n  if (o.initialValue === no) {\n    o.initialValue = null;\n  } else {\n    o.initialValue = parse(o.initialValue, o.inputFormat);\n  }\n  if (o.min === no) { o.min = null; } else { o.min = parse(o.min, o.inputFormat); }\n  if (o.max === no) { o.max = null; } else { o.max = parse(o.max, o.inputFormat); }\n  if (o.timeInterval === no) { o.timeInterval = 60 * 30; } // 30 minutes by default\n  if (o.min && o.max) {\n    if (o.max.isBefore(o.min)) {\n      temp = o.max;\n      o.max = o.min;\n      o.min = temp;\n    }\n    if (o.date === true) {\n      if (o.max.clone().subtract(1, 'days').isBefore(o.min)) {\n        throw new Error('`max` must be at least one day after `min`');\n      }\n    } else if (o.timeInterval * 1000 - o.min % (o.timeInterval * 1000) > o.max - o.min) {\n      throw new Error('`min` to `max` range must allow for at least one time option that matches `timeInterval`');\n    }\n  }\n  if (o.dateValidator === no) { o.dateValidator = Function.prototype; }\n  if (o.timeValidator === no) { o.timeValidator = Function.prototype; }\n  if (o.timeFormat === no) { o.timeFormat = 'HH:mm'; }\n  if (o.weekStart === no) { o.weekStart = momentum.moment().weekday(0).day(); }\n  if (o.weekdayFormat === no) { o.weekdayFormat = 'min'; }\n  if (o.weekdayFormat === 'long') {\n    o.weekdayFormat = momentum.moment.weekdays();\n  } else if (o.weekdayFormat === 'short') {\n    o.weekdayFormat = momentum.moment.weekdaysShort();\n  } else if (o.weekdayFormat === 'min') {\n    o.weekdayFormat = momentum.moment.weekdaysMin();\n  } else if (!Array.isArray(o.weekdayFormat) || o.weekdayFormat.length < 7) {\n    throw new Error('`weekdays` must be `min`, `short`, or `long`');\n  }\n  if (o.monthsInCalendar === no) { o.monthsInCalendar = 1; }\n  if (o.monthFormat === no) { o.monthFormat = 'MMMM YYYY'; }\n  if (o.dayFormat === no) { o.dayFormat = 'DD'; }\n  if (o.styles === no) { o.styles = {}; }\n\n  o.styles._isStylesConfiguration = true;\n\n  var styl = o.styles;\n  if (styl.back === no) { styl.back = 'rd-back'; }\n  if (styl.container === no) { styl.container = 'rd-container'; }\n  if (styl.positioned === no) { styl.positioned = 'rd-container-attachment'; }\n  if (styl.date === no) { styl.date = 'rd-date'; }\n  if (styl.dayBody === no) { styl.dayBody = 'rd-days-body'; }\n  if (styl.dayBodyElem === no) { styl.dayBodyElem = 'rd-day-body'; }\n  if (styl.dayPrevMonth === no) { styl.dayPrevMonth = 'rd-day-prev-month'; }\n  if (styl.dayNextMonth === no) { styl.dayNextMonth = 'rd-day-next-month'; }\n  if (styl.dayDisabled === no) { styl.dayDisabled = 'rd-day-disabled'; }\n  if (styl.dayConcealed === no) { styl.dayConcealed = 'rd-day-concealed'; }\n  if (styl.dayHead === no) { styl.dayHead = 'rd-days-head'; }\n  if (styl.dayHeadElem === no) { styl.dayHeadElem = 'rd-day-head'; }\n  if (styl.dayRow === no) { styl.dayRow = 'rd-days-row'; }\n  if (styl.dayTable === no) { styl.dayTable = 'rd-days'; }\n  if (styl.month === no) { styl.month = 'rd-month'; }\n  if (styl.monthLabel === no) { styl.monthLabel = 'rd-month-label'; }\n  if (styl.next === no) { styl.next = 'rd-next'; }\n  if (styl.selectedDay === no) { styl.selectedDay = 'rd-day-selected'; }\n  if (styl.selectedTime === no) { styl.selectedTime = 'rd-time-selected'; }\n  if (styl.time === no) { styl.time = 'rd-time'; }\n  if (styl.timeList === no) { styl.timeList = 'rd-time-list'; }\n  if (styl.timeOption === no) { styl.timeOption = 'rd-time-option'; }\n\n  return o;\n}\n\nmodule.exports = defaults;\n","'use strict';\n\nfunction dom (options) {\n  var o = options || {};\n  if (!o.type) { o.type = 'div'; }\n  var elem = document.createElement(o.type);\n  if (o.className) { elem.className = o.className; }\n  if (o.text) { elem.innerText = elem.textContent = o.text; }\n  if (o.attributes) {\n    Object.keys(o.attributes).forEach(function(key) {\n      elem.setAttribute(key, o.attributes[key]);\n    });\n  }\n  if (o.parent) { o.parent.appendChild(elem); }\n  return elem;\n}\n\nmodule.exports = dom;\n","'use strict';\nvar no;\nvar ikey = 'data-rome-id';\nvar index = [];\n\nfunction find (thing) { // can be a DOM element or a number\n  if (typeof thing !== 'number' && thing && thing.getAttribute) {\n    return find(thing.getAttribute(ikey));\n  }\n  var existing = index[thing];\n  if (existing !== no) {\n    return existing;\n  }\n  return null;\n}\n\nfunction assign (elem, instance) {\n  elem.setAttribute(ikey, instance.id = index.push(instance) - 1);\n}\n\nmodule.exports = {\n  find: find,\n  assign: assign\n};\n","'use strict';\n\nvar calendar = require('./calendar');\n\nfunction inline (elem, calendarOptions) {\n  var o = calendarOptions || {};\n\n  o.appendTo = elem;\n  o.associated = elem;\n\n  var cal = calendar(o);\n  cal.show();\n  return cal;\n}\n\nmodule.exports = inline;\n","'use strict';\n\nvar crossvent = require('crossvent');\nvar bullseye = require('bullseye');\nvar throttle = require('./throttle');\nvar clone = require('./clone');\nvar defaults = require('./defaults');\nvar calendar = require('./calendar');\nvar momentum = require('./momentum');\nvar classes = require('./classes');\n\nfunction inputCalendar (input, calendarOptions) {\n  var o = calendarOptions || {};\n\n  o.associated = input;\n\n  var api = calendar(o);\n  var throttledTakeInput = throttle(takeInput, 30);\n  var ignoreInvalidation;\n  var ignoreShow;\n  var eye;\n\n  init(o);\n\n  return api;\n\n  function init (initOptions) {\n    o = defaults(initOptions || o, api);\n\n    classes.add(api.container, o.styles.positioned);\n    crossvent.add(api.container, 'mousedown', containerMouseDown);\n    crossvent.add(api.container, 'click', containerClick);\n\n    api.getDate = unrequire(api.getDate);\n    api.getDateString = unrequire(api.getDateString);\n    api.getMoment = unrequire(api.getMoment);\n\n    if (o.initialValue) {\n      input.value = o.initialValue.format(o.inputFormat);\n    }\n\n    eye = bullseye(api.container, input);\n    api.on('data', updateInput);\n    api.on('show', eye.refresh);\n\n    eventListening();\n    throttledTakeInput();\n  }\n\n  function destroy () {\n    eventListening(true);\n    eye.destroy();\n    eye = null;\n  }\n\n  function eventListening (remove) {\n    var op = remove ? 'remove' : 'add';\n    crossvent[op](input, 'click', show);\n    crossvent[op](input, 'touchend', show);\n    crossvent[op](input, 'focusin', show);\n    crossvent[op](input, 'change', throttledTakeInput);\n    crossvent[op](input, 'keypress', throttledTakeInput);\n    crossvent[op](input, 'keydown', throttledTakeInput);\n    crossvent[op](input, 'input', throttledTakeInput);\n    if (o.invalidate) { crossvent[op](input, 'blur', invalidateInput); }\n\n    if (remove) {\n      api.once('ready', init);\n      api.off('destroyed', destroy);\n    } else {\n      api.off('ready', init);\n      api.once('destroyed', destroy);\n    }\n  }\n\n  function containerClick () {\n    ignoreShow = true;\n    input.focus();\n    ignoreShow = false;\n  }\n\n  function containerMouseDown () {\n    ignoreInvalidation = true;\n    setTimeout(unignore, 0);\n\n    function unignore () {\n      ignoreInvalidation = false;\n    }\n  }\n\n  function invalidateInput () {\n    if (!ignoreInvalidation && !isEmpty()) {\n      api.emitValues();\n    }\n  }\n\n  function show () {\n    if (ignoreShow) {\n      return;\n    }\n    api.show();\n  }\n\n  function takeInput () {\n    var value = input.value.trim();\n    if (isEmpty()) {\n      return;\n    }\n    var date = momentum.moment(value, o.inputFormat, o.strictParse);\n    api.setValue(date);\n  }\n\n  function updateInput (data) {\n    input.value = data;\n  }\n\n  function isEmpty () {\n    return o.required === false && input.value.trim() === '';\n  }\n\n  function unrequire (fn) {\n    return function maybe () {\n      return isEmpty() ? null : fn.apply(this, arguments);\n    };\n  }\n}\n\nmodule.exports = inputCalendar;\n","'use strict';\n\nfunction isInput (elem) {\n  return elem && elem.nodeName && elem.nodeName.toLowerCase() === 'input';\n}\n\nmodule.exports = isInput;\n","'use strict';\n\nfunction isMoment (value) {\n  return value && Object.prototype.hasOwnProperty.call(value, '_isAMomentObject');\n}\n\nvar api = {\n  moment: null,\n  isMoment: isMoment\n};\n\nmodule.exports = api;\n","'use strict';\n\nfunction noop () {}\n\nmodule.exports = noop;\n","'use strict';\n\nvar momentum = require('./momentum');\n\nfunction raw (date, format) {\n  if (typeof date === 'string') {\n    return momentum.moment(date, format);\n  }\n  if (Object.prototype.toString.call(date) === '[object Date]') {\n    return momentum.moment(date);\n  }\n  if (momentum.isMoment(date)) {\n    return date.clone();\n  }\n}\n\nfunction parse (date, format) {\n  var m = raw(date, typeof format === 'string' ? format : null);\n  return m && m.isValid() ? m : null;\n}\n\nmodule.exports = parse;\n","'use strict';\n\nif (!Array.prototype.filter) {\n  Array.prototype.filter = function (fn, ctx) {\n    var f = [];\n    this.forEach(function (v, i, t) {\n      if (fn.call(ctx, v, i, t)) { f.push(v); }\n    }, ctx);\n    return f;\n  };\n}\n","'use strict';\n\nif (!Array.prototype.forEach) {\n  Array.prototype.forEach = function (fn, ctx) {\n    if (this === void 0 || this === null || typeof fn !== 'function') {\n      throw new TypeError();\n    }\n    var t = this;\n    var len = t.length;\n    for (var i = 0; i < len; i++) {\n      if (i in t) { fn.call(ctx, t[i], i, t); }\n    }\n  };\n}\n","'use strict';\n\nif (!Array.prototype.indexOf) {\n  Array.prototype.indexOf = function (what, start) {\n    if (this === undefined || this === null) {\n      throw new TypeError();\n    }\n    var length = this.length;\n    start = +start || 0;\n    if (Math.abs(start) === Infinity) {\n      start = 0;\n    } else if (start < 0) {\n      start += length;\n      if (start < 0) { start = 0; }\n    }\n    for (; start < length; start++) {\n      if (this[start] === what) {\n        return start;\n      }\n    }\n    return -1;\n  };\n}\n","'use strict';\n\nArray.isArray || (Array.isArray = function (a) {\n  return '' + a !== a && Object.prototype.toString.call(a) === '[object Array]';\n});\n","'use strict';\n\nif (!Array.prototype.map) {\n  Array.prototype.map = function (fn, ctx) {\n    var context, result, i;\n\n    if (this == null) {\n      throw new TypeError('this is null or not defined');\n    }\n\n    var source = Object(this);\n    var len = source.length >>> 0;\n\n    if (typeof fn !== 'function') {\n      throw new TypeError(fn + ' is not a function');\n    }\n\n    if (arguments.length > 1) {\n      context = ctx;\n    }\n\n    result = new Array(len);\n    i = 0;\n\n    while (i < len) {\n      if (i in source) {\n        result[i] = fn.call(context, source[i], i, source);\n      }\n      i++;\n    }\n    return result;\n  };\n}\n","'use strict';\n\nif (!Array.prototype.some) {\n  Array.prototype.some = function (fn, ctx) {\n    var context, i;\n\n    if (this == null) {\n      throw new TypeError('this is null or not defined');\n    }\n\n    var source = Object(this);\n    var len = source.length >>> 0;\n\n    if (typeof fn !== 'function') {\n      throw new TypeError(fn + ' is not a function');\n    }\n\n    if (arguments.length > 1) {\n      context = ctx;\n    }\n\n    i = 0;\n\n    while (i < len) {\n      if (i in source) {\n        var test = fn.call(context, source[i], i, source);\n        if (test) {\n          return true;\n        }\n      }\n      i++;\n    }\n    return false;\n  };\n}\n","'use strict';\n\nif (!Function.prototype.bind) {\n  Function.prototype.bind = function (context) {\n    if (typeof this !== 'function') {\n      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');\n    }\n    var curried = Array.prototype.slice.call(arguments, 1);\n    var original = this;\n    var NoOp = function () {};\n    var bound = function () {\n      var ctx = this instanceof NoOp && context ? this : context;\n      var args = curried.concat(Array.prototype.slice.call(arguments));\n      return original.apply(ctx, args);\n    };\n    NoOp.prototype = this.prototype;\n    bound.prototype = new NoOp();\n    return bound;\n  };\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString');\nvar dontEnums = [\n  'toString',\n  'toLocaleString',\n  'valueOf',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'constructor'\n];\nvar dontEnumsLength = dontEnums.length;\n\nif (!Object.keys) {\n  Object.keys = function(obj) {\n    if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {\n      throw new TypeError('Object.keys called on non-object');\n    }\n\n    var result = [], prop, i;\n\n    for (prop in obj) {\n      if (hasOwn.call(obj, prop)) {\n        result.push(prop);\n      }\n    }\n\n    if (hasDontEnumBug) {\n      for (i = 0; i < dontEnumsLength; i++) {\n        if (hasOwn.call(obj, dontEnums[i])) {\n          result.push(dontEnums[i]);\n        }\n      }\n    }\n    return result;\n  };\n}\n","'use strict';\n\nif (!String.prototype.trim) {\n  String.prototype.trim = function () {\n    return this.replace(/^\\s+|\\s+$/g, '');\n  };\n}\n","'use strict';\n\n// these are only required for IE < 9\n// maybe move to IE-specific distro?\nrequire('./polyfills/function.bind');\nrequire('./polyfills/array.foreach');\nrequire('./polyfills/array.map');\nrequire('./polyfills/array.filter');\nrequire('./polyfills/array.isarray');\nrequire('./polyfills/array.indexof');\nrequire('./polyfills/array.some');\nrequire('./polyfills/string.trim');\nrequire('./polyfills/object.keys');\n\nvar core = require('./core');\nvar index = require('./index');\nvar use = require('./use');\n\ncore.use = use.bind(core);\ncore.find = index.find;\ncore.val = require('./validators');\n\nmodule.exports = core;\n","var rome = require('./rome');\nvar momentum = require('./momentum');\n\nrome.use(global.moment);\n\nif (momentum.moment === void 0) {\n  throw new Error('rome depends on moment.js, you can get it at http://momentjs.com, or you could use the bundled distribution file instead.');\n}\n\nmodule.exports = rome;\n","'use strict';\n\nfunction text (elem, value) {\n  if (arguments.length === 2) {\n    elem.innerText = elem.textContent = value;\n  }\n  return elem.innerText || elem.textContent;\n}\n\nmodule.exports = text;\n","'use strict';\n\nmodule.exports = function throttle (fn, boundary) {\n  var last = -Infinity;\n  var timer;\n  return function bounced () {\n    if (timer) {\n      return;\n    }\n    unbound();\n\n    function unbound () {\n      clearTimeout(timer);\n      timer = null;\n      var next = last + boundary;\n      var now = +new Date();\n      if (now > next) {\n        last = now;\n        fn.apply(this, arguments);\n      } else {\n        timer = setTimeout(unbound, next - now);\n      }\n    }\n  };\n};\n","'use strict';\n\nvar momentum = require('./momentum');\n\nfunction use (moment) {\n  this.moment = momentum.moment = moment;\n}\n\nmodule.exports = use;\n","'use strict';\n\nvar index = require('./index');\nvar parse = require('./parse');\nvar association = require('./association');\n\nfunction compareBuilder (compare) {\n  return function factory (value) {\n    var fixed = parse(value);\n\n    return function validate (date) {\n      var cal = index.find(value);\n      var left = parse(date);\n      var right = fixed || cal && cal.getMoment();\n      if (!right) {\n        return true;\n      }\n      if (cal) {\n        association.add(this, cal);\n      }\n      return compare(left, right);\n    };\n  };\n}\n\nfunction rangeBuilder (how, compare) {\n  return function factory (start, end) {\n    var dates;\n    var len = arguments.length;\n\n    if (Array.isArray(start)) {\n      dates = start;\n    } else {\n      if (len === 1) {\n        dates = [start];\n      } else if (len === 2) {\n        dates = [[start, end]];\n      }\n    }\n\n    return function validate (date) {\n      return dates.map(expand.bind(this))[how](compare.bind(this, date));\n    };\n\n    function expand (value) {\n      var start, end;\n      var cal = index.find(value);\n      if (cal) {\n        start = end = cal.getMoment();\n      } else if (Array.isArray(value)) {\n        start = value[0]; end = value[1];\n      } else {\n        start = end = value;\n      }\n      if (cal) {\n        association.add(cal, this);\n      }\n      return {\n        start: parse(start).startOf('day').toDate(),\n        end: parse(end).endOf('day').toDate()\n      };\n    }\n  };\n}\n\nvar afterEq  = compareBuilder(function (left, right) { return left >= right; });\nvar after    = compareBuilder(function (left, right) { return left  > right; });\nvar beforeEq = compareBuilder(function (left, right) { return left <= right; });\nvar before   = compareBuilder(function (left, right) { return left  < right; });\n\nvar except   = rangeBuilder('every', function (left, right) { return right.start  > left || right.end  < left; });\nvar only     = rangeBuilder('some',  function (left, right) { return right.start <= left && right.end >= left; });\n\nmodule.exports = {\n  afterEq: afterEq,\n  after: after,\n  beforeEq: beforeEq,\n  before: before,\n  except: except,\n  only: only\n};\n"]}