omniroute 2.3.12 → 2.3.14

package/app/node_modules/@swc/helpers/esm/_async_iterator.js

@@ -0,0 +1,44 @@
+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);
+}
+export { _async_iterator as _ };

package/app/node_modules/@swc/helpers/esm/_async_to_generator.js

@@ -0,0 +1,31 @@
+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);
+        });
+    };
+}
+export { _async_to_generator as _ };

package/app/node_modules/@swc/helpers/esm/_await_async_generator.js

@@ -0,0 +1,6 @@
+import { _ as _overload_yield } from "./_overload_yield.js";
+
+function _await_async_generator(value) {
+    return new _overload_yield(value, /* kind: await */ 0);
+}
+export { _await_async_generator as _ };

package/app/node_modules/@swc/helpers/esm/_await_value.js

@@ -0,0 +1,4 @@
+function _await_value(value) {
+    this.wrapped = value;
+}
+export { _await_value as _ };

package/app/node_modules/@swc/helpers/esm/_call_super.js

@@ -0,0 +1,17 @@
+import { _ as _get_prototype_of } from "./_get_prototype_of.js";
+import { _ as _is_native_reflect_construct } from "./_is_native_reflect_construct.js";
+import { _ as _possible_constructor_return } from "./_possible_constructor_return.js";
+
+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)
+    );
+}
+
+export { _call_super as _ };

package/app/node_modules/@swc/helpers/esm/_check_private_redeclaration.js

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

package/app/node_modules/@swc/helpers/esm/_class_apply_descriptor_destructure.js

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

package/app/node_modules/@swc/helpers/esm/_class_apply_descriptor_get.js

@@ -0,0 +1,6 @@
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+
+    return descriptor.value;
+}
+export { _class_apply_descriptor_get as _ };

package/app/node_modules/@swc/helpers/esm/_class_apply_descriptor_set.js

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

package/app/node_modules/@swc/helpers/esm/_class_apply_descriptor_update.js

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

package/app/node_modules/@swc/helpers/esm/_class_call_check.js

@@ -0,0 +1,4 @@
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+export { _class_call_check as _ };

package/app/node_modules/@swc/helpers/esm/_class_check_private_static_access.js

@@ -0,0 +1,4 @@
+function _class_check_private_static_access(receiver, classConstructor) {
+    if (receiver !== classConstructor) throw new TypeError("Private static access of wrong provenance");
+}
+export { _class_check_private_static_access as _ };

package/app/node_modules/@swc/helpers/esm/_class_check_private_static_field_descriptor.js

@@ -0,0 +1,6 @@
+function _class_check_private_static_field_descriptor(descriptor, action) {
+    if (descriptor === undefined) {
+        throw new TypeError("attempted to " + action + " private static field before its declaration");
+    }
+}
+export { _class_check_private_static_field_descriptor as _ };

package/app/node_modules/@swc/helpers/esm/_class_extract_field_descriptor.js

@@ -0,0 +1,6 @@
+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);
+}
+export { _class_extract_field_descriptor as _ };

package/app/node_modules/@swc/helpers/esm/_class_name_tdz_error.js

@@ -0,0 +1,4 @@
+function _class_name_tdz_error(name) {
+    throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
+}
+export { _class_name_tdz_error as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_field_destructure.js

@@ -0,0 +1,8 @@
+import { _ as _class_apply_descriptor_destructure } from "./_class_apply_descriptor_destructure.js";
+import { _ as _class_extract_field_descriptor } from "./_class_extract_field_descriptor.js";
+
+function _class_private_field_destructure(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    return _class_apply_descriptor_destructure(receiver, descriptor);
+}
+export { _class_private_field_destructure as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_field_get.js

@@ -0,0 +1,8 @@
+import { _ as _class_apply_descriptor_get } from "./_class_apply_descriptor_get.js";
+import { _ as _class_extract_field_descriptor } from "./_class_extract_field_descriptor.js";
+
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+export { _class_private_field_get as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_field_init.js

@@ -0,0 +1,7 @@
+import { _ as _check_private_redeclaration } from "./_check_private_redeclaration.js";
+
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+export { _class_private_field_init as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_field_loose_base.js

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

package/app/node_modules/@swc/helpers/esm/_class_private_field_loose_key.js

@@ -0,0 +1,6 @@
+var id = 0;
+
+function _class_private_field_loose_key(name) {
+    return "__private_" + id++ + "_" + name;
+}
+export { _class_private_field_loose_key as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_field_set.js

@@ -0,0 +1,9 @@
+import { _ as _class_apply_descriptor_set } from "./_class_apply_descriptor_set.js";
+import { _ as _class_extract_field_descriptor } from "./_class_extract_field_descriptor.js";
+
+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;
+}
+export { _class_private_field_set as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_field_update.js

@@ -0,0 +1,8 @@
+import { _ as _class_apply_descriptor_update } from "./_class_apply_descriptor_update.js";
+import { _ as _class_extract_field_descriptor } from "./_class_extract_field_descriptor.js";
+
+function _class_private_field_update(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "update");
+    return _class_apply_descriptor_update(receiver, descriptor);
+}
+export { _class_private_field_update as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_method_get.js

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

package/app/node_modules/@swc/helpers/esm/_class_private_method_init.js

@@ -0,0 +1,7 @@
+import { _ as _check_private_redeclaration } from "./_check_private_redeclaration.js";
+
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+export { _class_private_method_init as _ };

package/app/node_modules/@swc/helpers/esm/_class_private_method_set.js

@@ -0,0 +1,4 @@
+function _class_private_method_set() {
+    throw new TypeError("attempted to reassign private method");
+}
+export { _class_private_method_set as _ };

package/app/node_modules/@swc/helpers/esm/_class_static_private_field_destructure.js

@@ -0,0 +1,11 @@
+import { _ as _class_apply_descriptor_destructure } from "./_class_apply_descriptor_destructure.js";
+import { _ as _class_check_private_static_access } from "./_class_check_private_static_access.js";
+import { _ as _class_check_private_static_field_descriptor } from "./_class_check_private_static_field_descriptor.js";
+
+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);
+}
+export { _class_static_private_field_destructure as _ };

package/app/node_modules/@swc/helpers/esm/_class_static_private_field_spec_get.js

@@ -0,0 +1,11 @@
+import { _ as _class_apply_descriptor_get } from "./_class_apply_descriptor_get.js";
+import { _ as _class_check_private_static_access } from "./_class_check_private_static_access.js";
+import { _ as _class_check_private_static_field_descriptor } from "./_class_check_private_static_field_descriptor.js";
+
+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);
+}
+export { _class_static_private_field_spec_get as _ };

package/app/node_modules/@swc/helpers/esm/_class_static_private_field_spec_set.js

@@ -0,0 +1,12 @@
+import { _ as _class_apply_descriptor_set } from "./_class_apply_descriptor_set.js";
+import { _ as _class_check_private_static_access } from "./_class_check_private_static_access.js";
+import { _ as _class_check_private_static_field_descriptor } from "./_class_check_private_static_field_descriptor.js";
+
+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;
+}
+export { _class_static_private_field_spec_set as _ };

package/app/node_modules/@swc/helpers/esm/_class_static_private_field_update.js

@@ -0,0 +1,11 @@
+import { _ as _class_apply_descriptor_update } from "./_class_apply_descriptor_update.js";
+import { _ as _class_check_private_static_access } from "./_class_check_private_static_access.js";
+import { _ as _class_check_private_static_field_descriptor } from "./_class_check_private_static_field_descriptor.js";
+
+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);
+}
+export { _class_static_private_field_update as _ };

package/app/node_modules/@swc/helpers/esm/_class_static_private_method_get.js

@@ -0,0 +1,8 @@
+import { _ as _class_check_private_static_access } from "./_class_check_private_static_access.js";
+
+function _class_static_private_method_get(receiver, classConstructor, method) {
+    _class_check_private_static_access(receiver, classConstructor);
+
+    return method;
+}
+export { _class_static_private_method_get as _ };

package/app/node_modules/@swc/helpers/esm/_construct.js

@@ -0,0 +1,20 @@
+import { _ as _is_native_reflect_construct } from "./_is_native_reflect_construct.js";
+import { _ as _set_prototype_of } from "./_set_prototype_of.js";
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _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);
+}
+export { _construct as _ };

package/app/node_modules/@swc/helpers/esm/_create_class.js

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

package/app/node_modules/@swc/helpers/esm/_create_for_of_iterator_helper_loose.js

@@ -0,0 +1,22 @@
+import { _ as _unsupported_iterable_to_array } from "./_unsupported_iterable_to_array.js";
+
+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.");
+}
+export { _create_for_of_iterator_helper_loose as _ };

package/app/node_modules/@swc/helpers/esm/_create_super.js

@@ -0,0 +1,21 @@
+import { _ as _get_prototype_of } from "./_get_prototype_of.js";
+import { _ as _is_native_reflect_construct } from "./_is_native_reflect_construct.js";
+import { _ as _possible_constructor_return } from "./_possible_constructor_return.js";
+
+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);
+    };
+}
+export { _create_super as _ };