umwd-components 0.1.757 → 0.1.758

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

@@ -0,0 +1,138 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as path$1 } from '../../../../../_virtual/path.js';
+
+Object.defineProperty(path$1, "__esModule", {
+  value: true
+});
+path$1.default = void 0;
+const pi = Math.PI,
+  tau = 2 * pi,
+  epsilon = 1e-6,
+  tauEpsilon = tau - epsilon;
+function Path() {
+  this._x0 = this._y0 =
+  // start of current subpath
+  this._x1 = this._y1 = null; // end of current subpath
+  this._ = "";
+}
+function path() {
+  return new Path();
+}
+Path.prototype = path.prototype = {
+  constructor: Path,
+  moveTo: function (x, y) {
+    this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y);
+  },
+  closePath: function () {
+    if (this._x1 !== null) {
+      this._x1 = this._x0, this._y1 = this._y0;
+      this._ += "Z";
+    }
+  },
+  lineTo: function (x, y) {
+    this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y);
+  },
+  quadraticCurveTo: function (x1, y1, x, y) {
+    this._ += "Q" + +x1 + "," + +y1 + "," + (this._x1 = +x) + "," + (this._y1 = +y);
+  },
+  bezierCurveTo: function (x1, y1, x2, y2, x, y) {
+    this._ += "C" + +x1 + "," + +y1 + "," + +x2 + "," + +y2 + "," + (this._x1 = +x) + "," + (this._y1 = +y);
+  },
+  arcTo: function (x1, y1, x2, y2, r) {
+    x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
+    var x0 = this._x1,
+      y0 = this._y1,
+      x21 = x2 - x1,
+      y21 = y2 - y1,
+      x01 = x0 - x1,
+      y01 = y0 - y1,
+      l01_2 = x01 * x01 + y01 * y01;
+
+    // Is the radius negative? Error.
+    if (r < 0) throw new Error("negative radius: " + r);
+
+    // Is this path empty? Move to (x1,y1).
+    if (this._x1 === null) {
+      this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
+    }
+
+    // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
+    else if (!(l01_2 > epsilon)) ;
+
+    // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
+    // Equivalently, is (x1,y1) coincident with (x2,y2)?
+    // Or, is the radius zero? Line to (x1,y1).
+    else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) {
+      this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
+    }
+
+    // Otherwise, draw an arc!
+    else {
+      var x20 = x2 - x0,
+        y20 = y2 - y0,
+        l21_2 = x21 * x21 + y21 * y21,
+        l20_2 = x20 * x20 + y20 * y20,
+        l21 = Math.sqrt(l21_2),
+        l01 = Math.sqrt(l01_2),
+        l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),
+        t01 = l / l01,
+        t21 = l / l21;
+
+      // If the start tangent is not coincident with (x0,y0), line to.
+      if (Math.abs(t01 - 1) > epsilon) {
+        this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
+      }
+      this._ += "A" + r + "," + r + ",0,0," + +(y01 * x20 > x01 * y20) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
+    }
+  },
+  arc: function (x, y, r, a0, a1, ccw) {
+    x = +x, y = +y, r = +r, ccw = !!ccw;
+    var dx = r * Math.cos(a0),
+      dy = r * Math.sin(a0),
+      x0 = x + dx,
+      y0 = y + dy,
+      cw = 1 ^ ccw,
+      da = ccw ? a0 - a1 : a1 - a0;
+
+    // Is the radius negative? Error.
+    if (r < 0) throw new Error("negative radius: " + r);
+
+    // Is this path empty? Move to (x0,y0).
+    if (this._x1 === null) {
+      this._ += "M" + x0 + "," + y0;
+    }
+
+    // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).
+    else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) {
+      this._ += "L" + x0 + "," + y0;
+    }
+
+    // Is this arc empty? We’re done.
+    if (!r) return;
+
+    // Does the angle go the wrong way? Flip the direction.
+    if (da < 0) da = da % tau + tau;
+
+    // Is this a complete circle? Draw two arcs to complete the circle.
+    if (da > tauEpsilon) {
+      this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0);
+    }
+
+    // Is this arc non-empty? Draw an arc!
+    else if (da > epsilon) {
+      this._ += "A" + r + "," + r + ",0," + +(da >= pi) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1));
+    }
+  },
+  rect: function (x, y, w, h) {
+    this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + +w + "v" + +h + "h" + -w + "Z";
+  },
+  toString: function () {
+    return this._;
+  }
+};
+path$1.default = path;

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

@@ -0,0 +1,99 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as band$1 } from '../../../../../_virtual/band.js';
+import '../../d3-array/src/index.js';
+import './init.js';
+import './ordinal.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+import { __exports as ordinal } from '../../../../../_virtual/ordinal.js';
+
+Object.defineProperty(band$1, "__esModule", {
+  value: true
+});
+band$1.default = band;
+band$1.point = point;
+var _index = src;
+var _init = init;
+var _ordinal = _interopRequireDefault(ordinal);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function band() {
+  var scale = (0, _ordinal.default)().unknown(undefined),
+    domain = scale.domain,
+    ordinalRange = scale.range,
+    r0 = 0,
+    r1 = 1,
+    step,
+    bandwidth,
+    round = false,
+    paddingInner = 0,
+    paddingOuter = 0,
+    align = 0.5;
+  delete scale.unknown;
+  function rescale() {
+    var n = domain().length,
+      reverse = r1 < r0,
+      start = reverse ? r1 : r0,
+      stop = reverse ? r0 : r1;
+    step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
+    if (round) step = Math.floor(step);
+    start += (stop - start - step * (n - paddingInner)) * align;
+    bandwidth = step * (1 - paddingInner);
+    if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
+    var values = (0, _index.range)(n).map(function (i) {
+      return start + step * i;
+    });
+    return ordinalRange(reverse ? values.reverse() : values);
+  }
+  scale.domain = function (_) {
+    return arguments.length ? (domain(_), rescale()) : domain();
+  };
+  scale.range = function (_) {
+    return arguments.length ? ([r0, r1] = _, r0 = +r0, r1 = +r1, rescale()) : [r0, r1];
+  };
+  scale.rangeRound = function (_) {
+    return [r0, r1] = _, r0 = +r0, r1 = +r1, round = true, rescale();
+  };
+  scale.bandwidth = function () {
+    return bandwidth;
+  };
+  scale.step = function () {
+    return step;
+  };
+  scale.round = function (_) {
+    return arguments.length ? (round = !!_, rescale()) : round;
+  };
+  scale.padding = function (_) {
+    return arguments.length ? (paddingInner = Math.min(1, paddingOuter = +_), rescale()) : paddingInner;
+  };
+  scale.paddingInner = function (_) {
+    return arguments.length ? (paddingInner = Math.min(1, _), rescale()) : paddingInner;
+  };
+  scale.paddingOuter = function (_) {
+    return arguments.length ? (paddingOuter = +_, rescale()) : paddingOuter;
+  };
+  scale.align = function (_) {
+    return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
+  };
+  scale.copy = function () {
+    return band(domain(), [r0, r1]).round(round).paddingInner(paddingInner).paddingOuter(paddingOuter).align(align);
+  };
+  return _init.initRange.apply(rescale(), arguments);
+}
+function pointish(scale) {
+  var copy = scale.copy;
+  scale.padding = scale.paddingOuter;
+  delete scale.paddingInner;
+  delete scale.paddingOuter;
+  scale.copy = function () {
+    return pointish(copy());
+  };
+  return scale;
+}
+function point() {
+  return pointish(band.apply(null, arguments).paddingInner(1));
+}

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

@@ -0,0 +1,17 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as constant } from '../../../../../_virtual/constant2.js';
+
+Object.defineProperty(constant, "__esModule", {
+  value: true
+});
+constant.default = constants;
+function constants(x) {
+  return function () {
+    return x;
+  };
+}

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

@@ -0,0 +1,130 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as continuous$1 } from '../../../../../_virtual/continuous.js';
+import '../../d3-array/src/index.js';
+import '../../d3-interpolate/src/index.js';
+import './constant.js';
+import './number.js';
+import { __exports as src } from '../../../../../_virtual/index17.js';
+import { __exports as number } from '../../../../../_virtual/number.js';
+import { __exports as src$1 } from '../../../../../_virtual/index13.js';
+import { __exports as constant } from '../../../../../_virtual/constant2.js';
+
+Object.defineProperty(continuous$1, "__esModule", {
+  value: true
+});
+continuous$1.copy = copy;
+continuous$1.default = continuous;
+continuous$1.identity = identity;
+continuous$1.transformer = transformer;
+var _index = src$1;
+var _index2 = src;
+var _constant = _interopRequireDefault(constant);
+var _number = _interopRequireDefault(number);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var unit = [0, 1];
+function identity(x) {
+  return x;
+}
+function normalize(a, b) {
+  return (b -= a = +a) ? function (x) {
+    return (x - a) / b;
+  } : (0, _constant.default)(isNaN(b) ? NaN : 0.5);
+}
+function clamper(a, b) {
+  var t;
+  if (a > b) t = a, a = b, b = t;
+  return function (x) {
+    return Math.max(a, Math.min(b, x));
+  };
+}
+
+// normalize(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].
+// interpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding range value x in [a,b].
+function bimap(domain, range, interpolate) {
+  var d0 = domain[0],
+    d1 = domain[1],
+    r0 = range[0],
+    r1 = range[1];
+  if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
+  return function (x) {
+    return r0(d0(x));
+  };
+}
+function polymap(domain, range, interpolate) {
+  var j = Math.min(domain.length, range.length) - 1,
+    d = new Array(j),
+    r = new Array(j),
+    i = -1;
+
+  // Reverse descending domains.
+  if (domain[j] < domain[0]) {
+    domain = domain.slice().reverse();
+    range = range.slice().reverse();
+  }
+  while (++i < j) {
+    d[i] = normalize(domain[i], domain[i + 1]);
+    r[i] = interpolate(range[i], range[i + 1]);
+  }
+  return function (x) {
+    var i = (0, _index.bisect)(domain, x, 1, j) - 1;
+    return r[i](d[i](x));
+  };
+}
+function copy(source, target) {
+  return target.domain(source.domain()).range(source.range()).interpolate(source.interpolate()).clamp(source.clamp()).unknown(source.unknown());
+}
+function transformer() {
+  var domain = unit,
+    range = unit,
+    interpolate = _index2.interpolate,
+    transform,
+    untransform,
+    unknown,
+    clamp = identity,
+    piecewise,
+    output,
+    input;
+  function rescale() {
+    var n = Math.min(domain.length, range.length);
+    if (clamp !== identity) clamp = clamper(domain[0], domain[n - 1]);
+    piecewise = n > 2 ? polymap : bimap;
+    output = input = null;
+    return scale;
+  }
+  function scale(x) {
+    return x == null || isNaN(x = +x) ? unknown : (output || (output = piecewise(domain.map(transform), range, interpolate)))(transform(clamp(x)));
+  }
+  scale.invert = function (y) {
+    return clamp(untransform((input || (input = piecewise(range, domain.map(transform), _index2.interpolateNumber)))(y)));
+  };
+  scale.domain = function (_) {
+    return arguments.length ? (domain = Array.from(_, _number.default), rescale()) : domain.slice();
+  };
+  scale.range = function (_) {
+    return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+  };
+  scale.rangeRound = function (_) {
+    return range = Array.from(_), interpolate = _index2.interpolateRound, rescale();
+  };
+  scale.clamp = function (_) {
+    return arguments.length ? (clamp = _ ? true : identity, rescale()) : clamp !== identity;
+  };
+  scale.interpolate = function (_) {
+    return arguments.length ? (interpolate = _, rescale()) : interpolate;
+  };
+  scale.unknown = function (_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  return function (t, u) {
+    transform = t, untransform = u;
+    return rescale();
+  };
+}
+function continuous() {
+  return transformer()(identity, identity);
+}

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

@@ -0,0 +1,113 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as diverging$1 } from '../../../../../_virtual/diverging2.js';
+import '../../d3-interpolate/src/index.js';
+import './continuous.js';
+import './init.js';
+import './linear.js';
+import './log.js';
+import './sequential.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 sequential } from '../../../../../_virtual/sequential.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(diverging$1, "__esModule", {
+  value: true
+});
+diverging$1.default = diverging;
+diverging$1.divergingLog = divergingLog;
+diverging$1.divergingPow = divergingPow;
+diverging$1.divergingSqrt = divergingSqrt;
+diverging$1.divergingSymlog = divergingSymlog;
+var _index = src;
+var _continuous = continuous;
+var _init = init;
+var _linear = linear;
+var _log = log;
+var _sequential = sequential;
+var _symlog = symlog;
+var _pow = pow;
+function transformer() {
+  var x0 = 0,
+    x1 = 0.5,
+    x2 = 1,
+    s = 1,
+    t0,
+    t1,
+    t2,
+    k10,
+    k21,
+    interpolator = _continuous.identity,
+    transform,
+    clamp = false,
+    unknown;
+  function scale(x) {
+    return isNaN(x = +x) ? unknown : (x = 0.5 + ((x = +transform(x)) - t1) * (s * x < s * t1 ? k10 : k21), interpolator(clamp ? Math.max(0, Math.min(1, x)) : x));
+  }
+  scale.domain = function (_) {
+    return arguments.length ? ([x0, x1, x2] = _, t0 = transform(x0 = +x0), t1 = transform(x1 = +x1), t2 = transform(x2 = +x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1, scale) : [x0, x1, x2];
+  };
+  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, r2;
+      return arguments.length ? ([r0, r1, r2] = _, interpolator = (0, _index.piecewise)(interpolate, [r0, r1, r2]), scale) : [interpolator(0), interpolator(0.5), 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), t2 = t(x2), k10 = t0 === t1 ? 0 : 0.5 / (t1 - t0), k21 = t1 === t2 ? 0 : 0.5 / (t2 - t1), s = t1 < t0 ? -1 : 1;
+    return scale;
+  };
+}
+function diverging() {
+  var scale = (0, _linear.linearish)(transformer()(_continuous.identity));
+  scale.copy = function () {
+    return (0, _sequential.copy)(scale, diverging());
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}
+function divergingLog() {
+  var scale = (0, _log.loggish)(transformer()).domain([0.1, 1, 10]);
+  scale.copy = function () {
+    return (0, _sequential.copy)(scale, divergingLog()).base(scale.base());
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}
+function divergingSymlog() {
+  var scale = (0, _symlog.symlogish)(transformer());
+  scale.copy = function () {
+    return (0, _sequential.copy)(scale, divergingSymlog()).constant(scale.constant());
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}
+function divergingPow() {
+  var scale = (0, _pow.powish)(transformer());
+  scale.copy = function () {
+    return (0, _sequential.copy)(scale, divergingPow()).exponent(scale.exponent());
+  };
+  return _init.initInterpolator.apply(scale, arguments);
+}
+function divergingSqrt() {
+  return divergingPow.apply(null, arguments).exponent(0.5);
+}

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

@@ -0,0 +1,37 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as identity$1 } from '../../../../../_virtual/identity2.js';
+import './linear.js';
+import './number.js';
+import { __exports as linear } from '../../../../../_virtual/linear2.js';
+import { __exports as number } from '../../../../../_virtual/number.js';
+
+Object.defineProperty(identity$1, "__esModule", {
+  value: true
+});
+identity$1.default = identity;
+var _linear = linear;
+var _number = _interopRequireDefault(number);
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function identity(domain) {
+  var unknown;
+  function scale(x) {
+    return x == null || isNaN(x = +x) ? unknown : x;
+  }
+  scale.invert = scale;
+  scale.domain = scale.range = function (_) {
+    return arguments.length ? (domain = Array.from(_, _number.default), scale) : domain.slice();
+  };
+  scale.unknown = function (_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  scale.copy = function () {
+    return identity(domain).unknown(unknown);
+  };
+  domain = arguments.length ? Array.from(domain, _number.default) : [0, 1];
+  return (0, _linear.linearish)(scale);
+}