umwd-components 0.1.813 → 0.1.815

package/dist/esm/node_modules/restructure/src/VersionedStruct.js

@@ -0,0 +1,147 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Struct } from './Struct.js';
+
+const getPath = (object, pathArray) => {
+  return pathArray.reduce((prevObj, key) => prevObj && prevObj[key], object);
+};
+
+class VersionedStruct extends Struct {
+  constructor(type, versions = {}) {
+    super();
+    this.type = type;
+    this.versions = versions;
+    if (typeof type === 'string') {
+      this.versionPath = type.split('.');
+    }
+  }
+
+  decode(stream, parent, length = 0) {
+    const res = this._setup(stream, parent, length);
+
+    if (typeof this.type === 'string') {
+      res.version = getPath(parent, this.versionPath);
+    } else {
+      res.version = this.type.decode(stream);
+    }
+
+    if (this.versions.header) {
+      this._parseFields(stream, res, this.versions.header);
+    }
+
+    const fields = this.versions[res.version];
+    if ((fields == null)) {
+      throw new Error(`Unknown version ${res.version}`);
+    }
+
+    if (fields instanceof VersionedStruct) {
+      return fields.decode(stream, parent);
+    }
+
+    this._parseFields(stream, res, fields);
+
+    if (this.process != null) {
+      this.process.call(res, stream);
+    }
+    return res;
+  }
+
+  size(val, parent, includePointers = true) {
+    let key, type;
+    if (!val) {
+      throw new Error('Not a fixed size');
+    }
+
+    if (this.preEncode != null) {
+      this.preEncode.call(val);
+    }
+
+    const ctx = {
+      parent,
+      val,
+      pointerSize: 0
+    };
+
+    let size = 0;
+    if (typeof this.type !== 'string') {
+      size += this.type.size(val.version, ctx);
+    }
+
+    if (this.versions.header) {
+      for (key in this.versions.header) {
+        type = this.versions.header[key];
+        if (type.size != null) {
+          size += type.size(val[key], ctx);
+        }
+      }
+    }
+
+    const fields = this.versions[val.version];
+    if ((fields == null)) {
+      throw new Error(`Unknown version ${val.version}`);
+    }
+
+    for (key in fields) {
+      type = fields[key];
+      if (type.size != null) {
+        size += type.size(val[key], ctx);
+      }
+    }
+
+    if (includePointers) {
+      size += ctx.pointerSize;
+    }
+
+    return size;
+  }
+
+  encode(stream, val, parent) {
+    let key, type;
+    if (this.preEncode != null) {
+      this.preEncode.call(val, stream);
+    }
+
+    const ctx = {
+      pointers: [],
+      startOffset: stream.pos,
+      parent,
+      val,
+      pointerSize: 0
+    };
+
+    ctx.pointerOffset = stream.pos + this.size(val, ctx, false);
+
+    if (typeof this.type !== 'string') {
+      this.type.encode(stream, val.version);
+    }
+
+    if (this.versions.header) {
+      for (key in this.versions.header) {
+        type = this.versions.header[key];
+        if (type.encode != null) {
+          type.encode(stream, val[key], ctx);
+        }
+      }
+    }
+
+    const fields = this.versions[val.version];
+    for (key in fields) {
+      type = fields[key];
+      if (type.encode != null) {
+        type.encode(stream, val[key], ctx);
+      }
+    }
+
+    let i = 0;
+    while (i < ctx.pointers.length) {
+      const ptr = ctx.pointers[i++];
+      ptr.type.encode(stream, ptr.val, ptr.parent);
+    }
+  }
+}
+
+export { VersionedStruct };

package/dist/esm/node_modules/restructure/src/utils.js

@@ -0,0 +1,42 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { Number as NumberT } from './Number.js';
+
+function resolveLength(length, stream, parent) {
+  let res;
+  if (typeof length === 'number') {
+    res = length;
+
+  } else if (typeof length === 'function') {
+    res = length.call(parent, parent);
+
+  } else if (parent && (typeof length === 'string')) {
+    res = parent[length];
+
+  } else if (stream && length instanceof NumberT) {
+    res = length.decode(stream);
+  }
+
+  if (isNaN(res)) {
+    throw new Error('Not a fixed size');
+  }
+
+  return res;
+}
+class PropertyDescriptor {
+  constructor(opts = {}) {
+    this.enumerable = true;
+    this.configurable = true;
+
+    for (let key in opts) {
+      const val = opts[key];
+      this[key] = val;
+    }
+  }
+}
+
+export { PropertyDescriptor, resolveLength };

package/dist/esm/node_modules/safe-buffer/index.js

@@ -4,7 +4,7 @@
  * @license MIT
  */
   
-import { __module as safeBuffer } from '../../_virtual/index4.js';
+import { __module as safeBuffer } from '../../_virtual/index8.js';
 import require$$0 from 'buffer';
 
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

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

@@ -0,0 +1,382 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as scheduler_development } from '../../../_virtual/scheduler.development.js';
+
+/**
+ * @license React
+ * scheduler.development.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_development;
+
+function requireScheduler_development () {
+	if (hasRequiredScheduler_development) return scheduler_development;
+	hasRequiredScheduler_development = 1;
+	(function (exports) {
+		"production" !== process.env.NODE_ENV &&
+		  (function () {
+		    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);
+		        }
+		      }
+		    }
+		    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;
+		    }
+		    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
+		            );
+		        }
+		    }
+		    function shouldYieldToHost() {
+		      return exports.unstable_now() - startTime < frameInterval ? false : true;
+		    }
+		    function requestHostCallback() {
+		      isMessageLoopRunning ||
+		        ((isMessageLoopRunning = true), schedulePerformWorkUntilDeadline());
+		    }
+		    function requestHostTimeout(callback, ms) {
+		      taskTimeoutID = localSetTimeout(function () {
+		        callback(exports.unstable_now());
+		      }, ms);
+		    }
+		    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+		      "function" ===
+		        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
+		      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+		    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,
+		      isMessageLoopRunning = false,
+		      taskTimeoutID = -1,
+		      frameInterval = 5,
+		      startTime = -1;
+		    if ("function" === typeof localSetImmediate)
+		      var 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);
+		      };
+		    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;
+		        }
+		      };
+		    };
+		    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
+		      "function" ===
+		        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
+		      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+		  })(); 
+	} (scheduler_development));
+	return scheduler_development;
+}
+
+export { requireScheduler_development as __require };