(function webpackUniversalModuleDefinition(root, factory) {

if(typeof exports === 'object' && typeof module === 'object')

module.exports = factory(require("$rdf"));

else if(typeof define === 'function' && define.amd)

define("SolidLogic", ["$rdf"], factory);

else if(typeof exports === 'object')

exports["SolidLogic"] = factory(require("$rdf"));

else

root["SolidLogic"] = factory(root["$rdf"]);

})(this, (__WEBPACK_EXTERNAL_MODULE__264__) => {

return /******/ (() => { // webpackBootstrap

/******/ var __webpack_modules__ = ({

/***/ 264

(module) {

"use strict";

module.exports = __WEBPACK_EXTERNAL_MODULE__264__;

/***/ },

/***/ 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))

/******/ })();

/******/

/******/ /* webpack/runtime/make namespace object */

/******/ (() => {

/******/ // define __esModule on exports

/******/ __webpack_require__.r = (exports) => {

/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

/******/ }

/******/ Object.defineProperty(exports, '__esModule', { value: true });

/******/ };

/******/ })();

/******/

/************************************************************************/

var __webpack_exports__ = {};

// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.

(() => {

"use strict";

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// EXPORTS

__webpack_require__.d(__webpack_exports__, {

ACL_LINK: () => (/* reexport */ ACL_LINK),

CrossOriginForbiddenError: () => (/* reexport */ CrossOriginForbiddenError),

FetchError: () => (/* reexport */ FetchError),

NotEditableError: () => (/* reexport */ NotEditableError),

NotFoundError: () => (/* reexport */ NotFoundError),

SameOriginForbiddenError: () => (/* reexport */ SameOriginForbiddenError),

UnauthorizedError: () => (/* reexport */ UnauthorizedError),

WebOperationError: () => (/* reexport */ WebOperationError),

appContext: () => (/* reexport */ appContext),

authSession: () => (/* binding */ src_authSession),

authn: () => (/* binding */ authn),

createTypeIndexLogic: () => (/* reexport */ createTypeIndexLogic),

getSuggestedIssuers: () => (/* reexport */ getSuggestedIssuers),

offlineTestID: () => (/* reexport */ offlineTestID),

solidLogicSingleton: () => (/* reexport */ solidLogicSingleton),

store: () => (/* binding */ store)

});

;// ./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);

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/webcrypto.js

/* harmony default export */ const webcrypto = (crypto);

const isCryptoKey = (key) => key instanceof CryptoKey;

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/invalid_key_input.js

function message(msg, actual, ...types) {

types = types.filter(Boolean);

if (types.length > 2) {

const last = types.pop();

msg += `one of type ${types.join(', ')}, or ${last}.`;

}

else if (types.length === 2) {

msg += `one of type ${types[0]} or ${types[1]}.`;

}

else {

msg += `of type ${types[0]}.`;

}

if (actual == null) {

msg += ` Received ${actual}`;

}

else if (typeof actual === 'function' && actual.name) {

msg += ` Received function ${actual.name}`;

}

else if (typeof actual === 'object' && actual != null) {

if (actual.constructor?.name) {

msg += ` Received an instance of ${actual.constructor.name}`;

}

}

return msg;

}

/* harmony default export */ const invalid_key_input = ((actual, ...types) => {

return message('Key must be ', actual, ...types);

});

function withAlg(alg, actual, ...types) {

return message(`Key for the ${alg} algorithm must be `, actual, ...types);

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/buffer_utils.js

const encoder = new TextEncoder();

const decoder = new TextDecoder();

const MAX_INT32 = (/* unused pure expression or super */ null && (2 ** 32));

function concat(...buffers) {

const size = buffers.reduce((acc, { length }) => acc + length, 0);

const buf = new Uint8Array(size);

let i = 0;

for (const buffer of buffers) {

buf.set(buffer, i);

i += buffer.length;

}

return buf;

}

function p2s(alg, p2sInput) {

return concat(encoder.encode(alg), new Uint8Array([0]), p2sInput);

}

function writeUInt32BE(buf, value, offset) {

if (value < 0 || value >= MAX_INT32) {

throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);

}

buf.set([value >>> 24, value >>> 16, value >>> 8, value & 0xff], offset);

}

function uint64be(value) {

const high = Math.floor(value / MAX_INT32);

const low = value % MAX_INT32;

const buf = new Uint8Array(8);

writeUInt32BE(buf, high, 0);

writeUInt32BE(buf, low, 4);

return buf;

}

function uint32be(value) {

const buf = new Uint8Array(4);

writeUInt32BE(buf, value);

return buf;

}

function lengthAndInput(input) {

return concat(uint32be(input.length), input);

}

async function concatKdf(secret, bits, value) {

const iterations = Math.ceil((bits >> 3) / 32);

const res = new Uint8Array(iterations * 32);

for (let iter = 0; iter < iterations; iter++) {

const buf = new Uint8Array(4 + secret.length + value.length);

buf.set(uint32be(iter + 1));

buf.set(secret, 4);

buf.set(value, 4 + secret.length);

res.set(await digest('sha256', buf), iter * 32);

}

return res.slice(0, bits >> 3);

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/base64url.js

const encodeBase64 = (input) => {

let unencoded = input;

if (typeof unencoded === 'string') {

unencoded = encoder.encode(unencoded);

}

const CHUNK_SIZE = 0x8000;

const arr = [];

for (let i = 0; i < unencoded.length; i += CHUNK_SIZE) {

arr.push(String.fromCharCode.apply(null, unencoded.subarray(i, i + CHUNK_SIZE)));

}

return btoa(arr.join(''));

};

const encode = (input) => {

return encodeBase64(input).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');

};

const decodeBase64 = (encoded) => {

const binary = atob(encoded);

const bytes = new Uint8Array(binary.length);

for (let i = 0; i < binary.length; i++) {

bytes[i] = binary.charCodeAt(i);

}

return bytes;

};

const decode = (input) => {

let encoded = input;

if (encoded instanceof Uint8Array) {

encoded = decoder.decode(encoded);

}

encoded = encoded.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');

try {

return decodeBase64(encoded);

}

catch {

throw new TypeError('The input to be decoded is not correctly encoded.');

}

};

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/is_key_like.js

/* harmony default export */ const is_key_like = ((key) => {

if (isCryptoKey(key)) {

return true;

}

return key?.[Symbol.toStringTag] === 'KeyObject';

});

const types = ['CryptoKey'];

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/key_to_jwk.js

const keyToJWK = async (key) => {

if (key instanceof Uint8Array) {

return {

kty: 'oct',

k: encode(key),

};

}

if (!isCryptoKey(key)) {

throw new TypeError(invalid_key_input(key, ...types, 'Uint8Array'));

}

if (!key.extractable) {

throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');

}

const { ext, key_ops, alg, use, ...jwk } = await webcrypto.subtle.exportKey('jwk', key);

return jwk;

};

/* harmony default export */ const key_to_jwk = (keyToJWK);

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/key/export.js

async function exportSPKI(key) {

return exportPublic(key);

}

async function exportPKCS8(key) {

return exportPrivate(key);

}

async function exportJWK(key) {

return key_to_jwk(key);

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/util/errors.js

class JOSEError extends Error {

constructor(message, options) {

super(message, options);

this.code = 'ERR_JOSE_GENERIC';

this.name = this.constructor.name;

Error.captureStackTrace?.(this, this.constructor);

}

}

JOSEError.code = 'ERR_JOSE_GENERIC';

class JWTClaimValidationFailed extends JOSEError {

constructor(message, payload, claim = 'unspecified', reason = 'unspecified') {

super(message, { cause: { claim, reason, payload } });

this.code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';

this.claim = claim;

this.reason = reason;

this.payload = payload;

}

}

JWTClaimValidationFailed.code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';

class JWTExpired extends JOSEError {

constructor(message, payload, claim = 'unspecified', reason = 'unspecified') {

super(message, { cause: { claim, reason, payload } });

this.code = 'ERR_JWT_EXPIRED';

this.claim = claim;

this.reason = reason;

this.payload = payload;

}

}

JWTExpired.code = 'ERR_JWT_EXPIRED';

class JOSEAlgNotAllowed extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JOSE_ALG_NOT_ALLOWED';

}

}

JOSEAlgNotAllowed.code = 'ERR_JOSE_ALG_NOT_ALLOWED';

class errors_JOSENotSupported extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JOSE_NOT_SUPPORTED';

}

}

errors_JOSENotSupported.code = 'ERR_JOSE_NOT_SUPPORTED';

class JWEDecryptionFailed extends JOSEError {

constructor(message = 'decryption operation failed', options) {

super(message, options);

this.code = 'ERR_JWE_DECRYPTION_FAILED';

}

}

JWEDecryptionFailed.code = 'ERR_JWE_DECRYPTION_FAILED';

class JWEInvalid extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JWE_INVALID';

}

}

JWEInvalid.code = 'ERR_JWE_INVALID';

class JWSInvalid extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JWS_INVALID';

}

}

JWSInvalid.code = 'ERR_JWS_INVALID';

class JWTInvalid extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JWT_INVALID';

}

}

JWTInvalid.code = 'ERR_JWT_INVALID';

class JWKInvalid extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JWK_INVALID';

}

}

JWKInvalid.code = 'ERR_JWK_INVALID';

class JWKSInvalid extends JOSEError {

constructor() {

super(...arguments);

this.code = 'ERR_JWKS_INVALID';

}

}

JWKSInvalid.code = 'ERR_JWKS_INVALID';

class JWKSNoMatchingKey extends JOSEError {

constructor(message = 'no applicable key found in the JSON Web Key Set', options) {

super(message, options);

this.code = 'ERR_JWKS_NO_MATCHING_KEY';

}

}

JWKSNoMatchingKey.code = 'ERR_JWKS_NO_MATCHING_KEY';

class JWKSMultipleMatchingKeys extends JOSEError {

constructor(message = 'multiple matching keys found in the JSON Web Key Set', options) {

super(message, options);

this.code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';

}

}

Symbol.asyncIterator;

JWKSMultipleMatchingKeys.code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';

class JWKSTimeout extends JOSEError {

constructor(message = 'request timed out', options) {

super(message, options);

this.code = 'ERR_JWKS_TIMEOUT';

}

}

JWKSTimeout.code = 'ERR_JWKS_TIMEOUT';

class JWSSignatureVerificationFailed extends JOSEError {

constructor(message = 'signature verification failed', options) {

super(message, options);

this.code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';

}

}

JWSSignatureVerificationFailed.code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/subtle_dsa.js

function subtleDsa(alg, algorithm) {

const hash = `SHA-${alg.slice(-3)}`;

switch (alg) {

case 'HS256':

case 'HS384':

case 'HS512':

return { hash, name: 'HMAC' };

case 'PS256':

case 'PS384':

case 'PS512':

return { hash, name: 'RSA-PSS', saltLength: alg.slice(-3) >> 3 };

case 'RS256':

case 'RS384':

case 'RS512':

return { hash, name: 'RSASSA-PKCS1-v1_5' };

case 'ES256':

case 'ES384':

case 'ES512':

return { hash, name: 'ECDSA', namedCurve: algorithm.namedCurve };

case 'Ed25519':

return { name: 'Ed25519' };

case 'EdDSA':

return { name: algorithm.name };

default:

throw new errors_JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);

}

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/check_key_length.js

/* harmony default export */ const check_key_length = ((alg, key) => {

if (alg.startsWith('RS') || alg.startsWith('PS')) {

const { modulusLength } = key.algorithm;

if (typeof modulusLength !== 'number' || modulusLength < 2048) {

throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);

}

}

});

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/crypto_key.js

function unusable(name, prop = 'algorithm.name') {

return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);

}

function isAlgorithm(algorithm, name) {

return algorithm.name === name;

}

function getHashLength(hash) {

return parseInt(hash.name.slice(4), 10);

}

function getNamedCurve(alg) {

switch (alg) {

case 'ES256':

return 'P-256';

case 'ES384':

return 'P-384';

case 'ES512':

return 'P-521';

default:

throw new Error('unreachable');

}

}

function checkUsage(key, usages) {

if (usages.length && !usages.some((expected) => key.usages.includes(expected))) {

let msg = 'CryptoKey does not support this operation, its usages must include ';

if (usages.length > 2) {

const last = usages.pop();

msg += `one of ${usages.join(', ')}, or ${last}.`;

}

else if (usages.length === 2) {

msg += `one of ${usages[0]} or ${usages[1]}.`;

}

else {

msg += `${usages[0]}.`;

}

throw new TypeError(msg);

}

}

function checkSigCryptoKey(key, alg, ...usages) {

switch (alg) {

case 'HS256':

case 'HS384':

case 'HS512': {

if (!isAlgorithm(key.algorithm, 'HMAC'))

throw unusable('HMAC');

const expected = parseInt(alg.slice(2), 10);

const actual = getHashLength(key.algorithm.hash);

if (actual !== expected)

throw unusable(`SHA-${expected}`, 'algorithm.hash');

break;

}

case 'RS256':

case 'RS384':

case 'RS512': {

if (!isAlgorithm(key.algorithm, 'RSASSA-PKCS1-v1_5'))

throw unusable('RSASSA-PKCS1-v1_5');

const expected = parseInt(alg.slice(2), 10);

const actual = getHashLength(key.algorithm.hash);

if (actual !== expected)

throw unusable(`SHA-${expected}`, 'algorithm.hash');

break;

}

case 'PS256':

case 'PS384':

case 'PS512': {

if (!isAlgorithm(key.algorithm, 'RSA-PSS'))

throw unusable('RSA-PSS');

const expected = parseInt(alg.slice(2), 10);

const actual = getHashLength(key.algorithm.hash);

if (actual !== expected)

throw unusable(`SHA-${expected}`, 'algorithm.hash');

break;

}

case 'EdDSA': {

if (key.algorithm.name !== 'Ed25519' && key.algorithm.name !== 'Ed448') {

throw unusable('Ed25519 or Ed448');

}

break;

}

case 'Ed25519': {

if (!isAlgorithm(key.algorithm, 'Ed25519'))

throw unusable('Ed25519');

break;

}

case 'ES256':

case 'ES384':

case 'ES512': {

if (!isAlgorithm(key.algorithm, 'ECDSA'))

throw unusable('ECDSA');

const expected = getNamedCurve(alg);

const actual = key.algorithm.namedCurve;

if (actual !== expected)

throw unusable(expected, 'algorithm.namedCurve');

break;

}

default:

throw new TypeError('CryptoKey does not support this operation');

}

checkUsage(key, usages);

}

function checkEncCryptoKey(key, alg, ...usages) {

switch (alg) {

case 'A128GCM':

case 'A192GCM':

case 'A256GCM': {

if (!isAlgorithm(key.algorithm, 'AES-GCM'))

throw unusable('AES-GCM');

const expected = parseInt(alg.slice(1, 4), 10);

const actual = key.algorithm.length;

if (actual !== expected)

throw unusable(expected, 'algorithm.length');

break;

}

case 'A128KW':

case 'A192KW':

case 'A256KW': {

if (!isAlgorithm(key.algorithm, 'AES-KW'))

throw unusable('AES-KW');

const expected = parseInt(alg.slice(1, 4), 10);

const actual = key.algorithm.length;

if (actual !== expected)

throw unusable(expected, 'algorithm.length');

break;

}

case 'ECDH': {

switch (key.algorithm.name) {

case 'ECDH':

case 'X25519':

case 'X448':

break;

default:

throw unusable('ECDH, X25519, or X448');

}

break;

}

case 'PBES2-HS256+A128KW':

case 'PBES2-HS384+A192KW':

case 'PBES2-HS512+A256KW':

if (!isAlgorithm(key.algorithm, 'PBKDF2'))

throw unusable('PBKDF2');

break;

case 'RSA-OAEP':

case 'RSA-OAEP-256':

case 'RSA-OAEP-384':

case 'RSA-OAEP-512': {

if (!isAlgorithm(key.algorithm, 'RSA-OAEP'))

throw unusable('RSA-OAEP');

const expected = parseInt(alg.slice(9), 10) || 1;

const actual = getHashLength(key.algorithm.hash);

if (actual !== expected)

throw unusable(`SHA-${expected}`, 'algorithm.hash');

break;

}

default:

throw new TypeError('CryptoKey does not support this operation');

}

checkUsage(key, usages);

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/is_object.js

function isObjectLike(value) {

return typeof value === 'object' && value !== null;

}

function isObject(input) {

if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') {

return false;

}

if (Object.getPrototypeOf(input) === null) {

return true;

}

let proto = input;

while (Object.getPrototypeOf(proto) !== null) {

proto = Object.getPrototypeOf(proto);

}

return Object.getPrototypeOf(input) === proto;

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/is_jwk.js

function isJWK(key) {

return isObject(key) && typeof key.kty === 'string';

}

function isPrivateJWK(key) {

return key.kty !== 'oct' && typeof key.d === 'string';

}

function isPublicJWK(key) {

return key.kty !== 'oct' && typeof key.d === 'undefined';

}

function isSecretJWK(key) {

return isJWK(key) && key.kty === 'oct' && typeof key.k === 'string';

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/jwk_to_key.js

function subtleMapping(jwk) {

let algorithm;

let keyUsages;

switch (jwk.kty) {

case 'RSA': {

switch (jwk.alg) {

case 'PS256':

case 'PS384':

case 'PS512':

algorithm = { name: 'RSA-PSS', hash: `SHA-${jwk.alg.slice(-3)}` };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'RS256':

case 'RS384':

case 'RS512':

algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${jwk.alg.slice(-3)}` };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'RSA-OAEP':

case 'RSA-OAEP-256':

case 'RSA-OAEP-384':

case 'RSA-OAEP-512':

algorithm = {

name: 'RSA-OAEP',

hash: `SHA-${parseInt(jwk.alg.slice(-3), 10) || 1}`,

};

keyUsages = jwk.d ? ['decrypt', 'unwrapKey'] : ['encrypt', 'wrapKey'];

break;

default:

throw new errors_JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');

}

break;

}

case 'EC': {

switch (jwk.alg) {

case 'ES256':

algorithm = { name: 'ECDSA', namedCurve: 'P-256' };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'ES384':

algorithm = { name: 'ECDSA', namedCurve: 'P-384' };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'ES512':

algorithm = { name: 'ECDSA', namedCurve: 'P-521' };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'ECDH-ES':

case 'ECDH-ES+A128KW':

case 'ECDH-ES+A192KW':

case 'ECDH-ES+A256KW':

algorithm = { name: 'ECDH', namedCurve: jwk.crv };

keyUsages = jwk.d ? ['deriveBits'] : [];

break;

default:

throw new errors_JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');

}

break;

}

case 'OKP': {

switch (jwk.alg) {

case 'Ed25519':

algorithm = { name: 'Ed25519' };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'EdDSA':

algorithm = { name: jwk.crv };

keyUsages = jwk.d ? ['sign'] : ['verify'];

break;

case 'ECDH-ES':

case 'ECDH-ES+A128KW':

case 'ECDH-ES+A192KW':

case 'ECDH-ES+A256KW':

algorithm = { name: jwk.crv };

keyUsages = jwk.d ? ['deriveBits'] : [];

break;

default:

throw new errors_JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');

}

break;

}

default:

throw new errors_JOSENotSupported('Invalid or unsupported JWK "kty" (Key Type) Parameter value');

}

return { algorithm, keyUsages };

}

const parse = async (jwk) => {

if (!jwk.alg) {

throw new TypeError('"alg" argument is required when "jwk.alg" is not present');

}

const { algorithm, keyUsages } = subtleMapping(jwk);

const rest = [

algorithm,

jwk.ext ?? false,

jwk.key_ops ?? keyUsages,

];

const keyData = { ...jwk };

delete keyData.alg;

delete keyData.use;

return webcrypto.subtle.importKey('jwk', keyData, ...rest);

};

/* harmony default export */ const jwk_to_key = (parse);

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/normalize_key.js

const exportKeyValue = (k) => decode(k);

let privCache;

let pubCache;

const isKeyObject = (key) => {

return key?.[Symbol.toStringTag] === 'KeyObject';

};

const importAndCache = async (cache, key, jwk, alg, freeze = false) => {

let cached = cache.get(key);

if (cached?.[alg]) {

return cached[alg];

}

const cryptoKey = await jwk_to_key({ ...jwk, alg });

if (freeze)

Object.freeze(key);

if (!cached) {

cache.set(key, { [alg]: cryptoKey });

}

else {

cached[alg] = cryptoKey;

}

return cryptoKey;

};

const normalizePublicKey = (key, alg) => {

if (isKeyObject(key)) {

let jwk = key.export({ format: 'jwk' });

delete jwk.d;

delete jwk.dp;

delete jwk.dq;

delete jwk.p;

delete jwk.q;

delete jwk.qi;

if (jwk.k) {

return exportKeyValue(jwk.k);

}

pubCache || (pubCache = new WeakMap());

return importAndCache(pubCache, key, jwk, alg);

}

if (isJWK(key)) {

if (key.k)

return decode(key.k);

pubCache || (pubCache = new WeakMap());

const cryptoKey = importAndCache(pubCache, key, key, alg, true);

return cryptoKey;

}

return key;

};

const normalizePrivateKey = (key, alg) => {

if (isKeyObject(key)) {

let jwk = key.export({ format: 'jwk' });

if (jwk.k) {

return exportKeyValue(jwk.k);

}

privCache || (privCache = new WeakMap());

return importAndCache(privCache, key, jwk, alg);

}

if (isJWK(key)) {

if (key.k)

return decode(key.k);

privCache || (privCache = new WeakMap());

const cryptoKey = importAndCache(privCache, key, key, alg, true);

return cryptoKey;

}

return key;

};

/* harmony default export */ const normalize_key = ({ normalizePublicKey, normalizePrivateKey });

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/get_sign_verify_key.js

async function getCryptoKey(alg, key, usage) {

if (usage === 'sign') {

key = await normalize_key.normalizePrivateKey(key, alg);

}

if (usage === 'verify') {

key = await normalize_key.normalizePublicKey(key, alg);

}

if (isCryptoKey(key)) {

checkSigCryptoKey(key, alg, usage);

return key;

}

if (key instanceof Uint8Array) {

if (!alg.startsWith('HS')) {

throw new TypeError(invalid_key_input(key, ...types));

}

return webcrypto.subtle.importKey('raw', key, { hash: `SHA-${alg.slice(-3)}`, name: 'HMAC' }, false, [usage]);

}

throw new TypeError(invalid_key_input(key, ...types, 'Uint8Array', 'JSON Web Key'));

}

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/runtime/sign.js

const sign = async (alg, key, data) => {

const cryptoKey = await getCryptoKey(alg, key, 'sign');

check_key_length(alg, cryptoKey);

const signature = await webcrypto.subtle.sign(subtleDsa(alg, cryptoKey.algorithm), cryptoKey, data);

return new Uint8Array(signature);

};

/* harmony default export */ const runtime_sign = (sign);

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/is_disjoint.js

const isDisjoint = (...headers) => {

const sources = headers.filter(Boolean);

if (sources.length === 0 || sources.length === 1) {

return true;

}

let acc;

for (const header of sources) {

const parameters = Object.keys(header);

if (!acc || acc.size === 0) {

acc = new Set(parameters);

continue;

}

for (const parameter of parameters) {

if (acc.has(parameter)) {

return false;

}

acc.add(parameter);

}

}

return true;

};

/* harmony default export */ const is_disjoint = (isDisjoint);

;// ./node_modules/solid-oidc/node_modules/jose/dist/browser/lib/check_key_type.js

const tag = (key) => key?.[Symbol.toStringTag];

const jwkMatchesOp = (alg, key, usage) => {