umwd-components 0.1.814 → 0.1.816

package/dist/esm/node_modules/scheduler/cjs/scheduler.production.js

@@ -0,0 +1,359 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as scheduler_production } from '../../../_virtual/scheduler.production.js';
+
+/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredScheduler_production;
+
+function requireScheduler_production () {
+	if (hasRequiredScheduler_production) return scheduler_production;
+	hasRequiredScheduler_production = 1;
+	(function (exports) {
+		function push(heap, node) {
+		  var index = heap.length;
+		  heap.push(node);
+		  a: for (; 0 < index; ) {
+		    var parentIndex = (index - 1) >>> 1,
+		      parent = heap[parentIndex];
+		    if (0 < compare(parent, node))
+		      (heap[parentIndex] = node), (heap[index] = parent), (index = parentIndex);
+		    else break a;
+		  }
+		}
+		function peek(heap) {
+		  return 0 === heap.length ? null : heap[0];
+		}
+		function pop(heap) {
+		  if (0 === heap.length) return null;
+		  var first = heap[0],
+		    last = heap.pop();
+		  if (last !== first) {
+		    heap[0] = last;
+		    a: for (
+		      var index = 0, length = heap.length, halfLength = length >>> 1;
+		      index < halfLength;
+
+		    ) {
+		      var leftIndex = 2 * (index + 1) - 1,
+		        left = heap[leftIndex],
+		        rightIndex = leftIndex + 1,
+		        right = heap[rightIndex];
+		      if (0 > compare(left, last))
+		        rightIndex < length && 0 > compare(right, left)
+		          ? ((heap[index] = right),
+		            (heap[rightIndex] = last),
+		            (index = rightIndex))
+		          : ((heap[index] = left),
+		            (heap[leftIndex] = last),
+		            (index = leftIndex));
+		      else if (rightIndex < length && 0 > compare(right, last))
+		        (heap[index] = right), (heap[rightIndex] = last), (index = rightIndex);
+		      else break a;
+		    }
+		  }
+		  return first;
+		}
+		function compare(a, b) {
+		  var diff = a.sortIndex - b.sortIndex;
+		  return 0 !== diff ? diff : a.id - b.id;
+		}
+		exports.unstable_now = void 0;
+		if ("object" === typeof performance && "function" === typeof performance.now) {
+		  var localPerformance = performance;
+		  exports.unstable_now = function () {
+		    return localPerformance.now();
+		  };
+		} else {
+		  var localDate = Date,
+		    initialTime = localDate.now();
+		  exports.unstable_now = function () {
+		    return localDate.now() - initialTime;
+		  };
+		}
+		var taskQueue = [],
+		  timerQueue = [],
+		  taskIdCounter = 1,
+		  currentTask = null,
+		  currentPriorityLevel = 3,
+		  isPerformingWork = false,
+		  isHostCallbackScheduled = false,
+		  isHostTimeoutScheduled = false,
+		  localSetTimeout = "function" === typeof setTimeout ? setTimeout : null,
+		  localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null,
+		  localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
+		function advanceTimers(currentTime) {
+		  for (var timer = peek(timerQueue); null !== timer; ) {
+		    if (null === timer.callback) pop(timerQueue);
+		    else if (timer.startTime <= currentTime)
+		      pop(timerQueue),
+		        (timer.sortIndex = timer.expirationTime),
+		        push(taskQueue, timer);
+		    else break;
+		    timer = peek(timerQueue);
+		  }
+		}
+		function handleTimeout(currentTime) {
+		  isHostTimeoutScheduled = false;
+		  advanceTimers(currentTime);
+		  if (!isHostCallbackScheduled)
+		    if (null !== peek(taskQueue))
+		      (isHostCallbackScheduled = true), requestHostCallback();
+		    else {
+		      var firstTimer = peek(timerQueue);
+		      null !== firstTimer &&
+		        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
+		    }
+		}
+		var isMessageLoopRunning = false,
+		  taskTimeoutID = -1,
+		  frameInterval = 5,
+		  startTime = -1;
+		function shouldYieldToHost() {
+		  return exports.unstable_now() - startTime < frameInterval ? false : true;
+		}
+		function performWorkUntilDeadline() {
+		  if (isMessageLoopRunning) {
+		    var currentTime = exports.unstable_now();
+		    startTime = currentTime;
+		    var hasMoreWork = true;
+		    try {
+		      a: {
+		        isHostCallbackScheduled = !1;
+		        isHostTimeoutScheduled &&
+		          ((isHostTimeoutScheduled = !1),
+		          localClearTimeout(taskTimeoutID),
+		          (taskTimeoutID = -1));
+		        isPerformingWork = !0;
+		        var previousPriorityLevel = currentPriorityLevel;
+		        try {
+		          b: {
+		            advanceTimers(currentTime);
+		            for (
+		              currentTask = peek(taskQueue);
+		              null !== currentTask &&
+		              !(
+		                currentTask.expirationTime > currentTime && shouldYieldToHost()
+		              );
+
+		            ) {
+		              var callback = currentTask.callback;
+		              if ("function" === typeof callback) {
+		                currentTask.callback = null;
+		                currentPriorityLevel = currentTask.priorityLevel;
+		                var continuationCallback = callback(
+		                  currentTask.expirationTime <= currentTime
+		                );
+		                currentTime = exports.unstable_now();
+		                if ("function" === typeof continuationCallback) {
+		                  currentTask.callback = continuationCallback;
+		                  advanceTimers(currentTime);
+		                  hasMoreWork = !0;
+		                  break b;
+		                }
+		                currentTask === peek(taskQueue) && pop(taskQueue);
+		                advanceTimers(currentTime);
+		              } else pop(taskQueue);
+		              currentTask = peek(taskQueue);
+		            }
+		            if (null !== currentTask) hasMoreWork = !0;
+		            else {
+		              var firstTimer = peek(timerQueue);
+		              null !== firstTimer &&
+		                requestHostTimeout(
+		                  handleTimeout,
+		                  firstTimer.startTime - currentTime
+		                );
+		              hasMoreWork = !1;
+		            }
+		          }
+		          break a;
+		        } finally {
+		          (currentTask = null),
+		            (currentPriorityLevel = previousPriorityLevel),
+		            (isPerformingWork = !1);
+		        }
+		        hasMoreWork = void 0;
+		      }
+		    } finally {
+		      hasMoreWork
+		        ? schedulePerformWorkUntilDeadline()
+		        : (isMessageLoopRunning = false);
+		    }
+		  }
+		}
+		var schedulePerformWorkUntilDeadline;
+		if ("function" === typeof localSetImmediate)
+		  schedulePerformWorkUntilDeadline = function () {
+		    localSetImmediate(performWorkUntilDeadline);
+		  };
+		else if ("undefined" !== typeof MessageChannel) {
+		  var channel = new MessageChannel(),
+		    port = channel.port2;
+		  channel.port1.onmessage = performWorkUntilDeadline;
+		  schedulePerformWorkUntilDeadline = function () {
+		    port.postMessage(null);
+		  };
+		} else
+		  schedulePerformWorkUntilDeadline = function () {
+		    localSetTimeout(performWorkUntilDeadline, 0);
+		  };
+		function requestHostCallback() {
+		  isMessageLoopRunning ||
+		    ((isMessageLoopRunning = true), schedulePerformWorkUntilDeadline());
+		}
+		function requestHostTimeout(callback, ms) {
+		  taskTimeoutID = localSetTimeout(function () {
+		    callback(exports.unstable_now());
+		  }, ms);
+		}
+		exports.unstable_IdlePriority = 5;
+		exports.unstable_ImmediatePriority = 1;
+		exports.unstable_LowPriority = 4;
+		exports.unstable_NormalPriority = 3;
+		exports.unstable_Profiling = null;
+		exports.unstable_UserBlockingPriority = 2;
+		exports.unstable_cancelCallback = function (task) {
+		  task.callback = null;
+		};
+		exports.unstable_continueExecution = function () {
+		  isHostCallbackScheduled ||
+		    isPerformingWork ||
+		    ((isHostCallbackScheduled = true), requestHostCallback());
+		};
+		exports.unstable_forceFrameRate = function (fps) {
+		  0 > fps || 125 < fps
+		    ? console.error(
+		        "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
+		      )
+		    : (frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5);
+		};
+		exports.unstable_getCurrentPriorityLevel = function () {
+		  return currentPriorityLevel;
+		};
+		exports.unstable_getFirstCallbackNode = function () {
+		  return peek(taskQueue);
+		};
+		exports.unstable_next = function (eventHandler) {
+		  switch (currentPriorityLevel) {
+		    case 1:
+		    case 2:
+		    case 3:
+		      var priorityLevel = 3;
+		      break;
+		    default:
+		      priorityLevel = currentPriorityLevel;
+		  }
+		  var previousPriorityLevel = currentPriorityLevel;
+		  currentPriorityLevel = priorityLevel;
+		  try {
+		    return eventHandler();
+		  } finally {
+		    currentPriorityLevel = previousPriorityLevel;
+		  }
+		};
+		exports.unstable_pauseExecution = function () {};
+		exports.unstable_requestPaint = function () {};
+		exports.unstable_runWithPriority = function (priorityLevel, eventHandler) {
+		  switch (priorityLevel) {
+		    case 1:
+		    case 2:
+		    case 3:
+		    case 4:
+		    case 5:
+		      break;
+		    default:
+		      priorityLevel = 3;
+		  }
+		  var previousPriorityLevel = currentPriorityLevel;
+		  currentPriorityLevel = priorityLevel;
+		  try {
+		    return eventHandler();
+		  } finally {
+		    currentPriorityLevel = previousPriorityLevel;
+		  }
+		};
+		exports.unstable_scheduleCallback = function (
+		  priorityLevel,
+		  callback,
+		  options
+		) {
+		  var currentTime = exports.unstable_now();
+		  "object" === typeof options && null !== options
+		    ? ((options = options.delay),
+		      (options =
+		        "number" === typeof options && 0 < options
+		          ? currentTime + options
+		          : currentTime))
+		    : (options = currentTime);
+		  switch (priorityLevel) {
+		    case 1:
+		      var timeout = -1;
+		      break;
+		    case 2:
+		      timeout = 250;
+		      break;
+		    case 5:
+		      timeout = 1073741823;
+		      break;
+		    case 4:
+		      timeout = 1e4;
+		      break;
+		    default:
+		      timeout = 5e3;
+		  }
+		  timeout = options + timeout;
+		  priorityLevel = {
+		    id: taskIdCounter++,
+		    callback: callback,
+		    priorityLevel: priorityLevel,
+		    startTime: options,
+		    expirationTime: timeout,
+		    sortIndex: -1
+		  };
+		  options > currentTime
+		    ? ((priorityLevel.sortIndex = options),
+		      push(timerQueue, priorityLevel),
+		      null === peek(taskQueue) &&
+		        priorityLevel === peek(timerQueue) &&
+		        (isHostTimeoutScheduled
+		          ? (localClearTimeout(taskTimeoutID), (taskTimeoutID = -1))
+		          : (isHostTimeoutScheduled = true),
+		        requestHostTimeout(handleTimeout, options - currentTime)))
+		    : ((priorityLevel.sortIndex = timeout),
+		      push(taskQueue, priorityLevel),
+		      isHostCallbackScheduled ||
+		        isPerformingWork ||
+		        ((isHostCallbackScheduled = true), requestHostCallback()));
+		  return priorityLevel;
+		};
+		exports.unstable_shouldYield = shouldYieldToHost;
+		exports.unstable_wrapCallback = function (callback) {
+		  var parentPriorityLevel = currentPriorityLevel;
+		  return function () {
+		    var previousPriorityLevel = currentPriorityLevel;
+		    currentPriorityLevel = parentPriorityLevel;
+		    try {
+		      return callback.apply(this, arguments);
+		    } finally {
+		      currentPriorityLevel = previousPriorityLevel;
+		    }
+		  };
+		}; 
+	} (scheduler_production));
+	return scheduler_production;
+}
+
+export { requireScheduler_production as __require };

package/dist/esm/node_modules/scheduler/index.js

@@ -0,0 +1,21 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+import { __module as scheduler } from '../../_virtual/index9.js';
+import { __require as requireScheduler_production } from './cjs/scheduler.production.js';
+import { __require as requireScheduler_development } from './cjs/scheduler.development.js';
+
+if (process.env.NODE_ENV === 'production') {
+  scheduler.exports = requireScheduler_production();
+} else {
+  scheduler.exports = requireScheduler_development();
+}
+
+var schedulerExports = scheduler.exports;
+var index = /*@__PURE__*/getDefaultExportFromCjs(schedulerExports);
+
+export { index as default };

package/dist/esm/node_modules/simple-swizzle/index.js

@@ -0,0 +1,40 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __module as simpleSwizzle } from '../../_virtual/index10.js';
+import { i as isArrayish$1 } from './node_modules/is-arrayish/index.js';
+
+var isArrayish = isArrayish$1;
+
+var concat = Array.prototype.concat;
+var slice = Array.prototype.slice;
+
+var swizzle = simpleSwizzle.exports = function swizzle(args) {
+	var results = [];
+
+	for (var i = 0, len = args.length; i < len; i++) {
+		var arg = args[i];
+
+		if (isArrayish(arg)) {
+			// http://jsperf.com/javascript-array-concat-vs-push/98
+			results = concat.call(results, slice.call(arg));
+		} else {
+			results.push(arg);
+		}
+	}
+
+	return results;
+};
+
+swizzle.wrap = function (fn) {
+	return function () {
+		return fn(swizzle(arguments));
+	};
+};
+
+var simpleSwizzleExports = simpleSwizzle.exports;
+
+export { simpleSwizzleExports as s };

package/dist/esm/node_modules/simple-swizzle/node_modules/is-arrayish/index.js

@@ -0,0 +1,17 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+var isArrayish = function isArrayish(obj) {
+	if (!obj || typeof obj === 'string') {
+		return false;
+	}
+
+	return obj instanceof Array || Array.isArray(obj) ||
+		(obj.length >= 0 && (obj.splice instanceof Function ||
+			(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));
+};
+
+export { isArrayish as i };

package/dist/esm/node_modules/svg-arc-to-cubic-bezier/modules/index.js

@@ -0,0 +1,189 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var TAU = Math.PI * 2;
+
+var mapToEllipse = function mapToEllipse(_ref, rx, ry, cosphi, sinphi, centerx, centery) {
+  var x = _ref.x,
+      y = _ref.y;
+
+  x *= rx;
+  y *= ry;
+
+  var xp = cosphi * x - sinphi * y;
+  var yp = sinphi * x + cosphi * y;
+
+  return {
+    x: xp + centerx,
+    y: yp + centery
+  };
+};
+
+var approxUnitArc = function approxUnitArc(ang1, ang2) {
+  // If 90 degree circular arc, use a constant
+  // as derived from http://spencermortensen.com/articles/bezier-circle
+  var a = ang2 === 1.5707963267948966 ? 0.551915024494 : ang2 === -1.5707963267948966 ? -0.551915024494 : 4 / 3 * Math.tan(ang2 / 4);
+
+  var x1 = Math.cos(ang1);
+  var y1 = Math.sin(ang1);
+  var x2 = Math.cos(ang1 + ang2);
+  var y2 = Math.sin(ang1 + ang2);
+
+  return [{
+    x: x1 - y1 * a,
+    y: y1 + x1 * a
+  }, {
+    x: x2 + y2 * a,
+    y: y2 - x2 * a
+  }, {
+    x: x2,
+    y: y2
+  }];
+};
+
+var vectorAngle = function vectorAngle(ux, uy, vx, vy) {
+  var sign = ux * vy - uy * vx < 0 ? -1 : 1;
+
+  var dot = ux * vx + uy * vy;
+
+  if (dot > 1) {
+    dot = 1;
+  }
+
+  if (dot < -1) {
+    dot = -1;
+  }
+
+  return sign * Math.acos(dot);
+};
+
+var getArcCenter = function getArcCenter(px, py, cx, cy, rx, ry, largeArcFlag, sweepFlag, sinphi, cosphi, pxp, pyp) {
+  var rxsq = Math.pow(rx, 2);
+  var rysq = Math.pow(ry, 2);
+  var pxpsq = Math.pow(pxp, 2);
+  var pypsq = Math.pow(pyp, 2);
+
+  var radicant = rxsq * rysq - rxsq * pypsq - rysq * pxpsq;
+
+  if (radicant < 0) {
+    radicant = 0;
+  }
+
+  radicant /= rxsq * pypsq + rysq * pxpsq;
+  radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1);
+
+  var centerxp = radicant * rx / ry * pyp;
+  var centeryp = radicant * -ry / rx * pxp;
+
+  var centerx = cosphi * centerxp - sinphi * centeryp + (px + cx) / 2;
+  var centery = sinphi * centerxp + cosphi * centeryp + (py + cy) / 2;
+
+  var vx1 = (pxp - centerxp) / rx;
+  var vy1 = (pyp - centeryp) / ry;
+  var vx2 = (-pxp - centerxp) / rx;
+  var vy2 = (-pyp - centeryp) / ry;
+
+  var ang1 = vectorAngle(1, 0, vx1, vy1);
+  var ang2 = vectorAngle(vx1, vy1, vx2, vy2);
+
+  if (sweepFlag === 0 && ang2 > 0) {
+    ang2 -= TAU;
+  }
+
+  if (sweepFlag === 1 && ang2 < 0) {
+    ang2 += TAU;
+  }
+
+  return [centerx, centery, ang1, ang2];
+};
+
+var arcToBezier = function arcToBezier(_ref2) {
+  var px = _ref2.px,
+      py = _ref2.py,
+      cx = _ref2.cx,
+      cy = _ref2.cy,
+      rx = _ref2.rx,
+      ry = _ref2.ry,
+      _ref2$xAxisRotation = _ref2.xAxisRotation,
+      xAxisRotation = _ref2$xAxisRotation === undefined ? 0 : _ref2$xAxisRotation,
+      _ref2$largeArcFlag = _ref2.largeArcFlag,
+      largeArcFlag = _ref2$largeArcFlag === undefined ? 0 : _ref2$largeArcFlag,
+      _ref2$sweepFlag = _ref2.sweepFlag,
+      sweepFlag = _ref2$sweepFlag === undefined ? 0 : _ref2$sweepFlag;
+
+  var curves = [];
+
+  if (rx === 0 || ry === 0) {
+    return [];
+  }
+
+  var sinphi = Math.sin(xAxisRotation * TAU / 360);
+  var cosphi = Math.cos(xAxisRotation * TAU / 360);
+
+  var pxp = cosphi * (px - cx) / 2 + sinphi * (py - cy) / 2;
+  var pyp = -sinphi * (px - cx) / 2 + cosphi * (py - cy) / 2;
+
+  if (pxp === 0 && pyp === 0) {
+    return [];
+  }
+
+  rx = Math.abs(rx);
+  ry = Math.abs(ry);
+
+  var lambda = Math.pow(pxp, 2) / Math.pow(rx, 2) + Math.pow(pyp, 2) / Math.pow(ry, 2);
+
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+
+  var _getArcCenter = getArcCenter(px, py, cx, cy, rx, ry, largeArcFlag, sweepFlag, sinphi, cosphi, pxp, pyp),
+      _getArcCenter2 = _slicedToArray(_getArcCenter, 4),
+      centerx = _getArcCenter2[0],
+      centery = _getArcCenter2[1],
+      ang1 = _getArcCenter2[2],
+      ang2 = _getArcCenter2[3];
+
+  // If 'ang2' == 90.0000000001, then `ratio` will evaluate to
+  // 1.0000000001. This causes `segments` to be greater than one, which is an
+  // unecessary split, and adds extra points to the bezier curve. To alleviate
+  // this issue, we round to 1.0 when the ratio is close to 1.0.
+
+
+  var ratio = Math.abs(ang2) / (TAU / 4);
+  if (Math.abs(1.0 - ratio) < 0.0000001) {
+    ratio = 1.0;
+  }
+
+  var segments = Math.max(Math.ceil(ratio), 1);
+
+  ang2 /= segments;
+
+  for (var i = 0; i < segments; i++) {
+    curves.push(approxUnitArc(ang1, ang2));
+    ang1 += ang2;
+  }
+
+  return curves.map(function (curve) {
+    var _mapToEllipse = mapToEllipse(curve[0], rx, ry, cosphi, sinphi, centerx, centery),
+        x1 = _mapToEllipse.x,
+        y1 = _mapToEllipse.y;
+
+    var _mapToEllipse2 = mapToEllipse(curve[1], rx, ry, cosphi, sinphi, centerx, centery),
+        x2 = _mapToEllipse2.x,
+        y2 = _mapToEllipse2.y;
+
+    var _mapToEllipse3 = mapToEllipse(curve[2], rx, ry, cosphi, sinphi, centerx, centery),
+        x = _mapToEllipse3.x,
+        y = _mapToEllipse3.y;
+
+    return { x1: x1, y1: y1, x2: x2, y2: y2, x: x, y: y };
+  });
+};
+
+export { arcToBezier as default };