kiso_themes 1.0.2

data/app/assets/javascripts/vendor/fitie/fitie.js

@@ -0,0 +1 @@
+this.fitie=function(t){function e(){c.call(t,g+m,e);var a={boxSizing:"content-box",display:"inline-block",overflow:"hidden"};"backgroundColor backgroundImage borderColor borderStyle borderWidth bottom fontSize lineHeight height left opacity margin position right top visibility width".replace(/\w+/g,function(t){a[t]=l[t]}),d.border=d.margin=d.padding=0,d.display="block",d.height=d.width="auto",d.opacity=1;var h=t.videoWidth||t.width,s=t.videoHeight||t.height,u=h/s,v=document.createElement("object-fit");v.appendChild(t.parentNode.replaceChild(v,t));for(var p in a)v.runtimeStyle[p]=a[p];var b;"fill"===i?f?(d.width=o,d.height=n):(d["-ms-transform-origin"]="0% 0%",d["-ms-transform"]="scale("+o/h+","+n/s+")"):(r>u?"contain"===i:"cover"===i)?(b=n*u,d.width=Math.round(b)+"px",d.height=n+"px",d.marginLeft=Math.round((o-b)/2)+"px"):(b=o/u,d.width=o+"px",d.height=Math.round(b)+"px",d.marginTop=Math.round((n-b)/2)+"px")}var i=t.currentStyle["object-fit"];if(i&&/^(contain|cover|fill)$/.test(i)){var o=t.clientWidth,n=t.clientHeight,r=o/n,a=t.nodeName.toLowerCase(),d=t.runtimeStyle,l=t.currentStyle,h=t.addEventListener||t.attachEvent,c=t.removeEventListener||t.detachEvent,g=t.addEventListener?"":"on",f="img"===a,m=f?"load":"loadedmetadata";h.call(t,g+m,e),t.complete&&e()}},this.fitie.init=function(){if(document.body)for(var t=document.querySelectorAll("img,video"),e=-1;t[++e];)fitie(t[e]);else setTimeout(fitie.init)},/MSIE|Trident/.test(navigator.userAgent)&&this.fitie.init();

data/app/assets/javascripts/vendor/flot/flot-chart-resize.js

@@ -0,0 +1,59 @@
+/* Flot plugin for automatically redrawing plots as the placeholder resizes.
+
+Copyright (c) 2007-2014 IOLA and Ole Laursen.
+Licensed under the MIT license.
+
+It works by listening for changes on the placeholder div (through the jQuery
+resize event plugin) - if the size changes, it will redraw the plot.
+
+There are no options. If you need to disable the plugin for some plots, you
+can just fix the size of their placeholders.
+
+*/
+
+/* Inline dependency:
+ * jQuery resize event - v1.1 - 3/14/2010
+ * http://benalman.com/projects/jquery-resize-plugin/
+ *
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ */
+(function($,e,t){"$:nomunge";var i=[],n=$.resize=$.extend($.resize,{}),a,r=false,s="setTimeout",u="resize",m=u+"-special-event",o="pendingDelay",l="activeDelay",f="throttleWindow";n[o]=200;n[l]=20;n[f]=true;$.event.special[u]={setup:function(){if(!n[f]&&this[s]){return false}var e=$(this);i.push(this);e.data(m,{w:e.width(),h:e.height()});if(i.length===1){a=t;h()}},teardown:function(){if(!n[f]&&this[s]){return false}var e=$(this);for(var t=i.length-1;t>=0;t--){if(i[t]==this){i.splice(t,1);break}}e.removeData(m);if(!i.length){if(r){cancelAnimationFrame(a)}else{clearTimeout(a)}a=null}},add:function(e){if(!n[f]&&this[s]){return false}var i;function a(e,n,a){var r=$(this),s=r.data(m)||{};s.w=n!==t?n:r.width();s.h=a!==t?a:r.height();i.apply(this,arguments)}if($.isFunction(e)){i=e;return a}else{i=e.handler;e.handler=a}}};function h(t){if(r===true){r=t||1}for(var s=i.length-1;s>=0;s--){var l=$(i[s]);if(l[0]==e||l.is(":visible")){var f=l.width(),c=l.height(),d=l.data(m);if(d&&(f!==d.w||c!==d.h)){l.trigger(u,[d.w=f,d.h=c]);r=t||true}}else{d=l.data(m);d.w=0;d.h=0}}if(a!==null){if(r&&(t==null||t-r<1e3)){a=e.requestAnimationFrame(h)}else{a=setTimeout(h,n[o]);r=false}}}if(!e.requestAnimationFrame){e.requestAnimationFrame=function(){return e.webkitRequestAnimationFrame||e.mozRequestAnimationFrame||e.oRequestAnimationFrame||e.msRequestAnimationFrame||function(t,i){return e.setTimeout(function(){t((new Date).getTime())},n[l])}}()}if(!e.cancelAnimationFrame){e.cancelAnimationFrame=function(){return e.webkitCancelRequestAnimationFrame||e.mozCancelRequestAnimationFrame||e.oCancelRequestAnimationFrame||e.msCancelRequestAnimationFrame||clearTimeout}()}})(jQuery,this);
+
+(function ($) {
+    var options = { }; // no options
+
+    function init(plot) {
+        function onResize() {
+            var placeholder = plot.getPlaceholder();
+
+            // somebody might have hidden us and we can't plot
+            // when we don't have the dimensions
+            if (placeholder.width() == 0 || placeholder.height() == 0)
+                return;
+
+            plot.resize();
+            plot.setupGrid();
+            plot.draw();
+        }
+
+        function bindEvents(plot, eventHolder) {
+            plot.getPlaceholder().resize(onResize);
+        }
+
+        function shutdown(plot, eventHolder) {
+            plot.getPlaceholder().unbind("resize", onResize);
+        }
+
+        plot.hooks.bindEvents.push(bindEvents);
+        plot.hooks.shutdown.push(shutdown);
+    }
+
+    $.plot.plugins.push({
+        init: init,
+        options: options,
+        name: 'resize',
+        version: '1.0'
+    });
+})(jQuery);

data/app/assets/javascripts/vendor/flot/flot-chart-stack.js

@@ -0,0 +1,188 @@
+/* Flot plugin for stacking data sets rather than overlyaing them.
+
+Copyright (c) 2007-2014 IOLA and Ole Laursen.
+Licensed under the MIT license.
+
+The plugin assumes the data is sorted on x (or y if stacking horizontally).
+For line charts, it is assumed that if a line has an undefined gap (from a
+null point), then the line above it should have the same gap - insert zeros
+instead of "null" if you want another behaviour. This also holds for the start
+and end of the chart. Note that stacking a mix of positive and negative values
+in most instances doesn't make sense (so it looks weird).
+
+Two or more series are stacked when their "stack" attribute is set to the same
+key (which can be any number or string or just "true"). To specify the default
+stack, you can set the stack option like this:
+
+  series: {
+    stack: null/false, true, or a key (number/string)
+  }
+
+You can also specify it for a single series, like this:
+
+  $.plot( $("#placeholder"), [{
+    data: [ ... ],
+    stack: true
+  }])
+
+The stacking order is determined by the order of the data series in the array
+(later series end up on top of the previous).
+
+Internally, the plugin modifies the datapoints in each series, adding an
+offset to the y value. For line series, extra data points are inserted through
+interpolation. If there's a second y value, it's also adjusted (e.g for bar
+charts or filled areas).
+
+*/
+
+(function ($) {
+    var options = {
+        series: { stack: null } // or number/string
+    };
+
+    function init(plot) {
+        function findMatchingSeries(s, allseries) {
+            var res = null;
+            for (var i = 0; i < allseries.length; ++i) {
+                if (s == allseries[i])
+                    break;
+
+                if (allseries[i].stack == s.stack)
+                    res = allseries[i];
+            }
+
+            return res;
+        }
+
+        function stackData(plot, s, datapoints) {
+            if (s.stack == null || s.stack === false)
+                return;
+
+            var other = findMatchingSeries(s, plot.getData());
+            if (!other)
+                return;
+
+            var ps = datapoints.pointsize,
+                points = datapoints.points,
+                otherps = other.datapoints.pointsize,
+                otherpoints = other.datapoints.points,
+                newpoints = [],
+                px, py, intery, qx, qy, bottom,
+                withlines = s.lines.show,
+                horizontal = s.bars.horizontal,
+                withbottom = ps > 2 && (horizontal ? datapoints.format[2].x : datapoints.format[2].y),
+                withsteps = withlines && s.lines.steps,
+                fromgap = true,
+                keyOffset = horizontal ? 1 : 0,
+                accumulateOffset = horizontal ? 0 : 1,
+                i = 0, j = 0, l, m;
+
+            while (true) {
+                if (i >= points.length)
+                    break;
+
+                l = newpoints.length;
+
+                if (points[i] == null) {
+                    // copy gaps
+                    for (m = 0; m < ps; ++m)
+                        newpoints.push(points[i + m]);
+                    i += ps;
+                }
+                else if (j >= otherpoints.length) {
+                    // for lines, we can't use the rest of the points
+                    if (!withlines) {
+                        for (m = 0; m < ps; ++m)
+                            newpoints.push(points[i + m]);
+                    }
+                    i += ps;
+                }
+                else if (otherpoints[j] == null) {
+                    // oops, got a gap
+                    for (m = 0; m < ps; ++m)
+                        newpoints.push(null);
+                    fromgap = true;
+                    j += otherps;
+                }
+                else {
+                    // cases where we actually got two points
+                    px = points[i + keyOffset];
+                    py = points[i + accumulateOffset];
+                    qx = otherpoints[j + keyOffset];
+                    qy = otherpoints[j + accumulateOffset];
+                    bottom = 0;
+
+                    if (px == qx) {
+                        for (m = 0; m < ps; ++m)
+                            newpoints.push(points[i + m]);
+
+                        newpoints[l + accumulateOffset] += qy;
+                        bottom = qy;
+
+                        i += ps;
+                        j += otherps;
+                    }
+                    else if (px > qx) {
+                        // we got past point below, might need to
+                        // insert interpolated extra point
+                        if (withlines && i > 0 && points[i - ps] != null) {
+                            intery = py + (points[i - ps + accumulateOffset] - py) * (qx - px) / (points[i - ps + keyOffset] - px);
+                            newpoints.push(qx);
+                            newpoints.push(intery + qy);
+                            for (m = 2; m < ps; ++m)
+                                newpoints.push(points[i + m]);
+                            bottom = qy;
+                        }
+
+                        j += otherps;
+                    }
+                    else { // px < qx
+                        if (fromgap && withlines) {
+                            // if we come from a gap, we just skip this point
+                            i += ps;
+                            continue;
+                        }
+
+                        for (m = 0; m < ps; ++m)
+                            newpoints.push(points[i + m]);
+
+                        // we might be able to interpolate a point below,
+                        // this can give us a better y
+                        if (withlines && j > 0 && otherpoints[j - otherps] != null)
+                            bottom = qy + (otherpoints[j - otherps + accumulateOffset] - qy) * (px - qx) / (otherpoints[j - otherps + keyOffset] - qx);
+
+                        newpoints[l + accumulateOffset] += bottom;
+
+                        i += ps;
+                    }
+
+                    fromgap = false;
+
+                    if (l != newpoints.length && withbottom)
+                        newpoints[l + 2] += bottom;
+                }
+
+                // maintain the line steps invariant
+                if (withsteps && l != newpoints.length && l > 0
+                    && newpoints[l] != null
+                    && newpoints[l] != newpoints[l - ps]
+                    && newpoints[l + 1] != newpoints[l - ps + 1]) {
+                    for (m = 0; m < ps; ++m)
+                        newpoints[l + ps + m] = newpoints[l + m];
+                    newpoints[l + 1] = newpoints[l - ps + 1];
+                }
+            }
+
+            datapoints.points = newpoints;
+        }
+
+        plot.hooks.processDatapoints.push(stackData);
+    }
+
+    $.plot.plugins.push({
+        init: init,
+        options: options,
+        name: 'stack',
+        version: '1.2'
+    });
+})(jQuery);

data/app/assets/javascripts/vendor/flot/flot-chart-time.js

@@ -0,0 +1,432 @@
+/* Pretty handling of time axes.
+
+Copyright (c) 2007-2014 IOLA and Ole Laursen.
+Licensed under the MIT license.
+
+Set axis.mode to "time" to enable. See the section "Time series data" in
+API.txt for details.
+
+*/
+
+(function($) {
+
+  var options = {
+    xaxis: {
+      timezone: null,   // "browser" for local to the client or timezone for timezone-js
+      timeformat: null, // format string to use
+      twelveHourClock: false, // 12 or 24 time in time mode
+      monthNames: null  // list of names of months
+    }
+  };
+
+  // round to nearby lower multiple of base
+
+  function floorInBase(n, base) {
+    return base * Math.floor(n / base);
+  }
+
+  // Returns a string with the date d formatted according to fmt.
+  // A subset of the Open Group's strftime format is supported.
+
+  function formatDate(d, fmt, monthNames, dayNames) {
+
+    if (typeof d.strftime == "function") {
+      return d.strftime(fmt);
+    }
+
+    var leftPad = function(n, pad) {
+      n = "" + n;
+      pad = "" + (pad == null ? "0" : pad);
+      return n.length == 1 ? pad + n : n;
+    };
+
+    var r = [];
+    var escape = false;
+    var hours = d.getHours();
+    var isAM = hours < 12;
+
+    if (monthNames == null) {
+      monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    }
+
+    if (dayNames == null) {
+      dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    }
+
+    var hours12;
+
+    if (hours > 12) {
+      hours12 = hours - 12;
+    } else if (hours == 0) {
+      hours12 = 12;
+    } else {
+      hours12 = hours;
+    }
+
+    for (var i = 0; i < fmt.length; ++i) {
+
+      var c = fmt.charAt(i);
+
+      if (escape) {
+        switch (c) {
+          case 'a': c = "" + dayNames[d.getDay()]; break;
+          case 'b': c = "" + monthNames[d.getMonth()]; break;
+          case 'd': c = leftPad(d.getDate()); break;
+          case 'e': c = leftPad(d.getDate(), " "); break;
+          case 'h': // For back-compat with 0.7; remove in 1.0
+          case 'H': c = leftPad(hours); break;
+          case 'I': c = leftPad(hours12); break;
+          case 'l': c = leftPad(hours12, " "); break;
+          case 'm': c = leftPad(d.getMonth() + 1); break;
+          case 'M': c = leftPad(d.getMinutes()); break;
+          // quarters not in Open Group's strftime specification
+          case 'q':
+            c = "" + (Math.floor(d.getMonth() / 3) + 1); break;
+          case 'S': c = leftPad(d.getSeconds()); break;
+          case 'y': c = leftPad(d.getFullYear() % 100); break;
+          case 'Y': c = "" + d.getFullYear(); break;
+          case 'p': c = (isAM) ? ("" + "am") : ("" + "pm"); break;
+          case 'P': c = (isAM) ? ("" + "AM") : ("" + "PM"); break;
+          case 'w': c = "" + d.getDay(); break;
+        }
+        r.push(c);
+        escape = false;
+      } else {
+        if (c == "%") {
+          escape = true;
+        } else {
+          r.push(c);
+        }
+      }
+    }
+
+    return r.join("");
+  }
+
+  // To have a consistent view of time-based data independent of which time
+  // zone the client happens to be in we need a date-like object independent
+  // of time zones.  This is done through a wrapper that only calls the UTC
+  // versions of the accessor methods.
+
+  function makeUtcWrapper(d) {
+
+    function addProxyMethod(sourceObj, sourceMethod, targetObj, targetMethod) {
+      sourceObj[sourceMethod] = function() {
+        return targetObj[targetMethod].apply(targetObj, arguments);
+      };
+    };
+
+    var utc = {
+      date: d
+    };
+
+    // support strftime, if found
+
+    if (d.strftime != undefined) {
+      addProxyMethod(utc, "strftime", d, "strftime");
+    }
+
+    addProxyMethod(utc, "getTime", d, "getTime");
+    addProxyMethod(utc, "setTime", d, "setTime");
+
+    var props = ["Date", "Day", "FullYear", "Hours", "Milliseconds", "Minutes", "Month", "Seconds"];
+
+    for (var p = 0; p < props.length; p++) {
+      addProxyMethod(utc, "get" + props[p], d, "getUTC" + props[p]);
+      addProxyMethod(utc, "set" + props[p], d, "setUTC" + props[p]);
+    }
+
+    return utc;
+  };
+
+  // select time zone strategy.  This returns a date-like object tied to the
+  // desired timezone
+
+  function dateGenerator(ts, opts) {
+    if (opts.timezone == "browser") {
+      return new Date(ts);
+    } else if (!opts.timezone || opts.timezone == "utc") {
+      return makeUtcWrapper(new Date(ts));
+    } else if (typeof timezoneJS != "undefined" && typeof timezoneJS.Date != "undefined") {
+      var d = new timezoneJS.Date();
+      // timezone-js is fickle, so be sure to set the time zone before
+      // setting the time.
+      d.setTimezone(opts.timezone);
+      d.setTime(ts);
+      return d;
+    } else {
+      return makeUtcWrapper(new Date(ts));
+    }
+  }
+
+  // map of app. size of time units in milliseconds
+
+  var timeUnitSize = {
+    "second": 1000,
+    "minute": 60 * 1000,
+    "hour": 60 * 60 * 1000,
+    "day": 24 * 60 * 60 * 1000,
+    "month": 30 * 24 * 60 * 60 * 1000,
+    "quarter": 3 * 30 * 24 * 60 * 60 * 1000,
+    "year": 365.2425 * 24 * 60 * 60 * 1000
+  };
+
+  // the allowed tick sizes, after 1 year we use
+  // an integer algorithm
+
+  var baseSpec = [
+    [1, "second"], [2, "second"], [5, "second"], [10, "second"],
+    [30, "second"],
+    [1, "minute"], [2, "minute"], [5, "minute"], [10, "minute"],
+    [30, "minute"],
+    [1, "hour"], [2, "hour"], [4, "hour"],
+    [8, "hour"], [12, "hour"],
+    [1, "day"], [2, "day"], [3, "day"],
+    [0.25, "month"], [0.5, "month"], [1, "month"],
+    [2, "month"]
+  ];
+
+  // we don't know which variant(s) we'll need yet, but generating both is
+  // cheap
+
+  var specMonths = baseSpec.concat([[3, "month"], [6, "month"],
+    [1, "year"]]);
+  var specQuarters = baseSpec.concat([[1, "quarter"], [2, "quarter"],
+    [1, "year"]]);
+
+  function init(plot) {
+    plot.hooks.processOptions.push(function (plot, options) {
+      $.each(plot.getAxes(), function(axisName, axis) {
+
+        var opts = axis.options;
+
+        if (opts.mode == "time") {
+          axis.tickGenerator = function(axis) {
+
+            var ticks = [];
+            var d = dateGenerator(axis.min, opts);
+            var minSize = 0;
+
+            // make quarter use a possibility if quarters are
+            // mentioned in either of these options
+
+            var spec = (opts.tickSize && opts.tickSize[1] ===
+              "quarter") ||
+              (opts.minTickSize && opts.minTickSize[1] ===
+              "quarter") ? specQuarters : specMonths;
+
+            if (opts.minTickSize != null) {
+              if (typeof opts.tickSize == "number") {
+                minSize = opts.tickSize;
+              } else {
+                minSize = opts.minTickSize[0] * timeUnitSize[opts.minTickSize[1]];
+              }
+            }
+
+            for (var i = 0; i < spec.length - 1; ++i) {
+              if (axis.delta < (spec[i][0] * timeUnitSize[spec[i][1]]
+                        + spec[i + 1][0] * timeUnitSize[spec[i + 1][1]]) / 2
+                && spec[i][0] * timeUnitSize[spec[i][1]] >= minSize) {
+                break;
+              }
+            }
+
+            var size = spec[i][0];
+            var unit = spec[i][1];
+
+            // special-case the possibility of several years
+
+            if (unit == "year") {
+
+              // if given a minTickSize in years, just use it,
+              // ensuring that it's an integer
+
+              if (opts.minTickSize != null && opts.minTickSize[1] == "year") {
+                size = Math.floor(opts.minTickSize[0]);
+              } else {
+
+                var magn = Math.pow(10, Math.floor(Math.log(axis.delta / timeUnitSize.year) / Math.LN10));
+                var norm = (axis.delta / timeUnitSize.year) / magn;
+
+                if (norm < 1.5) {
+                  size = 1;
+                } else if (norm < 3) {
+                  size = 2;
+                } else if (norm < 7.5) {
+                  size = 5;
+                } else {
+                  size = 10;
+                }
+
+                size *= magn;
+              }
+
+              // minimum size for years is 1
+
+              if (size < 1) {
+                size = 1;
+              }
+            }
+
+            axis.tickSize = opts.tickSize || [size, unit];
+            var tickSize = axis.tickSize[0];
+            unit = axis.tickSize[1];
+
+            var step = tickSize * timeUnitSize[unit];
+
+            if (unit == "second") {
+              d.setSeconds(floorInBase(d.getSeconds(), tickSize));
+            } else if (unit == "minute") {
+              d.setMinutes(floorInBase(d.getMinutes(), tickSize));
+            } else if (unit == "hour") {
+              d.setHours(floorInBase(d.getHours(), tickSize));
+            } else if (unit == "month") {
+              d.setMonth(floorInBase(d.getMonth(), tickSize));
+            } else if (unit == "quarter") {
+              d.setMonth(3 * floorInBase(d.getMonth() / 3,
+                tickSize));
+            } else if (unit == "year") {
+              d.setFullYear(floorInBase(d.getFullYear(), tickSize));
+            }
+
+            // reset smaller components
+
+            d.setMilliseconds(0);
+
+            if (step >= timeUnitSize.minute) {
+              d.setSeconds(0);
+            }
+            if (step >= timeUnitSize.hour) {
+              d.setMinutes(0);
+            }
+            if (step >= timeUnitSize.day) {
+              d.setHours(0);
+            }
+            if (step >= timeUnitSize.day * 4) {
+              d.setDate(1);
+            }
+            if (step >= timeUnitSize.month * 2) {
+              d.setMonth(floorInBase(d.getMonth(), 3));
+            }
+            if (step >= timeUnitSize.quarter * 2) {
+              d.setMonth(floorInBase(d.getMonth(), 6));
+            }
+            if (step >= timeUnitSize.year) {
+              d.setMonth(0);
+            }
+
+            var carry = 0;
+            var v = Number.NaN;
+            var prev;
+
+            do {
+
+              prev = v;
+              v = d.getTime();
+              ticks.push(v);
+
+              if (unit == "month" || unit == "quarter") {
+                if (tickSize < 1) {
+
+                  // a bit complicated - we'll divide the
+                  // month/quarter up but we need to take
+                  // care of fractions so we don't end up in
+                  // the middle of a day
+
+                  d.setDate(1);
+                  var start = d.getTime();
+                  d.setMonth(d.getMonth() +
+                    (unit == "quarter" ? 3 : 1));
+                  var end = d.getTime();
+                  d.setTime(v + carry * timeUnitSize.hour + (end - start) * tickSize);
+                  carry = d.getHours();
+                  d.setHours(0);
+                } else {
+                  d.setMonth(d.getMonth() +
+                    tickSize * (unit == "quarter" ? 3 : 1));
+                }
+              } else if (unit == "year") {
+                d.setFullYear(d.getFullYear() + tickSize);
+              } else {
+                d.setTime(v + step);
+              }
+            } while (v < axis.max && v != prev);
+
+            return ticks;
+          };
+
+          axis.tickFormatter = function (v, axis) {
+
+            var d = dateGenerator(v, axis.options);
+
+            // first check global format
+
+            if (opts.timeformat != null) {
+              return formatDate(d, opts.timeformat, opts.monthNames, opts.dayNames);
+            }
+
+            // possibly use quarters if quarters are mentioned in
+            // any of these places
+
+            var useQuarters = (axis.options.tickSize &&
+                axis.options.tickSize[1] == "quarter") ||
+              (axis.options.minTickSize &&
+                axis.options.minTickSize[1] == "quarter");
+
+            var t = axis.tickSize[0] * timeUnitSize[axis.tickSize[1]];
+            var span = axis.max - axis.min;
+            var suffix = (opts.twelveHourClock) ? " %p" : "";
+            var hourCode = (opts.twelveHourClock) ? "%I" : "%H";
+            var fmt;
+
+            if (t < timeUnitSize.minute) {
+              fmt = hourCode + ":%M:%S" + suffix;
+            } else if (t < timeUnitSize.day) {
+              if (span < 2 * timeUnitSize.day) {
+                fmt = hourCode + ":%M" + suffix;
+              } else {
+                fmt = "%b %d " + hourCode + ":%M" + suffix;
+              }
+            } else if (t < timeUnitSize.month) {
+              fmt = "%b %d";
+            } else if ((useQuarters && t < timeUnitSize.quarter) ||
+              (!useQuarters && t < timeUnitSize.year)) {
+              if (span < timeUnitSize.year) {
+                fmt = "%b";
+              } else {
+                fmt = "%b %Y";
+              }
+            } else if (useQuarters && t < timeUnitSize.year) {
+              if (span < timeUnitSize.year) {
+                fmt = "Q%q";
+              } else {
+                fmt = "Q%q %Y";
+              }
+            } else {
+              fmt = "%Y";
+            }
+
+            var rt = formatDate(d, fmt, opts.monthNames, opts.dayNames);
+
+            return rt;
+          };
+        }
+      });
+    });
+  }
+
+  $.plot.plugins.push({
+    init: init,
+    options: options,
+    name: 'time',
+    version: '1.0'
+  });
+
+  // Time-axis support used to be in Flot core, which exposed the
+  // formatDate function on the plot object.  Various plugins depend
+  // on the function, so we need to re-expose it here.
+
+  $.plot.formatDate = formatDate;
+  $.plot.dateGenerator = dateGenerator;
+
+})(jQuery);