super-time-tracker-ui 0.1.37 → 0.1.39

package/dist/standalone/node_modules/@swc/helpers/cjs/_async_generator_delegate.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+function _async_generator_delegate(inner, awaitWrap) {
+    var iter = {}, waiting = false;
+
+    function pump(key, value) {
+        waiting = true;
+        value = new Promise(function(resolve) {
+            resolve(inner[key](value));
+        });
+
+        return { done: false, value: awaitWrap(value) };
+    }
+
+    if (typeof Symbol === "function" && Symbol.iterator) {
+        iter[Symbol.iterator] = function() {
+            return this;
+        };
+    }
+
+    iter.next = function(value) {
+        if (waiting) {
+            waiting = false;
+
+            return value;
+        }
+
+        return pump("next", value);
+    };
+
+    if (typeof inner.throw === "function") {
+        iter.throw = function(value) {
+            if (waiting) {
+                waiting = false;
+                throw value;
+            }
+
+            return pump("throw", value);
+        };
+    }
+    if (typeof inner.return === "function") {
+        iter.return = function(value) {
+            return pump("return", value);
+        };
+    }
+
+    return iter;
+}
+exports._ = _async_generator_delegate;

package/dist/standalone/node_modules/@swc/helpers/cjs/_async_iterator.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+function _async_iterator(iterable) {
+    var method, async, sync, retry = 2;
+    for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
+        if (async && null != (method = iterable[async])) return method.call(iterable);
+        if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+        async = "@@asyncIterator", sync = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+    function AsyncFromSyncIteratorContinuation(r) {
+        if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+
+        var done = r.done;
+
+        return Promise.resolve(r.value).then(function(value) {
+            return { value: value, done: done };
+        });
+    }
+
+    return AsyncFromSyncIterator = function(s) {
+        this.s = s, this.n = s.next;
+    },
+        AsyncFromSyncIterator.prototype = {
+            s: null,
+            n: null,
+
+            next: function() {
+                return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+            },
+            return: function(value) {
+                var ret = this.s.return;
+
+                return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+            },
+            throw: function(value) {
+                var thr = this.s.return;
+
+                return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+            }
+        },
+        new AsyncFromSyncIterator(s);
+}
+exports._ = _async_iterator;

package/dist/standalone/node_modules/@swc/helpers/cjs/_async_to_generator.cjs

@@ -0,0 +1,33 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+
+            _next(undefined);
+        });
+    };
+}
+exports._ = _async_to_generator;

package/dist/standalone/node_modules/@swc/helpers/cjs/_await_async_generator.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+var _await_value = require("./_await_value.cjs");
+
+function _await_async_generator(value) {
+    return new _await_value._(value);
+}
+exports._ = _await_async_generator;

package/dist/standalone/node_modules/@swc/helpers/cjs/_await_value.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+function _await_value(value) {
+    this.wrapped = value;
+}
+exports._ = _await_value;

package/dist/standalone/node_modules/@swc/helpers/cjs/_call_super.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+var _get_prototype_of = require("./_get_prototype_of.cjs");
+var _is_native_reflect_construct = require("./_is_native_reflect_construct.cjs");
+var _possible_constructor_return = require("./_possible_constructor_return.cjs");
+
+function _call_super(_this, derived, args) {
+    // Super
+    derived = _get_prototype_of._(derived);
+    return _possible_constructor_return._(
+        _this,
+        _is_native_reflect_construct._()
+            // NOTE: This doesn't work if this.__proto__.constructor has been modified.
+            ? Reflect.construct(derived, args || [], _get_prototype_of._(_this).constructor)
+            : derived.apply(_this, args)
+    );
+}
+
+exports._ = _call_super;

package/dist/standalone/node_modules/@swc/helpers/cjs/_check_private_redeclaration.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+exports._ = _check_private_redeclaration;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_apply_descriptor_destructure.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+function _class_apply_descriptor_destructure(receiver, descriptor) {
+    if (descriptor.set) {
+        if (!("__destrObj" in descriptor)) {
+            descriptor.__destrObj = {
+                set value(v) {
+                    descriptor.set.call(receiver, v);
+                }
+            };
+        }
+
+        return descriptor.__destrObj;
+    } else {
+        if (!descriptor.writable) {
+            // This should only throw in strict mode, but class bodies are
+            // always strict and private fields can only be used inside
+            // class bodies.
+            throw new TypeError("attempted to set read only private field");
+        }
+
+        return descriptor;
+    }
+}
+exports._ = _class_apply_descriptor_destructure;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_apply_descriptor_get.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+
+    return descriptor.value;
+}
+exports._ = _class_apply_descriptor_get;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_apply_descriptor_set.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) {
+            // This should only throw in strict mode, but class bodies are
+            // always strict and private fields can only be used inside
+            // class bodies.
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+exports._ = _class_apply_descriptor_set;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_apply_descriptor_update.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+function _class_apply_descriptor_update(receiver, descriptor) {
+    if (descriptor.set) {
+        if (!descriptor.get) throw new TypeError("attempted to read set only private field");
+
+        if (!("__destrWrapper" in descriptor)) {
+            descriptor.__destrWrapper = {
+                set value(v) {
+                    descriptor.set.call(receiver, v);
+                },
+                get value() {
+                    return descriptor.get.call(receiver);
+                }
+            };
+        }
+
+        return descriptor.__destrWrapper;
+    } else {
+        if (!descriptor.writable) {
+            // This should only throw in strict mode, but class bodies are
+            // always strict and private fields can only be used inside
+            // class bodies.
+            throw new TypeError("attempted to set read only private field");
+        }
+
+        return descriptor;
+    }
+}
+exports._ = _class_apply_descriptor_update;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_call_check.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+exports._ = _class_call_check;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_check_private_static_access.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+function _class_check_private_static_access(receiver, classConstructor) {
+    if (receiver !== classConstructor) throw new TypeError("Private static access of wrong provenance");
+}
+exports._ = _class_check_private_static_access;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_check_private_static_field_descriptor.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+function _class_check_private_static_field_descriptor(descriptor, action) {
+    if (descriptor === undefined) {
+        throw new TypeError("attempted to " + action + " private static field before its declaration");
+    }
+}
+exports._ = _class_check_private_static_field_descriptor;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_extract_field_descriptor.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+
+    return privateMap.get(receiver);
+}
+exports._ = _class_extract_field_descriptor;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_name_tdz_error.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+function _class_name_tdz_error(name) {
+    throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+exports._ = _class_name_tdz_error;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_destructure.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+var _class_apply_descriptor_destructure = require("./_class_apply_descriptor_destructure.cjs");
+var _class_extract_field_descriptor = require("./_class_extract_field_descriptor.cjs");
+
+function _class_private_field_destructure(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor._(receiver, privateMap, "set");
+    return _class_apply_descriptor_destructure._(receiver, descriptor);
+}
+exports._ = _class_private_field_destructure;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_get.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+var _class_apply_descriptor_get = require("./_class_apply_descriptor_get.cjs");
+var _class_extract_field_descriptor = require("./_class_extract_field_descriptor.cjs");
+
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor._(receiver, privateMap, "get");
+    return _class_apply_descriptor_get._(receiver, descriptor);
+}
+exports._ = _class_private_field_get;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_init.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+var _check_private_redeclaration = require("./_check_private_redeclaration.cjs");
+
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration._(obj, privateMap);
+    privateMap.set(obj, value);
+}
+exports._ = _class_private_field_init;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_loose_base.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+function _class_private_field_loose_base(receiver, privateKey) {
+    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+        throw new TypeError("attempted to use private field on non-instance");
+    }
+
+    return receiver;
+}
+exports._ = _class_private_field_loose_base;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_loose_key.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+var id = 0;
+
+function _class_private_field_loose_key(name) {
+    return "__private_" + id++ + "_" + name;
+}
+exports._ = _class_private_field_loose_key;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_set.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+var _class_apply_descriptor_set = require("./_class_apply_descriptor_set.cjs");
+var _class_extract_field_descriptor = require("./_class_extract_field_descriptor.cjs");
+
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor._(receiver, privateMap, "set");
+    _class_apply_descriptor_set._(receiver, descriptor, value);
+    return value;
+}
+exports._ = _class_private_field_set;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_field_update.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+var _class_apply_descriptor_update = require("./_class_apply_descriptor_update.cjs");
+var _class_extract_field_descriptor = require("./_class_extract_field_descriptor.cjs");
+
+function _class_private_field_update(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor._(receiver, privateMap, "update");
+    return _class_apply_descriptor_update._(receiver, descriptor);
+}
+exports._ = _class_private_field_update;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_method_get.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+
+    return fn;
+}
+exports._ = _class_private_method_get;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_method_init.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+var _check_private_redeclaration = require("./_check_private_redeclaration.cjs");
+
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration._(obj, privateSet);
+    privateSet.add(obj);
+}
+exports._ = _class_private_method_init;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_private_method_set.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+function _class_private_method_set() {
+    throw new TypeError("attempted to reassign private method");
+}
+exports._ = _class_private_method_set;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_static_private_field_destructure.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+var _class_apply_descriptor_destructure = require("./_class_apply_descriptor_destructure.cjs");
+var _class_check_private_static_access = require("./_class_check_private_static_access.cjs");
+var _class_check_private_static_field_descriptor = require("./_class_check_private_static_field_descriptor.cjs");
+
+function _class_static_private_field_destructure(receiver, classConstructor, descriptor) {
+    _class_check_private_static_access._(receiver, classConstructor);
+    _class_check_private_static_field_descriptor._(descriptor, "set");
+
+    return _class_apply_descriptor_destructure._(receiver, descriptor);
+}
+exports._ = _class_static_private_field_destructure;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_static_private_field_spec_get.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+var _class_apply_descriptor_get = require("./_class_apply_descriptor_get.cjs");
+var _class_check_private_static_access = require("./_class_check_private_static_access.cjs");
+var _class_check_private_static_field_descriptor = require("./_class_check_private_static_field_descriptor.cjs");
+
+function _class_static_private_field_spec_get(receiver, classConstructor, descriptor) {
+    _class_check_private_static_access._(receiver, classConstructor);
+    _class_check_private_static_field_descriptor._(descriptor, "get");
+
+    return _class_apply_descriptor_get._(receiver, descriptor);
+}
+exports._ = _class_static_private_field_spec_get;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_static_private_field_spec_set.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+var _class_apply_descriptor_set = require("./_class_apply_descriptor_set.cjs");
+var _class_check_private_static_access = require("./_class_check_private_static_access.cjs");
+var _class_check_private_static_field_descriptor = require("./_class_check_private_static_field_descriptor.cjs");
+
+function _class_static_private_field_spec_set(receiver, classConstructor, descriptor, value) {
+    _class_check_private_static_access._(receiver, classConstructor);
+    _class_check_private_static_field_descriptor._(descriptor, "set");
+    _class_apply_descriptor_set._(receiver, descriptor, value);
+
+    return value;
+}
+exports._ = _class_static_private_field_spec_set;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_static_private_field_update.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+var _class_apply_descriptor_update = require("./_class_apply_descriptor_update.cjs");
+var _class_check_private_static_access = require("./_class_check_private_static_access.cjs");
+var _class_check_private_static_field_descriptor = require("./_class_check_private_static_field_descriptor.cjs");
+
+function _class_static_private_field_update(receiver, classConstructor, descriptor) {
+    _class_check_private_static_access._(receiver, classConstructor);
+    _class_check_private_static_field_descriptor._(descriptor, "update");
+
+    return _class_apply_descriptor_update._(receiver, descriptor);
+}
+exports._ = _class_static_private_field_update;

package/dist/standalone/node_modules/@swc/helpers/cjs/_class_static_private_method_get.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+var _class_check_private_static_access = require("./_class_check_private_static_access.cjs");
+
+function _class_static_private_method_get(receiver, classConstructor, method) {
+    _class_check_private_static_access._(receiver, classConstructor);
+
+    return method;
+}
+exports._ = _class_static_private_method_get;

package/dist/standalone/node_modules/@swc/helpers/cjs/_construct.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+var _is_native_reflect_construct = require("./_is_native_reflect_construct.cjs");
+var _set_prototype_of = require("./_set_prototype_of.cjs");
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct._()) exports._ = _construct = Reflect.construct;
+    else {
+        exports._ = _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+
+            if (Class) _set_prototype_of._(instance, Class.prototype);
+
+            return instance;
+        };
+    }
+
+    return _construct.apply(null, arguments);
+}
+exports._ = _construct;

package/dist/standalone/node_modules/@swc/helpers/cjs/_create_class.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+
+        if ("value" in descriptor) descriptor.writable = true;
+
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+
+    return Constructor;
+}
+exports._ = _create_class;

package/dist/standalone/node_modules/@swc/helpers/cjs/_create_for_of_iterator_helper_loose.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+var _unsupported_iterable_to_array = require("./_unsupported_iterable_to_array.cjs");
+
+function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+
+    if (it) return (it = it.call(o)).next.bind(it);
+    // Fallback for engines without symbol support
+    if (Array.isArray(o) || (it = _unsupported_iterable_to_array._(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+
+        var i = 0;
+
+        return function() {
+            if (i >= o.length) return { done: true };
+
+            return { done: false, value: o[i++] };
+        };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+exports._ = _create_for_of_iterator_helper_loose;

package/dist/standalone/node_modules/@swc/helpers/cjs/_create_super.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+var _get_prototype_of = require("./_get_prototype_of.cjs");
+var _is_native_reflect_construct = require("./_is_native_reflect_construct.cjs");
+var _possible_constructor_return = require("./_possible_constructor_return.cjs");
+
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct._();
+
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of._(Derived), result;
+
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of._(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+
+        return _possible_constructor_return._(this, result);
+    };
+}
+exports._ = _create_super;