vega
Version:
The Vega visualization grammar.
1,560 lines (1,537 loc) • 1.01 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-dsv'), require('topojson-client'), require('d3-array'), require('d3-format'), require('d3-time'), require('d3-time-format'), require('d3-shape'), require('d3-path'), require('d3-scale'), require('d3-interpolate'), require('d3-geo'), require('d3-color'), require('d3-force'), require('d3-hierarchy'), require('d3-delaunay'), require('d3-timer')) :
typeof define === 'function' && define.amd ? define(['exports', 'd3-dsv', 'topojson-client', 'd3-array', 'd3-format', 'd3-time', 'd3-time-format', 'd3-shape', 'd3-path', 'd3-scale', 'd3-interpolate', 'd3-geo', 'd3-color', 'd3-force', 'd3-hierarchy', 'd3-delaunay', 'd3-timer'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vega = {}, global.d3, global.topojson, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3, global.d3));
})(this, (function (exports, d3Dsv, topojsonClient, d3Array, d3Format, d3Time, d3TimeFormat, d3Shape, d3Path, $$1, $$1$1, d3Geo, d3Color, d3Force, d3Hierarchy, d3Delaunay, d3Timer) { 'use strict';
function _interopNamespaceDefault(e) {
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var $__namespace = /*#__PURE__*/_interopNamespaceDefault($$1);
var $$1__namespace = /*#__PURE__*/_interopNamespaceDefault($$1$1);
function accessor(fn, fields, name) {
fn.fields = fields || [];
fn.fname = name;
return fn;
}
function accessorName(fn) {
return fn == null ? null : fn.fname;
}
function accessorFields(fn) {
return fn == null ? null : fn.fields;
}
function getter$1(path) {
return path.length === 1 ? get1(path[0]) : getN(path);
}
var get1 = function get1(field) {
return function (obj) {
return obj[field];
};
};
var getN = function getN(path) {
var len = path.length;
return function (obj) {
for (var i = 0; i < len; ++i) {
obj = obj[path[i]];
}
return obj;
};
};
function error(message) {
throw Error(message);
}
function splitAccessPath(p) {
var path = [],
n = p.length;
var q = null,
b = 0,
s = '',
i,
j,
c;
p = p + '';
function push() {
path.push(s + p.substring(i, j));
s = '';
i = j + 1;
}
for (i = j = 0; j < n; ++j) {
c = p[j];
if (c === '\\') {
s += p.substring(i, j++);
i = j;
} else if (c === q) {
push();
q = null;
b = -1;
} else if (q) {
continue;
} else if (i === b && c === '"') {
i = j + 1;
q = c;
} else if (i === b && c === "'") {
i = j + 1;
q = c;
} else if (c === '.' && !b) {
if (j > i) {
push();
} else {
i = j + 1;
}
} else if (c === '[') {
if (j > i) push();
b = i = j + 1;
} else if (c === ']') {
if (!b) error('Access path missing open bracket: ' + p);
if (b > 0) push();
b = 0;
i = j + 1;
}
}
if (b) error('Access path missing closing bracket: ' + p);
if (q) error('Access path missing closing quote: ' + p);
if (j > i) {
j++;
push();
}
return path;
}
function field$1(field, name, opt) {
var path = splitAccessPath(field);
field = path.length === 1 ? path[0] : field;
return accessor((opt && opt.get || getter$1)(path), [field], name || field);
}
var id = field$1('id');
var identity = accessor(function (_) {
return _;
}, [], 'identity');
var zero$1 = accessor(function () {
return 0;
}, [], 'zero');
var one$1 = accessor(function () {
return 1;
}, [], 'one');
var truthy = accessor(function () {
return true;
}, [], 'true');
var falsy = accessor(function () {
return false;
}, [], 'false');
function log$1$1(method, level, input) {
var args = [level].concat([].slice.call(input));
console[method].apply(console, args); // eslint-disable-line no-console
}
var None$2 = 0;
var Error$1 = 1;
var Warn = 2;
var Info = 3;
var Debug = 4;
function logger(_, method) {
var handler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : log$1$1;
var _level = _ || None$2;
return {
level: function level(_) {
if (arguments.length) {
_level = +_;
return this;
} else {
return _level;
}
},
error: function error() {
if (_level >= Error$1) handler(method || 'error', 'ERROR', arguments);
return this;
},
warn: function warn() {
if (_level >= Warn) handler(method || 'warn', 'WARN', arguments);
return this;
},
info: function info() {
if (_level >= Info) handler(method || 'log', 'INFO', arguments);
return this;
},
debug: function debug() {
if (_level >= Debug) handler(method || 'log', 'DEBUG', arguments);
return this;
}
};
}
var isArray = Array.isArray;
function isObject(_) {
return _ === Object(_);
}
var isLegalKey = function isLegalKey(key) {
return key !== '__proto__';
};
function mergeConfig() {
for (var _len = arguments.length, configs = new Array(_len), _key = 0; _key < _len; _key++) {
configs[_key] = arguments[_key];
}
return configs.reduce(function (out, source) {
for (var _key2 in source) {
if (_key2 === 'signals') {
// for signals, we merge the signals arrays
// source signals take precedence over
// existing signals with the same name
out.signals = mergeNamed(out.signals, source.signals);
} else {
// otherwise, merge objects subject to recursion constraints
// for legend block, recurse for the layout entry only
// for style block, recurse for all properties
// otherwise, no recursion: objects overwrite, no merging
var r = _key2 === 'legend' ? {
layout: 1
} : _key2 === 'style' ? true : null;
writeConfig(out, _key2, source[_key2], r);
}
}
return out;
}, {});
}
function writeConfig(output, key, value, recurse) {
if (!isLegalKey(key)) return;
var k, o;
if (isObject(value) && !isArray(value)) {
o = isObject(output[key]) ? output[key] : output[key] = {};
for (k in value) {
if (recurse && (recurse === true || recurse[k])) {
writeConfig(o, k, value[k]);
} else if (isLegalKey(k)) {
o[k] = value[k];
}
}
} else {
output[key] = value;
}
}
function mergeNamed(a, b) {
if (a == null) return b;
var map = {},
out = [];
function add(_) {
if (!map[_.name]) {
map[_.name] = 1;
out.push(_);
}
}
b.forEach(add);
a.forEach(add);
return out;
}
function peek$1(array) {
return array[array.length - 1];
}
function toNumber(_) {
return _ == null || _ === '' ? null : +_;
}
var exp$1 = function exp(sign) {
return function (x) {
return sign * Math.exp(x);
};
};
var log$2 = function log(sign) {
return function (x) {
return Math.log(sign * x);
};
};
var symlog = function symlog(c) {
return function (x) {
return Math.sign(x) * Math.log1p(Math.abs(x / c));
};
};
var symexp = function symexp(c) {
return function (x) {
return Math.sign(x) * Math.expm1(Math.abs(x)) * c;
};
};
var pow$1 = function pow(exponent) {
return function (x) {
return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);
};
};
function pan(domain, delta, lift, ground) {
var d0 = lift(domain[0]),
d1 = lift(peek$1(domain)),
dd = (d1 - d0) * delta;
return [ground(d0 - dd), ground(d1 - dd)];
}
function panLinear(domain, delta) {
return pan(domain, delta, toNumber, identity);
}
function panLog(domain, delta) {
var sign = Math.sign(domain[0]);
return pan(domain, delta, log$2(sign), exp$1(sign));
}
function panPow(domain, delta, exponent) {
return pan(domain, delta, pow$1(exponent), pow$1(1 / exponent));
}
function panSymlog(domain, delta, constant) {
return pan(domain, delta, symlog(constant), symexp(constant));
}
function zoom(domain, anchor, scale, lift, ground) {
var d0 = lift(domain[0]),
d1 = lift(peek$1(domain)),
da = anchor != null ? lift(anchor) : (d0 + d1) / 2;
return [ground(da + (d0 - da) * scale), ground(da + (d1 - da) * scale)];
}
function zoomLinear(domain, anchor, scale) {
return zoom(domain, anchor, scale, toNumber, identity);
}
function zoomLog(domain, anchor, scale) {
var sign = Math.sign(domain[0]);
return zoom(domain, anchor, scale, log$2(sign), exp$1(sign));
}
function zoomPow(domain, anchor, scale, exponent) {
return zoom(domain, anchor, scale, pow$1(exponent), pow$1(1 / exponent));
}
function zoomSymlog(domain, anchor, scale, constant) {
return zoom(domain, anchor, scale, symlog(constant), symexp(constant));
}
function quarter(date) {
return 1 + ~~(new Date(date).getMonth() / 3);
}
function utcquarter(date) {
return 1 + ~~(new Date(date).getUTCMonth() / 3);
}
function array$2(_) {
return _ != null ? isArray(_) ? _ : [_] : [];
}
/**
* Span-preserving range clamp. If the span of the input range is less
* than (max - min) and an endpoint exceeds either the min or max value,
* the range is translated such that the span is preserved and one
* endpoint touches the boundary of the min/max range.
* If the span exceeds (max - min), the range [min, max] is returned.
*/
function clampRange(range, min, max) {
var lo = range[0],
hi = range[1],
span;
if (hi < lo) {
span = hi;
hi = lo;
lo = span;
}
span = hi - lo;
return span >= max - min ? [min, max] : [lo = Math.min(Math.max(lo, min), max - span), lo + span];
}
function isFunction(_) {
return typeof _ === 'function';
}
var DESCENDING = 'descending';
function compare$1(fields, orders, opt) {
opt = opt || {};
orders = array$2(orders) || [];
var ord = [],
get = [],
fmap = {},
gen = opt.comparator || comparator;
array$2(fields).forEach(function (f, i) {
if (f == null) return;
ord.push(orders[i] === DESCENDING ? -1 : 1);
get.push(f = isFunction(f) ? f : field$1(f, null, opt));
(accessorFields(f) || []).forEach(function (_) {
return fmap[_] = 1;
});
});
return get.length === 0 ? null : accessor(gen(get, ord), Object.keys(fmap));
}
var ascending$1 = function ascending(u, v) {
return (u < v || u == null) && v != null ? -1 : (u > v || v == null) && u != null ? 1 : (v = v instanceof Date ? +v : v, u = u instanceof Date ? +u : u) !== u && v === v ? -1 : v !== v && u === u ? 1 : 0;
};
var comparator = function comparator(fields, orders) {
return fields.length === 1 ? compare1(fields[0], orders[0]) : compareN(fields, orders, fields.length);
};
var compare1 = function compare1(field, order) {
return function (a, b) {
return ascending$1(field(a), field(b)) * order;
};
};
var compareN = function compareN(fields, orders, n) {
orders.push(0); // pad zero for convenient lookup
return function (a, b) {
var f,
c = 0,
i = -1;
while (c === 0 && ++i < n) {
f = fields[i];
c = ascending$1(f(a), f(b));
}
return c * orders[i];
};
};
function constant$1(_) {
return isFunction(_) ? _ : function () {
return _;
};
}
function debounce(delay, handler) {
var tid;
return function (e) {
if (tid) clearTimeout(tid);
tid = setTimeout(function () {
return handler(e), tid = null;
}, delay);
};
}
function extend(_) {
for (var x, k, i = 1, len = arguments.length; i < len; ++i) {
x = arguments[i];
for (k in x) {
_[k] = x[k];
}
}
return _;
}
/**
* Return an array with minimum and maximum values, in the
* form [min, max]. Ignores null, undefined, and NaN values.
*/
function extent(array, f) {
var i = 0,
n,
v,
min,
max;
if (array && (n = array.length)) {
if (f == null) {
// find first valid value
for (v = array[i]; i < n && (v == null || v !== v); v = array[++i]);
min = max = v;
// visit all other values
for (; i < n; ++i) {
v = array[i];
// skip null/undefined; NaN will fail all comparisons
if (v != null) {
if (v < min) min = v;
if (v > max) max = v;
}
}
} else {
// find first valid value
for (v = f(array[i]); i < n && (v == null || v !== v); v = f(array[++i]));
min = max = v;
// visit all other values
for (; i < n; ++i) {
v = f(array[i]);
// skip null/undefined; NaN will fail all comparisons
if (v != null) {
if (v < min) min = v;
if (v > max) max = v;
}
}
}
}
return [min, max];
}
function extentIndex(array, f) {
var n = array.length;
var i = -1,
a,
b,
c,
u,
v;
if (f == null) {
while (++i < n) {
b = array[i];
if (b != null && b >= b) {
a = c = b;
break;
}
}
if (i === n) return [-1, -1];
u = v = i;
while (++i < n) {
b = array[i];
if (b != null) {
if (a > b) {
a = b;
u = i;
}
if (c < b) {
c = b;
v = i;
}
}
}
} else {
while (++i < n) {
b = f(array[i], i, array);
if (b != null && b >= b) {
a = c = b;
break;
}
}
if (i === n) return [-1, -1];
u = v = i;
while (++i < n) {
b = f(array[i], i, array);
if (b != null) {
if (a > b) {
a = b;
u = i;
}
if (c < b) {
c = b;
v = i;
}
}
}
}
return [u, v];
}
function _has(object, property) {
return Object.hasOwn(object, property);
}
var NULL = {};
function fastmap(input) {
var obj = {},
_test;
function has$1(key) {
return _has(obj, key) && obj[key] !== NULL;
}
var map = {
size: 0,
empty: 0,
object: obj,
has: has$1,
get: function get(key) {
return has$1(key) ? obj[key] : undefined;
},
set: function set(key, value) {
if (!has$1(key)) {
++map.size;
if (obj[key] === NULL) --map.empty;
}
obj[key] = value;
return this;
},
delete: function _delete(key) {
if (has$1(key)) {
--map.size;
++map.empty;
obj[key] = NULL;
}
return this;
},
clear: function clear() {
map.size = map.empty = 0;
map.object = obj = {};
},
test: function test(_) {
if (arguments.length) {
_test = _;
return map;
} else {
return _test;
}
},
clean: function clean() {
var next = {};
var size = 0;
for (var _key3 in obj) {
var value = obj[_key3];
if (value !== NULL && (!_test || !_test(value))) {
next[_key3] = value;
++size;
}
}
map.size = size;
map.empty = 0;
map.object = obj = next;
}
};
if (input) Object.keys(input).forEach(function (key) {
map.set(key, input[key]);
});
return map;
}
function flush(range, value, threshold, left, right, center) {
if (!threshold && threshold !== 0) return center;
var t = +threshold;
var a = range[0],
b = peek$1(range),
l;
// swap endpoints if range is reversed
if (b < a) {
l = a;
a = b;
b = l;
}
// compare value to endpoints
l = Math.abs(value - a);
var r = Math.abs(b - value);
// adjust if value is within threshold distance of endpoint
return l < r && l <= t ? left : r <= t ? right : center;
}
function inherits(child, parent, members) {
var proto = child.prototype = Object.create(parent.prototype);
Object.defineProperty(proto, 'constructor', {
value: child,
writable: true,
enumerable: true,
configurable: true
});
return extend(proto, members);
}
/**
* Predicate that returns true if the value lies within the span
* of the given range. The left and right flags control the use
* of inclusive (true) or exclusive (false) comparisons.
*/
function inrange(value, range, left, right) {
var r0 = range[0],
r1 = range[range.length - 1],
t;
if (r0 > r1) {
t = r0;
r0 = r1;
r1 = t;
}
left = left === undefined || left;
right = right === undefined || right;
return (left ? r0 <= value : r0 < value) && (right ? value <= r1 : value < r1);
}
function isBoolean$1(_) {
return typeof _ === 'boolean';
}
function isDate$1(_) {
return Object.prototype.toString.call(_) === '[object Date]';
}
function isIterable(_) {
return _ && isFunction(_[Symbol.iterator]);
}
function isNumber$1(_) {
return typeof _ === 'number';
}
function isRegExp(_) {
return Object.prototype.toString.call(_) === '[object RegExp]';
}
function isString(_) {
return typeof _ === 'string';
}
function key$1(fields, flat, opt) {
if (fields) {
fields = flat ? array$2(fields).map(function (f) {
return f.replace(/\\(.)/g, '$1');
}) : array$2(fields);
}
var len = fields && fields.length,
gen = opt && opt.get || getter$1,
map = function map(f) {
return gen(flat ? [f] : splitAccessPath(f));
};
var fn;
if (!len) {
fn = function fn() {
return '';
};
} else if (len === 1) {
var get = map(fields[0]);
fn = function fn(_) {
return '' + get(_);
};
} else {
var _get = fields.map(map);
fn = function fn(_) {
var s = '' + _get[0](_),
i = 0;
while (++i < len) s += '|' + _get[i](_);
return s;
};
}
return accessor(fn, fields, 'key');
}
function lerp(array, frac) {
var lo = array[0],
hi = peek$1(array),
f = +frac;
return !f ? lo : f === 1 ? hi : lo + f * (hi - lo);
}
var DEFAULT_MAX_SIZE = 10000;
// adapted from https://github.com/dominictarr/hashlru/ (MIT License)
function lruCache(maxsize) {
maxsize = +maxsize || DEFAULT_MAX_SIZE;
var curr, prev, size;
var clear = function clear() {
curr = {};
prev = {};
size = 0;
};
var update = function update(key, value) {
if (++size > maxsize) {
prev = curr;
curr = {};
size = 1;
}
return curr[key] = value;
};
clear();
return {
clear: clear,
has: function has(key) {
return _has(curr, key) || _has(prev, key);
},
get: function get(key) {
return _has(curr, key) ? curr[key] : _has(prev, key) ? update(key, prev[key]) : undefined;
},
set: function set(key, value) {
return _has(curr, key) ? curr[key] = value : update(key, value);
}
};
}
function merge$2(compare, array0, array1, output) {
var n0 = array0.length,
n1 = array1.length;
if (!n1) return array0;
if (!n0) return array1;
var merged = output || new array0.constructor(n0 + n1);
var i0 = 0,
i1 = 0,
i = 0;
for (; i0 < n0 && i1 < n1; ++i) {
merged[i] = compare(array0[i0], array1[i1]) > 0 ? array1[i1++] : array0[i0++];
}
for (; i0 < n0; ++i0, ++i) {
merged[i] = array0[i0];
}
for (; i1 < n1; ++i1, ++i) {
merged[i] = array1[i1];
}
return merged;
}
function repeat(str, reps) {
var s = '';
while (--reps >= 0) s += str;
return s;
}
function pad(str, length, padchar, align) {
var c = padchar || ' ',
s = str + '',
n = length - s.length;
return n <= 0 ? s : align === 'left' ? repeat(c, n) + s : align === 'center' ? repeat(c, ~~(n / 2)) + s + repeat(c, Math.ceil(n / 2)) : s + repeat(c, n);
}
/**
* Return the numerical span of an array: the difference between
* the last and first values.
*/
function span(array) {
return array && peek$1(array) - array[0] || 0;
}
function $(x) {
return isArray(x) ? '[' + x.map($) + ']' : isObject(x) || isString(x) ?
// Output valid JSON and JS source strings.
// See http://timelessrepo.com/json-isnt-a-javascript-subset
JSON.stringify(x).replace("\u2028", "\\u2028").replace("\u2029", "\\u2029") : x;
}
function toBoolean(_) {
return _ == null || _ === '' ? null : !_ || _ === 'false' || _ === '0' ? false : !!_;
}
var defaultParser = function defaultParser(_) {
return isNumber$1(_) ? _ : isDate$1(_) ? _ : Date.parse(_);
};
function toDate(_, parser) {
parser = parser || defaultParser;
return _ == null || _ === '' ? null : parser(_);
}
function toString(_) {
return _ == null || _ === '' ? null : _ + '';
}
function toSet(_) {
var s = {},
n = _.length;
for (var i = 0; i < n; ++i) s[_[i]] = true;
return s;
}
function truncate$1(str, length, align, ellipsis) {
var e = ellipsis != null ? ellipsis : "\u2026",
s = str + '',
n = s.length,
l = Math.max(0, length - e.length);
return n <= length ? s : align === 'left' ? e + s.slice(n - l) : align === 'center' ? s.slice(0, Math.ceil(l / 2)) + e + s.slice(n - ~~(l / 2)) : s.slice(0, l) + e;
}
function visitArray(array, filter, visitor) {
if (array) {
if (filter) {
var n = array.length;
for (var i = 0; i < n; ++i) {
var t = filter(array[i]);
if (t) visitor(t, i, array);
}
} else {
array.forEach(visitor);
}
}
}
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
return n;
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) return r;
}
function _arrayWithoutHoles(r) {
if (Array.isArray(r)) return _arrayLikeToArray(r);
}
function _assertThisInitialized(e) {
if (undefined === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return e;
}
function asyncGeneratorStep(n, t, e, r, o, a, c) {
try {
var i = n[a](c),
u = i.value;
} catch (n) {
return void e(n);
}
i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
return function () {
var t = this,
e = arguments;
return new Promise(function (r, o) {
var a = n.apply(t, e);
function _next(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
}
function _throw(n) {
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
}
_next(undefined);
});
};
}
function _callSuper(t, o, e) {
return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
}
function _classCallCheck(a, n) {
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
writable: false
}), e;
}
function _createForOfIteratorHelper(r, e) {
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (!t) {
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
t && (r = t);
var n = 0,
F = function () {};
return {
s: F,
n: function () {
return n >= r.length ? {
done: true
} : {
done: false,
value: r[n++]
};
},
e: function (r) {
throw r;
},
f: F
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var o,
a = true,
u = false;
return {
s: function () {
t = t.call(r);
},
n: function () {
var r = t.next();
return a = r.done, r;
},
e: function (r) {
u = true, o = r;
},
f: function () {
try {
a || null == t.return || t.return();
} finally {
if (u) throw o;
}
}
};
}
function _defineProperty(e, r, t) {
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
value: t,
enumerable: true,
configurable: true,
writable: true
}) : e[r] = t, e;
}
function _get() {
return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {
var p = _superPropBase(e, t);
if (p) {
var n = Object.getOwnPropertyDescriptor(p, t);
return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
}
}, _get.apply(null, arguments);
}
function _getPrototypeOf(t) {
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
}, _getPrototypeOf(t);
}
function _inherits(t, e) {
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
t.prototype = Object.create(e && e.prototype, {
constructor: {
value: t,
writable: true,
configurable: true
}
}), Object.defineProperty(t, "prototype", {
writable: false
}), e && _setPrototypeOf(t, e);
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
} catch (t) {}
return (_isNativeReflectConstruct = function () {
return !!t;
})();
}
function _iterableToArray(r) {
if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
}
function _iterableToArrayLimit(r, l) {
var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
if (null != t) {
var e,
n,
i,
u,
a = [],
f = true,
o = false;
try {
if (i = (t = t.call(r)).next, 0 === l) {
if (Object(t) !== t) return;
f = !1;
} else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
} catch (r) {
o = true, n = r;
} finally {
try {
if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
} finally {
if (o) throw n;
}
}
return a;
}
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _possibleConstructorReturn(t, e) {
if (e && ("object" == typeof e || "function" == typeof e)) return e;
if (undefined !== e) throw new TypeError("Derived constructors may only return object or undefined");
return _assertThisInitialized(t);
}
function _regeneratorRuntime() {
_regeneratorRuntime = function () {
return e;
};
var t,
e = {},
r = Object.prototype,
n = r.hasOwnProperty,
o = Object.defineProperty || function (t, e, r) {
t[e] = r.value;
},
i = "function" == typeof Symbol ? Symbol : {},
a = i.iterator || "@@iterator",
c = i.asyncIterator || "@@asyncIterator",
u = i.toStringTag || "@@toStringTag";
function define(t, e, r) {
return Object.defineProperty(t, e, {
value: r,
enumerable: true,
configurable: true,
writable: true
}), t[e];
}
try {
define({}, "");
} catch (t) {
define = function (t, e, r) {
return t[e] = r;
};
}
function wrap(t, e, r, n) {
var i = e && e.prototype instanceof Generator ? e : Generator,
a = Object.create(i.prototype),
c = new Context(n || []);
return o(a, "_invoke", {
value: makeInvokeMethod(t, r, c)
}), a;
}
function tryCatch(t, e, r) {
try {
return {
type: "normal",
arg: t.call(e, r)
};
} catch (t) {
return {
type: "throw",
arg: t
};
}
}
e.wrap = wrap;
var h = "suspendedStart",
l = "suspendedYield",
f = "executing",
s = "completed",
y = {};
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
var p = {};
define(p, a, function () {
return this;
});
var d = Object.getPrototypeOf,
v = d && d(d(values([])));
v && v !== r && n.call(v, a) && (p = v);
var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
function defineIteratorMethods(t) {
["next", "throw", "return"].forEach(function (e) {
define(t, e, function (t) {
return this._invoke(e, t);
});
});
}
function AsyncIterator(t, e) {
function invoke(r, o, i, a) {
var c = tryCatch(t[r], t, o);
if ("throw" !== c.type) {
var u = c.arg,
h = u.value;
return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
invoke("next", t, i, a);
}, function (t) {
invoke("throw", t, i, a);
}) : e.resolve(h).then(function (t) {
u.value = t, i(u);
}, function (t) {
return invoke("throw", t, i, a);
});
}
a(c.arg);
}
var r;
o(this, "_invoke", {
value: function (t, n) {
function callInvokeWithMethodAndArg() {
return new e(function (e, r) {
invoke(t, n, e, r);
});
}
return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
}
});
}
function makeInvokeMethod(e, r, n) {
var o = h;
return function (i, a) {
if (o === f) throw Error("Generator is already running");
if (o === s) {
if ("throw" === i) throw a;
return {
value: t,
done: true
};
}
for (n.method = i, n.arg = a;;) {
var c = n.delegate;
if (c) {
var u = maybeInvokeDelegate(c, n);
if (u) {
if (u === y) continue;
return u;
}
}
if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
if (o === h) throw o = s, n.arg;
n.dispatchException(n.arg);
} else "return" === n.method && n.abrupt("return", n.arg);
o = f;
var p = tryCatch(e, r, n);
if ("normal" === p.type) {
if (o = n.done ? s : l, p.arg === y) continue;
return {
value: p.arg,
done: n.done
};
}
"throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
}
};
}
function maybeInvokeDelegate(e, r) {
var n = r.method,
o = e.iterator[n];
if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
var i = tryCatch(o, e.iterator, r.arg);
if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
var a = i.arg;
return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
}
function pushTryEntry(t) {
var e = {
tryLoc: t[0]
};
1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
}
function resetTryEntry(t) {
var e = t.completion || {};
e.type = "normal", delete e.arg, t.completion = e;
}
function Context(t) {
this.tryEntries = [{
tryLoc: "root"
}], t.forEach(pushTryEntry, this), this.reset(true);
}
function values(e) {
if (e || "" === e) {
var r = e[a];
if (r) return r.call(e);
if ("function" == typeof e.next) return e;
if (!isNaN(e.length)) {
var o = -1,
i = function next() {
for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = false, next;
return next.value = t, next.done = true, next;
};
return i.next = i;
}
}
throw new TypeError(typeof e + " is not iterable");
}
return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
value: GeneratorFunctionPrototype,
configurable: true
}), o(GeneratorFunctionPrototype, "constructor", {
value: GeneratorFunction,
configurable: true
}), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
var e = "function" == typeof t && t.constructor;
return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
}, e.mark = function (t) {
return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
}, e.awrap = function (t) {
return {
__await: t
};
}, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
return this;
}), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
undefined === i && (i = Promise);
var a = new AsyncIterator(wrap(t, r, n, o), i);
return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
return t.done ? t.value : a.next();
});
}, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
return this;
}), define(g, "toString", function () {
return "[object Generator]";
}), e.keys = function (t) {
var e = Object(t),
r = [];
for (var n in e) r.push(n);
return r.reverse(), function next() {
for (; r.length;) {
var t = r.pop();
if (t in e) return next.value = t, next.done = false, next;
}
return next.done = true, next;
};
}, e.values = values, Context.prototype = {
constructor: Context,
reset: function (e) {
if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
},
stop: function () {
this.done = true;
var t = this.tryEntries[0].completion;
if ("throw" === t.type) throw t.arg;
return this.rval;
},
dispatchException: function (e) {
if (this.done) throw e;
var r = this;
function handle(n, o) {
return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
}
for (var o = this.tryEntries.length - 1; o >= 0; --o) {
var i = this.tryEntries[o],
a = i.completion;
if ("root" === i.tryLoc) return handle("end");
if (i.tryLoc <= this.prev) {
var c = n.call(i, "catchLoc"),
u = n.call(i, "finallyLoc");
if (c && u) {
if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
} else if (c) {
if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
} else {
if (!u) throw Error("try statement without catch or finally");
if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
}
}
}
},
abrupt: function (t, e) {
for (var r = this.tryEntries.length - 1; r >= 0; --r) {
var o = this.tryEntries[r];
if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
var i = o;
break;
}
}
i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
var a = i ? i.completion : {};
return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
},
complete: function (t, e) {
if ("throw" === t.type) throw t.arg;
return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
},
finish: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
}
},
catch: function (t) {
for (var e = this.tryEntries.length - 1; e >= 0; --e) {
var r = this.tryEntries[e];
if (r.tryLoc === t) {
var n = r.completion;
if ("throw" === n.type) {
var o = n.arg;
resetTryEntry(r);
}
return o;
}
}
throw Error("illegal catch attempt");
},
delegateYield: function (e, r, n) {
return this.delegate = {
iterator: values(e),
resultName: r,
nextLoc: n
}, "next" === this.method && (this.arg = t), y;
}
}, e;
}
function _setPrototypeOf(t, e) {
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
return t.__proto__ = e, t;
}, _setPrototypeOf(t, e);
}
function _slicedToArray(r, e) {
return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
}
function _superPropBase(t, o) {
for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););
return t;
}
function _superPropGet(t, o, e, r) {
var p = _get(_getPrototypeOf(t.prototype ), o, e);
return "function" == typeof p ? function (t) {
return p.apply(e, t);
} : p;
}
function _toConsumableArray(r) {
return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (undefined !== e) {
var i = e.call(t, r || "default");
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
return typeof o;
} : function (o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ("string" == typeof r) return _arrayLikeToArray(r, a);
var t = {}.toString.call(r).slice(8, -1);
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : undefined;
}
}
var _defaultSpecifiers, _localGet, _utcGet, _timeIntervals, _utcIntervals;
var YEAR = 'year';
var QUARTER = 'quarter';
var MONTH = 'month';
var WEEK = 'week';
var DATE = 'date';
var DAY = 'day';
var DAYOFYEAR = 'dayofyear';
var HOURS = 'hours';
var MINUTES = 'minutes';
var SECONDS = 'seconds';
var MILLISECONDS = 'milliseconds';
var TIME_UNITS = [YEAR, QUARTER, MONTH, WEEK, DATE, DAY, DAYOFYEAR, HOURS, MINUTES, SECONDS, MILLISECONDS];
var UNITS = TIME_UNITS.reduce(function (o, u, i) {
return o[u] = 1 + i, o;
}, {});
function timeUnits(units) {
var u = array$2(units).slice(),
m = {};
// check validity
if (!u.length) error('Missing time unit.');
u.forEach(function (unit) {
if (_has(UNITS, unit)) {
m[unit] = 1;
} else {
error("Invalid time unit: ".concat(unit, "."));
}
});
var numTypes = (m[WEEK] || m[DAY] ? 1 : 0) + (m[QUARTER] || m[MONTH] || m[DATE] ? 1 : 0) + (m[DAYOFYEAR] ? 1 : 0);
if (numTypes > 1) {
error("Incompatible time units: ".concat(units));
}
// ensure proper sort order
u.sort(function (a, b) {
return UNITS[a] - UNITS[b];
});
return u;
}
var defaultSpecifiers = (_defaultSpecifiers = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defaultSpecifiers, YEAR, '%Y '), QUARTER, 'Q%q '), MONTH, '%b '), DATE, '%d '), WEEK, 'W%U '), DAY, '%a '), DAYOFYEAR, '%j '), HOURS, '%H:00'), MINUTES, '00:%M'), SECONDS, ':%S'), _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defaultSpecifiers, MILLISECONDS, '.%L'), "".concat(YEAR, "-").concat(MONTH), '%Y-%m '), "".concat(YEAR, "-").concat(MONTH, "-").concat(DATE), '%Y-%m-%d '), "".concat(HOURS, "-").concat(MINUTES), '%H:%M'));
function timeUnitSpecifier(units, specifiers) {
var s = extend({}, defaultSpecifiers, specifiers),
u = timeUnits(units),
n = u.length;
var fmt = '',
start = 0,
end,
key;
for (start = 0; start < n;) {
for (end = u.length; end > start; --end) {
key = u.slice(start, end).join('-');
if (s[key] != null) {
fmt += s[key];
start = end;
break;
}
}
}
return fmt.trim();
}
var t0 = new Date();
function localYear(y) {
t0.setFullYear(y);
t0.setMonth(0);
t0.setDate(1);
t0.setHours(0, 0, 0, 0);
return t0;
}
function dayofyear(d) {
return localDayOfYear(new Date(d));
}
function week(d) {
return localWeekNum(new Date(d));
}
function localDayOfYear(d) {
return d3Time.timeDay.count(localYear(d.getFullYear()) - 1, d);
}
function localWeekNum(d) {
return d3Time.timeWeek.count(localYear(d.getFullYear()) - 1, d);
}
function localFirst(y) {
return localYear(y).getDay();
}
function localDate(y, m, d, H, M, S, L) {
if (0 <= y && y < 100) {
var date = new Date(-1, m, d, H, M, S, L);
date.setFullYear(y);
return date;
}
return new Date(y, m, d, H, M, S, L);
}
function utcdayofyear(d) {
return utcDayOfYear(new Date(d));
}
function utcweek(d) {
return utcWeekNum(new Date(d));
}
function utcDayOfYear(d) {
var y = Date.UTC(d.getUTCFullYear(), 0, 1);
return d3Time.utcDay.count(y - 1, d);
}
function utcWeekNum(d) {
var y = Date.UTC(d.getUTCFullYear(), 0, 1);
return d3Time.utcWeek.count(y - 1, d);
}
function utcFirst(y) {
t0.setTime(Date.UTC(y, 0, 1));
return t0.getUTCDay();
}
function utcDate(y, m, d, H, M, S, L) {
if (0 <= y && y < 100) {
var date = new Date(Date.UTC(-1, m, d, H, M, S, L));
date.setUTCFullYear(d.y);
return date;
}
return new Date(Date.UTC(y, m, d, H, M, S, L));
}
function floor(units, step, get, inv, newDate) {
var s = step || 1,
b = peek$1(units),
_ = function _(unit, p, key) {
key = key || unit;
return getUnit(get[key], inv[key], unit === b && s, p);
};
var t = new Date(),
u = toSet(units),
y = u[YEAR] ? _(YEAR) : constant$1(2012),
m = u[MONTH] ? _(MONTH) : u[QUARTER] ? _(QUARTER) : zero$1,
d = u[WEEK] && u[DAY] ? _(DAY, 1, WEEK + DAY) : u[WEEK] ? _(WEEK, 1) : u[DAY] ? _(DAY, 1) : u[DATE] ? _(DATE, 1) : u[DAYOFYEAR] ? _(DAYOFYEAR, 1) : one$1,
H = u[HOURS] ? _(HOURS) : zero$1,
M = u[MINUTES] ? _(MINUTES) : zero$1,
S = u[SECONDS] ? _(SECONDS) : zero$1,
L = u[MILLISECONDS] ? _(MILLISECONDS) : zero$1;
return function (v) {
t.setTime(+v);
var year = y(t);
return newDate(year, m(t), d(t, year), H(t), M(t), S(t), L(t));
};
}
function getUnit(f, inv, step, phase) {
var u = step <= 1 ? f : phase ? function (d, y) {
return phase + step * Math.floor((f(d, y) - phase) / step);
} : function (d, y) {
return step * Math.floor(f(d, y) / step);
};
return inv ? function (d, y) {
return inv(u(d, y), y);
} : u;
}
// returns the day of the year based on week number, day of week,
// and the day of the week for the first day of the year
function weekday(week, day, firstDay) {
return day + week * 7 - (firstDay + 6) % 7;
}
// -- LOCAL TIME --
var localGet = (_localGet = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_localGet, YEAR, function (d) {
return d.getFullYear();
}), QUARTER, function (d) {
return Math.floor(d.getMonth() / 3);
}), MONTH, function (d) {
return d.getMonth();
}), DATE, function (d) {
return d.getDate();
}), HOURS, function (d) {
return d.getHours();
}), MINUTES, function (d) {
return d.getMinutes();
}), SECONDS, function (d) {
return d.getSeconds();
}), MILLISECONDS, function (d) {
return d.getMilliseconds();
}), DAYOFYEAR, function (d) {
return localDayOfYear(d);
}), WEEK, function (d) {
return localWeekNum(d);
}), _defineProperty(_defineProperty(_localGet, WEEK + DAY, function (d, y) {
return weekday(localWeekNum(d), d.getDay(), localFirst(y));
}), DAY, function (d, y) {
return weekday(1, d.getDay(), localFirst(y));
}));
var localInv = _defineProperty(_defineProperty({}, QUARTER, function (q) {
return 3 * q;
}), WEEK, function (w, y) {
return weekday(w, 0, localFirst(y));
});
function timeFloor(units, step) {
return floor(units, step || 1, localGet, localInv, localDate);
}
// -- UTC TIME --
var utcGet = (_utcGet = {}, _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_utcGet, YEAR, function (d) {
return d.getUTCFullYear();
}), QUARTER, function (d) {
return Math.floor(d.getUTCMonth() / 3);
}), MONTH, function (d) {
return d.getUTCMonth();
}), DATE, function (d) {
return d.getUTCDate();
}), HOURS, function (d) {
return d.getUTCHours();
}), MINUTES, function