solid-ui 2.4.25-3d353685 → 2.4.25-e709d181

package/dist/main.js

@@ -13119,12 +13119,12 @@ Object.defineProperty(exports, "__esModule", ({
 }));
 exports.versionInfo = void 0;
 var versionInfo = {
-  buildTime: '2023-02-13T18:33:53Z',
-  commit: '3d3536854bc96f1a76b3da3788eb578207ead433',
+  buildTime: '2023-03-02T16:37:54Z',
+  commit: 'e709d1818c38b016f4032b30613ee30fdcc12dc3',
   npmInfo: {
     'solid-ui': '2.4.25',
     npm: '8.19.3',
-    node: '16.19.0',
+    node: '16.19.1',
     v8: '9.4.146.26-node.24',
     uv: '1.43.0',
     zlib: '1.2.11',
@@ -13134,7 +13134,7 @@ var versionInfo = {
     nghttp2: '1.47.0',
     napi: '8',
     llhttp: '6.0.10',
-    openssl: '1.1.1s+quic',
+    openssl: '1.1.1t+quic',
     cldr: '41.0',
     icu: '71.1',
     tz: '2022f',
@@ -25646,7 +25646,10 @@ class ClientAuthentication {
         this.login = async (options, eventEmitter) => {
             var _a, _b;
             await this.sessionInfoManager.clear(options.sessionId);
-            const redirectUrl = (0, oidc_client_ext_1.removeOidcQueryParam)((_a = options.redirectUrl) !== null && _a !== void 0 ? _a : window.location.href);
+            const redirectUrl = (_a = options.redirectUrl) !== null && _a !== void 0 ? _a : (0, oidc_client_ext_1.removeOidcQueryParam)(window.location.href);
+            if (!(0, solid_client_authn_core_1.isValidRedirectUrl)(redirectUrl)) {
+                throw new Error(`${redirectUrl} is not a valid redirect URL, it is either a malformed IRI or it includes a hash fragment.`);
+            }
             await this.loginHandler.handle({
                 ...options,
                 redirectUrl,
@@ -26117,7 +26120,6 @@ exports["default"] = ClientRegistrar;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.WELL_KNOWN_OPENID_CONFIG = void 0;
 const solid_client_authn_core_1 = __webpack_require__(/*! @inrupt/solid-client-authn-core */ "./node_modules/@inrupt/solid-client-authn-core/dist/index.js");
-const urlPath_1 = __webpack_require__(/*! ../../util/urlPath */ "./node_modules/@inrupt/solid-client-authn-browser/dist/util/urlPath.js");
 exports.WELL_KNOWN_OPENID_CONFIG = ".well-known/openid-configuration";
 const issuerConfigKeyMap = {
     issuer: {
@@ -26223,7 +26225,7 @@ class IssuerConfigFetcher {
     }
     async fetchConfig(issuer) {
         let issuerConfig;
-        const openIdConfigUrl = (0, urlPath_1.appendToUrlPathname)(issuer, exports.WELL_KNOWN_OPENID_CONFIG);
+        const openIdConfigUrl = new URL(exports.WELL_KNOWN_OPENID_CONFIG, issuer).href;
         const issuerConfigRequestBody = await window.fetch(openIdConfigUrl);
         try {
             issuerConfig = processConfig(await issuerConfigRequestBody.json());
@@ -26774,27 +26776,6 @@ exports["default"] = StorageUtilityBrowser;
 
 /***/ }),
 
-/***/ "./node_modules/@inrupt/solid-client-authn-browser/dist/util/urlPath.js":
-/*!******************************************************************************!*\
-  !*** ./node_modules/@inrupt/solid-client-authn-browser/dist/util/urlPath.js ***!
-  \******************************************************************************/
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.appendToUrlPathname = void 0;
-function appendToUrlPathname(url, append) {
-    const parsedUrl = new URL(url);
-    const path = parsedUrl.pathname;
-    parsedUrl.pathname = `${path}${path.endsWith("/") ? "" : "/"}${append.startsWith("/") ? append.substring(1) : append}`;
-    return parsedUrl.toString();
-}
-exports.appendToUrlPathname = appendToUrlPathname;
-//# sourceMappingURL=urlPath.js.map
-
-/***/ }),
-
 /***/ "./node_modules/@inrupt/solid-client-authn-browser/node_modules/uuid/dist/commonjs-browser/index.js":
 /*!**********************************************************************************************************!*\
   !*** ./node_modules/@inrupt/solid-client-authn-browser/node_modules/uuid/dist/commonjs-browser/index.js ***!
@@ -27909,6 +27890,16 @@ async function getWebidFromTokenPayload(idToken, jwksIri, issuerIri, clientId) {
     }
 }
 
+function isValidRedirectUrl(redirectUrl) {
+    try {
+        const urlObject = new URL(redirectUrl);
+        return urlObject.hash === "";
+    }
+    catch (e) {
+        return false;
+    }
+}
+
 function isSupportedTokenType(token) {
     return typeof token === "string" && ["DPoP", "Bearer"].includes(token);
 }
@@ -28324,6 +28315,7 @@ exports.getSessionIdFromOauthState = getSessionIdFromOauthState;
 exports.getWebidFromTokenPayload = getWebidFromTokenPayload;
 exports.handleRegistration = handleRegistration;
 exports.isSupportedTokenType = isSupportedTokenType;
+exports.isValidRedirectUrl = isValidRedirectUrl;
 exports.loadOidcContextFromStorage = loadOidcContextFromStorage;
 exports.mockStorage = mockStorage;
 exports.mockStorageUtility = mockStorageUtility;
@@ -35244,6 +35236,7 @@ const {
 } = __webpack_require__(/*! ./url */ "./node_modules/jsonld/lib/url.js");
 
 const {
+  REGEX_KEYWORD,
   addValue: _addValue,
   asArray: _asArray,
   compareShortestLeast: _compareShortestLeast
@@ -35261,7 +35254,6 @@ module.exports = api;
  *          to compact, null for none.
  * @param element the element to compact.
  * @param options the compaction options.
- * @param compactionMap the compaction map to use.
  *
  * @return a promise that resolves to the compacted value.
  */
@@ -35269,33 +35261,21 @@ api.compact = async ({
   activeCtx,
   activeProperty = null,
   element,
-  options = {},
-  compactionMap = () => undefined
+  options = {}
 }) => {
   // recursively compact array
   if(_isArray(element)) {
     let rval = [];
     for(let i = 0; i < element.length; ++i) {
-      // compact, dropping any null values unless custom mapped
-      let compacted = await api.compact({
+      const compacted = await api.compact({
         activeCtx,
         activeProperty,
         element: element[i],
-        options,
-        compactionMap
+        options
       });
       if(compacted === null) {
-        compacted = await compactionMap({
-          unmappedValue: element[i],
-          activeCtx,
-          activeProperty,
-          parent: element,
-          index: i,
-          options
-        });
-        if(compacted === undefined) {
-          continue;
-        }
+        // FIXME: need event?
+        continue;
       }
       rval.push(compacted);
     }
@@ -35359,8 +35339,7 @@ api.compact = async ({
           activeCtx,
           activeProperty,
           element: element['@list'],
-          options,
-          compactionMap
+          options
         });
       }
     }
@@ -35488,8 +35467,7 @@ api.compact = async ({
           activeCtx,
           activeProperty: '@reverse',
           element: expandedValue,
-          options,
-          compactionMap
+          options
         });
 
         // handle double-reversed properties
@@ -35526,8 +35504,7 @@ api.compact = async ({
           activeCtx,
           activeProperty,
           element: expandedValue,
-          options,
-          compactionMap
+          options
         });
 
         if(!(_isArray(compactedValue) && compactedValue.length === 0)) {
@@ -35644,8 +35621,7 @@ api.compact = async ({
           activeCtx,
           activeProperty: itemActiveProperty,
           element: (isList || isGraph) ? inner : expandedItem,
-          options,
-          compactionMap
+          options
         });
 
         // handle @list
@@ -35840,8 +35816,7 @@ api.compact = async ({
                 activeCtx,
                 activeProperty: itemActiveProperty,
                 element: {'@id': expandedItem['@id']},
-                options,
-                compactionMap
+                options
               });
             }
           }
@@ -36155,7 +36130,8 @@ api.compactIri = ({
         // The None case preserves rval as potentially relative
         return iri;
       } else {
-        return _removeBase(_prependBase(base, activeCtx['@base']), iri);
+        const _iri = _removeBase(_prependBase(base, activeCtx['@base']), iri);
+        return REGEX_KEYWORD.test(_iri) ? `./${_iri}` : _iri;
       }
     } else {
       return _removeBase(base, iri);
@@ -36462,13 +36438,18 @@ const {
 } = __webpack_require__(/*! ./url */ "./node_modules/jsonld/lib/url.js");
 
 const {
+  handleEvent: _handleEvent
+} = __webpack_require__(/*! ./events */ "./node_modules/jsonld/lib/events.js");
+
+const {
+  REGEX_BCP47,
+  REGEX_KEYWORD,
   asArray: _asArray,
   compareShortestLeast: _compareShortestLeast
 } = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.js");
 
 const INITIAL_CONTEXT_CACHE = new Map();
 const INITIAL_CONTEXT_CACHE_MAX_SIZE = 10000;
-const KEYWORD_PATTERN = /^@[a-zA-Z]+$/;
 
 const api = {};
 module.exports = api;
@@ -36503,6 +36484,23 @@ api.process = async ({
     return activeCtx;
   }
 
+  // event handler for capturing events to replay when using a cached context
+  const events = [];
+  const eventCaptureHandler = [
+    ({event, next}) => {
+      events.push(event);
+      next();
+    }
+  ];
+  // chain to original handler
+  if(options.eventHandler) {
+    eventCaptureHandler.push(options.eventHandler);
+  }
+  // store original options to use when replaying events
+  const originalOptions = options;
+  // shallow clone options with event capture handler
+  options = {...options, eventHandler: eventCaptureHandler};
+
   // resolve contexts
   const resolved = await options.contextResolver.resolve({
     activeCtx,
@@ -36540,46 +36538,12 @@ api.process = async ({
     if(ctx === null) {
       // We can't nullify if there are protected terms and we're
       // not allowing overrides (e.g. processing a property term scoped context)
-      if(!overrideProtected &&
-        Object.keys(activeCtx.protected).length !== 0) {
-        const protectedMode = (options && options.protectedMode) || 'error';
-        if(protectedMode === 'error') {
-          throw new JsonLdError(
-            'Tried to nullify a context with protected terms outside of ' +
-            'a term definition.',
-            'jsonld.SyntaxError',
-            {code: 'invalid context nullification'});
-        } else if(protectedMode === 'warn') {
-          // FIXME: remove logging and use a handler
-          console.warn('WARNING: invalid context nullification');
-
-          // get processed context from cache if available
-          const processed = resolvedContext.getProcessed(activeCtx);
-          if(processed) {
-            rval = activeCtx = processed;
-            continue;
-          }
-
-          const oldActiveCtx = activeCtx;
-          // copy all protected term definitions to fresh initial context
-          rval = activeCtx = api.getInitialContext(options).clone();
-          for(const [term, _protected] of
-            Object.entries(oldActiveCtx.protected)) {
-            if(_protected) {
-              activeCtx.mappings[term] =
-                util.clone(oldActiveCtx.mappings[term]);
-            }
-          }
-          activeCtx.protected = util.clone(oldActiveCtx.protected);
-
-          // cache processed result
-          resolvedContext.setProcessed(oldActiveCtx, rval);
-          continue;
-        }
+      if(!overrideProtected && Object.keys(activeCtx.protected).length !== 0) {
         throw new JsonLdError(
-          'Invalid protectedMode.',
+          'Tried to nullify a context with protected terms outside of ' +
+          'a term definition.',
           'jsonld.SyntaxError',
-          {code: 'invalid protected mode', context: localCtx, protectedMode});
+          {code: 'invalid context nullification'});
       }
       rval = activeCtx = api.getInitialContext(options).clone();
       continue;
@@ -36588,7 +36552,14 @@ api.process = async ({
     // get processed context from cache if available
     const processed = resolvedContext.getProcessed(activeCtx);
     if(processed) {
-      rval = activeCtx = processed;
+      if(originalOptions.eventHandler) {
+        // replay events with original non-capturing options
+        for(const event of processed.events) {
+          _handleEvent({event, options: originalOptions});
+        }
+      }
+
+      rval = activeCtx = processed.context;
       continue;
     }
 
@@ -36673,8 +36644,25 @@ api.process = async ({
           '@context must be an absolute IRI.',
           'jsonld.SyntaxError', {code: 'invalid vocab mapping', context: ctx});
       } else {
-        rval['@vocab'] = _expandIri(rval, value, {vocab: true, base: true},
+        const vocab = _expandIri(rval, value, {vocab: true, base: true},
           undefined, undefined, options);
+        if(!_isAbsoluteIri(vocab)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'relative @vocab reference',
+                level: 'warning',
+                message: 'Relative @vocab reference found.',
+                details: {
+                  vocab
+                }
+              },
+              options
+            });
+          }
+        }
+        rval['@vocab'] = vocab;
       }
       defined.set('@vocab', true);
     }
@@ -36691,6 +36679,22 @@ api.process = async ({
           'jsonld.SyntaxError',
           {code: 'invalid default language', context: ctx});
       } else {
+        if(!value.match(REGEX_BCP47)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'invalid @language value',
+                level: 'warning',
+                message: '@language value must be valid BCP47.',
+                details: {
+                  language: value
+                }
+              },
+              options
+            });
+          }
+        }
         rval['@language'] = value.toLowerCase();
       }
       defined.set('@language', true);
@@ -36856,7 +36860,10 @@ api.process = async ({
     }
 
     // cache processed result
-    resolvedContext.setProcessed(activeCtx, rval);
+    resolvedContext.setProcessed(activeCtx, {
+      context: rval,
+      events
+    });
   }
 
   return rval;
@@ -36871,9 +36878,6 @@ api.process = async ({
  * @param defined a map of defining/defined keys to detect cycles and prevent
  *          double definitions.
  * @param {Object} [options] - creation options.
- * @param {string} [options.protectedMode="error"] - "error" to throw error
- *   on `@protected` constraint violation, "warn" to allow violations and
- *   signal a warning.
  * @param overrideProtected `false` allows protected terms to be modified.
  */
 api.createTermDefinition = ({
@@ -36923,10 +36927,23 @@ api.createTermDefinition = ({
       'Invalid JSON-LD syntax; keywords cannot be overridden.',
       'jsonld.SyntaxError',
       {code: 'keyword redefinition', context: localCtx, term});
-  } else if(term.match(KEYWORD_PATTERN)) {
-    // FIXME: remove logging and use a handler
-    console.warn('WARNING: terms beginning with "@" are reserved' +
-      ' for future use and ignored', {term});
+  } else if(term.match(REGEX_KEYWORD)) {
+    if(options.eventHandler) {
+      _handleEvent({
+        event: {
+          type: ['JsonLdEvent'],
+          code: 'reserved term',
+          level: 'warning',
+          message:
+            'Terms beginning with "@" are ' +
+            'reserved for future use and dropped.',
+          details: {
+            term
+          }
+        },
+        options
+      });
+    }
     return;
   } else if(term === '') {
     throw new JsonLdError(
@@ -37006,10 +37023,23 @@ api.createTermDefinition = ({
         'jsonld.SyntaxError', {code: 'invalid IRI mapping', context: localCtx});
     }
 
-    if(!api.isKeyword(reverse) && reverse.match(KEYWORD_PATTERN)) {
-      // FIXME: remove logging and use a handler
-      console.warn('WARNING: values beginning with "@" are reserved' +
-        ' for future use and ignored', {reverse});
+    if(reverse.match(REGEX_KEYWORD)) {
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'reserved @reverse value',
+            level: 'warning',
+            message:
+              '@reverse values beginning with "@" are ' +
+              'reserved for future use and dropped.',
+            details: {
+              reverse
+            }
+          },
+          options
+        });
+      }
       if(previousMapping) {
         activeCtx.mappings.set(term, previousMapping);
       } else {
@@ -37042,10 +37072,23 @@ api.createTermDefinition = ({
     if(id === null) {
       // reserve a null term, which may be protected
       mapping['@id'] = null;
-    } else if(!api.isKeyword(id) && id.match(KEYWORD_PATTERN)) {
-      // FIXME: remove logging and use a handler
-      console.warn('WARNING: values beginning with "@" are reserved' +
-        ' for future use and ignored', {id});
+    } else if(!api.isKeyword(id) && id.match(REGEX_KEYWORD)) {
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'reserved @id value',
+            level: 'warning',
+            message:
+              '@id values beginning with "@" are ' +
+              'reserved for future use and dropped.',
+            details: {
+              id
+            }
+          },
+          options
+        });
+      }
       if(previousMapping) {
         activeCtx.mappings.set(term, previousMapping);
       } else {
@@ -37360,23 +37403,10 @@ api.createTermDefinition = ({
     activeCtx.protected[term] = true;
     mapping.protected = true;
     if(!_deepCompare(previousMapping, mapping)) {
-      const protectedMode = (options && options.protectedMode) || 'error';
-      if(protectedMode === 'error') {
-        throw new JsonLdError(
-          `Invalid JSON-LD syntax; tried to redefine "${term}" which is a ` +
-          'protected term.',
-          'jsonld.SyntaxError',
-          {code: 'protected term redefinition', context: localCtx, term});
-      } else if(protectedMode === 'warn') {
-        // FIXME: remove logging and use a handler
-        console.warn('WARNING: protected term redefinition', {term});
-        return;
-      }
       throw new JsonLdError(
-        'Invalid protectedMode.',
+        'Invalid JSON-LD syntax; tried to redefine a protected term.',
         'jsonld.SyntaxError',
-        {code: 'invalid protected mode', context: localCtx, term,
-          protectedMode});
+        {code: 'protected term redefinition', context: localCtx, term});
     }
   }
 };
@@ -37425,7 +37455,7 @@ function _expandIri(activeCtx, value, relativeTo, localCtx, defined, options) {
   }
 
   // ignore non-keyword things that look like a keyword
-  if(value.match(KEYWORD_PATTERN)) {
+  if(value.match(REGEX_KEYWORD)) {
     return null;
   }
 
@@ -37483,21 +37513,104 @@ function _expandIri(activeCtx, value, relativeTo, localCtx, defined, options) {
     }
   }
 
-  // prepend vocab
-  if(relativeTo.vocab && '@vocab' in activeCtx) {
-    return activeCtx['@vocab'] + value;
-  }
+  // A flag that captures whether the iri being expanded is
+  // the value for an @type
+  //let typeExpansion = false;
+
+  //if(options !== undefined && options.typeExpansion !== undefined) {
+  //  typeExpansion = options.typeExpansion;
+  //}
 
-  // prepend base
-  if(relativeTo.base && '@base' in activeCtx) {
-    if(activeCtx['@base']) {
-      // The null case preserves value as potentially relative
-      return prependBase(prependBase(options.base, activeCtx['@base']), value);
+  if(relativeTo.vocab && '@vocab' in activeCtx) {
+    // prepend vocab
+    const prependedResult = activeCtx['@vocab'] + value;
+    // FIXME: needed? may be better as debug event.
+    /*
+    if(options && options.eventHandler) {
+      _handleEvent({
+        event: {
+          type: ['JsonLdEvent'],
+          code: 'prepending @vocab during expansion',
+          level: 'info',
+          message: 'Prepending @vocab during expansion.',
+          details: {
+            type: '@vocab',
+            vocab: activeCtx['@vocab'],
+            value,
+            result: prependedResult,
+            typeExpansion
+          }
+        },
+        options
+      });
     }
+    */
+    // the null case preserves value as potentially relative
+    value = prependedResult;
   } else if(relativeTo.base) {
-    return prependBase(options.base, value);
+    // prepend base
+    let prependedResult;
+    let base;
+    if('@base' in activeCtx) {
+      if(activeCtx['@base']) {
+        base = prependBase(options.base, activeCtx['@base']);
+        prependedResult = prependBase(base, value);
+      } else {
+        base = activeCtx['@base'];
+        prependedResult = value;
+      }
+    } else {
+      base = options.base;
+      prependedResult = prependBase(options.base, value);
+    }
+    // FIXME: needed? may be better as debug event.
+    /*
+    if(options && options.eventHandler) {
+      _handleEvent({
+        event: {
+          type: ['JsonLdEvent'],
+          code: 'prepending @base during expansion',
+          level: 'info',
+          message: 'Prepending @base during expansion.',
+          details: {
+            type: '@base',
+            base,
+            value,
+            result: prependedResult,
+            typeExpansion
+          }
+        },
+        options
+      });
+    }
+    */
+    // the null case preserves value as potentially relative
+    value = prependedResult;
   }
 
+  // FIXME: duplicate? needed? maybe just enable in a verbose debug mode
+  /*
+  if(!_isAbsoluteIri(value) && options && options.eventHandler) {
+    // emit event indicating a relative IRI was found, which can result in it
+    // being dropped when converting to other RDF representations
+    _handleEvent({
+      event: {
+        type: ['JsonLdEvent'],
+        code: 'relative IRI after expansion',
+        // FIXME: what level?
+        level: 'warning',
+        message: 'Relative IRI after expansion.',
+        details: {
+          relativeIri: value,
+          typeExpansion
+        }
+      },
+      options
+    });
+    // NOTE: relative reference events emitted at calling sites as needed
+  }
+  */
+
   return value;
 }
 
@@ -38013,7 +38126,7 @@ module.exports = ({
       }
 
       // "alternate" link header is a redirect
-      alternate = linkHeaders['alternate'];
+      alternate = linkHeaders.alternate;
       if(alternate &&
         alternate.type == 'application/ld+json' &&
         !(contentType || '').match(/^application\/(\w*\+)?json$/)) {
@@ -38040,6 +38153,195 @@ function _get(xhr, url, headers) {
 }
 
 
+/***/ }),
+
+/***/ "./node_modules/jsonld/lib/events.js":
+/*!*******************************************!*\
+  !*** ./node_modules/jsonld/lib/events.js ***!
+  \*******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+/*
+ * Copyright (c) 2020 Digital Bazaar, Inc. All rights reserved.
+ */
+
+
+const JsonLdError = __webpack_require__(/*! ./JsonLdError */ "./node_modules/jsonld/lib/JsonLdError.js");
+
+const {
+  isArray: _isArray
+} = __webpack_require__(/*! ./types */ "./node_modules/jsonld/lib/types.js");
+
+const {
+  asArray: _asArray
+} = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.js");
+
+const api = {};
+module.exports = api;
+
+// default handler, store as null or an array
+// exposed to allow fast external pre-handleEvent() checks
+api.defaultEventHandler = null;
+
+/**
+ * Setup event handler.
+ *
+ * Return an array event handler constructed from an optional safe mode
+ * handler, an optional options event handler, and an optional default handler.
+ *
+ * @param {object} options - processing options
+ *   {function|object|array} [eventHandler] - an event handler.
+ *
+ * @return an array event handler.
+ */
+api.setupEventHandler = ({options = {}}) => {
+  // build in priority order
+  const eventHandler = [].concat(
+    options.safe ? api.safeEventHandler : [],
+    options.eventHandler ? _asArray(options.eventHandler) : [],
+    api.defaultEventHandler ? api.defaultEventHandler : []
+  );
+  // null if no handlers
+  return eventHandler.length === 0 ? null : eventHandler;
+};
+
+/**
+ * Handle an event.
+ *
+ * Top level APIs have a common 'eventHandler' option. This option can be a
+ * function, array of functions, object mapping event.code to functions (with a
+ * default to call next()), or any combination of such handlers. Handlers will
+ * be called with an object with an 'event' entry and a 'next' function. Custom
+ * handlers should process the event as appropriate. The 'next()' function
+ * should be called to let the next handler process the event.
+ *
+ * NOTE: Only call this function if options.eventHandler is set and is an
+ * array of hanlers. This is an optimization. Callers are expected to check
+ * for an event handler before constructing events and calling this function.
+ *
+ * @param {object} event - event structure:
+ *   {string} code - event code
+ *   {string} level - severity level, one of: ['warning']
+ *   {string} message - human readable message
+ *   {object} details - event specific details
+ * @param {object} options - processing options
+ *   {array} eventHandler - an event handler array.
+ */
+api.handleEvent = ({
+  event,
+  options
+}) => {
+  _handle({event, handlers: options.eventHandler});
+};
+
+function _handle({event, handlers}) {
+  let doNext = true;
+  for(let i = 0; doNext && i < handlers.length; ++i) {
+    doNext = false;
+    const handler = handlers[i];
+    if(_isArray(handler)) {
+      doNext = _handle({event, handlers: handler});
+    } else if(typeof handler === 'function') {
+      handler({event, next: () => {
+        doNext = true;
+      }});
+    } else if(typeof handler === 'object') {
+      if(event.code in handler) {
+        handler[event.code]({event, next: () => {
+          doNext = true;
+        }});
+      } else {
+        doNext = true;
+      }
+    } else {
+      throw new JsonLdError(
+        'Invalid event handler.',
+        'jsonld.InvalidEventHandler',
+        {event});
+    }
+  }
+  return doNext;
+}
+
+const _notSafeEventCodes = new Set([
+  'empty object',
+  'free-floating scalar',
+  'invalid @language value',
+  'invalid property',
+  // NOTE: spec edge case
+  'null @id value',
+  'null @value value',
+  'object with only @id',
+  'object with only @language',
+  'object with only @list',
+  'object with only @value',
+  'relative @id reference',
+  'relative @type reference',
+  'relative @vocab reference',
+  'reserved @id value',
+  'reserved @reverse value',
+  'reserved term',
+  // toRDF
+  'blank node predicate',
+  'relative graph reference',
+  'relative object reference',
+  'relative predicate reference',
+  'relative subject reference'
+]);
+
+// safe handler that rejects unsafe warning conditions
+api.safeEventHandler = function safeEventHandler({event, next}) {
+  // fail on all unsafe warnings
+  if(event.level === 'warning' && _notSafeEventCodes.has(event.code)) {
+    throw new JsonLdError(
+      'Safe mode validation error.',
+      'jsonld.ValidationError',
+      {event}
+    );
+  }
+  next();
+};
+
+// logs all events and continues
+api.logEventHandler = function logEventHandler({event, next}) {
+  console.log(`EVENT: ${event.message}`, {event});
+  next();
+};
+
+// log 'warning' level events
+api.logWarningEventHandler = function logWarningEventHandler({event, next}) {
+  if(event.level === 'warning') {
+    console.warn(`WARNING: ${event.message}`, {event});
+  }
+  next();
+};
+
+// fallback to throw errors for any unhandled events
+api.unhandledEventHandler = function unhandledEventHandler({event}) {
+  throw new JsonLdError(
+    'No handler for event.',
+    'jsonld.UnhandledEvent',
+    {event}
+  );
+};
+
+/**
+ * Set default event handler.
+ *
+ * By default, all event are unhandled. It is recommended to pass in an
+ * eventHandler into each call. However, this call allows using a default
+ * eventHandler when one is not otherwise provided.
+ *
+ * @param {object} options - default handler options:
+ *   {function|object|array} eventHandler - a default event handler.
+ *     falsey to unset.
+ */
+api.setDefaultEventHandler = function({eventHandler} = {}) {
+  api.defaultEventHandler = eventHandler ? _asArray(eventHandler) : null;
+};
+
+
 /***/ }),
 
 /***/ "./node_modules/jsonld/lib/expand.js":
@@ -38084,15 +38386,20 @@ const {
 } = __webpack_require__(/*! ./url */ "./node_modules/jsonld/lib/url.js");
 
 const {
+  REGEX_BCP47,
+  REGEX_KEYWORD,
   addValue: _addValue,
   asArray: _asArray,
   getValues: _getValues,
   validateTypeValue: _validateTypeValue
 } = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.js");
 
+const {
+  handleEvent: _handleEvent
+} = __webpack_require__(/*! ./events */ "./node_modules/jsonld/lib/events.js");
+
 const api = {};
 module.exports = api;
-const REGEX_BCP47 = /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/;
 
 /**
  * Recursively expands an element using the given context. Any context in
@@ -38109,10 +38416,6 @@ const REGEX_BCP47 = /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/;
  * @param typeScopedContext an optional type-scoped active context for
  *          expanding values of nodes that were expressed according to
  *          a type-scoped context.
- * @param expansionMap(info) a function that can be used to custom map
- *          unmappable values (or to throw an error when they are detected);
- *          if this function returns `undefined` then the default behavior
- *          will be used.
  *
  * @return a Promise that resolves to the expanded value.
  */
@@ -38123,8 +38426,7 @@ api.expand = async ({
   options = {},
   insideList = false,
   insideIndex = false,
-  typeScopedContext = null,
-  expansionMap = () => undefined
+  typeScopedContext = null
 }) => {
   // nothing to expand
   if(element === null || element === undefined) {
@@ -38137,21 +38439,28 @@ api.expand = async ({
   }
 
   if(!_isArray(element) && !_isObject(element)) {
-    // drop free-floating scalars that are not in lists unless custom mapped
+    // drop free-floating scalars that are not in lists
     if(!insideList && (activeProperty === null ||
       _expandIri(activeCtx, activeProperty, {vocab: true},
         options) === '@graph')) {
-      const mapped = await expansionMap({
-        unmappedValue: element,
-        activeCtx,
-        activeProperty,
-        options,
-        insideList
-      });
-      if(mapped === undefined) {
-        return null;
+      // FIXME
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'free-floating scalar',
+            level: 'warning',
+            message: 'Dropping free-floating scalar not in a list.',
+            details: {
+              value: element
+              //activeProperty
+              //insideList
+            }
+          },
+          options
+        });
       }
-      return mapped;
+      return null;
     }
 
     // expand element according to value expansion rules
@@ -38171,7 +38480,6 @@ api.expand = async ({
         activeProperty,
         element: element[i],
         options,
-        expansionMap,
         insideIndex,
         typeScopedContext
       });
@@ -38180,19 +38488,16 @@ api.expand = async ({
       }
 
       if(e === null) {
-        e = await expansionMap({
-          unmappedValue: element[i],
-          activeCtx,
-          activeProperty,
-          parent: element,
-          index: i,
-          options,
-          expandedParent: rval,
-          insideList
-        });
-        if(e === undefined) {
-          continue;
-        }
+        // FIXME: add debug event?
+        //unmappedValue: element[i],
+        //activeProperty,
+        //parent: element,
+        //index: i,
+        //expandedParent: rval,
+        //insideList
+
+        // NOTE: no-value events emitted at calling sites as needed
+        continue;
       }
 
       if(_isArray(e)) {
@@ -38305,8 +38610,8 @@ api.expand = async ({
     options,
     insideList,
     typeKey,
-    typeScopedContext,
-    expansionMap});
+    typeScopedContext
+  });
 
   // get property count on expanded output
   keys = Object.keys(rval);
@@ -38343,24 +38648,27 @@ api.expand = async ({
     const values = rval['@value'] === null ? [] : _asArray(rval['@value']);
     const types = _getValues(rval, '@type');
 
-    // drop null @values unless custom mapped
+    // drop null @values
     if(_processingMode(activeCtx, 1.1) && types.includes('@json') &&
       types.length === 1) {
       // Any value of @value is okay if @type: @json
     } else if(values.length === 0) {
-      const mapped = await expansionMap({
-        unmappedValue: rval,
-        activeCtx,
-        activeProperty,
-        element,
-        options,
-        insideList
-      });
-      if(mapped !== undefined) {
-        rval = mapped;
-      } else {
-        rval = null;
+      // FIXME
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'null @value value',
+            level: 'warning',
+            message: 'Dropping null @value value.',
+            details: {
+              value: rval
+            }
+          },
+          options
+        });
       }
+      rval = null;
     } else if(!values.every(v => (_isString(v) || _isEmptyObject(v))) &&
       '@language' in rval) {
       // if @language is present, @value must be a string
@@ -38395,43 +38703,64 @@ api.expand = async ({
       count = keys.length;
     }
   } else if(count === 1 && '@language' in rval) {
-    // drop objects with only @language unless custom mapped
-    const mapped = await expansionMap(rval, {
-      unmappedValue: rval,
-      activeCtx,
-      activeProperty,
-      element,
-      options,
-      insideList
-    });
-    if(mapped !== undefined) {
-      rval = mapped;
-    } else {
-      rval = null;
+    // drop objects with only @language
+    // FIXME
+    if(options.eventHandler) {
+      _handleEvent({
+        event: {
+          type: ['JsonLdEvent'],
+          code: 'object with only @language',
+          level: 'warning',
+          message: 'Dropping object with only @language.',
+          details: {
+            value: rval
+          }
+        },
+        options
+      });
     }
+    rval = null;
   }
 
-  // drop certain top-level objects that do not occur in lists, unless custom
-  // mapped
+  // drop certain top-level objects that do not occur in lists
   if(_isObject(rval) &&
     !options.keepFreeFloatingNodes && !insideList &&
     (activeProperty === null || expandedActiveProperty === '@graph')) {
     // drop empty object, top-level @value/@list, or object with only @id
     if(count === 0 || '@value' in rval || '@list' in rval ||
       (count === 1 && '@id' in rval)) {
-      const mapped = await expansionMap({
-        unmappedValue: rval,
-        activeCtx,
-        activeProperty,
-        element,
-        options,
-        insideList
-      });
-      if(mapped !== undefined) {
-        rval = mapped;
-      } else {
-        rval = null;
+      // FIXME
+      if(options.eventHandler) {
+        // FIXME: one event or diff event for empty, @v/@l, {@id}?
+        let code;
+        let message;
+        if(count === 0) {
+          code = 'empty object';
+          message = 'Dropping empty object.';
+        } else if('@value' in rval) {
+          code = 'object with only @value';
+          message = 'Dropping object with only @value.';
+        } else if('@list' in rval) {
+          code = 'object with only @list';
+          message = 'Dropping object with only @list.';
+        } else if(count === 1 && '@id' in rval) {
+          code = 'object with only @id';
+          message = 'Dropping object with only @id.';
+        }
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code,
+            level: 'warning',
+            message,
+            details: {
+              value: rval
+            }
+          },
+          options
+        });
       }
+      rval = null;
     }
   }
 
@@ -38450,10 +38779,6 @@ api.expand = async ({
  * @param insideList true if the element is a list, false if not.
  * @param typeKey first key found expanding to @type.
  * @param typeScopedContext the context before reverting.
- * @param expansionMap(info) a function that can be used to custom map
- *          unmappable values (or to throw an error when they are detected);
- *          if this function returns `undefined` then the default behavior
- *          will be used.
  */
 async function _expandObject({
   activeCtx,
@@ -38464,8 +38789,7 @@ async function _expandObject({
   options = {},
   insideList,
   typeKey,
-  typeScopedContext,
-  expansionMap
+  typeScopedContext
 }) {
   const keys = Object.keys(element).sort();
   const nests = [];
@@ -38475,7 +38799,10 @@ async function _expandObject({
   const isJsonType = element[typeKey] &&
     _expandIri(activeCtx,
       (_isArray(element[typeKey]) ? element[typeKey][0] : element[typeKey]),
-      {vocab: true}, options) === '@json';
+      {vocab: true}, {
+        ...options,
+        typeExpansion: true
+      }) === '@json';
 
   for(const key of keys) {
     let value = element[key];
@@ -38487,25 +38814,28 @@ async function _expandObject({
     }
 
     // expand property
-    let expandedProperty = _expandIri(activeCtx, key, {vocab: true}, options);
+    const expandedProperty = _expandIri(activeCtx, key, {vocab: true}, options);
 
-    // drop non-absolute IRI keys that aren't keywords unless custom mapped
+    // drop non-absolute IRI keys that aren't keywords
     if(expandedProperty === null ||
       !(_isAbsoluteIri(expandedProperty) || _isKeyword(expandedProperty))) {
-      // TODO: use `await` to support async
-      expandedProperty = expansionMap({
-        unmappedProperty: key,
-        activeCtx,
-        activeProperty,
-        parent: element,
-        options,
-        insideList,
-        value,
-        expandedParent
-      });
-      if(expandedProperty === undefined) {
-        continue;
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'invalid property',
+            level: 'warning',
+            message: 'Dropping property that did not expand into an ' +
+              'absolute IRI or keyword.',
+            details: {
+              property: key,
+              expandedProperty
+            }
+          },
+          options
+        });
       }
+      continue;
     }
 
     if(_isKeyword(expandedProperty)) {
@@ -38558,8 +38888,61 @@ async function _expandObject({
 
       _addValue(
         expandedParent, '@id',
-        _asArray(value).map(v =>
-          _isString(v) ? _expandIri(activeCtx, v, {base: true}, options) : v),
+        _asArray(value).map(v => {
+          if(_isString(v)) {
+            const ve = _expandIri(activeCtx, v, {base: true}, options);
+            if(options.eventHandler) {
+              if(ve === null) {
+                // NOTE: spec edge case
+                // See https://github.com/w3c/json-ld-api/issues/480
+                if(v === null) {
+                  _handleEvent({
+                    event: {
+                      type: ['JsonLdEvent'],
+                      code: 'null @id value',
+                      level: 'warning',
+                      message: 'Null @id found.',
+                      details: {
+                        id: v
+                      }
+                    },
+                    options
+                  });
+                } else {
+                  // matched KEYWORD regex
+                  _handleEvent({
+                    event: {
+                      type: ['JsonLdEvent'],
+                      code: 'reserved @id value',
+                      level: 'warning',
+                      message: 'Reserved @id found.',
+                      details: {
+                        id: v
+                      }
+                    },
+                    options
+                  });
+                }
+              } else if(!_isAbsoluteIri(ve)) {
+                _handleEvent({
+                  event: {
+                    type: ['JsonLdEvent'],
+                    code: 'relative @id reference',
+                    level: 'warning',
+                    message: 'Relative @id reference found.',
+                    details: {
+                      id: v,
+                      expandedId: ve
+                    }
+                  },
+                  options
+                });
+              }
+            }
+            return ve;
+          }
+          return v;
+        }),
         {propertyIsArray: options.isFrame});
       continue;
     }
@@ -38571,17 +38954,39 @@ async function _expandObject({
         value = Object.fromEntries(Object.entries(value).map(([k, v]) => [
           _expandIri(typeScopedContext, k, {vocab: true}),
           _asArray(v).map(vv =>
-            _expandIri(typeScopedContext, vv, {base: true, vocab: true})
+            _expandIri(typeScopedContext, vv, {base: true, vocab: true},
+              {...options, typeExpansion: true})
           )
         ]));
       }
       _validateTypeValue(value, options.isFrame);
       _addValue(
         expandedParent, '@type',
-        _asArray(value).map(v =>
-          _isString(v) ?
-            _expandIri(typeScopedContext, v,
-              {base: true, vocab: true}, options) : v),
+        _asArray(value).map(v => {
+          if(_isString(v)) {
+            const ve = _expandIri(typeScopedContext, v,
+              {base: true, vocab: true},
+              {...options, typeExpansion: true});
+            if(ve !== '@json' && !_isAbsoluteIri(ve)) {
+              if(options.eventHandler) {
+                _handleEvent({
+                  event: {
+                    type: ['JsonLdEvent'],
+                    code: 'relative @type reference',
+                    level: 'warning',
+                    message: 'Relative @type reference found.',
+                    details: {
+                      type: v
+                    }
+                  },
+                  options
+                });
+              }
+            }
+            return ve;
+          }
+          return v;
+        }),
         {propertyIsArray: options.isFrame});
       continue;
     }
@@ -38594,8 +38999,7 @@ async function _expandObject({
         activeCtx,
         activeProperty,
         element: value,
-        options,
-        expansionMap
+        options
       }));
 
       // Expanded values must be node objects
@@ -38651,9 +39055,22 @@ async function _expandObject({
       value = _asArray(value).map(v => _isString(v) ? v.toLowerCase() : v);
 
       // ensure language tag matches BCP47
-      for(const lang of value) {
-        if(_isString(lang) && !lang.match(REGEX_BCP47)) {
-          console.warn(`@language must be valid BCP47: ${lang}`);
+      for(const language of value) {
+        if(_isString(language) && !language.match(REGEX_BCP47)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'invalid @language value',
+                level: 'warning',
+                message: '@language value must be valid BCP47.',
+                details: {
+                  language
+                }
+              },
+              options
+            });
+          }
         }
       }
 
@@ -38714,8 +39131,7 @@ async function _expandObject({
         activeProperty:
         '@reverse',
         element: value,
-        options,
-        expansionMap
+        options
       });
       // properties double-reversed
       if('@reverse' in expandedValue) {
@@ -38790,7 +39206,6 @@ async function _expandObject({
         options,
         activeProperty: key,
         value,
-        expansionMap,
         asGraph,
         indexKey,
         propertyIndex
@@ -38803,7 +39218,6 @@ async function _expandObject({
         options,
         activeProperty: key,
         value,
-        expansionMap,
         asGraph,
         indexKey: '@id'
       });
@@ -38815,7 +39229,6 @@ async function _expandObject({
         options,
         activeProperty: key,
         value,
-        expansionMap,
         asGraph: false,
         indexKey: '@type'
       });
@@ -38832,8 +39245,7 @@ async function _expandObject({
           activeProperty: nextActiveProperty,
           element: value,
           options,
-          insideList: isList,
-          expansionMap
+          insideList: isList
         });
       } else if(
         _getContextValue(activeCtx, key, '@type') === '@json') {
@@ -38848,29 +39260,18 @@ async function _expandObject({
           activeProperty: key,
           element: value,
           options,
-          insideList: false,
-          expansionMap
+          insideList: false
         });
       }
     }
 
     // drop null values if property is not @value
     if(expandedValue === null && expandedProperty !== '@value') {
-      // TODO: use `await` to support async
-      expandedValue = expansionMap({
-        unmappedValue: value,
-        expandedProperty,
-        activeCtx: termCtx,
-        activeProperty,
-        parent: element,
-        options,
-        insideList,
-        key,
-        expandedParent
-      });
-      if(expandedValue === undefined) {
-        continue;
-      }
+      // FIXME: event?
+      //unmappedValue: value,
+      //expandedProperty,
+      //key,
+      continue;
     }
 
     // convert expanded value to @list if container specifies it
@@ -38952,8 +39353,8 @@ async function _expandObject({
         options,
         insideList,
         typeScopedContext,
-        typeKey,
-        expansionMap});
+        typeKey
+      });
     }
   }
 }
@@ -38981,7 +39382,8 @@ function _expandValue({activeCtx, activeProperty, value, options}) {
   if(expandedProperty === '@id') {
     return _expandIri(activeCtx, value, {base: true}, options);
   } else if(expandedProperty === '@type') {
-    return _expandIri(activeCtx, value, {vocab: true, base: true}, options);
+    return _expandIri(activeCtx, value, {vocab: true, base: true},
+      {...options, typeExpansion: true});
   }
 
   // get type definition from context
@@ -38989,7 +39391,25 @@ function _expandValue({activeCtx, activeProperty, value, options}) {
 
   // do @id expansion (automatic for @graph)
   if((type === '@id' || expandedProperty === '@graph') && _isString(value)) {
-    return {'@id': _expandIri(activeCtx, value, {base: true}, options)};
+    const expandedValue = _expandIri(activeCtx, value, {base: true}, options);
+    // NOTE: handle spec edge case and avoid invalid {"@id": null}
+    if(expandedValue === null && value.match(REGEX_KEYWORD)) {
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'reserved @id value',
+            level: 'warning',
+            message: 'Reserved @id found.',
+            details: {
+              id: activeProperty
+            }
+          },
+          options
+        });
+      }
+    }
+    return {'@id': expandedValue};
   }
   // do @id expansion w/vocab
   if(type === '@vocab' && _isString(value)) {
@@ -39060,6 +39480,22 @@ function _expandLanguageMap(activeCtx, languageMap, direction, options) {
       }
       const val = {'@value': item};
       if(expandedKey !== '@none') {
+        if(!key.match(REGEX_BCP47)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'invalid @language value',
+                level: 'warning',
+                message: '@language value must be valid BCP47.',
+                details: {
+                  language: key
+                }
+              },
+              options
+            });
+          }
+        }
         val['@language'] = key.toLowerCase();
       }
       if(direction) {
@@ -39071,9 +39507,9 @@ function _expandLanguageMap(activeCtx, languageMap, direction, options) {
   return rval;
 }
 
-async function _expandIndexMap(
-  {activeCtx, options, activeProperty, value, expansionMap, asGraph,
-    indexKey, propertyIndex}) {
+async function _expandIndexMap({
+  activeCtx, options, activeProperty, value, asGraph, indexKey, propertyIndex
+}) {
   const rval = [];
   const keys = Object.keys(value).sort();
   const isTypeIndex = indexKey === '@type';
@@ -39102,8 +39538,7 @@ async function _expandIndexMap(
       element: val,
       options,
       insideList: false,
-      insideIndex: true,
-      expansionMap
+      insideIndex: true
     });
 
     // expand for @type, but also for @none
@@ -40068,7 +40503,15 @@ function _valueMatch(pattern, value) {
 const JsonLdError = __webpack_require__(/*! ./JsonLdError */ "./node_modules/jsonld/lib/JsonLdError.js");
 const graphTypes = __webpack_require__(/*! ./graphTypes */ "./node_modules/jsonld/lib/graphTypes.js");
 const types = __webpack_require__(/*! ./types */ "./node_modules/jsonld/lib/types.js");
-const util = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.js");
+
+const {
+  REGEX_BCP47,
+  addValue: _addValue
+} = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.js");
+
+const {
+  handleEvent: _handleEvent
+} = __webpack_require__(/*! ./events */ "./node_modules/jsonld/lib/events.js");
 
 // constants
 const {
@@ -40091,8 +40534,6 @@ const {
   XSD_STRING,
 } = __webpack_require__(/*! ./constants */ "./node_modules/jsonld/lib/constants.js");
 
-const REGEX_BCP47 = /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/;
-
 const api = {};
 module.exports = api;
 
@@ -40106,15 +40547,16 @@ module.exports = api;
  */
 api.fromRDF = async (
   dataset,
-  {
-    useRdfType = false,
-    useNativeTypes = false,
-    rdfDirection = null
-  }
+  options
 ) => {
   const defaultGraph = {};
   const graphMap = {'@default': defaultGraph};
   const referencedOnce = {};
+  const {
+    useRdfType = false,
+    useNativeTypes = false,
+    rdfDirection = null
+  } = options;
 
   for(const quad of dataset) {
     // TODO: change 'name' to 'graph'
@@ -40145,12 +40587,12 @@ api.fromRDF = async (
     }
 
     if(p === RDF_TYPE && !useRdfType && objectIsNode) {
-      util.addValue(node, '@type', o.value, {propertyIsArray: true});
+      _addValue(node, '@type', o.value, {propertyIsArray: true});
       continue;
     }
 
-    const value = _RDFToObject(o, useNativeTypes, rdfDirection);
-    util.addValue(node, p, value, {propertyIsArray: true});
+    const value = _RDFToObject(o, useNativeTypes, rdfDirection, options);
+    _addValue(node, p, value, {propertyIsArray: true});
 
     // object may be an RDF list/partial list node but we can't know easily
     // until all triples are read
@@ -40209,12 +40651,12 @@ api.fromRDF = async (
       }
 
       if(p === RDF_TYPE && !useRdfType && objectIsId) {
-        util.addValue(node, '@type', o.value, {propertyIsArray: true});
+        _addValue(node, '@type', o.value, {propertyIsArray: true});
         continue;
       }
 
       const value = _RDFToObject(o, useNativeTypes);
-      util.addValue(node, p, value, {propertyIsArray: true});
+      _addValue(node, p, value, {propertyIsArray: true});
 
       // object may be an RDF list/partial list node but we can't know easily
       // until all triples are read
@@ -40337,10 +40779,12 @@ api.fromRDF = async (
  *
  * @param o the RDF triple object to convert.
  * @param useNativeTypes true to output native types, false not to.
+ * @param rdfDirection text direction mode [null, i18n-datatype]
+ * @param options top level API options
  *
  * @return the JSON-LD object.
  */
-function _RDFToObject(o, useNativeTypes, rdfDirection) {
+function _RDFToObject(o, useNativeTypes, rdfDirection, options) {
   // convert NamedNode/BlankNode object to JSON-LD
   if(o.termType.endsWith('Node')) {
     return {'@id': o.value};
@@ -40351,6 +40795,22 @@ function _RDFToObject(o, useNativeTypes, rdfDirection) {
 
   // add language
   if(o.language) {
+    if(!o.language.match(REGEX_BCP47)) {
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'invalid @language value',
+            level: 'warning',
+            message: '@language value must be valid BCP47.',
+            details: {
+              language: o.language
+            }
+          },
+          options
+        });
+      }
+    }
     rval['@language'] = o.language;
   } else {
     let type = o.datatype.value;
@@ -40396,7 +40856,20 @@ function _RDFToObject(o, useNativeTypes, rdfDirection) {
       if(language.length > 0) {
         rval['@language'] = language;
         if(!language.match(REGEX_BCP47)) {
-          console.warn(`@language must be valid BCP47: ${language}`);
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'invalid @language value',
+                level: 'warning',
+                message: '@language value must be valid BCP47.',
+                details: {
+                  language
+                }
+              },
+              options
+            });
+          }
         }
       }
       rval['@direction'] = direction;
@@ -40526,11 +40999,12 @@ api.isSimpleGraph = v => {
 api.isBlankNode = v => {
   // Note: A value is a blank node if all of these hold true:
   // 1. It is an Object.
-  // 2. If it has an @id key its value begins with '_:'.
+  // 2. If it has an @id key that is not a string OR begins with '_:'.
   // 3. It has no keys OR is not a @value, @set, or @list.
   if(types.isObject(v)) {
     if('@id' in v) {
-      return (v['@id'].indexOf('_:') === 0);
+      const id = v['@id'];
+      return !types.isString(id) || id.indexOf('_:') === 0;
     }
     return (Object.keys(v).length === 0 ||
       !(('@value' in v) || ('@set' in v) || ('@list' in v)));
@@ -40553,7 +41027,7 @@ api.isBlankNode = v => {
  * @author Dave Longley
  *
  * @license BSD 3-Clause License
- * Copyright (c) 2011-2019 Digital Bazaar, Inc.
+ * Copyright (c) 2011-2022 Digital Bazaar, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40629,6 +41103,16 @@ const {
   mergeNodeMaps: _mergeNodeMaps
 } = __webpack_require__(/*! ./nodeMap */ "./node_modules/jsonld/lib/nodeMap.js");
 
+const {
+  logEventHandler: _logEventHandler,
+  logWarningEventHandler: _logWarningEventHandler,
+  safeEventHandler: _safeEventHandler,
+  setDefaultEventHandler: _setDefaultEventHandler,
+  setupEventHandler: _setupEventHandler,
+  strictEventHandler: _strictEventHandler,
+  unhandledEventHandler: _unhandledEventHandler
+} = __webpack_require__(/*! ./events */ "./node_modules/jsonld/lib/events.js");
+
 /* eslint-disable indent */
 // attaches jsonld API to the given object
 const wrapper = function(jsonld) {
@@ -40659,15 +41143,8 @@ const _resolvedContextCache = new LRU({max: RESOLVED_CONTEXT_CACHE_MAX_SIZE});
  *          [skipExpansion] true to assume the input is expanded and skip
  *            expansion, false not to, defaults to false.
  *          [documentLoader(url, options)] the document loader.
- *          [expansionMap(info)] a function that can be used to custom map
- *            unmappable values (or to throw an error when they are detected);
- *            if this function returns `undefined` then the default behavior
- *            will be used.
  *          [framing] true if compaction is occuring during a framing operation.
- *          [compactionMap(info)] a function that can be used to custom map
- *            unmappable values (or to throw an error when they are detected);
- *            if this function returns `undefined` then the default behavior
- *            will be used.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the compacted output.
@@ -40725,8 +41202,7 @@ jsonld.compact = async function(input, ctx, options) {
   let compacted = await _compact({
     activeCtx,
     element: expanded,
-    options,
-    compactionMap: options.compactionMap
+    options
   });
 
   // perform clean up
@@ -40802,10 +41278,7 @@ jsonld.compact = async function(input, ctx, options) {
  *          [keepFreeFloatingNodes] true to keep free-floating nodes,
  *            false not to, defaults to false.
  *          [documentLoader(url, options)] the document loader.
- *          [expansionMap(info)] a function that can be used to custom map
- *            unmappable values (or to throw an error when they are detected);
- *            if this function returns `undefined` then the default behavior
- *            will be used.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the expanded output.
@@ -40821,9 +41294,6 @@ jsonld.expand = async function(input, options) {
     contextResolver: new ContextResolver(
       {sharedCache: _resolvedContextCache})
   });
-  if(options.expansionMap === false) {
-    options.expansionMap = undefined;
-  }
 
   // build set of objects that may have @contexts to resolve
   const toResolve = {};
@@ -40874,8 +41344,7 @@ jsonld.expand = async function(input, options) {
   let expanded = await _expand({
     activeCtx,
     element: toResolve.input,
-    options,
-    expansionMap: options.expansionMap
+    options
   });
 
   // optimize away @graph with no other properties
@@ -40958,6 +41427,7 @@ jsonld.flatten = async function(input, ctx, options) {
  *          [requireAll] default @requireAll flag (default: true).
  *          [omitDefault] default @omitDefault flag (default: false).
  *          [documentLoader(url, options)] the document loader.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the framed output.
@@ -41056,6 +41526,7 @@ jsonld.frame = async function(input, frame, options) {
  *          [base] the base IRI to use.
  *          [expandContext] a context to expand with.
  *          [documentLoader(url, options)] the document loader.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the linked output.
@@ -41076,12 +41547,18 @@ jsonld.link = async function(input, ctx, options) {
  * unless the 'inputFormat' option is used. The output is an RDF dataset
  * unless the 'format' option is used.
  *
+ * Note: Canonicalization sets `safe` to `true` and `base` to `null` by
+ * default in order to produce safe outputs and "fail closed" by default. This
+ * is different from the other API transformations in this version which
+ * allow unsafe defaults (for cryptographic usage) in order to comply with the
+ * JSON-LD 1.1 specification.
+ *
  * @param input the input to normalize as JSON-LD or as a format specified by
  *          the 'inputFormat' option.
  * @param [options] the options to use:
  *          [algorithm] the normalization algorithm to use, `URDNA2015` or
  *            `URGNA2012` (default: `URDNA2015`).
- *          [base] the base IRI to use.
+ *          [base] the base IRI to use (default: `null`).
  *          [expandContext] a context to expand with.
  *          [skipExpansion] true to assume the input is expanded and skip
  *            expansion, false not to, defaults to false.
@@ -41091,6 +41568,7 @@ jsonld.link = async function(input, ctx, options) {
  *            'application/n-quads' for N-Quads.
  *          [documentLoader(url, options)] the document loader.
  *          [useNative] true to use a native canonize algorithm
+ *          [safe] true to use safe mode. (default: true).
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the normalized output.
@@ -41102,9 +41580,10 @@ jsonld.normalize = jsonld.canonize = async function(input, options) {
 
   // set default options
   options = _setDefaults(options, {
-    base: _isString(input) ? input : '',
+    base: _isString(input) ? input : null,
     algorithm: 'URDNA2015',
     skipExpansion: false,
+    safe: true,
     contextResolver: new ContextResolver(
       {sharedCache: _resolvedContextCache})
   });
@@ -41145,6 +41624,9 @@ jsonld.normalize = jsonld.canonize = async function(input, options) {
  *            (default: false).
  *          [useNativeTypes] true to convert XSD types into native types
  *            (boolean, integer, double), false not to (default: false).
+ *          [rdfDirection] 'i18n-datatype' to support RDF transformation of
+ *             @direction (default: null).
+ *          [safe] true to use safe mode. (default: false)
  *
  * @return a Promise that resolves to the JSON-LD document.
  */
@@ -41194,6 +41676,7 @@ jsonld.fromRDF = async function(dataset, options) {
  *          [produceGeneralizedRdf] true to output generalized RDF, false
  *            to produce only standard RDF (default: false).
  *          [documentLoader(url, options)] the document loader.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the RDF dataset.
@@ -41286,6 +41769,7 @@ jsonld.createNodeMap = async function(input, options) {
  *            new properties where a node is in the `object` position
  *            (default: true).
  *          [documentLoader(url, options)] the document loader.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the merged output.
@@ -41448,6 +41932,7 @@ jsonld.get = async function(url, options) {
  * @param localCtx the local context to process.
  * @param [options] the options to use:
  *          [documentLoader(url, options)] the document loader.
+ *          [safe] true to use safe mode. (default: false)
  *          [contextResolver] internal use only.
  *
  * @return a Promise that resolves to the new active context.
@@ -41533,6 +42018,14 @@ jsonld.registerRDFParser('application/nquads', NQuads.parse);
 /* URL API */
 jsonld.url = __webpack_require__(/*! ./url */ "./node_modules/jsonld/lib/url.js");
 
+/* Events API and handlers */
+jsonld.logEventHandler = _logEventHandler;
+jsonld.logWarningEventHandler = _logWarningEventHandler;
+jsonld.safeEventHandler = _safeEventHandler;
+jsonld.setDefaultEventHandler = _setDefaultEventHandler;
+jsonld.strictEventHandler = _strictEventHandler;
+jsonld.unhandledEventHandler = _unhandledEventHandler;
+
 /* Utility API */
 jsonld.util = util;
 // backwards compatibility
@@ -41554,7 +42047,24 @@ function _setDefaults(options, {
   documentLoader = jsonld.documentLoader,
   ...defaults
 }) {
-  return Object.assign({}, {documentLoader}, defaults, options);
+  // fail if obsolete options present
+  if(options && 'compactionMap' in options) {
+    throw new JsonLdError(
+      '"compactionMap" not supported.',
+      'jsonld.OptionsError');
+  }
+  if(options && 'expansionMap' in options) {
+    throw new JsonLdError(
+      '"expansionMap" not supported.',
+      'jsonld.OptionsError');
+  }
+  return Object.assign(
+    {},
+    {documentLoader},
+    defaults,
+    options,
+    {eventHandler: _setupEventHandler({options})}
+  );
 }
 
 // end of jsonld API `wrapper` factory
@@ -41948,6 +42458,10 @@ const jsonCanonicalize = __webpack_require__(/*! canonicalize */ "./node_modules
 const types = __webpack_require__(/*! ./types */ "./node_modules/jsonld/lib/types.js");
 const util = __webpack_require__(/*! ./util */ "./node_modules/jsonld/lib/util.js");
 
+const {
+  handleEvent: _handleEvent
+} = __webpack_require__(/*! ./events */ "./node_modules/jsonld/lib/events.js");
+
 const {
   // RDF,
   // RDF_LIST,
@@ -42004,6 +42518,20 @@ api.toRDF = (input, options) => {
       graphTerm.value = graphName;
     } else {
       // skip relative IRIs (not valid RDF)
+      if(options.eventHandler) {
+        _handleEvent({
+          event: {
+            type: ['JsonLdEvent'],
+            code: 'relative graph reference',
+            level: 'warning',
+            message: 'Relative graph reference found.',
+            details: {
+              graph: graphName
+            }
+          },
+          options
+        });
+      }
       continue;
     }
     _graphToRDF(dataset, nodeMap[graphName], graphTerm, issuer, options);
@@ -42045,6 +42573,20 @@ function _graphToRDF(dataset, graph, graphTerm, issuer, options) {
 
         // skip relative IRI subjects (not valid RDF)
         if(!_isAbsoluteIri(id)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'relative subject reference',
+                level: 'warning',
+                message: 'Relative subject reference found.',
+                details: {
+                  subject: id
+                }
+              },
+              options
+            });
+          }
           continue;
         }
 
@@ -42056,18 +42598,48 @@ function _graphToRDF(dataset, graph, graphTerm, issuer, options) {
 
         // skip relative IRI predicates (not valid RDF)
         if(!_isAbsoluteIri(property)) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'relative predicate reference',
+                level: 'warning',
+                message: 'Relative predicate reference found.',
+                details: {
+                  predicate: property
+                }
+              },
+              options
+            });
+          }
           continue;
         }
 
         // skip blank node predicates unless producing generalized RDF
         if(predicate.termType === 'BlankNode' &&
           !options.produceGeneralizedRdf) {
+          if(options.eventHandler) {
+            _handleEvent({
+              event: {
+                type: ['JsonLdEvent'],
+                code: 'blank node predicate',
+                level: 'warning',
+                message: 'Dropping blank node predicate.',
+                details: {
+                  // FIXME: add better issuer API to get reverse mapping
+                  property: issuer.getOldIds()
+                    .find(key => issuer.getId(key) === property)
+                }
+              },
+              options
+            });
+          }
           continue;
         }
 
         // convert list, value or node object to triple
-        const object =
-          _objectToRDF(item, issuer, dataset, graphTerm, options.rdfDirection);
+        const object = _objectToRDF(
+          item, issuer, dataset, graphTerm, options.rdfDirection, options);
         // skip null objects (they are relative IRIs)
         if(object) {
           dataset.push({
@@ -42090,10 +42662,11 @@ function _graphToRDF(dataset, graph, graphTerm, issuer, options) {
  * @param issuer a IdentifierIssuer for assigning blank node names.
  * @param dataset the array of quads to append to.
  * @param graphTerm the graph term for each quad.
+ * @param options the RDF serialization options.
  *
  * @return the head of the list.
  */
-function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
+function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection, options) {
   const first = {termType: 'NamedNode', value: RDF_FIRST};
   const rest = {termType: 'NamedNode', value: RDF_REST};
   const nil = {termType: 'NamedNode', value: RDF_NIL};
@@ -42104,7 +42677,8 @@ function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
   let subject = result;
 
   for(const item of list) {
-    const object = _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection);
+    const object = _objectToRDF(
+      item, issuer, dataset, graphTerm, rdfDirection, options);
     const next = {termType: 'BlankNode', value: issuer.getId()};
     dataset.push({
       subject,
@@ -42123,7 +42697,8 @@ function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
 
   // Tail of list
   if(last) {
-    const object = _objectToRDF(last, issuer, dataset, graphTerm, rdfDirection);
+    const object = _objectToRDF(
+      last, issuer, dataset, graphTerm, rdfDirection, options);
     dataset.push({
       subject,
       predicate: first,
@@ -42149,10 +42724,13 @@ function _listToRDF(list, issuer, dataset, graphTerm, rdfDirection) {
  * @param issuer a IdentifierIssuer for assigning blank node names.
  * @param dataset the dataset to append RDF quads to.
  * @param graphTerm the graph term for each quad.
+ * @param options the RDF serialization options.
  *
  * @return the RDF literal or RDF resource.
  */
-function _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection) {
+function _objectToRDF(
+  item, issuer, dataset, graphTerm, rdfDirection, options
+) {
   const object = {};
 
   // convert value object to RDF
@@ -42198,8 +42776,8 @@ function _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection) {
       object.datatype.value = datatype || XSD_STRING;
     }
   } else if(graphTypes.isList(item)) {
-    const _list =
-      _listToRDF(item['@list'], issuer, dataset, graphTerm, rdfDirection);
+    const _list = _listToRDF(
+      item['@list'], issuer, dataset, graphTerm, rdfDirection, options);
     object.termType = _list.termType;
     object.value = _list.value;
   } else {
@@ -42211,6 +42789,20 @@ function _objectToRDF(item, issuer, dataset, graphTerm, rdfDirection) {
 
   // skip relative IRIs, not valid RDF
   if(object.termType === 'NamedNode' && !_isAbsoluteIri(object.value)) {
+    if(options.eventHandler) {
+      _handleEvent({
+        event: {
+          type: ['JsonLdEvent'],
+          code: 'relative object reference',
+          level: 'warning',
+          message: 'Relative object reference found.',
+          details: {
+            object: object.value
+          }
+        },
+        options
+      });
+    }
     return null;
   }
 
@@ -42654,10 +43246,12 @@ const IdentifierIssuer = (__webpack_require__(/*! rdf-canonize */ "./node_module
 const JsonLdError = __webpack_require__(/*! ./JsonLdError */ "./node_modules/jsonld/lib/JsonLdError.js");
 
 // constants
+const REGEX_BCP47 = /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/;
 const REGEX_LINK_HEADERS = /(?:<[^>]*?>|"[^"]*?"|[^,])+/g;
 const REGEX_LINK_HEADER = /\s*<([^>]*?)>\s*(?:;\s*(.*))?/;
 const REGEX_LINK_HEADER_PARAMS =
   /(.*?)=(?:(?:"([^"]*?)")|([^"]*?))\s*(?:(?:;\s*)|$)/g;
+const REGEX_KEYWORD = /^@[a-zA-Z]+$/;
 
 const DEFAULTS = {
   headers: {
@@ -42668,6 +43262,8 @@ const DEFAULTS = {
 const api = {};
 module.exports = api;
 api.IdentifierIssuer = IdentifierIssuer;
+api.REGEX_BCP47 = REGEX_BCP47;
+api.REGEX_KEYWORD = REGEX_KEYWORD;
 
 /**
  * Clones an object, array, Map, Set, or string/number. If a typed JavaScript
@@ -42774,7 +43370,7 @@ api.parseLinkHeader = header => {
     while((match = REGEX_LINK_HEADER_PARAMS.exec(params))) {
       result[match[1]] = (match[2] === undefined) ? match[3] : match[2];
     }
-    const rel = result['rel'] || '';
+    const rel = result.rel || '';
     if(Array.isArray(rval[rel])) {
       rval[rel].push(result);
     } else if(rval.hasOwnProperty(rel)) {
@@ -52440,10 +53036,11 @@ var Collection = /*#__PURE__*/function (_Node) {
   }, {
     key: "substitute",
     value: function substitute(bindings) {
-      var elementsCopy = this.elements.map(function (ea) {
-        return ea.substitute(bindings);
+      var collection = new Collection();
+      this.elements.forEach(function (ea) {
+        collection.append(ea.substitute(bindings));
       });
-      return new Collection(elementsCopy);
+      return collection;
     }
   }, {
     key: "toNT",
@@ -54280,16 +54877,17 @@ var Fetcher = /*#__PURE__*/function () {
       var fetcher = this;
       // @ts-ignore
       if (fetcher.fetchQueue && fetcher.fetchQueue[uri]) {
-        console.log('Internal error - fetchQueue exists ' + uri);
+        // console.log('Internal error - fetchQueue exists ' + uri)
         var promise = fetcher.fetchQueue[uri];
         if (promise['PromiseStatus'] === 'resolved') {
           delete fetcher.fetchQueue[uri];
         } else {
           // pending
           delete fetcher.fetchQueue[uri];
-          console.log('*** Fetcher: pending fetchQueue deleted ' + uri);
+          // console.log('*** Fetcher: pending fetchQueue deleted ' + uri)
         }
       }
+
       if (fetcher.requested[uri] && fetcher.requested[uri] !== 'done' && fetcher.requested[uri] !== 'failed' && fetcher.requested[uri] !== 404) {
         var msg = "Rdflib: fetcher: Destructive operation on <".concat(fetcher.requested[uri], "> file being fetched! ") + uri;
         console.error(msg);
@@ -56154,6 +56752,9 @@ function jsonldParser(str, kb, base, callback) {
   var baseString = base && Object.prototype.hasOwnProperty.call(base, 'termType') ? base.value : base;
   return jsonld__WEBPACK_IMPORTED_MODULE_0___default().flatten(JSON.parse(str), null, {
     base: baseString
+  }).then(function (flattened) {
+    console.log(flattened);
+    return flattened;
   }).then(function (flattened) {
     return flattened.reduce(function (store, flatResource) {
       kb = processResource(kb, base, flatResource);
@@ -61241,7 +61842,7 @@ contentType, callback, options) {
         documentString = sz.statementsToNTriples(newSts);
         return executeCallback(null, documentString);
       case _types__WEBPACK_IMPORTED_MODULE_0__.JSONLDContentType:
-        sz.setFlags('si'); // use turtle parameters
+        sz.setFlags('si dr'); // turtle + dr (means no default, no relative prefix)
         documentString = sz.statementsToJsonld(newSts); // convert via turtle
         return executeCallback(null, documentString);
       case _types__WEBPACK_IMPORTED_MODULE_0__.NQuadsContentType:
@@ -61313,7 +61914,6 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-// import * as jsonld from 'jsonld'
 
 function createSerializer(store) {
   return new Serializer(store);
@@ -61820,7 +62420,7 @@ var Serializer = /*#__PURE__*/function () {
       var termToN3 = termToN3Method.bind(this);
       function prefixDirectivesMethod() {
         var str = '';
-        if (this.defaultNamespace) {
+        if (this.flags.indexOf('d') < 0 && this.defaultNamespace) {
           str += '@prefix : ' + this.explicitURI(this.defaultNamespace) + '.\n';
         }
         for (var ns in this.prefixes) {
@@ -62305,20 +62905,19 @@ var Serializer = /*#__PURE__*/function () {
     key: "statementsToJsonld",
     value: function statementsToJsonld(sts) {
       // ttl2jsonld creates context keys for all ttl prefix
-      // context keys must be full IRI
-      function findId(itemObj) {
+      // context keys must be absolute IRI ttl2jsonld@0.0.8
+      /* function findId (itemObj) {
         if (itemObj['@id']) {
-          var item = itemObj['@id'].split(':');
-          if (keys[item[0]]) itemObj['@id'] = jsonldObj['@context'][item[0]] + item[1];
+          const item = itemObj['@id'].split(':')
+          if (keys[item[0]]) itemObj['@id'] = jsonldObj['@context'][item[0]] + item[1]
         }
-        var itemValues = Object.values(itemObj);
-        for (var i in itemValues) {
-          if (typeof itemValues[i] !== 'string') {
-            // @list contains array
-            findId(itemValues[i]);
+        const itemValues = Object.values(itemObj)
+        for (const i in itemValues) {
+          if (typeof itemValues[i] !== 'string') { // @list contains array
+            findId(itemValues[i])
           }
         }
-      }
+      } */
       var turtleDoc = this.statementsToN3(sts);
       var jsonldObj = _frogcat_ttl2jsonld__WEBPACK_IMPORTED_MODULE_4__.parse(turtleDoc);
       return JSON.stringify(jsonldObj, null, 2);
@@ -63257,9 +63856,9 @@ var IndexedFormula = /*#__PURE__*/function (_Formula) {
           // console.log('ds before substitute: ' + ds)
           if (binding) ds = ds.substitute(binding);
           // console.log('applyPatch: delete: ' + ds)
-          ds = ds.statements;
+
           var bad = [];
-          var ds2 = ds.map(function (st) {
+          var ds2 = ds.elements.map(function (st) {
             // Find the actual statements in the store
             var sts = targetKB.statementsMatching(st.subject, st.predicate, st.object, target);
             if (sts.length === 0) {
@@ -63284,8 +63883,7 @@ var IndexedFormula = /*#__PURE__*/function (_Formula) {
           // log.info("doPatch insert "+patch['insert'])
           ds = patch['insert'];
           if (binding) ds = ds.substitute(binding);
-          ds = ds.statements;
-          ds.map(function (st) {
+          ds.elements.map(function (st) {
             st.graph = target;
             targetKB.add(st.subject, st.predicate, st.object, st.graph);
           });
@@ -63302,6 +63900,7 @@ var IndexedFormula = /*#__PURE__*/function (_Formula) {
         //@ts-ignore TODO: add sync property to Query when converting Query to typescript
         query.sync = true;
         var bindingsFound = [];
+        query.pat.initBindings = [];
         targetKB.query(query, function onBinding(binding) {
           bindingsFound.push(binding);
           // console.log('   got a binding: ' + bindingDebug(binding))
@@ -66820,15 +67419,13 @@ function createAclLogic(store) {
     var ns = ns_1.ns;
     function findAclDocUrl(url) {
         return __awaiter(this, void 0, void 0, function () {
-            var doc, docNode;
+            var docNode;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        doc = store.sym(url);
-                        return [4 /*yield*/, store.fetcher.load(doc)];
+                    case 0: return [4 /*yield*/, store.fetcher.load(url)];
                     case 1:
                         _a.sent();
-                        docNode = store.any(doc, exports.ACL_LINK);
+                        docNode = store.any(url, exports.ACL_LINK);
                         if (!docNode) {
                             throw new Error("No ACL link discovered for ".concat(url));
                         }
@@ -67636,7 +68233,7 @@ function createInboxLogic(store, profileLogic, utilityLogic, containerLogic, acl
                     case 2: return [4 /*yield*/, profileLogic.getMainInbox(user)];
                     case 3:
                         inbox = _a.sent();
-                        return [4 /*yield*/, containerLogic.getContainerMembers(inbox.value)];
+                        return [4 /*yield*/, containerLogic.getContainerMembers(inbox)];
                     case 4:
                         urls = _a.sent();
                         return [2 /*return*/, urls.filter(function (url) { return !containerLogic.isContainer(url); })];
@@ -68792,19 +69389,21 @@ var rdflib_1 = __webpack_require__(/*! rdflib */ "./node_modules/rdflib/esm/inde
 function createContainerLogic(store) {
     function getContainerElements(containerNode) {
         return store
-            .statementsMatching(containerNode, (0, rdflib_1.sym)("http://www.w3.org/ns/ldp#contains"), undefined, containerNode.doc())
+            .statementsMatching(containerNode, (0, rdflib_1.sym)("http://www.w3.org/ns/ldp#contains"), undefined)
             .map(function (st) { return st.object; });
     }
     function isContainer(url) {
-        return url.charAt(url.length - 1) === "/";
+        var nodeToString = url.value;
+        return nodeToString.charAt(nodeToString.length - 1) === "/";
     }
     function createContainer(url) {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
+            var stringToNode, result;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!isContainer(url)) {
+                        stringToNode = (0, rdflib_1.sym)(url);
+                        if (!isContainer(stringToNode)) {
                             throw new Error("Not a container URL ".concat(url));
                         }
                         return [4 /*yield*/, store.fetcher._fetch(url, {
@@ -68828,16 +69427,12 @@ function createContainerLogic(store) {
     }
     function getContainerMembers(containerUrl) {
         return __awaiter(this, void 0, void 0, function () {
-            var containerNode, nodes;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        containerNode = store.sym(containerUrl);
-                        return [4 /*yield*/, store.fetcher.load(containerNode)];
+                    case 0: return [4 /*yield*/, store.fetcher.load(containerUrl)];
                     case 1:
                         _a.sent();
-                        nodes = getContainerElements(containerNode);
-                        return [2 /*return*/, nodes.map(function (node) { return node.value; })];
+                        return [2 /*return*/, getContainerElements(containerUrl)];
                 }
             });
         });
@@ -69023,28 +69618,30 @@ var CustomError_1 = __webpack_require__(/*! ../logic/CustomError */ "./node_modu
 var debug = __importStar(__webpack_require__(/*! ../util/debug */ "./node_modules/solid-logic/lib/util/debug.js"));
 var utils_1 = __webpack_require__(/*! ./utils */ "./node_modules/solid-logic/lib/util/utils.js");
 function createUtilityLogic(store, aclLogic, containerLogic) {
-    function recursiveDelete(url) {
+    function recursiveDelete(containerNode) {
         return __awaiter(this, void 0, void 0, function () {
-            var aclDocUrl, containerMembers, e_1;
+            var aclDocUrl, containerMembers, nodeToStringHere, e_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         _a.trys.push([0, 6, , 7]);
-                        if (!containerLogic.isContainer(url)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, aclLogic.findAclDocUrl(url)];
+                        if (!containerLogic.isContainer(containerNode)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, aclLogic.findAclDocUrl(containerNode)];
                     case 1:
                         aclDocUrl = _a.sent();
                         return [4 /*yield*/, store.fetcher._fetch(aclDocUrl, { method: "DELETE" })];
                     case 2:
                         _a.sent();
-                        return [4 /*yield*/, containerLogic.getContainerMembers(url)];
+                        return [4 /*yield*/, containerLogic.getContainerMembers(containerNode)];
                     case 3:
                         containerMembers = _a.sent();
                         return [4 /*yield*/, Promise.all(containerMembers.map(function (url) { return recursiveDelete(url); }))];
                     case 4:
                         _a.sent();
                         _a.label = 5;
-                    case 5: return [2 /*return*/, store.fetcher._fetch(url, { method: "DELETE" })];
+                    case 5:
+                        nodeToStringHere = containerNode.value;
+                        return [2 /*return*/, store.fetcher._fetch(nodeToStringHere, { method: "DELETE" })];
                     case 6:
                         e_1 = _a.sent();
                         return [3 /*break*/, 7];
@@ -69189,7 +69786,7 @@ function createUtilityLogic(store, aclLogic, containerLogic) {
                                 ''
                             ].join('\n');
                         }
-                        return [4 /*yield*/, aclLogic.findAclDocUrl(options.target)];
+                        return [4 /*yield*/, aclLogic.findAclDocUrl((0, rdflib_1.sym)(options.target))];
                     case 1:
                         aclDocUrl = _a.sent();
                         return [2 /*return*/, store.fetcher._fetch(aclDocUrl, {
@@ -73561,6 +74158,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "getWebidFromTokenPayload": () => (/* binding */ getWebidFromTokenPayload),
 /* harmony export */   "handleRegistration": () => (/* binding */ handleRegistration),
 /* harmony export */   "isSupportedTokenType": () => (/* binding */ isSupportedTokenType),
+/* harmony export */   "isValidRedirectUrl": () => (/* binding */ isValidRedirectUrl),
 /* harmony export */   "loadOidcContextFromStorage": () => (/* binding */ loadOidcContextFromStorage),
 /* harmony export */   "mockStorage": () => (/* binding */ mockStorage),
 /* harmony export */   "mockStorageUtility": () => (/* binding */ mockStorageUtility),
@@ -73667,6 +74265,16 @@ async function getWebidFromTokenPayload(idToken, jwksIri, issuerIri, clientId) {
     }
 }
 
+function isValidRedirectUrl(redirectUrl) {
+    try {
+        const urlObject = new URL(redirectUrl);
+        return urlObject.hash === "";
+    }
+    catch (e) {
+        return false;
+    }
+}
+
 function isSupportedTokenType(token) {
     return typeof token === "string" && ["DPoP", "Bearer"].includes(token);
 }
@@ -75036,7 +75644,7 @@ class LocalJWKSet {
         this._jwks = clone(jwks);
     }
     async getKey(protectedHeader, token) {
-        const { alg, kid } = { ...protectedHeader, ...token.header };
+        const { alg, kid } = { ...protectedHeader, ...token === null || token === void 0 ? void 0 : token.header };
         const kty = getKtyFromAlg(alg);
         const candidates = this._jwks.keys.filter((jwk) => {
             let candidate = kty === jwk.kty;
@@ -75078,18 +75686,33 @@ class LocalJWKSet {
             throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_1__.JWKSNoMatchingKey();
         }
         else if (length !== 1) {
-            throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_1__.JWKSMultipleMatchingKeys();
+            const error = new _util_errors_js__WEBPACK_IMPORTED_MODULE_1__.JWKSMultipleMatchingKeys();
+            const { _cached } = this;
+            error[Symbol.asyncIterator] = async function* () {
+                for (const jwk of candidates) {
+                    try {
+                        yield await importWithAlgCache(_cached, jwk, alg);
+                    }
+                    catch (_a) {
+                        continue;
+                    }
+                }
+            };
+            throw error;
         }
-        const cached = this._cached.get(jwk) || this._cached.set(jwk, {}).get(jwk);
-        if (cached[alg] === undefined) {
-            const keyObject = await (0,_key_import_js__WEBPACK_IMPORTED_MODULE_0__.importJWK)({ ...jwk, ext: true }, alg);
-            if (keyObject instanceof Uint8Array || keyObject.type !== 'public') {
-                throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_1__.JWKSInvalid('JSON Web Key Set members must be public keys');
-            }
-            cached[alg] = keyObject;
+        return importWithAlgCache(this._cached, jwk, alg);
+    }
+}
+async function importWithAlgCache(cache, jwk, alg) {
+    const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk);
+    if (cached[alg] === undefined) {
+        const keyObject = await (0,_key_import_js__WEBPACK_IMPORTED_MODULE_0__.importJWK)({ ...jwk, ext: true }, alg);
+        if (keyObject.type !== 'public') {
+            throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_1__.JWKSInvalid('JSON Web Key Set members must be public keys');
         }
-        return cached[alg];
+        cached[alg] = keyObject;
     }
+    return cached[alg];
 }
 function createLocalJWKSet(jwks) {
     return LocalJWKSet.prototype.getKey.bind(new LocalJWKSet(jwks));
@@ -76518,13 +77141,13 @@ function checkSigCryptoKey(key, alg, ...usages) {
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
-        case (0,_runtime_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)() && 'EdDSA': {
-            if (!isAlgorithm(key.algorithm, 'NODE-ED25519'))
-                throw unusable('NODE-ED25519');
-            break;
-        }
         case 'EdDSA': {
             if (key.algorithm.name !== 'Ed25519' && key.algorithm.name !== 'Ed448') {
+                if ((0,_runtime_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)()) {
+                    if (isAlgorithm(key.algorithm, 'NODE-ED25519'))
+                        break;
+                    throw unusable('Ed25519, Ed448, or NODE-ED25519');
+                }
                 throw unusable('Ed25519 or Ed448');
             }
             break;
@@ -77409,7 +78032,7 @@ const getNamedCurve = (keyData) => {
     }
 };
 const genericImport = async (replace, keyFormat, pem, alg, options) => {
-    var _a;
+    var _a, _b;
     let algorithm;
     let keyUsages;
     const keyData = new Uint8Array(atob(pem.replace(replace, ''))
@@ -77460,12 +78083,6 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
             keyUsages = isPublic ? [] : ['deriveBits'];
             break;
         }
-        case (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)() && 'EdDSA': {
-            const namedCurve = getNamedCurve(keyData).toUpperCase();
-            algorithm = { name: `NODE-${namedCurve}`, namedCurve: `NODE-${namedCurve}` };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        }
         case 'EdDSA':
             algorithm = { name: getNamedCurve(keyData) };
             keyUsages = isPublic ? ['verify'] : ['sign'];
@@ -77473,7 +78090,18 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
         default:
             throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_5__.JOSENotSupported('Invalid or unsupported "alg" (Algorithm) value');
     }
-    return _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.importKey(keyFormat, keyData, algorithm, (_a = options === null || options === void 0 ? void 0 : options.extractable) !== null && _a !== void 0 ? _a : false, keyUsages);
+    try {
+        return await _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.importKey(keyFormat, keyData, algorithm, (_a = options === null || options === void 0 ? void 0 : options.extractable) !== null && _a !== void 0 ? _a : false, keyUsages);
+    }
+    catch (err) {
+        if (algorithm.name === 'Ed25519' &&
+            (err === null || err === void 0 ? void 0 : err.name) === 'NotSupportedError' &&
+            (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)()) {
+            algorithm = { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' };
+            return await _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.importKey(keyFormat, keyData, algorithm, (_b = options === null || options === void 0 ? void 0 : options.extractable) !== null && _b !== void 0 ? _b : false, keyUsages);
+        }
+        throw err;
+    }
 };
 const fromPKCS8 = (pem, alg, options) => {
     return genericImport(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, 'pkcs8', pem, alg, options);
@@ -78038,7 +78666,7 @@ function getModulusLengthOption(options) {
     return modulusLength;
 }
 async function generateKeyPair(alg, options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     let algorithm;
     let keyUsages;
     switch (alg) {
@@ -78088,17 +78716,6 @@ async function generateKeyPair(alg, options) {
             algorithm = { name: 'ECDSA', namedCurve: 'P-521' };
             keyUsages = ['sign', 'verify'];
             break;
-        case (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)() && 'EdDSA':
-            switch (options === null || options === void 0 ? void 0 : options.crv) {
-                case undefined:
-                case 'Ed25519':
-                    algorithm = { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' };
-                    keyUsages = ['sign', 'verify'];
-                    break;
-                default:
-                    throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_2__.JOSENotSupported('Invalid or unsupported crv option provided');
-            }
-            break;
         case 'EdDSA':
             keyUsages = ['sign', 'verify'];
             const crv = (_a = options === null || options === void 0 ? void 0 : options.crv) !== null && _a !== void 0 ? _a : 'Ed25519';
@@ -78136,7 +78753,18 @@ async function generateKeyPair(alg, options) {
         default:
             throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_2__.JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
     }
-    return (_webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.generateKey(algorithm, (_c = options === null || options === void 0 ? void 0 : options.extractable) !== null && _c !== void 0 ? _c : false, keyUsages));
+    try {
+        return (await _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.generateKey(algorithm, (_c = options === null || options === void 0 ? void 0 : options.extractable) !== null && _c !== void 0 ? _c : false, keyUsages));
+    }
+    catch (err) {
+        if (algorithm.name === 'Ed25519' &&
+            (err === null || err === void 0 ? void 0 : err.name) === 'NotSupportedError' &&
+            (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)()) {
+            algorithm = { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' };
+            return (await _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.generateKey(algorithm, (_d = options === null || options === void 0 ? void 0 : options.extractable) !== null && _d !== void 0 ? _d : false, keyUsages));
+        }
+        throw err;
+    }
 }
 
 
@@ -78316,19 +78944,6 @@ function subtleMapping(jwk) {
             }
             break;
         }
-        case (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)() && 'OKP':
-            if (jwk.alg !== 'EdDSA') {
-                throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_2__.JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-            }
-            switch (jwk.crv) {
-                case 'Ed25519':
-                    algorithm = { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' };
-                    keyUsages = jwk.d ? ['sign'] : ['verify'];
-                    break;
-                default:
-                    throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_2__.JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-            }
-            break;
         case 'OKP': {
             switch (jwk.alg) {
                 case 'EdDSA':
@@ -78366,7 +78981,18 @@ const parse = async (jwk) => {
     const keyData = { ...jwk };
     delete keyData.alg;
     delete keyData.use;
-    return _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.importKey('jwk', keyData, ...rest);
+    try {
+        return await _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.importKey('jwk', keyData, ...rest);
+    }
+    catch (err) {
+        if (algorithm.name === 'Ed25519' &&
+            (err === null || err === void 0 ? void 0 : err.name) === 'NotSupportedError' &&
+            (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)()) {
+            rest[0] = { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' };
+            return await _webcrypto_js__WEBPACK_IMPORTED_MODULE_1__["default"].subtle.importKey('jwk', keyData, ...rest);
+        }
+        throw err;
+    }
 };
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (parse);
 
@@ -78631,10 +79257,10 @@ function subtleDsa(alg, algorithm) {
         case 'ES384':
         case 'ES512':
             return { hash, name: 'ECDSA', namedCurve: algorithm.namedCurve };
-        case (0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)() && 'EdDSA':
-            const { namedCurve } = algorithm;
-            return { name: namedCurve, namedCurve };
         case 'EdDSA':
+            if ((0,_env_js__WEBPACK_IMPORTED_MODULE_0__.isCloudflareWorkers)() && algorithm.name === 'NODE-ED25519') {
+                return { name: 'NODE-ED25519', namedCurve: 'NODE-ED25519' };
+            }
             return { name: algorithm.name };
         default:
             throw new _util_errors_js__WEBPACK_IMPORTED_MODULE_1__.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
@@ -79058,6 +79684,7 @@ class JWKSMultipleMatchingKeys extends JOSEError {
         return 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
     }
 }
+Symbol.asyncIterator;
 class JWKSTimeout extends JOSEError {
     constructor() {
         super(...arguments);