		@@ -1,176 +0,64 @@
		'use strict';
		"use strict";

		var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _regenerator = require('babel-runtime/regenerator');

		var _regenerator2 = _interopRequireDefault(_regenerator);

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

		exports.authnFetch = authnFetch;

		require('isomorphic-fetch');
		require("isomorphic-fetch");

		var _urlUtil = require('./url-util');
		var _urlUtil = require("./url-util");

		var _host = require('./host');
		var _host = require("./host");

		var _session = require('./session');
		var _session = require("./session");

		var _webidOidc = require('./webid-oidc');
		var WebIdOidc = _interopRequireWildcard(require("./webid-oidc"));

		var WebIdOidc = _interopRequireWildcard(_webidOidc);
		/* global fetch, RequestInfo, Response */
		// Store the global fetch, so the user can safely override it
		const globalFetch = fetch;

		function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		// Store the global fetch, so the user can safely override it
		var globalFetch = fetch;
		/* global fetch, RequestInfo, Response */
		function authnFetch(storage) {
		var _this = this;
		return async (input, options) => {
		options = options \|\| {};
		const session = await (0, _session.getSession)(storage);
		const shouldShareCreds = await shouldShareCredentials(storage)(input);

		return function () {
		var _ref = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(input, options) {
		var session, shouldShareCreds, resp, _shouldShareCreds;
		if (session && shouldShareCreds) {
		return fetchWithCredentials(session, input, options);
		}

		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		options = options \|\| {};
		_context.next = 3;
		return (0, _session.getSession)(storage);
		const resp = await globalFetch(input, options);

		case 3:
		session = _context.sent;
		_context.next = 6;
		return shouldShareCredentials(storage)(input);
		if (resp.status === 401) {
		await (0, _host.updateHostFromResponse)(storage)(resp);
		const shouldShareCreds = await shouldShareCredentials(storage)(input);

		case 6:
		shouldShareCreds = _context.sent;
		if (session && shouldShareCreds) {
		return fetchWithCredentials(session, input, options);
		}
		}

		if (!(session && shouldShareCreds)) {
		_context.next = 9;
		break;
		}

		return _context.abrupt('return', fetchWithCredentials(session, input, options));

		case 9:
		_context.next = 11;
		return globalFetch(input, options);

		case 11:
		resp = _context.sent;

		if (!(resp.status === 401)) {
		_context.next = 20;
		break;
		}

		_context.next = 15;
		return (0, _host.updateHostFromResponse)(storage)(resp);

		case 15:
		_context.next = 17;
		return shouldShareCredentials(storage)(input);

		case 17:
		_shouldShareCreds = _context.sent;

		if (!(session && _shouldShareCreds)) {
		_context.next = 20;
		break;
		}

		return _context.abrupt('return', fetchWithCredentials(session, input, options));

		case 20:
		return _context.abrupt('return', resp);

		case 21:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, _this);
		}));

		return function (_x, _x2) {
		return _ref.apply(this, arguments);
		};
		}();
		return resp;
		};
		}

		function shouldShareCredentials(storage) {
		var _this2 = this;
		return async input => {
		const session = await (0, _session.getSession)(storage);

		return function () {
		var _ref2 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee2(input) {
		var session, requestHost;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		_context2.next = 2;
		return (0, _session.getSession)(storage);
		if (!session) {
		return false;
		}

		case 2:
		session = _context2.sent;

		if (session) {
		_context2.next = 5;
		break;
		}

		return _context2.abrupt('return', false);

		case 5:
		_context2.next = 7;
		return (0, _host.getHost)(storage)((0, _urlUtil.toUrlString)(input));

		case 7:
		requestHost = _context2.sent;
		return _context2.abrupt('return', requestHost != null && requestHost.requiresAuth);

		case 9:
		case 'end':
		return _context2.stop();
		}
		}
		}, _callee2, _this2);
		}));

		return function (_x3) {
		return _ref2.apply(this, arguments);
		};
		}();
		const requestHost = await (0, _host.getHost)(storage)((0, _urlUtil.toUrlString)(input));
		return requestHost != null && requestHost.requiresAuth;
		};
		}

		var fetchWithCredentials = function () {
		var _ref3 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee3(session, input, options) {
		return _regenerator2.default.wrap(function _callee3$(_context3) {
		while (1) {
		switch (_context3.prev = _context3.next) {
		case 0:
		return _context3.abrupt('return', WebIdOidc.fetchWithCredentials(session)(globalFetch, input, options));

		case 1:
		case 'end':
		return _context3.stop();
		}
		}
		}, _callee3, undefined);
		}));

		return function fetchWithCredentials(_x4, _x5, _x6) {
		return _ref3.apply(this, arguments);
		};
		}();
		const fetchWithCredentials = async (session, input, options) => {
		return WebIdOidc.fetchWithCredentials(session)(globalFetch, input, options);
		};

170

lib/host.js

		@@ -1,23 +0,10 @@
		'use strict';
		"use strict";

		var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});

		var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

		var _defineProperty3 = _interopRequireDefault(_defineProperty2);

		var _extends3 = require('babel-runtime/helpers/extends');

		var _extends4 = _interopRequireDefault(_extends3);

		var _regenerator = require('babel-runtime/regenerator');

		var _regenerator2 = _interopRequireDefault(_regenerator);

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

		exports.getHost = getHost;
		@@ -27,126 +14,59 @@ exports.saveHost = saveHost;

		var _session = require('./session');
		var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

		var _storage = require('./storage');
		var _session = require("./session");

		var _webidOidc = require('./webid-oidc');
		var _storage = require("./storage");

		var WebIdOidc = _interopRequireWildcard(_webidOidc);
		var WebIdOidc = _interopRequireWildcard(require("./webid-oidc"));

		function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		/* globalRequest, Response, URL */
		function getHost(storage) {
		var _this = this;
		return async url => {
		const _ref = new URL(url),
		host = _ref.host;

		return function () {
		var _ref = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(url) {
		var _ref2, host, session, _ref3, hosts;
		const session = await (0, _session.getSession)(storage);

		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		_ref2 = new URL(url), host = _ref2.host;
		_context.next = 3;
		return (0, _session.getSession)(storage);
		if (session && host === new URL(session.idp).host) {
		return {
		url: host,
		requiresAuth: true
		};
		}

		case 3:
		session = _context.sent;
		const _ref2 = await (0, _storage.getData)(storage),
		hosts = _ref2.hosts;

		if (!(session && host === new URL(session.idp).host)) {
		_context.next = 6;
		break;
		}
		return hosts && hosts[host];
		};
		}

		return _context.abrupt('return', { url: host, requiresAuth: true });

		case 6:
		_context.next = 8;
		return (0, _storage.getData)(storage);

		case 8:
		_ref3 = _context.sent;
		hosts = _ref3.hosts;
		return _context.abrupt('return', hosts && hosts[host]);

		case 11:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, _this);
		}));

		return function (_x) {
		return _ref.apply(this, arguments);
		};
		}();
		}
		/* globalRequest, Response, URL */
		function saveHost(storage) {
		var _this2 = this;

		return function () {
		var _ref5 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee2(_ref4) {
		var url = _ref4.url,
		requiresAuth = _ref4.requiresAuth;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		_context2.next = 2;
		return (0, _storage.updateStorage)(storage, function (data) {
		return (0, _extends4.default)({}, data, {
		hosts: (0, _extends4.default)({}, data.hosts, (0, _defineProperty3.default)({}, url, { requiresAuth: requiresAuth }))
		});
		});

		case 2:
		case 'end':
		return _context2.stop();
		}
		return async ({
		url,
		requiresAuth
		}) => {
		await (0, _storage.updateStorage)(storage, data => (0, _objectSpread2.default)({}, data, {
		hosts: (0, _objectSpread2.default)({}, data.hosts, {
		[url]: {
		requiresAuth
		}
		}, _callee2, _this2);
		})
		}));

		return function (_x2) {
		return _ref5.apply(this, arguments);
		};
		}();
		};
		}

		function updateHostFromResponse(storage) {
		var _this3 = this;
		return async resp => {
		if (WebIdOidc.requiresAuth(resp)) {
		const _ref3 = new URL(resp.url),
		host = _ref3.host;

		return function () {
		var _ref6 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee3(resp) {
		var _ref7, _host;

		return _regenerator2.default.wrap(function _callee3$(_context3) {
		while (1) {
		switch (_context3.prev = _context3.next) {
		case 0:
		if (!WebIdOidc.requiresAuth(resp)) {
		_context3.next = 4;
		break;
		}

		_ref7 = new URL(resp.url), _host = _ref7.host;
		_context3.next = 4;
		return saveHost(storage)({ url: _host, requiresAuth: true });

		case 4:
		case 'end':
		return _context3.stop();
		}
		}
		}, _callee3, _this3);
		}));

		return function (_x3) {
		return _ref6.apply(this, arguments);
		};
		}();
		await saveHost(storage)({
		url: host,
		requiresAuth: true
		});
		}
		};
		}

lib/index.js

		@@ -1,30 +0,20 @@
		'use strict';
		"use strict";

		var _getOwnPropertyNames = require('babel-runtime/core-js/object/get-own-property-names');
		const SolidAuthClient = require('./solid-auth-client').default; // Export a singleton instance of SolidAuthClient

		var _getOwnPropertyNames2 = _interopRequireDefault(_getOwnPropertyNames);

		var _solidAuthClient = require('./solid-auth-client');
		const auth = new SolidAuthClient(); // Bind methods to instance, so they can be invoked as regular functions
		// (e.g., to pass around the fetch function)

		var _solidAuthClient2 = _interopRequireDefault(_solidAuthClient);
		Object.getOwnPropertyNames(SolidAuthClient.prototype).forEach(property => {
		const value = auth[property];

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		// Export a singleton instance of SolidAuthClient
		var auth = new _solidAuthClient2.default();

		// Bind methods to instance, so they can be invoked as regular functions
		// (e.g., to pass around the fetch function)
		(0, _getOwnPropertyNames2.default)(_solidAuthClient2.default.prototype).forEach(function (property) {
		var value = auth[property];
		if (typeof value === 'function') {
		auth[property] = value.bind(auth);
		}
		});
		}); // Export the instance as an object for backward compatibility
		// (should become a default export)

		// Export the instance as an object for backward compatibility
		// (should become a default export of auth)
		module.exports = auth;
		module.exports = auth; // Expose window.SolidAuthClient for backward compatibility

		// Expose window.SolidAuthClient for backward compatibility
		if (typeof window !== 'undefined') {
		@@ -34,6 +24,6 @@ if ('SolidAuthClient' in window) {
		} else {
		var warned = false;
		let warned = false;
		Object.defineProperty(window, 'SolidAuthClient', {
		enumerable: true,
		get: function get() {
		get: () => {
		if (!warned) {
		@@ -44,2 +34,3 @@ warned = true;
		}

		return auth;
		@@ -46,0 +37,0 @@ }

253

lib/ipc.js

		@@ -1,204 +0,137 @@
		'use strict';
		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.combineHandlers = exports.server = exports.client = undefined;
		exports.combineHandlers = exports.server = exports.client = void 0;

		var _regenerator = require('babel-runtime/regenerator');
		var _v = _interopRequireDefault(require("uuid/v4"));

		var _regenerator2 = _interopRequireDefault(_regenerator);
		const NAMESPACE = 'solid-auth-client';

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
		const namespace = data => ({
		[NAMESPACE]: data
		});

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

		var _promise = require('babel-runtime/core-js/promise');

		var _promise2 = _interopRequireDefault(_promise);

		var _typeof2 = require('babel-runtime/helpers/typeof');

		var _typeof3 = _interopRequireDefault(_typeof2);

		var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

		var _defineProperty3 = _interopRequireDefault(_defineProperty2);

		var _v = require('uuid/v4');

		var _v2 = _interopRequireDefault(_v);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		/*
		This module describes a simple IPC interface for communicating between browser windows.
		Window.postMessage() is the transport interface, and a request/response interface
		is defined on top of it as follows:

		const request = {
		'solid-auth-client': {
		id: 'abcd-efgh-ijkl',
		method: 'doSomethingPlease',
		args: [ 'one', 'two', 'three' ]
		}
		const getNamespacedPayload = eventData => {
		if (!eventData \|\| typeof eventData !== 'object') {
		return null;
		}

		const response = {
		'solid-auth-client': {
		id: 'abcd-efgh-ijkl',
		ret: 'the_value'
		}
		}
		*/
		const payload = eventData[NAMESPACE];

		var NAMESPACE = 'solid-auth-client';


		var namespace = function namespace(data) {
		return (0, _defineProperty3.default)({}, NAMESPACE, data);
		};

		var getNamespacedPayload = function getNamespacedPayload(eventData) {
		if (!eventData \|\| (typeof eventData === 'undefined' ? 'undefined' : (0, _typeof3.default)(eventData)) !== 'object') {
		if (!payload \|\| typeof payload !== 'object') {
		return null;
		}
		var payload = eventData[NAMESPACE];
		if (!payload \|\| (typeof payload === 'undefined' ? 'undefined' : (0, _typeof3.default)(payload)) !== 'object') {
		return null;
		}

		return payload;
		};

		var getResponse = function getResponse(eventData) {
		var resp = getNamespacedPayload(eventData);
		const getResponse = eventData => {
		const resp = getNamespacedPayload(eventData);

		if (!resp) {
		return null;
		}
		var id = resp.id,
		ret = resp.ret;

		return id != null && typeof id === 'string' && resp.hasOwnProperty('ret') ? { id: id, ret: ret } : null;
		const id = resp.id,
		ret = resp.ret;
		return id != null && typeof id === 'string' && resp.hasOwnProperty('ret') ? {
		id,
		ret
		} : null;
		};

		var getRequest = function getRequest(eventData) {
		var req = getNamespacedPayload(eventData);
		const getRequest = eventData => {
		const req = getNamespacedPayload(eventData);

		if (!req) {
		return null;
		}
		var id = req.id,
		method = req.method,
		args = req.args;

		return id != null && typeof id === 'string' && typeof method === 'string' && Array.isArray(args) ? { id: id, method: method, args: args } : null;
		const id = req.id,
		method = req.method,
		args = req.args;
		return id != null && typeof id === 'string' && typeof method === 'string' && Array.isArray(args) ? {
		id,
		method,
		args
		} : null;
		};

		var client = exports.client = function client(serverWindow, serverOrigin) {
		return function (request) {
		return new _promise2.default(function (resolve, reject) {
		var reqId = (0, _v2.default)();
		var responseListener = function responseListener(event) {
		var data = event.data,
		const client = (serverWindow, serverOrigin) => request => {
		return new Promise((resolve, reject) => {
		const reqId = (0, _v.default)();

		const responseListener = event => {
		const data = event.data,
		origin = event.origin;
		const resp = getResponse(data);

		var resp = getResponse(data);
		if (serverOrigin !== '*' && origin !== serverOrigin \|\| !resp) {
		return;
		}
		if (resp.id !== reqId) {
		return;
		}
		resolve(resp.ret);
		window.removeEventListener('message', responseListener);
		};
		window.addEventListener('message', responseListener);
		serverWindow.postMessage({
		'solid-auth-client': {
		id: reqId,
		method: request.method,
		args: request.args
		}
		}, serverOrigin);
		});
		};
		};
		if (serverOrigin !== '*' && origin !== serverOrigin \|\| !resp) {
		return;
		}

		var server = exports.server = function server(clientWindow, clientOrigin) {
		return function (handle) {
		var messageListener = function () {
		var _ref2 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(event) {
		var data, origin, req, resp;
		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		data = event.data, origin = event.origin;
		req = getRequest(data);
		if (resp.id !== reqId) {
		return;
		}

		if (req) {
		_context.next = 4;
		break;
		}
		resolve(resp.ret);
		window.removeEventListener('message', responseListener);
		};

		return _context.abrupt('return');
		window.addEventListener('message', responseListener);
		serverWindow.postMessage({
		'solid-auth-client': {
		id: reqId,
		method: request.method,
		args: request.args
		}
		}, serverOrigin);
		});
		};

		case 4:
		if (!(origin !== clientOrigin)) {
		_context.next = 7;
		break;
		}
		exports.client = client;

		console.warn('SECURITY WARNING: solid-auth-client is listening for messages from ' + clientOrigin + ', ' + ('but received a message from ' + origin + '. Ignoring the message.'));
		return _context.abrupt('return');
		const server = (clientWindow, clientOrigin) => handle => {
		const messageListener = async event => {
		const data = event.data,
		origin = event.origin;
		const req = getRequest(data);

		case 7:
		_context.next = 9;
		return handle(req);
		if (!req) {
		return;
		}

		case 9:
		resp = _context.sent;
		if (origin !== clientOrigin) {
		console.warn(`SECURITY WARNING: solid-auth-client is listening for messages from ${clientOrigin}, ` + `but received a message from ${origin}. Ignoring the message.`);
		return;
		}

		if (resp) {
		clientWindow.postMessage(namespace(resp), clientOrigin);
		}
		const resp = await handle(req);

		case 11:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, undefined);
		}));
		if (resp) {
		clientWindow.postMessage(namespace(resp), clientOrigin);
		}
		};

		return function messageListener(_x) {
		return _ref2.apply(this, arguments);
		};
		}();

		var _server = {
		start: function start() {
		window.addEventListener('message', messageListener);
		return _server;
		},
		stop: function stop() {
		window.removeEventListener('message', messageListener);
		return _server;
		}
		};
		return _server;
		const _server = {
		start: () => {
		window.addEventListener('message', messageListener);
		return _server;
		},
		stop: () => {
		window.removeEventListener('message', messageListener);
		return _server;
		}
		};
		return _server;
		};

		var combineHandlers = exports.combineHandlers = function combineHandlers() {
		for (var _len = arguments.length, handlers = Array(_len), _key = 0; _key < _len; _key++) {
		handlers[_key] = arguments[_key];
		}
		exports.server = server;

		return function (req) {
		return handlers.map(function (handler) {
		return handler(req);
		}).find(function (promise) {
		return promise !== null;
		});
		};
		};
		const combineHandlers = (...handlers) => req => handlers.map(handler => handler(req)).find(promise => promise !== null);

		exports.combineHandlers = combineHandlers;

139

lib/popup.js

		@@ -1,2 +0,2 @@
		'use strict';
		"use strict";

		@@ -6,84 +6,88 @@ Object.defineProperty(exports, "__esModule", {
		});
		exports.openIdpSelector = exports.startPopupServer = exports.appOriginHandler = exports.loginHandler = exports.storageHandler = undefined;
		exports.openIdpSelector = exports.startPopupServer = exports.appOriginHandler = exports.loginHandler = exports.storageHandler = void 0;

		var _promise = require('babel-runtime/core-js/promise');
		var _ipc = require("./ipc");

		var _promise2 = _interopRequireDefault(_promise);
		var _urlUtil = require("./url-util");

		var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
		const popupAppRequestHandler = (store, options, foundSessionCb) => (0, _ipc.combineHandlers)(storageHandler(store), loginHandler(options, foundSessionCb), appOriginHandler);

		var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
		const storageHandler = store => req => {
		const id = req.id,
		method = req.method,
		args = req.args;

		var _ipc = require('./ipc');
		switch (method) {
		case 'storage/getItem':
		return store.getItem(...args).then(item => ({
		id,
		ret: item
		}));

		var _urlUtil = require('./url-util');
		case 'storage/setItem':
		return store.setItem(...args).then(() => ({
		id,
		ret: null
		}));

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
		case 'storage/removeItem':
		return store.removeItem(...args).then(() => ({
		id,
		ret: null
		}));

		var popupAppRequestHandler = function popupAppRequestHandler(store, options, foundSessionCb) {
		return (0, _ipc.combineHandlers)(storageHandler(store), loginHandler(options, foundSessionCb), appOriginHandler);
		default:
		return null;
		}
		};

		var storageHandler = exports.storageHandler = function storageHandler(store) {
		return function (req) {
		var id = req.id,
		exports.storageHandler = storageHandler;

		const loginHandler = (options, foundSessionCb) => req => {
		const id = req.id,
		method = req.method,
		args = req.args;

		switch (method) {
		case 'storage/getItem':
		return store.getItem.apply(store, (0, _toConsumableArray3.default)(args)).then(function (item) {
		return { id: id, ret: item };
		});
		case 'storage/setItem':
		return store.setItem.apply(store, (0, _toConsumableArray3.default)(args)).then(function () {
		return { id: id, ret: null };
		});
		case 'storage/removeItem':
		return store.removeItem.apply(store, (0, _toConsumableArray3.default)(args)).then(function () {
		return { id: id, ret: null };
		});
		default:
		return null;
		}
		};
		};
		switch (method) {
		case 'getLoginOptions':
		return Promise.resolve({
		id,
		ret: {
		popupUri: options.popupUri,
		callbackUri: options.callbackUri
		}
		});

		var loginHandler = exports.loginHandler = function loginHandler(options, foundSessionCb) {
		return function (req) {
		var id = req.id,
		method = req.method,
		args = req.args;
		case 'foundSession':
		foundSessionCb(args[0]);
		return Promise.resolve({
		id,
		ret: null
		});

		switch (method) {
		case 'getLoginOptions':
		return _promise2.default.resolve({
		id: id,
		ret: {
		popupUri: options.popupUri,
		callbackUri: options.callbackUri
		}
		});
		case 'foundSession':
		foundSessionCb(args[0]);
		return _promise2.default.resolve({ id: id, ret: null });
		default:
		return null;
		}
		};
		default:
		return null;
		}
		};

		var appOriginHandler = exports.appOriginHandler = function appOriginHandler(req) {
		var id = req.id,
		method = req.method;
		exports.loginHandler = loginHandler;

		return method === 'getAppOrigin' ? _promise2.default.resolve({ id: id, ret: window.location.origin }) : null;
		const appOriginHandler = req => {
		const id = req.id,
		method = req.method;
		return method === 'getAppOrigin' ? Promise.resolve({
		id,
		ret: window.location.origin
		}) : null;
		};

		var startPopupServer = exports.startPopupServer = function startPopupServer(store, childWindow, options) {
		return new _promise2.default(function (resolve, reject) {
		exports.appOriginHandler = appOriginHandler;

		const startPopupServer = (store, childWindow, options) => {
		return new Promise((resolve, reject) => {
		if (!(options.popupUri && options.callbackUri)) {
		return reject(new Error('Cannot serve a popup without both "options.popupUri" and "options.callbackUri"'));
		}
		var popupServer = (0, _ipc.server)(childWindow, (0, _urlUtil.originOf)(options.popupUri \|\| ''))(popupAppRequestHandler(store, options, function (session) {

		const popupServer = (0, _ipc.server)(childWindow, (0, _urlUtil.originOf)(options.popupUri \|\| ''))(popupAppRequestHandler(store, options, session => {
		popupServer.stop();
		@@ -96,10 +100,15 @@ resolve(session);

		var openIdpSelector = exports.openIdpSelector = function openIdpSelector(options) {
		exports.startPopupServer = startPopupServer;

		const openIdpSelector = options => {
		if (!(options.popupUri && options.callbackUri)) {
		throw new Error('Cannot open IDP select UI. Must provide both "options.popupUri" and "options.callbackUri".');
		}
		var width = 650;
		var height = 400;
		var w = window.open(options.popupUri, '_blank', 'width=' + width + ',height=' + height + ',left=' + (window.innerWidth - width) / 2 + ',top=' + (window.innerHeight - height) / 2);

		const width = 650;
		const height = 400;
		const w = window.open(options.popupUri, '_blank', `width=${width},height=${height},left=${(window.innerWidth - width) / 2},top=${(window.innerHeight - height) / 2}`);
		return w;
		};
		};

		exports.openIdpSelector = openIdpSelector;

118

lib/session.js

		@@ -1,108 +0,34 @@
		'use strict';
		"use strict";

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.clearSession = exports.getSession = undefined;
		exports.getSession = getSession;
		exports.saveSession = saveSession;
		exports.clearSession = clearSession;

		var _extends2 = require('babel-runtime/helpers/extends');
		var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

		var _extends3 = _interopRequireDefault(_extends2);
		var _storage = require("./storage");

		var _regenerator = require('babel-runtime/regenerator');
		async function getSession(storage) {
		const data = await (0, _storage.getData)(storage);
		return data.session \|\| null;
		}

		var _regenerator2 = _interopRequireDefault(_regenerator);

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

		var getSession = exports.getSession = function () {
		var _ref = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(storage) {
		var data;
		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		_context.next = 2;
		return (0, _storage.getData)(storage);

		case 2:
		data = _context.sent;
		return _context.abrupt('return', data.session \|\| null);

		case 4:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, this);
		}));

		return function getSession(_x) {
		return _ref.apply(this, arguments);
		function saveSession(storage) {
		return async session => {
		const data = await (0, _storage.updateStorage)(storage, data => (0, _objectSpread2.default)({}, data, {
		session
		}));
		return data.session;
		};
		}();
		}

		var clearSession = exports.clearSession = function () {
		var _ref3 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee3(storage) {
		return _regenerator2.default.wrap(function _callee3$(_context3) {
		while (1) {
		switch (_context3.prev = _context3.next) {
		case 0:
		_context3.next = 2;
		return (0, _storage.updateStorage)(storage, function (data) {
		return (0, _extends3.default)({}, data, { session: null });
		});

		case 2:
		case 'end':
		return _context3.stop();
		}
		}
		}, _callee3, this);
		async function clearSession(storage) {
		await (0, _storage.updateStorage)(storage, data => (0, _objectSpread2.default)({}, data, {
		session: null
		}));

		return function clearSession(_x3) {
		return _ref3.apply(this, arguments);
		};
		}();

		exports.saveSession = saveSession;

		var _storage = require('./storage');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		function saveSession(storage) {
		var _this = this;

		return function () {
		var _ref2 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee2(session) {
		var data;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		_context2.next = 2;
		return (0, _storage.updateStorage)(storage, function (data) {
		return (0, _extends3.default)({}, data, { session: session });
		});

		case 2:
		data = _context2.sent;
		return _context2.abrupt('return', data.session);

		case 4:
		case 'end':
		return _context2.stop();
		}
		}
		}, _callee2, _this);
		}));

		return function (_x2) {
		return _ref2.apply(this, arguments);
		};
		}();
		}

342

lib/solid-auth-client.js

		@@ -1,62 +0,30 @@
		'use strict';
		"use strict";

		var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.default = void 0;

		var _regenerator = require('babel-runtime/regenerator');
		var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

		var _regenerator2 = _interopRequireDefault(_regenerator);
		var _events = _interopRequireDefault(require("events"));

		var _extends2 = require('babel-runtime/helpers/extends');
		var _authnFetch = require("./authn-fetch");

		var _extends3 = _interopRequireDefault(_extends2);
		var _popup = require("./popup");

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
		var _session = require("./session");

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
		var _storage = require("./storage");

		var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
		var _urlUtil = require("./url-util");

		var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
		var WebIdOidc = _interopRequireWildcard(require("./webid-oidc"));

		var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

		var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

		var _createClass2 = require('babel-runtime/helpers/createClass');

		var _createClass3 = _interopRequireDefault(_createClass2);

		var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

		var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

		var _inherits2 = require('babel-runtime/helpers/inherits');

		var _inherits3 = _interopRequireDefault(_inherits2);

		var _events = require('events');

		var _events2 = _interopRequireDefault(_events);

		var _authnFetch = require('./authn-fetch');

		var _popup = require('./popup');

		var _session = require('./session');

		var _storage = require('./storage');

		var _urlUtil = require('./url-util');

		var _webidOidc = require('./webid-oidc');

		var WebIdOidc = _interopRequireWildcard(_webidOidc);

		function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		var defaultLoginOptions = function defaultLoginOptions(url) {
		/* global RequestInfo, Response */
		const defaultLoginOptions = url => {
		return {
		@@ -68,245 +36,77 @@ callbackUri: url ? url.split('#')[0] : '',
		};
		/* global RequestInfo, Response */

		var SolidAuthClient = function (_EventEmitter) {
		(0, _inherits3.default)(SolidAuthClient, _EventEmitter);
		class SolidAuthClient extends _events.default {
		fetch(input, options) {
		return (0, _authnFetch.authnFetch)((0, _storage.defaultStorage)())(input, options);
		}

		function SolidAuthClient() {
		(0, _classCallCheck3.default)(this, SolidAuthClient);
		return (0, _possibleConstructorReturn3.default)(this, (SolidAuthClient.__proto__ \|\| (0, _getPrototypeOf2.default)(SolidAuthClient)).apply(this, arguments));
		async login(idp, options) {
		options = (0, _objectSpread2.default)({}, defaultLoginOptions((0, _urlUtil.currentUrlNoParams)()), options);
		const webIdOidcLogin = await WebIdOidc.login(idp, options);
		return webIdOidcLogin;
		}

		(0, _createClass3.default)(SolidAuthClient, [{
		key: 'fetch',
		value: function fetch(input, options) {
		return (0, _authnFetch.authnFetch)((0, _storage.defaultStorage)())(input, options);
		async popupLogin(options) {
		options = (0, _objectSpread2.default)({}, defaultLoginOptions(), options);

		if (!/https?:/.test(options.popupUri)) {
		options.popupUri = new URL(options.popupUri \|\| '/.well-known/solid/login', window.location).toString();
		}
		}, {
		key: 'login',
		value: function () {
		var _ref = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(idp, options) {
		var webIdOidcLogin;
		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		options = (0, _extends3.default)({}, defaultLoginOptions((0, _urlUtil.currentUrlNoParams)()), options);
		_context.next = 3;
		return WebIdOidc.login(idp, options);

		case 3:
		webIdOidcLogin = _context.sent;
		return _context.abrupt('return', webIdOidcLogin);
		if (!options.callbackUri) {
		options.callbackUri = options.popupUri;
		}

		case 5:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, this);
		}));
		const childWindow = (0, _popup.openIdpSelector)(options);
		const session = await (0, _popup.startPopupServer)(options.storage, childWindow, options);
		this.emit('login', session);
		this.emit('session', session);
		return session;
		}

		function login(_x, _x2) {
		return _ref.apply(this, arguments);
		}
		async currentSession(storage = (0, _storage.defaultStorage)()) {
		let session = await (0, _session.getSession)(storage);

		return login;
		}()
		}, {
		key: 'popupLogin',
		value: function () {
		var _ref2 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee2(options) {
		var childWindow, session;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		options = (0, _extends3.default)({}, defaultLoginOptions(), options);
		if (!/https?:/.test(options.popupUri)) {
		options.popupUri = new URL(options.popupUri \|\| '/.well-known/solid/login', window.location).toString();
		}
		if (!options.callbackUri) {
		options.callbackUri = options.popupUri;
		}
		childWindow = (0, _popup.openIdpSelector)(options);
		_context2.next = 6;
		return (0, _popup.startPopupServer)(options.storage, childWindow, options);

		case 6:
		session = _context2.sent;

		this.emit('login', session);
		this.emit('session', session);
		return _context2.abrupt('return', session);

		case 10:
		case 'end':
		return _context2.stop();
		}
		}
		}, _callee2, this);
		}));

		function popupLogin(_x3) {
		return _ref2.apply(this, arguments);
		if (!session) {
		try {
		session = await WebIdOidc.currentSession(storage);
		} catch (err) {
		console.error(err);
		}

		return popupLogin;
		}()
		}, {
		key: 'currentSession',
		value: function () {
		var _ref3 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee3() {
		var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _storage.defaultStorage)();
		var session;
		return _regenerator2.default.wrap(function _callee3$(_context3) {
		while (1) {
		switch (_context3.prev = _context3.next) {
		case 0:
		_context3.next = 2;
		return (0, _session.getSession)(storage);

		case 2:
		session = _context3.sent;

		if (session) {
		_context3.next = 18;
		break;
		}

		_context3.prev = 4;
		_context3.next = 7;
		return WebIdOidc.currentSession(storage);

		case 7:
		session = _context3.sent;
		_context3.next = 13;
		break;

		case 10:
		_context3.prev = 10;
		_context3.t0 = _context3['catch'](4);

		console.error(_context3.t0);

		case 13:
		if (!session) {
		_context3.next = 18;
		break;
		}

		this.emit('login', session);
		this.emit('session', session);
		_context3.next = 18;
		return (0, _session.saveSession)(storage)(session);

		case 18:
		return _context3.abrupt('return', session);

		case 19:
		case 'end':
		return _context3.stop();
		}
		}
		}, _callee3, this, [[4, 10]]);
		}));

		function currentSession() {
		return _ref3.apply(this, arguments);
		if (session) {
		this.emit('login', session);
		this.emit('session', session);
		await (0, _session.saveSession)(storage)(session);
		}
		}

		return currentSession;
		}()
		}, {
		key: 'trackSession',
		value: function () {
		var _ref4 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee4(callback) {
		return _regenerator2.default.wrap(function _callee4$(_context4) {
		while (1) {
		switch (_context4.prev = _context4.next) {
		case 0:
		_context4.t0 = callback;
		_context4.next = 3;
		return this.currentSession();
		return session;
		}

		case 3:
		_context4.t1 = _context4.sent;
		(0, _context4.t0)(_context4.t1);
		async trackSession(callback) {
		/* eslint-disable standard/no-callback-literal */
		callback((await this.currentSession()));
		this.on('session', callback);
		}

		this.on('session', callback);
		async logout(storage = (0, _storage.defaultStorage)()) {
		const session = await (0, _session.getSession)(storage);

		case 6:
		case 'end':
		return _context4.stop();
		}
		}
		}, _callee4, this);
		}));

		function trackSession(_x5) {
		return _ref4.apply(this, arguments);
		if (session) {
		try {
		await WebIdOidc.logout(storage);
		this.emit('logout');
		this.emit('session', null);
		} catch (err) {
		console.warn('Error logging out:');
		console.error(err);
		}

		return trackSession;
		}()
		}, {
		key: 'logout',
		value: function () {
		var _ref5 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee5() {
		var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _storage.defaultStorage)();
		var session;
		return _regenerator2.default.wrap(function _callee5$(_context5) {
		while (1) {
		switch (_context5.prev = _context5.next) {
		case 0:
		_context5.next = 2;
		return (0, _session.getSession)(storage);
		await (0, _session.clearSession)(storage);
		}
		}

		case 2:
		session = _context5.sent;
		}

		if (!session) {
		_context5.next = 17;
		break;
		}

		_context5.prev = 4;
		_context5.next = 7;
		return WebIdOidc.logout(storage);

		case 7:
		this.emit('logout');
		this.emit('session', null);
		_context5.next = 15;
		break;

		case 11:
		_context5.prev = 11;
		_context5.t0 = _context5['catch'](4);

		console.warn('Error logging out:');
		console.error(_context5.t0);

		case 15:
		_context5.next = 17;
		return (0, _session.clearSession)(storage);

		case 17:
		case 'end':
		return _context5.stop();
		}
		}
		}, _callee5, this, [[4, 11]]);
		}));

		function logout() {
		return _ref5.apply(this, arguments);
		}

		return logout;
		}()
		}]);
		return SolidAuthClient;
		}(_events2.default);

		exports.default = SolidAuthClient;

241

lib/storage.js

		@@ -1,2 +0,2 @@
		'use strict';
		"use strict";

		@@ -6,67 +6,48 @@ Object.defineProperty(exports, "__esModule", {
		});
		exports.postMessageStorage = exports.memStorage = exports.updateStorage = exports.getData = exports.defaultStorage = exports.NAMESPACE = undefined;
		exports.getData = getData;
		exports.updateStorage = updateStorage;
		exports.asyncStorage = asyncStorage;
		exports.postMessageStorage = exports.memStorage = exports.defaultStorage = exports.NAMESPACE = void 0;

		var _promise = require('babel-runtime/core-js/promise');
		var _ipc = require("./ipc");

		var _promise2 = _interopRequireDefault(_promise);
		const NAMESPACE = 'solid-auth-client';
		exports.NAMESPACE = NAMESPACE;

		var _stringify = require('babel-runtime/core-js/json/stringify');
		const defaultStorage = () => {
		try {
		if (window && window.localStorage) {
		return asyncStorage(window.localStorage);
		}
		} catch (e) {
		if (!(e instanceof ReferenceError)) {
		throw e;
		}
		}

		var _stringify2 = _interopRequireDefault(_stringify);

		var _regenerator = require('babel-runtime/regenerator');

		var _regenerator2 = _interopRequireDefault(_regenerator);

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

		console.warn(`'window.localStorage' unavailable. ` + `Creating a (not very useful) in-memory storage object as the default storage interface.`);
		return asyncStorage(memStorage());
		};
		/**
		* Gets the deserialized stored data
		*/
		var getData = exports.getData = function () {
		var _ref = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(store) {
		var serialized, data;
		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		serialized = void 0;
		data = void 0;
		_context.prev = 2;
		_context.next = 5;
		return store.getItem(NAMESPACE);

		case 5:
		serialized = _context.sent;

		data = JSON.parse(serialized \|\| '{}');
		_context.next = 14;
		break;
		exports.defaultStorage = defaultStorage;

		case 9:
		_context.prev = 9;
		_context.t0 = _context['catch'](2);
		async function getData(store) {
		let serialized;
		let data;

		console.warn('Could not deserialize data:', serialized);
		console.error(_context.t0);
		data = {};
		try {
		serialized = await store.getItem(NAMESPACE);
		data = JSON.parse(serialized \|\| '{}');
		} catch (e) {
		console.warn('Could not deserialize data:', serialized);
		console.error(e);
		data = {};
		}

		case 14:
		return _context.abrupt('return', data);

		case 15:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, this, [[2, 9]]);
		}));

		return function getData(_x) {
		return _ref.apply(this, arguments);
		};
		}();

		return data;
		}
		/**
		@@ -77,34 +58,8 @@ * Updates a Storage object without mutating its intermediate representation.

		var updateStorage = exports.updateStorage = function () {
		var _ref2 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee2(store, update) {
		var currentData, newData;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		_context2.next = 2;
		return getData(store);

		case 2:
		currentData = _context2.sent;
		newData = update(currentData);
		_context2.next = 6;
		return store.setItem(NAMESPACE, (0, _stringify2.default)(newData));

		case 6:
		return _context2.abrupt('return', newData);

		case 7:
		case 'end':
		return _context2.stop();
		}
		}
		}, _callee2, this);
		}));

		return function updateStorage(_x2, _x3) {
		return _ref2.apply(this, arguments);
		};
		}();

		async function updateStorage(store, update) {
		const currentData = await getData(store);
		const newData = update(currentData);
		await store.setItem(NAMESPACE, JSON.stringify(newData));
		return newData;
		}
		/**
		@@ -115,33 +70,12 @@ * Takes a synchronous storage interface and wraps it with an async interface.

		exports.asyncStorage = asyncStorage;

		var _ipc = require('./ipc');

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		var NAMESPACE = exports.NAMESPACE = 'solid-auth-client';
		var defaultStorage = exports.defaultStorage = function defaultStorage() {
		try {
		if (window && window.localStorage) {
		return asyncStorage(window.localStorage);
		}
		} catch (e) {
		if (!(e instanceof ReferenceError)) {
		throw e;
		}
		}
		console.warn('\'window.localStorage\' unavailable. ' + 'Creating a (not very useful) in-memory storage object as the default storage interface.');
		return asyncStorage(memStorage());
		};function asyncStorage(storage) {
		function asyncStorage(storage) {
		return {
		getItem: function getItem(key) {
		return _promise2.default.resolve(storage.getItem(key));
		getItem: key => {
		return Promise.resolve(storage.getItem(key));
		},

		setItem: function setItem(key, val) {
		return _promise2.default.resolve(storage.setItem(key, val));
		setItem: (key, val) => {
		return Promise.resolve(storage.setItem(key, val));
		},

		removeItem: function removeItem(key) {
		return _promise2.default.resolve(storage.removeItem(key));
		removeItem: key => {
		return Promise.resolve(storage.removeItem(key));
		}
		@@ -151,13 +85,13 @@ };

		var memStorage = exports.memStorage = function memStorage() {
		var store = {};
		const memStorage = () => {
		const store = {};
		return {
		getItem: function getItem(key) {
		getItem: key => {
		if (typeof store[key] === 'undefined') return null;
		return store[key];
		},
		setItem: function setItem(key, val) {
		setItem: (key, val) => {
		store[key] = val;
		},
		removeItem: function removeItem(key) {
		removeItem: key => {
		delete store[key];
		@@ -168,51 +102,34 @@ }

		var postMessageStorage = exports.postMessageStorage = function postMessageStorage(storageWindow, storageOrigin) {
		var request = (0, _ipc.client)(storageWindow, storageOrigin);
		exports.memStorage = memStorage;

		const postMessageStorage = (storageWindow, storageOrigin) => {
		const request = (0, _ipc.client)(storageWindow, storageOrigin);
		return {
		getItem: function () {
		var _ref3 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee3(key) {
		var ret;
		return _regenerator2.default.wrap(function _callee3$(_context3) {
		while (1) {
		switch (_context3.prev = _context3.next) {
		case 0:
		_context3.next = 2;
		return request({ method: 'storage/getItem', args: [key] });
		getItem: async key => {
		const ret = await request({
		method: 'storage/getItem',
		args: [key]
		});

		case 2:
		ret = _context3.sent;

		if (!(typeof ret !== 'string')) {
		_context3.next = 5;
		break;
		}

		throw new Error('expected postMessage call for \'storage/getItem\' to return a string, but got value ' + ret);

		case 5:
		return _context3.abrupt('return', ret);

		case 6:
		case 'end':
		return _context3.stop();
		}
		}
		}, _callee3, undefined);
		}));

		function getItem(_x4) {
		return _ref3.apply(this, arguments);
		if (typeof ret !== 'string') {
		throw new Error(`expected postMessage call for 'storage/getItem' to return a string, but got value ${ret}`);
		}

		return getItem;
		}(),

		setItem: function setItem(key, val) {
		return request({ method: 'storage/setItem', args: [key, val] });
		return ret;
		},

		removeItem: function removeItem(key) {
		return request({ method: 'storage/removeItem', args: [key] });
		setItem: (key, val) => {
		return request({
		method: 'storage/setItem',
		args: [key, val]
		});
		},
		removeItem: key => {
		return request({
		method: 'storage/removeItem',
		args: [key]
		});
		}
		};
		};
		};

		exports.postMessageStorage = postMessageStorage;

lib/url-util.js

		@@ -1,2 +0,2 @@
		'use strict';
		"use strict";

		@@ -6,26 +6,31 @@ Object.defineProperty(exports, "__esModule", {
		});
		exports.toUrlString = exports.originOf = exports.navigateTo = exports.currentUrlNoParams = exports.currentUrl = void 0;

		/* eslint-env browser */
		const currentUrl = () => window.location.href;

		var currentUrl = exports.currentUrl = function currentUrl() {
		return window.location.href;
		};
		exports.currentUrl = currentUrl;

		var currentUrlNoParams = exports.currentUrlNoParams = function currentUrlNoParams() {
		return window.location.origin + window.location.pathname;
		};
		const currentUrlNoParams = () => window.location.origin + window.location.pathname;

		var navigateTo = exports.navigateTo = function navigateTo(url) {
		exports.currentUrlNoParams = currentUrlNoParams;

		const navigateTo = url => {
		window.location.href = url;
		};

		var originOf = exports.originOf = function originOf(url) {
		return new URL(url).origin;
		};
		exports.navigateTo = navigateTo;

		var toUrlString = exports.toUrlString = function toUrlString(url) {
		const originOf = url => new URL(url).origin;

		exports.originOf = originOf;

		const toUrlString = url => {
		if (typeof url !== 'string') {
		url = 'url' in url ? url.url : url.toString();
		}

		return new URL(url, currentUrl()).toString();
		};
		};

		exports.toUrlString = toUrlString;

440

lib/webid-oidc.js

		@@ -1,255 +0,116 @@
		'use strict';
		"use strict";

		var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

		var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

		Object.defineProperty(exports, "__esModule", {
		value: true
		});
		exports.fetchWithCredentials = exports.requiresAuth = exports.getRegisteredRp = exports.logout = exports.currentSession = exports.login = undefined;
		exports.fetchWithCredentials = exports.requiresAuth = exports.getRegisteredRp = exports.logout = exports.currentSession = exports.login = void 0;

		var _extends2 = require('babel-runtime/helpers/extends');
		var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));

		var _extends3 = _interopRequireDefault(_extends2);
		var authorization = _interopRequireWildcard(require("auth-header"));

		var _regenerator = require('babel-runtime/regenerator');
		var _oidcRp = _interopRequireDefault(require("@solid/oidc-rp"));

		var _regenerator2 = _interopRequireDefault(_regenerator);
		var _PoPToken = _interopRequireDefault(require("@solid/oidc-rp/lib/PoPToken"));

		var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
		var _urlUtil = require("./url-util");

		var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
		var _storage = require("./storage");

		var getStoredRp = function () {
		var _ref3 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee3(storage) {
		var data, rpConfig;
		return _regenerator2.default.wrap(function _callee3$(_context3) {
		while (1) {
		switch (_context3.prev = _context3.next) {
		case 0:
		_context3.next = 2;
		return (0, _storage.getData)(storage);
		/* global RequestInfo, Response */
		const login = async (idp, options) => {
		try {
		const rp = await getRegisteredRp(idp, options);
		await saveAppHashFragment(options.storage);
		return sendAuthRequest(rp, options);
		} catch (err) {
		console.warn('Error logging in with WebID-OIDC');
		console.error(err);
		return null;
		}
		};

		case 2:
		data = _context3.sent;
		rpConfig = data.rpConfig;
		exports.login = login;

		if (!rpConfig) {
		_context3.next = 9;
		break;
		}
		const currentSession = async (storage = (0, _storage.defaultStorage)()) => {
		try {
		const rp = await getStoredRp(storage);

		rpConfig.store = storage;
		return _context3.abrupt('return', _oidcRp2.default.from(rpConfig));
		if (!rp) {
		return null;
		}

		case 9:
		return _context3.abrupt('return', null);
		const url = (0, _urlUtil.currentUrl)();

		case 10:
		case 'end':
		return _context3.stop();
		}
		}
		}, _callee3, this);
		}));
		if (!url \|\| !url.includes('#access_token=')) {
		return null;
		}

		return function getStoredRp(_x4) {
		return _ref3.apply(this, arguments);
		};
		}();
		const storeData = await (0, _storage.getData)(storage);
		const session = await rp.validateResponse(url, storeData);

		var storeRp = function () {
		var _ref4 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee4(storage, idp, rp) {
		return _regenerator2.default.wrap(function _callee4$(_context4) {
		while (1) {
		switch (_context4.prev = _context4.next) {
		case 0:
		_context4.next = 2;
		return (0, _storage.updateStorage)(storage, function (data) {
		return (0, _extends3.default)({}, data, {
		rpConfig: rp
		});
		});
		if (!session) {
		return null;
		}

		case 2:
		return _context4.abrupt('return', rp);
		await restoreAppHashFragment(storage);
		return (0, _objectSpread2.default)({}, session, {
		webId: session.idClaims.sub,
		idp: session.issuer
		});
		} catch (err) {
		console.warn('Error finding a WebID-OIDC session');
		console.error(err);
		return null;
		}
		};

		case 3:
		case 'end':
		return _context4.stop();
		}
		}
		}, _callee4, this);
		}));
		exports.currentSession = currentSession;

		return function storeRp(_x5, _x6, _x7) {
		return _ref4.apply(this, arguments);
		};
		}();
		const logout = storage => getStoredRp(storage).then(rp => rp ? rp.logout() : undefined).catch(err => {
		console.warn('Error logging out of the WebID-OIDC session');
		console.error(err);
		});

		var _authHeader = require('auth-header');
		exports.logout = logout;

		var authorization = _interopRequireWildcard(_authHeader);
		const getRegisteredRp = (idp, options) => getStoredRp(options.storage).then(rp => {
		if (rp && rp.provider.url === idp) {
		return rp;
		}

		var _oidcRp = require('@solid/oidc-rp');
		return registerRp(idp, options).then(rp => storeRp(options.storage, idp, rp));
		});

		var _oidcRp2 = _interopRequireDefault(_oidcRp);
		exports.getRegisteredRp = getRegisteredRp;

		var _PoPToken = require('@solid/oidc-rp/lib/PoPToken');
		async function getStoredRp(storage) {
		const data = await (0, _storage.getData)(storage);
		const rpConfig = data.rpConfig;

		var _PoPToken2 = _interopRequireDefault(_PoPToken);
		if (rpConfig) {
		rpConfig.store = storage;
		return _oidcRp.default.from(rpConfig);
		} else {
		return null;
		}
		}

		var _urlUtil = require('./url-util');

		var _storage = require('./storage');

		function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		var login = exports.login = function () {
		var _ref = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee(idp, options) {
		var rp;
		return _regenerator2.default.wrap(function _callee$(_context) {
		while (1) {
		switch (_context.prev = _context.next) {
		case 0:
		_context.prev = 0;
		_context.next = 3;
		return getRegisteredRp(idp, options);

		case 3:
		rp = _context.sent;
		_context.next = 6;
		return saveAppHashFragment(options.storage);

		case 6:
		return _context.abrupt('return', sendAuthRequest(rp, options));

		case 9:
		_context.prev = 9;
		_context.t0 = _context['catch'](0);

		console.warn('Error logging in with WebID-OIDC');
		console.error(_context.t0);
		return _context.abrupt('return', null);

		case 14:
		case 'end':
		return _context.stop();
		}
		}
		}, _callee, undefined, [[0, 9]]);
		async function storeRp(storage, idp, rp) {
		await (0, _storage.updateStorage)(storage, data => (0, _objectSpread2.default)({}, data, {
		rpConfig: rp
		}));
		return rp;
		}

		return function login(_x, _x2) {
		return _ref.apply(this, arguments);
		};
		}();
		/* global RequestInfo, Response */
		var currentSession = exports.currentSession = function () {
		var _ref2 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee2() {
		var storage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : (0, _storage.defaultStorage)();
		var rp, url, storeData, session;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
		while (1) {
		switch (_context2.prev = _context2.next) {
		case 0:
		_context2.prev = 0;
		_context2.next = 3;
		return getStoredRp(storage);

		case 3:
		rp = _context2.sent;

		if (rp) {
		_context2.next = 6;
		break;
		}

		return _context2.abrupt('return', null);

		case 6:
		url = (0, _urlUtil.currentUrl)();

		if (!(!url \|\| !url.includes('#access_token='))) {
		_context2.next = 9;
		break;
		}

		return _context2.abrupt('return', null);

		case 9:
		_context2.next = 11;
		return (0, _storage.getData)(storage);

		case 11:
		storeData = _context2.sent;
		_context2.next = 14;
		return rp.validateResponse(url, storeData);

		case 14:
		session = _context2.sent;

		if (session) {
		_context2.next = 17;
		break;
		}

		return _context2.abrupt('return', null);

		case 17:
		_context2.next = 19;
		return restoreAppHashFragment(storage);

		case 19:
		return _context2.abrupt('return', (0, _extends3.default)({}, session, {
		webId: session.idClaims.sub,
		idp: session.issuer
		}));

		case 22:
		_context2.prev = 22;
		_context2.t0 = _context2['catch'](0);

		console.warn('Error finding a WebID-OIDC session');
		console.error(_context2.t0);
		return _context2.abrupt('return', null);

		case 27:
		case 'end':
		return _context2.stop();
		}
		}
		}, _callee2, undefined, [[0, 22]]);
		}));

		return function currentSession() {
		return _ref2.apply(this, arguments);
		};
		}();

		var logout = exports.logout = function logout(storage) {
		return getStoredRp(storage).then(function (rp) {
		return rp ? rp.logout() : undefined;
		}).catch(function (err) {
		console.warn('Error logging out of the WebID-OIDC session');
		console.error(err);
		});
		};

		var getRegisteredRp = exports.getRegisteredRp = function getRegisteredRp(idp, options) {
		return getStoredRp(options.storage).then(function (rp) {
		if (rp && rp.provider.url === idp) {
		return rp;
		}
		return registerRp(idp, options).then(function (rp) {
		return storeRp(options.storage, idp, rp);
		});
		});
		};

		var registerRp = function registerRp(idp, _ref5) {
		var storage = _ref5.storage,
		callbackUri = _ref5.callbackUri;

		var responseType = 'id_token token';
		var registration = {
		const registerRp = (idp, {
		storage,
		callbackUri
		}) => {
		const responseType = 'id_token token';
		const registration = {
		issuer: idp,
		@@ -261,3 +122,3 @@ grant_types: ['implicit'],
		};
		var options = {
		const options = {
		defaults: {
		@@ -271,76 +132,45 @@ authenticate: {
		};
		return _oidcRp2.default.register(idp, registration, options);
		return _oidcRp.default.register(idp, registration, options);
		};

		var sendAuthRequest = function () {
		var _ref7 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee5(rp, _ref6) {
		var callbackUri = _ref6.callbackUri,
		storage = _ref6.storage;
		var data, url;
		return _regenerator2.default.wrap(function _callee5$(_context5) {
		while (1) {
		switch (_context5.prev = _context5.next) {
		case 0:
		_context5.next = 2;
		return (0, _storage.getData)(storage);

		case 2:
		data = _context5.sent;
		_context5.next = 5;
		return rp.createRequest({ redirect_uri: callbackUri }, data);

		case 5:
		url = _context5.sent;
		_context5.next = 8;
		return (0, _storage.updateStorage)(storage, function () {
		return data;
		});

		case 8:
		return _context5.abrupt('return', (0, _urlUtil.navigateTo)(url));

		case 9:
		case 'end':
		return _context5.stop();
		}
		}
		}, _callee5, undefined);
		}));

		return function sendAuthRequest(_x8, _x9) {
		return _ref7.apply(this, arguments);
		};
		}();

		var saveAppHashFragment = function saveAppHashFragment(store) {
		return (0, _storage.updateStorage)(store, function (data) {
		return (0, _extends3.default)({}, data, {
		appHashFragment: window.location.hash
		});
		});
		const sendAuthRequest = async (rp, {
		callbackUri,
		storage
		}) => {
		const data = await (0, _storage.getData)(storage);
		const url = await rp.createRequest({
		redirect_uri: callbackUri
		}, data);
		await (0, _storage.updateStorage)(storage, () => data);
		return (0, _urlUtil.navigateTo)(url);
		};

		var restoreAppHashFragment = function restoreAppHashFragment(store) {
		return (0, _storage.updateStorage)(store, function (data) {
		window.location.hash = data.appHashFragment;
		delete data.appHashFragment;
		return data;
		});
		};
		const saveAppHashFragment = store => (0, _storage.updateStorage)(store, data => (0, _objectSpread2.default)({}, data, {
		appHashFragment: window.location.hash
		}));

		const restoreAppHashFragment = store => (0, _storage.updateStorage)(store, data => {
		window.location.hash = data.appHashFragment;
		delete data.appHashFragment;
		return data;
		});
		/**
		* Answers whether a HTTP response requires WebID-OIDC authentication.
		*/
		var requiresAuth = exports.requiresAuth = function requiresAuth(resp) {


		const requiresAuth = resp => {
		if (resp.status !== 401) {
		return false;
		}
		var wwwAuthHeader = resp.headers.get('www-authenticate');

		const wwwAuthHeader = resp.headers.get('www-authenticate');

		if (!wwwAuthHeader) {
		return false;
		}
		var auth = authorization.parse(wwwAuthHeader);

		const auth = authorization.parse(wwwAuthHeader);
		return auth.scheme === 'Bearer' && auth.params && auth.params.scope === 'openid webid';
		};

		/**
		@@ -350,35 +180,17 @@ * Fetches a resource, providing the WebID-OIDC ID Token as authentication.
		*/
		var fetchWithCredentials = exports.fetchWithCredentials = function fetchWithCredentials(session) {
		return function () {
		var _ref8 = (0, _asyncToGenerator3.default)( /#__PURE__/_regenerator2.default.mark(function _callee6(fetch, input, options) {
		var popToken, authenticatedOptions;
		return _regenerator2.default.wrap(function _callee6$(_context6) {
		while (1) {
		switch (_context6.prev = _context6.next) {
		case 0:
		_context6.next = 2;
		return _PoPToken2.default.issueFor((0, _urlUtil.toUrlString)(input), session);

		case 2:
		popToken = _context6.sent;
		authenticatedOptions = (0, _extends3.default)({}, options, {
		credentials: 'include',
		headers: (0, _extends3.default)({}, options && options.headers ? options.headers : {}, {
		authorization: 'Bearer ' + popToken
		})
		});
		return _context6.abrupt('return', fetch(input, authenticatedOptions));

		case 5:
		case 'end':
		return _context6.stop();
		}
		}
		}, _callee6, undefined);
		}));
		exports.requiresAuth = requiresAuth;

		return function (_x10, _x11, _x12) {
		return _ref8.apply(this, arguments);
		};
		}();
		};
		const fetchWithCredentials = session => async (fetch, input, options) => {
		const popToken = await _PoPToken.default.issueFor((0, _urlUtil.toUrlString)(input), session);
		const authenticatedOptions = (0, _objectSpread2.default)({}, options, {
		credentials: 'include',
		headers: (0, _objectSpread2.default)({}, options && options.headers ? options.headers : {}, {
		authorization: `Bearer ${popToken}`
		})
		});
		return fetch(input, authenticatedOptions);
		};

		exports.fetchWithCredentials = fetchWithCredentials;

package.json

		{
		"name": "solid-auth-client",
		"version": "2.2.4",
		"version": "2.2.5",
		"description": "Opaquely authenticates solid clients",
		@@ -48,3 +48,3 @@ "main": "lib/index.js",
		"@solid/oidc-rp": "^0.8.0",
		"auth-header": "^0.3.1",
		"auth-header": "^1.0.0",
		"commander": "^2.11.0",
		@@ -55,27 +55,30 @@ "isomorphic-fetch": "^2.2.1",
		"devDependencies": {
		"babel-cli": "^6.24.1",
		"babel-eslint": "^8.2.3",
		"babel-jest": "^23.4.2",
		"babel-loader": "^7.0.0",
		"babel-plugin-transform-class-properties": "^6.24.1",
		"babel-plugin-transform-object-rest-spread": "^6.23.0",
		"babel-plugin-transform-runtime": "^6.23.0",
		"babel-preset-env": "^1.6.1",
		"babel-preset-flow": "^6.23.0",
		"babel-preset-react": "^6.24.1",
		"@babel/cli": "^7.1.0",
		"@babel/core": "^7.1.0",
		"@babel/plugin-proposal-class-properties": "^7.1.0",
		"@babel/plugin-proposal-object-rest-spread": "^7.0.0",
		"@babel/plugin-transform-runtime": "^7.1.0",
		"@babel/preset-env": "^7.1.0",
		"@babel/preset-flow": "^7.0.0",
		"@babel/preset-react": "^7.0.0",
		"@babel/runtime": "^7.0.0",
		"babel-core": "^7.0.0-bridge.0",
		"babel-eslint": "^10.0.0",
		"babel-jest": "^23.6.0",
		"babel-loader": "^8.0.2",
		"clean-webpack-plugin": "^0.1.19",
		"coveralls": "^3.0.2",
		"cross-env": "^5.0.5",
		"css-loader": "^0.28.4",
		"eslint": "^4.19.1",
		"eslint-config-prettier": "^2.9.0",
		"eslint-config-standard": "^11.0.0",
		"css-loader": "^1.0.0",
		"eslint": "^5.6.0",
		"eslint-config-prettier": "^3.1.0",
		"eslint-config-standard": "^12.0.0",
		"eslint-plugin-flowtype": "^2.50.0",
		"eslint-plugin-import": "^2.11.0",
		"eslint-plugin-node": "^6.0.1",
		"eslint-plugin-import": "^2.14.0",
		"eslint-plugin-node": "^7.0.1",
		"eslint-plugin-prettier": "^2.6.0",
		"eslint-plugin-promise": "^3.7.0",
		"eslint-plugin-promise": "^4.0.1",
		"eslint-plugin-react": "^7.7.0",
		"eslint-plugin-standard": "^3.1.0",
		"flow-bin": "^0.79.1",
		"eslint-plugin-standard": "^4.0.0",
		"flow-bin": "^0.81.0",
		"html-webpack-inline-source-plugin": "0.0.10",
		@@ -85,3 +88,3 @@ "html-webpack-plugin": "^3.2.0",
		"jsonwebtoken": "^8.3.0",
		"nock": "^9.0.14",
		"nock": "^10.0.0",
		"pre-commit": "^1.2.2",
		@@ -93,6 +96,6 @@ "preact": "^8.2.5",
		"rsa-pem-to-jwk": "^1.1.3",
		"style-loader": "^0.18.2",
		"webpack": "^4.16.1",
		"webpack-cli": "^3.0.8",
		"webpack-dev-server": "^3.1.4"
		"style-loader": "^0.23.0",
		"webpack": "^4.20.2",
		"webpack-cli": "^3.1.1",
		"webpack-dev-server": "^3.1.9"
		},
		@@ -99,0 +102,0 @@ "jest": {

dist-lib/solid-auth-client.bundle.js

Sorry, the diff of this file is too big to display

dist-lib/solid-auth-client.bundle.js.map

Sorry, the diff of this file is not supported yet

dist-popup/popup-template.html

Sorry, the diff of this file is not supported yet

dist-popup/popup.html

Sorry, the diff of this file is not supported yet

solid-auth-client - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes