@veritone-ce/design-system 2.9.0-next.2 → 2.9.0-next.3

package/dist/cjs/bundled_modules/d3-scale/src/pow.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var linear = require('./linear.js');
+var continuous = require('./continuous.js');
+var init = require('./init.js');
+
+function transformPow(exponent) {
+  return function(x) {
+    return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);
+  };
+}
+
+function transformSqrt(x) {
+  return x < 0 ? -Math.sqrt(-x) : Math.sqrt(x);
+}
+
+function transformSquare(x) {
+  return x < 0 ? -x * x : x * x;
+}
+
+function powish(transform) {
+  var scale = transform(continuous.identity, continuous.identity),
+      exponent = 1;
+
+  function rescale() {
+    return exponent === 1 ? transform(continuous.identity, continuous.identity)
+        : exponent === 0.5 ? transform(transformSqrt, transformSquare)
+        : transform(transformPow(exponent), transformPow(1 / exponent));
+  }
+
+  scale.exponent = function(_) {
+    return arguments.length ? (exponent = +_, rescale()) : exponent;
+  };
+
+  return linear.linearish(scale);
+}
+
+function pow() {
+  var scale = powish(continuous.transformer());
+
+  scale.copy = function() {
+    return continuous.copy(scale, pow()).exponent(scale.exponent());
+  };
+
+  init.initRange.apply(scale, arguments);
+
+  return scale;
+}
+
+function sqrt() {
+  return pow.apply(null, arguments).exponent(0.5);
+}
+
+exports.default = pow;
+exports.powish = powish;
+exports.sqrt = sqrt;

package/dist/cjs/bundled_modules/d3-scale/src/quantile.js

@@ -0,0 +1,65 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var init = require('./init.js');
+var ascending = require('../../d3-array/src/ascending.js');
+var quantile$1 = require('../../d3-array/src/quantile.js');
+var bisect = require('../../d3-array/src/bisect.js');
+
+function quantile() {
+  var domain = [],
+      range = [],
+      thresholds = [],
+      unknown;
+
+  function rescale() {
+    var i = 0, n = Math.max(1, range.length);
+    thresholds = new Array(n - 1);
+    while (++i < n) thresholds[i - 1] = quantile$1.quantileSorted(domain, i / n);
+    return scale;
+  }
+
+  function scale(x) {
+    return x == null || isNaN(x = +x) ? unknown : range[bisect.bisectRight(thresholds, x)];
+  }
+
+  scale.invertExtent = function(y) {
+    var i = range.indexOf(y);
+    return i < 0 ? [NaN, NaN] : [
+      i > 0 ? thresholds[i - 1] : domain[0],
+      i < thresholds.length ? thresholds[i] : domain[domain.length - 1]
+    ];
+  };
+
+  scale.domain = function(_) {
+    if (!arguments.length) return domain.slice();
+    domain = [];
+    for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);
+    domain.sort(ascending.default);
+    return rescale();
+  };
+
+  scale.range = function(_) {
+    return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+  };
+
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+
+  scale.quantiles = function() {
+    return thresholds.slice();
+  };
+
+  scale.copy = function() {
+    return quantile()
+        .domain(domain)
+        .range(range)
+        .unknown(unknown);
+  };
+
+  return init.initRange.apply(scale, arguments);
+}
+
+exports.default = quantile;

package/dist/cjs/bundled_modules/d3-scale/src/quantize.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var linear = require('./linear.js');
+var init = require('./init.js');
+var bisect = require('../../d3-array/src/bisect.js');
+
+function quantize() {
+  var x0 = 0,
+      x1 = 1,
+      n = 1,
+      domain = [0.5],
+      range = [0, 1],
+      unknown;
+
+  function scale(x) {
+    return x != null && x <= x ? range[bisect.bisectRight(domain, x, 0, n)] : unknown;
+  }
+
+  function rescale() {
+    var i = -1;
+    domain = new Array(n);
+    while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);
+    return scale;
+  }
+
+  scale.domain = function(_) {
+    return arguments.length ? ([x0, x1] = _, x0 = +x0, x1 = +x1, rescale()) : [x0, x1];
+  };
+
+  scale.range = function(_) {
+    return arguments.length ? (n = (range = Array.from(_)).length - 1, rescale()) : range.slice();
+  };
+
+  scale.invertExtent = function(y) {
+    var i = range.indexOf(y);
+    return i < 0 ? [NaN, NaN]
+        : i < 1 ? [x0, domain[0]]
+        : i >= n ? [domain[n - 1], x1]
+        : [domain[i - 1], domain[i]];
+  };
+
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : scale;
+  };
+
+  scale.thresholds = function() {
+    return domain.slice();
+  };
+
+  scale.copy = function() {
+    return quantize()
+        .domain([x0, x1])
+        .range(range)
+        .unknown(unknown);
+  };
+
+  return init.initRange.apply(linear.linearish(scale), arguments);
+}
+
+exports.default = quantize;

package/dist/cjs/bundled_modules/d3-scale/src/sequential.js

@@ -0,0 +1,119 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var continuous = require('./continuous.js');
+var init = require('./init.js');
+var linear = require('./linear.js');
+var log = require('./log.js');
+var symlog = require('./symlog.js');
+var pow = require('./pow.js');
+var value = require('../../d3-interpolate/src/value.js');
+var round = require('../../d3-interpolate/src/round.js');
+
+function transformer() {
+  var x0 = 0,
+      x1 = 1,
+      t0,
+      t1,
+      k10,
+      transform,
+      interpolator = continuous.identity,
+      clamp = false,
+      unknown;
+
+  function scale(x) {
+    return x == null || isNaN(x = +x) ? unknown : interpolator(k10 === 0 ? 0.5 : (x = (transform(x) - t0) * k10, clamp ? Math.max(0, Math.min(1, x)) : x));
+  }
+
+  scale.domain = function(_) {
+    return arguments.length ? ([x0, x1] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0), scale) : [x0, x1];
+  };
+
+  scale.clamp = function(_) {
+    return arguments.length ? (clamp = !!_, scale) : clamp;
+  };
+
+  scale.interpolator = function(_) {
+    return arguments.length ? (interpolator = _, scale) : interpolator;
+  };
+
+  function range(interpolate) {
+    return function(_) {
+      var r0, r1;
+      return arguments.length ? ([r0, r1] = _, interpolator = interpolate(r0, r1), scale) : [interpolator(0), interpolator(1)];
+    };
+  }
+
+  scale.range = range(value.default);
+
+  scale.rangeRound = range(round.default);
+
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+
+  return function(t) {
+    transform = t, t0 = t(x0), t1 = t(x1), k10 = t0 === t1 ? 0 : 1 / (t1 - t0);
+    return scale;
+  };
+}
+
+function copy(source, target) {
+  return target
+      .domain(source.domain())
+      .interpolator(source.interpolator())
+      .clamp(source.clamp())
+      .unknown(source.unknown());
+}
+
+function sequential() {
+  var scale = linear.linearish(transformer()(continuous.identity));
+
+  scale.copy = function() {
+    return copy(scale, sequential());
+  };
+
+  return init.initInterpolator.apply(scale, arguments);
+}
+
+function sequentialLog() {
+  var scale = log.loggish(transformer()).domain([1, 10]);
+
+  scale.copy = function() {
+    return copy(scale, sequentialLog()).base(scale.base());
+  };
+
+  return init.initInterpolator.apply(scale, arguments);
+}
+
+function sequentialSymlog() {
+  var scale = symlog.symlogish(transformer());
+
+  scale.copy = function() {
+    return copy(scale, sequentialSymlog()).constant(scale.constant());
+  };
+
+  return init.initInterpolator.apply(scale, arguments);
+}
+
+function sequentialPow() {
+  var scale = pow.powish(transformer());
+
+  scale.copy = function() {
+    return copy(scale, sequentialPow()).exponent(scale.exponent());
+  };
+
+  return init.initInterpolator.apply(scale, arguments);
+}
+
+function sequentialSqrt() {
+  return sequentialPow.apply(null, arguments).exponent(0.5);
+}
+
+exports.copy = copy;
+exports.default = sequential;
+exports.sequentialLog = sequentialLog;
+exports.sequentialPow = sequentialPow;
+exports.sequentialSqrt = sequentialSqrt;
+exports.sequentialSymlog = sequentialSymlog;

package/dist/cjs/bundled_modules/d3-scale/src/symlog.js

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var linear = require('./linear.js');
+var continuous = require('./continuous.js');
+var init = require('./init.js');
+
+function transformSymlog(c) {
+  return function(x) {
+    return Math.sign(x) * Math.log1p(Math.abs(x / c));
+  };
+}
+
+function transformSymexp(c) {
+  return function(x) {
+    return Math.sign(x) * Math.expm1(Math.abs(x)) * c;
+  };
+}
+
+function symlogish(transform) {
+  var c = 1, scale = transform(transformSymlog(c), transformSymexp(c));
+
+  scale.constant = function(_) {
+    return arguments.length ? transform(transformSymlog(c = +_), transformSymexp(c)) : c;
+  };
+
+  return linear.linearish(scale);
+}
+
+function symlog() {
+  var scale = symlogish(continuous.transformer());
+
+  scale.copy = function() {
+    return continuous.copy(scale, symlog()).constant(scale.constant());
+  };
+
+  return init.initRange.apply(scale, arguments);
+}
+
+exports.default = symlog;
+exports.symlogish = symlogish;

package/dist/cjs/bundled_modules/d3-scale/src/threshold.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var init = require('./init.js');
+var bisect = require('../../d3-array/src/bisect.js');
+
+function threshold() {
+  var domain = [0.5],
+      range = [0, 1],
+      unknown,
+      n = 1;
+
+  function scale(x) {
+    return x != null && x <= x ? range[bisect.bisectRight(domain, x, 0, n)] : unknown;
+  }
+
+  scale.domain = function(_) {
+    return arguments.length ? (domain = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice();
+  };
+
+  scale.range = function(_) {
+    return arguments.length ? (range = Array.from(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice();
+  };
+
+  scale.invertExtent = function(y) {
+    var i = range.indexOf(y);
+    return [domain[i - 1], domain[i]];
+  };
+
+  scale.unknown = function(_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+
+  scale.copy = function() {
+    return threshold()
+        .domain(domain)
+        .range(range)
+        .unknown(unknown);
+  };
+
+  return init.initRange.apply(scale, arguments);
+}
+
+exports.default = threshold;

package/dist/cjs/bundled_modules/d3-scale/src/tickFormat.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ticks = require('../../d3-array/src/ticks.js');
+var formatSpecifier = require('../../d3-format/src/formatSpecifier.js');
+var precisionFixed = require('../../d3-format/src/precisionFixed.js');
+var precisionRound = require('../../d3-format/src/precisionRound.js');
+var precisionPrefix = require('../../d3-format/src/precisionPrefix.js');
+var defaultLocale = require('../../d3-format/src/defaultLocale.js');
+
+function tickFormat(start, stop, count, specifier) {
+  var step = ticks.tickStep(start, stop, count),
+      precision;
+  specifier = formatSpecifier.default(specifier == null ? ",f" : specifier);
+  switch (specifier.type) {
+    case "s": {
+      var value = Math.max(Math.abs(start), Math.abs(stop));
+      if (specifier.precision == null && !isNaN(precision = precisionPrefix.default(step, value))) specifier.precision = precision;
+      return defaultLocale.formatPrefix(specifier, value);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      if (specifier.precision == null && !isNaN(precision = precisionRound.default(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
+      break;
+    }
+    case "f":
+    case "%": {
+      if (specifier.precision == null && !isNaN(precision = precisionFixed.default(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+      break;
+    }
+  }
+  return defaultLocale.format(specifier);
+}
+
+exports.default = tickFormat;

package/dist/cjs/bundled_modules/d3-scale/src/time.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var continuous = require('./continuous.js');
+var init = require('./init.js');
+var nice = require('./nice.js');
+var defaultLocale = require('../../d3-time-format/src/defaultLocale.js');
+var second = require('../../d3-time/src/second.js');
+var minute = require('../../d3-time/src/minute.js');
+var hour = require('../../d3-time/src/hour.js');
+var day = require('../../d3-time/src/day.js');
+var week = require('../../d3-time/src/week.js');
+var month = require('../../d3-time/src/month.js');
+var year = require('../../d3-time/src/year.js');
+var ticks = require('../../d3-time/src/ticks.js');
+
+function date(t) {
+  return new Date(t);
+}
+
+function number(t) {
+  return t instanceof Date ? +t : +new Date(+t);
+}
+
+function calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format) {
+  var scale = continuous.default(),
+      invert = scale.invert,
+      domain = scale.domain;
+
+  var formatMillisecond = format(".%L"),
+      formatSecond = format(":%S"),
+      formatMinute = format("%I:%M"),
+      formatHour = format("%I %p"),
+      formatDay = format("%a %d"),
+      formatWeek = format("%b %d"),
+      formatMonth = format("%B"),
+      formatYear = format("%Y");
+
+  function tickFormat(date) {
+    return (second(date) < date ? formatMillisecond
+        : minute(date) < date ? formatSecond
+        : hour(date) < date ? formatMinute
+        : day(date) < date ? formatHour
+        : month(date) < date ? (week(date) < date ? formatDay : formatWeek)
+        : year(date) < date ? formatMonth
+        : formatYear)(date);
+  }
+
+  scale.invert = function(y) {
+    return new Date(invert(y));
+  };
+
+  scale.domain = function(_) {
+    return arguments.length ? domain(Array.from(_, number)) : domain().map(date);
+  };
+
+  scale.ticks = function(interval) {
+    var d = domain();
+    return ticks(d[0], d[d.length - 1], interval == null ? 10 : interval);
+  };
+
+  scale.tickFormat = function(count, specifier) {
+    return specifier == null ? tickFormat : format(specifier);
+  };
+
+  scale.nice = function(interval) {
+    var d = domain();
+    if (!interval || typeof interval.range !== "function") interval = tickInterval(d[0], d[d.length - 1], interval == null ? 10 : interval);
+    return interval ? domain(nice.default(d, interval)) : scale;
+  };
+
+  scale.copy = function() {
+    return continuous.copy(scale, calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format));
+  };
+
+  return scale;
+}
+
+function time() {
+  return init.initRange.apply(calendar(ticks.timeTicks, ticks.timeTickInterval, year.timeYear, month.timeMonth, week.timeSunday, day.timeDay, hour.timeHour, minute.timeMinute, second.second, defaultLocale.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]), arguments);
+}
+
+exports.calendar = calendar;
+exports.default = time;

package/dist/cjs/bundled_modules/d3-scale/src/utcTime.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var time = require('./time.js');
+var init = require('./init.js');
+var defaultLocale = require('../../d3-time-format/src/defaultLocale.js');
+var second = require('../../d3-time/src/second.js');
+var minute = require('../../d3-time/src/minute.js');
+var hour = require('../../d3-time/src/hour.js');
+var day = require('../../d3-time/src/day.js');
+var week = require('../../d3-time/src/week.js');
+var month = require('../../d3-time/src/month.js');
+var year = require('../../d3-time/src/year.js');
+var ticks = require('../../d3-time/src/ticks.js');
+
+function utcTime() {
+  return init.initRange.apply(time.calendar(ticks.utcTicks, ticks.utcTickInterval, year.utcYear, month.utcMonth, week.utcSunday, day.utcDay, hour.utcHour, minute.utcMinute, second.second, defaultLocale.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]), arguments);
+}
+
+exports.default = utcTime;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Accent.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeAccent = colors.default("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666");
+
+exports.default = schemeAccent;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Dark2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeDark2 = colors.default("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666");
+
+exports.default = schemeDark2;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Paired.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemePaired = colors.default("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928");
+
+exports.default = schemePaired;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Pastel1.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemePastel1 = colors.default("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2");
+
+exports.default = schemePastel1;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Pastel2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemePastel2 = colors.default("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc");
+
+exports.default = schemePastel2;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Set1.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeSet1 = colors.default("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999");
+
+exports.default = schemeSet1;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Set2.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeSet2 = colors.default("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3");
+
+exports.default = schemeSet2;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/Set3.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeSet3 = colors.default("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f");
+
+exports.default = schemeSet3;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/category10.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeCategory10 = colors.default("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf");
+
+exports.default = schemeCategory10;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/categorical/observable10.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var colors = require('../colors.js');
+
+var schemeObservable10 = colors.default("4269d0efb118ff725c6cc5b03ca951ff8ab7a463f297bbf59c6b4e9498a0");
+
+exports.default = schemeObservable10;

package/dist/cjs/bundled_modules/d3-scale-chromatic/src/colors.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function colors(specifier) {
+  var n = specifier.length / 6 | 0, colors = new Array(n), i = 0;
+  while (i < n) colors[i] = "#" + specifier.slice(i * 6, ++i * 6);
+  return colors;
+}
+
+exports.default = colors;