@spica-devkit/identity 0.9.29 → 0.11.0

package/dist/index.mjs

@@ -1,24 +1,4 @@
-import axios_1 from 'axios';
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function createCommonjsModule(fn, basedir, module) {
-	return module = {
-		path: basedir,
-		exports: {},
-		require: function (path, base) {
-			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
-		}
-	}, fn(module, module.exports), module.exports;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
-}
-
-var request = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Axios = exports.logWarning = void 0;
+import axios from 'axios';
 
 function logWarning(response) {
     const warning = response.headers["warning"];
@@ -26,7 +6,6 @@ function logWarning(response) {
         console.warn(warning);
     }
 }
-exports.logWarning = logWarning;
 class Axios {
     constructor(config) {
         this.interceptors = {
@@ -53,10 +32,11 @@ class Axios {
                 }
             }
         };
-        this.instance = axios_1.default.create(config);
+        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;
@@ -89,16 +69,77 @@ class Axios {
         return this.instance.request(config);
     }
 }
-exports.Axios = Axios;
-
-});
-
-var initialize_1 = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPlatformBrowser = exports.checkInitialized = exports.initialize = void 0;
+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;
-function initialize(options) {
+let service$1;
+function initialize$1(options) {
     let authorization;
     if ("apikey" in options) {
         authorization = `APIKEY ${options.apikey}`;
@@ -111,90 +152,28 @@ function initialize(options) {
     if (!publicUrl) {
         throw new Error("Public url must be provided.");
     }
-    if (!service) {
-        service = new request.Axios({ baseURL: publicUrl, headers: { Authorization: authorization } });
+    if (!service$1) {
+        service$1 = new Axios({ baseURL: publicUrl, headers: { Authorization: authorization } });
     }
     else {
-        service.setBaseUrl(publicUrl);
-        service.setAuthorization(authorization);
+        service$1.setBaseUrl(publicUrl);
+        service$1.setAuthorization(authorization);
     }
-    return { authorization, publicUrl, service };
+    return { authorization, publicUrl, service: service$1 };
 }
-exports.initialize = initialize;
 function checkInitialized(authorization) {
     if (!authorization) {
         throw new Error("You should call initialize method with a valid apikey or identity token.");
     }
 }
-exports.checkInitialized = checkInitialized;
 function getPublicUrl() {
     return isPlatformBrowser() ? undefined : process.env.__INTERNAL__SPICA__PUBLIC_URL__;
 }
 function isPlatformBrowser() {
     return typeof window !== "undefined";
 }
-exports.isPlatformBrowser = isPlatformBrowser;
-
-});
-
-var _interface = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-
-});
-
-var url = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildUrl = void 0;
-function buildUrl(baseUrl, queryParams = {}) {
-    const url = new URL(baseUrl);
-    for (let [key, value] of Object.entries(queryParams)) {
-        if (typeof value != "string") {
-            value = JSON.stringify(value);
-        }
-        url.searchParams.set(key, value);
-    }
-    return url;
-}
-exports.buildUrl = buildUrl;
-
-});
-
-var src = createCommonjsModule(function (module, exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(initialize_1, exports);
-__exportStar(_interface, exports);
-__exportStar(request, exports);
-__exportStar(url, exports);
-
-});
-
-var internal_common = createCommonjsModule(function (module, exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(src, exports);
-
-});
 
-/*! *****************************************************************************
+/******************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -208,493 +187,428 @@ 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 */
+/* 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+        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 __());
-}
-
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-function isFunction(x) {
-    return typeof x === 'function';
-}
-
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-var _enable_super_gross_mode_that_will_cause_bad_things = false;
-var config = {
-    Promise: undefined,
-    set useDeprecatedSynchronousErrorHandling(value) {
-        if (value) {
-            var error = /*@__PURE__*/ new Error();
-            /*@__PURE__*/ console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \n' + error.stack);
-        }
-        _enable_super_gross_mode_that_will_cause_bad_things = value;
-    },
-    get useDeprecatedSynchronousErrorHandling() {
-        return _enable_super_gross_mode_that_will_cause_bad_things;
-    },
-};
-
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-function hostReportError(err) {
-    setTimeout(function () { throw err; }, 0);
-}
-
-/** PURE_IMPORTS_START _config,_util_hostReportError PURE_IMPORTS_END */
-var empty = {
-    closed: true,
-    next: function (value) { },
-    error: function (err) {
-        if (config.useDeprecatedSynchronousErrorHandling) {
-            throw err;
-        }
-        else {
-            hostReportError(err);
-        }
-    },
-    complete: function () { }
+}
+
+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;
 };
 
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-var isArray = /*@__PURE__*/ (function () { return Array.isArray || (function (x) { return x && typeof x.length === 'number'; }); })();
-
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-function isObject(x) {
-    return x !== null && typeof x === 'object';
+function isFunction(value) {
+    return typeof value === 'function';
 }
 
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-var UnsubscriptionErrorImpl = /*@__PURE__*/ (function () {
-    function UnsubscriptionErrorImpl(errors) {
-        Error.call(this);
-        this.message = errors ?
-            errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ') : '';
+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;
-        return this;
+    };
+});
+
+function arrRemove(arr, item) {
+    if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
     }
-    UnsubscriptionErrorImpl.prototype = /*@__PURE__*/ Object.create(Error.prototype);
-    return UnsubscriptionErrorImpl;
-})();
-var UnsubscriptionError = UnsubscriptionErrorImpl;
+}
 
-/** PURE_IMPORTS_START _util_isArray,_util_isObject,_util_isFunction,_util_UnsubscriptionError PURE_IMPORTS_END */
-var Subscription = /*@__PURE__*/ (function () {
-    function Subscription(unsubscribe) {
+var Subscription = (function () {
+    function Subscription(initialTeardown) {
+        this.initialTeardown = initialTeardown;
         this.closed = false;
-        this._parentOrParents = null;
-        this._subscriptions = null;
-        if (unsubscribe) {
-            this._ctorUnsubscribe = true;
-            this._unsubscribe = unsubscribe;
-        }
+        this._parentage = null;
+        this._finalizers = null;
     }
     Subscription.prototype.unsubscribe = function () {
+        var e_1, _a, e_2, _b;
         var errors;
-        if (this.closed) {
-            return;
-        }
-        var _a = this, _parentOrParents = _a._parentOrParents, _ctorUnsubscribe = _a._ctorUnsubscribe, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;
-        this.closed = true;
-        this._parentOrParents = null;
-        this._subscriptions = null;
-        if (_parentOrParents instanceof Subscription) {
-            _parentOrParents.remove(this);
-        }
-        else if (_parentOrParents !== null) {
-            for (var index = 0; index < _parentOrParents.length; ++index) {
-                var parent_1 = _parentOrParents[index];
-                parent_1.remove(this);
-            }
-        }
-        if (isFunction(_unsubscribe)) {
-            if (_ctorUnsubscribe) {
-                this._unsubscribe = undefined;
-            }
-            try {
-                _unsubscribe.call(this);
-            }
-            catch (e) {
-                errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];
-            }
-        }
-        if (isArray(_subscriptions)) {
-            var index = -1;
-            var len = _subscriptions.length;
-            while (++index < len) {
-                var sub = _subscriptions[index];
-                if (isObject(sub)) {
+        if (!this.closed) {
+            this.closed = true;
+            var _parentage = this._parentage;
+            if (_parentage) {
+                this._parentage = null;
+                if (Array.isArray(_parentage)) {
                     try {
-                        sub.unsubscribe();
-                    }
-                    catch (e) {
-                        errors = errors || [];
-                        if (e instanceof UnsubscriptionError) {
-                            errors = errors.concat(flattenUnsubscriptionErrors(e.errors));
+                        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);
                         }
-                        else {
-                            errors.push(e);
+                    }
+                    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);
+                }
             }
-        }
-        if (errors) {
-            throw new UnsubscriptionError(errors);
-        }
-    };
-    Subscription.prototype.add = function (teardown) {
-        var subscription = teardown;
-        if (!teardown) {
-            return Subscription.EMPTY;
-        }
-        switch (typeof teardown) {
-            case 'function':
-                subscription = new Subscription(teardown);
-            case 'object':
-                if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {
-                    return subscription;
+            var initialFinalizer = this.initialTeardown;
+            if (isFunction(initialFinalizer)) {
+                try {
+                    initialFinalizer();
                 }
-                else if (this.closed) {
-                    subscription.unsubscribe();
-                    return subscription;
+                catch (e) {
+                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
                 }
-                else if (!(subscription instanceof Subscription)) {
-                    var tmp = subscription;
-                    subscription = new Subscription();
-                    subscription._subscriptions = [tmp];
+            }
+            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; }
                 }
-                break;
-            default: {
-                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');
             }
-        }
-        var _parentOrParents = subscription._parentOrParents;
-        if (_parentOrParents === null) {
-            subscription._parentOrParents = this;
-        }
-        else if (_parentOrParents instanceof Subscription) {
-            if (_parentOrParents === this) {
-                return subscription;
+            if (errors) {
+                throw new UnsubscriptionError(errors);
             }
-            subscription._parentOrParents = [_parentOrParents, this];
         }
-        else if (_parentOrParents.indexOf(this) === -1) {
-            _parentOrParents.push(this);
-        }
-        else {
-            return subscription;
+    };
+    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);
+            }
         }
-        var subscriptions = this._subscriptions;
-        if (subscriptions === null) {
-            this._subscriptions = [subscription];
+    };
+    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 {
-            subscriptions.push(subscription);
+        else if (Array.isArray(_parentage)) {
+            arrRemove(_parentage, parent);
         }
-        return subscription;
     };
-    Subscription.prototype.remove = function (subscription) {
-        var subscriptions = this._subscriptions;
-        if (subscriptions) {
-            var subscriptionIndex = subscriptions.indexOf(subscription);
-            if (subscriptionIndex !== -1) {
-                subscriptions.splice(subscriptionIndex, 1);
-            }
+    Subscription.prototype.remove = function (teardown) {
+        var _finalizers = this._finalizers;
+        _finalizers && arrRemove(_finalizers, teardown);
+        if (teardown instanceof Subscription) {
+            teardown._removeParent(this);
         }
     };
-    Subscription.EMPTY = (function (empty) {
+    Subscription.EMPTY = (function () {
+        var empty = new Subscription();
         empty.closed = true;
         return empty;
-    }(new Subscription()));
+    })();
     return Subscription;
 }());
-function flattenUnsubscriptionErrors(errors) {
-    return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError) ? err.errors : err); }, []);
+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();
+    }
 }
 
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-var rxSubscriber = /*@__PURE__*/ (function () {
-    return typeof Symbol === 'function'
-        ? /*@__PURE__*/ Symbol('rxSubscriber')
-        : '@@rxSubscriber_' + /*@__PURE__*/ Math.random();
-})();
+var config = {
+    onUnhandledError: null,
+    onStoppedNotification: null,
+    Promise: undefined,
+    useDeprecatedSynchronousErrorHandling: false,
+    useDeprecatedNextContext: false,
+};
 
-/** PURE_IMPORTS_START tslib,_util_isFunction,_Observer,_Subscription,_internal_symbol_rxSubscriber,_config,_util_hostReportError PURE_IMPORTS_END */
-var Subscriber = /*@__PURE__*/ (function (_super) {
+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(destinationOrNext, error, complete) {
+    function Subscriber(destination) {
         var _this = _super.call(this) || this;
-        _this.syncErrorValue = null;
-        _this.syncErrorThrown = false;
-        _this.syncErrorThrowable = false;
         _this.isStopped = false;
-        switch (arguments.length) {
-            case 0:
-                _this.destination = empty;
-                break;
-            case 1:
-                if (!destinationOrNext) {
-                    _this.destination = empty;
-                    break;
-                }
-                if (typeof destinationOrNext === 'object') {
-                    if (destinationOrNext instanceof Subscriber) {
-                        _this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;
-                        _this.destination = destinationOrNext;
-                        destinationOrNext.add(_this);
-                    }
-                    else {
-                        _this.syncErrorThrowable = true;
-                        _this.destination = new SafeSubscriber(_this, destinationOrNext);
-                    }
-                    break;
-                }
-            default:
-                _this.syncErrorThrowable = true;
-                _this.destination = new SafeSubscriber(_this, destinationOrNext, error, complete);
-                break;
+        if (destination) {
+            _this.destination = destination;
+            if (isSubscription(destination)) {
+                destination.add(_this);
+            }
+        }
+        else {
+            _this.destination = EMPTY_OBSERVER;
         }
         return _this;
     }
-    Subscriber.prototype[rxSubscriber] = function () { return this; };
     Subscriber.create = function (next, error, complete) {
-        var subscriber = new Subscriber(next, error, complete);
-        subscriber.syncErrorThrowable = false;
-        return subscriber;
+        return new SafeSubscriber(next, error, complete);
     };
     Subscriber.prototype.next = function (value) {
-        if (!this.isStopped) {
+        if (this.isStopped) ;
+        else {
             this._next(value);
         }
     };
     Subscriber.prototype.error = function (err) {
-        if (!this.isStopped) {
+        if (this.isStopped) ;
+        else {
             this.isStopped = true;
             this._error(err);
         }
     };
     Subscriber.prototype.complete = function () {
-        if (!this.isStopped) {
+        if (this.isStopped) ;
+        else {
             this.isStopped = true;
             this._complete();
         }
     };
     Subscriber.prototype.unsubscribe = function () {
-        if (this.closed) {
-            return;
+        if (!this.closed) {
+            this.isStopped = true;
+            _super.prototype.unsubscribe.call(this);
+            this.destination = null;
         }
-        this.isStopped = true;
-        _super.prototype.unsubscribe.call(this);
     };
     Subscriber.prototype._next = function (value) {
         this.destination.next(value);
     };
     Subscriber.prototype._error = function (err) {
-        this.destination.error(err);
-        this.unsubscribe();
+        try {
+            this.destination.error(err);
+        }
+        finally {
+            this.unsubscribe();
+        }
     };
     Subscriber.prototype._complete = function () {
-        this.destination.complete();
-        this.unsubscribe();
-    };
-    Subscriber.prototype._unsubscribeAndRecycle = function () {
-        var _parentOrParents = this._parentOrParents;
-        this._parentOrParents = null;
-        this.unsubscribe();
-        this.closed = false;
-        this.isStopped = false;
-        this._parentOrParents = _parentOrParents;
-        return this;
+        try {
+            this.destination.complete();
+        }
+        finally {
+            this.unsubscribe();
+        }
     };
     return Subscriber;
 }(Subscription));
-var SafeSubscriber = /*@__PURE__*/ (function (_super) {
-    __extends(SafeSubscriber, _super);
-    function SafeSubscriber(_parentSubscriber, observerOrNext, error, complete) {
-        var _this = _super.call(this) || this;
-        _this._parentSubscriber = _parentSubscriber;
-        var next;
-        var context = _this;
-        if (isFunction(observerOrNext)) {
-            next = observerOrNext;
-        }
-        else if (observerOrNext) {
-            next = observerOrNext.next;
-            error = observerOrNext.error;
-            complete = observerOrNext.complete;
-            if (observerOrNext !== empty) {
-                context = Object.create(observerOrNext);
-                if (isFunction(context.unsubscribe)) {
-                    _this.add(context.unsubscribe.bind(context));
-                }
-                context.unsubscribe = _this.unsubscribe.bind(_this);
-            }
-        }
-        _this._context = context;
-        _this._next = next;
-        _this._error = error;
-        _this._complete = complete;
-        return _this;
+var ConsumerObserver = (function () {
+    function ConsumerObserver(partialObserver) {
+        this.partialObserver = partialObserver;
     }
-    SafeSubscriber.prototype.next = function (value) {
-        if (!this.isStopped && this._next) {
-            var _parentSubscriber = this._parentSubscriber;
-            if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-                this.__tryOrUnsub(this._next, value);
+    ConsumerObserver.prototype.next = function (value) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.next) {
+            try {
+                partialObserver.next(value);
             }
-            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
-                this.unsubscribe();
+            catch (error) {
+                handleUnhandledError(error);
             }
         }
     };
-    SafeSubscriber.prototype.error = function (err) {
-        if (!this.isStopped) {
-            var _parentSubscriber = this._parentSubscriber;
-            var useDeprecatedSynchronousErrorHandling = config.useDeprecatedSynchronousErrorHandling;
-            if (this._error) {
-                if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-                    this.__tryOrUnsub(this._error, err);
-                    this.unsubscribe();
-                }
-                else {
-                    this.__tryOrSetError(_parentSubscriber, this._error, err);
-                    this.unsubscribe();
-                }
-            }
-            else if (!_parentSubscriber.syncErrorThrowable) {
-                this.unsubscribe();
-                if (useDeprecatedSynchronousErrorHandling) {
-                    throw err;
-                }
-                hostReportError(err);
+    ConsumerObserver.prototype.error = function (err) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.error) {
+            try {
+                partialObserver.error(err);
             }
-            else {
-                if (useDeprecatedSynchronousErrorHandling) {
-                    _parentSubscriber.syncErrorValue = err;
-                    _parentSubscriber.syncErrorThrown = true;
-                }
-                else {
-                    hostReportError(err);
-                }
-                this.unsubscribe();
+            catch (error) {
+                handleUnhandledError(error);
             }
         }
-    };
-    SafeSubscriber.prototype.complete = function () {
-        var _this = this;
-        if (!this.isStopped) {
-            var _parentSubscriber = this._parentSubscriber;
-            if (this._complete) {
-                var wrappedComplete = function () { return _this._complete.call(_this._context); };
-                if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {
-                    this.__tryOrUnsub(wrappedComplete);
-                    this.unsubscribe();
-                }
-                else {
-                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);
-                    this.unsubscribe();
-                }
-            }
-            else {
-                this.unsubscribe();
-            }
+        else {
+            handleUnhandledError(err);
         }
     };
-    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {
-        try {
-            fn.call(this._context, value);
-        }
-        catch (err) {
-            this.unsubscribe();
-            if (config.useDeprecatedSynchronousErrorHandling) {
-                throw err;
+    ConsumerObserver.prototype.complete = function () {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.complete) {
+            try {
+                partialObserver.complete();
             }
-            else {
-                hostReportError(err);
+            catch (error) {
+                handleUnhandledError(error);
             }
         }
     };
-    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {
-        if (!config.useDeprecatedSynchronousErrorHandling) {
-            throw new Error('bad call');
-        }
-        try {
-            fn.call(this._context, value);
+    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,
+            };
         }
-        catch (err) {
-            if (config.useDeprecatedSynchronousErrorHandling) {
-                parent.syncErrorValue = err;
-                parent.syncErrorThrown = true;
-                return true;
-            }
-            else {
-                hostReportError(err);
-                return true;
+        else {
+            {
+                partialObserver = observerOrNext;
             }
         }
-        return false;
-    };
-    SafeSubscriber.prototype._unsubscribe = function () {
-        var _parentSubscriber = this._parentSubscriber;
-        this._context = null;
-        this._parentSubscriber = null;
-        _parentSubscriber.unsubscribe();
-    };
+        _this.destination = new ConsumerObserver(partialObserver);
+        return _this;
+    }
     return SafeSubscriber;
 }(Subscriber));
-
-/** PURE_IMPORTS_START _Subscriber PURE_IMPORTS_END */
-function canReportError(observer) {
-    while (observer) {
-        var _a = observer, closed_1 = _a.closed, destination = _a.destination, isStopped = _a.isStopped;
-        if (closed_1 || isStopped) {
-            return false;
-        }
-        else if (destination && destination instanceof Subscriber) {
-            observer = destination;
-        }
-        else {
-            observer = null;
-        }
+function handleUnhandledError(error) {
+    {
+        reportUnhandledError(error);
     }
-    return true;
 }
-
-/** PURE_IMPORTS_START _Subscriber,_symbol_rxSubscriber,_Observer PURE_IMPORTS_END */
-function toSubscriber(nextOrObserver, error, complete) {
-    if (nextOrObserver) {
-        if (nextOrObserver instanceof Subscriber) {
-            return nextOrObserver;
-        }
-        if (nextOrObserver[rxSubscriber]) {
-            return nextOrObserver[rxSubscriber]();
-        }
-    }
-    if (!nextOrObserver && !error && !complete) {
-        return new Subscriber(empty);
-    }
-    return new Subscriber(nextOrObserver, error, complete);
+function defaultErrorHandler(err) {
+    throw err;
 }
+var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop,
+};
 
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
-var observable = /*@__PURE__*/ (function () { return typeof Symbol === 'function' && Symbol.observable || '@@observable'; })();
+var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
 
-/** PURE_IMPORTS_START  PURE_IMPORTS_END */
 function identity(x) {
     return x;
 }
 
-/** PURE_IMPORTS_START _identity PURE_IMPORTS_END */
 function pipeFromArray(fns) {
     if (fns.length === 0) {
         return identity;
@@ -707,10 +621,8 @@ function pipeFromArray(fns) {
     };
 }
 
-/** PURE_IMPORTS_START _util_canReportError,_util_toSubscriber,_symbol_observable,_util_pipe,_config PURE_IMPORTS_END */
-var Observable = /*@__PURE__*/ (function () {
+var Observable = (function () {
     function Observable(subscribe) {
-        this._isScalar = false;
         if (subscribe) {
             this._subscribe = subscribe;
         }
@@ -722,64 +634,52 @@ var Observable = /*@__PURE__*/ (function () {
         return observable;
     };
     Observable.prototype.subscribe = function (observerOrNext, error, complete) {
-        var operator = this.operator;
-        var sink = toSubscriber(observerOrNext, error, complete);
-        if (operator) {
-            sink.add(operator.call(sink, this.source));
-        }
-        else {
-            sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?
-                this._subscribe(sink) :
-                this._trySubscribe(sink));
-        }
-        if (config.useDeprecatedSynchronousErrorHandling) {
-            if (sink.syncErrorThrowable) {
-                sink.syncErrorThrowable = false;
-                if (sink.syncErrorThrown) {
-                    throw sink.syncErrorValue;
-                }
-            }
-        }
-        return sink;
+        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) {
-            if (config.useDeprecatedSynchronousErrorHandling) {
-                sink.syncErrorThrown = true;
-                sink.syncErrorValue = err;
-            }
-            if (canReportError(sink)) {
-                sink.error(err);
-            }
-            else {
-                console.warn(err);
-            }
+            sink.error(err);
         }
     };
     Observable.prototype.forEach = function (next, promiseCtor) {
         var _this = this;
         promiseCtor = getPromiseCtor(promiseCtor);
         return new promiseCtor(function (resolve, reject) {
-            var subscription;
-            subscription = _this.subscribe(function (value) {
-                try {
-                    next(value);
-                }
-                catch (err) {
-                    reject(err);
-                    if (subscription) {
-                        subscription.unsubscribe();
+            var subscriber = new SafeSubscriber({
+                next: function (value) {
+                    try {
+                        next(value);
                     }
-                }
-            }, reject, resolve);
+                    catch (err) {
+                        reject(err);
+                        subscriber.unsubscribe();
+                    }
+                },
+                error: reject,
+                complete: resolve,
+            });
+            _this.subscribe(subscriber);
         });
     };
     Observable.prototype._subscribe = function (subscriber) {
-        var source = this.source;
-        return source && source.subscribe(subscriber);
+        var _a;
+        return (_a = this.source) === null || _a === undefined ? undefined : _a.subscribe(subscriber);
     };
     Observable.prototype[observable] = function () {
         return this;
@@ -789,9 +689,6 @@ var Observable = /*@__PURE__*/ (function () {
         for (var _i = 0; _i < arguments.length; _i++) {
             operations[_i] = arguments[_i];
         }
-        if (operations.length === 0) {
-            return this;
-        }
         return pipeFromArray(operations)(this);
     };
     Observable.prototype.toPromise = function (promiseCtor) {
@@ -799,7 +696,7 @@ var Observable = /*@__PURE__*/ (function () {
         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); });
+            _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
         });
     };
     Observable.create = function (subscribe) {
@@ -808,40 +705,19 @@ var Observable = /*@__PURE__*/ (function () {
     return Observable;
 }());
 function getPromiseCtor(promiseCtor) {
-    if (!promiseCtor) {
-        promiseCtor =  Promise;
-    }
-    if (!promiseCtor) {
-        throw new Error('no Promise impl found');
-    }
-    return 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));
 }
 
-var copy = createCommonjsModule(function (module, exports) {
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepCopyJSON = void 0;
 function deepCopyJSON(param) {
     return JSON.parse(JSON.stringify(param));
 }
-exports.deepCopyJSON = deepCopyJSON;
-
-});
-
-var copy$1 = createCommonjsModule(function (module, exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(copy, exports);
-
-});
 
 let authorization;
 let service;
@@ -859,7 +735,7 @@ class _Challenge {
     }
 }
 function initialize(options) {
-    const { authorization: _authorization, service: _service } = internal_common.initialize(options);
+    const { authorization: _authorization, service: _service } = initialize$1(options);
     authorization = _authorization;
     service = _service;
     service.setWriteDefaults({
@@ -873,11 +749,11 @@ function verifyToken(token, baseUrl) {
     if (!_baseUrl) {
         throw new Error("You should pass the base url of the server or call the initialize method.");
     }
-    const req = new internal_common.Axios({ baseURL: _baseUrl });
+    const req = new Axios({ baseURL: _baseUrl });
     return req.get(`${identitySegment}/verify`, { headers: { Authorization: token } });
 }
 async function login(identifier, password, tokenLifeSpan) {
-    internal_common.checkInitialized(authorization);
+    checkInitialized(authorization);
     return service
         .post("/passport/identify", {
         identifier,
@@ -892,7 +768,6 @@ async function login(identifier, password, tokenLifeSpan) {
         return challenge;
     });
 }
-// we don't want to export this function because it's for internal usages
 function isTokenScheme(response) {
     return typeof response.token == "string";
 }
@@ -900,7 +775,7 @@ function isChallenge(tokenOrChallenge) {
     return typeof tokenOrChallenge.show == "function" && typeof tokenOrChallenge.answer == "function";
 }
 async function loginWithStrategy(id) {
-    internal_common.checkInitialized(authorization);
+    checkInitialized(authorization);
     const { url, state } = await service.get(`/passport/strategy/${id}/url`);
     const token = new Observable(observer => {
         service
@@ -945,18 +820,18 @@ function getStrategies() {
     return service.get("/passport/strategies");
 }
 function get(id) {
-    internal_common.checkInitialized(authorization);
+    checkInitialized(authorization);
     return service.get(`${identitySegment}/${id}`);
 }
 function getAll(queryParams = {}) {
-    internal_common.checkInitialized(authorization);
+    checkInitialized(authorization);
     return service.get(identitySegment, {
         params: queryParams
     });
 }
 async function insert(identity) {
-    internal_common.checkInitialized(authorization);
-    identity = copy$1.deepCopyJSON(identity);
+    checkInitialized(authorization);
+    identity = deepCopyJSON(identity);
     const desiredPolicies = identity.policies;
     delete identity.policies;
     const insertedIdentity = await service.post(identitySegment, identity);
@@ -966,27 +841,26 @@ async function insert(identity) {
     });
 }
 async function update(id, identity) {
-    internal_common.checkInitialized(authorization);
+    checkInitialized(authorization);
     const existingIdentity = await service.get(`${identitySegment}/${id}`);
-    await policy.detach(id, existingIdentity.policies || []);
-    identity = copy$1.deepCopyJSON(identity);
+    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);
-    return policy.attach(id, desiredPolicies || []).then(policies => {
-        updatedIdentity.policies = policies;
-        return updatedIdentity;
-    });
+    updatedIdentity.policies = desiredPolicies;
+    await policy.attach(id, policiesForAttach);
+    await policy.detach(id, policiesForDetach);
+    return updatedIdentity;
 }
 function remove(id) {
-    internal_common.checkInitialized(authorization);
+    checkInitialized(authorization);
     return service.delete(`${identitySegment}/${id}`);
 }
-// policy attach detach
 var policy;
 (function (policy) {
     function attach(identityId, policyIds = []) {
-        internal_common.checkInitialized(authorization);
+        checkInitialized(authorization);
         const promises = [];
         const attachedPolicies = new Set();
         for (const policyId of policyIds) {
@@ -1003,7 +877,7 @@ var policy;
     }
     policy.attach = attach;
     function detach(identityId, policyIds = []) {
-        internal_common.checkInitialized(authorization);
+        checkInitialized(authorization);
         const promises = [];
         const detachedPolicies = new Set();
         for (const policyId of policyIds) {
@@ -1020,6 +894,13 @@ var policy;
     }
     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