@absolutejs/auth 0.57.3 → 0.57.5

package/dist/server.js

@@ -181,6 +181,1002 @@ var init_crypto = __esm(() => {
   textDecoder = new TextDecoder;
 });
 
+// node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS(() => {
+  /*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** */
+  var Reflect2;
+  (function(Reflect3) {
+    (function(factory) {
+      var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+      var exporter = makeExporter(Reflect3);
+      if (typeof root.Reflect !== "undefined") {
+        exporter = makeExporter(root.Reflect, exporter);
+      }
+      factory(exporter, root);
+      if (typeof root.Reflect === "undefined") {
+        root.Reflect = Reflect3;
+      }
+      function makeExporter(target, previous) {
+        return function(key, value) {
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
+          if (previous)
+            previous(key, value);
+        };
+      }
+      function functionThis() {
+        try {
+          return Function("return this;")();
+        } catch (_) {}
+      }
+      function indirectEvalThis() {
+        try {
+          return (undefined, eval)("(function() { return this; })()");
+        } catch (_) {}
+      }
+      function sloppyModeThis() {
+        return functionThis() || indirectEvalThis();
+      }
+    })(function(exporter, root) {
+      var hasOwn = Object.prototype.hasOwnProperty;
+      var supportsSymbol = typeof Symbol === "function";
+      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+      var supportsCreate = typeof Object.create === "function";
+      var supportsProto = { __proto__: [] } instanceof Array;
+      var downLevel = !supportsCreate && !supportsProto;
+      var HashMap = {
+        create: supportsCreate ? function() {
+          return MakeDictionary(Object.create(null));
+        } : supportsProto ? function() {
+          return MakeDictionary({ __proto__: null });
+        } : function() {
+          return MakeDictionary({});
+        },
+        has: downLevel ? function(map3, key) {
+          return hasOwn.call(map3, key);
+        } : function(map3, key) {
+          return key in map3;
+        },
+        get: downLevel ? function(map3, key) {
+          return hasOwn.call(map3, key) ? map3[key] : undefined;
+        } : function(map3, key) {
+          return map3[key];
+        }
+      };
+      var functionPrototype = Object.getPrototypeOf(Function);
+      var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+      var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+      var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+      var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
+      var metadataRegistry = GetOrCreateMetadataRegistry();
+      var metadataProvider = CreateMetadataProvider(metadataRegistry);
+      function decorate(decorators, target, propertyKey, attributes) {
+        if (!IsUndefined5(propertyKey)) {
+          if (!IsArray5(decorators))
+            throw new TypeError;
+          if (!IsObject5(target))
+            throw new TypeError;
+          if (!IsObject5(attributes) && !IsUndefined5(attributes) && !IsNull5(attributes))
+            throw new TypeError;
+          if (IsNull5(attributes))
+            attributes = undefined;
+          propertyKey = ToPropertyKey(propertyKey);
+          return DecorateProperty(decorators, target, propertyKey, attributes);
+        } else {
+          if (!IsArray5(decorators))
+            throw new TypeError;
+          if (!IsConstructor3(target))
+            throw new TypeError;
+          return DecorateConstructor(decorators, target);
+        }
+      }
+      exporter("decorate", decorate);
+      function metadata(metadataKey, metadataValue) {
+        function decorator(target, propertyKey) {
+          if (!IsObject5(target))
+            throw new TypeError;
+          if (!IsUndefined5(propertyKey) && !IsPropertyKey(propertyKey))
+            throw new TypeError;
+          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        return decorator;
+      }
+      exporter("metadata", metadata);
+      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      exporter("defineMetadata", defineMetadata);
+      function hasMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasMetadata", hasMetadata);
+      function hasOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasOwnMetadata", hasOwnMetadata);
+      function getMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getMetadata", getMetadata);
+      function getOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getOwnMetadata", getOwnMetadata);
+      function getMetadataKeys(target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryMetadataKeys(target, propertyKey);
+      }
+      exporter("getMetadataKeys", getMetadataKeys);
+      function getOwnMetadataKeys(target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryOwnMetadataKeys(target, propertyKey);
+      }
+      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+      function deleteMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        if (!IsObject5(target))
+          throw new TypeError;
+        if (!IsUndefined5(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        var provider = GetMetadataProvider(target, propertyKey, false);
+        if (IsUndefined5(provider))
+          return false;
+        return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("deleteMetadata", deleteMetadata);
+      function DecorateConstructor(decorators, target) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target);
+          if (!IsUndefined5(decorated) && !IsNull5(decorated)) {
+            if (!IsConstructor3(decorated))
+              throw new TypeError;
+            target = decorated;
+          }
+        }
+        return target;
+      }
+      function DecorateProperty(decorators, target, propertyKey, descriptor) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target, propertyKey, descriptor);
+          if (!IsUndefined5(decorated) && !IsNull5(decorated)) {
+            if (!IsObject5(decorated))
+              throw new TypeError;
+            descriptor = decorated;
+          }
+        }
+        return descriptor;
+      }
+      function OrdinaryHasMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return true;
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull5(parent))
+          return OrdinaryHasMetadata(MetadataKey, parent, P);
+        return false;
+      }
+      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined5(provider))
+          return false;
+        return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+      }
+      function OrdinaryGetMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull5(parent))
+          return OrdinaryGetMetadata(MetadataKey, parent, P);
+        return;
+      }
+      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined5(provider))
+          return;
+        return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      }
+      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+        var provider = GetMetadataProvider(O, P, true);
+        provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+      }
+      function OrdinaryMetadataKeys(O, P) {
+        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (parent === null)
+          return ownKeys;
+        var parentKeys = OrdinaryMetadataKeys(parent, P);
+        if (parentKeys.length <= 0)
+          return ownKeys;
+        if (ownKeys.length <= 0)
+          return parentKeys;
+        var set = new _Set;
+        var keys = [];
+        for (var _i2 = 0, ownKeys_1 = ownKeys;_i2 < ownKeys_1.length; _i2++) {
+          var key = ownKeys_1[_i2];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        for (var _a = 0, parentKeys_1 = parentKeys;_a < parentKeys_1.length; _a++) {
+          var key = parentKeys_1[_a];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        return keys;
+      }
+      function OrdinaryOwnMetadataKeys(O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (!provider) {
+          return [];
+        }
+        return provider.OrdinaryOwnMetadataKeys(O, P);
+      }
+      function Type2(x) {
+        if (x === null)
+          return 1;
+        switch (typeof x) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return x === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function IsUndefined5(x) {
+        return x === undefined;
+      }
+      function IsNull5(x) {
+        return x === null;
+      }
+      function IsSymbol5(x) {
+        return typeof x === "symbol";
+      }
+      function IsObject5(x) {
+        return typeof x === "object" ? x !== null : typeof x === "function";
+      }
+      function ToPrimitive(input, PreferredType) {
+        switch (Type2(input)) {
+          case 0:
+            return input;
+          case 1:
+            return input;
+          case 2:
+            return input;
+          case 3:
+            return input;
+          case 4:
+            return input;
+          case 5:
+            return input;
+        }
+        var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+        if (exoticToPrim !== undefined) {
+          var result = exoticToPrim.call(input, hint);
+          if (IsObject5(result))
+            throw new TypeError;
+          return result;
+        }
+        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+      }
+      function OrdinaryToPrimitive(O, hint) {
+        if (hint === "string") {
+          var toString_1 = O.toString;
+          if (IsCallable(toString_1)) {
+            var result = toString_1.call(O);
+            if (!IsObject5(result))
+              return result;
+          }
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject5(result))
+              return result;
+          }
+        } else {
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject5(result))
+              return result;
+          }
+          var toString_2 = O.toString;
+          if (IsCallable(toString_2)) {
+            var result = toString_2.call(O);
+            if (!IsObject5(result))
+              return result;
+          }
+        }
+        throw new TypeError;
+      }
+      function ToBoolean(argument) {
+        return !!argument;
+      }
+      function ToString(argument) {
+        return "" + argument;
+      }
+      function ToPropertyKey(argument) {
+        var key = ToPrimitive(argument, 3);
+        if (IsSymbol5(key))
+          return key;
+        return ToString(key);
+      }
+      function IsArray5(argument) {
+        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+      }
+      function IsCallable(argument) {
+        return typeof argument === "function";
+      }
+      function IsConstructor3(argument) {
+        return typeof argument === "function";
+      }
+      function IsPropertyKey(argument) {
+        switch (Type2(argument)) {
+          case 3:
+            return true;
+          case 4:
+            return true;
+          default:
+            return false;
+        }
+      }
+      function SameValueZero(x, y) {
+        return x === y || x !== x && y !== y;
+      }
+      function GetMethod(V, P) {
+        var func = V[P];
+        if (func === undefined || func === null)
+          return;
+        if (!IsCallable(func))
+          throw new TypeError;
+        return func;
+      }
+      function GetIterator(obj) {
+        var method = GetMethod(obj, iteratorSymbol);
+        if (!IsCallable(method))
+          throw new TypeError;
+        var iterator = method.call(obj);
+        if (!IsObject5(iterator))
+          throw new TypeError;
+        return iterator;
+      }
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
+      function IteratorStep(iterator) {
+        var result = iterator.next();
+        return result.done ? false : result;
+      }
+      function IteratorClose(iterator) {
+        var f = iterator["return"];
+        if (f)
+          f.call(iterator);
+      }
+      function OrdinaryGetPrototypeOf(O) {
+        var proto = Object.getPrototypeOf(O);
+        if (typeof O !== "function" || O === functionPrototype)
+          return proto;
+        if (proto !== functionPrototype)
+          return proto;
+        var prototype = O.prototype;
+        var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+        if (prototypeProto == null || prototypeProto === Object.prototype)
+          return proto;
+        var constructor = prototypeProto.constructor;
+        if (typeof constructor !== "function")
+          return proto;
+        if (constructor === O)
+          return proto;
+        return constructor;
+      }
+      function CreateMetadataRegistry() {
+        var fallback;
+        if (!IsUndefined5(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+          fallback = CreateFallbackProvider(root.Reflect);
+        }
+        var first;
+        var second;
+        var rest;
+        var targetProviderMap = new _WeakMap;
+        var registry = {
+          registerProvider,
+          getProvider,
+          setProvider
+        };
+        return registry;
+        function registerProvider(provider) {
+          if (!Object.isExtensible(registry)) {
+            throw new Error("Cannot add provider to a frozen registry.");
+          }
+          switch (true) {
+            case fallback === provider:
+              break;
+            case IsUndefined5(first):
+              first = provider;
+              break;
+            case first === provider:
+              break;
+            case IsUndefined5(second):
+              second = provider;
+              break;
+            case second === provider:
+              break;
+            default:
+              if (rest === undefined)
+                rest = new _Set;
+              rest.add(provider);
+              break;
+          }
+        }
+        function getProviderNoCache(O, P) {
+          if (!IsUndefined5(first)) {
+            if (first.isProviderFor(O, P))
+              return first;
+            if (!IsUndefined5(second)) {
+              if (second.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined5(rest)) {
+                var iterator = GetIterator(rest);
+                while (true) {
+                  var next = IteratorStep(iterator);
+                  if (!next) {
+                    return;
+                  }
+                  var provider = IteratorValue(next);
+                  if (provider.isProviderFor(O, P)) {
+                    IteratorClose(iterator);
+                    return provider;
+                  }
+                }
+              }
+            }
+          }
+          if (!IsUndefined5(fallback) && fallback.isProviderFor(O, P)) {
+            return fallback;
+          }
+          return;
+        }
+        function getProvider(O, P) {
+          var providerMap = targetProviderMap.get(O);
+          var provider;
+          if (!IsUndefined5(providerMap)) {
+            provider = providerMap.get(P);
+          }
+          if (!IsUndefined5(provider)) {
+            return provider;
+          }
+          provider = getProviderNoCache(O, P);
+          if (!IsUndefined5(provider)) {
+            if (IsUndefined5(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return provider;
+        }
+        function hasProvider(provider) {
+          if (IsUndefined5(provider))
+            throw new TypeError;
+          return first === provider || second === provider || !IsUndefined5(rest) && rest.has(provider);
+        }
+        function setProvider(O, P, provider) {
+          if (!hasProvider(provider)) {
+            throw new Error("Metadata provider not registered.");
+          }
+          var existingProvider = getProvider(O, P);
+          if (existingProvider !== provider) {
+            if (!IsUndefined5(existingProvider)) {
+              return false;
+            }
+            var providerMap = targetProviderMap.get(O);
+            if (IsUndefined5(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return true;
+        }
+      }
+      function GetOrCreateMetadataRegistry() {
+        var metadataRegistry2;
+        if (!IsUndefined5(registrySymbol) && IsObject5(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          metadataRegistry2 = root.Reflect[registrySymbol];
+        }
+        if (IsUndefined5(metadataRegistry2)) {
+          metadataRegistry2 = CreateMetadataRegistry();
+        }
+        if (!IsUndefined5(registrySymbol) && IsObject5(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          Object.defineProperty(root.Reflect, registrySymbol, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: metadataRegistry2
+          });
+        }
+        return metadataRegistry2;
+      }
+      function CreateMetadataProvider(registry) {
+        var metadata2 = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var targetMetadata = metadata2.get(O);
+            if (IsUndefined5(targetMetadata))
+              return false;
+            return targetMetadata.has(P);
+          },
+          OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+          OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+          OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+          OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+          OrdinaryDeleteMetadata
+        };
+        metadataRegistry.registerProvider(provider);
+        return provider;
+        function GetOrCreateMetadataMap(O, P, Create3) {
+          var targetMetadata = metadata2.get(O);
+          var createdTargetMetadata = false;
+          if (IsUndefined5(targetMetadata)) {
+            if (!Create3)
+              return;
+            targetMetadata = new _Map;
+            metadata2.set(O, targetMetadata);
+            createdTargetMetadata = true;
+          }
+          var metadataMap = targetMetadata.get(P);
+          if (IsUndefined5(metadataMap)) {
+            if (!Create3)
+              return;
+            metadataMap = new _Map;
+            targetMetadata.set(P, metadataMap);
+            if (!registry.setProvider(O, P, provider)) {
+              targetMetadata.delete(P);
+              if (createdTargetMetadata) {
+                metadata2.delete(O);
+              }
+              throw new Error("Wrong provider for target.");
+            }
+          }
+          return metadataMap;
+        }
+        function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined5(metadataMap))
+            return false;
+          return ToBoolean(metadataMap.has(MetadataKey));
+        }
+        function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined5(metadataMap))
+            return;
+          return metadataMap.get(MetadataKey);
+        }
+        function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, true);
+          metadataMap.set(MetadataKey, MetadataValue);
+        }
+        function OrdinaryOwnMetadataKeys2(O, P) {
+          var keys = [];
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined5(metadataMap))
+            return keys;
+          var keysObj = metadataMap.keys();
+          var iterator = GetIterator(keysObj);
+          var k = 0;
+          while (true) {
+            var next = IteratorStep(iterator);
+            if (!next) {
+              keys.length = k;
+              return keys;
+            }
+            var nextValue = IteratorValue(next);
+            try {
+              keys[k] = nextValue;
+            } catch (e) {
+              try {
+                IteratorClose(iterator);
+              } finally {
+                throw e;
+              }
+            }
+            k++;
+          }
+        }
+        function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined5(metadataMap))
+            return false;
+          if (!metadataMap.delete(MetadataKey))
+            return false;
+          if (metadataMap.size === 0) {
+            var targetMetadata = metadata2.get(O);
+            if (!IsUndefined5(targetMetadata)) {
+              targetMetadata.delete(P);
+              if (targetMetadata.size === 0) {
+                metadata2.delete(targetMetadata);
+              }
+            }
+          }
+          return true;
+        }
+      }
+      function CreateFallbackProvider(reflect) {
+        var { defineMetadata: defineMetadata2, hasOwnMetadata: hasOwnMetadata2, getOwnMetadata: getOwnMetadata2, getOwnMetadataKeys: getOwnMetadataKeys2, deleteMetadata: deleteMetadata2 } = reflect;
+        var metadataOwner = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var metadataPropertySet = metadataOwner.get(O);
+            if (!IsUndefined5(metadataPropertySet) && metadataPropertySet.has(P)) {
+              return true;
+            }
+            if (getOwnMetadataKeys2(O, P).length) {
+              if (IsUndefined5(metadataPropertySet)) {
+                metadataPropertySet = new _Set;
+                metadataOwner.set(O, metadataPropertySet);
+              }
+              metadataPropertySet.add(P);
+              return true;
+            }
+            return false;
+          },
+          OrdinaryDefineOwnMetadata: defineMetadata2,
+          OrdinaryHasOwnMetadata: hasOwnMetadata2,
+          OrdinaryGetOwnMetadata: getOwnMetadata2,
+          OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+          OrdinaryDeleteMetadata: deleteMetadata2
+        };
+        return provider;
+      }
+      function GetMetadataProvider(O, P, Create3) {
+        var registeredProvider = metadataRegistry.getProvider(O, P);
+        if (!IsUndefined5(registeredProvider)) {
+          return registeredProvider;
+        }
+        if (Create3) {
+          if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+            return metadataProvider;
+          }
+          throw new Error("Illegal state.");
+        }
+        return;
+      }
+      function CreateMapPolyfill() {
+        var cacheSentinel = {};
+        var arraySentinel = [];
+        var MapIterator = function() {
+          function MapIterator2(keys, values, selector) {
+            this._index = 0;
+            this._keys = keys;
+            this._values = values;
+            this._selector = selector;
+          }
+          MapIterator2.prototype["@@iterator"] = function() {
+            return this;
+          };
+          MapIterator2.prototype[iteratorSymbol] = function() {
+            return this;
+          };
+          MapIterator2.prototype.next = function() {
+            var index2 = this._index;
+            if (index2 >= 0 && index2 < this._keys.length) {
+              var result = this._selector(this._keys[index2], this._values[index2]);
+              if (index2 + 1 >= this._keys.length) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              } else {
+                this._index++;
+              }
+              return { value: result, done: false };
+            }
+            return { value: undefined, done: true };
+          };
+          MapIterator2.prototype.throw = function(error) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            throw error;
+          };
+          MapIterator2.prototype.return = function(value) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            return { value, done: true };
+          };
+          return MapIterator2;
+        }();
+        var Map2 = function() {
+          function Map3() {
+            this._keys = [];
+            this._values = [];
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          }
+          Object.defineProperty(Map3.prototype, "size", {
+            get: function() {
+              return this._keys.length;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Map3.prototype.has = function(key) {
+            return this._find(key, false) >= 0;
+          };
+          Map3.prototype.get = function(key) {
+            var index2 = this._find(key, false);
+            return index2 >= 0 ? this._values[index2] : undefined;
+          };
+          Map3.prototype.set = function(key, value) {
+            var index2 = this._find(key, true);
+            this._values[index2] = value;
+            return this;
+          };
+          Map3.prototype.delete = function(key) {
+            var index2 = this._find(key, false);
+            if (index2 >= 0) {
+              var size = this._keys.length;
+              for (var i = index2 + 1;i < size; i++) {
+                this._keys[i - 1] = this._keys[i];
+                this._values[i - 1] = this._values[i];
+              }
+              this._keys.length--;
+              this._values.length--;
+              if (SameValueZero(key, this._cacheKey)) {
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              return true;
+            }
+            return false;
+          };
+          Map3.prototype.clear = function() {
+            this._keys.length = 0;
+            this._values.length = 0;
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          };
+          Map3.prototype.keys = function() {
+            return new MapIterator(this._keys, this._values, getKey);
+          };
+          Map3.prototype.values = function() {
+            return new MapIterator(this._keys, this._values, getValue);
+          };
+          Map3.prototype.entries = function() {
+            return new MapIterator(this._keys, this._values, getEntry);
+          };
+          Map3.prototype["@@iterator"] = function() {
+            return this.entries();
+          };
+          Map3.prototype[iteratorSymbol] = function() {
+            return this.entries();
+          };
+          Map3.prototype._find = function(key, insert) {
+            if (!SameValueZero(this._cacheKey, key)) {
+              this._cacheIndex = -1;
+              for (var i = 0;i < this._keys.length; i++) {
+                if (SameValueZero(this._keys[i], key)) {
+                  this._cacheIndex = i;
+                  break;
+                }
+              }
+            }
+            if (this._cacheIndex < 0 && insert) {
+              this._cacheIndex = this._keys.length;
+              this._keys.push(key);
+              this._values.push(undefined);
+            }
+            return this._cacheIndex;
+          };
+          return Map3;
+        }();
+        return Map2;
+        function getKey(key, _) {
+          return key;
+        }
+        function getValue(_, value) {
+          return value;
+        }
+        function getEntry(key, value) {
+          return [key, value];
+        }
+      }
+      function CreateSetPolyfill() {
+        var Set5 = function() {
+          function Set6() {
+            this._map = new _Map;
+          }
+          Object.defineProperty(Set6.prototype, "size", {
+            get: function() {
+              return this._map.size;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Set6.prototype.has = function(value) {
+            return this._map.has(value);
+          };
+          Set6.prototype.add = function(value) {
+            return this._map.set(value, value), this;
+          };
+          Set6.prototype.delete = function(value) {
+            return this._map.delete(value);
+          };
+          Set6.prototype.clear = function() {
+            this._map.clear();
+          };
+          Set6.prototype.keys = function() {
+            return this._map.keys();
+          };
+          Set6.prototype.values = function() {
+            return this._map.keys();
+          };
+          Set6.prototype.entries = function() {
+            return this._map.entries();
+          };
+          Set6.prototype["@@iterator"] = function() {
+            return this.keys();
+          };
+          Set6.prototype[iteratorSymbol] = function() {
+            return this.keys();
+          };
+          return Set6;
+        }();
+        return Set5;
+      }
+      function CreateWeakMapPolyfill() {
+        var UUID_SIZE = 16;
+        var keys = HashMap.create();
+        var rootKey = CreateUniqueKey();
+        return function() {
+          function WeakMap2() {
+            this._key = CreateUniqueKey();
+          }
+          WeakMap2.prototype.has = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.has(table, this._key) : false;
+          };
+          WeakMap2.prototype.get = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.get(table, this._key) : undefined;
+          };
+          WeakMap2.prototype.set = function(target, value) {
+            var table = GetOrCreateWeakMapTable(target, true);
+            table[this._key] = value;
+            return this;
+          };
+          WeakMap2.prototype.delete = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? delete table[this._key] : false;
+          };
+          WeakMap2.prototype.clear = function() {
+            this._key = CreateUniqueKey();
+          };
+          return WeakMap2;
+        }();
+        function CreateUniqueKey() {
+          var key;
+          do
+            key = "@@WeakMap@@" + CreateUUID();
+          while (HashMap.has(keys, key));
+          keys[key] = true;
+          return key;
+        }
+        function GetOrCreateWeakMapTable(target, create2) {
+          if (!hasOwn.call(target, rootKey)) {
+            if (!create2)
+              return;
+            Object.defineProperty(target, rootKey, { value: HashMap.create() });
+          }
+          return target[rootKey];
+        }
+        function FillRandomBytes(buffer, size) {
+          for (var i = 0;i < size; ++i)
+            buffer[i] = Math.random() * 255 | 0;
+          return buffer;
+        }
+        function GenRandomBytes(size) {
+          if (typeof Uint8Array === "function") {
+            var array = new Uint8Array(size);
+            if (typeof crypto !== "undefined") {
+              crypto.getRandomValues(array);
+            } else if (typeof msCrypto !== "undefined") {
+              msCrypto.getRandomValues(array);
+            } else {
+              FillRandomBytes(array, size);
+            }
+            return array;
+          }
+          return FillRandomBytes(new Array(size), size);
+        }
+        function CreateUUID() {
+          var data = GenRandomBytes(UUID_SIZE);
+          data[6] = data[6] & 79 | 64;
+          data[8] = data[8] & 191 | 128;
+          var result = "";
+          for (var offset = 0;offset < UUID_SIZE; ++offset) {
+            var byte = data[offset];
+            if (offset === 4 || offset === 6 || offset === 8)
+              result += "-";
+            if (byte < 16)
+              result += "0";
+            result += byte.toString(16).toLowerCase();
+          }
+          return result;
+        }
+      }
+      function MakeDictionary(obj) {
+        obj.__ = undefined;
+        delete obj.__;
+        return obj;
+      }
+    });
+  })(Reflect2 || (Reflect2 = {}));
+});
+
 // node_modules/citra/dist/index.js
 var BASE64_BLOCK_SIZE = 4;
 var NUM_GENERATOR_BYTES = 32;
@@ -9637,11 +10633,11 @@ var roleRoutes = ({
     if (!await mayManage(user, organizationId)) {
       return status("Forbidden", "Cannot manage roles");
     }
-    const [scoped, global] = await Promise.all([
+    const [scoped, global2] = await Promise.all([
       roleStore.listRoles(organizationId),
       roleStore.listRoles()
     ]);
-    return status("OK", { roles: [...scoped, ...global] });
+    return status("OK", { roles: [...scoped, ...global2] });
   }, { cookie, params: t19.Object({ organizationId: t19.String() }) }).put(`${rolesRoute}/:organizationId/members/:userId`, async ({
     body: { roles },
     cookie: { user_session_id },
@@ -23150,12 +24146,12 @@ var QueryBuilder2 = class {
     return { as: as2 };
   };
   with(...queries) {
-    const self = this;
+    const self2 = this;
     function select(fields) {
       return new PgSelectBuilder2({
         fields: fields ?? undefined,
         session: undefined,
-        dialect: self.getDialect(),
+        dialect: self2.getDialect(),
         withList: queries
       });
     }
@@ -23163,7 +24159,7 @@ var QueryBuilder2 = class {
       return new PgSelectBuilder2({
         fields: fields ?? undefined,
         session: undefined,
-        dialect: self.getDialect(),
+        dialect: self2.getDialect(),
         distinct: true
       });
     }
@@ -23171,7 +24167,7 @@ var QueryBuilder2 = class {
       return new PgSelectBuilder2({
         fields: fields ?? undefined,
         session: undefined,
-        dialect: self.getDialect(),
+        dialect: self2.getDialect(),
         distinct: { on }
       });
     }
@@ -23692,44 +24688,44 @@ var PgAsyncDatabase2 = class {
   }
   $cache;
   with(...queries) {
-    const self = this;
+    const self2 = this;
     function select(fields) {
       return new PgSelectBuilder2({
         fields: fields ?? undefined,
-        session: self.session,
-        dialect: self.dialect,
+        session: self2.session,
+        dialect: self2.dialect,
         withList: queries,
-        tagged: self.tagged
+        tagged: self2.tagged
       }, PgAsyncSelectBase2);
     }
     function selectDistinct(fields) {
       return new PgSelectBuilder2({
         fields: fields ?? undefined,
-        session: self.session,
-        dialect: self.dialect,
+        session: self2.session,
+        dialect: self2.dialect,
         withList: queries,
         distinct: true,
-        tagged: self.tagged
+        tagged: self2.tagged
       }, PgAsyncSelectBase2);
     }
     function selectDistinctOn(on, fields) {
       return new PgSelectBuilder2({
         fields: fields ?? undefined,
-        session: self.session,
-        dialect: self.dialect,
+        session: self2.session,
+        dialect: self2.dialect,
         withList: queries,
         distinct: { on },
-        tagged: self.tagged
+        tagged: self2.tagged
       }, PgAsyncSelectBase2);
     }
     function update(table) {
-      return new PgUpdateBuilder2(table, self.session, self.dialect, queries, PgAsyncUpdateBase2);
+      return new PgUpdateBuilder2(table, self2.session, self2.dialect, queries, PgAsyncUpdateBase2);
     }
     function insert(table) {
-      return new PgInsertBuilder2(table, self.session, self.dialect, queries, undefined, PgAsyncInsertBase2);
+      return new PgInsertBuilder2(table, self2.session, self2.dialect, queries, undefined, PgAsyncInsertBase2);
     }
     function delete_(table) {
-      return new PgAsyncDeleteBase2(table, self.session, self.dialect, queries);
+      return new PgAsyncDeleteBase2(table, self2.session, self2.dialect, queries);
     }
     return {
       select,
@@ -28474,8 +29470,8 @@ function FromConstructor6(schema, references) {
       return class {
         constructor() {
           for (const [key, val] of Object.entries(value)) {
-            const self = this;
-            self[key] = val;
+            const self2 = this;
+            self2[key] = val;
           }
         }
       };
@@ -36868,6 +37864,160 @@ var auth = async (configuration) => {
   return application.use(authContext);
 };
 var createAuthApplications = async (configuration) => buildAuthApplications(configuration);
+// src/sso/nodeSamlAdapter.ts
+var import_reflect_metadata = __toESM(require_Reflect(), 1);
+var STANDARD_PROFILE_KEYS = new Set([
+  "ID",
+  "getAssertion",
+  "getAssertionXml",
+  "getSamlResponseXml",
+  "issuer",
+  "mainAttributes",
+  "nameID",
+  "nameIDFormat",
+  "sessionIndex",
+  "spNameQualifier"
+]);
+var DEFAULT_NAMEID_FORMAT = "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress";
+var siblingEndpoints = (urls) => {
+  const acsUrl = urls.acsUrl ?? urls.sloUrl?.replace(/\/slo(\?|$)/, "/acs$1");
+  const sloUrl = urls.sloUrl ?? urls.acsUrl?.replace(/\/acs(\?|$)/, "/slo$1");
+  return { acsUrl, sloUrl };
+};
+var createNodeSamlAdapter = async (options = {}) => {
+  const { SAML } = await import("@node-saml/node-saml");
+  const {
+    signatureAlgorithm = "sha256",
+    spCertificate,
+    spPrivateKey
+  } = options;
+  const canSign = spPrivateKey !== undefined;
+  const build = (connection, urls) => {
+    const { acsUrl, sloUrl } = siblingEndpoints(urls);
+    const baseUrl = acsUrl ?? sloUrl;
+    if (baseUrl === undefined) {
+      throw new Error("node-saml adapter requires an acsUrl or sloUrl to build a SAML client");
+    }
+    const spEntityId = new URL(baseUrl).origin;
+    return new SAML({
+      audience: spEntityId,
+      callbackUrl: acsUrl ?? baseUrl,
+      entryPoint: connection.config.idpSsoUrl,
+      idpCert: connection.config.idpX509Cert,
+      issuer: spEntityId,
+      logoutUrl: connection.config.idpSloUrl,
+      wantAssertionsSigned: true,
+      ...canSign ? {
+        logoutCallbackUrl: sloUrl ?? baseUrl,
+        privateKey: spPrivateKey,
+        signatureAlgorithm
+      } : {}
+    });
+  };
+  const adapter2 = {
+    createAuthorizationUrl: ({ acsUrl, connection, relayState }) => build(connection, { acsUrl }).getAuthorizeUrlAsync(relayState ?? "", undefined, {}),
+    getServiceProviderMetadata: ({ acsUrl, connection, sloUrl }) => build(connection, {
+      acsUrl,
+      sloUrl
+    }).generateServiceProviderMetadata(null, spCertificate ?? null),
+    validateAssertion: async ({ acsUrl, connection, samlResponse }) => {
+      const { profile: profile2 } = await build(connection, {
+        acsUrl
+      }).validatePostResponseAsync({ SAMLResponse: samlResponse });
+      if (!profile2) {
+        throw new Error("SAML response contained no assertion profile");
+      }
+      const attributes = {};
+      for (const [key, value] of Object.entries(profile2)) {
+        if (!STANDARD_PROFILE_KEYS.has(key))
+          attributes[key] = value;
+      }
+      const email = profile2.email ?? (profile2.nameID.includes("@") ? profile2.nameID : undefined);
+      const result = {
+        attributes,
+        email,
+        nameId: profile2.nameID,
+        sessionIndex: profile2.sessionIndex
+      };
+      return result;
+    }
+  };
+  if (!canSign)
+    return adapter2;
+  return {
+    ...adapter2,
+    createLogoutRequestUrl: ({
+      connection,
+      nameId,
+      relayState,
+      sessionIndex,
+      sloUrl
+    }) => {
+      const saml = build(connection, { sloUrl });
+      return saml.getLogoutUrlAsync({
+        issuer: new URL(sloUrl).origin,
+        nameID: nameId,
+        nameIDFormat: DEFAULT_NAMEID_FORMAT,
+        sessionIndex
+      }, relayState ?? "", {});
+    },
+    createLogoutResponseUrl: ({
+      connection,
+      inResponseTo,
+      nameId,
+      relayState,
+      sloUrl
+    }) => {
+      const saml = build(connection, { sloUrl });
+      return saml.getLogoutResponseUrlAsync({
+        ID: inResponseTo,
+        issuer: new URL(sloUrl).origin,
+        nameID: nameId ?? "",
+        nameIDFormat: DEFAULT_NAMEID_FORMAT
+      }, relayState ?? "", {}, true);
+    },
+    validateLogoutRequest: async ({
+      connection,
+      relayState,
+      samlRequest,
+      signature,
+      signatureAlgorithm: sigAlg,
+      signedQueryString,
+      sloUrl
+    }) => {
+      const saml = build(connection, { sloUrl });
+      const { profile: profile2 } = await saml.validateRedirectAsync({
+        RelayState: relayState,
+        SAMLRequest: samlRequest,
+        SigAlg: sigAlg,
+        Signature: signature
+      }, signedQueryString ?? "");
+      return {
+        nameId: profile2?.nameID,
+        relayState,
+        requestId: profile2?.ID,
+        sessionIndex: profile2?.sessionIndex
+      };
+    },
+    validateLogoutResponse: async ({
+      connection,
+      relayState,
+      samlResponse,
+      signature,
+      signatureAlgorithm: sigAlg,
+      signedQueryString,
+      sloUrl
+    }) => {
+      const saml = build(connection, { sloUrl });
+      await saml.validateRedirectAsync({
+        RelayState: relayState,
+        SAMLResponse: samlResponse,
+        SigAlg: sigAlg,
+        Signature: signature
+      }, signedQueryString ?? "");
+    }
+  };
+};
 
 // src/server.ts
 var auth2 = auth;
@@ -36879,9 +38029,14 @@ export {
   isUserSessionId,
   instantiateUserSession,
   extractPropFromIdentity,
+  createSetupSession,
+  createPostgresSsoConnectionStore,
+  createPostgresSetupSessionStore,
+  createPostgresScimTokenStore,
+  createNodeSamlAdapter,
   createAuthContext,
   auth2 as auth
 };
 
-//# debugId=34FC98C7B8C7C52E64756E2164756E21
+//# debugId=AE9FEC97123E4CE764756E2164756E21
 //# sourceMappingURL=server.js.map