@spica-devkit/identity 0.13.0 → 0.13.2

package/dist/index.mjs

@@ -1,906 +0,0 @@
-import axios from 'axios';
-
-function logWarning(response) {
-    const warning = response.headers["warning"];
-    if (warning) {
-        console.warn(warning);
-    }
-}
-class Axios {
-    constructor(config) {
-        this.interceptors = {
-            request: {
-                onFulfilled: (request) => {
-                    request.maxBodyLength = Number.MAX_SAFE_INTEGER;
-                    request.maxContentLength = Number.MAX_SAFE_INTEGER;
-                    if (!request.headers["Authorization"]) {
-                        throw new Error("You should call initialize method with a valid apikey or identity token.");
-                    }
-                    return request;
-                },
-                onRejected: (error) => {
-                    return Promise.reject(error);
-                }
-            },
-            response: {
-                onFulfilled: (response) => {
-                    logWarning(response);
-                    return response.data;
-                },
-                onRejected: (error) => {
-                    return Promise.reject(error.response ? error.response.data : error);
-                }
-            }
-        };
-        this.instance = axios.create(config);
-        this.instance.interceptors.request.use(this.interceptors.request.onFulfilled, this.interceptors.request.onRejected);
-        this.instance.interceptors.response.use(this.interceptors.response.onFulfilled, this.interceptors.response.onRejected);
-        this.baseUrl = this.instance.defaults.baseURL;
-        this.instance.defaults.paramsSerializer = paramsSerializer;
-    }
-    setBaseUrl(url) {
-        this.instance.defaults.baseURL = url;
-    }
-    setWriteDefaults(writeDefaults) {
-        for (const [header, value] of Object.entries(writeDefaults.headers)) {
-            this.instance.defaults.headers.post[header] = value;
-            this.instance.defaults.headers.put[header] = value;
-        }
-    }
-    setAuthorization(authorization) {
-        this.instance.defaults.headers["Authorization"] = authorization;
-    }
-    get(url, config) {
-        return this.instance.get(url, config);
-    }
-    post(url, body, config) {
-        return this.instance.post(url, body, config);
-    }
-    put(url, body, config) {
-        return this.instance.put(url, body, config);
-    }
-    patch(url, body, config) {
-        return this.instance.patch(url, body, config);
-    }
-    delete(url, config) {
-        return this.instance.delete(url, config);
-    }
-    request(config) {
-        return this.instance.request(config);
-    }
-}
-function encode(val) {
-    return encodeURIComponent(val)
-        .replace(/%3A/gi, ":")
-        .replace(/%24/g, "$")
-        .replace(/%2C/gi, ",")
-        .replace(/%20/g, "+")
-        .replace(/%5B/gi, "[")
-        .replace(/%5D/gi, "]");
-}
-function utilsIsURLSearchParams(val) {
-    return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
-}
-function utilsIsArray(val) {
-    return toString.call(val) === "[object Array]";
-}
-function utilsIsDate(val) {
-    return toString.call(val) === "[object Date]";
-}
-function utilsIsObject(val) {
-    return val !== null && typeof val === "object";
-}
-function utilsForEach(obj, fn) {
-    if (obj === null || typeof obj === "undefined") {
-        return;
-    }
-    if (typeof obj !== "object") {
-        obj = [obj];
-    }
-    if (utilsIsArray(obj)) {
-        for (var i = 0, l = obj.length; i < l; i++) {
-            fn.call(null, obj[i], i, obj);
-        }
-    }
-    else {
-        for (var key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                fn.call(null, obj[key], key, obj);
-            }
-        }
-    }
-}
-function paramsSerializer(params) {
-    if (utilsIsURLSearchParams(params)) {
-        return params.toString();
-    }
-    var parts = [];
-    utilsForEach(params, function serialize(val, key) {
-        if (val === null || typeof val === "undefined") {
-            return;
-        }
-        if (utilsIsArray(val)) {
-            key = key + "[]";
-        }
-        else {
-            val = [val];
-        }
-        utilsForEach(val, function parseValue(v) {
-            if (utilsIsDate(v)) {
-                v = v.toISOString();
-            }
-            else if (utilsIsObject(v)) {
-                v = JSON.stringify(v);
-            }
-            parts.push(encode(key) + "=" + encode(v));
-        });
-    });
-    return parts.join("&");
-}
-
-let service$1;
-function initialize$1(options) {
-    let authorization;
-    if ("apikey" in options) {
-        authorization = `APIKEY ${options.apikey}`;
-    }
-    else if ("identity" in options) {
-        authorization = `IDENTITY ${options.identity}`;
-    }
-    checkInitialized(authorization);
-    const publicUrl = options.publicUrl || getPublicUrl();
-    if (!publicUrl) {
-        throw new Error("Public url must be provided.");
-    }
-    if (!service$1) {
-        service$1 = new Axios({ baseURL: publicUrl, headers: { Authorization: authorization } });
-    }
-    else {
-        service$1.setBaseUrl(publicUrl);
-        service$1.setAuthorization(authorization);
-    }
-    return { authorization, publicUrl, service: service$1 };
-}
-function checkInitialized(authorization) {
-    if (!authorization) {
-        throw new Error("You should call initialize method with a valid apikey or identity token.");
-    }
-}
-function getPublicUrl() {
-    return isPlatformBrowser() ? undefined : process.env.__INTERNAL__SPICA__PUBLIC_URL__;
-}
-function isPlatformBrowser() {
-    return typeof window !== "undefined";
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = undefined;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
-function createErrorClass(createImpl) {
-    var _super = function (instance) {
-        Error.call(instance);
-        instance.stack = new Error().stack;
-    };
-    var ctorFunc = createImpl(_super);
-    ctorFunc.prototype = Object.create(Error.prototype);
-    ctorFunc.prototype.constructor = ctorFunc;
-    return ctorFunc;
-}
-
-var UnsubscriptionError = createErrorClass(function (_super) {
-    return function UnsubscriptionErrorImpl(errors) {
-        _super(this);
-        this.message = errors
-            ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
-            : '';
-        this.name = 'UnsubscriptionError';
-        this.errors = errors;
-    };
-});
-
-function arrRemove(arr, item) {
-    if (arr) {
-        var index = arr.indexOf(item);
-        0 <= index && arr.splice(index, 1);
-    }
-}
-
-var Subscription = (function () {
-    function Subscription(initialTeardown) {
-        this.initialTeardown = initialTeardown;
-        this.closed = false;
-        this._parentage = null;
-        this._finalizers = null;
-    }
-    Subscription.prototype.unsubscribe = function () {
-        var e_1, _a, e_2, _b;
-        var errors;
-        if (!this.closed) {
-            this.closed = true;
-            var _parentage = this._parentage;
-            if (_parentage) {
-                this._parentage = null;
-                if (Array.isArray(_parentage)) {
-                    try {
-                        for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
-                            var parent_1 = _parentage_1_1.value;
-                            parent_1.remove(this);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                }
-                else {
-                    _parentage.remove(this);
-                }
-            }
-            var initialFinalizer = this.initialTeardown;
-            if (isFunction(initialFinalizer)) {
-                try {
-                    initialFinalizer();
-                }
-                catch (e) {
-                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
-                }
-            }
-            var _finalizers = this._finalizers;
-            if (_finalizers) {
-                this._finalizers = null;
-                try {
-                    for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
-                        var finalizer = _finalizers_1_1.value;
-                        try {
-                            execFinalizer(finalizer);
-                        }
-                        catch (err) {
-                            errors = errors !== null && errors !== void 0 ? errors : [];
-                            if (err instanceof UnsubscriptionError) {
-                                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
-                            }
-                            else {
-                                errors.push(err);
-                            }
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-            }
-            if (errors) {
-                throw new UnsubscriptionError(errors);
-            }
-        }
-    };
-    Subscription.prototype.add = function (teardown) {
-        var _a;
-        if (teardown && teardown !== this) {
-            if (this.closed) {
-                execFinalizer(teardown);
-            }
-            else {
-                if (teardown instanceof Subscription) {
-                    if (teardown.closed || teardown._hasParent(this)) {
-                        return;
-                    }
-                    teardown._addParent(this);
-                }
-                (this._finalizers = (_a = this._finalizers) !== null && _a !== undefined ? _a : []).push(teardown);
-            }
-        }
-    };
-    Subscription.prototype._hasParent = function (parent) {
-        var _parentage = this._parentage;
-        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
-    };
-    Subscription.prototype._addParent = function (parent) {
-        var _parentage = this._parentage;
-        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
-    };
-    Subscription.prototype._removeParent = function (parent) {
-        var _parentage = this._parentage;
-        if (_parentage === parent) {
-            this._parentage = null;
-        }
-        else if (Array.isArray(_parentage)) {
-            arrRemove(_parentage, parent);
-        }
-    };
-    Subscription.prototype.remove = function (teardown) {
-        var _finalizers = this._finalizers;
-        _finalizers && arrRemove(_finalizers, teardown);
-        if (teardown instanceof Subscription) {
-            teardown._removeParent(this);
-        }
-    };
-    Subscription.EMPTY = (function () {
-        var empty = new Subscription();
-        empty.closed = true;
-        return empty;
-    })();
-    return Subscription;
-}());
-Subscription.EMPTY;
-function isSubscription(value) {
-    return (value instanceof Subscription ||
-        (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
-}
-function execFinalizer(finalizer) {
-    if (isFunction(finalizer)) {
-        finalizer();
-    }
-    else {
-        finalizer.unsubscribe();
-    }
-}
-
-var config = {
-    onUnhandledError: null,
-    onStoppedNotification: null,
-    Promise: undefined,
-    useDeprecatedSynchronousErrorHandling: false,
-    useDeprecatedNextContext: false,
-};
-
-var timeoutProvider = {
-    setTimeout: function (handler, timeout) {
-        var args = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-        }
-        return setTimeout.apply(undefined, __spreadArray([handler, timeout], __read(args)));
-    },
-    clearTimeout: function (handle) {
-        return (clearTimeout)(handle);
-    },
-    delegate: undefined,
-};
-
-function reportUnhandledError(err) {
-    timeoutProvider.setTimeout(function () {
-        {
-            throw err;
-        }
-    });
-}
-
-function noop() { }
-
-function errorContext(cb) {
-    {
-        cb();
-    }
-}
-
-var Subscriber = (function (_super) {
-    __extends(Subscriber, _super);
-    function Subscriber(destination) {
-        var _this = _super.call(this) || this;
-        _this.isStopped = false;
-        if (destination) {
-            _this.destination = destination;
-            if (isSubscription(destination)) {
-                destination.add(_this);
-            }
-        }
-        else {
-            _this.destination = EMPTY_OBSERVER;
-        }
-        return _this;
-    }
-    Subscriber.create = function (next, error, complete) {
-        return new SafeSubscriber(next, error, complete);
-    };
-    Subscriber.prototype.next = function (value) {
-        if (this.isStopped) ;
-        else {
-            this._next(value);
-        }
-    };
-    Subscriber.prototype.error = function (err) {
-        if (this.isStopped) ;
-        else {
-            this.isStopped = true;
-            this._error(err);
-        }
-    };
-    Subscriber.prototype.complete = function () {
-        if (this.isStopped) ;
-        else {
-            this.isStopped = true;
-            this._complete();
-        }
-    };
-    Subscriber.prototype.unsubscribe = function () {
-        if (!this.closed) {
-            this.isStopped = true;
-            _super.prototype.unsubscribe.call(this);
-            this.destination = null;
-        }
-    };
-    Subscriber.prototype._next = function (value) {
-        this.destination.next(value);
-    };
-    Subscriber.prototype._error = function (err) {
-        try {
-            this.destination.error(err);
-        }
-        finally {
-            this.unsubscribe();
-        }
-    };
-    Subscriber.prototype._complete = function () {
-        try {
-            this.destination.complete();
-        }
-        finally {
-            this.unsubscribe();
-        }
-    };
-    return Subscriber;
-}(Subscription));
-var ConsumerObserver = (function () {
-    function ConsumerObserver(partialObserver) {
-        this.partialObserver = partialObserver;
-    }
-    ConsumerObserver.prototype.next = function (value) {
-        var partialObserver = this.partialObserver;
-        if (partialObserver.next) {
-            try {
-                partialObserver.next(value);
-            }
-            catch (error) {
-                handleUnhandledError(error);
-            }
-        }
-    };
-    ConsumerObserver.prototype.error = function (err) {
-        var partialObserver = this.partialObserver;
-        if (partialObserver.error) {
-            try {
-                partialObserver.error(err);
-            }
-            catch (error) {
-                handleUnhandledError(error);
-            }
-        }
-        else {
-            handleUnhandledError(err);
-        }
-    };
-    ConsumerObserver.prototype.complete = function () {
-        var partialObserver = this.partialObserver;
-        if (partialObserver.complete) {
-            try {
-                partialObserver.complete();
-            }
-            catch (error) {
-                handleUnhandledError(error);
-            }
-        }
-    };
-    return ConsumerObserver;
-}());
-var SafeSubscriber = (function (_super) {
-    __extends(SafeSubscriber, _super);
-    function SafeSubscriber(observerOrNext, error, complete) {
-        var _this = _super.call(this) || this;
-        var partialObserver;
-        if (isFunction(observerOrNext) || !observerOrNext) {
-            partialObserver = {
-                next: (observerOrNext !== null && observerOrNext !== undefined ? observerOrNext : undefined),
-                error: error !== null && error !== undefined ? error : undefined,
-                complete: complete !== null && complete !== undefined ? complete : undefined,
-            };
-        }
-        else {
-            {
-                partialObserver = observerOrNext;
-            }
-        }
-        _this.destination = new ConsumerObserver(partialObserver);
-        return _this;
-    }
-    return SafeSubscriber;
-}(Subscriber));
-function handleUnhandledError(error) {
-    {
-        reportUnhandledError(error);
-    }
-}
-function defaultErrorHandler(err) {
-    throw err;
-}
-var EMPTY_OBSERVER = {
-    closed: true,
-    next: noop,
-    error: defaultErrorHandler,
-    complete: noop,
-};
-
-var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
-
-function identity(x) {
-    return x;
-}
-
-function pipeFromArray(fns) {
-    if (fns.length === 0) {
-        return identity;
-    }
-    if (fns.length === 1) {
-        return fns[0];
-    }
-    return function piped(input) {
-        return fns.reduce(function (prev, fn) { return fn(prev); }, input);
-    };
-}
-
-var Observable = (function () {
-    function Observable(subscribe) {
-        if (subscribe) {
-            this._subscribe = subscribe;
-        }
-    }
-    Observable.prototype.lift = function (operator) {
-        var observable = new Observable();
-        observable.source = this;
-        observable.operator = operator;
-        return observable;
-    };
-    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
-        var _this = this;
-        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
-        errorContext(function () {
-            var _a = _this, operator = _a.operator, source = _a.source;
-            subscriber.add(operator
-                ?
-                    operator.call(subscriber, source)
-                : source
-                    ?
-                        _this._subscribe(subscriber)
-                    :
-                        _this._trySubscribe(subscriber));
-        });
-        return subscriber;
-    };
-    Observable.prototype._trySubscribe = function (sink) {
-        try {
-            return this._subscribe(sink);
-        }
-        catch (err) {
-            sink.error(err);
-        }
-    };
-    Observable.prototype.forEach = function (next, promiseCtor) {
-        var _this = this;
-        promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function (resolve, reject) {
-            var subscriber = new SafeSubscriber({
-                next: function (value) {
-                    try {
-                        next(value);
-                    }
-                    catch (err) {
-                        reject(err);
-                        subscriber.unsubscribe();
-                    }
-                },
-                error: reject,
-                complete: resolve,
-            });
-            _this.subscribe(subscriber);
-        });
-    };
-    Observable.prototype._subscribe = function (subscriber) {
-        var _a;
-        return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
-    };
-    Observable.prototype[observable] = function () {
-        return this;
-    };
-    Observable.prototype.pipe = function () {
-        var operations = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            operations[_i] = arguments[_i];
-        }
-        return pipeFromArray(operations)(this);
-    };
-    Observable.prototype.toPromise = function (promiseCtor) {
-        var _this = this;
-        promiseCtor = getPromiseCtor(promiseCtor);
-        return new promiseCtor(function (resolve, reject) {
-            var value;
-            _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
-        });
-    };
-    Observable.create = function (subscribe) {
-        return new Observable(subscribe);
-    };
-    return Observable;
-}());
-function getPromiseCtor(promiseCtor) {
-    var _a;
-    return (_a = promiseCtor !== null && promiseCtor !== undefined ? promiseCtor : config.Promise) !== null && _a !== undefined ? _a : Promise;
-}
-function isObserver(value) {
-    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
-}
-function isSubscriber(value) {
-    return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
-}
-
-function deepCopyJSON(param) {
-    return JSON.parse(JSON.stringify(param));
-}
-
-let authorization;
-let service;
-const identitySegment = "passport/identity";
-class _Challenge {
-    constructor(res, answerResponseMapper = r => r) {
-        this.res = res;
-        this.answerResponseMapper = answerResponseMapper;
-    }
-    show() {
-        return this.res.challenge;
-    }
-    answer(answer) {
-        return service.post(this.res.answerUrl, { answer }).then(r => this.answerResponseMapper(r));
-    }
-}
-function initialize(options) {
-    const { authorization: _authorization, service: _service } = initialize$1(options);
-    authorization = _authorization;
-    service = _service;
-    service.setWriteDefaults({
-        headers: {
-            "Content-Type": "application/json"
-        }
-    });
-}
-function verifyToken(token, baseUrl) {
-    const _baseUrl = baseUrl ? baseUrl : service ? service.baseUrl : undefined;
-    if (!_baseUrl) {
-        throw new Error("You should pass the base url of the server or call the initialize method.");
-    }
-    const req = new Axios({ baseURL: _baseUrl });
-    return req.get(`${identitySegment}/verify`, { headers: { Authorization: token } });
-}
-async function login(identifier, password, tokenLifeSpan) {
-    checkInitialized(authorization);
-    return service
-        .post("/passport/identify", {
-        identifier,
-        password,
-        expires: tokenLifeSpan
-    })
-        .then(r => {
-        if (isTokenScheme(r)) {
-            return r.token;
-        }
-        const challenge = new _Challenge(r, r => r.token);
-        return challenge;
-    });
-}
-function isTokenScheme(response) {
-    return typeof response.token == "string";
-}
-function isChallenge(tokenOrChallenge) {
-    return typeof tokenOrChallenge.show == "function" && typeof tokenOrChallenge.answer == "function";
-}
-async function loginWithStrategy(id) {
-    checkInitialized(authorization);
-    const { url, state } = await service.get(`/passport/strategy/${id}/url`);
-    const token = new Observable(observer => {
-        service
-            .post("/passport/identify", {
-            state
-        })
-            .then(r => {
-            if (isTokenScheme(r)) {
-                observer.next(r.token);
-            }
-            else {
-                const challenge = new _Challenge(r, r => r.token);
-                observer.next(challenge);
-            }
-            observer.complete();
-        })
-            .catch(e => observer.error(e));
-    });
-    return {
-        url,
-        token
-    };
-}
-var authfactor;
-(function (authfactor) {
-    function list() {
-        return service.get("passport/identity/factors");
-    }
-    authfactor.list = list;
-    async function register(identityId, factor) {
-        const response = await service.post(`passport/identity/${identityId}/start-factor-verification`, factor);
-        const challenge = new _Challenge(response, response => response.message);
-        return challenge;
-    }
-    authfactor.register = register;
-    function unregister(identityId) {
-        return service.delete(`passport/identity/${identityId}/factors`);
-    }
-    authfactor.unregister = unregister;
-})(authfactor || (authfactor = {}));
-function getStrategies() {
-    return service.get("/passport/strategies");
-}
-function get(id) {
-    checkInitialized(authorization);
-    return service.get(`${identitySegment}/${id}`);
-}
-function getAll(queryParams = {}) {
-    checkInitialized(authorization);
-    return service.get(identitySegment, {
-        params: queryParams
-    });
-}
-async function insert(identity) {
-    checkInitialized(authorization);
-    identity = deepCopyJSON(identity);
-    const desiredPolicies = identity.policies;
-    delete identity.policies;
-    const insertedIdentity = await service.post(identitySegment, identity);
-    return policy.attach(insertedIdentity._id, desiredPolicies).then(policies => {
-        insertedIdentity.policies = policies;
-        return insertedIdentity;
-    });
-}
-async function update(id, identity) {
-    checkInitialized(authorization);
-    const existingIdentity = await service.get(`${identitySegment}/${id}`);
-    identity = deepCopyJSON(identity);
-    const desiredPolicies = identity.policies;
-    delete identity.policies;
-    const { onlyInFirst: policiesForDetach, onlyInSecond: policiesForAttach } = getArrayDifferences(existingIdentity.policies, desiredPolicies);
-    const updatedIdentity = await service.put(`${identitySegment}/${id}`, identity);
-    updatedIdentity.policies = desiredPolicies;
-    await policy.attach(id, policiesForAttach);
-    await policy.detach(id, policiesForDetach);
-    return updatedIdentity;
-}
-function remove(id) {
-    checkInitialized(authorization);
-    return service.delete(`${identitySegment}/${id}`);
-}
-var policy;
-(function (policy) {
-    function attach(identityId, policyIds = []) {
-        checkInitialized(authorization);
-        const promises = [];
-        const attachedPolicies = new Set();
-        for (const policyId of policyIds) {
-            const promise = service
-                .put(`${identitySegment}/${identityId}/policy/${policyId}`, {})
-                .then(() => attachedPolicies.add(policyId))
-                .catch(e => {
-                console.error(`Failed to attach policy with id ${policyId}: `, e);
-                return e;
-            });
-            promises.push(promise);
-        }
-        return Promise.all(promises).then(() => Array.from(attachedPolicies));
-    }
-    policy.attach = attach;
-    function detach(identityId, policyIds = []) {
-        checkInitialized(authorization);
-        const promises = [];
-        const detachedPolicies = new Set();
-        for (const policyId of policyIds) {
-            const promise = service
-                .delete(`${identitySegment}/${identityId}/policy/${policyId}`)
-                .then(() => detachedPolicies.add(policyId))
-                .catch(e => {
-                console.error(`Failed to detach policy with id ${policyId}: `, e);
-                return e;
-            });
-            promises.push(promise);
-        }
-        return Promise.all(promises).then(() => Array.from(detachedPolicies));
-    }
-    policy.detach = detach;
-})(policy || (policy = {}));
-function getArrayDifferences(arr1, arr2) {
-    const set1 = new Set(arr1);
-    const set2 = new Set(arr2);
-    const onlyInFirst = arr1.filter(item => !set2.has(item));
-    const onlyInSecond = arr2.filter(item => !set1.has(item));
-    return { onlyInFirst, onlyInSecond };
-}
-
-export { authfactor, get, getAll, getStrategies, initialize, insert, isChallenge, login, loginWithStrategy, policy, remove, update, verifyToken };
-//# sourceMappingURL=index.mjs.map