@aerogel/plugin-solid 0.0.1-next.04142b2821eaa6e510478867fc4e63149b6ae8c9

package/dist/aerogel-plugin-solid.js

@@ -0,0 +1,620 @@
+var X = Object.defineProperty;
+var Z = (n, e, t) => e in n ? X(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var a = (n, e, t) => Z(n, typeof e != "symbol" ? e + "" : e, t);
+import { persistent as ee, defineServiceState as te, Events as d, UI as I, translateWithDefault as l, App as g, Storage as ie, Errors as D, defineFormValidationRule as ne, computedAsync as re, Cache as P, useForm as se, requiredStringInput as oe, Form as ae, Input as le, Button as O, registerErrorHandler as ce, bootServices as ue } from "@aerogel/core";
+import { SolidEngine as he, SolidTypeIndex as m, SolidContainer as A, SolidACLAuthorization as de, SolidDocument as ge, bootSolidModels as fe } from "soukai-solid";
+import { JSError as R, arr as me, fail as S, PromisedValue as pe, Storage as L, after as F, required as M, facade as we, tap as x, arrayUnique as z, objectWithout as W, isDevelopment as ye, asyncMemo as B, hasLocationQueryParameter as w, getLocationQueryParameter as E, arrayFilter as Se, setAsyncMemo as j, urlRoot as ve, requireUrlParse as be, objectWithoutEmpty as Ie, parseBoolean as V, arrayWithout as Pe } from "@noeldemartin/utils";
+import { fetchLoginUserProfile as Ae } from "@noeldemartin/solid-utils";
+import { setEngine as Le } from "soukai";
+import y from "virtual:aerogel-solid";
+import { markRaw as xe, createElementBlock as v, openBlock as h, createElementVNode as _, defineComponent as $, unref as u, computed as H, createBlock as p, toDisplayString as T, withCtx as U, createVNode as Ee, createTextVNode as N } from "vue";
+class _e extends R {
+}
+function Ue(n, e) {
+  return n;
+}
+class b extends R {
+  constructor(t, i, r) {
+    super(Ue(t), r);
+    a(this, "description");
+    this.description = i;
+  }
+}
+class Ce extends R {
+  constructor(e, t) {
+    super(`Container at ${e.url} is already in use`, t);
+  }
+}
+class Q {
+  constructor() {
+    a(this, "name");
+    a(this, "authenticatedFetch");
+    a(this, "booted");
+    a(this, "listeners", me([]));
+    a(this, "_engine");
+  }
+  get engine() {
+    return this._engine = this._engine ?? new he(this.requireAuthenticatedFetch()), this._engine;
+  }
+  getAuthenticatedFetch() {
+    return this.authenticatedFetch ?? null;
+  }
+  requireAuthenticatedFetch() {
+    return this.authenticatedFetch ?? S("Authenticated fetch is not ready");
+  }
+  addListener(e) {
+    return this.listeners.includes(e) || this.listeners.push(e), () => {
+      this.removeListener(e);
+    };
+  }
+  removeListener(e) {
+    this.listeners.includes(e) && this.listeners.remove(e);
+  }
+  async boot() {
+    if (this.booted)
+      return this.booted;
+    this.booted = new pe(), await this.restoreSession(), this.booted.resolve();
+  }
+  async initAuthenticatedFetch(e) {
+    this.authenticatedFetch = e, await this.notifyListeners("onAuthenticatedFetchReady", e);
+  }
+  async startSession(e) {
+    const t = {
+      authenticator: this,
+      ...e
+    };
+    return await this.notifyListeners("onSessionStarted", t), t;
+  }
+  async failSession(e, t) {
+    await this.notifyListeners("onSessionFailed", e, t);
+  }
+  async endSession() {
+    await this.notifyListeners("onSessionEnded");
+  }
+  async notifyListeners(e, ...t) {
+    await Promise.all(
+      this.listeners.toArray().map(async (i) => {
+        const r = i[e];
+        await (r == null ? void 0 : r(...t));
+      })
+    );
+  }
+}
+const C = "inrupt-authenticator";
+class Te extends Q {
+  constructor() {
+    super(...arguments);
+    a(this, "_events");
+    a(this, "_fetch");
+    a(this, "_login");
+    a(this, "_logout");
+    a(this, "_handleIncomingRedirect");
+  }
+  async login(t) {
+    L.set(C, t);
+    const i = {
+      oidcIssuer: t
+    };
+    return y.clientID && (i.clientId = y.clientID.client_id, i.clientName = y.clientID.client_name, i.redirectUrl = y.clientID.redirect_uris[0]), await this._login(i), await F({ seconds: 60 }), S("Browser should have redirected, but it didn't");
+  }
+  async logout() {
+    await this._logout(), await this.endSession();
+  }
+  async restoreSession() {
+    const { events: t, fetch: i, handleIncomingRedirect: r, login: s, logout: c } = await import("./InruptAuthenticator.lazy-BvpQLGoj.js");
+    this._fetch = i, this._login = s, this._logout = c, this._events = t, this._handleIncomingRedirect = r, await this.loginFromRedirect();
+  }
+  async loginFromRedirect() {
+    const t = L.get(C);
+    if (!t)
+      return;
+    this._events().on("error", (r, s) => {
+      r ?? (r = "Error using Inrupt Authenticator method"), typeof s == "object" ? this.failSession(t, new b(r, null, { cause: s })) : this.failSession(t, new b(r, s));
+    });
+    const i = await this._handleIncomingRedirect(globalThis.location.href);
+    L.remove(C), i != null && i.isLoggedIn && i.webId && await this.initSession(i.webId);
+  }
+  async initSession(t) {
+    await this.initAuthenticatedFetch(this._fetch);
+    try {
+      const i = await f.requireUserProfile(t);
+      await this.startSession({ user: i, loginUrl: t });
+    } catch (i) {
+      await this.failSession(t, i);
+    }
+  }
+}
+class Re extends Q {
+  constructor() {
+    super();
+    a(this, "store");
+    this.store = ee("legacy-authenticator", {});
+  }
+  async login(t, i) {
+    const { SolidAuthClient: r } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js");
+    throw this.store.webId = i == null ? void 0 : i.webId, this.store.loginUrl = (i == null ? void 0 : i.oidcIssuerUrl) ?? t, await r.login(this.store.loginUrl) === null ? (delete this.store.webId, delete this.store.loginUrl, new b("Could not log in with Solid using the legacy authenticator")) : (await F({ seconds: 60 }), new Error("Browser should have redirected, but it didn't"));
+  }
+  async logout() {
+    const { SolidAuthClient: t } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js");
+    delete this.store.webId, delete this.store.loginUrl, await t.logout(), await this.endSession();
+  }
+  async restoreSession() {
+    if (!this.store.loginUrl)
+      return;
+    const { SolidAuthClient: t } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js"), i = await t.currentSession(), r = M(this.store.loginUrl);
+    await this.initAuthenticatedFetch((s, c) => t.fetch(s, c));
+    try {
+      const s = await f.requireUserProfile(M((i == null ? void 0 : i.webId) ?? this.store.webId));
+      await this.startSession({ user: s, loginUrl: r });
+    } catch (s) {
+      await this.failSession(r, s);
+    }
+  }
+}
+const q = {}, Fe = {
+  inrupt: new Te(),
+  legacy: new Re()
+};
+function $e(n) {
+  q.default = n;
+}
+function Y(n) {
+  return q[n];
+}
+function qe(n) {
+  Object.entries(n).forEach(([e, t]) => ke(e, t));
+}
+function ke(n, e) {
+  q[n] = e, e.name = e.name ?? n;
+}
+const k = { autoReconnect: !0 }, De = te({
+  name: "solid",
+  persist: ["autoReconnect", "dismissed", "previousSession", "profiles", "staleProfiles"],
+  initialState: {
+    autoReconnect: k.autoReconnect,
+    dismissed: !1,
+    ignorePreviousSessionError: !1,
+    loginStartupError: null,
+    loginOngoing: !1,
+    preferredAuthenticator: null,
+    previousSession: null,
+    profiles: {},
+    session: null,
+    loginStale: !1,
+    staleProfiles: []
+  },
+  serialize(n) {
+    var e;
+    return ((e = n.previousSession) == null ? void 0 : e.error) instanceof Error && (n.previousSession.error = n.previousSession.error.message), n;
+  },
+  computed: {
+    user: (n) => {
+      var e, t;
+      return ((e = n.session) == null ? void 0 : e.user) ?? ((t = n.previousSession) == null ? void 0 : t.profile) ?? null;
+    },
+    authenticator: (n) => {
+      var e;
+      return ((e = n.session) == null ? void 0 : e.authenticator) ?? null;
+    },
+    fetch() {
+      var n;
+      return ((n = this.authenticator) == null ? void 0 : n.getAuthenticatedFetch()) ?? globalThis.fetch.bind(globalThis);
+    },
+    error(n) {
+      var e;
+      return n.loginStartupError ? n.loginStartupError ?? null : n.ignorePreviousSessionError ? null : ((e = n.previousSession) == null ? void 0 : e.error) ?? null;
+    }
+  }
+});
+class Oe extends De {
+  isLoggedIn() {
+    return !!this.session;
+  }
+  wasLoggedIn() {
+    return !!this.previousSession;
+  }
+  hasLoggedIn() {
+    return !!(this.session || this.previousSession);
+  }
+  requireAuthenticator() {
+    return this.authenticator ?? S("Could not get authenticator");
+  }
+  requireUser() {
+    return this.user ?? S("Could not get user profile (are you logged in?)");
+  }
+  requireUserProfile(e) {
+    return this.getUserProfile(e, { required: !0 });
+  }
+  /* eslint-enable max-len */
+  async getUserProfile(e, t = {}) {
+    var c;
+    let i = null;
+    const r = t.markStale ?? !((c = this.authenticator) != null && c.getAuthenticatedFetch()), s = this.profiles[e] ?? await x(
+      await Ae(e, {
+        fetch: this.fetch,
+        required: t.required ?? !1,
+        onLoaded(o) {
+          i = o;
+        }
+      }),
+      async (o) => {
+        o && (i && await d.emit("solid:user-profile-loaded", [o, i]), this.rememberProfile(o));
+      }
+    );
+    return s && r && this.setState({ staleProfiles: z(this.staleProfiles.concat([s.webId])) }), s;
+  }
+  async refreshUserProfile() {
+    if (!this.isLoggedIn())
+      return;
+    this.setState({ profiles: W(this.profiles, [this.user.webId]) });
+    const e = await this.requireUserProfile(this.user.webId);
+    this.setState({
+      session: {
+        ...this.session,
+        user: e
+      }
+    });
+  }
+  async login(e, t = {}) {
+    if (ye() && e === "dev" && (e = "http://localhost:3000"), /^https?:\/\//.test(e) || (t.fallbackUrl ?? (t.fallbackUrl = `http://${e}`), e = `https://${e}`), this.isLoggedIn())
+      return !0;
+    if (this.loginOngoing)
+      throw new Error("Authentication already in progress");
+    return t.loading ? I.loading(l("solid.loggingIn", "Logging in..."), () => this.attemptLogin(e, t)) : this.attemptLogin(e, t);
+  }
+  async reconnect(e = {}) {
+    const { force: t, ...i } = e;
+    this.isLoggedIn() || !this.previousSession || this.previousSession.error !== null && !t || await this.login(this.previousSession.loginUrl, {
+      authenticator: this.previousSession.authenticator,
+      ...i,
+      loading: i.loading ?? !1
+    });
+  }
+  async logout(e = !1) {
+    var c, o;
+    const t = !g.plugin("@aerogel/local-first") || !!((c = g.service("$cloud")) != null && c.ready), i = !g.plugin("@aerogel/local-first") || !!((o = g.service("$cloud")) != null && o.dirty), [r, s] = e ? [!0, { wipeLocalData: t }] : await I.confirm(
+      t ? l("solid.logoutConfirmTitle", "Log out from this device?") : l("solid.disconnectConfirmTitle", "Disconnect account?"),
+      t ? i ? l(
+        "solid.logoutConfirmMessageWithLocalChanges",
+        "There are some changes that haven't been synchronized and will be lost, but the rest of the data will remain in your Solid POD."
+      ) : l(
+        "solid.logoutConfirmMessage",
+        "Logging out will remove all the data from this device, but you'll still have it in your Solid POD."
+      ) : l(
+        "solid.disconnectConfirmMessage",
+        "You'll need to introduce your credentials again to connect to your Solid POD."
+      ),
+      {
+        acceptText: l("solid.logoutConfirmAccept", "Log out"),
+        acceptVariant: "danger",
+        cancelText: l(
+          "solid.logoutConfirmCancel",
+          l("ui.cancel", "Cancel")
+        ),
+        checkboxes: t ? i ? {
+          wipeLocalData: {
+            label: l(
+              "solid.logoutConfirmWipeNotice",
+              "I understand that changes that haven't been synchronized will be lost."
+            ),
+            default: !1,
+            required: !0
+          }
+        } : void 0 : {
+          wipeLocalData: {
+            label: l(
+              "solid.logoutConfirmWipe",
+              "Also remove all existing data"
+            ),
+            default: !1
+          }
+        }
+      }
+    );
+    r && this.previousSession && await I.loading(l("solid.logoutOngoing", "Logging out..."), async () => {
+      this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !1,
+        loginStartupError: null,
+        previousSession: null,
+        ...k
+      }), this.isLoggedIn() && await this.authenticator.logout(), (s.wipeLocalData ?? !0) && await ie.purge(), await d.emit("auth:logout"), await d.emit("auth:after-logout");
+    });
+  }
+  async whenLoggedIn(e) {
+    return this.isLoggedIn() ? e(this.session) : new Promise((t) => {
+      const i = (r) => t(e(r));
+      d.once("auth:login", i);
+    });
+  }
+  dismiss() {
+    this.setState({ dismissed: !0 });
+  }
+  async findOrCreatePrivateTypeIndex() {
+    return await this.findPrivateTypeIndex() ?? await this.createPrivateTypeIndex();
+  }
+  async findPrivateTypeIndex() {
+    const { webId: e, privateTypeIndexUrl: t } = this.requireUser(), i = this.requireAuthenticator().engine;
+    return t ? B(`${e}-privateTypeIndex`, () => m.withEngine(i).find(t)) : null;
+  }
+  async findOrCreatePublicTypeIndex() {
+    return await this.findPublicTypeIndex() ?? await this.createPublicTypeIndex();
+  }
+  async findPublicTypeIndex() {
+    const { webId: e, publicTypeIndexUrl: t } = this.requireUser(), i = this.requireAuthenticator().engine;
+    return t ? B(`${e}-publicTypeIndex`, () => m.withEngine(i).find(t)) : null;
+  }
+  async createPrivateContainer(e) {
+    const t = this.requireAuthenticator().engine;
+    return A.withEngine(t, async () => {
+      const i = await A.find(e.url);
+      if (i && !e.reuseExisting)
+        throw new Ce(i);
+      const r = i ?? new A({ url: e.url, name: e.name });
+      if (await r.save(), e.registerFor) {
+        const s = await this.findOrCreatePrivateTypeIndex();
+        await r.register(s, e.registerFor);
+      }
+      return r;
+    });
+  }
+  async boot() {
+    var e, t;
+    await D.booted, w("authenticator") && this.setState({
+      preferredAuthenticator: E("authenticator")
+    }), w("refreshProfile") && this.setState({
+      staleProfiles: z(
+        this.staleProfiles.concat(Se([(e = this.session) == null ? void 0 : e.user.webId, (t = this.previousSession) == null ? void 0 : t.loginUrl]))
+      )
+    }), await this.restorePreviousSession(), await this.startupReconnect();
+  }
+  async createPrivateTypeIndex() {
+    const e = this.requireUser(), t = this.requireAuthenticator(), i = await m.withEngine(t.engine).createPrivate(e);
+    return x(i, () => {
+      e.privateTypeIndexUrl = i.url, j(`${e.webId}-privateTypeIndex`, i), this.rememberProfile(e);
+    });
+  }
+  async createPublicTypeIndex() {
+    const e = this.requireUser(), t = this.requireAuthenticator(), i = await m.withEngine(t.engine).createPublic(e);
+    return x(i, () => {
+      e.privateTypeIndexUrl = i.url, j(`${e.webId}-publicTypeIndex`, i), this.rememberProfile(e);
+    });
+  }
+  async attemptLogin(e, t) {
+    const i = t.authenticator ?? this.preferredAuthenticator ?? "default", r = t.onError ?? ((o) => g.isMounted() ? D.report(o) : this.setState({ loginStartupError: o })), s = setTimeout(() => this.loginStale = !0, 1e4), c = {
+      dismissed: this.dismissed,
+      ignorePreviousSessionError: this.ignorePreviousSessionError,
+      previousSession: this.previousSession
+    };
+    this.loginOngoing = !0;
+    try {
+      const o = await this.getUserProfile(e, { markStale: !0 }), G = (o == null ? void 0 : o.oidcIssuerUrl) ?? ve((o == null ? void 0 : o.webId) ?? e), J = await this.bootAuthenticator(i), { domain: K } = be(e);
+      return this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !0,
+        previousSession: Ie({
+          profile: o,
+          loginUrl: e,
+          authenticator: i,
+          error: l(
+            "auth.stuckConnecting",
+            `We didn't hear back from the identity provider at \`${K}\`, maybe try reconnecting?`
+          )
+        })
+      }), await d.emit("auth:before-login"), await J.login(G, o), !0;
+    } catch (o) {
+      return this.setState(c), o instanceof _e ? !1 : t.fallbackUrl ? F().then(() => this.login(t.fallbackUrl ?? "", W(t, "fallbackUrl"))) : (r(o), !1);
+    } finally {
+      clearTimeout(s), this.setState({
+        loginOngoing: !1,
+        loginStale: !1
+      });
+    }
+  }
+  async restorePreviousSession() {
+    this.previousSession && await this.bootAuthenticator(this.previousSession.authenticator);
+  }
+  async startupReconnect() {
+    this.reconnectOnStartup() && await this.reconnect({ force: this.forcingReconnect() });
+  }
+  reconnectOnStartup() {
+    return w("autoReconnect") ? V(E("autoReconnect")) : this.autoReconnect;
+  }
+  forcingReconnect() {
+    return w("autoReconnect") && V(E("autoReconnect"));
+  }
+  async bootAuthenticator(e) {
+    const t = Y(e);
+    return t.addListener({
+      onSessionStarted: async (i) => {
+        this.setState({
+          session: i,
+          previousSession: {
+            authenticator: t.name,
+            loginUrl: i.loginUrl,
+            profile: i.user,
+            error: null
+          }
+        }), this.staleProfiles.includes(i.user.webId) && await this.refreshUserProfile(), g.plugin("@aerogel/local-first") || Le(i.authenticator.engine), de.setEngine(i.authenticator.engine), m.setEngine(i.authenticator.engine), ge.setEngine(i.authenticator.engine), await d.emit("auth:login", i);
+      },
+      onSessionFailed: async (i, r) => {
+        var s;
+        this.setState({
+          session: null,
+          previousSession: {
+            profile: (s = this.previousSession) == null ? void 0 : s.profile,
+            authenticator: t.name,
+            loginUrl: i,
+            error: r
+          }
+        });
+      },
+      onSessionEnded: () => this.setState({ session: null }),
+      onAuthenticatedFetchReady: (i) => d.emit("auth:fetch-ready", i)
+    }), await t.boot(), t;
+  }
+  rememberProfile(e) {
+    this.setState({
+      profiles: {
+        ...this.profiles,
+        [e.webId]: e
+      },
+      staleProfiles: Pe(this.staleProfiles, e.webId)
+    });
+  }
+}
+const f = we(Oe);
+function Me() {
+  ne("container_url", (n) => {
+    if (!n.endsWith("/"))
+      return "containerEndingSlashMissing";
+  });
+}
+const ze = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function We(n, e) {
+  return h(), v("svg", ze, e[0] || (e[0] = [
+    _("path", {
+      fill: "currentColor",
+      d: "M15 2H5L4 8h12zM0 10s2 1 10 1s10-1 10-1l-4-2H4zm8 4h4v1H8z"
+    }, null, -1),
+    _("circle", {
+      cx: "6",
+      cy: "15",
+      r: "3",
+      fill: "currentColor"
+    }, null, -1),
+    _("circle", {
+      cx: "14",
+      cy: "15",
+      r: "3",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const Be = xe({ name: "ooui-user-anonymous", render: We }), je = ["src"], Ve = /* @__PURE__ */ $({
+  __name: "SolidImage",
+  props: {
+    src: {}
+  },
+  setup(n) {
+    const e = re(async () => {
+      const i = await P.get(n.src) ?? await t(n.src), r = await (i == null ? void 0 : i.blob());
+      return r && URL.createObjectURL(r);
+    });
+    async function t(i) {
+      try {
+        const r = await f.fetch(i);
+        return r.status !== 200 ? null : (await P.store(i, r), P.get(i));
+      } catch {
+        return null;
+      }
+    }
+    return (i, r) => (h(), v("img", { src: u(e) }, null, 8, je));
+  }
+}), Ne = { class: "relative flex items-center justify-center rounded-full bg-gray-200" }, He = {
+  key: 1,
+  class: "text-sm font-semibold tracking-wider text-gray-500",
+  "aria-hidden": "true"
+}, it = /* @__PURE__ */ $({
+  __name: "SolidAvatar",
+  setup(n) {
+    const e = H(() => {
+      var i;
+      return (((i = f.user) == null ? void 0 : i.name) ?? "").trim().split(" ").map((r) => {
+        var s;
+        return (s = r[0]) == null ? void 0 : s.toUpperCase();
+      }).join("").slice(0, 3);
+    });
+    return (t, i) => {
+      var r, s;
+      return h(), v("div", Ne, [
+        (r = t.$solid.user) != null && r.avatarUrl ? (h(), p(Ve, {
+          key: 0,
+          src: (s = t.$solid.user) == null ? void 0 : s.avatarUrl,
+          alt: "",
+          class: "absolute inset-0 size-full rounded-full"
+        }, null, 8, ["src"])) : e.value ? (h(), v("span", He, T(e.value), 1)) : (h(), p(u(Be), {
+          key: 2,
+          class: "size-6 text-gray-500"
+        }))
+      ]);
+    };
+  }
+}), nt = /* @__PURE__ */ $({
+  __name: "SolidLogin",
+  setup(n) {
+    const e = se({ url: oe() }), t = H(
+      () => g.development && (!e.url || e.url === "dev" || e.url.trim().length === 0)
+    );
+    return (i, r) => (h(), p(u(ae), {
+      form: u(e),
+      class: "flex flex-col items-center gap-2 md:flex-row",
+      onSubmit: r[1] || (r[1] = (s) => i.$solid.login(u(e).url))
+    }, {
+      default: U(() => [
+        Ee(u(le), {
+          name: "url",
+          "aria-label": i.$td("solid.logIn.label", "Login url"),
+          placeholder: i.$td("solid.logIn.placeholder", "https://me.solidcommunity.net"),
+          class: "w-96 max-w-full"
+        }, null, 8, ["aria-label", "placeholder"]),
+        t.value ? (h(), p(u(O), {
+          key: 0,
+          submit: "",
+          class: "w-full whitespace-nowrap md:w-auto",
+          onClick: r[0] || (r[0] = (s) => u(e).url = "dev")
+        }, {
+          default: U(() => [
+            N(T(i.$td("solid.logIn.dev", "Log in to dev server")), 1)
+          ]),
+          _: 1
+        })) : (h(), p(u(O), {
+          key: 1,
+          submit: "",
+          class: "w-full md:w-auto"
+        }, {
+          default: U(() => [
+            N(T(i.$td("solid.logIn.submit", "Log in")), 1)
+          ]),
+          _: 1
+        }))
+      ]),
+      _: 1
+    }, 8, ["form"]));
+  }
+}), Qe = { $solid: f };
+function rt(n = {}) {
+  return {
+    async install(e) {
+      fe(), qe({ ...Fe, ...n.authenticators ?? {} }), Me(), $e(Y(n.defaultAuthenticator ?? "inrupt")), ce((t) => {
+        if (t instanceof b)
+          return t.description ? `${t.message} (${t.description})` : t.message;
+      }), typeof n.autoReconnect == "boolean" && (k.autoReconnect = n.autoReconnect, f.hasPersistedState() || (f.autoReconnect = n.autoReconnect)), n.onUserProfileLoaded && d.on("solid:user-profile-loaded", ([t, i]) => {
+        var r;
+        (r = n.onUserProfileLoaded) == null || r.call(n, t, i);
+      }), await ue(e, Qe);
+    }
+  };
+}
+export {
+  _e as AuthenticationCancelledError,
+  b as AuthenticationFailedError,
+  Q as Authenticator,
+  Ce as ContainerAlreadyInUse,
+  f as Solid,
+  it as SolidAvatar,
+  Ve as SolidImage,
+  nt as SolidLogin,
+  Oe as SolidService,
+  Fe as authenticators,
+  rt as default,
+  Y as getAuthenticator,
+  ke as registerAuthenticator,
+  qe as registerAuthenticators,
+  $e as setDefaultAuthenticator
+};
+//# sourceMappingURL=aerogel-plugin-solid.js.map