umwd-components 0.1.757 → 0.1.758

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/quantile.js

@@ -0,0 +1,58 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as quantile$1 } from '../../../../../_virtual/quantile.js';
+import '../../d3-array/src/index.js';
+import './init.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+
+Object.defineProperty(quantile$1, "__esModule", {
+  value: true
+});
+quantile$1.default = quantile;
+var _index = src;
+var _init = init;
+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] = (0, _index.quantileSorted)(domain, i / n);
+    return scale;
+  }
+  function scale(x) {
+    return x == null || isNaN(x = +x) ? unknown : range[(0, _index.bisect)(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(_index.ascending);
+    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);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/quantize.js

@@ -0,0 +1,58 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as quantize$1 } from '../../../../../_virtual/quantize.js';
+import '../../d3-array/src/index.js';
+import './linear.js';
+import './init.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as linear } from '../../../../../_virtual/linear2.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+
+Object.defineProperty(quantize$1, "__esModule", {
+  value: true
+});
+quantize$1.default = quantize;
+var _index = src;
+var _linear = linear;
+var _init = init;
+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[(0, _index.bisect)(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((0, _linear.linearish)(scale), arguments);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/radial.js

@@ -0,0 +1,67 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as radial$1 } from '../../../../../_virtual/radial.js';
+import './continuous.js';
+import './init.js';
+import './linear.js';
+import './number.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as linear } from '../../../../../_virtual/linear2.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+import { __exports as number } from '../../../../../_virtual/number.js';
+
+Object.defineProperty(radial$1, "__esModule", {
+  value: true
+});
+radial$1.default = radial;
+var _continuous = _interopRequireDefault(continuous);
+var _init = init;
+var _linear = linear;
+var _number = _interopRequireDefault(number);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function square(x) {
+  return Math.sign(x) * x * x;
+}
+function unsquare(x) {
+  return Math.sign(x) * Math.sqrt(Math.abs(x));
+}
+function radial() {
+  var squared = (0, _continuous.default)(),
+    range = [0, 1],
+    round = false,
+    unknown;
+  function scale(x) {
+    var y = unsquare(squared(x));
+    return isNaN(y) ? unknown : round ? Math.round(y) : y;
+  }
+  scale.invert = function (y) {
+    return squared.invert(square(y));
+  };
+  scale.domain = function (_) {
+    return arguments.length ? (squared.domain(_), scale) : squared.domain();
+  };
+  scale.range = function (_) {
+    return arguments.length ? (squared.range((range = Array.from(_, _number.default)).map(square)), scale) : range.slice();
+  };
+  scale.rangeRound = function (_) {
+    return scale.range(_).round(true);
+  };
+  scale.round = function (_) {
+    return arguments.length ? (round = !!_, scale) : round;
+  };
+  scale.clamp = function (_) {
+    return arguments.length ? (squared.clamp(_), scale) : squared.clamp();
+  };
+  scale.unknown = function (_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  scale.copy = function () {
+    return radial(squared.domain(), range).round(round).clamp(squared.clamp()).unknown(unknown);
+  };
+  _init.initRange.apply(scale, arguments);
+  return (0, _linear.linearish)(scale);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/sequential.js

@@ -0,0 +1,110 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as sequential$1 } from '../../../../../_virtual/sequential.js';
+import '../../d3-interpolate/src/index.js';
+import './continuous.js';
+import './init.js';
+import './linear.js';
+import './log.js';
+import './symlog.js';
+import './pow.js';
+import { __exports as linear } from '../../../../../_virtual/linear2.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as log } from '../../../../../_virtual/log.js';
+import { __exports as symlog } from '../../../../../_virtual/symlog.js';
+import { __exports as pow } from '../../../../../_virtual/pow.js';
+import { __exports as src } from '../../../../../_virtual/index17.js';
+
+Object.defineProperty(sequential$1, "__esModule", {
+  value: true
+});
+sequential$1.copy = copy;
+sequential$1.default = sequential;
+sequential$1.sequentialLog = sequentialLog;
+sequential$1.sequentialPow = sequentialPow;
+sequential$1.sequentialSqrt = sequentialSqrt;
+sequential$1.sequentialSymlog = sequentialSymlog;
+var _index = src;
+var _continuous = continuous;
+var _init = init;
+var _linear = linear;
+var _log = log;
+var _symlog = symlog;
+var _pow = pow;
+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(_index.interpolate);
+  scale.rangeRound = range(_index.interpolateRound);
+  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 = (0, _linear.linearish)(transformer()(_continuous.identity));
+  scale.copy = function () {
+    return copy(scale, sequential());
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}
+function sequentialLog() {
+  var scale = (0, _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 = (0, _symlog.symlogish)(transformer());
+  scale.copy = function () {
+    return copy(scale, sequentialSymlog()).constant(scale.constant());
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}
+function sequentialPow() {
+  var scale = (0, _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);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/sequentialQuantile.js

@@ -0,0 +1,50 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as sequentialQuantile$1 } from '../../../../../_virtual/sequentialQuantile.js';
+import '../../d3-array/src/index.js';
+import './continuous.js';
+import './init.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+
+Object.defineProperty(sequentialQuantile$1, "__esModule", {
+  value: true
+});
+sequentialQuantile$1.default = sequentialQuantile;
+var _index = src;
+var _continuous = continuous;
+var _init = init;
+function sequentialQuantile() {
+  var domain = [],
+    interpolator = _continuous.identity;
+  function scale(x) {
+    if (x != null && !isNaN(x = +x)) return interpolator(((0, _index.bisect)(domain, x, 1) - 1) / (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(_index.ascending);
+    return scale;
+  };
+  scale.interpolator = function (_) {
+    return arguments.length ? (interpolator = _, scale) : interpolator;
+  };
+  scale.range = function () {
+    return domain.map((d, i) => interpolator(i / (domain.length - 1)));
+  };
+  scale.quantiles = function (n) {
+    return Array.from({
+      length: n + 1
+    }, (_, i) => (0, _index.quantile)(domain, i / n));
+  };
+  scale.copy = function () {
+    return sequentialQuantile(interpolator).domain(domain);
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/symlog.js

@@ -0,0 +1,47 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as symlog$1 } from '../../../../../_virtual/symlog.js';
+import './linear.js';
+import './continuous.js';
+import './init.js';
+import { __exports as linear } from '../../../../../_virtual/linear2.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+
+Object.defineProperty(symlog$1, "__esModule", {
+  value: true
+});
+symlog$1.default = symlog;
+symlog$1.symlogish = symlogish;
+var _linear = linear;
+var _continuous = continuous;
+var _init = init;
+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 (0, _linear.linearish)(scale);
+}
+function symlog() {
+  var scale = symlogish((0, _continuous.transformer)());
+  scale.copy = function () {
+    return (0, _continuous.copy)(scale, symlog()).constant(scale.constant());
+  };
+  return _init.initRange.apply(scale, arguments);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/threshold.js

@@ -0,0 +1,44 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as threshold$1 } from '../../../../../_virtual/threshold.js';
+import '../../d3-array/src/index.js';
+import './init.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+
+Object.defineProperty(threshold$1, "__esModule", {
+  value: true
+});
+threshold$1.default = threshold;
+var _index = src;
+var _init = init;
+function threshold() {
+  var domain = [0.5],
+    range = [0, 1],
+    unknown,
+    n = 1;
+  function scale(x) {
+    return x != null && x <= x ? range[(0, _index.bisect)(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);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/tickFormat.js

@@ -0,0 +1,47 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as tickFormat$1 } from '../../../../../_virtual/tickFormat.js';
+import '../../d3-array/src/index.js';
+import '../../d3-format/src/index.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+import { __exports as src$1 } from '../../../../../_virtual/index14.js';
+
+Object.defineProperty(tickFormat$1, "__esModule", {
+  value: true
+});
+tickFormat$1.default = tickFormat;
+var _index = src;
+var _index2 = src$1;
+function tickFormat(start, stop, count, specifier) {
+  var step = (0, _index.tickStep)(start, stop, count),
+    precision;
+  specifier = (0, _index2.formatSpecifier)(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 = (0, _index2.precisionPrefix)(step, value))) specifier.precision = precision;
+        return (0, _index2.formatPrefix)(specifier, value);
+      }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r":
+      {
+        if (specifier.precision == null && !isNaN(precision = (0, _index2.precisionRound)(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 = (0, _index2.precisionFixed)(step))) specifier.precision = precision - (specifier.type === "%") * 2;
+        break;
+      }
+  }
+  return (0, _index2.format)(specifier);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/time.js

@@ -0,0 +1,78 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as time$1 } from '../../../../../_virtual/time.js';
+import '../../d3-time/src/index.js';
+import '../../d3-time-format/src/index.js';
+import './continuous.js';
+import './init.js';
+import './nice.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as src } from '../../../../../_virtual/index15.js';
+import { __exports as src$1 } from '../../../../../_virtual/index16.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+import { __exports as nice } from '../../../../../_virtual/nice.js';
+
+Object.defineProperty(time$1, "__esModule", {
+  value: true
+});
+time$1.calendar = calendar;
+time$1.default = time;
+var _index = src$1;
+var _index2 = src;
+var _continuous = _interopRequireWildcard(continuous);
+var _init = init;
+var _nice = _interopRequireDefault(nice);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 = (0, _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((0, _nice.default)(d, interval)) : scale;
+  };
+  scale.copy = function () {
+    return (0, _continuous.copy)(scale, calendar(ticks, tickInterval, year, month, week, day, hour, minute, second, format));
+  };
+  return scale;
+}
+function time() {
+  return _init.initRange.apply(calendar(_index.timeTicks, _index.timeTickInterval, _index.timeYear, _index.timeMonth, _index.timeWeek, _index.timeDay, _index.timeHour, _index.timeMinute, _index.timeSecond, _index2.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]), arguments);
+}

package/dist/esm/node_modules/victory-vendor/lib-vendor/d3-scale/src/utcTime.js

@@ -0,0 +1,27 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as utcTime$1 } from '../../../../../_virtual/utcTime.js';
+import '../../d3-time/src/index.js';
+import '../../d3-time-format/src/index.js';
+import './time.js';
+import './init.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as time } from '../../../../../_virtual/time.js';
+import { __exports as src } from '../../../../../_virtual/index16.js';
+import { __exports as src$1 } from '../../../../../_virtual/index15.js';
+
+Object.defineProperty(utcTime$1, "__esModule", {
+  value: true
+});
+utcTime$1.default = utcTime;
+var _index = src;
+var _index2 = src$1;
+var _time = time;
+var _init = init;
+function utcTime() {
+  return _init.initRange.apply((0, _time.calendar)(_index.utcTicks, _index.utcTickInterval, _index.utcYear, _index.utcMonth, _index.utcWeek, _index.utcDay, _index.utcHour, _index.utcMinute, _index.utcSecond, _index2.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]), arguments);
+}