super-time-tracker-ui 0.1.37 → 0.1.38

package/dist/standalone/node_modules/@swc/helpers/esm/_apply_decs_2203_r.js

@@ -0,0 +1,548 @@
+/* @minVersion 7.20.0 */
+
+/**
+  Enums are used in this file, but not assigned to vars to avoid non-hoistable values
+
+  CONSTRUCTOR = 0;
+  PUBLIC = 1;
+  PRIVATE = 2;
+
+  FIELD = 0;
+  ACCESSOR = 1;
+  METHOD = 2;
+  GETTER = 3;
+  SETTER = 4;
+
+  STATIC = 5;
+
+  CLASS = 10; // only used in assertValidReturnValue
+*/
+
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+    function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+        return function addInitializer(initializer) {
+            assertNotFinished(decoratorFinishedRef, "addInitializer");
+            assertCallable(initializer, "An initializer");
+            initializers.push(initializer);
+        };
+    }
+
+    function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+        var kindStr;
+
+        switch (kind) {
+            case 1 /* ACCESSOR */:
+                kindStr = "accessor";
+                break;
+            case 2 /* METHOD */:
+                kindStr = "method";
+                break;
+            case 3 /* GETTER */:
+                kindStr = "getter";
+                break;
+            case 4 /* SETTER */:
+                kindStr = "setter";
+                break;
+            default:
+                kindStr = "field";
+        }
+
+        var ctx = { kind: kindStr, name: isPrivate ? "#" + name : name, static: isStatic, private: isPrivate, metadata: metadata };
+
+        var decoratorFinishedRef = { v: false };
+
+        ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+
+        var get, set;
+        if (kind === 0 /* FIELD */) {
+            if (isPrivate) {
+                get = desc.get;
+                set = desc.set;
+            } else {
+                get = function() {
+                    return this[name];
+                };
+                set = function(v) {
+                    this[name] = v;
+                };
+            }
+        } else if (kind === 2 /* METHOD */) {
+            get = function() {
+                return desc.value;
+            };
+        } else {
+            // replace with values that will go through the final getter and setter
+            if (kind === 1 /* ACCESSOR */ || kind === 3 /* GETTER */) {
+                get = function() {
+                    return desc.get.call(this);
+                };
+            }
+
+            if (kind === 1 /* ACCESSOR */ || kind === 4 /* SETTER */) {
+                set = function(v) {
+                    desc.set.call(this, v);
+                };
+            }
+        }
+        ctx.access = get && set ? { get: get, set: set } : get ? { get: get } : { set: set };
+
+        try {
+            return dec(value, ctx);
+        } finally {
+            decoratorFinishedRef.v = true;
+        }
+    }
+
+    function assertNotFinished(decoratorFinishedRef, fnName) {
+        if (decoratorFinishedRef.v) {
+            throw new Error("attempted to call " + fnName + " after decoration was finished");
+        }
+    }
+
+    function assertCallable(fn, hint) {
+        if (typeof fn !== "function") {
+            throw new TypeError(hint + " must be a function");
+        }
+    }
+
+    function assertValidReturnValue(kind, value) {
+        var type = typeof value;
+
+        if (kind === 1 /* ACCESSOR */) {
+            if (type !== "object" || value === null) {
+                throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+            }
+            if (value.get !== undefined) {
+                assertCallable(value.get, "accessor.get");
+            }
+            if (value.set !== undefined) {
+                assertCallable(value.set, "accessor.set");
+            }
+            if (value.init !== undefined) {
+                assertCallable(value.init, "accessor.init");
+            }
+        } else if (type !== "function") {
+            var hint;
+            if (kind === 0 /* FIELD */) {
+                hint = "field";
+            } else if (kind === 10 /* CLASS */) {
+                hint = "class";
+            } else {
+                hint = "method";
+            }
+            throw new TypeError(hint + " decorators must return a function or void 0");
+        }
+    }
+
+    function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+        var decs = decInfo[0];
+
+        var desc, init, value;
+
+        if (isPrivate) {
+            if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {
+                desc = { get: decInfo[3], set: decInfo[4] };
+            } else if (kind === 3 /* GETTER */) {
+                desc = { get: decInfo[3] };
+            } else if (kind === 4 /* SETTER */) {
+                desc = { set: decInfo[3] };
+            } else {
+                desc = { value: decInfo[3] };
+            }
+        } else if (kind !== 0 /* FIELD */) {
+            desc = Object.getOwnPropertyDescriptor(base, name);
+        }
+
+        if (kind === 1 /* ACCESSOR */) {
+            value = { get: desc.get, set: desc.set };
+        } else if (kind === 2 /* METHOD */) {
+            value = desc.value;
+        } else if (kind === 3 /* GETTER */) {
+            value = desc.get;
+        } else if (kind === 4 /* SETTER */) {
+            value = desc.set;
+        }
+
+        var newValue, get, set;
+
+        if (typeof decs === "function") {
+            newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+
+            if (newValue !== void 0) {
+                assertValidReturnValue(kind, newValue);
+
+                if (kind === 0 /* FIELD */) {
+                    init = newValue;
+                } else if (kind === 1 /* ACCESSOR */) {
+                    init = newValue.init;
+                    get = newValue.get || value.get;
+                    set = newValue.set || value.set;
+
+                    value = { get: get, set: set };
+                } else {
+                    value = newValue;
+                }
+            }
+        } else {
+            for (var i = decs.length - 1; i >= 0; i--) {
+                var dec = decs[i];
+
+                newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+
+                if (newValue !== void 0) {
+                    assertValidReturnValue(kind, newValue);
+                    var newInit;
+
+                    if (kind === 0 /* FIELD */) {
+                        newInit = newValue;
+                    } else if (kind === 1 /* ACCESSOR */) {
+                        newInit = newValue.init;
+                        get = newValue.get || value.get;
+                        set = newValue.set || value.set;
+
+                        value = { get: get, set: set };
+                    } else {
+                        value = newValue;
+                    }
+
+                    if (newInit !== void 0) {
+                        if (init === void 0) {
+                            init = newInit;
+                        } else if (typeof init === "function") {
+                            init = [init, newInit];
+                        } else {
+                            init.push(newInit);
+                        }
+                    }
+                }
+            }
+        }
+
+        if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {
+            if (init === void 0) {
+                // If the initializer was void 0, sub in a dummy initializer
+                init = function(instance, init) {
+                    return init;
+                };
+            } else if (typeof init !== "function") {
+                var ownInitializers = init;
+
+                init = function(instance, init) {
+                    var value = init;
+
+                    for (var i = 0; i < ownInitializers.length; i++) value = ownInitializers[i].call(instance, value);
+
+                    return value;
+                };
+            } else {
+                var originalInitializer = init;
+
+                init = function(instance, init) {
+                    return originalInitializer.call(instance, init);
+                };
+            }
+
+            ret.push(init);
+        }
+
+        if (kind !== 0 /* FIELD */) {
+            if (kind === 1 /* ACCESSOR */) {
+                desc.get = value.get;
+                desc.set = value.set;
+            } else if (kind === 2 /* METHOD */) {
+                desc.value = value;
+            } else if (kind === 3 /* GETTER */) {
+                desc.get = value;
+            } else if (kind === 4 /* SETTER */) {
+                desc.set = value;
+            }
+
+            if (isPrivate) {
+                if (kind === 1 /* ACCESSOR */) {
+                    ret.push(function(instance, args) {
+                        return value.get.call(instance, args);
+                    });
+                    ret.push(function(instance, args) {
+                        return value.set.call(instance, args);
+                    });
+                } else if (kind === 2 /* METHOD */) {
+                    ret.push(value);
+                } else {
+                    ret.push(function(instance, args) {
+                        return value.call(instance, args);
+                    });
+                }
+            } else {
+                Object.defineProperty(base, name, desc);
+            }
+        }
+    }
+
+    function applyMemberDecs(Class, decInfos, metadata) {
+        var ret = [];
+        var protoInitializers;
+        var staticInitializers;
+
+        var existingProtoNonFields = new Map();
+        var existingStaticNonFields = new Map();
+
+        for (var i = 0; i < decInfos.length; i++) {
+            var decInfo = decInfos[i];
+
+            // skip computed property names
+            if (!Array.isArray(decInfo)) continue;
+
+            var kind = decInfo[1];
+            var name = decInfo[2];
+            var isPrivate = decInfo.length > 3;
+
+            var isStatic = kind >= 5; /* STATIC */
+            var base;
+            var initializers;
+
+            if (isStatic) {
+                base = Class;
+                kind = kind - 5 /* STATIC */;
+                // initialize staticInitializers when we see a non-field static member
+                staticInitializers = staticInitializers || [];
+                initializers = staticInitializers;
+            } else {
+                base = Class.prototype;
+                // initialize protoInitializers when we see a non-field member
+                protoInitializers = protoInitializers || [];
+                initializers = protoInitializers;
+            }
+
+            if (kind !== 0 /* FIELD */ && !isPrivate) {
+                var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+
+                var existingKind = existingNonFields.get(name) || 0;
+
+                if (existingKind === true || (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ || (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */) {
+                    throw new Error(
+                        "Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "
+                            + name
+                    );
+                } else if (!existingKind && kind > 2 /* METHOD */) {
+                    existingNonFields.set(name, kind);
+                } else {
+                    existingNonFields.set(name, true);
+                }
+            }
+
+            applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+        }
+
+        pushInitializers(ret, protoInitializers);
+        pushInitializers(ret, staticInitializers);
+        return ret;
+    }
+
+    function pushInitializers(ret, initializers) {
+        if (initializers) {
+            ret.push(function(instance) {
+                for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+                return instance;
+            });
+        }
+    }
+
+    function applyClassDecs(targetClass, classDecs, metadata) {
+        if (classDecs.length > 0) {
+            var initializers = [];
+            var newClass = targetClass;
+            var name = targetClass.name;
+
+            for (var i = classDecs.length - 1; i >= 0; i--) {
+                var decoratorFinishedRef = { v: false };
+
+                try {
+                    var nextNewClass = classDecs[i](newClass, { kind: "class", name: name, addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef), metadata });
+                } finally {
+                    decoratorFinishedRef.v = true;
+                }
+
+                if (nextNewClass !== undefined) {
+                    assertValidReturnValue(10, /* CLASS */ nextNewClass);
+                    newClass = nextNewClass;
+                }
+            }
+
+            return [defineMetadata(newClass, metadata), function() {
+                for (var i = 0; i < initializers.length; i++) initializers[i].call(newClass);
+            }];
+        }
+        // The transformer will not emit assignment when there are no class decorators,
+        // so we don't have to return an empty array here.
+    }
+
+    function defineMetadata(Class, metadata) {
+        return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: true, enumerable: true, value: metadata });
+    }
+
+    /**
+    Basic usage:
+
+    applyDecs(
+      Class,
+      [
+        // member decorators
+        [
+          dec,                // dec or array of decs
+          0,                  // kind of value being decorated
+          'prop',             // name of public prop on class containing the value being decorated,
+          '#p',               // the name of the private property (if is private, void 0 otherwise),
+        ]
+      ],
+      [
+        // class decorators
+        dec1, dec2
+      ]
+    )
+    ```
+
+    Fully transpiled example:
+
+    ```js
+    @dec
+    class Class {
+      @dec
+      a = 123;
+
+      @dec
+      #a = 123;
+
+      @dec
+      @dec2
+      accessor b = 123;
+
+      @dec
+      accessor #b = 123;
+
+      @dec
+      c() { console.log('c'); }
+
+      @dec
+      #c() { console.log('privC'); }
+
+      @dec
+      get d() { console.log('d'); }
+
+      @dec
+      get #d() { console.log('privD'); }
+
+      @dec
+      set e(v) { console.log('e'); }
+
+      @dec
+      set #e(v) { console.log('privE'); }
+    }
+
+
+    // becomes
+    let initializeInstance;
+    let initializeClass;
+
+    let initA;
+    let initPrivA;
+
+    let initB;
+    let initPrivB, getPrivB, setPrivB;
+
+    let privC;
+    let privD;
+    let privE;
+
+    let Class;
+    class _Class {
+      static {
+        let ret = applyDecs(
+          this,
+          [
+            [dec, 0, 'a'],
+            [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],
+            [[dec, dec2], 1, 'b'],
+            [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],
+            [dec, 2, 'c'],
+            [dec, 2, 'c', () => console.log('privC')],
+            [dec, 3, 'd'],
+            [dec, 3, 'd', () => console.log('privD')],
+            [dec, 4, 'e'],
+            [dec, 4, 'e', () => console.log('privE')],
+          ],
+          [
+            dec
+          ]
+        )
+
+        initA = ret[0];
+
+        initPrivA = ret[1];
+
+        initB = ret[2];
+
+        initPrivB = ret[3];
+        getPrivB = ret[4];
+        setPrivB = ret[5];
+
+        privC = ret[6];
+
+        privD = ret[7];
+
+        privE = ret[8];
+
+        initializeInstance = ret[9];
+
+        Class = ret[10]
+
+        initializeClass = ret[11];
+      }
+
+      a = (initializeInstance(this), initA(this, 123));
+
+      #a = initPrivA(this, 123);
+
+      #bData = initB(this, 123);
+      get b() { return this.#bData }
+      set b(v) { this.#bData = v }
+
+      #privBData = initPrivB(this, 123);
+      get #b() { return getPrivB(this); }
+      set #b(v) { setPrivB(this, v); }
+
+      c() { console.log('c'); }
+
+      #c(...args) { return privC(this, ...args) }
+
+      get d() { console.log('d'); }
+
+      get #d() { return privD(this); }
+
+      set e(v) { console.log('e'); }
+
+      set #e(v) { privE(this, v); }
+    }
+
+    initializeClass(Class);
+   */
+
+    _apply_decs_2203_r = function(targetClass, memberDecs, classDecs, parentClass) {
+        if (parentClass !== void 0) {
+            var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+        }
+        var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+        var e = applyMemberDecs(targetClass, memberDecs, metadata);
+        if (!classDecs.length) defineMetadata(targetClass, metadata);
+        return {
+            e: e,
+            // Lazily apply class decorations so that member init locals can be properly bound.
+            get c() {
+                return applyClassDecs(targetClass, classDecs, metadata);
+            }
+        };
+    };
+
+    return _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass);
+}
+
+export { _apply_decs_2203_r as _ };

package/dist/standalone/node_modules/@swc/helpers/esm/_array_like_to_array.js

@@ -0,0 +1,8 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+    return arr2;
+}
+export { _array_like_to_array as _ };

package/dist/standalone/node_modules/@swc/helpers/esm/_array_with_holes.js

@@ -0,0 +1,4 @@
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+export { _array_with_holes as _ };

package/dist/standalone/node_modules/@swc/helpers/esm/_array_without_holes.js

@@ -0,0 +1,6 @@
+import { _ as _array_like_to_array } from "./_array_like_to_array.js";
+
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+export { _array_without_holes as _ };

package/dist/standalone/node_modules/@swc/helpers/esm/_assert_this_initialized.js

@@ -0,0 +1,6 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+
+    return self;
+}
+export { _assert_this_initialized as _ };

package/dist/standalone/node_modules/@swc/helpers/esm/_async_generator.js

@@ -0,0 +1,76 @@
+import { _ as _await_value } from "./_await_value.js";
+
+function _async_generator(gen) {
+    var front, back;
+
+    function send(key, arg) {
+        return new Promise(function(resolve, reject) {
+            var request = { key: key, arg: arg, resolve: resolve, reject: reject, next: null };
+            if (back) back = back.next = request;
+            else {
+                front = back = request;
+                resume(key, arg);
+            }
+        });
+    }
+
+    function resume(key, arg) {
+        try {
+            var result = gen[key](arg);
+            var value = result.value;
+            var wrappedAwait = value instanceof _await_value;
+            Promise.resolve(wrappedAwait ? value.wrapped : value).then(function(arg) {
+                if (wrappedAwait) {
+                    resume("next", arg);
+
+                    return;
+                }
+                settle(result.done ? "return" : "normal", arg);
+            }, function(err) {
+                resume("throw", err);
+            });
+        } catch (err) {
+            settle("throw", err);
+        }
+    }
+
+    function settle(type, value) {
+        switch (type) {
+            case "return":
+                front.resolve({ value: value, done: true });
+                break;
+            case "throw":
+                front.reject(value);
+                break;
+            default:
+                front.resolve({ value: value, done: false });
+                break;
+        }
+        front = front.next;
+        if (front) resume(front.key, front.arg);
+        else back = null;
+    }
+
+    this._invoke = send;
+
+    if (typeof gen.return !== "function") this.return = undefined;
+}
+
+if (typeof Symbol === "function" && Symbol.asyncIterator) {
+    _async_generator.prototype[Symbol.asyncIterator] = function() {
+        return this;
+    };
+}
+
+_async_generator.prototype.next = function(arg) {
+    return this._invoke("next", arg);
+};
+
+_async_generator.prototype.throw = function(arg) {
+    return this._invoke("throw", arg);
+};
+
+_async_generator.prototype.return = function(arg) {
+    return this._invoke("return", arg);
+};
+export { _async_generator as _ };

package/dist/standalone/node_modules/@swc/helpers/esm/_async_generator_delegate.js

@@ -0,0 +1,47 @@
+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;
+}
+export { _async_generator_delegate as _ };