@pod-os/core 0.11.2-fe7524c.0 → 0.12.1-eddb6ac.0

package/dist/index.js

@@ -7,9 +7,8 @@ import {
   isNamedNode,
   lit,
   namedNode,
-  st,
-  v4_default
-} from "./chunk-NJZBRQIY.js";
+  st
+} from "./chunk-7C7N3OSJ.js";
 import {
   __commonJS,
   __export,
@@ -7589,7 +7588,7 @@ var require_oidc_client_min = __commonJS({
 var require_lunr = __commonJS({
   "../node_modules/lunr/lunr.js"(exports, module2) {
     (function() {
-      var lunr2 = function(config) {
+      var lunr2 = function(config2) {
         var builder = new lunr2.Builder();
         builder.pipeline.add(
           lunr2.trimmer,
@@ -7599,7 +7598,7 @@ var require_lunr = __commonJS({
         builder.searchPipeline.add(
           lunr2.stemmer
         );
-        config.call(builder, builder);
+        config2.call(builder, builder);
         return builder.build();
       };
       lunr2.version = "2.3.9";
@@ -9374,6 +9373,1675 @@ var require_slugify = __commonJS({
   }
 });
 
+// ../node_modules/tslib/tslib.es6.mjs
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2)
+      if (Object.prototype.hasOwnProperty.call(b2, p))
+        d2[p] = b2[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 __awaiter(thisArg, _arguments, P, generator3) {
+  function adopt(value6) {
+    return value6 instanceof P ? value6 : new P(function(resolve) {
+      resolve(value6);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject2) {
+    function fulfilled(value6) {
+      try {
+        step4(generator3.next(value6));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function rejected(value6) {
+      try {
+        step4(generator3["throw"](value6));
+      } catch (e) {
+        reject2(e);
+      }
+    }
+    function step4(result5) {
+      result5.done ? resolve(result5.value) : adopt(result5.value).then(fulfilled, rejected);
+    }
+    step4((generator3 = generator3.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1)
+      throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb2(0), "throw": verb2(1), "return": verb2(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb2(n2) {
+    return function(v2) {
+      return step4([n2, v2]);
+    };
+  }
+  function step4(op2) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op2[0] && (_ = 0)), _)
+      try {
+        if (f = 1, y && (t = op2[0] & 2 ? y["return"] : op2[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op2[1])).done)
+          return t;
+        if (y = 0, t)
+          op2 = [op2[0] & 2, t.value];
+        switch (op2[0]) {
+          case 0:
+          case 1:
+            t = op2;
+            break;
+          case 4:
+            _.label++;
+            return { value: op2[1], done: false };
+          case 5:
+            _.label++;
+            y = op2[1];
+            op2 = [0];
+            continue;
+          case 7:
+            op2 = _.ops.pop();
+            _.trys.pop();
+            continue;
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op2[0] === 6 || op2[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op2[0] === 3 && (!t || op2[1] > t[0] && op2[1] < t[3])) {
+              _.label = op2[1];
+              break;
+            }
+            if (op2[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op2;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+              _.ops.push(op2);
+              break;
+            }
+            if (t[2])
+              _.ops.pop();
+            _.trys.pop();
+            continue;
+        }
+        op2 = body.call(thisArg, _);
+      } catch (e) {
+        op2 = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op2[0] & 5)
+      throw op2[1];
+    return { value: op2[0] ? op2[1] : void 0, done: true };
+  }
+}
+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 = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n2) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n2 === void 0 || n2-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error4) {
+    e = { error: error4 };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to2, from2, pack) {
+  if (pack || arguments.length === 2)
+    for (var i = 0, l = from2.length, ar; i < l; i++) {
+      if (ar || !(i in from2)) {
+        if (!ar)
+          ar = Array.prototype.slice.call(from2, 0, i);
+        ar[i] = from2[i];
+      }
+    }
+  return to2.concat(ar || Array.prototype.slice.call(from2));
+}
+function __await(v2) {
+  return this instanceof __await ? (this.v = v2, this) : new __await(v2);
+}
+function __asyncGenerator(thisArg, _arguments, generator3) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator3.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb2("next"), verb2("throw"), verb2("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb2(n2) {
+    if (g[n2])
+      i[n2] = function(v2) {
+        return new Promise(function(a, b) {
+          q.push([n2, v2, a, b]) > 1 || resume(n2, v2);
+        });
+      };
+  }
+  function resume(n2, v2) {
+    try {
+      step4(g[n2](v2));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step4(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject2) : settle(q[0][2], r);
+  }
+  function fulfill(value6) {
+    resume("next", value6);
+  }
+  function reject2(value6) {
+    resume("throw", value6);
+  }
+  function settle(f, v2) {
+    if (f(v2), q.shift(), q.length)
+      resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb2("next"), verb2("throw"), verb2("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb2(n2) {
+    i[n2] = o[n2] && function(v2) {
+      return new Promise(function(resolve, reject2) {
+        v2 = o[n2](v2), settle(resolve, reject2, v2.done, v2.value);
+      });
+    };
+  }
+  function settle(resolve, reject2, d, v2) {
+    Promise.resolve(v2).then(function(v3) {
+      resolve({ value: v3, done: d });
+    }, reject2);
+  }
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isFunction.js
+function isFunction(value6) {
+  return typeof value6 === "function";
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
+function createErrorClass(createImpl) {
+  var _super = function(instance3) {
+    Error.call(instance3);
+    instance3.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
+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;
+  };
+});
+
+// ../node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
+function arrRemove(arr, item4) {
+  if (arr) {
+    var index2 = arr.indexOf(item4);
+    0 <= index2 && arr.splice(index2, 1);
+  }
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/Subscription.js
+var Subscription = function() {
+  function Subscription3(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription3.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);
+      }
+    }
+  };
+  Subscription3.prototype.add = function(teardown2) {
+    var _a;
+    if (teardown2 && teardown2 !== this) {
+      if (this.closed) {
+        execFinalizer(teardown2);
+      } else {
+        if (teardown2 instanceof Subscription3) {
+          if (teardown2.closed || teardown2._hasParent(this)) {
+            return;
+          }
+          teardown2._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown2);
+      }
+    }
+  };
+  Subscription3.prototype._hasParent = function(parent4) {
+    var _parentage = this._parentage;
+    return _parentage === parent4 || Array.isArray(_parentage) && _parentage.includes(parent4);
+  };
+  Subscription3.prototype._addParent = function(parent4) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent4), _parentage) : _parentage ? [_parentage, parent4] : parent4;
+  };
+  Subscription3.prototype._removeParent = function(parent4) {
+    var _parentage = this._parentage;
+    if (_parentage === parent4) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent4);
+    }
+  };
+  Subscription3.prototype.remove = function(teardown2) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown2);
+    if (teardown2 instanceof Subscription3) {
+      teardown2._removeParent(this);
+    }
+  };
+  Subscription3.EMPTY = function() {
+    var empty = new Subscription3();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription3;
+}();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value6) {
+  return value6 instanceof Subscription || value6 && "closed" in value6 && isFunction(value6.remove) && isFunction(value6.add) && isFunction(value6.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/config.js
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
+var timeoutProvider = {
+  setTimeout: function(handler, timeout2) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = timeoutProvider.delegate;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+      return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout2], __read(args)));
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout2], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+
+// ../node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    var onUnhandledError = config.onUnhandledError;
+    if (onUnhandledError) {
+      onUnhandledError(err);
+    } else {
+      throw err;
+    }
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/noop.js
+function noop() {
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
+var COMPLETE_NOTIFICATION = function() {
+  return createNotification("C", void 0, void 0);
+}();
+function errorNotification(error4) {
+  return createNotification("E", void 0, error4);
+}
+function nextNotification(value6) {
+  return createNotification("N", value6, void 0);
+}
+function createNotification(kind2, value6, error4) {
+  return {
+    kind: kind2,
+    value: value6,
+    error: error4
+  };
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/errorContext.js
+var context = null;
+function errorContext(cb) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    var isRoot = !context;
+    if (isRoot) {
+      context = { errorThrown: false, error: null };
+    }
+    cb();
+    if (isRoot) {
+      var _a = context, errorThrown = _a.errorThrown, error4 = _a.error;
+      context = null;
+      if (errorThrown) {
+        throw error4;
+      }
+    }
+  } else {
+    cb();
+  }
+}
+function captureError(err) {
+  if (config.useDeprecatedSynchronousErrorHandling && context) {
+    context.errorThrown = true;
+    context.error = err;
+  }
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/Subscriber.js
+var Subscriber = function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination2) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination2) {
+      _this.destination = destination2;
+      if (isSubscription(destination2)) {
+        destination2.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next3, error4, complete2) {
+    return new SafeSubscriber(next3, error4, complete2);
+  };
+  Subscriber2.prototype.next = function(value6) {
+    if (this.isStopped) {
+      handleStoppedNotification(nextNotification(value6), this);
+    } else {
+      this._next(value6);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) {
+      handleStoppedNotification(errorNotification(err), this);
+    } else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) {
+      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+    } else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value6) {
+    this.destination.next(value6);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+}(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn2, thisArg) {
+  return _bind.call(fn2, thisArg);
+}
+var ConsumerObserver = function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value6) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value6);
+      } catch (error4) {
+        handleUnhandledError(error4);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error4) {
+        handleUnhandledError(error4);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error4) {
+        handleUnhandledError(error4);
+      }
+    }
+  };
+  return ConsumerObserver2;
+}();
+var SafeSubscriber = function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error4, complete2) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error4 !== null && error4 !== void 0 ? error4 : void 0,
+        complete: complete2 !== null && complete2 !== void 0 ? complete2 : void 0
+      };
+    } else {
+      var context_1;
+      if (_this && config.useDeprecatedNextContext) {
+        context_1 = Object.create(observerOrNext);
+        context_1.unsubscribe = function() {
+          return _this.unsubscribe();
+        };
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context_1),
+          error: observerOrNext.error && bind(observerOrNext.error, context_1),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+}(Subscriber);
+function handleUnhandledError(error4) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    captureError(error4);
+  } else {
+    reportUnhandledError(error4);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+function handleStoppedNotification(notification2, subscriber3) {
+  var onStoppedNotification = config.onStoppedNotification;
+  onStoppedNotification && timeoutProvider.setTimeout(function() {
+    return onStoppedNotification(notification2, subscriber3);
+  });
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+
+// ../node_modules/rxjs/dist/esm5/internal/symbol/observable.js
+var observable = function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+}();
+
+// ../node_modules/rxjs/dist/esm5/internal/util/identity.js
+function identity(x) {
+  return x;
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/pipe.js
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input2) {
+    return fns.reduce(function(prev, fn2) {
+      return fn2(prev);
+    }, input2);
+  };
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/Observable.js
+var Observable = function() {
+  function Observable2(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator2) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator2;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error4, complete2) {
+    var _this = this;
+    var subscriber3 = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error4, complete2);
+    errorContext(function() {
+      var _a = _this, operator2 = _a.operator, source8 = _a.source;
+      subscriber3.add(operator2 ? operator2.call(subscriber3, source8) : source8 ? _this._subscribe(subscriber3) : _this._trySubscribe(subscriber3));
+    });
+    return subscriber3;
+  };
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable2.prototype.forEach = function(next3, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject2) {
+      var subscriber3 = new SafeSubscriber({
+        next: function(value6) {
+          try {
+            next3(value6);
+          } catch (err) {
+            reject2(err);
+            subscriber3.unsubscribe();
+          }
+        },
+        error: reject2,
+        complete: resolve
+      });
+      _this.subscribe(subscriber3);
+    });
+  };
+  Observable2.prototype._subscribe = function(subscriber3) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber3);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject2) {
+      var value6;
+      _this.subscribe(function(x) {
+        return value6 = x;
+      }, function(err) {
+        return reject2(err);
+      }, function() {
+        return resolve(value6);
+      });
+    });
+  };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+}();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value6) {
+  return value6 && isFunction(value6.next) && isFunction(value6.error) && isFunction(value6.complete);
+}
+function isSubscriber(value6) {
+  return value6 && value6 instanceof Subscriber || isObserver(value6) && isSubscription(value6);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/lift.js
+function hasLift(source8) {
+  return isFunction(source8 === null || source8 === void 0 ? void 0 : source8.lift);
+}
+function operate(init) {
+  return function(source8) {
+    if (hasLift(source8)) {
+      return source8.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
+function createOperatorSubscriber(destination2, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination2, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function(_super) {
+  __extends(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination2, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination2) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function(value6) {
+      try {
+        onNext(value6);
+      } catch (err) {
+        destination2.error(err);
+      }
+    } : _super.prototype._next;
+    _this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination2.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination2.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber2.prototype.unsubscribe = function() {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+    }
+  };
+  return OperatorSubscriber2;
+}(Subscriber);
+
+// ../node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = "ObjectUnsubscribedError";
+    this.message = "object unsubscribed";
+  };
+});
+
+// ../node_modules/rxjs/dist/esm5/internal/Subject.js
+var Subject = function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype.lift = function(operator2) {
+    var subject5 = new AnonymousSubject(this, this);
+    subject5.operator = operator2;
+    return subject5;
+  };
+  Subject2.prototype._throwIfClosed = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject2.prototype.next = function(value6) {
+    var _this = this;
+    errorContext(function() {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer2 = _c.value;
+            observer2.next(value6);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return))
+              _a.call(_b);
+          } finally {
+            if (e_1)
+              throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject2.prototype.error = function(err) {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject2.prototype.complete = function() {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject2.prototype, "observed", {
+    get: function() {
+      var _a;
+      return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject2.prototype._trySubscribe = function(subscriber3) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber3);
+  };
+  Subject2.prototype._subscribe = function(subscriber3) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber3);
+    return this._innerSubscribe(subscriber3);
+  };
+  Subject2.prototype._innerSubscribe = function(subscriber3) {
+    var _this = this;
+    var _a = this, hasError2 = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+    if (hasError2 || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber3);
+    return new Subscription(function() {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber3);
+    });
+  };
+  Subject2.prototype._checkFinalizedStatuses = function(subscriber3) {
+    var _a = this, hasError2 = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+    if (hasError2) {
+      subscriber3.error(thrownError);
+    } else if (isStopped) {
+      subscriber3.complete();
+    }
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination2, source8) {
+    return new AnonymousSubject(destination2, source8);
+  };
+  return Subject2;
+}(Observable);
+var AnonymousSubject = function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination2, source8) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination2;
+    _this.source = source8;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value6) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value6);
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber3) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber3)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject2;
+}(Subject);
+
+// ../node_modules/rxjs/dist/esm5/internal/BehaviorSubject.js
+var BehaviorSubject = function(_super) {
+  __extends(BehaviorSubject3, _super);
+  function BehaviorSubject3(_value2) {
+    var _this = _super.call(this) || this;
+    _this._value = _value2;
+    return _this;
+  }
+  Object.defineProperty(BehaviorSubject3.prototype, "value", {
+    get: function() {
+      return this.getValue();
+    },
+    enumerable: false,
+    configurable: true
+  });
+  BehaviorSubject3.prototype._subscribe = function(subscriber3) {
+    var subscription2 = _super.prototype._subscribe.call(this, subscriber3);
+    !subscription2.closed && subscriber3.next(this._value);
+    return subscription2;
+  };
+  BehaviorSubject3.prototype.getValue = function() {
+    var _a = this, hasError2 = _a.hasError, thrownError = _a.thrownError, _value2 = _a._value;
+    if (hasError2) {
+      throw thrownError;
+    }
+    this._throwIfClosed();
+    return _value2;
+  };
+  BehaviorSubject3.prototype.next = function(value6) {
+    _super.prototype.next.call(this, this._value = value6);
+  };
+  return BehaviorSubject3;
+}(Subject);
+
+// ../node_modules/rxjs/dist/esm5/internal/observable/empty.js
+var EMPTY = new Observable(function(subscriber3) {
+  return subscriber3.complete();
+});
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
+function isScheduler(value6) {
+  return value6 && isFunction(value6.schedule);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/args.js
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popScheduler(args) {
+  return isScheduler(last(args)) ? args.pop() : void 0;
+}
+function popNumber(args, defaultValue4) {
+  return typeof last(args) === "number" ? args.pop() : defaultValue4;
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js
+var isArrayLike = function(x) {
+  return x && typeof x.length === "number" && typeof x !== "function";
+};
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isPromise.js
+function isPromise(value6) {
+  return isFunction(value6 === null || value6 === void 0 ? void 0 : value6.then);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js
+function isInteropObservable(input2) {
+  return isFunction(input2[observable]);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js
+function isAsyncIterable(obj) {
+  return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js
+function createInvalidObservableTypeError(input2) {
+  return new TypeError("You provided " + (input2 !== null && typeof input2 === "object" ? "an invalid object" : "'" + input2 + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/symbol/iterator.js
+function getSymbolIterator() {
+  if (typeof Symbol !== "function" || !Symbol.iterator) {
+    return "@@iterator";
+  }
+  return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isIterable.js
+function isIterable(input2) {
+  return isFunction(input2 === null || input2 === void 0 ? void 0 : input2[iterator]);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js
+function readableStreamLikeToAsyncGenerator(readableStream) {
+  return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+    var reader, _a, value6, done;
+    return __generator(this, function(_b) {
+      switch (_b.label) {
+        case 0:
+          reader = readableStream.getReader();
+          _b.label = 1;
+        case 1:
+          _b.trys.push([1, , 9, 10]);
+          _b.label = 2;
+        case 2:
+          if (false)
+            return [3, 8];
+          return [4, __await(reader.read())];
+        case 3:
+          _a = _b.sent(), value6 = _a.value, done = _a.done;
+          if (!done)
+            return [3, 5];
+          return [4, __await(void 0)];
+        case 4:
+          return [2, _b.sent()];
+        case 5:
+          return [4, __await(value6)];
+        case 6:
+          return [4, _b.sent()];
+        case 7:
+          _b.sent();
+          return [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          reader.releaseLock();
+          return [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function isReadableStreamLike(obj) {
+  return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js
+function innerFrom(input2) {
+  if (input2 instanceof Observable) {
+    return input2;
+  }
+  if (input2 != null) {
+    if (isInteropObservable(input2)) {
+      return fromInteropObservable(input2);
+    }
+    if (isArrayLike(input2)) {
+      return fromArrayLike(input2);
+    }
+    if (isPromise(input2)) {
+      return fromPromise(input2);
+    }
+    if (isAsyncIterable(input2)) {
+      return fromAsyncIterable(input2);
+    }
+    if (isIterable(input2)) {
+      return fromIterable(input2);
+    }
+    if (isReadableStreamLike(input2)) {
+      return fromReadableStreamLike(input2);
+    }
+  }
+  throw createInvalidObservableTypeError(input2);
+}
+function fromInteropObservable(obj) {
+  return new Observable(function(subscriber3) {
+    var obs = obj[observable]();
+    if (isFunction(obs.subscribe)) {
+      return obs.subscribe(subscriber3);
+    }
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function fromArrayLike(array) {
+  return new Observable(function(subscriber3) {
+    for (var i = 0; i < array.length && !subscriber3.closed; i++) {
+      subscriber3.next(array[i]);
+    }
+    subscriber3.complete();
+  });
+}
+function fromPromise(promise) {
+  return new Observable(function(subscriber3) {
+    promise.then(function(value6) {
+      if (!subscriber3.closed) {
+        subscriber3.next(value6);
+        subscriber3.complete();
+      }
+    }, function(err) {
+      return subscriber3.error(err);
+    }).then(null, reportUnhandledError);
+  });
+}
+function fromIterable(iterable) {
+  return new Observable(function(subscriber3) {
+    var e_1, _a;
+    try {
+      for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+        var value6 = iterable_1_1.value;
+        subscriber3.next(value6);
+        if (subscriber3.closed) {
+          return;
+        }
+      }
+    } catch (e_1_1) {
+      e_1 = { error: e_1_1 };
+    } finally {
+      try {
+        if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return))
+          _a.call(iterable_1);
+      } finally {
+        if (e_1)
+          throw e_1.error;
+      }
+    }
+    subscriber3.complete();
+  });
+}
+function fromAsyncIterable(asyncIterable) {
+  return new Observable(function(subscriber3) {
+    process(asyncIterable, subscriber3).catch(function(err) {
+      return subscriber3.error(err);
+    });
+  });
+}
+function fromReadableStreamLike(readableStream) {
+  return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process(asyncIterable, subscriber3) {
+  var asyncIterable_1, asyncIterable_1_1;
+  var e_2, _a;
+  return __awaiter(this, void 0, void 0, function() {
+    var value6, e_2_1;
+    return __generator(this, function(_b) {
+      switch (_b.label) {
+        case 0:
+          _b.trys.push([0, 5, 6, 11]);
+          asyncIterable_1 = __asyncValues(asyncIterable);
+          _b.label = 1;
+        case 1:
+          return [4, asyncIterable_1.next()];
+        case 2:
+          if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done))
+            return [3, 4];
+          value6 = asyncIterable_1_1.value;
+          subscriber3.next(value6);
+          if (subscriber3.closed) {
+            return [2];
+          }
+          _b.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          e_2_1 = _b.sent();
+          e_2 = { error: e_2_1 };
+          return [3, 11];
+        case 6:
+          _b.trys.push([6, , 9, 10]);
+          if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return)))
+            return [3, 8];
+          return [4, _a.call(asyncIterable_1)];
+        case 7:
+          _b.sent();
+          _b.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (e_2)
+            throw e_2.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          subscriber3.complete();
+          return [2];
+      }
+    });
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat3) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  if (repeat3 === void 0) {
+    repeat3 = false;
+  }
+  var scheduleSubscription = scheduler.schedule(function() {
+    work();
+    if (repeat3) {
+      parentSubscription.add(this.schedule(null, delay));
+    } else {
+      this.unsubscribe();
+    }
+  }, delay);
+  parentSubscription.add(scheduleSubscription);
+  if (!repeat3) {
+    return scheduleSubscription;
+  }
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/observeOn.js
+function observeOn(scheduler, delay) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  return operate(function(source8, subscriber3) {
+    source8.subscribe(createOperatorSubscriber(subscriber3, function(value6) {
+      return executeSchedule(subscriber3, scheduler, function() {
+        return subscriber3.next(value6);
+      }, delay);
+    }, function() {
+      return executeSchedule(subscriber3, scheduler, function() {
+        return subscriber3.complete();
+      }, delay);
+    }, function(err) {
+      return executeSchedule(subscriber3, scheduler, function() {
+        return subscriber3.error(err);
+      }, delay);
+    }));
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js
+function subscribeOn(scheduler, delay) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  return operate(function(source8, subscriber3) {
+    subscriber3.add(scheduler.schedule(function() {
+      return source8.subscribe(subscriber3);
+    }, delay));
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js
+function scheduleObservable(input2, scheduler) {
+  return innerFrom(input2).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js
+function schedulePromise(input2, scheduler) {
+  return innerFrom(input2).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js
+function scheduleArray(input2, scheduler) {
+  return new Observable(function(subscriber3) {
+    var i = 0;
+    return scheduler.schedule(function() {
+      if (i === input2.length) {
+        subscriber3.complete();
+      } else {
+        subscriber3.next(input2[i++]);
+        if (!subscriber3.closed) {
+          this.schedule();
+        }
+      }
+    });
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js
+function scheduleIterable(input2, scheduler) {
+  return new Observable(function(subscriber3) {
+    var iterator2;
+    executeSchedule(subscriber3, scheduler, function() {
+      iterator2 = input2[iterator]();
+      executeSchedule(subscriber3, scheduler, function() {
+        var _a;
+        var value6;
+        var done;
+        try {
+          _a = iterator2.next(), value6 = _a.value, done = _a.done;
+        } catch (err) {
+          subscriber3.error(err);
+          return;
+        }
+        if (done) {
+          subscriber3.complete();
+        } else {
+          subscriber3.next(value6);
+        }
+      }, 0, true);
+    });
+    return function() {
+      return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
+    };
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js
+function scheduleAsyncIterable(input2, scheduler) {
+  if (!input2) {
+    throw new Error("Iterable cannot be null");
+  }
+  return new Observable(function(subscriber3) {
+    executeSchedule(subscriber3, scheduler, function() {
+      var iterator2 = input2[Symbol.asyncIterator]();
+      executeSchedule(subscriber3, scheduler, function() {
+        iterator2.next().then(function(result5) {
+          if (result5.done) {
+            subscriber3.complete();
+          } else {
+            subscriber3.next(result5.value);
+          }
+        });
+      }, 0, true);
+    });
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js
+function scheduleReadableStreamLike(input2, scheduler) {
+  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input2), scheduler);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js
+function scheduled(input2, scheduler) {
+  if (input2 != null) {
+    if (isInteropObservable(input2)) {
+      return scheduleObservable(input2, scheduler);
+    }
+    if (isArrayLike(input2)) {
+      return scheduleArray(input2, scheduler);
+    }
+    if (isPromise(input2)) {
+      return schedulePromise(input2, scheduler);
+    }
+    if (isAsyncIterable(input2)) {
+      return scheduleAsyncIterable(input2, scheduler);
+    }
+    if (isIterable(input2)) {
+      return scheduleIterable(input2, scheduler);
+    }
+    if (isReadableStreamLike(input2)) {
+      return scheduleReadableStreamLike(input2, scheduler);
+    }
+  }
+  throw createInvalidObservableTypeError(input2);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/observable/from.js
+function from(input2, scheduler) {
+  return scheduler ? scheduled(input2, scheduler) : innerFrom(input2);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/map.js
+function map(project, thisArg) {
+  return operate(function(source8, subscriber3) {
+    var index2 = 0;
+    source8.subscribe(createOperatorSubscriber(subscriber3, function(value6) {
+      subscriber3.next(project.call(thisArg, value6, index2++));
+    }));
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/util/mapOneOrManyArgs.js
+var isArray = Array.isArray;
+function callOrApply(fn2, args) {
+  return isArray(args) ? fn2.apply(void 0, __spreadArray([], __read(args))) : fn2(args);
+}
+function mapOneOrManyArgs(fn2) {
+  return map(function(args) {
+    return callOrApply(fn2, args);
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js
+function mergeInternals(source8, subscriber3, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+  var buffer = [];
+  var active2 = 0;
+  var index2 = 0;
+  var isComplete = false;
+  var checkComplete = function() {
+    if (isComplete && !buffer.length && !active2) {
+      subscriber3.complete();
+    }
+  };
+  var outerNext = function(value6) {
+    return active2 < concurrent ? doInnerSub(value6) : buffer.push(value6);
+  };
+  var doInnerSub = function(value6) {
+    expand && subscriber3.next(value6);
+    active2++;
+    var innerComplete = false;
+    innerFrom(project(value6, index2++)).subscribe(createOperatorSubscriber(subscriber3, function(innerValue) {
+      onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
+      if (expand) {
+        outerNext(innerValue);
+      } else {
+        subscriber3.next(innerValue);
+      }
+    }, function() {
+      innerComplete = true;
+    }, void 0, function() {
+      if (innerComplete) {
+        try {
+          active2--;
+          var _loop_1 = function() {
+            var bufferedValue = buffer.shift();
+            if (innerSubScheduler) {
+              executeSchedule(subscriber3, innerSubScheduler, function() {
+                return doInnerSub(bufferedValue);
+              });
+            } else {
+              doInnerSub(bufferedValue);
+            }
+          };
+          while (buffer.length && active2 < concurrent) {
+            _loop_1();
+          }
+          checkComplete();
+        } catch (err) {
+          subscriber3.error(err);
+        }
+      }
+    }));
+  };
+  source8.subscribe(createOperatorSubscriber(subscriber3, outerNext, function() {
+    isComplete = true;
+    checkComplete();
+  }));
+  return function() {
+    additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
+  };
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js
+function mergeMap(project, resultSelector, concurrent) {
+  if (concurrent === void 0) {
+    concurrent = Infinity;
+  }
+  if (isFunction(resultSelector)) {
+    return mergeMap(function(a, i) {
+      return map(function(b, ii) {
+        return resultSelector(a, b, i, ii);
+      })(innerFrom(project(a, i)));
+    }, concurrent);
+  } else if (typeof resultSelector === "number") {
+    concurrent = resultSelector;
+  }
+  return operate(function(source8, subscriber3) {
+    return mergeInternals(source8, subscriber3, project, concurrent);
+  });
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/mergeAll.js
+function mergeAll(concurrent) {
+  if (concurrent === void 0) {
+    concurrent = Infinity;
+  }
+  return mergeMap(identity, concurrent);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/observable/fromEvent.js
+var nodeEventEmitterMethods = ["addListener", "removeListener"];
+var eventTargetMethods = ["addEventListener", "removeEventListener"];
+var jqueryMethods = ["on", "off"];
+function fromEvent(target5, eventName, options, resultSelector) {
+  if (isFunction(options)) {
+    resultSelector = options;
+    options = void 0;
+  }
+  if (resultSelector) {
+    return fromEvent(target5, eventName, options).pipe(mapOneOrManyArgs(resultSelector));
+  }
+  var _a = __read(isEventTarget(target5) ? eventTargetMethods.map(function(methodName) {
+    return function(handler) {
+      return target5[methodName](eventName, handler, options);
+    };
+  }) : isNodeStyleEventEmitter(target5) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target5, eventName)) : isJQueryStyleEventEmitter(target5) ? jqueryMethods.map(toCommonHandlerRegistry(target5, eventName)) : [], 2), add2 = _a[0], remove = _a[1];
+  if (!add2) {
+    if (isArrayLike(target5)) {
+      return mergeMap(function(subTarget) {
+        return fromEvent(subTarget, eventName, options);
+      })(innerFrom(target5));
+    }
+  }
+  if (!add2) {
+    throw new TypeError("Invalid event target");
+  }
+  return new Observable(function(subscriber3) {
+    var handler = function() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return subscriber3.next(1 < args.length ? args : args[0]);
+    };
+    add2(handler);
+    return function() {
+      return remove(handler);
+    };
+  });
+}
+function toCommonHandlerRegistry(target5, eventName) {
+  return function(methodName) {
+    return function(handler) {
+      return target5[methodName](eventName, handler);
+    };
+  };
+}
+function isNodeStyleEventEmitter(target5) {
+  return isFunction(target5.addListener) && isFunction(target5.removeListener);
+}
+function isJQueryStyleEventEmitter(target5) {
+  return isFunction(target5.on) && isFunction(target5.off);
+}
+function isEventTarget(target5) {
+  return isFunction(target5.addEventListener) && isFunction(target5.removeEventListener);
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/observable/merge.js
+function merge() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  var scheduler = popScheduler(args);
+  var concurrent = popNumber(args, Infinity);
+  var sources = args;
+  return !sources.length ? EMPTY : sources.length === 1 ? innerFrom(sources[0]) : mergeAll(concurrent)(from(sources, scheduler));
+}
+
+// ../node_modules/rxjs/dist/esm5/internal/operators/tap.js
+function tap(observerOrNext, error4, complete2) {
+  var tapObserver = isFunction(observerOrNext) || error4 || complete2 ? { next: observerOrNext, error: error4, complete: complete2 } : observerOrNext;
+  return tapObserver ? operate(function(source8, subscriber3) {
+    var _a;
+    (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+    var isUnsub = true;
+    source8.subscribe(createOperatorSubscriber(subscriber3, function(value6) {
+      var _a2;
+      (_a2 = tapObserver.next) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, value6);
+      subscriber3.next(value6);
+    }, function() {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      subscriber3.complete();
+    }, function(err) {
+      var _a2;
+      isUnsub = false;
+      (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
+      subscriber3.error(err);
+    }, function() {
+      var _a2, _b;
+      if (isUnsub) {
+        (_a2 = tapObserver.unsubscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+      }
+      (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+    }));
+  }) : identity;
+}
+
 // ../node_modules/@inrupt/solid-client-authn-core/dist/index.mjs
 var import_events = __toESM(require_events(), 1);
 
@@ -9548,8 +11216,8 @@ function checkUsage(key3, usages) {
   if (usages.length && !usages.some((expected) => key3.usages.includes(expected))) {
     let msg = "CryptoKey does not support this operation, its usages must include ";
     if (usages.length > 2) {
-      const last2 = usages.pop();
-      msg += `one of ${usages.join(", ")}, or ${last2}.`;
+      const last3 = usages.pop();
+      msg += `one of ${usages.join(", ")}, or ${last3}.`;
     } else if (usages.length === 2) {
       msg += `one of ${usages[0]} or ${usages[1]}.`;
     } else {
@@ -9619,8 +11287,8 @@ function checkSigCryptoKey(key3, alg, ...usages) {
 // ../node_modules/jose/dist/browser/lib/invalid_key_input.js
 function message(msg, actual2, ...types2) {
   if (types2.length > 2) {
-    const last2 = types2.pop();
-    msg += `one of type ${types2.join(", ")}, or ${last2}.`;
+    const last3 = types2.pop();
+    msg += `one of type ${types2.join(", ")}, or ${last3}.`;
   } else if (types2.length === 2) {
     msg += `one of type ${types2[0]} or ${types2[1]}.`;
   } else {
@@ -10594,6 +12262,54 @@ async function generateKeyPair2(alg, options) {
   return generateKeyPair(alg, options);
 }
 
+// ../node_modules/uuid/dist/esm-browser/rng.js
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+  }
+  return getRandomValues(rnds8);
+}
+
+// ../node_modules/uuid/dist/esm-browser/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset3 = 0) {
+  return byteToHex[arr[offset3 + 0]] + byteToHex[arr[offset3 + 1]] + byteToHex[arr[offset3 + 2]] + byteToHex[arr[offset3 + 3]] + "-" + byteToHex[arr[offset3 + 4]] + byteToHex[arr[offset3 + 5]] + "-" + byteToHex[arr[offset3 + 6]] + byteToHex[arr[offset3 + 7]] + "-" + byteToHex[arr[offset3 + 8]] + byteToHex[arr[offset3 + 9]] + "-" + byteToHex[arr[offset3 + 10]] + byteToHex[arr[offset3 + 11]] + byteToHex[arr[offset3 + 12]] + byteToHex[arr[offset3 + 13]] + byteToHex[arr[offset3 + 14]] + byteToHex[arr[offset3 + 15]];
+}
+
+// ../node_modules/uuid/dist/esm-browser/native.js
+var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native_default = {
+  randomUUID
+};
+
+// ../node_modules/uuid/dist/esm-browser/v4.js
+function v4(options, buf, offset3) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset3 = offset3 || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset3 + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
 // ../node_modules/@inrupt/solid-client-authn-core/dist/index.mjs
 var SOLID_CLIENT_AUTHN_KEY_PREFIX = "solidClientAuthn:";
 var PREFERRED_SIGNING_ALG = ["ES256", "RS256"];
@@ -11280,7 +12996,7 @@ async function registerClient(options, issuerConfig) {
     throw new Error("The OIDC issuer discovery profile is missing the 'id_token_signing_alg_values_supported' value, which is mandatory.");
   }
   const signingAlg = determineSigningAlg(issuerConfig.idTokenSigningAlgValuesSupported, PREFERRED_SIGNING_ALG);
-  const config = {
+  const config2 = {
     /* eslint-disable camelcase */
     client_name: options.clientName,
     application_type: "web",
@@ -11297,7 +13013,7 @@ async function registerClient(options, issuerConfig) {
   const registerResponse = await fetch(issuerConfig.registrationEndpoint.toString(), {
     method: "POST",
     headers,
-    body: JSON.stringify(config)
+    body: JSON.stringify(config2)
   });
   if (registerResponse.ok) {
     const responseBody = await registerResponse.json();
@@ -11794,11 +13510,11 @@ var issuerConfigKeyMap = {
     convertToUrl: true
   }
 };
-function processConfig(config) {
+function processConfig(config2) {
   const parsedConfig = {};
-  Object.keys(config).forEach((key3) => {
+  Object.keys(config2).forEach((key3) => {
     if (issuerConfigKeyMap[key3]) {
-      parsedConfig[issuerConfigKeyMap[key3].toKey] = config[key3];
+      parsedConfig[issuerConfigKeyMap[key3].toKey] = config2[key3];
     }
   });
   if (!Array.isArray(parsedConfig.scopesSupported)) {
@@ -12340,6 +14056,16 @@ var Session = class _Session extends import_events2.default {
   }
 };
 
+// src/authentication/observeSession.ts
+function observeSession(session4) {
+  const sessionInfoSubject = new BehaviorSubject(session4.info);
+  const login = fromEvent(session4.events, EVENTS.LOGIN);
+  const logout = fromEvent(session4.events, EVENTS.LOGOUT);
+  const sessionRestored = fromEvent(session4.events, EVENTS.SESSION_RESTORED);
+  merge(login, logout, sessionRestored).pipe(map(() => sessionInfoSubject.next(session4.info))).subscribe();
+  return sessionInfoSubject;
+}
+
 // src/authentication/index.ts
 var BrowserSession = class {
   get authenticatedFetch() {
@@ -12347,13 +14073,12 @@ var BrowserSession = class {
   }
   constructor() {
     this.session = new Session();
+    this.sessionInfo$ = observeSession(this.session);
     this._authenticatedFetch = this.session.fetch;
   }
-  async handleIncomingRedirect() {
+  async handleIncomingRedirect(restorePreviousSession = false) {
     return this.session.handleIncomingRedirect({
-      // session restore disabled, due to
-      // https://github.com/inrupt/solid-client-authn-js/issues/1647
-      restorePreviousSession: false
+      restorePreviousSession
     });
   }
   async login(oidcIssuer2) {
@@ -12366,12 +14091,21 @@ var BrowserSession = class {
   async logout() {
     return this.session.logout();
   }
+  /**
+   * @deprecated use observeSession instead
+   */
   trackSession(callback) {
-    this.session.onLogin(() => callback(this.session.info));
-    this.session.onLogout(() => callback(this.session.info));
-    this.session.onSessionRestore(() => callback(this.session.info));
+    this.session.on(EVENTS.LOGIN, () => callback(this.session.info));
+    this.session.on(EVENTS.LOGOUT, () => callback(this.session.info));
+    this.session.on(EVENTS.SESSION_RESTORED, () => callback(this.session.info));
     callback(this.session.info);
   }
+  observeSession() {
+    return this.sessionInfo$;
+  }
+  onSessionRestore(callback) {
+    this.session.on(EVENTS.SESSION_RESTORED, callback);
+  }
 };
 
 // src/files/BinaryFile.ts
@@ -12431,7 +14165,7 @@ var FileFetcher = class {
 
 // src/modules/contacts.ts
 async function loadContactsModule(store) {
-  const module2 = await import("./dist-D3HKZNEN.js");
+  const module2 = await import("./dist-762OQHAF.js");
   return new module2.default({
     store: store.graph,
     fetcher: store.fetcher,
@@ -12642,6 +14376,52 @@ var WebIdProfile = class extends Thing {
   }
 };
 
+// src/search/SearchIndex.ts
+var import_lunr = __toESM(require_lunr());
+var SearchIndex = class {
+  constructor(indexes) {
+    this.index = (0, import_lunr.default)(function() {
+      this.ref("uri");
+      this.field("uri");
+      this.field("label");
+      this.metadataWhitelist = ["position"];
+      const items2 = indexes.flatMap((it) => it.getIndexedItems());
+      items2.forEach((item4) => {
+        this.add({
+          uri: item4.uri,
+          label: item4.label
+        });
+      });
+    });
+  }
+  /**
+   * Search the index for a given term. It finds partial matches, but will rank exact matches higher.
+   *
+   * The rank order is:
+   *
+   *  1. exact matches
+   *  2. prefix matches
+   *  3. suffix matches
+   *  4. any matches inside a literal
+   *
+   * @param term The (partial) term to search for
+   * @param maxResults The maximum number of results to return (defaults to 10)
+   */
+  search(term2, maxResults = 10) {
+    const escapedTerm = term2.replace(/[~^+:]/g, (x) => `\\${x}`);
+    return this.index.search(
+      `${escapedTerm}^100 ${escapedTerm}*^20 *${escapedTerm}^10 *${escapedTerm}*^5`
+    ).slice(0, maxResults);
+  }
+  /**
+   * Remove all data from the search index.
+   */
+  clear() {
+    this.index = (0, import_lunr.default)(() => {
+    });
+  }
+};
+
 // src/rdf-document/RdfDocument.ts
 var RdfDocument = class extends Thing {
   constructor(uri6, store, editable = false) {
@@ -12693,52 +14473,6 @@ var LabelIndex = class extends RdfDocument {
   }
 };
 
-// src/search/SearchIndex.ts
-var import_lunr = __toESM(require_lunr());
-var SearchIndex = class {
-  constructor(indexes) {
-    this.index = (0, import_lunr.default)(function() {
-      this.ref("uri");
-      this.field("uri");
-      this.field("label");
-      this.metadataWhitelist = ["position"];
-      const items2 = indexes.flatMap((it) => it.getIndexedItems());
-      items2.forEach((item4) => {
-        this.add({
-          uri: item4.uri,
-          label: item4.label
-        });
-      });
-    });
-  }
-  /**
-   * Search the index for a given term. It finds partial matches, but will rank exact matches higher.
-   *
-   * The rank order is:
-   *
-   *  1. exact matches
-   *  2. prefix matches
-   *  3. suffix matches
-   *  4. any matches inside a literal
-   *
-   * @param term The (partial) term to search for
-   * @param maxResults The maximum number of results to return (defaults to 10)
-   */
-  search(term2, maxResults = 10) {
-    const escapedTerm = term2.replace(/[~^+:]/g, (x) => `\\${x}`);
-    return this.index.search(
-      `${escapedTerm}^100 ${escapedTerm}*^20 *${escapedTerm}^10 *${escapedTerm}*^5`
-    ).slice(0, maxResults);
-  }
-  /**
-   * Remove all data from the search index.
-   */
-  clear() {
-    this.index = (0, import_lunr.default)(() => {
-    });
-  }
-};
-
 // src/Store.ts
 var Store = class {
   constructor(session4) {
@@ -12931,7 +14665,7 @@ var author = "http://www.w3.org/ns/activitystreams#author";
 var bcc = "http://www.w3.org/ns/activitystreams#bcc";
 var bto = "http://www.w3.org/ns/activitystreams#bto";
 var cc = "http://www.w3.org/ns/activitystreams#cc";
-var context = "http://www.w3.org/ns/activitystreams#context";
+var context2 = "http://www.w3.org/ns/activitystreams#context";
 var generator = "http://www.w3.org/ns/activitystreams#generator";
 var icon = "http://www.w3.org/ns/activitystreams#icon";
 var image = "http://www.w3.org/ns/activitystreams#image";
@@ -13049,7 +14783,7 @@ var asImport = /* @__PURE__ */ Object.freeze({
   bcc,
   bto,
   cc,
-  context,
+  context: context2,
   generator,
   icon,
   image,
@@ -13693,7 +15427,7 @@ var testRun = "http://hl7.org/fhir/testRun";
 var SubstanceProtein = "http://hl7.org/fhir/SubstanceProtein";
 var _focalDevice = "http://hl7.org/fhir/_focalDevice";
 var _operationType = "http://hl7.org/fhir/_operationType";
-var context2 = "http://hl7.org/fhir/context";
+var context3 = "http://hl7.org/fhir/context";
 var occurrenceDateTime = "http://hl7.org/fhir/occurrenceDateTime";
 var DetectedIssueEvidenceComponent = "http://hl7.org/fhir/DetectedIssueEvidenceComponent";
 var _ExplanationOfBenefit = "http://hl7.org/fhir/_ExplanationOfBenefit";
@@ -14038,7 +15772,7 @@ var _revenue = "http://hl7.org/fhir/_revenue";
 var _returnedAmount = "http://hl7.org/fhir/_returnedAmount";
 var MedicationKnowledgeDefinitionalIngredientComponent = "http://hl7.org/fhir/MedicationKnowledgeDefinitionalIngredientComponent";
 var candidate = "http://hl7.org/fhir/candidate";
-var Subscription = "http://hl7.org/fhir/Subscription";
+var Subscription2 = "http://hl7.org/fhir/Subscription";
 var relatedAction = "http://hl7.org/fhir/relatedAction";
 var textPresentation = "http://hl7.org/fhir/textPresentation";
 var _supplements = "http://hl7.org/fhir/_supplements";
@@ -14639,7 +16373,7 @@ var rule = "http://hl7.org/fhir/rule";
 var Specimen = "http://hl7.org/fhir/Specimen";
 var _MedicinalProductDefinition = "http://hl7.org/fhir/_MedicinalProductDefinition";
 var OperationDefinition = "http://hl7.org/fhir/OperationDefinition";
-var process = "http://hl7.org/fhir/process";
+var process2 = "http://hl7.org/fhir/process";
 var CitationCitedArtifactContributorshipEntryContributionInstanceComponent = "http://hl7.org/fhir/CitationCitedArtifactContributorshipEntryContributionInstanceComponent";
 var EncounterAdmissionComponent = "http://hl7.org/fhir/EncounterAdmissionComponent";
 var _MedicationDispense = "http://hl7.org/fhir/_MedicationDispense";
@@ -16050,7 +17784,7 @@ var Payee = "http://hl7.org/fhir/Payee";
 var _measurementType = "http://hl7.org/fhir/_measurementType";
 var RelatedArtifact = "http://hl7.org/fhir/RelatedArtifact";
 var RequestOrchestrationActionDynamicValueComponent = "http://hl7.org/fhir/RequestOrchestrationActionDynamicValueComponent";
-var identity = "http://hl7.org/fhir/identity";
+var identity2 = "http://hl7.org/fhir/identity";
 var subType = "http://hl7.org/fhir/subType";
 var ValueSetExpansionContainsComponent = "http://hl7.org/fhir/ValueSetExpansionContainsComponent";
 var MedicationKnowledgePackagingComponent = "http://hl7.org/fhir/MedicationKnowledgePackagingComponent";
@@ -17238,7 +18972,7 @@ var freeToShare = "http://hl7.org/fhir/freeToShare";
 var ElementDefinitionMappingComponent = "http://hl7.org/fhir/ElementDefinitionMappingComponent";
 var copackagedIndicator = "http://hl7.org/fhir/copackagedIndicator";
 var precheckBehavior = "http://hl7.org/fhir/precheckBehavior";
-var map = "http://hl7.org/fhir/map";
+var map2 = "http://hl7.org/fhir/map";
 var additionalInfo = "http://hl7.org/fhir/additionalInfo";
 var preConditions = "http://hl7.org/fhir/preConditions";
 var numberOfSubunits = "http://hl7.org/fhir/numberOfSubunits";
@@ -17926,7 +19660,7 @@ var fhirImport = /* @__PURE__ */ Object.freeze({
   SubstanceProtein,
   _focalDevice,
   _operationType,
-  context: context2,
+  context: context3,
   occurrenceDateTime,
   DetectedIssueEvidenceComponent,
   _ExplanationOfBenefit,
@@ -18271,7 +20005,7 @@ var fhirImport = /* @__PURE__ */ Object.freeze({
   _returnedAmount,
   MedicationKnowledgeDefinitionalIngredientComponent,
   candidate,
-  Subscription,
+  Subscription: Subscription2,
   relatedAction,
   textPresentation,
   _supplements,
@@ -18872,7 +20606,7 @@ var fhirImport = /* @__PURE__ */ Object.freeze({
   Specimen,
   _MedicinalProductDefinition,
   OperationDefinition,
-  process,
+  process: process2,
   CitationCitedArtifactContributorshipEntryContributionInstanceComponent,
   EncounterAdmissionComponent,
   _MedicationDispense,
@@ -20283,7 +22017,7 @@ var fhirImport = /* @__PURE__ */ Object.freeze({
   _measurementType,
   RelatedArtifact,
   RequestOrchestrationActionDynamicValueComponent,
-  identity,
+  identity: identity2,
   subType,
   ValueSetExpansionContainsComponent,
   MedicationKnowledgePackagingComponent,
@@ -21471,7 +23205,7 @@ var fhirImport = /* @__PURE__ */ Object.freeze({
   ElementDefinitionMappingComponent,
   copackagedIndicator,
   precheckBehavior,
-  map,
+  map: map2,
   additionalInfo,
   preConditions,
   numberOfSubunits,
@@ -22203,7 +23937,7 @@ var extension2 = "http://www.w3.org/ns/hydra/core#extension";
 var first = "http://www.w3.org/ns/hydra/core#first";
 var freetextQuery = "http://www.w3.org/ns/hydra/core#freetextQuery";
 var headerName = "http://www.w3.org/ns/hydra/core#headerName";
-var last = "http://www.w3.org/ns/hydra/core#last";
+var last2 = "http://www.w3.org/ns/hydra/core#last";
 var limit2 = "http://www.w3.org/ns/hydra/core#limit";
 var mapping2 = "http://www.w3.org/ns/hydra/core#mapping";
 var member3 = "http://www.w3.org/ns/hydra/core#member";
@@ -22265,7 +23999,7 @@ var hydraImport = /* @__PURE__ */ Object.freeze({
   first,
   freetextQuery,
   headerName,
-  last,
+  last: last2,
   limit: limit2,
   mapping: mapping2,
   member: member3,
@@ -22353,7 +24087,7 @@ var Mailbox = "http://www.w3.org/2007/ont/link#Mailbox";
 var ProtocolEvent = "http://www.w3.org/2007/ont/link#ProtocolEvent";
 var RDFDocument = "http://www.w3.org/2007/ont/link#RDFDocument";
 var Response2 = "http://www.w3.org/2007/ont/link#Response";
-var Session2 = "http://www.w3.org/2007/ont/link#Session";
+var Session3 = "http://www.w3.org/2007/ont/link#Session";
 var isMentionedIn = "http://www.w3.org/2007/ont/link#isMentionedIn";
 var mentionsClass = "http://www.w3.org/2007/ont/link#mentionsClass";
 var protocol2 = "http://www.w3.org/2007/ont/link#protocol";
@@ -22373,7 +24107,7 @@ var linkImport = /* @__PURE__ */ Object.freeze({
   ProtocolEvent,
   RDFDocument,
   Response: Response2,
-  Session: Session2,
+  Session: Session3,
   isMentionedIn,
   mentionsClass,
   protocol: protocol2,
@@ -24403,7 +26137,7 @@ var lyricist = "http://schema.org/lyricist";
 var lyrics = "http://schema.org/lyrics";
 var maintainer = "http://schema.org/maintainer";
 var manufacturer2 = "http://schema.org/manufacturer";
-var map2 = "http://schema.org/map";
+var map3 = "http://schema.org/map";
 var mapType = "http://schema.org/mapType";
 var maps = "http://schema.org/maps";
 var marginOfError = "http://schema.org/marginOfError";
@@ -26771,7 +28505,7 @@ var schemaImport = /* @__PURE__ */ Object.freeze({
   lyrics,
   maintainer,
   manufacturer: manufacturer2,
-  map: map2,
+  map: map3,
   mapType,
   maps,
   marginOfError,
@@ -29141,7 +30875,7 @@ var lyricist2 = "https://schema.org/lyricist";
 var lyrics2 = "https://schema.org/lyrics";
 var maintainer2 = "https://schema.org/maintainer";
 var manufacturer3 = "https://schema.org/manufacturer";
-var map3 = "https://schema.org/map";
+var map4 = "https://schema.org/map";
 var mapType2 = "https://schema.org/mapType";
 var maps2 = "https://schema.org/maps";
 var marginOfError2 = "https://schema.org/marginOfError";
@@ -31509,7 +33243,7 @@ var schema_httpsImport = /* @__PURE__ */ Object.freeze({
   lyrics: lyrics2,
   maintainer: maintainer2,
   manufacturer: manufacturer3,
-  map: map3,
+  map: map4,
   mapType: mapType2,
   maps: maps2,
   marginOfError: marginOfError2,
@@ -32639,7 +34373,7 @@ var Mailbox2 = "http://www.w3.org/2007/ont/link#Mailbox";
 var ProtocolEvent2 = "http://www.w3.org/2007/ont/link#ProtocolEvent";
 var RDFDocument2 = "http://www.w3.org/2007/ont/link#RDFDocument";
 var Response3 = "http://www.w3.org/2007/ont/link#Response";
-var Session3 = "http://www.w3.org/2007/ont/link#Session";
+var Session4 = "http://www.w3.org/2007/ont/link#Session";
 var isMentionedIn2 = "http://www.w3.org/2007/ont/link#isMentionedIn";
 var mentionsClass2 = "http://www.w3.org/2007/ont/link#mentionsClass";
 var protocol3 = "http://www.w3.org/2007/ont/link#protocol";
@@ -32659,7 +34393,7 @@ var tabImport = /* @__PURE__ */ Object.freeze({
   ProtocolEvent: ProtocolEvent2,
   RDFDocument: RDFDocument2,
   Response: Response3,
-  Session: Session3,
+  Session: Session4,
   isMentionedIn: isMentionedIn2,
   mentionsClass: mentionsClass2,
   protocol: protocol3,
@@ -32681,7 +34415,7 @@ var Mailbox3 = "http://www.w3.org/2007/ont/link#Mailbox";
 var ProtocolEvent3 = "http://www.w3.org/2007/ont/link#ProtocolEvent";
 var RDFDocument3 = "http://www.w3.org/2007/ont/link#RDFDocument";
 var Response4 = "http://www.w3.org/2007/ont/link#Response";
-var Session4 = "http://www.w3.org/2007/ont/link#Session";
+var Session5 = "http://www.w3.org/2007/ont/link#Session";
 var isMentionedIn3 = "http://www.w3.org/2007/ont/link#isMentionedIn";
 var mentionsClass3 = "http://www.w3.org/2007/ont/link#mentionsClass";
 var protocol4 = "http://www.w3.org/2007/ont/link#protocol";
@@ -32701,7 +34435,7 @@ var tabontImport = /* @__PURE__ */ Object.freeze({
   ProtocolEvent: ProtocolEvent3,
   RDFDocument: RDFDocument3,
   Response: Response4,
-  Session: Session4,
+  Session: Session5,
   isMentionedIn: isMentionedIn3,
   mentionsClass: mentionsClass3,
   protocol: protocol4,
@@ -33175,11 +34909,26 @@ var PodOS = class {
   constructor() {
     this.session = new BrowserSession();
     this.store = new Store(this.session);
+    this.flagAuthorizationMetaDataOnSessionChange();
     this.uriService = new UriService(this.store);
     this.fileFetcher = new FileFetcher(this.session);
   }
-  handleIncomingRedirect() {
-    this.session.handleIncomingRedirect();
+  /*
+       Flagging authorization metadata is necessary every time the user
+       logs in or out, so that metadata from previous requests is outdated
+       and not considered to determine whether a resource is editable anymore.
+  
+       See: https://github.com/linkeddata/rdflib.js/pull/512
+    */
+  flagAuthorizationMetaDataOnSessionChange() {
+    this.session.observeSession().pipe(
+      tap(() => {
+        this.store.updater.flagAuthorizationMetadata();
+      })
+    ).subscribe();
+  }
+  handleIncomingRedirect(restorePreviousSession = false) {
+    this.session.handleIncomingRedirect(restorePreviousSession);
   }
   fetch(uri6) {
     return this.store.fetch(uri6);
@@ -33202,12 +34951,28 @@ var PodOS = class {
   proposeUriForNewThing(referenceUri, name7) {
     return this.uriService.proposeUriForNewThing(referenceUri, name7);
   }
+  /**
+   * @deprecated use observeSession instead
+   * @param callback
+   */
   trackSession(callback) {
     return this.session.trackSession((session4) => {
-      this.store.updater.flagAuthorizationMetadata();
       callback(session4);
     });
   }
+  /**
+   * returns a behavior subject that can be used to observe changes in the session state
+   */
+  observeSession() {
+    return this.session.observeSession();
+  }
+  /**
+   * Calls the provided callback with the original URL that was open before the silent auth redirect
+   * @param callback
+   */
+  onSessionRestore(callback) {
+    this.session.onSessionRestore(callback);
+  }
   /**
    * Fetch the WebId profile and preferences file for the given WebID
    * @param webId