/**

* Copyright (c) 2021, Leon Sorokin

* All rights reserved. (MIT Licensed)

*

* uPlot.js (μPlot)

* A small, fast chart for time series, lines, areas, ohlc & bars

* https://github.com/leeoniya/uPlot (v1.6.7)

*/

'use strict';

const FEAT_TIME = true;

function debounce(fn, time) {

let pending = null;

function run() {

pending = null;

fn();

}

return function() {

clearTimeout(pending);

pending = setTimeout(run, time);

}

}

// binary search for index of closest value

function closestIdx(num, arr, lo, hi) {

let mid;

lo = lo || 0;

hi = hi || arr.length - 1;

let bitwise = hi <= 2147483647;

while (hi - lo > 1) {

mid = bitwise ? (lo + hi) >> 1 : floor((lo + hi) / 2);

if (arr[mid] < num)

lo = mid;

else

hi = mid;

}

if (num - arr[lo] <= arr[hi] - num)

return lo;

return hi;

}

function nonNullIdx(data, _i0, _i1, dir) {

for (let i = dir == 1 ? _i0 : _i1; i >= _i0 && i <= _i1; i += dir) {

if (data[i] != null)

return i;

}

return -1;

}

function getMinMax(data, _i0, _i1, sorted) {

// console.log("getMinMax()");

let _min = inf;

let _max = -inf;

if (sorted == 1) {

_min = data[_i0];

_max = data[_i1];

}

else if (sorted == -1) {

_min = data[_i1];

_max = data[_i0];

}

else {

for (let i = _i0; i <= _i1; i++) {

if (data[i] != null) {

_min = min(_min, data[i]);

_max = max(_max, data[i]);

}

}

}

return [_min, _max];

}

function getMinMaxLog(data, _i0, _i1) {

// console.log("getMinMax()");

let _min = inf;

let _max = -inf;

for (let i = _i0; i <= _i1; i++) {

if (data[i] > 0) {

_min = min(_min, data[i]);

_max = max(_max, data[i]);

}

}

return [

_min == inf ? 1 : _min,

_max == -inf ? 10 : _max,

];

}

const _fixedTuple = [0, 0];

function fixIncr(minIncr, maxIncr, minExp, maxExp) {

_fixedTuple[0] = minExp < 0 ? roundDec(minIncr, -minExp) : minIncr;

_fixedTuple[1] = maxExp < 0 ? roundDec(maxIncr, -maxExp) : maxIncr;

return _fixedTuple;

}

function rangeLog(min, max, base, fullMags) {

let logFn = base == 10 ? log10 : log2;

if (min == max) {

min /= base;

max *= base;

}

let minExp, maxExp, minMaxIncrs;

if (fullMags) {

minExp = floor(logFn(min));

maxExp = ceil(logFn(max));

minMaxIncrs = fixIncr(pow(base, minExp), pow(base, maxExp), minExp, maxExp);

min = minMaxIncrs[0];

max = minMaxIncrs[1];

}

else {

minExp = floor(logFn(abs(min)));

maxExp = floor(logFn(abs(max)));

minMaxIncrs = fixIncr(pow(base, minExp), pow(base, maxExp), minExp, maxExp);

min = incrRoundDn(min, minMaxIncrs[0]);

max = incrRoundUp(max, minMaxIncrs[1]);

}

return [min, max];

}

function rangeAsinh(min, max, base, fullMags) {

let minMax = rangeLog(min, max, base, fullMags);

if (min == 0)

minMax[0] = 0;

if (max == 0)

minMax[1] = 0;

return minMax;

}

const _eqRangePart = {

pad: 0,

soft: null,

mode: 0,

};

const _eqRange = {

min: _eqRangePart,

max: _eqRangePart,

};

// this ensures that non-temporal/numeric y-axes get multiple-snapped padding added above/below

// TODO: also account for incrs when snapping to ensure top of axis gets a tick & value

function rangeNum(_min, _max, mult, extra) {

if (isObj(mult))

return _rangeNum(_min, _max, mult);

_eqRangePart.pad = mult;

_eqRangePart.soft = extra ? 0 : null;

_eqRangePart.mode = extra ? 3 : 0;

return _rangeNum(_min, _max, _eqRange);

}

// nullish coalesce

function ifNull(lh, rh) {

return lh == null ? rh : lh;

}

function _rangeNum(_min, _max, cfg) {

let cmin = cfg.min;

let cmax = cfg.max;

let padMin = ifNull(cmin.pad, 0);

let padMax = ifNull(cmax.pad, 0);

let hardMin = ifNull(cmin.hard, -inf);

let hardMax = ifNull(cmax.hard, inf);

let softMin = ifNull(cmin.soft, inf);

let softMax = ifNull(cmax.soft, -inf);

let softMinMode = ifNull(cmin.mode, 0);

let softMaxMode = ifNull(cmax.mode, 0);

let delta = _max - _min;

let nonZeroDelta = delta || abs(_max) || 1e3;

let mag = log10(nonZeroDelta);

let base = pow(10, floor(mag));

let _padMin = nonZeroDelta * (delta == 0 ? (_min == 0 ? .1 : 1) : padMin);

let _newMin = roundDec(incrRoundDn(_min - _padMin, base/10), 6);

let _softMin = _min >= softMin && (softMinMode == 1 || softMinMode == 3 && _newMin <= softMin || softMinMode == 2 && _newMin >= softMin) ? softMin : inf;

let minLim = max(hardMin, _newMin < _softMin && _min >= _softMin ? _softMin : min(_softMin, _newMin));

let _padMax = nonZeroDelta * (delta == 0 ? (_max == 0 ? .1 : 1) : padMax);

let _newMax = roundDec(incrRoundUp(_max + _padMax, base/10), 6);

let _softMax = _max <= softMax && (softMaxMode == 1 || softMaxMode == 3 && _newMax >= softMax || softMaxMode == 2 && _newMax <= softMax) ? softMax : -inf;

let maxLim = min(hardMax, _newMax > _softMax && _max <= _softMax ? _softMax : max(_softMax, _newMax));

if (minLim == maxLim && minLim == 0)

maxLim = 100;

return [minLim, maxLim];

}

// alternative: https://stackoverflow.com/a/2254896

const fmtNum = new Intl.NumberFormat(navigator.language).format;

const M = Math;

const PI = M.PI;

const abs = M.abs;

const floor = M.floor;

const round = M.round;

const ceil = M.ceil;

const min = M.min;

const max = M.max;

const pow = M.pow;

const sqrt = M.sqrt;

const log10 = M.log10;

const log2 = M.log2;

const sinh = (v, linthresh = 1) => M.sinh(v / linthresh);

const asinh = (v, linthresh = 1) => M.asinh(v / linthresh);

const inf = Infinity;

function incrRound(num, incr) {

return round(num/incr)*incr;

}

function clamp(num, _min, _max) {

return min(max(num, _min), _max);

}

function fnOrSelf(v) {

return typeof v == "function" ? v : () => v;

}

const retArg1 = (_0, _1) => _1;

const retNull = _ => null;

const retTrue = _ => true;

function incrRoundUp(num, incr) {

return ceil(num/incr)*incr;

}

function incrRoundDn(num, incr) {

return floor(num/incr)*incr;

}

function roundDec(val, dec) {

return round(val * (dec = 10**dec)) / dec;

}

const fixedDec = new Map();

function guessDec(num) {

return ((""+num).split(".")[1] || "").length;

}

function genIncrs(base, minExp, maxExp, mults) {

let incrs = [];

let multDec = mults.map(guessDec);

for (let exp = minExp; exp < maxExp; exp++) {

let expa = abs(exp);

let mag = roundDec(pow(base, exp), expa);

for (let i = 0; i < mults.length; i++) {

let _incr = mults[i] * mag;

let dec = (_incr >= 0 && exp >= 0 ? 0 : expa) + (exp >= multDec[i] ? 0 : multDec[i]);

let incr = roundDec(_incr, dec);

incrs.push(incr);

fixedDec.set(incr, dec);

}

}

return incrs;

}

//export const assign = Object.assign;

const EMPTY_OBJ = {};

const isArr = Array.isArray;

function isStr(v) {

return typeof v == 'string';

}

function isObj(v) {

let is = false;

if (v != null) {

let c = v.constructor;

is = c == null || c == Object;

}

return is;

}

function fastIsObj(v) {

return v != null && typeof v == 'object';

}

function copy(o, _isObj) {

_isObj = _isObj || isObj;

let out;

if (isArr(o))

out = o.map(v => copy(v, _isObj));

else if (_isObj(o)) {

out = {};

for (var k in o)

out[k] = copy(o[k], _isObj);

}

else

out = o;

return out;

}

function assign(targ) {

let args = arguments;

for (let i = 1; i < args.length; i++) {

let src = args[i];

for (let key in src) {

if (isObj(targ[key]))

assign(targ[key], copy(src[key]));

else

targ[key] = copy(src[key]);

}

}

return targ;

}

// nullModes

const NULL_REMOVE = 0; // nulls are converted to undefined (e.g. for spanGaps: true)

const NULL_RETAIN = 1; // nulls are retained, with alignment artifacts set to undefined (default)

const NULL_EXPAND = 2; // nulls are expanded to include any adjacent alignment artifacts

// sets undefined values to nulls when adjacent to existing nulls (minesweeper)

function nullExpand(yVals, nullIdxs, alignedLen) {

for (let i = 0, xi, lastNullIdx = -1; i < nullIdxs.length; i++) {

let nullIdx = nullIdxs[i];

if (nullIdx > lastNullIdx) {

xi = nullIdx - 1;

while (xi >= 0 && yVals[xi] == null)

yVals[xi--] = null;

xi = nullIdx + 1;

while (xi < alignedLen && yVals[xi] == null)

yVals[lastNullIdx = xi++] = null;

}

}

}

// nullModes is a tables-matched array indicating how to treat nulls in each series

// output is sorted ASC on the joined field (table[0]) and duplicate join values are collapsed

function join(tables, nullModes) {

let xVals = new Set();

for (let ti = 0; ti < tables.length; ti++) {

let t = tables[ti];

let xs = t[0];

let len = xs.length;

for (let i = 0; i < len; i++)

xVals.add(xs[i]);

}

let data = [Array.from(xVals).sort((a, b) => a - b)];

let alignedLen = data[0].length;

let xIdxs = new Map();

for (let i = 0; i < alignedLen; i++)

xIdxs.set(data[0][i], i);

for (let ti = 0; ti < tables.length; ti++) {

let t = tables[ti];

let xs = t[0];

for (let si = 1; si < t.length; si++) {

let ys = t[si];

let yVals = Array(alignedLen).fill(undefined);

let nullMode = nullModes ? nullModes[ti][si] : NULL_RETAIN;

let nullIdxs = [];

for (let i = 0; i < ys.length; i++) {

let yVal = ys[i];

let alignedIdx = xIdxs.get(xs[i]);

if (yVal == null) {

if (nullMode != NULL_REMOVE) {

yVals[alignedIdx] = yVal;

if (nullMode == NULL_EXPAND)

nullIdxs.push(alignedIdx);

}

}

else

yVals[alignedIdx] = yVal;

}

nullExpand(yVals, nullIdxs, alignedLen);

data.push(yVals);

}

}

return data;

}

const microTask = typeof queueMicrotask == "undefined" ? fn => Promise.resolve().then(fn) : queueMicrotask;

const WIDTH = "width";

const HEIGHT = "height";

const TOP = "top";

const BOTTOM = "bottom";

const LEFT = "left";

const RIGHT = "right";

const hexBlack = "#000";

const transparent = hexBlack + "0";

const mousemove = "mousemove";

const mousedown = "mousedown";

const mouseup = "mouseup";

const mouseenter = "mouseenter";

const mouseleave = "mouseleave";

const dblclick = "dblclick";

const resize = "resize";

const scroll = "scroll";

const pre = "u-";

const UPLOT = "uplot";

const ORI_HZ = pre + "hz";

const ORI_VT = pre + "vt";

const TITLE = pre + "title";

const WRAP = pre + "wrap";

const UNDER = pre + "under";

const OVER = pre + "over";

const OFF = pre + "off";

const SELECT = pre + "select";

const CURSOR_X = pre + "cursor-x";

const CURSOR_Y = pre + "cursor-y";

const CURSOR_PT = pre + "cursor-pt";

const LEGEND = pre + "legend";

const LEGEND_LIVE = pre + "live";

const LEGEND_INLINE = pre + "inline";

const LEGEND_THEAD = pre + "thead";

const LEGEND_SERIES = pre + "series";

const LEGEND_MARKER = pre + "marker";

const LEGEND_LABEL = pre + "label";

const LEGEND_VALUE = pre + "value";

const doc = document;

const win = window;

const pxRatio = devicePixelRatio;

function addClass(el, c) {

if (c != null) {

let cl = el.classList;

!cl.contains(c) && cl.add(c);

}

}

function remClass(el, c) {

let cl = el.classList;

cl.contains(c) && cl.remove(c);

}

function setStylePx(el, name, value) {

el.style[name] = value + "px";

}

function placeTag(tag, cls, targ, refEl) {

let el = doc.createElement(tag);

if (cls != null)

addClass(el, cls);

if (targ != null)

targ.insertBefore(el, refEl);

return el;

}

function placeDiv(cls, targ) {

return placeTag("div", cls, targ);

}

function trans(el, xPos, yPos, xMax, yMax) {

el.style.transform = "translate(" + xPos + "px," + yPos + "px)";

if (xPos < 0 || yPos < 0 || xPos > xMax || yPos > yMax)

addClass(el, OFF);

else

remClass(el, OFF);

}

const evOpts = {passive: true};

function on(ev, el, cb) {

el.addEventListener(ev, cb, evOpts);

}

function off(ev, el, cb) {

el.removeEventListener(ev, cb, evOpts);

}

const months = [

"January",

"February",

"March",

"April",

"May",

"June",

"July",

"August",

"September",

"October",

"November",

"December",

];

const days = [

"Sunday",

"Monday",

"Tuesday",

"Wednesday",

"Thursday",

"Friday",

"Saturday",

];

function slice3(str) {

return str.slice(0, 3);

}

const days3 = days.map(slice3);

const months3 = months.map(slice3);

const engNames = {

MMMM: months,

MMM: months3,

WWWW: days,

WWW: days3,

};

function zeroPad2(int) {

return (int < 10 ? '0' : '') + int;

}

function zeroPad3(int) {

return (int < 10 ? '00' : int < 100 ? '0' : '') + int;

}

/*

function suffix(int) {

let mod10 = int % 10;

return int + (

mod10 == 1 && int != 11 ? "st" :

mod10 == 2 && int != 12 ? "nd" :

mod10 == 3 && int != 13 ? "rd" : "th"

);

}

*/

const subs = {

// 2019

YYYY: d => d.getFullYear(),

// 19

YY: d => (d.getFullYear()+'').slice(2),

// July

MMMM: (d, names) => names.MMMM[d.getMonth()],

// Jul

MMM: (d, names) => names.MMM[d.getMonth()],

// 07

MM: d => zeroPad2(d.getMonth()+1),

// 7

M: d => d.getMonth()+1,

// 09

DD: d => zeroPad2(d.getDate()),

// 9

D: d => d.getDate(),

// Monday

WWWW: (d, names) => names.WWWW[d.getDay()],

// Mon

WWW: (d, names) => names.WWW[d.getDay()],

// 03

HH: d => zeroPad2(d.getHours()),

// 3

H: d => d.getHours(),

// 9 (12hr, unpadded)

h: d => {let h = d.getHours(); return h == 0 ? 12 : h > 12 ? h - 12 : h;},

// AM

AA: d => d.getHours() >= 12 ? 'PM' : 'AM',

// am

aa: d => d.getHours() >= 12 ? 'pm' : 'am',

// a

a: d => d.getHours() >= 12 ? 'p' : 'a',

// 09

mm: d => zeroPad2(d.getMinutes()),

// 9

m: d => d.getMinutes(),

// 09

ss: d => zeroPad2(d.getSeconds()),

// 9

s: d => d.getSeconds(),

// 374

fff: d => zeroPad3(d.getMilliseconds()),

};

function fmtDate(tpl, names) {

names = names || engNames;

let parts = [];

let R = /\{([a-z]+)\}|[^{]+/gi, m;

while (m = R.exec(tpl))

parts.push(m[0][0] == '{' ? subs[m[1]] : m[0]);

return d => {

let out = '';

for (let i = 0; i < parts.length; i++)

out += typeof parts[i] == "string" ? parts[i] : parts[i](d, names);

return out;

}

}

const localTz = new Intl.DateTimeFormat().resolvedOptions().timeZone;

// https://stackoverflow.com/questions/15141762/how-to-initialize-a-javascript-date-to-a-particular-time-zone/53652131#53652131

function tzDate(date, tz) {

let date2;

// perf optimization

if (tz == 'UTC' || tz == 'Etc/UTC')

date2 = new Date(+date + date.getTimezoneOffset() * 6e4);

else if (tz == localTz)

date2 = date;

else {

date2 = new Date(date.toLocaleString('en-US', {timeZone: tz}));

date2.setMilliseconds(date.getMilliseconds());

}

return date2;

}

//export const series = [];

// default formatters:

const onlyWhole = v => v % 1 == 0;

const allMults = [1,2,2.5,5];

// ...0.01, 0.02, 0.025, 0.05, 0.1, 0.2, 0.25, 0.5

const decIncrs = genIncrs(10, -16, 0, allMults);

// 1, 2, 2.5, 5, 10, 20, 25, 50...

const oneIncrs = genIncrs(10, 0, 16, allMults);

// 1, 2, 5, 10, 20, 25, 50...

const wholeIncrs = oneIncrs.filter(onlyWhole);

const numIncrs = decIncrs.concat(oneIncrs);

const NL = "\n";

const yyyy = "{YYYY}";

const NLyyyy = NL + yyyy;

const md = "{M}/{D}";

const NLmd = NL + md;

const NLmdyy = NLmd + "/{YY}";

const aa = "{aa}";

const hmm = "{h}:{mm}";

const hmmaa = hmm + aa;

const NLhmmaa = NL + hmmaa;

const ss = ":{ss}";

const _ = null;

function genTimeStuffs(ms) {

let s = ms * 1e3,

m = s * 60,

h = m * 60,

d = h * 24,

mo = d * 30,

y = d * 365;

// min of 1e-3 prevents setting a temporal x ticks too small since Date objects cannot advance ticks smaller than 1ms

let subSecIncrs = ms == 1 ? genIncrs(10, 0, 3, allMults).filter(onlyWhole) : genIncrs(10, -3, 0, allMults);

let timeIncrs = subSecIncrs.concat([

// minute divisors (# of secs)

s,

s * 5,

s * 10,

s * 15,

s * 30,

// hour divisors (# of mins)

m,

m * 5,

m * 10,

m * 15,

m * 30,

// day divisors (# of hrs)

h,

h * 2,

h * 3,

h * 4,

h * 6,

h * 8,

h * 12,

// month divisors TODO: need more?

d,

d * 2,

d * 3,

d * 4,

d * 5,

d * 6,

d * 7,

d * 8,

d * 9,

d * 10,

d * 15,

// year divisors (# months, approx)

mo,

mo * 2,

mo * 3,

mo * 4,

mo * 6,

// century divisors

y,

y * 2,

y * 5,

y * 10,

y * 25,

y * 50,

y * 100,

]);

// [0]: minimum num secs in the tick incr

// [1]: default tick format

// [2-7]: rollover tick formats

// [8]: mode: 0: replace [1] -> [2-7], 1: concat [1] + [2-7]

const _timeAxisStamps = [

// tick incr default year month day hour min sec mode

[y, yyyy, _, _, _, _, _, _, 1],

[d * 28, "{MMM}", NLyyyy, _, _, _, _, _, 1],

[d, md, NLyyyy, _, _, _, _, _, 1],

[h, "{h}" + aa, NLmdyy, _, NLmd, _, _, _, 1],

[m, hmmaa, NLmdyy, _, NLmd, _, _, _, 1],

[s, ss, NLmdyy + " " + hmmaa, _, NLmd + " " + hmmaa, _, NLhmmaa, _, 1],

[ms, ss + ".{fff}", NLmdyy + " " + hmmaa, _, NLmd + " " + hmmaa, _, NLhmmaa, _, 1],

];

// the ensures that axis ticks, values & grid are aligned to logical temporal breakpoints and not an arbitrary timestamp

// https://www.timeanddate.com/time/dst/

// https://www.timeanddate.com/time/dst/2019.html

// https://www.epochconverter.com/timezones

function timeAxisSplits(tzDate) {

return (self, axisIdx, scaleMin, scaleMax, foundIncr, foundSpace) => {

let splits = [];

let isYr = foundIncr >= y;

let isMo = foundIncr >= mo && foundIncr < y;

// get the timezone-adjusted date

let minDate = tzDate(scaleMin);

let minDateTs = minDate * ms;

// get ts of 12am (this lands us at or before the original scaleMin)

let minMin = mkDate(minDate.getFullYear(), isYr ? 0 : minDate.getMonth(), isMo || isYr ? 1 : minDate.getDate());

let minMinTs = minMin * ms;

if (isMo || isYr) {

let moIncr = isMo ? foundIncr / mo : 0;

let yrIncr = isYr ? foundIncr / y : 0;

// let tzOffset = scaleMin - minDateTs; // needed?

let split = minDateTs == minMinTs ? minDateTs : mkDate(minMin.getFullYear() + yrIncr, minMin.getMonth() + moIncr, 1) * ms;

let splitDate = new Date(split / ms);

let baseYear = splitDate.getFullYear();

let baseMonth = splitDate.getMonth();

for (let i = 0; split <= scaleMax; i++) {

let next = mkDate(baseYear + yrIncr * i, baseMonth + moIncr * i, 1);

let offs = next - tzDate(next * ms);

split = (+next + offs) * ms;

if (split <= scaleMax)

splits.push(split);

}

}

else {

let incr0 = foundIncr >= d ? d : foundIncr;

let tzOffset = floor(scaleMin) - floor(minDateTs);

let split = minMinTs + tzOffset + incrRoundUp(minDateTs - minMinTs, incr0);

splits.push(split);

let date0 = tzDate(split);

let prevHour = date0.getHours() + (date0.getMinutes() / m) + (date0.getSeconds() / h);

let incrHours = foundIncr / h;

let minSpace = self.axes[axisIdx]._space;

let pctSpace = foundSpace / minSpace;

while (1) {

split = roundDec(split + foundIncr, ms == 1 ? 0 : 3);

if (split > scaleMax)

break;

if (incrHours > 1) {

let expectedHour = floor(roundDec(prevHour + incrHours, 6)) % 24;

let splitDate = tzDate(split);

let actualHour = splitDate.getHours();

let dstShift = actualHour - expectedHour;

if (dstShift > 1)

dstShift = -1;

split -= dstShift * h;

prevHour = (prevHour + incrHours) % 24;

// add a tick only if it's further than 70% of the min allowed label spacing

let prevSplit = splits[splits.length - 1];

let pctIncr = roundDec((split - prevSplit) / foundIncr, 3);

if (pctIncr * pctSpace >= .7)

splits.push(split);

}

else

splits.push(split);

}

}

return splits;

}

}

return [

timeIncrs,

_timeAxisStamps,

timeAxisSplits,

];

}

const [ timeIncrsMs, _timeAxisStampsMs, timeAxisSplitsMs ] = genTimeStuffs(1);

const [ timeIncrsS, _timeAxisStampsS, timeAxisSplitsS ] = genTimeStuffs(1e-3);

// base 2

genIncrs(2, -53, 53, [1]);

/*

console.log({

decIncrs,

oneIncrs,

wholeIncrs,

numIncrs,

timeIncrs,

fixedDec,

});

*/

function timeAxisStamps(stampCfg, fmtDate) {

return stampCfg.map(s => s.map((v, i) =>

i == 0 || i == 8 || v == null ? v : fmtDate(i == 1 || s[8] == 0 ? v : s[1] + v)

));

}

// TODO: will need to accept spaces[] and pull incr into the loop when grid will be non-uniform, eg for log scales.

// currently we ignore this for months since they're *nearly* uniform and the added complexity is not worth it

function timeAxisVals(tzDate, stamps) {

return (self, splits, axisIdx, foundSpace, foundIncr) => {

let s = stamps.find(s => foundIncr >= s[0]) || stamps[stamps.length - 1];

// these track boundaries when a full label is needed again

let prevYear;

let prevMnth;

let prevDate;

let prevHour;

let prevMins;

let prevSecs;

return splits.map(split => {

let date = tzDate(split);

let newYear = date.getFullYear();

let newMnth = date.getMonth();

let newDate = date.getDate();

let newHour = date.getHours();

let newMins = date.getMinutes();

let newSecs = date.getSeconds();

let stamp = (

newYear != prevYear && s[2] ||

newMnth != prevMnth && s[3] ||

newDate != prevDate && s[4] ||

newHour != prevHour && s[5] ||

newMins != prevMins && s[6] ||

newSecs != prevSecs && s[7] ||

s[1]

);

prevYear = newYear;

prevMnth = newMnth;

prevDate = newDate;

prevHour = newHour;

prevMins = newMins;

prevSecs = newSecs;

return stamp(date);

});

}

}

// for when axis.values is defined as a static fmtDate template string

function timeAxisVal(tzDate, dateTpl) {

let stamp = fmtDate(dateTpl);

return (self, splits, axisIdx, foundSpace, foundIncr) => splits.map(split => stamp(tzDate(split)));

}

function mkDate(y, m, d) {

return new Date(y, m, d);

}

function timeSeriesStamp(stampCfg, fmtDate) {

return fmtDate(stampCfg);

}

const _timeSeriesStamp = '{YYYY}-{MM}-{DD} {h}:{mm}{aa}';

function timeSeriesVal(tzDate, stamp) {

return (self, val) => stamp(tzDate(val));

}

const legendWidth = 2;

const legendDash = "solid";

function legendStroke(self, seriesIdx) {

let s = self.series[seriesIdx];

return s.width ? s.stroke(self, seriesIdx) : s.points.width ? s.points.stroke(self, seriesIdx) : null;

}

function legendFill(self, seriesIdx) {

return self.series[seriesIdx].fill(self, seriesIdx);

}

function cursorPointShow(self, si) {

let o = self.cursor.points;

let pt = placeDiv();

let stroke = o.stroke(self, si);

let fill = o.fill(self, si);

pt.style.background = fill || stroke;

let size = o.size(self, si);