umwd-components 0.1.757 → 0.1.758

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

@@ -0,0 +1,236 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as src } from '../../../../../_virtual/index5.js';
+import './band.js';
+import './identity.js';
+import './linear.js';
+import './log.js';
+import './symlog.js';
+import './ordinal.js';
+import './pow.js';
+import './radial.js';
+import './quantile.js';
+import './quantize.js';
+import './threshold.js';
+import './time.js';
+import './utcTime.js';
+import './sequential.js';
+import './sequentialQuantile.js';
+import './diverging.js';
+import './tickFormat.js';
+import { __exports as band } from '../../../../../_virtual/band.js';
+import { __exports as diverging } from '../../../../../_virtual/diverging2.js';
+import { __exports as identity } from '../../../../../_virtual/identity2.js';
+import { __exports as ordinal } from '../../../../../_virtual/ordinal.js';
+import { __exports as linear } from '../../../../../_virtual/linear2.js';
+import { __exports as log } from '../../../../../_virtual/log.js';
+import { __exports as pow } from '../../../../../_virtual/pow.js';
+import { __exports as quantile } from '../../../../../_virtual/quantile.js';
+import { __exports as quantize } from '../../../../../_virtual/quantize.js';
+import { __exports as radial } from '../../../../../_virtual/radial.js';
+import { __exports as sequential } from '../../../../../_virtual/sequential.js';
+import { __exports as sequentialQuantile } from '../../../../../_virtual/sequentialQuantile.js';
+import { __exports as symlog } from '../../../../../_virtual/symlog.js';
+import { __exports as threshold } from '../../../../../_virtual/threshold.js';
+import { __exports as time } from '../../../../../_virtual/time.js';
+import { __exports as utcTime } from '../../../../../_virtual/utcTime.js';
+import { __exports as tickFormat } from '../../../../../_virtual/tickFormat.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	Object.defineProperty(exports, "scaleBand", {
+	  enumerable: true,
+	  get: function () {
+	    return _band.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleDiverging", {
+	  enumerable: true,
+	  get: function () {
+	    return _diverging.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleDivergingLog", {
+	  enumerable: true,
+	  get: function () {
+	    return _diverging.divergingLog;
+	  }
+	});
+	Object.defineProperty(exports, "scaleDivergingPow", {
+	  enumerable: true,
+	  get: function () {
+	    return _diverging.divergingPow;
+	  }
+	});
+	Object.defineProperty(exports, "scaleDivergingSqrt", {
+	  enumerable: true,
+	  get: function () {
+	    return _diverging.divergingSqrt;
+	  }
+	});
+	Object.defineProperty(exports, "scaleDivergingSymlog", {
+	  enumerable: true,
+	  get: function () {
+	    return _diverging.divergingSymlog;
+	  }
+	});
+	Object.defineProperty(exports, "scaleIdentity", {
+	  enumerable: true,
+	  get: function () {
+	    return _identity.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleImplicit", {
+	  enumerable: true,
+	  get: function () {
+	    return _ordinal.implicit;
+	  }
+	});
+	Object.defineProperty(exports, "scaleLinear", {
+	  enumerable: true,
+	  get: function () {
+	    return _linear.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleLog", {
+	  enumerable: true,
+	  get: function () {
+	    return _log.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleOrdinal", {
+	  enumerable: true,
+	  get: function () {
+	    return _ordinal.default;
+	  }
+	});
+	Object.defineProperty(exports, "scalePoint", {
+	  enumerable: true,
+	  get: function () {
+	    return _band.point;
+	  }
+	});
+	Object.defineProperty(exports, "scalePow", {
+	  enumerable: true,
+	  get: function () {
+	    return _pow.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleQuantile", {
+	  enumerable: true,
+	  get: function () {
+	    return _quantile.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleQuantize", {
+	  enumerable: true,
+	  get: function () {
+	    return _quantize.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleRadial", {
+	  enumerable: true,
+	  get: function () {
+	    return _radial.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSequential", {
+	  enumerable: true,
+	  get: function () {
+	    return _sequential.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSequentialLog", {
+	  enumerable: true,
+	  get: function () {
+	    return _sequential.sequentialLog;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSequentialPow", {
+	  enumerable: true,
+	  get: function () {
+	    return _sequential.sequentialPow;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSequentialQuantile", {
+	  enumerable: true,
+	  get: function () {
+	    return _sequentialQuantile.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSequentialSqrt", {
+	  enumerable: true,
+	  get: function () {
+	    return _sequential.sequentialSqrt;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSequentialSymlog", {
+	  enumerable: true,
+	  get: function () {
+	    return _sequential.sequentialSymlog;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSqrt", {
+	  enumerable: true,
+	  get: function () {
+	    return _pow.sqrt;
+	  }
+	});
+	Object.defineProperty(exports, "scaleSymlog", {
+	  enumerable: true,
+	  get: function () {
+	    return _symlog.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleThreshold", {
+	  enumerable: true,
+	  get: function () {
+	    return _threshold.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleTime", {
+	  enumerable: true,
+	  get: function () {
+	    return _time.default;
+	  }
+	});
+	Object.defineProperty(exports, "scaleUtc", {
+	  enumerable: true,
+	  get: function () {
+	    return _utcTime.default;
+	  }
+	});
+	Object.defineProperty(exports, "tickFormat", {
+	  enumerable: true,
+	  get: function () {
+	    return _tickFormat.default;
+	  }
+	});
+	var _band = _interopRequireWildcard(band);
+	var _identity = _interopRequireDefault(identity);
+	var _linear = _interopRequireDefault(linear);
+	var _log = _interopRequireDefault(log);
+	var _symlog = _interopRequireDefault(symlog);
+	var _ordinal = _interopRequireWildcard(ordinal);
+	var _pow = _interopRequireWildcard(pow);
+	var _radial = _interopRequireDefault(radial);
+	var _quantile = _interopRequireDefault(quantile);
+	var _quantize = _interopRequireDefault(quantize);
+	var _threshold = _interopRequireDefault(threshold);
+	var _time = _interopRequireDefault(time);
+	var _utcTime = _interopRequireDefault(utcTime);
+	var _sequential = _interopRequireWildcard(sequential);
+	var _sequentialQuantile = _interopRequireDefault(sequentialQuantile);
+	var _diverging = _interopRequireWildcard(diverging);
+	var _tickFormat = _interopRequireDefault(tickFormat);
+	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; } 
+} (src));

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

@@ -0,0 +1,46 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as init } from '../../../../../_virtual/init.js';
+
+Object.defineProperty(init, "__esModule", {
+  value: true
+});
+init.initInterpolator = initInterpolator;
+init.initRange = initRange;
+function initRange(domain, range) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      this.range(domain);
+      break;
+    default:
+      this.range(range).domain(domain);
+      break;
+  }
+  return this;
+}
+function initInterpolator(domain, interpolator) {
+  switch (arguments.length) {
+    case 0:
+      break;
+    case 1:
+      {
+        if (typeof domain === "function") this.interpolator(domain);else this.range(domain);
+        break;
+      }
+    default:
+      {
+        this.domain(domain);
+        if (typeof interpolator === "function") this.interpolator(interpolator);else this.range(interpolator);
+        break;
+      }
+  }
+  return this;
+}
+
+export { init as default };

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

@@ -0,0 +1,81 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as linear$1 } from '../../../../../_virtual/linear2.js';
+import '../../d3-array/src/index.js';
+import './continuous.js';
+import './init.js';
+import './tickFormat.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as tickFormat } from '../../../../../_virtual/tickFormat.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+
+Object.defineProperty(linear$1, "__esModule", {
+  value: true
+});
+linear$1.default = linear;
+linear$1.linearish = linearish;
+var _index = src;
+var _continuous = _interopRequireWildcard(continuous);
+var _init = init;
+var _tickFormat = _interopRequireDefault(tickFormat);
+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 linearish(scale) {
+  var domain = scale.domain;
+  scale.ticks = function (count) {
+    var d = domain();
+    return (0, _index.ticks)(d[0], d[d.length - 1], count == null ? 10 : count);
+  };
+  scale.tickFormat = function (count, specifier) {
+    var d = domain();
+    return (0, _tickFormat.default)(d[0], d[d.length - 1], count == null ? 10 : count, specifier);
+  };
+  scale.nice = function (count) {
+    if (count == null) count = 10;
+    var d = domain();
+    var i0 = 0;
+    var i1 = d.length - 1;
+    var start = d[i0];
+    var stop = d[i1];
+    var prestep;
+    var step;
+    var maxIter = 10;
+    if (stop < start) {
+      step = start, start = stop, stop = step;
+      step = i0, i0 = i1, i1 = step;
+    }
+    while (maxIter-- > 0) {
+      step = (0, _index.tickIncrement)(start, stop, count);
+      if (step === prestep) {
+        d[i0] = start;
+        d[i1] = stop;
+        return domain(d);
+      } else if (step > 0) {
+        start = Math.floor(start / step) * step;
+        stop = Math.ceil(stop / step) * step;
+      } else if (step < 0) {
+        start = Math.ceil(start * step) / step;
+        stop = Math.floor(stop * step) / step;
+      } else {
+        break;
+      }
+      prestep = step;
+    }
+    return scale;
+  };
+  return scale;
+}
+function linear() {
+  var scale = (0, _continuous.default)();
+  scale.copy = function () {
+    return (0, _continuous.copy)(scale, linear());
+  };
+  _init.initRange.apply(scale, arguments);
+  return linearish(scale);
+}

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

@@ -0,0 +1,139 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as log$1 } from '../../../../../_virtual/log.js';
+import '../../d3-array/src/index.js';
+import '../../d3-format/src/index.js';
+import './nice.js';
+import './continuous.js';
+import './init.js';
+import { __exports as src } from '../../../../../_virtual/index13.js';
+import { __exports as src$1 } from '../../../../../_virtual/index14.js';
+import { __exports as continuous } from '../../../../../_virtual/continuous.js';
+import { __exports as init } from '../../../../../_virtual/init.js';
+import { __exports as nice } from '../../../../../_virtual/nice.js';
+
+Object.defineProperty(log$1, "__esModule", {
+  value: true
+});
+log$1.default = log;
+log$1.loggish = loggish;
+var _index = src;
+var _index2 = src$1;
+var _nice = _interopRequireDefault(nice);
+var _continuous = continuous;
+var _init = init;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function transformLog(x) {
+  return Math.log(x);
+}
+function transformExp(x) {
+  return Math.exp(x);
+}
+function transformLogn(x) {
+  return -Math.log(-x);
+}
+function transformExpn(x) {
+  return -Math.exp(-x);
+}
+function pow10(x) {
+  return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x;
+}
+function powp(base) {
+  return base === 10 ? pow10 : base === Math.E ? Math.exp : x => Math.pow(base, x);
+}
+function logp(base) {
+  return base === Math.E ? Math.log : base === 10 && Math.log10 || base === 2 && Math.log2 || (base = Math.log(base), x => Math.log(x) / base);
+}
+function reflect(f) {
+  return (x, k) => -f(-x, k);
+}
+function loggish(transform) {
+  const scale = transform(transformLog, transformExp);
+  const domain = scale.domain;
+  let base = 10;
+  let logs;
+  let pows;
+  function rescale() {
+    logs = logp(base), pows = powp(base);
+    if (domain()[0] < 0) {
+      logs = reflect(logs), pows = reflect(pows);
+      transform(transformLogn, transformExpn);
+    } else {
+      transform(transformLog, transformExp);
+    }
+    return scale;
+  }
+  scale.base = function (_) {
+    return arguments.length ? (base = +_, rescale()) : base;
+  };
+  scale.domain = function (_) {
+    return arguments.length ? (domain(_), rescale()) : domain();
+  };
+  scale.ticks = count => {
+    const d = domain();
+    let u = d[0];
+    let v = d[d.length - 1];
+    const r = v < u;
+    if (r) [u, v] = [v, u];
+    let i = logs(u);
+    let j = logs(v);
+    let k;
+    let t;
+    const n = count == null ? 10 : +count;
+    let z = [];
+    if (!(base % 1) && j - i < n) {
+      i = Math.floor(i), j = Math.ceil(j);
+      if (u > 0) for (; i <= j; ++i) {
+        for (k = 1; k < base; ++k) {
+          t = i < 0 ? k / pows(-i) : k * pows(i);
+          if (t < u) continue;
+          if (t > v) break;
+          z.push(t);
+        }
+      } else for (; i <= j; ++i) {
+        for (k = base - 1; k >= 1; --k) {
+          t = i > 0 ? k / pows(-i) : k * pows(i);
+          if (t < u) continue;
+          if (t > v) break;
+          z.push(t);
+        }
+      }
+      if (z.length * 2 < n) z = (0, _index.ticks)(u, v, n);
+    } else {
+      z = (0, _index.ticks)(i, j, Math.min(j - i, n)).map(pows);
+    }
+    return r ? z.reverse() : z;
+  };
+  scale.tickFormat = (count, specifier) => {
+    if (count == null) count = 10;
+    if (specifier == null) specifier = base === 10 ? "s" : ",";
+    if (typeof specifier !== "function") {
+      if (!(base % 1) && (specifier = (0, _index2.formatSpecifier)(specifier)).precision == null) specifier.trim = true;
+      specifier = (0, _index2.format)(specifier);
+    }
+    if (count === Infinity) return specifier;
+    const k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?
+    return d => {
+      let i = d / pows(Math.round(logs(d)));
+      if (i * base < base - 0.5) i *= base;
+      return i <= k ? specifier(d) : "";
+    };
+  };
+  scale.nice = () => {
+    return domain((0, _nice.default)(domain(), {
+      floor: x => pows(Math.floor(logs(x))),
+      ceil: x => pows(Math.ceil(logs(x)))
+    }));
+  };
+  return scale;
+}
+function log() {
+  const scale = loggish((0, _continuous.transformer)()).domain([1, 10]);
+  scale.copy = () => (0, _continuous.copy)(scale, log()).base(scale.base());
+  _init.initRange.apply(scale, arguments);
+  return scale;
+}

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

@@ -0,0 +1,27 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as nice$1 } from '../../../../../_virtual/nice.js';
+
+Object.defineProperty(nice$1, "__esModule", {
+  value: true
+});
+nice$1.default = nice;
+function nice(domain, interval) {
+  domain = domain.slice();
+  var i0 = 0,
+    i1 = domain.length - 1,
+    x0 = domain[i0],
+    x1 = domain[i1],
+    t;
+  if (x1 < x0) {
+    t = i0, i0 = i1, i1 = t;
+    t = x0, x0 = x1, x1 = t;
+  }
+  domain[i0] = interval.floor(x0);
+  domain[i1] = interval.ceil(x1);
+  return domain;
+}

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

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

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

@@ -0,0 +1,54 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as ordinal$1 } from '../../../../../_virtual/ordinal.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(ordinal$1, "__esModule", {
+  value: true
+});
+ordinal$1.default = ordinal;
+ordinal$1.implicit = void 0;
+var _index = src;
+var _init = init;
+const implicit = ordinal$1.implicit = Symbol("implicit");
+function ordinal() {
+  var index = new _index.InternMap(),
+    domain = [],
+    range = [],
+    unknown = implicit;
+  function scale(d) {
+    let i = index.get(d);
+    if (i === undefined) {
+      if (unknown !== implicit) return unknown;
+      index.set(d, i = domain.push(d) - 1);
+    }
+    return range[i % range.length];
+  }
+  scale.domain = function (_) {
+    if (!arguments.length) return domain.slice();
+    domain = [], index = new _index.InternMap();
+    for (const value of _) {
+      if (index.has(value)) continue;
+      index.set(value, domain.push(value) - 1);
+    }
+    return scale;
+  };
+  scale.range = function (_) {
+    return arguments.length ? (range = Array.from(_), scale) : range.slice();
+  };
+  scale.unknown = function (_) {
+    return arguments.length ? (unknown = _, scale) : unknown;
+  };
+  scale.copy = function () {
+    return ordinal(domain, range).unknown(unknown);
+  };
+  _init.initRange.apply(scale, arguments);
+  return scale;
+}

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

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