solid-logic 4.0.8-3 → 5.0.0

package/dist/solid-logic.esm.js

@@ -0,0 +1,2358 @@
+import { Session as __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_144ab6cc_Session__ } from "@uvdsl/solid-oidc-client-browser";
+import * as __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_core_9566af4e__ from "@uvdsl/solid-oidc-client-browser/core";
+import * as __WEBPACK_EXTERNAL_MODULE_rdflib__ from "rdflib";
+/******/ var __webpack_modules__ = ({
+
+/***/ 386
+(module) {
+
+/**
+ * Provides a way to access commonly used namespaces
+ *
+ * Usage:
+ *
+ *   ```
+ *   const $rdf = require('rdflib'); //or any other RDF/JS-compatible library
+ *   const ns = require('solid-namespace')($rdf);
+ *   const store = $rdf.graph();
+ *
+ *   let me = ...;
+ *   let name = store.any(me, ns.vcard(‘fn’)) || store.any(me, ns.foaf(‘name’));
+ *   ```
+ * @module vocab
+ */
+const aliases = {
+  acl: 'http://www.w3.org/ns/auth/acl#',
+  arg: 'http://www.w3.org/ns/pim/arg#',
+  as: 'https://www.w3.org/ns/activitystreams#',
+  bookmark: 'http://www.w3.org/2002/01/bookmark#',
+  cal: 'http://www.w3.org/2002/12/cal/ical#',
+  cco: 'http://www.ontologyrepository.com/CommonCoreOntologies/',
+  cert: 'http://www.w3.org/ns/auth/cert#',
+  contact: 'http://www.w3.org/2000/10/swap/pim/contact#',
+  dc: 'http://purl.org/dc/elements/1.1/',
+  dct: 'http://purl.org/dc/terms/',
+  doap: 'http://usefulinc.com/ns/doap#',
+  foaf: 'http://xmlns.com/foaf/0.1/',
+  geo: 'http://www.w3.org/2003/01/geo/wgs84_pos#',
+  gpx: 'http://www.w3.org/ns/pim/gpx#',
+  gr: 'http://purl.org/goodrelations/v1#',
+  http: 'http://www.w3.org/2007/ont/http#',
+  httph: 'http://www.w3.org/2007/ont/httph#',
+  icalTZ: 'http://www.w3.org/2002/12/cal/icaltzd#', // Beware: not cal:
+  ldp: 'http://www.w3.org/ns/ldp#',
+  link: 'http://www.w3.org/2007/ont/link#',
+  log: 'http://www.w3.org/2000/10/swap/log#',
+  meeting: 'http://www.w3.org/ns/pim/meeting#',
+  mo: 'http://purl.org/ontology/mo/',
+  org: 'http://www.w3.org/ns/org#',
+  owl: 'http://www.w3.org/2002/07/owl#',
+  pad: 'http://www.w3.org/ns/pim/pad#',
+  patch: 'http://www.w3.org/ns/pim/patch#',
+  prov: 'http://www.w3.org/ns/prov#',
+  pto: 'http://www.productontology.org/id/',
+  qu: 'http://www.w3.org/2000/10/swap/pim/qif#',
+  trip: 'http://www.w3.org/ns/pim/trip#',
+  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  rss: 'http://purl.org/rss/1.0/',
+  sched: 'http://www.w3.org/ns/pim/schedule#',
+  schema: 'http://schema.org/', // @@ beware confusion with documents no 303
+  sioc: 'http://rdfs.org/sioc/ns#',
+  skos: 'http://www.w3.org/2004/02/skos/core#',
+  solid: 'http://www.w3.org/ns/solid/terms#',
+  space: 'http://www.w3.org/ns/pim/space#',
+  stat: 'http://www.w3.org/ns/posix/stat#',
+  tab: 'http://www.w3.org/2007/ont/link#',
+  tabont: 'http://www.w3.org/2007/ont/link#',
+  ui: 'http://www.w3.org/ns/ui#',
+  vann: 'http://purl.org/vocab/vann/',
+  vcard: 'http://www.w3.org/2006/vcard/ns#',
+  wf: 'http://www.w3.org/2005/01/wf/flow#',
+  xsd: 'http://www.w3.org/2001/XMLSchema#',
+}
+
+/**
+ * @param [rdflib] {RDF} Optional RDF Library (such as rdflib.js or rdf-ext) to inject
+ */
+function vocab (rdf = { namedNode: u => u }) {
+  const namespaces = {}
+  for (const alias in aliases) {
+    const expansion = aliases[alias]
+    namespaces[alias] = function (localName = '') {
+      return rdf.namedNode(expansion + localName)
+    }
+  };
+
+  return namespaces
+};
+
+module.exports = vocab
+
+
+/***/ }
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/ 
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ 	// Check if module is in cache
+/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 	if (cachedModule !== undefined) {
+/******/ 		return cachedModule.exports;
+/******/ 	}
+/******/ 	// Create a new module (and put it into the cache)
+/******/ 	var module = __webpack_module_cache__[moduleId] = {
+/******/ 		// no module.id needed
+/******/ 		// no module.loaded needed
+/******/ 		exports: {}
+/******/ 	};
+/******/ 
+/******/ 	// Execute the module function
+/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 
+/******/ 	// Return the exports of the module
+/******/ 	return module.exports;
+/******/ }
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = (module) => {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			() => (module['default']) :
+/******/ 			() => (module);
+/******/ 		__webpack_require__.d(getter, { a: getter });
+/******/ 		return getter;
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/global */
+/******/ (() => {
+/******/ 	__webpack_require__.g = (function() {
+/******/ 		if (typeof globalThis === 'object') return globalThis;
+/******/ 		try {
+/******/ 			return this || new Function('return this')();
+/******/ 		} catch (e) {
+/******/ 			if (typeof window === 'object') return window;
+/******/ 		}
+/******/ 	})();
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/************************************************************************/
+
+;// ./src/util/debug.ts
+function log(...args) {
+    console.log(...args);
+}
+function warn(...args) {
+    console.warn(...args);
+}
+function error(...args) {
+    console.error(...args);
+}
+function trace(...args) {
+    console.trace(...args);
+}
+
+;// external "@uvdsl/solid-oidc-client-browser"
+
+;// external "@uvdsl/solid-oidc-client-browser/core"
+const core_namespaceObject = __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_core_9566af4e__;
+;// ./src/authSession/session.ts
+/**
+ * OIDC session factory.
+ *
+ * Everything needed to create and configure the underlying auth session:
+ *   - Session database backends (in-memory and IndexedDB)
+ *   - Session instantiation (WebSession or SessionCore, with local-dev
+ *     fallbacks for environments where the service worker can't load)
+ *   - Login compatibility shim that normalises legacy call-site signatures
+ *     and resolves the canonical issuer through /.well-known discovery
+ *
+ * The raw session instance (_session) is consumed by authSession.ts where
+ * the legacy event layer and logout listener are attached.
+ *
+ * DO NOT import _session directly — always go through authSession.ts so
+ * the event wiring is guaranteed to run.
+ */
+
+
+// ---------------------------------------------------------------------------
+// Session databases
+// ---------------------------------------------------------------------------
+class MemorySessionDatabase {
+    constructor() {
+        this.map = new Map();
+    }
+    shouldPreserveExistingRefreshToken(id, value) {
+        return id === 'refresh_token' && (value == null || value === '') && this.map.has(id);
+    }
+    async init() {
+        return this;
+    }
+    async setItem(id, value) {
+        // Some Solid IdPs do not include refresh_token on refresh responses.
+        // Keep the previous token instead of overwriting it with null/undefined.
+        if (this.shouldPreserveExistingRefreshToken(id, value)) {
+            return;
+        }
+        this.map.set(id, value);
+    }
+    async getItem(id) {
+        return this.map.has(id) ? this.map.get(id) : null;
+    }
+    async deleteItem(id) {
+        this.map.delete(id);
+    }
+    async clear() {
+        this.map.clear();
+    }
+    close() {
+        // No-op for in-memory database
+    }
+}
+class IndexedDbSessionDatabase {
+    constructor() {
+        this.db = null;
+        this.dbName = 'soidc';
+        this.storeName = 'session';
+        this.dbVersion = 1;
+    }
+    async shouldPreserveExistingRefreshToken(id, value) {
+        if (id !== 'refresh_token' || !(value == null || value === '')) {
+            return false;
+        }
+        const existing = await this.getItem(id);
+        return existing != null && existing !== '';
+    }
+    async init() {
+        if (this.db)
+            return this;
+        if (typeof indexedDB === 'undefined') {
+            throw new Error('IndexedDB is not available in this environment');
+        }
+        await new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    db.createObjectStore(this.storeName);
+                }
+            };
+        });
+        return this;
+    }
+    async setItem(id, value) {
+        await this.init();
+        // Some Solid IdPs do not include refresh_token on refresh responses.
+        // Keep the previous token instead of overwriting it with null/undefined.
+        if (await this.shouldPreserveExistingRefreshToken(id, value)) {
+            return;
+        }
+        await this.withStore('readwrite', store => store.put(value, id));
+    }
+    async getItem(id) {
+        await this.init();
+        return this.withStore('readonly', store => store.get(id));
+    }
+    async deleteItem(id) {
+        await this.init();
+        await this.withStore('readwrite', store => store.delete(id));
+    }
+    async clear() {
+        await this.init();
+        await this.withStore('readwrite', store => store.clear());
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    withStore(mode, op) {
+        return new Promise((resolve, reject) => {
+            if (!this.db) {
+                reject(new Error('Session database not initialized'));
+                return;
+            }
+            const tx = this.db.transaction(this.storeName, mode);
+            const store = tx.objectStore(this.storeName);
+            const request = op(store);
+            let result = null;
+            tx.onerror = () => { var _a; return reject((_a = tx.error) !== null && _a !== void 0 ? _a : request.error); };
+            tx.onabort = () => { var _a, _b; return reject((_b = (_a = tx.error) !== null && _a !== void 0 ? _a : request.error) !== null && _b !== void 0 ? _b : new Error('IndexedDB transaction aborted')); };
+            tx.oncomplete = () => resolve(result);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                var _a;
+                result = (_a = request.result) !== null && _a !== void 0 ? _a : null;
+            };
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Session instantiation
+// ---------------------------------------------------------------------------
+function getSessionCoreCtor() {
+    var _a, _b, _c;
+    const coreAny = core_namespaceObject;
+    const candidate = (_c = (_a = coreAny.SessionCore) !== null && _a !== void 0 ? _a : (_b = coreAny.default) === null || _b === void 0 ? void 0 : _b.SessionCore) !== null && _c !== void 0 ? _c : coreAny.default;
+    if (typeof candidate !== 'function') {
+        return null;
+    }
+    return candidate;
+}
+const SessionCoreCtor = getSessionCoreCtor();
+function createSession() {
+    const shouldSkipWorkerInLocalDev = typeof window !== 'undefined' && (() => {
+        const host = window.location.hostname;
+        // In local NSS setups (including subdomain mode like alice.localhost),
+        // worker-based session storage can be brittle and lose state on reload.
+        // Prefer SessionCore + IndexedDB for deterministic persistence.
+        return host === 'localhost' || host === '127.0.0.1' || host.endsWith('.localhost');
+    })();
+    if (shouldSkipWorkerInLocalDev) {
+        if (SessionCoreCtor) {
+            return new SessionCoreCtor(undefined, { database: new IndexedDbSessionDatabase() });
+        }
+        return new __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_144ab6cc_Session__();
+    }
+    try {
+        return new __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_144ab6cc_Session__();
+    }
+    catch (error) {
+        // In some deployments, worker URL resolution can become file:// and fail cross-origin.
+        // Fall back to SessionCore so auth still works without background refresh worker.
+        // Use IndexedDB to keep refresh-token persistence across page reloads.
+        console.warn('solid-logic: falling back to non-worker auth session:', error);
+        try {
+            if (SessionCoreCtor) {
+                return new SessionCoreCtor(undefined, { database: new IndexedDbSessionDatabase() });
+            }
+            return new __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_144ab6cc_Session__();
+        }
+        catch (dbError) {
+            console.warn('solid-logic: IndexedDB unavailable, using in-memory session database:', dbError);
+            if (SessionCoreCtor) {
+                return new SessionCoreCtor(undefined, { database: new MemorySessionDatabase() });
+            }
+            return new __WEBPACK_EXTERNAL_MODULE__uvdsl_solid_oidc_client_browser_144ab6cc_Session__();
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton session
+// ---------------------------------------------------------------------------
+const _session = createSession();
+
+
+;// ./src/authSession/issuer.ts
+/**
+ * Issuer discovery utilities.
+ *
+ * Resolves OIDC issuer endpoints from /.well-known/openid-configuration
+ * so that login can use the canonical issuer host.
+ */
+async function discoverIssuerFromWellKnown(issuer) {
+    try {
+        const issuerUrl = new URL(issuer);
+        const wellKnownUrl = new URL('/.well-known/openid-configuration', issuerUrl.origin);
+        const wellKnownResponse = await fetch(wellKnownUrl.toString(), { credentials: 'include' });
+        if (!wellKnownResponse.ok) {
+            return null;
+        }
+        const wellKnownPayload = await wellKnownResponse.json();
+        if (typeof (wellKnownPayload === null || wellKnownPayload === void 0 ? void 0 : wellKnownPayload.issuer) !== 'string' || !wellKnownPayload.issuer) {
+            return null;
+        }
+        return wellKnownPayload.issuer.replace(/\/$/, '');
+    }
+    catch (_err) {
+        return null;
+    }
+}
+async function resolveIssuerForLogin(issuer) {
+    // Prefer the issuer advertised by discovery; if app and issuer hosts still differ,
+    // redirecting to the canonical issuer host is cleaner than rewriting the issuer here.
+    const discoveredIssuer = await discoverIssuerFromWellKnown(issuer);
+    if (discoveredIssuer) {
+        return discoveredIssuer;
+    }
+    return issuer;
+}
+
+;// ./src/authSession/events.ts
+/**
+ * Legacy event compatibility layer.
+ *
+ * Pure EventEmitter-style shim — no side effects, no uvdsl dependencies.
+ * Wired into the auth session by authSession.ts.
+ */
+/**
+ * Minimal EventEmitter-style shim so that existing consumers using
+ * `authSession.events.on('login' | 'logout' | 'sessionRestore', handler)`
+ * continue working without modification.
+ *
+ * Events are emitted by SolidAuthnLogic.checkUser() (login/sessionRestore)
+ * and by the sessionStateChange listener in authSession.ts (logout).
+ */
+class SessionEvents {
+    constructor() {
+        this.listeners = new Map();
+    }
+    on(event, handler) {
+        if (!this.listeners.has(event))
+            this.listeners.set(event, new Set());
+        this.listeners.get(event).add(handler);
+    }
+    off(event, handler) {
+        var _a;
+        (_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.delete(handler);
+    }
+    emit(event, ...args) {
+        var _a;
+        (_a = this.listeners.get(event)) === null || _a === void 0 ? void 0 : _a.forEach(h => h(...args));
+    }
+}
+
+;// ./src/authSession/authSession.ts
+/**
+ * Auth session wiring.
+ *
+ * Takes the raw OIDC session from session.ts and layers on:
+ *   - Login compatibility shim (normalises legacy call-site signatures
+ *     and resolves the canonical issuer)
+ *   - SessionEvents shim (legacy EventEmitter-style API)
+ *   - Logout listener (emits 'logout' on session deactivation)
+ *
+ * Exports the fully assembled authSession.
+ */
+var _a;
+
+
+
+// ---------------------------------------------------------------------------
+// Login compatibility shim
+// ---------------------------------------------------------------------------
+// Wraps _session.login() so that call sites with different calling
+// conventions all work.  The underlying session expects:
+//   login(issuer: string, redirectUrl: string)
+//
+// idpOrOptions can be:
+//   - a string (issuer URL) — passed through with less resolution
+//   - an options object with any of these field-name variants:
+//       issuer:   oidcIssuer | idp | issuer
+//       redirect: redirectUrl | redirect_uri | redirectUri
+//     (all redirect field names map to the same value: the URL the IdP
+//     should send the browser back to after authentication)
+//   - anything else — passed through to the underlying session as-is
+//
+// In all cases the issuer is resolved through
+// /.well-known/openid-configuration before redirect so the canonical
+// issuer host is used.
+const sessionAny = _session;
+const originalLogin = typeof sessionAny.login === 'function'
+    ? sessionAny.login.bind(_session)
+    : undefined;
+if (originalLogin) {
+    const compatLogin = async (idpOrOptions, redirectUri) => {
+        var _a, _b, _c, _d;
+        if (idpOrOptions && typeof idpOrOptions === 'object' && !Array.isArray(idpOrOptions)) {
+            const oidcIssuer = (_b = (_a = idpOrOptions.oidcIssuer) !== null && _a !== void 0 ? _a : idpOrOptions.idp) !== null && _b !== void 0 ? _b : idpOrOptions.issuer;
+            const redirectUrl = (_d = (_c = idpOrOptions.redirectUrl) !== null && _c !== void 0 ? _c : idpOrOptions.redirect_uri) !== null && _d !== void 0 ? _d : idpOrOptions.redirectUri;
+            if (typeof oidcIssuer === 'string' && typeof redirectUrl === 'string') {
+                return originalLogin(await resolveIssuerForLogin(oidcIssuer), redirectUrl);
+            }
+        }
+        if (typeof idpOrOptions === 'string') {
+            return originalLogin(await resolveIssuerForLogin(idpOrOptions), redirectUri);
+        }
+        return originalLogin(idpOrOptions, redirectUri);
+    };
+    sessionAny.login = compatLogin;
+}
+// ---------------------------------------------------------------------------
+// Legacy event layer
+// ---------------------------------------------------------------------------
+const events = new SessionEvents();
+// Emit the legacy 'logout' event when the session transitions from active to inactive.
+// 'login' and 'sessionRestore' are emitted in SolidAuthnLogic.checkUser()
+// because only that call site knows which path activated the session.
+let _wasActive = (_a = _session.isActive) !== null && _a !== void 0 ? _a : Boolean(_session.webId);
+if (typeof _session.addEventListener === 'function') {
+    ;
+    _session.addEventListener('sessionStateChange', () => {
+        var _a;
+        const isNowActive = (_a = _session.isActive) !== null && _a !== void 0 ? _a : Boolean(_session.webId);
+        if (_wasActive && !isNowActive) {
+            events.emit('logout');
+        }
+        _wasActive = isNowActive;
+    });
+}
+const authSession = Object.assign(_session, { events });
+// Legacy `info` compatibility shape.
+// The uvdsl session stores state on `webId_`/`isActive_` and exposes them via
+// `webId`/`isActive` getters, but legacy consumers (e.g. solid-ui's
+// `loginStatusBox` widget, `SolidAuthnLogic.currentUser()`'s fallback path)
+// read `authSession.info.webId` / `authSession.info.isLoggedIn`. Expose those
+// as a derived getter so legacy login/logout UI renders the correct state
+// (logout button instead of a mislabelled login button).
+Object.defineProperty(authSession, 'info', {
+    enumerable: true,
+    configurable: true,
+    get() {
+        const sessionAny = _session;
+        const isActive = sessionAny.isActive === true || Boolean(sessionAny.webId);
+        return {
+            webId: sessionAny.webId,
+            isLoggedIn: isActive
+        };
+    }
+});
+
+;// external "rdflib"
+const external_rdflib_namespaceObject = __WEBPACK_EXTERNAL_MODULE_rdflib__;
+// EXTERNAL MODULE: ./node_modules/solid-namespace/index.js
+var solid_namespace = __webpack_require__(386);
+var solid_namespace_default = /*#__PURE__*/__webpack_require__.n(solid_namespace);
+;// ./src/util/ns.ts
+// Namespaces we commonly use and have common prefixes for around Solid
+ // Delegate to this which takes RDFlib as param.
+
+const ns_ns = solid_namespace_default()(external_rdflib_namespaceObject);
+
+;// ./src/acl/aclLogic.ts
+
+
+const ACL_LINK = (0,external_rdflib_namespaceObject.sym)('http://www.iana.org/assignments/link-relations/acl');
+function createAclLogic(store) {
+    const ns = ns_ns;
+    async function findAclDocUrl(url) {
+        await store.fetcher.load(url);
+        const docNode = store.any(url, ACL_LINK);
+        if (!docNode) {
+            throw new Error(`No ACL link discovered for ${url}`);
+        }
+        return docNode.value;
+    }
+    /**
+     * Simple Access Control
+     *
+     * This function sets up a simple default ACL for a resource, with
+     * RWC for the owner, and a specified access (default none) for the public.
+     * In all cases owner has read write control.
+     * Parameter lists modes allowed to public
+     *
+     * @param options
+     * @param options.public eg ['Read', 'Write']
+     *
+     * @returns Resolves with aclDoc uri on successful write
+     */
+    function setACLUserPublic(docURI, me, options) {
+        const aclDoc = store.any(store.sym(docURI), ACL_LINK);
+        return Promise.resolve()
+            .then(() => {
+            if (aclDoc) {
+                return aclDoc;
+            }
+            return fetchACLRel(docURI).catch(err => {
+                throw new Error(`Error fetching rel=ACL header for ${docURI}: ${err}`);
+            });
+        })
+            .then(aclDoc => {
+            const aclText = genACLText(docURI, me, aclDoc.uri, options);
+            if (!store.fetcher) {
+                throw new Error('Cannot PUT this, store has no fetcher');
+            }
+            return store.fetcher
+                .webOperation('PUT', aclDoc.uri, {
+                data: aclText,
+                contentType: 'text/turtle'
+            })
+                .then(result => {
+                if (!result.ok) {
+                    throw new Error('Error writing ACL text: ' + result.error);
+                }
+                return aclDoc;
+            });
+        });
+    }
+    /**
+     * @param docURI
+     * @returns
+     */
+    function fetchACLRel(docURI) {
+        const fetcher = store.fetcher;
+        if (!fetcher) {
+            throw new Error('Cannot fetch ACL rel, store has no fetcher');
+        }
+        return fetcher.load(docURI).then(result => {
+            if (!result.ok) {
+                throw new Error('fetchACLRel: While loading:' + result.error);
+            }
+            const aclDoc = store.any(store.sym(docURI), ACL_LINK);
+            if (!aclDoc) {
+                throw new Error('fetchACLRel: No Link rel=ACL header for ' + docURI);
+            }
+            return aclDoc;
+        });
+    }
+    /**
+     * @param docURI
+     * @param me
+     * @param aclURI
+     * @param options
+     *
+     * @returns Serialized ACL
+     */
+    function genACLText(docURI, me, aclURI, options = {}) {
+        const optPublic = options.public || [];
+        const g = (0,external_rdflib_namespaceObject.graph)();
+        const auth = (0,external_rdflib_namespaceObject.Namespace)('http://www.w3.org/ns/auth/acl#');
+        let a = g.sym(`${aclURI}#a1`);
+        const acl = g.sym(aclURI);
+        const doc = g.sym(docURI);
+        g.add(a, ns.rdf('type'), auth('Authorization'), acl);
+        g.add(a, auth('accessTo'), doc, acl);
+        if (options.defaultForNew) {
+            g.add(a, auth('default'), doc, acl);
+        }
+        g.add(a, auth('agent'), me, acl);
+        g.add(a, auth('mode'), auth('Read'), acl);
+        g.add(a, auth('mode'), auth('Write'), acl);
+        g.add(a, auth('mode'), auth('Control'), acl);
+        if (optPublic.length) {
+            a = g.sym(`${aclURI}#a2`);
+            g.add(a, ns.rdf('type'), auth('Authorization'), acl);
+            g.add(a, auth('accessTo'), doc, acl);
+            g.add(a, auth('agentClass'), ns.foaf('Agent'), acl);
+            for (let p = 0; p < optPublic.length; p++) {
+                g.add(a, auth('mode'), auth(optPublic[p]), acl); // Like 'Read' etc
+            }
+        }
+        return (0,external_rdflib_namespaceObject.serialize)(acl, g, aclURI);
+    }
+    return {
+        findAclDocUrl,
+        setACLUserPublic,
+        genACLText
+    };
+}
+
+;// ./src/authn/authUtil.ts
+
+
+/**
+ * find a user or app's context as set in window.SolidAppContext
+ * this is a const, not a function, because we have problems to jest mock it otherwise
+ * see: https://github.com/facebook/jest/issues/936#issuecomment-545080082 for more
+ * @return {any} - an appContext object
+ */
+const appContext = () => {
+    let { SolidAppContext } = window;
+    SolidAppContext || (SolidAppContext = {});
+    SolidAppContext.viewingNoAuthPage = false;
+    if (SolidAppContext.noAuth && window.document) {
+        const currentPage = window.document.location.href;
+        if (currentPage.startsWith(SolidAppContext.noAuth)) {
+            SolidAppContext.viewingNoAuthPage = true;
+            const params = new URLSearchParams(window.document.location.search);
+            if (params) {
+                let viewedPage = SolidAppContext.viewedPage = params.get('uri') || null;
+                if (viewedPage) {
+                    viewedPage = decodeURI(viewedPage);
+                    if (!viewedPage.startsWith(SolidAppContext.noAuth)) {
+                        const ary = viewedPage.split(/\//);
+                        SolidAppContext.idp = ary[0] + '//' + ary[2];
+                        SolidAppContext.viewingNoAuthPage = false;
+                    }
+                }
+            }
+        }
+    }
+    return SolidAppContext;
+};
+/**
+ * Returns `sym($SolidTestEnvironment.username)` if
+ * `$SolidTestEnvironment.username` is defined as a global
+ * or
+ * returns testID defined in the HTML page
+ * @returns {NamedNode|null}
+ */
+function offlineTestID() {
+    const { $SolidTestEnvironment } = window;
+    if (typeof $SolidTestEnvironment !== 'undefined' &&
+        $SolidTestEnvironment.username) {
+        // Test setup
+        log('Assuming the user is ' + $SolidTestEnvironment.username);
+        return (0,external_rdflib_namespaceObject.sym)($SolidTestEnvironment.username);
+    }
+    // hack that makes SolidOS work in offline mode by adding the webId directly in html
+    // example usage: https://github.com/solidos/mashlib/blob/29b8b53c46bf02e0e219f0bacd51b0e9951001dd/test/contact/local.html#L37
+    if (typeof document !== 'undefined' &&
+        document.location &&
+        ('' + document.location).slice(0, 16) === 'http://localhost') {
+        const div = document.getElementById('appTarget');
+        if (!div)
+            return null;
+        const id = div.getAttribute('testID');
+        if (!id)
+            return null;
+        log('Assuming user is ' + id);
+        return (0,external_rdflib_namespaceObject.sym)(id);
+    }
+    return null;
+}
+
+;// ./src/authn/SolidAuthnLogic.ts
+
+
+
+class SolidAuthnLogic {
+    constructor(solidAuthSession) {
+        this.checkUserInFlight = null;
+        this.sessionRestoreHookAttached = false;
+        this.fallbackWebId = null;
+        this.session = solidAuthSession;
+    }
+    // we created authSession getter because we want to access it as authn.authSession externally
+    get authSession() { return this.session; }
+    currentUser() {
+        var _a, _b;
+        const app = appContext();
+        if (app.viewingNoAuthPage) {
+            return (0,external_rdflib_namespaceObject.sym)(app.webId);
+        }
+        const sessionAny = this.session;
+        const infoWebId = (_a = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.info) === null || _a === void 0 ? void 0 : _a.webId;
+        const sessionWebId = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.webId;
+        const webId = infoWebId || sessionWebId || this.fallbackWebId;
+        const infoLoggedIn = (_b = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.info) === null || _b === void 0 ? void 0 : _b.isLoggedIn;
+        const sessionActive = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.isActive;
+        const isLoggedIn = infoLoggedIn === true || sessionActive === true ||
+            ((infoLoggedIn == null && sessionActive == null) ? Boolean(webId) : false) ||
+            Boolean(this.fallbackWebId);
+        if (this && this.session && webId && isLoggedIn) {
+            return (0,external_rdflib_namespaceObject.sym)(webId);
+        }
+        return offlineTestID(); // null unless testing
+    }
+    /**
+     * Retrieves currently logged in webId from either
+     * defaultTestUser or SolidAuth
+     * Also activates a session after login
+     * @param [setUserCallback] Optional callback
+     * @returns Resolves with webId uri, if no callback provided
+     */
+    async checkUser(setUserCallback) {
+        var _a;
+        // Save hash for "restorePreviousSession"
+        const preLoginRedirectHash = new URL(window.location.href).hash;
+        if (preLoginRedirectHash) {
+            window.localStorage.setItem('preLoginRedirectHash', preLoginRedirectHash);
+        }
+        const sessionAny = this.session;
+        if (!this.sessionRestoreHookAttached && typeof ((_a = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.events) === null || _a === void 0 ? void 0 : _a.on) === 'function') {
+            // Backward-compatible hook for auth clients exposing an EventEmitter-style API.
+            sessionAny.events.on('sessionRestore', (url) => {
+                log(`Session restored to ${url}`);
+                if (document.location.toString() !== url)
+                    history.replaceState(null, '', url);
+            });
+            this.sessionRestoreHookAttached = true;
+        }
+        if (!this.checkUserInFlight) {
+            this.checkUserInFlight = this.resolveCurrentUser();
+        }
+        const inFlight = this.checkUserInFlight;
+        let me;
+        try {
+            me = await inFlight;
+        }
+        finally {
+            if (this.checkUserInFlight === inFlight) {
+                this.checkUserInFlight = null;
+            }
+        }
+        return Promise.resolve(setUserCallback ? setUserCallback(me) : me);
+    }
+    async resolveCurrentUser() {
+        var _a, _b, _c, _d, _e, _f;
+        const sessionAny = this.session;
+        /**
+         * Handle a successful authentication redirect
+         */
+        const redirectUrl = new URL(window.location.href);
+        redirectUrl.hash = '';
+        if (typeof (sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.handleIncomingRedirect) === 'function') {
+            await sessionAny.handleIncomingRedirect({
+                restorePreviousSession: true,
+                url: redirectUrl.href
+            });
+        }
+        else {
+            if (typeof (sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.restore) === 'function') {
+                const wasActive = (_a = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.isActive) !== null && _a !== void 0 ? _a : Boolean(sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.webId);
+                try {
+                    await sessionAny.restore();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (!/no session to restore/i.test(message)) {
+                        throw error;
+                    }
+                    log('No previous session to restore');
+                }
+                const isNowActive = (_b = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.isActive) !== null && _b !== void 0 ? _b : Boolean(sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.webId);
+                if (!wasActive && isNowActive) {
+                    (_c = sessionAny.events) === null || _c === void 0 ? void 0 : _c.emit('sessionRestore', window.location.href);
+                }
+            }
+            if (typeof (sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.handleRedirectFromLogin) === 'function') {
+                const wasActive = (_d = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.isActive) !== null && _d !== void 0 ? _d : Boolean(sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.webId);
+                await sessionAny.handleRedirectFromLogin();
+                const isNowActive = (_e = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.isActive) !== null && _e !== void 0 ? _e : Boolean(sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.webId);
+                if (!wasActive && isNowActive) {
+                    (_f = sessionAny.events) === null || _f === void 0 ? void 0 : _f.emit('login');
+                }
+            }
+        }
+        // Check to see if a hash was stored in local storage
+        const postLoginRedirectHash = window.localStorage.getItem('preLoginRedirectHash');
+        if (postLoginRedirectHash) {
+            const curUrl = new URL(window.location.href);
+            if (curUrl.hash !== postLoginRedirectHash) {
+                if (history.pushState) {
+                    // debug.log('Setting window.location.has using pushState')
+                    history.pushState(null, document.title, postLoginRedirectHash);
+                }
+                else {
+                    // debug.warn('Setting window.location.has using location.hash')
+                    location.hash = postLoginRedirectHash;
+                }
+                curUrl.hash = postLoginRedirectHash;
+            }
+            // See https://stackoverflow.com/questions/3870057/how-can-i-update-window-location-hash-without-jumping-the-document
+            // window.location.href = curUrl.toString()// @@ See https://developer.mozilla.org/en-US/docs/Web/API/Window/location
+            window.localStorage.setItem('preLoginRedirectHash', '');
+        }
+        // Check to see if already logged in / have the WebID
+        let me = offlineTestID();
+        if (me) {
+            return me;
+        }
+        let webId = this.webIdFromSession(sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.info, sessionAny);
+        if (!webId) {
+            // NSS-specific fallback: recover WebID from NSS cookie session when client restore is empty.
+            webId = await this.probeNssCookieBackedWebId();
+        }
+        if (webId) {
+            this.fallbackWebId = webId;
+        }
+        else {
+            this.fallbackWebId = null;
+        }
+        if (webId) {
+            me = this.saveUser(webId);
+        }
+        if (me) {
+            log(`(Logged in as ${me} by authentication)`);
+        }
+        return me;
+    }
+    async probeNssCookieBackedWebId() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        const { hostname, port, protocol } = window.location;
+        const localhostSuffix = '.localhost';
+        // NSS local pods use subdomains like alice.localhost.
+        if (!hostname.endsWith(localhostSuffix)) {
+            return null;
+        }
+        const podName = hostname.slice(0, -localhostSuffix.length);
+        if (!podName || podName === 'localhost' || podName.includes('.')) {
+            return null;
+        }
+        try {
+            // NSS returns 403 on this account page when the cookie session is valid.
+            const probeResponse = await fetch('/account/password/change', {
+                credentials: 'include',
+                redirect: 'manual',
+                cache: 'no-store'
+            });
+            if (probeResponse.status !== 403) {
+                return null;
+            }
+            const origin = `${protocol}//${hostname}${port ? `:${port}` : ''}`;
+            return `${origin}/profile/card#me`;
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    /**
+     * Saves `webId` in `context.me`
+     * @param webId
+     * @param context
+     *
+     * @returns Returns the WebID, after setting it
+     */
+    saveUser(webId, context) {
+        let webIdUri;
+        if (webId) {
+            webIdUri = (typeof webId === 'string') ? webId : webId.uri;
+            const me = (0,external_rdflib_namespaceObject.namedNode)(webIdUri);
+            if (context) {
+                context.me = me;
+            }
+            return me;
+        }
+        return null;
+    }
+    /**
+     * @returns {Promise<string|null>} Resolves with WebID URI or null
+     */
+    webIdFromSession(sessionInfo, sessionRoot) {
+        const webId = (sessionInfo === null || sessionInfo === void 0 ? void 0 : sessionInfo.webId) || (sessionRoot === null || sessionRoot === void 0 ? void 0 : sessionRoot.webId);
+        if (!webId) {
+            return null;
+        }
+        const infoLoggedIn = sessionInfo === null || sessionInfo === void 0 ? void 0 : sessionInfo.isLoggedIn;
+        const rootLoggedIn = sessionRoot === null || sessionRoot === void 0 ? void 0 : sessionRoot.isLoggedIn;
+        const rootActive = sessionRoot === null || sessionRoot === void 0 ? void 0 : sessionRoot.isActive;
+        if (infoLoggedIn === true || rootLoggedIn === true || rootActive === true) {
+            return webId;
+        }
+        if (infoLoggedIn === false && rootLoggedIn === false && rootActive === false) {
+            return null;
+        }
+        return webId;
+    }
+}
+
+;// ./src/util/utils.ts
+/* unused harmony import specifier */ var NamedNode;
+
+function newThing(doc) {
+    return (0,external_rdflib_namespaceObject.sym)(doc.uri + '#' + 'id' + ('' + Date.now()));
+}
+function uniqueNodes(arr) {
+    const uris = arr.map(x => x.uri);
+    const set = new Set(uris);
+    const uris2 = Array.from(set);
+    const arr2 = uris2.map(u => new NamedNode(u));
+    return arr2; // Array.from(new Set(arr.map(x => x.uri))).map(u => sym(u))
+}
+function getArchiveUrl(baseUrl, date) {
+    const year = date.getUTCFullYear();
+    const month = ('0' + (date.getUTCMonth() + 1)).slice(-2);
+    const day = ('0' + (date.getUTCDate())).slice(-2);
+    const parts = baseUrl.split('/');
+    const filename = parts[parts.length - 1];
+    return new URL(`./archive/${year}/${month}/${day}/${filename}`, baseUrl).toString();
+}
+function differentOrigin(doc) {
+    if (!doc) {
+        return true;
+    }
+    return (`${window.location.origin}/` !== new URL(doc.value).origin);
+}
+function suggestPreferencesFile(me) {
+    const stripped = me.uri.replace('/profile/', '/').replace('/public/', '/');
+    // const stripped = me.uri.replace(\/[p|P]rofile/\g, '/').replace(\/[p|P]ublic/\g, '/')
+    const folderURI = stripped.split('/').slice(0, -1).join('/') + '/settings/';
+    const fileURI = folderURI + 'prefs.ttl';
+    return (0,external_rdflib_namespaceObject.sym)(fileURI);
+}
+function determineChatContainer(invitee, podRoot) {
+    // Create chat
+    // See https://gitter.im/solid/chat-app?at=5f3c800f855be416a23ae74a
+    const chatContainerStr = new URL(`IndividualChats/${new URL(invitee.value).host}/`, podRoot.value).toString();
+    return new external_rdflib_namespaceObject.NamedNode(chatContainerStr);
+}
+
+;// ./src/chat/chatLogic.ts
+
+
+
+const CHAT_LOCATION_IN_CONTAINER = 'index.ttl#this';
+function createChatLogic(store, profileLogic) {
+    const ns = ns_ns;
+    async function setAcl(chatContainer, me, invitee) {
+        // Some servers don't present a Link http response header
+        // if the container doesn't exist yet, so refetch the container
+        // now that it has been created:
+        await store.fetcher.load(chatContainer);
+        // FIXME: check the Why value on this quad:
+        const chatAclDoc = store.any(chatContainer, new external_rdflib_namespaceObject.NamedNode('http://www.iana.org/assignments/link-relations/acl'));
+        if (!chatAclDoc) {
+            throw new Error('Chat ACL doc not found!');
+        }
+        const aclBody = `
+            @prefix acl: <http://www.w3.org/ns/auth/acl#>.
+            <#owner>
+            a acl:Authorization;
+            acl:agent <${me.value}>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Write, acl:Control.
+            <#invitee>
+            a acl:Authorization;
+            acl:agent <${invitee.value}>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Append.
+            `;
+        await store.fetcher.webOperation('PUT', chatAclDoc.value, {
+            data: aclBody,
+            contentType: 'text/turtle',
+        });
+    }
+    async function addToPrivateTypeIndex(chatThing, me) {
+        // Add to private type index
+        const privateTypeIndex = store.any(me, ns.solid('privateTypeIndex'));
+        if (!privateTypeIndex) {
+            throw new Error('Private type index not found!');
+        }
+        await store.fetcher.load(privateTypeIndex);
+        const reg = newThing(privateTypeIndex);
+        const ins = [
+            (0,external_rdflib_namespaceObject.st)(reg, ns.rdf('type'), ns.solid('TypeRegistration'), privateTypeIndex.doc()),
+            (0,external_rdflib_namespaceObject.st)(reg, ns.solid('forClass'), ns.meeting('LongChat'), privateTypeIndex.doc()),
+            (0,external_rdflib_namespaceObject.st)(reg, ns.solid('instance'), chatThing, privateTypeIndex.doc()),
+        ];
+        await new Promise((resolve, reject) => {
+            store.updater.update([], ins, function (_uri, ok, errm) {
+                if (!ok) {
+                    reject(new Error(errm));
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    async function findChat(invitee) {
+        const me = await profileLogic.loadMe();
+        const podRoot = await profileLogic.getPodRoot(me);
+        const chatContainer = determineChatContainer(invitee, podRoot);
+        let exists = true;
+        try {
+            await store.fetcher.load(new external_rdflib_namespaceObject.NamedNode(chatContainer.value + 'index.ttl#this'));
+        }
+        catch (e) {
+            exists = false;
+        }
+        return { me, chatContainer, exists };
+    }
+    async function createChatThing(chatContainer, me) {
+        const created = await mintNew({
+            me,
+            newBase: chatContainer.value,
+        });
+        return created.newInstance;
+    }
+    function mintNew(newPaneOptions) {
+        const kb = store;
+        const updater = kb.updater;
+        if (newPaneOptions.me && !newPaneOptions.me.uri) {
+            throw new Error('chat mintNew:  Invalid userid ' + newPaneOptions.me);
+        }
+        const newInstance = (newPaneOptions.newInstance =
+            newPaneOptions.newInstance ||
+                kb.sym(newPaneOptions.newBase + CHAT_LOCATION_IN_CONTAINER));
+        const newChatDoc = newInstance.doc();
+        kb.add(newInstance, ns.rdf('type'), ns.meeting('LongChat'), newChatDoc);
+        kb.add(newInstance, ns.dc('title'), 'Chat channel', newChatDoc);
+        kb.add(newInstance, ns.dc('created'), (0,external_rdflib_namespaceObject.term)(new Date(Date.now())), newChatDoc);
+        if (newPaneOptions.me) {
+            kb.add(newInstance, ns.dc('author'), newPaneOptions.me, newChatDoc);
+        }
+        return new Promise(function (resolve, reject) {
+            updater === null || updater === void 0 ? void 0 : updater.put(newChatDoc, kb.statementsMatching(undefined, undefined, undefined, newChatDoc), 'text/turtle', function (uri2, ok, message) {
+                if (ok) {
+                    resolve({
+                        ...newPaneOptions,
+                        newInstance,
+                    });
+                }
+                else {
+                    reject(new Error('FAILED to save new chat channel at: ' + uri2 + ' : ' + message));
+                }
+            });
+        });
+    }
+    /**
+     * Find (and optionally create) an individual chat between the current user and the given invitee
+     * @param invitee - The person to chat with
+     * @param createIfMissing - Whether the chat should be created, if missing
+     * @returns null if missing, or a node referring to an already existing chat, or the newly created chat
+     */
+    async function getChat(invitee, createIfMissing = true) {
+        const { me, chatContainer, exists } = await findChat(invitee);
+        if (exists) {
+            return new external_rdflib_namespaceObject.NamedNode(chatContainer.value + CHAT_LOCATION_IN_CONTAINER);
+        }
+        if (createIfMissing) {
+            const chatThing = await createChatThing(chatContainer, me);
+            await sendInvite(invitee, chatThing);
+            await setAcl(chatContainer, me, invitee);
+            await addToPrivateTypeIndex(chatThing, me);
+            return chatThing;
+        }
+        return null;
+    }
+    async function sendInvite(invitee, chatThing) {
+        var _a;
+        await store.fetcher.load(invitee.doc());
+        const inviteeInbox = store.any(invitee, ns.ldp('inbox'), undefined, invitee.doc());
+        if (!inviteeInbox) {
+            throw new Error(`Invitee inbox not found! ${invitee.value}`);
+        }
+        const inviteBody = `
+        <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
+        ${ns.rdf('seeAlso')} <${chatThing.value}> .
+        `;
+        const inviteResponse = await ((_a = store.fetcher) === null || _a === void 0 ? void 0 : _a.webOperation('POST', inviteeInbox.value, {
+            data: inviteBody,
+            contentType: 'text/turtle',
+        }));
+        const locationStr = inviteResponse === null || inviteResponse === void 0 ? void 0 : inviteResponse.headers.get('location');
+        if (!locationStr) {
+            throw new Error(`Invite sending returned a ${inviteResponse === null || inviteResponse === void 0 ? void 0 : inviteResponse.status}`);
+        }
+    }
+    return {
+        setAcl, addToPrivateTypeIndex, findChat, createChatThing, getChat, sendInvite, mintNew
+    };
+}
+
+;// ./src/inbox/inboxLogic.ts
+
+function createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic) {
+    async function createInboxFor(peerWebId, nick) {
+        const myWebId = await profileLogic.loadMe();
+        const podRoot = await profileLogic.getPodRoot(myWebId);
+        const ourInbox = `${podRoot.value}p2p-inboxes/${encodeURIComponent(nick)}/`;
+        await containerLogic.createContainer(ourInbox);
+        // const aclDocUrl = await aclLogic.findAclDocUrl(ourInbox);
+        await utilityLogic.setSinglePeerAccess({
+            ownerWebId: myWebId.value,
+            peerWebId,
+            accessToModes: 'acl:Append',
+            target: ourInbox
+        });
+        return ourInbox;
+    }
+    async function getNewMessages(user) {
+        if (!user) {
+            user = await profileLogic.loadMe();
+        }
+        const inbox = await profileLogic.getMainInbox(user);
+        const urls = await containerLogic.getContainerMembers(inbox);
+        return urls.filter(url => !containerLogic.isContainer(url));
+    }
+    async function markAsRead(url, date) {
+        const downloaded = await store.fetcher._fetch(url);
+        if (downloaded.status !== 200) {
+            throw new Error(`Not OK! ${url}`);
+        }
+        const archiveUrl = getArchiveUrl(url, date);
+        const options = {
+            method: 'PUT',
+            body: await downloaded.text(),
+            headers: [
+                ['Content-Type', downloaded.headers.get('Content-Type') || 'application/octet-stream']
+            ]
+        };
+        const uploaded = await store.fetcher._fetch(archiveUrl, options);
+        if (uploaded.status.toString()[0] === '2') {
+            await store.fetcher._fetch(url, {
+                method: 'DELETE'
+            });
+        }
+    }
+    return {
+        createInboxFor,
+        getNewMessages,
+        markAsRead
+    };
+}
+
+;// ./src/logic/CustomError.ts
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        // see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+        this.name = new.target.name; // stack traces display correctly now
+    }
+}
+class UnauthorizedError extends CustomError {
+}
+class CrossOriginForbiddenError extends CustomError {
+}
+class SameOriginForbiddenError extends CustomError {
+}
+class NotFoundError extends CustomError {
+}
+class NotEditableError extends CustomError {
+}
+class WebOperationError extends CustomError {
+}
+class FetchError extends CustomError {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+
+;// ./src/typeIndex/typeIndexDocuments.ts
+function publicTypeIndexDocument() {
+    return [
+        '@prefix solid: <http://www.w3.org/ns/solid/terms#>.',
+        '<>',
+        '    a solid:TypeIndex ;',
+        '    a solid:ListedDocument.'
+    ].join('\n');
+}
+function privateTypeIndexDocument() {
+    return [
+        '@prefix solid: <http://www.w3.org/ns/solid/terms#>.',
+        '<>',
+        '    a solid:TypeIndex ;',
+        '    a solid:UnlistedDocument.'
+    ].join('\n');
+}
+
+;// ./src/typeIndex/typeIndexAclDocuments.ts
+function publicTypeIndexAclDocument(webId, publicTypeIndexUri) {
+    const fileName = new URL(publicTypeIndexUri).pathname.split('/').pop() || 'publicTypeIndex.ttl';
+    return [
+        '# ACL resource for the Public Type Index',
+        '',
+        '@prefix acl: <http://www.w3.org/ns/auth/acl#>.',
+        '@prefix foaf: <http://xmlns.com/foaf/0.1/>.',
+        '',
+        '<#owner>',
+        '    a acl:Authorization;',
+        '',
+        '    acl:agent',
+        `        <${webId}>;`,
+        '',
+        `    acl:accessTo <./${fileName}>;`,
+        '',
+        '    acl:mode',
+        '        acl:Read, acl:Write, acl:Control.',
+        '',
+        '# Public-readable',
+        '<#public>',
+        '    a acl:Authorization;',
+        '',
+        '    acl:agentClass foaf:Agent;',
+        '',
+        `    acl:accessTo <./${fileName}>;`,
+        '',
+        '    acl:mode acl:Read.'
+    ].join('\n');
+}
+
+;// ./src/profile/profileDocuments.ts
+function preferencesFileDocument() {
+    return [
+        '@prefix dct: <http://purl.org/dc/terms/>.',
+        '@prefix pim: <http://www.w3.org/ns/pim/space#>.',
+        '@prefix solid: <http://www.w3.org/ns/solid/terms#>.',
+        '<>',
+        '    a pim:ConfigurationFile ;',
+        '    dct:title "Preferences file".'
+    ].join('\n');
+}
+
+;// ./src/profile/profileAclDocuments.ts
+function ownerOnlyContainerAclDocument(webId) {
+    return [
+        '@prefix acl: <http://www.w3.org/ns/auth/acl#>.',
+        '',
+        '<#owner>',
+        'a acl:Authorization;',
+        `acl:agent <${webId}>;`,
+        'acl:accessTo <./>;',
+        'acl:default <./>;',
+        'acl:mode acl:Read, acl:Write, acl:Control.'
+    ].join('\n');
+}
+
+;// ./src/util/containerLogic.ts
+
+/**
+ * Container-related class
+ */
+function createContainerLogic(store) {
+    function getContainerElements(containerNode) {
+        return store
+            .statementsMatching(containerNode, (0,external_rdflib_namespaceObject.sym)('http://www.w3.org/ns/ldp#contains'), undefined)
+            .map((st) => st.object);
+    }
+    function isContainer(url) {
+        const nodeToString = url.value;
+        return nodeToString.charAt(nodeToString.length - 1) === '/';
+    }
+    async function createContainer(url) {
+        const stringToNode = (0,external_rdflib_namespaceObject.sym)(url);
+        if (!isContainer(stringToNode)) {
+            throw new Error(`Not a container URL ${url}`);
+        }
+        // Copied from https://github.com/solidos/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
+        const result = await store.fetcher._fetch(url, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'text/turtle',
+                'If-None-Match': '*',
+                Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"', // See https://github.com/solidos/node-solid-server/issues/1465
+            },
+            body: ' ', // work around https://github.com/michielbdejong/community-server/issues/4#issuecomment-776222863
+        });
+        // Treat 409 as idempotent success: another process/request already created the container.
+        if (result.status === 409) {
+            return;
+        }
+        if (result.status.toString()[0] !== '2') {
+            throw new Error(`Not OK: got ${result.status} response while creating container at ${url}`);
+        }
+    }
+    async function getContainerMembers(containerUrl) {
+        await store.fetcher.load(containerUrl);
+        return getContainerElements(containerUrl);
+    }
+    return {
+        isContainer,
+        createContainer,
+        getContainerElements,
+        getContainerMembers
+    };
+}
+
+;// ./src/profile/profileLogic.ts
+
+
+
+
+
+
+
+
+
+
+
+function createProfileLogic(store, authn, utilityLogic) {
+    const ns = ns_ns;
+    const containerLogic = createContainerLogic(store);
+    const loadPreferencesInFlight = new Map();
+    const cachedPreferencesFileByWebId = new Map();
+    function isAbsoluteHttpUri(uri) {
+        return !!uri && (uri.startsWith('https://') || uri.startsWith('http://'));
+    }
+    function docDirUri(node) {
+        const doc = node.doc();
+        const dir = doc.dir();
+        if ((dir === null || dir === void 0 ? void 0 : dir.uri) && isAbsoluteHttpUri(dir.uri))
+            return dir.uri;
+        const docUri = doc.uri;
+        if (!docUri || !isAbsoluteHttpUri(docUri))
+            return null;
+        const withoutFragment = docUri.split('#')[0];
+        const lastSlash = withoutFragment.lastIndexOf('/');
+        if (lastSlash === -1)
+            return null;
+        return withoutFragment.slice(0, lastSlash + 1);
+    }
+    function suggestTypeIndexInPreferences(preferencesFile, filename) {
+        const dirUri = docDirUri(preferencesFile);
+        if (!dirUri)
+            throw new Error(`Cannot derive directory for preferences file ${preferencesFile.uri}`);
+        return (0,external_rdflib_namespaceObject.sym)(dirUri + filename);
+    }
+    function isNotFoundError(err) {
+        var _a;
+        if (((_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status) === 404)
+            return true;
+        const text = `${(err === null || err === void 0 ? void 0 : err.message) || err || ''}`;
+        return text.includes('404') || text.includes('Not Found');
+    }
+    async function ensureContainerExists(containerUri) {
+        const containerNode = (0,external_rdflib_namespaceObject.sym)(containerUri);
+        try {
+            await store.fetcher.load(containerNode);
+            return;
+        }
+        catch (err) {
+            if (!isNotFoundError(err))
+                throw err;
+        }
+        await containerLogic.createContainer(containerUri);
+    }
+    async function ensureOwnerOnlyAclForSettings(user, preferencesFile) {
+        var _a;
+        const dirUri = docDirUri(preferencesFile);
+        if (!dirUri)
+            throw new Error(`Cannot derive settings directory from ${preferencesFile.uri}`);
+        await ensureContainerExists(dirUri);
+        const containerNode = (0,external_rdflib_namespaceObject.sym)(dirUri);
+        let aclDocUri;
+        try {
+            await store.fetcher.load(containerNode);
+            aclDocUri = (_a = store.any(containerNode, ACL_LINK)) === null || _a === void 0 ? void 0 : _a.value;
+        }
+        catch (err) {
+            if (!isNotFoundError(err))
+                throw err;
+        }
+        if (!aclDocUri) {
+            // Fallback for servers/tests where rel=acl is not exposed in mocked headers.
+            aclDocUri = `${dirUri}.acl`;
+        }
+        const aclDoc = (0,external_rdflib_namespaceObject.sym)(aclDocUri);
+        try {
+            await store.fetcher.load(aclDoc);
+            return;
+        }
+        catch (err) {
+            if (!isNotFoundError(err))
+                throw err;
+        }
+        await store.fetcher.webOperation('PUT', aclDoc.uri, {
+            data: ownerOnlyContainerAclDocument(user.uri),
+            contentType: 'text/turtle'
+        });
+    }
+    async function ensurePublicTypeIndexAclOnCreate(user, publicTypeIndex, ensureAcl = false) {
+        var _a, _b, _c;
+        const created = await utilityLogic.loadOrCreateWithContentOnCreate(publicTypeIndex, publicTypeIndexDocument());
+        if (!created && !ensureAcl)
+            return;
+        let aclDocUri;
+        try {
+            await store.fetcher.load(publicTypeIndex);
+            aclDocUri = (_a = store.any(publicTypeIndex, ACL_LINK)) === null || _a === void 0 ? void 0 : _a.value;
+        }
+        catch (err) {
+            if (!isNotFoundError(err))
+                throw err;
+        }
+        if (!aclDocUri) {
+            aclDocUri = `${publicTypeIndex.uri}.acl`;
+        }
+        const aclDoc = (0,external_rdflib_namespaceObject.sym)(aclDocUri);
+        try {
+            await store.fetcher.webOperation('PUT', aclDoc.uri, {
+                data: publicTypeIndexAclDocument(user.uri, publicTypeIndex.uri),
+                contentType: 'text/turtle',
+                headers: { 'If-None-Match': '*' }
+            });
+        }
+        catch (err) {
+            const status = (_c = (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.status) !== null && _c !== void 0 ? _c : err === null || err === void 0 ? void 0 : err.status;
+            if (status !== 412)
+                throw err;
+        }
+    }
+    async function ensurePrivateTypeIndexOnCreate(privateTypeIndex) {
+        await utilityLogic.loadOrCreateWithContentOnCreate(privateTypeIndex, privateTypeIndexDocument());
+    }
+    async function initializePreferencesDefaults(user, preferencesFile) {
+        const preferencesDoc = preferencesFile.doc();
+        const profileDoc = user.doc();
+        await store.fetcher.load(preferencesDoc);
+        const profilePublicTypeIndex = store.any(user, ns.solid('publicTypeIndex'), null, profileDoc);
+        const preferencesPublicTypeIndex = store.any(user, ns.solid('publicTypeIndex'), null, preferencesDoc);
+        const publicTypeIndex = profilePublicTypeIndex ||
+            preferencesPublicTypeIndex ||
+            suggestTypeIndexInPreferences(preferencesFile, 'publicTypeIndex.ttl');
+        const privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), null, preferencesDoc) ||
+            suggestTypeIndexInPreferences(preferencesFile, 'privateTypeIndex.ttl');
+        // Keep discovery consistent with typeIndexLogic, which resolves publicTypeIndex from the profile doc.
+        const createdProfilePublicTypeIndexLink = !profilePublicTypeIndex;
+        if (createdProfilePublicTypeIndexLink) {
+            await utilityLogic.followOrCreateLinkWithContentOnCreate(user, ns.solid('publicTypeIndex'), publicTypeIndex, profileDoc, publicTypeIndexDocument());
+        }
+        const toInsert = [];
+        if (!store.holds(preferencesDoc, ns.rdf('type'), ns.space('ConfigurationFile'), preferencesDoc)) {
+            toInsert.push((0,external_rdflib_namespaceObject.st)(preferencesDoc, ns.rdf('type'), ns.space('ConfigurationFile'), preferencesDoc));
+        }
+        if (!store.holds(preferencesDoc, ns.dct('title'), undefined, preferencesDoc)) {
+            toInsert.push((0,external_rdflib_namespaceObject.st)(preferencesDoc, ns.dct('title'), (0,external_rdflib_namespaceObject.literal)('Preferences file'), preferencesDoc));
+        }
+        if (!store.holds(user, ns.solid('publicTypeIndex'), publicTypeIndex, preferencesDoc)) {
+            toInsert.push((0,external_rdflib_namespaceObject.st)(user, ns.solid('publicTypeIndex'), publicTypeIndex, preferencesDoc));
+        }
+        if (!store.holds(user, ns.solid('privateTypeIndex'), privateTypeIndex, preferencesDoc)) {
+            toInsert.push((0,external_rdflib_namespaceObject.st)(user, ns.solid('privateTypeIndex'), privateTypeIndex, preferencesDoc));
+        }
+        if (toInsert.length > 0) {
+            await store.updater.update([], toInsert);
+            await store.fetcher.load(preferencesDoc);
+        }
+        await ensurePublicTypeIndexAclOnCreate(user, publicTypeIndex, createdProfilePublicTypeIndexLink);
+        await ensurePrivateTypeIndexOnCreate(privateTypeIndex);
+    }
+    async function ensurePreferencesDocExists(preferencesFile) {
+        var _a, _b;
+        try {
+            const created = await utilityLogic.loadOrCreateWithContentOnCreate(preferencesFile, preferencesFileDocument());
+            if (created) {
+                return true;
+            }
+            return false;
+        }
+        catch (err) {
+            if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                throw new UnauthorizedError();
+            }
+            if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 403) {
+                if (differentOrigin(preferencesFile)) {
+                    throw new CrossOriginForbiddenError();
+                }
+                throw new SameOriginForbiddenError();
+            }
+            throw err;
+        }
+    }
+    /**
+     * loads the preference without throwing errors - if it can create it it does so.
+     * remark: it still throws error if it cannot load profile.
+     * @param user
+     * @returns undefined if preferenceFile cannot be returned or NamedNode if it can find it or create it
+     */
+    async function silencedLoadPreferences(user) {
+        try {
+            return await loadPreferences(user);
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+    /**
+     * loads the preference without returning different errors if it cannot create or load it.
+     * remark: it also throws error if it cannot load profile.
+     * @param user
+     * @returns undefined if preferenceFile cannot be an Error or NamedNode if it can find it or create it
+     */
+    async function loadPreferences(user) {
+        const cachedPreferencesFile = cachedPreferencesFileByWebId.get(user.uri);
+        if (cachedPreferencesFile) {
+            return cachedPreferencesFile;
+        }
+        const inFlight = loadPreferencesInFlight.get(user.uri);
+        if (inFlight) {
+            return inFlight;
+        }
+        const run = (async () => {
+            var _a;
+            await loadProfile(user);
+            const possiblePreferencesFile = suggestPreferencesFile(user);
+            let preferencesFile;
+            try {
+                const existingPreferencesFile = store.any(user, ns.space('preferencesFile'), null, user.doc());
+                if (existingPreferencesFile) {
+                    preferencesFile = existingPreferencesFile;
+                }
+                else {
+                    preferencesFile = await utilityLogic.followOrCreateLink(user, ns.space('preferencesFile'), possiblePreferencesFile, user.doc());
+                }
+                await ensureOwnerOnlyAclForSettings(user, preferencesFile);
+                await ensurePreferencesDocExists(preferencesFile);
+                await initializePreferencesDefaults(user, preferencesFile);
+            }
+            catch (err) {
+                const message = `User ${user} has no pointer in profile to preferences file.`;
+                warn(message);
+                // we are listing the possible errors
+                if (err instanceof NotEditableError) {
+                    throw err;
+                }
+                if (err instanceof WebOperationError) {
+                    throw err;
+                }
+                if (err instanceof UnauthorizedError) {
+                    throw err;
+                }
+                if (err instanceof CrossOriginForbiddenError) {
+                    throw err;
+                }
+                if (err instanceof SameOriginForbiddenError) {
+                    throw err;
+                }
+                if (err instanceof FetchError) {
+                    throw err;
+                }
+                throw err;
+            }
+            try {
+                await store.fetcher.load(preferencesFile);
+            }
+            catch (err) { // Maybe a permission problem or origin problem
+                const msg = `Unable to load preference of user ${user}: ${err}`;
+                if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                    // Self-heal when a stale profile pointer references a missing preferences file.
+                    await ensureOwnerOnlyAclForSettings(user, preferencesFile);
+                    await ensurePreferencesDocExists(preferencesFile);
+                    await initializePreferencesDefaults(user, preferencesFile);
+                    await store.fetcher.load(preferencesFile);
+                    return preferencesFile;
+                }
+                warn(msg);
+                if (err.response.status === 401) {
+                    throw new UnauthorizedError();
+                }
+                if (err.response.status === 403) {
+                    if (differentOrigin(preferencesFile)) {
+                        throw new CrossOriginForbiddenError();
+                    }
+                    throw new SameOriginForbiddenError();
+                }
+                /*if (err.response.status === 404) {
+                    throw new NotFoundError();
+                }*/
+                throw new Error(msg);
+            }
+            cachedPreferencesFileByWebId.set(user.uri, preferencesFile);
+            return preferencesFile;
+        })();
+        loadPreferencesInFlight.set(user.uri, run);
+        try {
+            return await run;
+        }
+        finally {
+            if (loadPreferencesInFlight.get(user.uri) === run) {
+                loadPreferencesInFlight.delete(user.uri);
+            }
+        }
+    }
+    async function loadProfile(user) {
+        if (!user) {
+            throw new Error('loadProfile: no user given.');
+        }
+        try {
+            await store.fetcher.load(user.doc());
+        }
+        catch (err) {
+            throw new Error(`Unable to load profile of user ${user}: ${err}`);
+        }
+        return user.doc();
+    }
+    async function loadMe() {
+        const me = authn.currentUser();
+        if (me === null) {
+            throw new Error('Current user not found! Not logged in?');
+        }
+        await store.fetcher.load(me.doc());
+        return me;
+    }
+    function getPodRoot(user) {
+        const podRoot = findStorage(user);
+        if (!podRoot) {
+            throw new Error('User pod root not found!');
+        }
+        return podRoot;
+    }
+    async function getMainInbox(user) {
+        await store.fetcher.load(user);
+        const mainInbox = store.any(user, ns.ldp('inbox'), undefined, user.doc());
+        if (!mainInbox) {
+            throw new Error('User main inbox not found!');
+        }
+        return mainInbox;
+    }
+    function findStorage(me) {
+        return store.any(me, ns.space('storage'), undefined, me.doc());
+    }
+    return {
+        loadMe,
+        getPodRoot,
+        getMainInbox,
+        findStorage,
+        loadPreferences,
+        loadProfile,
+        silencedLoadPreferences
+    };
+}
+
+;// ./src/typeIndex/typeIndexLogic.ts
+
+
+
+
+
+function createTypeIndexLogic(store, authn, profileLogic, utilityLogic) {
+    const ns = ns_ns;
+    function isAbsoluteHttpUri(uri) {
+        return !!uri && (uri.startsWith('https://') || uri.startsWith('http://'));
+    }
+    function getRegistrations(instance, theClass) {
+        return store
+            .each(undefined, ns.solid('instance'), instance)
+            .filter((r) => {
+            return store.holds(r, ns.solid('forClass'), theClass);
+        });
+    }
+    async function loadTypeIndexesFor(user) {
+        if (!user)
+            throw new Error('loadTypeIndexesFor: No user given');
+        const profile = await profileLogic.loadProfile(user);
+        let suggestion = null;
+        try {
+            suggestion = suggestPublicTypeIndex(user);
+        }
+        catch (err) {
+            const message = `User ${user} has no usable profile document directory for publicTypeIndex.`;
+            warn(message);
+        }
+        let publicTypeIndex;
+        try {
+            const existingPublicTypeIndex = store.any(user, ns.solid('publicTypeIndex'), undefined, profile);
+            if (existingPublicTypeIndex) {
+                publicTypeIndex = existingPublicTypeIndex;
+            }
+            else if (suggestion) {
+                publicTypeIndex = await utilityLogic.followOrCreateLinkWithContentOnCreate(user, ns.solid('publicTypeIndex'), suggestion, profile, publicTypeIndexDocument());
+            }
+            else {
+                publicTypeIndex = null;
+            }
+        }
+        catch (err) {
+            const message = `User ${user} has no pointer in profile to publicTypeIndex file: ${err}`;
+            warn(message);
+        }
+        const publicScopes = publicTypeIndex ? [{ label: 'public', index: publicTypeIndex, agent: user }] : [];
+        let preferencesFile;
+        try {
+            preferencesFile = await profileLogic.silencedLoadPreferences(user);
+        }
+        catch (err) {
+            preferencesFile = null;
+        }
+        let privateScopes;
+        if (preferencesFile) { // watch out - can be in either as spec was not clear.  Legacy is profile.
+            // If there is a legacy one linked from the profile, use that.
+            // Otherwiae use or make one linked from Preferences
+            let suggestedPrivateTypeIndex = null;
+            try {
+                suggestedPrivateTypeIndex = suggestPrivateTypeIndex(preferencesFile);
+            }
+            catch (err) {
+                const message = `User ${user} has no usable preferences document directory for privateTypeIndex.`;
+                warn(message);
+            }
+            let privateTypeIndex;
+            try {
+                const existingPrivateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile);
+                if (existingPrivateTypeIndex) {
+                    privateTypeIndex = existingPrivateTypeIndex;
+                }
+                else if (suggestedPrivateTypeIndex) {
+                    privateTypeIndex = await utilityLogic.followOrCreateLinkWithContentOnCreate(user, ns.solid('privateTypeIndex'), suggestedPrivateTypeIndex, preferencesFile, privateTypeIndexDocument());
+                }
+                else {
+                    privateTypeIndex = null;
+                }
+            }
+            catch (err) {
+                const message = `User ${user} has no pointer in preference file to privateTypeIndex file: ${err}`;
+                warn(message);
+            }
+            privateScopes = privateTypeIndex ? [{ label: 'private', index: privateTypeIndex, agent: user }] : [];
+        }
+        else {
+            privateScopes = [];
+        }
+        const scopes = publicScopes.concat(privateScopes);
+        if (scopes.length === 0)
+            return scopes;
+        const files = scopes.map(scope => scope.index);
+        try {
+            await store.fetcher.load(files);
+        }
+        catch (err) {
+            warn('Problems loading type index: ', err);
+        }
+        return scopes;
+    }
+    async function loadCommunityTypeIndexes(user) {
+        let preferencesFile;
+        try {
+            preferencesFile = await profileLogic.silencedLoadPreferences(user);
+        }
+        catch (err) {
+            const message = `User ${user} has no pointer in profile to preferences file.`;
+            warn(message);
+        }
+        if (preferencesFile) { // For now, pick up communities as simple links from the preferences file.
+            const communities = store.each(user, ns.solid('community'), undefined, preferencesFile).concat(store.each(user, ns.solid('community'), undefined, user.doc()));
+            let result = [];
+            for (const org of communities) {
+                if (org.termType !== 'NamedNode' || !isAbsoluteHttpUri(org.uri)) {
+                    warn(`Skipping malformed community node for ${user}: ${org}`);
+                    continue;
+                }
+                try {
+                    result = result.concat(await loadTypeIndexesFor(org));
+                }
+                catch (err) {
+                    warn(`Skipping community type indexes for ${org.uri}: ${err}`);
+                }
+            }
+            return result;
+        }
+        return []; // No communities
+    }
+    async function loadAllTypeIndexes(user) {
+        return (await loadTypeIndexesFor(user)).concat(await loadCommunityTypeIndexes(user));
+    }
+    async function getScopedAppInstances(klass, user) {
+        const scopes = await loadAllTypeIndexes(user);
+        let scopedApps = [];
+        for (const scope of scopes) {
+            const scopedApps0 = await getScopedAppsFromIndex(scope, klass);
+            scopedApps = scopedApps.concat(scopedApps0);
+        }
+        return scopedApps;
+    }
+    // This is the function signature which used to be in solid-ui/logic
+    // Recommended to use getScopedAppInstances instead as it provides more information.
+    //
+    async function getAppInstances(klass) {
+        const user = authn.currentUser();
+        if (!user)
+            throw new Error('getAppInstances: Must be logged in to find apps.');
+        const scopedAppInstances = await getScopedAppInstances(klass, user);
+        return scopedAppInstances.map(scoped => scoped.instance);
+    }
+    function docDirUri(node) {
+        const doc = node.doc();
+        const dir = doc.dir();
+        if ((dir === null || dir === void 0 ? void 0 : dir.uri) && isAbsoluteHttpUri(dir.uri))
+            return dir.uri;
+        const docUri = doc.uri;
+        if (!docUri || !isAbsoluteHttpUri(docUri)) {
+            log(`docDirUri: missing or non-http(s) doc uri for ${node === null || node === void 0 ? void 0 : node.uri}`);
+            return null;
+        }
+        const withoutFragment = docUri.split('#')[0];
+        const lastSlash = withoutFragment.lastIndexOf('/');
+        if (lastSlash === -1) {
+            log(`docDirUri: no slash in doc uri ${docUri}`);
+            return null;
+        }
+        return withoutFragment.slice(0, lastSlash + 1);
+    }
+    function suggestPublicTypeIndex(me) {
+        const dirUri = docDirUri(me);
+        if (!dirUri)
+            throw new Error(`suggestPublicTypeIndex: Cannot derive directory for ${me.uri}`);
+        return (0,external_rdflib_namespaceObject.sym)(dirUri + 'publicTypeIndex.ttl');
+    }
+    // Note this one is based off the pref file not the profile
+    function suggestPrivateTypeIndex(preferencesFile) {
+        const dirUri = docDirUri(preferencesFile);
+        if (!dirUri)
+            throw new Error(`suggestPrivateTypeIndex: Cannot derive directory for ${preferencesFile.uri}`);
+        return (0,external_rdflib_namespaceObject.sym)(dirUri + 'privateTypeIndex.ttl');
+    }
+    /*
+    * Register a new app in a type index
+    * used in chat in bookmark.js (solid-ui)
+    * Returns the registration object if successful else null
+    */
+    async function registerInTypeIndex(instance, index, theClass) {
+        const registration = newThing(index);
+        const ins = [
+            // See https://github.com/solid/solid/blob/main/proposals/data-discovery.md
+            (0,external_rdflib_namespaceObject.st)(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
+            (0,external_rdflib_namespaceObject.st)(registration, ns.solid('forClass'), theClass, index),
+            (0,external_rdflib_namespaceObject.st)(registration, ns.solid('instance'), instance, index)
+        ];
+        try {
+            await store.updater.update([], ins);
+        }
+        catch (err) {
+            const msg = `Unable to register ${instance} in index ${index}: ${err}`;
+            console.warn(msg);
+            return null;
+        }
+        return registration;
+    }
+    async function deleteTypeIndexRegistration(item) {
+        const reg = store.the(null, ns.solid('instance'), item.instance, item.scope.index);
+        if (!reg)
+            throw new Error(`deleteTypeIndexRegistration: No registration found for ${item.instance}`);
+        const statements = store.statementsMatching(reg, null, null, item.scope.index);
+        await store.updater.update(statements, []);
+    }
+    async function getScopedAppsFromIndex(scope, theClass) {
+        const index = scope.index;
+        const results = [];
+        const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
+            .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
+            .map(st => st.subject);
+        for (const reg of registrations) {
+            const klass = store.any(reg, ns.solid('forClass'), null, index);
+            if (!theClass || klass.sameTerm(theClass)) {
+                const instances = store.each(reg, ns.solid('instance'), null, index);
+                for (const instance of instances) {
+                    results.push({ instance, type: klass, scope });
+                }
+                const containers = store.each(reg, ns.solid('instanceContainer'), null, index);
+                for (const instance of containers) {
+                    await store.fetcher.load(instance);
+                    results.push({ instance: (0,external_rdflib_namespaceObject.sym)(instance.value), type: klass, scope });
+                }
+            }
+        }
+        return results;
+    }
+    return {
+        registerInTypeIndex,
+        getRegistrations,
+        loadTypeIndexesFor,
+        loadCommunityTypeIndexes,
+        loadAllTypeIndexes,
+        getScopedAppInstances,
+        getAppInstances,
+        suggestPublicTypeIndex,
+        suggestPrivateTypeIndex,
+        deleteTypeIndexRegistration,
+        getScopedAppsFromIndex
+    };
+}
+
+;// ./src/util/utilityLogic.ts
+
+
+
+
+function createUtilityLogic(store, aclLogic, containerLogic) {
+    async function recursiveDelete(containerNode) {
+        try {
+            if (containerLogic.isContainer(containerNode)) {
+                const aclDocUrl = await aclLogic.findAclDocUrl(containerNode);
+                await store.fetcher._fetch(aclDocUrl, { method: 'DELETE' });
+                const containerMembers = await containerLogic.getContainerMembers(containerNode);
+                await Promise.all(containerMembers.map((url) => recursiveDelete(url)));
+            }
+            return store.fetcher._fetch(containerNode.value, { method: 'DELETE' });
+        }
+        catch (e) {
+            log(`Please manually remove ${containerNode.value} from your system.`, e);
+        }
+    }
+    /**
+     * Create a resource if it really does not exist.
+     * Be absolutely sure something does not exist before creating a new empty file,
+     * as otherwise existing content could be deleted.
+     */
+    async function loadOrCreateIfNotExists(doc) {
+        var _a, _b, _c, _d, _e;
+        try {
+            return await store.fetcher.load(doc);
+        }
+        catch (err) {
+            if (((_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                try {
+                    await store.fetcher.webOperation('PUT', doc.uri, {
+                        data: '',
+                        contentType: 'text/turtle',
+                        headers: { 'If-None-Match': '*' }
+                    });
+                }
+                catch (putErr) {
+                    const status = (_c = (_b = putErr === null || putErr === void 0 ? void 0 : putErr.response) === null || _b === void 0 ? void 0 : _b.status) !== null && _c !== void 0 ? _c : putErr === null || putErr === void 0 ? void 0 : putErr.status;
+                    if (status !== 412) {
+                        const msg = `createIfNotExists: PUT FAILED: ${doc}: ${putErr}`;
+                        throw new WebOperationError(msg);
+                    }
+                }
+                return await store.fetcher.load(doc);
+            }
+            if (((_d = err === null || err === void 0 ? void 0 : err.response) === null || _d === void 0 ? void 0 : _d.status) === 401) {
+                throw new UnauthorizedError();
+            }
+            if (((_e = err === null || err === void 0 ? void 0 : err.response) === null || _e === void 0 ? void 0 : _e.status) === 403) {
+                if (differentOrigin(doc)) {
+                    throw new CrossOriginForbiddenError();
+                }
+                throw new SameOriginForbiddenError();
+            }
+            const msg = `createIfNotExists doc load error: ${doc}: ${err}`;
+            throw new FetchError(err === null || err === void 0 ? void 0 : err.status, `${(err === null || err === void 0 ? void 0 : err.message) || ''}${msg}`);
+        }
+    }
+    async function loadOrCreateWithContentOnCreate(doc, data) {
+        var _a, _b, _c, _d;
+        try {
+            await store.fetcher.load(doc);
+            return false;
+        }
+        catch (err) {
+            const status = (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : err === null || err === void 0 ? void 0 : err.status;
+            if (status !== 404) {
+                throw err;
+            }
+        }
+        try {
+            await store.fetcher.webOperation('PUT', doc.uri, {
+                data,
+                contentType: 'text/turtle',
+                headers: { 'If-None-Match': '*' }
+            });
+            return true;
+        }
+        catch (err) {
+            const status = (_d = (_c = err === null || err === void 0 ? void 0 : err.response) === null || _c === void 0 ? void 0 : _c.status) !== null && _d !== void 0 ? _d : err === null || err === void 0 ? void 0 : err.status;
+            if (status === 412) {
+                // Another client created the resource between our 404 check and PUT.
+                return false;
+            }
+            throw err;
+        }
+    }
+    /*
+     * Follow link from this doc to another thing, or else make a new link.
+     * Returns existing object, or creates it if non-existent.
+     */
+    async function followOrCreateLink(subject, predicate, object, doc) {
+        await store.fetcher.load(doc);
+        const result = store.any(subject, predicate, null, doc);
+        if (result)
+            return result;
+        if (!store.updater.editable(doc)) {
+            const msg = `followOrCreateLink: cannot edit ${doc.value}`;
+            warn(msg);
+            throw new NotEditableError(msg);
+        }
+        try {
+            await store.updater.update([], [(0,external_rdflib_namespaceObject.st)(subject, predicate, object, doc)]);
+        }
+        catch (err) {
+            const msg = `followOrCreateLink: Error making link in ${doc} to ${object}: ${err}`;
+            warn(msg);
+            throw new WebOperationError(err);
+        }
+        try {
+            await loadOrCreateIfNotExists(object);
+        }
+        catch (err) {
+            warn(`followOrCreateLink: Error loading or saving new linked document: ${object}: ${err}`);
+            throw err;
+        }
+        return object;
+    }
+    async function followOrCreateLinkWithContentOnCreate(subject, predicate, object, doc, data) {
+        await store.fetcher.load(doc);
+        const result = store.any(subject, predicate, null, doc);
+        if (result)
+            return result;
+        if (!store.updater.editable(doc)) {
+            const msg = `followOrCreateLinkWithContentOnCreate: cannot edit ${doc.value}`;
+            warn(msg);
+            throw new NotEditableError(msg);
+        }
+        try {
+            await store.updater.update([], [(0,external_rdflib_namespaceObject.st)(subject, predicate, object, doc)]);
+        }
+        catch (err) {
+            const msg = `followOrCreateLinkWithContentOnCreate: Error making link in ${doc} to ${object}: ${err}`;
+            warn(msg);
+            throw new WebOperationError(msg);
+        }
+        try {
+            await loadOrCreateWithContentOnCreate(object, data);
+        }
+        catch (err) {
+            warn(`followOrCreateLinkWithContentOnCreate: Error loading or saving new linked document: ${object}: ${err}`);
+            throw err;
+        }
+        return object;
+    }
+    // Copied from
+    // https://github.com/solidos/web-access-control-tests/blob/v3.0.0/test/surface/delete.test.ts#L5
+    async function setSinglePeerAccess(options) {
+        let str = [
+            '@prefix acl: <http://www.w3.org/ns/auth/acl#>.',
+            '',
+            '<#alice> a acl:Authorization;\n  acl:agent <' + options.ownerWebId + '>;',
+            `  acl:accessTo <${options.target}>;`,
+            `  acl:default <${options.target}>;`,
+            '  acl:mode acl:Read, acl:Write, acl:Control.',
+            ''
+        ].join('\n');
+        if (options.accessToModes) {
+            str += [
+                '<#bobAccessTo> a acl:Authorization;',
+                `  acl:agent <${options.peerWebId}>;`,
+                `  acl:accessTo <${options.target}>;`,
+                `  acl:mode ${options.accessToModes}.`,
+                ''
+            ].join('\n');
+        }
+        if (options.defaultModes) {
+            str += [
+                '<#bobDefault> a acl:Authorization;',
+                `  acl:agent <${options.peerWebId}>;`,
+                `  acl:default <${options.target}>;`,
+                `  acl:mode ${options.defaultModes}.`,
+                ''
+            ].join('\n');
+        }
+        const aclDocUrl = await aclLogic.findAclDocUrl((0,external_rdflib_namespaceObject.sym)(options.target));
+        return store.fetcher._fetch(aclDocUrl, {
+            method: 'PUT',
+            body: str,
+            headers: [['Content-Type', 'text/turtle']]
+        });
+    }
+    async function createEmptyRdfDoc(doc, comment) {
+        await store.fetcher.webOperation('PUT', doc.uri, {
+            data: `# ${new Date()} ${comment}\n`,
+            contentType: 'text/turtle'
+        });
+    }
+    return {
+        recursiveDelete,
+        setSinglePeerAccess,
+        createEmptyRdfDoc,
+        followOrCreateLink,
+        followOrCreateLinkWithContentOnCreate,
+        loadOrCreateIfNotExists,
+        loadOrCreateWithContentOnCreate
+    };
+}
+
+;// ./src/logic/solidLogic.ts
+
+
+
+
+
+
+
+
+
+
+/*
+** It is important to distinquish `fetch`, a function provided by the browser
+** and `Fetcher`, a helper object for the rdflib Store which turns it
+** into a `ConnectedStore` or a `LiveStore`.  A Fetcher object is
+** available at store.fetcher, and `fetch` function at `store.fetcher._fetch`,
+*/
+function createSolidLogic(specialFetch, session) {
+    log('SolidLogic: Unique instance created.  There should only be one of these.');
+    const store = external_rdflib_namespaceObject.graph();
+    external_rdflib_namespaceObject.fetcher(store, { fetch: specialFetch.fetch }); // Attach a web I/O module, store.fetcher
+    store.updater = new external_rdflib_namespaceObject.UpdateManager(store); // Add real-time live updates store.updater
+    store.features = []; // disable automatic node merging on store load
+    const authn = new SolidAuthnLogic(session);
+    const acl = createAclLogic(store);
+    const containerLogic = createContainerLogic(store);
+    const utilityLogic = createUtilityLogic(store, acl, containerLogic);
+    const profile = createProfileLogic(store, authn, utilityLogic);
+    const chat = createChatLogic(store, profile);
+    const inbox = createInboxLogic(store, profile, utilityLogic, containerLogic, acl);
+    const typeIndex = createTypeIndexLogic(store, authn, profile, utilityLogic);
+    log('SolidAuthnLogic initialized');
+    function load(doc) {
+        return store.fetcher.load(doc);
+    }
+    // @@@@ use the one in rdflib.js when it is available and delete this
+    function updatePromise(del, ins = []) {
+        return new Promise((resolve, reject) => {
+            store.updater.update(del, ins, function (_uri, ok, errorBody) {
+                if (!ok) {
+                    reject(new Error(errorBody));
+                }
+                else {
+                    resolve();
+                }
+            }); // callback
+        }); // promise
+    }
+    function clearStore() {
+        store.statements.slice().forEach(store.remove.bind(store));
+    }
+    return {
+        store,
+        authn,
+        acl,
+        inbox,
+        chat,
+        profile,
+        typeIndex,
+        load,
+        updatePromise,
+        clearStore
+    };
+}
+
+;// ./src/logic/solidLogicSingleton.ts
+
+
+
+const _fetch = async (url, requestInit) => {
+    var _a;
+    const omitCreds = requestInit && requestInit.credentials && requestInit.credentials == 'omit';
+    const sessionAny = authSession;
+    const sessionWebId = ((_a = sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.info) === null || _a === void 0 ? void 0 : _a.webId) || (sessionAny === null || sessionAny === void 0 ? void 0 : sessionAny.webId);
+    if (sessionWebId && !omitCreds) { // see https://github.com/solidos/solidos/issues/114
+        // In fact fetch should respect credentials omit itself
+        const authenticatedFetch = (typeof sessionAny.fetch === 'function')
+            ? sessionAny.fetch.bind(sessionAny)
+            : (typeof sessionAny.authFetch === 'function' ? sessionAny.authFetch.bind(sessionAny) : null);
+        if (authenticatedFetch) {
+            return authenticatedFetch(url, requestInit);
+        }
+        return window.fetch(url, requestInit);
+    }
+    else {
+        return window.fetch(url, requestInit);
+    }
+};
+// Global singleton pattern to ensure unique store across library versions
+const SINGLETON_SYMBOL = Symbol.for('solid-logic-singleton');
+const globalTarget = (typeof window !== 'undefined' ? window : __webpack_require__.g);
+function getOrCreateSingleton() {
+    if (!globalTarget[SINGLETON_SYMBOL]) {
+        log('SolidLogic: Creating new global singleton instance.');
+        globalTarget[SINGLETON_SYMBOL] = createSolidLogic({ fetch: _fetch }, authSession);
+        log('Unique quadstore initialized.');
+    }
+    else {
+        log('SolidLogic: Using existing global singleton instance.');
+    }
+    return globalTarget[SINGLETON_SYMBOL];
+}
+//this const makes solidLogicSingleton global accessible in mashlib
+const solidLogicSingleton = getOrCreateSingleton();
+
+
+;// ./src/authn/serverLogout.ts
+async function performServerSideLogout(options = {}) {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    const issuer = options.issuer || '';
+    const postLogoutRedirectPath = options.postLogoutRedirectPath || '/';
+    // Provider-specific logout endpoint discovery (OIDC end_session_endpoint).
+    try {
+        if (issuer) {
+            const wellKnownUri = new URL(issuer);
+            wellKnownUri.pathname = '/.well-known/openid-configuration';
+            const wellKnownResult = await fetch(wellKnownUri.toString(), { credentials: 'include' });
+            if (wellKnownResult.status === 200) {
+                const openidConfiguration = await wellKnownResult.json();
+                if (openidConfiguration && openidConfiguration.end_session_endpoint) {
+                    await fetch(openidConfiguration.end_session_endpoint, { credentials: 'include' });
+                }
+            }
+        }
+    }
+    catch (_err) {
+        // Continue with local logout even if provider logout is unavailable.
+    }
+    // NSS well-known logout endpoint clears cookie-backed server sessions.
+    try {
+        const logoutResponse = await fetch('/.well-known/solid/logout', { credentials: 'include' });
+        if (logoutResponse.ok || logoutResponse.redirected) {
+            window.location.assign(postLogoutRedirectPath);
+            return true;
+        }
+    }
+    catch (_err) {
+        // Not all deployments expose this endpoint.
+    }
+    return false;
+}
+
+;// ./src/issuer/issuerLogic.ts
+const DEFAULT_ISSUERS = [
+    {
+        name: 'Solid Community',
+        uri: 'https://solidcommunity.net'
+    },
+    {
+        name: 'Solid Web',
+        uri: 'https://solidweb.org'
+    },
+    {
+        name: 'Solid Web ME',
+        uri: 'https://solidweb.me'
+    },
+    {
+        name: 'Inrupt.com',
+        uri: 'https://login.inrupt.com'
+    }
+];
+/**
+ * @returns - A list of suggested OIDC issuers
+ */
+function getSuggestedIssuers() {
+    // Suggest a default list of OIDC issuers
+    const issuers = [...DEFAULT_ISSUERS];
+    // Suggest the current host if not already included
+    const { host, origin } = new URL(location.href);
+    const hosts = issuers.map(({ uri }) => new URL(uri).host);
+    if (!hosts.includes(host)) {
+        issuers.unshift({ name: host, uri: origin });
+    }
+    return issuers;
+}
+
+;// ./src/index.ts
+// Make these variables directly accessible as it is what you need most of the time
+// This also makes these variable globaly accesible in mashlib
+
+const authn = solidLogicSingleton.authn;
+const src_authSession = solidLogicSingleton.authn.authSession;
+const store = solidLogicSingleton.store;
+
+
+
+
+
+
+
+
+export { ACL_LINK, CrossOriginForbiddenError, FetchError, NotEditableError, NotFoundError, SameOriginForbiddenError, UnauthorizedError, WebOperationError, appContext, src_authSession as authSession, authn, createTypeIndexLogic, getSuggestedIssuers, offlineTestID, performServerSideLogout, solidLogicSingleton, store };
+
+//# sourceMappingURL=solid-logic.esm.js.map