@pod-os/core 0.20.1-rc.e23505f.0 → 0.20.1-rc.f98c05a.0

package/lib/index.js

@@ -11676,15 +11676,15 @@ var PodOS = (() => {
         default:
           throw new Error("Serialize: Content-type " + contentType4 + " not supported for data write.");
       }
-    } catch (err) {
+    } catch (err2) {
       if (callback) {
-        return callback(err, void 0);
+        return callback(err2, void 0);
       }
-      throw err;
+      throw err2;
     }
-    function executeCallback(err, result6) {
+    function executeCallback(err2, result6) {
       if (callback) {
-        callback(err, result6);
+        callback(err2, result6);
         return;
       } else {
         return result6;
@@ -12729,8 +12729,8 @@ var PodOS = (() => {
         var id4 = "match" + matchIndex++;
         var fetchResource = function(requestedTerm, id5) {
           var docuri = requestedTerm.uri.split("#")[0];
-          fetcher3.nowOrWhenFetched(docuri, void 0, function(ok, body, xhr) {
-            if (!ok) {
+          fetcher3.nowOrWhenFetched(docuri, void 0, function(ok2, body, xhr) {
+            if (!ok2) {
               console.log("Error following link to <" + requestedTerm.uri + "> in query: " + body);
             }
             match(
@@ -16618,7 +16618,7 @@ var PodOS = (() => {
               '"createMessageDigest" cannot be used with "useNative".'
             );
           }
-          return new Promise((resolve, reject) => rdfCanonizeNative.canonize(dataset3, options, (err, canonical2) => err ? reject(err) : resolve(canonical2)));
+          return new Promise((resolve, reject) => rdfCanonizeNative.canonize(dataset3, options, (err2, canonical2) => err2 ? reject(err2) : resolve(canonical2)));
         }
         if (options.algorithm === "URDNA2015") {
           return new URDNA2015(options).main(dataset3);
@@ -17380,7 +17380,7 @@ var PodOS = (() => {
         const req = new xhr();
         return new Promise((resolve, reject) => {
           req.onload = () => resolve(req);
-          req.onerror = (err) => reject(err);
+          req.onerror = (err2) => reject(err2);
           req.open("GET", url7, true);
           for (const k in headers) {
             req.setRequestHeader(k, headers[k]);
@@ -25516,8 +25516,8 @@ var PodOS = (() => {
   var require_queue_microtask = __commonJS({
     "../node_modules/queue-microtask/index.js"(exports, module3) {
       var promise;
-      module3.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
-        throw err;
+      module3.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : global) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err2) => setTimeout(() => {
+        throw err2;
       }, 0));
     }
   });
@@ -25925,13 +25925,13 @@ var PodOS = (() => {
         // ### `_syntaxError` creates a syntax error for the given issue
         _syntaxError(issue3) {
           this._input = null;
-          const err = new Error(`Unexpected "${issue3}" on line ${this._line}.`);
-          err.context = {
+          const err2 = new Error(`Unexpected "${issue3}" on line ${this._line}.`);
+          err2.context = {
             token: void 0,
             line: this._line,
             previousToken: this.previousToken
           };
-          return err;
+          return err2;
         }
         // ### Strips off any starting UTF BOM mark.
         _readStartingBom(input2) {
@@ -27021,13 +27021,13 @@ var PodOS = (() => {
         }
         // ### `_error` emits an error message through the callback
         _error(message4, token2) {
-          const err = new Error(`${message4} on line ${token2.line}.`);
-          err.context = {
+          const err2 = new Error(`${message4} on line ${token2.line}.`);
+          err2.context = {
             token: token2,
             line: token2.line,
             previousToken: this._lexer.previousToken
           };
-          this._callback(err);
+          this._callback(err2);
           this._callback = noop2;
         }
         // ### `_resolveIRI` resolves an IRI against the base path
@@ -28628,21 +28628,21 @@ var PodOS = (() => {
         }
       }
     }
-    function nquadCallback(err, nquads) {
-      if (err) {
-        callback(err, kb);
+    function nquadCallback(err2, nquads) {
+      if (err2) {
+        callback(err2, kb);
       }
       try {
         n3Parser.parse(nquads, tripleCallback);
-      } catch (err2) {
-        callback(err2, kb);
+      } catch (err3) {
+        callback(err3, kb);
       }
     }
-    function tripleCallback(err, triple2) {
+    function tripleCallback(err2, triple2) {
       if (triple2) {
         kb.add(triple2.subject, triple2.predicate, triple2.object, triple2.graph);
       } else {
-        callback(err, kb);
+        callback(err2, kb);
       }
     }
   }
@@ -29090,7 +29090,7 @@ var PodOS = (() => {
           exports2.DOMException = g.DOMException;
           try {
             new exports2.DOMException();
-          } catch (err) {
+          } catch (err2) {
             exports2.DOMException = function(message4, name9) {
               this.message = message4;
               this.name = name9;
@@ -29314,8 +29314,8 @@ var PodOS = (() => {
           let parser = new RDFParser(kb);
           try {
             parser.parse(this.dom, options.original.value, options.original);
-          } catch (err) {
-            return fetcher2.failFetch(options, "Syntax error parsing RDF/XML! " + err, "parse_error");
+          } catch (err2) {
+            return fetcher2.failFetch(options, "Syntax error parsing RDF/XML! " + err2, "parse_error");
           }
           if (!options.noMeta) {
             kb.add(options.original, ns2.rdf("type"), ns2.link("RDFDocument"), fetcher2.appNode);
@@ -29369,8 +29369,8 @@ var PodOS = (() => {
           if (!options.noRDFa && parseRDFaDOM) {
             try {
               parseRDFaDOM(this.dom, kb, options.original.value);
-            } catch (err) {
-              let msg = "Error trying to parse " + options.resource + " as RDFa:\n" + err + ":\n" + err.stack;
+            } catch (err2) {
+              let msg = "Error trying to parse " + options.resource + " as RDFa:\n" + err2 + ":\n" + err2.stack;
               return fetcher2.failFetch(options, msg, "parse_error");
             }
           }
@@ -29478,8 +29478,8 @@ var PodOS = (() => {
             await jsonldParser(responseText, kb, options.original.value);
             fetcher2.store.add(options.original, ns2.rdf("type"), ns2.link("RDFDocument"), fetcher2.appNode);
             return fetcher2.doneFetch(options, response6);
-          } catch (err) {
-            const msg = "Error trying to parse " + options.resource + " as JSON-LD:\n" + err;
+          } catch (err2) {
+            const msg = "Error trying to parse " + options.resource + " as JSON-LD:\n" + err2;
             return fetcher2.failFetch(options, msg, "parse_error", response6);
           }
         }
@@ -29523,8 +29523,8 @@ var PodOS = (() => {
           let p = n3parser_default(kb, kb, options.original.value, options.original.value, null, null, "", null);
           try {
             p.loadBuf(responseText);
-          } catch (err) {
-            let msg = "Error trying to parse " + options.resource + " as Notation3:\n" + err;
+          } catch (err2) {
+            let msg = "Error trying to parse " + options.resource + " as Notation3:\n" + err2;
             return fetcher2.failFetch(options, msg, "parse_error", response6);
           }
           fetcher2.addStatus(options.req, "N3 parsed: " + p.statementCount + " triples in " + p.lines + " lines.");
@@ -29922,13 +29922,13 @@ var PodOS = (() => {
                 userCallback(false, oops);
               }
             }
-          }, function(err) {
-            var message4 = err.message || err.statusText;
+          }, function(err2) {
+            var message4 = err2.message || err2.statusText;
             message4 = "Failed to load  <" + uri6 + "> " + message4;
-            if (err.response && err.response.status) {
-              message4 += " status: " + err.response.status;
+            if (err2.response && err2.response.status) {
+              message4 += " status: " + err2.response.status;
             }
-            userCallback(false, message4, err.response);
+            userCallback(false, message4, err2.response);
           });
         }
         /**
@@ -29969,11 +29969,11 @@ var PodOS = (() => {
             this.requested[docpart(options.original.value)] = statusCode2;
             this.fireCallbacks("fail", [options.original.value, errorMessage]);
           }
-          var err = new Error("Fetcher: " + errorMessage);
-          err.status = statusCode2;
-          err.statusText = errorMessage;
-          err.response = response6;
-          return Promise.reject(err);
+          var err2 = new Error("Fetcher: " + errorMessage);
+          err2.status = statusCode2;
+          err2.statusText = errorMessage;
+          err2.response = response6;
+          return Promise.reject(err2);
         }
         // in the why part of the quad distinguish between HTML and HTTP header
         // Reverse is set iif the link was rev= as opposed to rel=
@@ -30053,9 +30053,9 @@ var PodOS = (() => {
           options.contentType = options["content-type"] || options["Content-Type"] || options.contentType || TurtleContentType;
           if (options.contentType === "application/ld+json") {
             return new Promise((resolve, reject) => {
-              serialize(doc, this.store, doc.uri, options.contentType, (err, jsonString) => {
-                if (err) {
-                  reject(err);
+              serialize(doc, this.store, doc.uri, options.contentType, (err2, jsonString) => {
+                if (err2) {
+                  reject(err2);
                 } else {
                   options.data = jsonString;
                   this.webOperation("PUT", uri6, options).then((res) => resolve(res)).catch((error4) => reject(error4));
@@ -30098,20 +30098,20 @@ var PodOS = (() => {
           const fetcher2 = this;
           try {
             var response6 = await fetcher2.load(doc);
-          } catch (err) {
-            if (err.response.status === 404) {
+          } catch (err2) {
+            if (err2.response.status === 404) {
               try {
                 response6 = await fetcher2.webOperation("PUT", doc.value, {
                   data: data2,
                   contentType: contentType4
                 });
-              } catch (err2) {
-                throw err2;
+              } catch (err3) {
+                throw err3;
               }
               delete fetcher2.requested[doc.value];
               return response6;
             } else {
-              throw err;
+              throw err2;
             }
           }
           return response6;
@@ -30202,8 +30202,8 @@ var PodOS = (() => {
                 e2.response = response6;
                 reject(e2);
               }
-            }, (err) => {
-              let msg = "Fetch error for " + method5 + " of <" + uri6 + ">:" + err;
+            }, (err2) => {
+              let msg = "Fetch error for " + method5 + " of <" + uri6 + ">:" + err2;
               reject(new Error(msg));
             });
           });
@@ -30953,8 +30953,8 @@ var PodOS = (() => {
               throw new Error(message4);
             }
             callbackFunction(uri6, response6.ok, response6.responseText, response6);
-          }).catch((err) => {
-            callbackFunction(uri6, false, err.message, err);
+          }).catch((err2) => {
+            callbackFunction(uri6, false, err2.message, err2);
           });
         }
         // ARE THESE THREE FUNCTIONS USED? DEPRECATE?
@@ -31066,8 +31066,8 @@ var PodOS = (() => {
           control2.reloading = true;
           var retryTimeout = 1e3;
           var tryReload = function() {
-            updater.reload(updater.store, doc, function(ok, message4, response6) {
-              if (ok) {
+            updater.reload(updater.store, doc, function(ok2, message4, response6) {
+              if (ok2) {
                 if (control2.downstreamChangeListeners) {
                   for (let i = 0; i < control2.downstreamChangeListeners.length; i++) {
                     control2.downstreamChangeListeners[i]();
@@ -31138,7 +31138,7 @@ var PodOS = (() => {
             };
             var control2 = self2.patchControlFor(doc);
             control2.upstreamCount = 0;
-            socket.onerror = function onerror(err) {
+            socket.onerror = function onerror(err2) {
             };
             socket.onclose = function(event4) {
               retryTimeout *= 2;
@@ -31284,8 +31284,8 @@ _:patch
           if (!callback) {
             var thisUpdater = this;
             return new Promise(function(resolve, reject) {
-              thisUpdater.update(deletions, insertions, function(uri6, ok, errorBody) {
-                if (!ok) {
+              thisUpdater.update(deletions, insertions, function(uri6, ok2, errorBody) {
+                if (!ok2) {
                   reject(new Error(errorBody));
                 } else {
                   resolve();
@@ -31345,11 +31345,11 @@ _:patch
               }
               this.store.fetcher.load(doc).then((response6) => {
                 this.update(deletions, insertions, callback, true, options);
-              }, (err) => {
-                if (err.response.status === 404) {
+              }, (err2) => {
+                if (err2.response.status === 404) {
                   this.update(deletions, insertions, callback, true, options);
                 } else {
-                  throw new Error(`Update: Can't get updatability status ${doc} before patching: ${err}`);
+                  throw new Error(`Update: Can't get updatability status ${doc} before patching: ${err2}`);
                 }
               });
               return;
@@ -31447,8 +31447,8 @@ _:patch
               kb.add(is[i].subject, is[i].predicate, is[i].object, doc);
             }
             callbackFunction(doc.value, response7.ok, response7.responseText, response7);
-          }).catch((err) => {
-            callbackFunction(doc.value, false, err.message, err);
+          }).catch((err2) => {
+            callbackFunction(doc.value, false, err2.message, err2);
           });
         }
         /**
@@ -31547,8 +31547,8 @@ _:patch
               });
             }
             callback(doc.value, response6.ok, "", response6);
-          }).catch((err) => {
-            callback(doc.value, false, err.message);
+          }).catch((err2) => {
+            callback(doc.value, false, err2.message);
           });
         }
         /**
@@ -31570,8 +31570,8 @@ _:patch
             noMeta: true,
             clearPreviousData: true
           };
-          kb.fetcher.nowOrWhenFetched(doc.value, options, function(ok, body, response6) {
-            if (!ok) {
+          kb.fetcher.nowOrWhenFetched(doc.value, options, function(ok2, body, response6) {
+            if (!ok2) {
               callbackFunction(false, "Error reloading data: " + body, response6);
             } else if (response6.onErrorWasCalled || response6.status !== 200) {
               callbackFunction(false, "Non-HTTP error reloading data: " + body, response6);
@@ -34759,8 +34759,10 @@ _:patch
     Thing: () => Thing,
     UriService: () => UriService,
     WebIdProfile: () => WebIdProfile,
+    httpProblem: () => httpProblem,
     labelFromUri: () => labelFromUri,
-    listKnownTerms: () => listKnownTerms
+    listKnownTerms: () => listKnownTerms,
+    networkProblem: () => networkProblem
   });
 
   // ../node_modules/tslib/tslib.es6.mjs
@@ -34840,8 +34842,8 @@ _:patch
   var UnsubscriptionError = createErrorClass(function(_super) {
     return function UnsubscriptionErrorImpl(errors) {
       _super(this);
-      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
-        return i + 1 + ") " + err.toString();
+      this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err2, i) {
+        return i + 1 + ") " + err2.toString();
       }).join("\n  ") : "";
       this.name = "UnsubscriptionError";
       this.errors = errors;
@@ -34907,12 +34909,12 @@ _:patch
               var finalizer = _finalizers_1_1.value;
               try {
                 execFinalizer(finalizer);
-              } catch (err) {
+              } catch (err2) {
                 errors = errors !== null && errors !== void 0 ? errors : [];
-                if (err instanceof UnsubscriptionError) {
-                  errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                if (err2 instanceof UnsubscriptionError) {
+                  errors = __spreadArray(__spreadArray([], __read(errors)), __read(err2.errors));
                 } else {
-                  errors.push(err);
+                  errors.push(err2);
                 }
               }
             }
@@ -35019,13 +35021,13 @@ _:patch
   };
 
   // ../node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
-  function reportUnhandledError(err) {
+  function reportUnhandledError(err2) {
     timeoutProvider.setTimeout(function() {
       var onUnhandledError = config.onUnhandledError;
       if (onUnhandledError) {
-        onUnhandledError(err);
+        onUnhandledError(err2);
       } else {
-        throw err;
+        throw err2;
       }
     });
   }
@@ -35072,10 +35074,10 @@ _:patch
       cb();
     }
   }
-  function captureError(err) {
+  function captureError(err2) {
     if (config.useDeprecatedSynchronousErrorHandling && context) {
       context.errorThrown = true;
-      context.error = err;
+      context.error = err2;
     }
   }
 
@@ -35105,12 +35107,12 @@ _:patch
         this._next(value7);
       }
     };
-    Subscriber2.prototype.error = function(err) {
+    Subscriber2.prototype.error = function(err2) {
       if (this.isStopped) {
-        handleStoppedNotification(errorNotification(err), this);
+        handleStoppedNotification(errorNotification(err2), this);
       } else {
         this.isStopped = true;
-        this._error(err);
+        this._error(err2);
       }
     };
     Subscriber2.prototype.complete = function() {
@@ -35131,9 +35133,9 @@ _:patch
     Subscriber2.prototype._next = function(value7) {
       this.destination.next(value7);
     };
-    Subscriber2.prototype._error = function(err) {
+    Subscriber2.prototype._error = function(err2) {
       try {
-        this.destination.error(err);
+        this.destination.error(err2);
       } finally {
         this.unsubscribe();
       }
@@ -35165,16 +35167,16 @@ _:patch
         }
       }
     };
-    ConsumerObserver2.prototype.error = function(err) {
+    ConsumerObserver2.prototype.error = function(err2) {
       var partialObserver = this.partialObserver;
       if (partialObserver.error) {
         try {
-          partialObserver.error(err);
+          partialObserver.error(err2);
         } catch (error4) {
           handleUnhandledError(error4);
         }
       } else {
-        handleUnhandledError(err);
+        handleUnhandledError(err2);
       }
     };
     ConsumerObserver2.prototype.complete = function() {
@@ -35228,8 +35230,8 @@ _:patch
       reportUnhandledError(error4);
     }
   }
-  function defaultErrorHandler(err) {
-    throw err;
+  function defaultErrorHandler(err2) {
+    throw err2;
   }
   function handleStoppedNotification(notification2, subscriber3) {
     var onStoppedNotification = config.onStoppedNotification;
@@ -35294,8 +35296,8 @@ _:patch
     Observable2.prototype._trySubscribe = function(sink) {
       try {
         return this._subscribe(sink);
-      } catch (err) {
-        sink.error(err);
+      } catch (err2) {
+        sink.error(err2);
       }
     };
     Observable2.prototype.forEach = function(next4, promiseCtor) {
@@ -35306,8 +35308,8 @@ _:patch
           next: function(value7) {
             try {
               next4(value7);
-            } catch (err) {
-              reject(err);
+            } catch (err2) {
+              reject(err2);
               subscriber3.unsubscribe();
             }
           },
@@ -35338,8 +35340,8 @@ _:patch
         var value7;
         _this.subscribe(function(x) {
           return value7 = x;
-        }, function(err) {
-          return reject(err);
+        }, function(err2) {
+          return reject(err2);
         }, function() {
           return resolve(value7);
         });
@@ -35371,8 +35373,8 @@ _:patch
         return source8.lift(function(liftedSource) {
           try {
             return init(liftedSource, this);
-          } catch (err) {
-            this.error(err);
+          } catch (err2) {
+            this.error(err2);
           }
         });
       }
@@ -35393,15 +35395,15 @@ _:patch
       _this._next = onNext ? function(value7) {
         try {
           onNext(value7);
-        } catch (err) {
-          destination2.error(err);
+        } catch (err2) {
+          destination2.error(err2);
         }
       } : _super.prototype._next;
-      _this._error = onError ? function(err) {
+      _this._error = onError ? function(err2) {
         try {
-          onError(err);
-        } catch (err2) {
-          destination2.error(err2);
+          onError(err2);
+        } catch (err3) {
+          destination2.error(err3);
         } finally {
           this.unsubscribe();
         }
@@ -35409,8 +35411,8 @@ _:patch
       _this._complete = onComplete ? function() {
         try {
           onComplete();
-        } catch (err) {
-          destination2.error(err);
+        } catch (err2) {
+          destination2.error(err2);
         } finally {
           this.unsubscribe();
         }
@@ -35486,16 +35488,16 @@ _:patch
         }
       });
     };
-    Subject2.prototype.error = function(err) {
+    Subject2.prototype.error = function(err2) {
       var _this = this;
       errorContext(function() {
         _this._throwIfClosed();
         if (!_this.isStopped) {
           _this.hasError = _this.isStopped = true;
-          _this.thrownError = err;
+          _this.thrownError = err2;
           var observers = _this.observers;
           while (observers.length) {
-            observers.shift().error(err);
+            observers.shift().error(err2);
           }
         }
       });
@@ -35577,9 +35579,9 @@ _:patch
       var _a, _b;
       (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value7);
     };
-    AnonymousSubject2.prototype.error = function(err) {
+    AnonymousSubject2.prototype.error = function(err2) {
       var _a, _b;
-      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+      (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err2);
     };
     AnonymousSubject2.prototype.complete = function() {
       var _a, _b;
@@ -35642,11 +35644,11 @@ _:patch
         isUnsub = false;
         (_a2 = tapObserver.complete) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
         subscriber3.complete();
-      }, function(err) {
+      }, function(err2) {
         var _a2;
         isUnsub = false;
-        (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err);
-        subscriber3.error(err);
+        (_a2 = tapObserver.error) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver, err2);
+        subscriber3.error(err2);
       }, function() {
         var _a2, _b;
         if (isUnsub) {
@@ -35693,6 +35695,499 @@ _:patch
     }
   };
 
+  // src/problems/index.ts
+  function httpProblem(title10, response6) {
+    return {
+      type: "http",
+      title: title10,
+      status: response6.status,
+      detail: `The server responded with ${response6.status} ${response6.statusText}`
+    };
+  }
+  function networkProblem(title10, cause) {
+    return {
+      type: "network",
+      title: title10,
+      detail: `The server could not be reached: ${cause.message}`
+    };
+  }
+
+  // ../node_modules/neverthrow/dist/index.es.js
+  var defaultErrorConfig = {
+    withStackTrace: false
+  };
+  var createNeverThrowError = (message4, result6, config2 = defaultErrorConfig) => {
+    const data2 = result6.isOk() ? { type: "Ok", value: result6.value } : { type: "Err", value: result6.error };
+    const maybeStack = config2.withStackTrace ? new Error().stack : void 0;
+    return {
+      data: data2,
+      message: message4,
+      stack: maybeStack
+    };
+  };
+  function __awaiter(thisArg, _arguments, P, generator3) {
+    function adopt(value7) {
+      return value7 instanceof P ? value7 : new P(function(resolve) {
+        resolve(value7);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value7) {
+        try {
+          step4(generator3.next(value7));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value7) {
+        try {
+          step4(generator3["throw"](value7));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step4(result6) {
+        result6.done ? resolve(result6.value) : adopt(result6.value).then(fulfilled, rejected);
+      }
+      step4((generator3 = generator3.apply(thisArg, _arguments || [])).next());
+    });
+  }
+  function __values2(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+      next: function() {
+        if (o && i >= o.length) o = void 0;
+        return { value: o && o[i++], done: !o };
+      }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  function __await(v2) {
+    return this instanceof __await ? (this.v = v2, this) : new __await(v2);
+  }
+  function __asyncGenerator(thisArg, _arguments, generator3) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator3.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb2("next"), verb2("throw"), verb2("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i;
+    function awaitReturn(f) {
+      return function(v2) {
+        return Promise.resolve(v2).then(f, reject);
+      };
+    }
+    function verb2(n2, f) {
+      if (g[n2]) {
+        i[n2] = function(v2) {
+          return new Promise(function(a, b) {
+            q.push([n2, v2, a, b]) > 1 || resume(n2, v2);
+          });
+        };
+        if (f) i[n2] = f(i[n2]);
+      }
+    }
+    function resume(n2, v2) {
+      try {
+        step4(g[n2](v2));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
+    }
+    function step4(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value7) {
+      resume("next", value7);
+    }
+    function reject(value7) {
+      resume("throw", value7);
+    }
+    function settle(f, v2) {
+      if (f(v2), q.shift(), q.length) resume(q[0][0], q[0][1]);
+    }
+  }
+  function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb2("next"), verb2("throw", function(e) {
+      throw e;
+    }), verb2("return"), i[Symbol.iterator] = function() {
+      return this;
+    }, i;
+    function verb2(n2, f) {
+      i[n2] = o[n2] ? function(v2) {
+        return (p = !p) ? { value: __await(o[n2](v2)), done: false } : f ? f(v2) : v2;
+      } : f;
+    }
+  }
+  function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb2("next"), verb2("throw"), verb2("return"), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i);
+    function verb2(n2) {
+      i[n2] = o[n2] && function(v2) {
+        return new Promise(function(resolve, reject) {
+          v2 = o[n2](v2), settle(resolve, reject, v2.done, v2.value);
+        });
+      };
+    }
+    function settle(resolve, reject, d, v2) {
+      Promise.resolve(v2).then(function(v3) {
+        resolve({ value: v3, done: d });
+      }, reject);
+    }
+  }
+  var ResultAsync = class _ResultAsync {
+    constructor(res) {
+      this._promise = res;
+    }
+    static fromSafePromise(promise) {
+      const newPromise = promise.then((value7) => new Ok(value7));
+      return new _ResultAsync(newPromise);
+    }
+    static fromPromise(promise, errorFn) {
+      const newPromise = promise.then((value7) => new Ok(value7)).catch((e) => new Err(errorFn(e)));
+      return new _ResultAsync(newPromise);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static fromThrowable(fn2, errorFn) {
+      return (...args) => {
+        return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+          try {
+            return new Ok(yield fn2(...args));
+          } catch (error4) {
+            return new Err(errorFn ? errorFn(error4) : error4);
+          }
+        }))());
+      };
+    }
+    static combine(asyncResultList) {
+      return combineResultAsyncList(asyncResultList);
+    }
+    static combineWithAllErrors(asyncResultList) {
+      return combineResultAsyncListWithAllErrors(asyncResultList);
+    }
+    map(f) {
+      return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        return new Ok(yield f(res.value));
+      })));
+    }
+    andThrough(f) {
+      return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        const newRes = yield f(res.value);
+        if (newRes.isErr()) {
+          return new Err(newRes.error);
+        }
+        return new Ok(res.value);
+      })));
+    }
+    andTee(f) {
+      return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        try {
+          yield f(res.value);
+        } catch (e) {
+        }
+        return new Ok(res.value);
+      })));
+    }
+    orTee(f) {
+      return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+        if (res.isOk()) {
+          return new Ok(res.value);
+        }
+        try {
+          yield f(res.error);
+        } catch (e) {
+        }
+        return new Err(res.error);
+      })));
+    }
+    mapErr(f) {
+      return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+        if (res.isOk()) {
+          return new Ok(res.value);
+        }
+        return new Err(yield f(res.error));
+      })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    andThen(f) {
+      return new _ResultAsync(this._promise.then((res) => {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        const newValue = f(res.value);
+        return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+      }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    orElse(f) {
+      return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+        if (res.isErr()) {
+          return f(res.error);
+        }
+        return new Ok(res.value);
+      })));
+    }
+    match(ok2, _err) {
+      return this._promise.then((res) => res.match(ok2, _err));
+    }
+    unwrapOr(t) {
+      return this._promise.then((res) => res.unwrapOr(t));
+    }
+    /**
+     * @deprecated will be removed in 9.0.0.
+     *
+     * You can use `safeTry` without this method.
+     * @example
+     * ```typescript
+     * safeTry(async function* () {
+     *   const okValue = yield* yourResult
+     * })
+     * ```
+     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+     */
+    safeUnwrap() {
+      return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+        return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+      });
+    }
+    // Makes ResultAsync implement PromiseLike<Result>
+    then(successCallback, failureCallback) {
+      return this._promise.then(successCallback, failureCallback);
+    }
+    [Symbol.asyncIterator]() {
+      return __asyncGenerator(this, arguments, function* _a() {
+        const result6 = yield __await(this._promise);
+        if (result6.isErr()) {
+          yield yield __await(errAsync(result6.error));
+        }
+        return yield __await(result6.value);
+      });
+    }
+  };
+  function errAsync(err2) {
+    return new ResultAsync(Promise.resolve(new Err(err2)));
+  }
+  var fromPromise = ResultAsync.fromPromise;
+  var fromSafePromise = ResultAsync.fromSafePromise;
+  var fromAsyncThrowable = ResultAsync.fromThrowable;
+  var combineResultList = (resultList) => {
+    let acc = ok([]);
+    for (const result6 of resultList) {
+      if (result6.isErr()) {
+        acc = err(result6.error);
+        break;
+      } else {
+        acc.map((list) => list.push(result6.value));
+      }
+    }
+    return acc;
+  };
+  var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+  var combineResultListWithAllErrors = (resultList) => {
+    let acc = ok([]);
+    for (const result6 of resultList) {
+      if (result6.isErr() && acc.isErr()) {
+        acc.error.push(result6.error);
+      } else if (result6.isErr() && acc.isOk()) {
+        acc = err([result6.error]);
+      } else if (result6.isOk() && acc.isOk()) {
+        acc.value.push(result6.value);
+      }
+    }
+    return acc;
+  };
+  var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+  var Result;
+  (function(Result2) {
+    function fromThrowable2(fn2, errorFn) {
+      return (...args) => {
+        try {
+          const result6 = fn2(...args);
+          return ok(result6);
+        } catch (e) {
+          return err(errorFn ? errorFn(e) : e);
+        }
+      };
+    }
+    Result2.fromThrowable = fromThrowable2;
+    function combine(resultList) {
+      return combineResultList(resultList);
+    }
+    Result2.combine = combine;
+    function combineWithAllErrors(resultList) {
+      return combineResultListWithAllErrors(resultList);
+    }
+    Result2.combineWithAllErrors = combineWithAllErrors;
+  })(Result || (Result = {}));
+  function ok(value7) {
+    return new Ok(value7);
+  }
+  function err(err2) {
+    return new Err(err2);
+  }
+  var Ok = class {
+    constructor(value7) {
+      this.value = value7;
+    }
+    isOk() {
+      return true;
+    }
+    isErr() {
+      return !this.isOk();
+    }
+    map(f) {
+      return ok(f(this.value));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    mapErr(_f) {
+      return ok(this.value);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    andThen(f) {
+      return f(this.value);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    andThrough(f) {
+      return f(this.value).map((_value2) => this.value);
+    }
+    andTee(f) {
+      try {
+        f(this.value);
+      } catch (e) {
+      }
+      return ok(this.value);
+    }
+    orTee(_f) {
+      return ok(this.value);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    orElse(_f) {
+      return ok(this.value);
+    }
+    asyncAndThen(f) {
+      return f(this.value);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    asyncAndThrough(f) {
+      return f(this.value).map(() => this.value);
+    }
+    asyncMap(f) {
+      return ResultAsync.fromSafePromise(f(this.value));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    unwrapOr(_v) {
+      return this.value;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    match(ok2, _err) {
+      return ok2(this.value);
+    }
+    safeUnwrap() {
+      const value7 = this.value;
+      return (function* () {
+        return value7;
+      })();
+    }
+    _unsafeUnwrap(_) {
+      return this.value;
+    }
+    _unsafeUnwrapErr(config2) {
+      throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config2);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
+    *[Symbol.iterator]() {
+      return this.value;
+    }
+  };
+  var Err = class {
+    constructor(error4) {
+      this.error = error4;
+    }
+    isOk() {
+      return false;
+    }
+    isErr() {
+      return !this.isOk();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    map(_f) {
+      return err(this.error);
+    }
+    mapErr(f) {
+      return err(f(this.error));
+    }
+    andThrough(_f) {
+      return err(this.error);
+    }
+    andTee(_f) {
+      return err(this.error);
+    }
+    orTee(f) {
+      try {
+        f(this.error);
+      } catch (e) {
+      }
+      return err(this.error);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    andThen(_f) {
+      return err(this.error);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    orElse(f) {
+      return f(this.error);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    asyncAndThen(_f) {
+      return errAsync(this.error);
+    }
+    asyncAndThrough(_f) {
+      return errAsync(this.error);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    asyncMap(_f) {
+      return errAsync(this.error);
+    }
+    unwrapOr(v2) {
+      return v2;
+    }
+    match(_ok, err2) {
+      return err2(this.error);
+    }
+    safeUnwrap() {
+      const error4 = this.error;
+      return (function* () {
+        yield err(error4);
+        throw new Error("Do not use this generator out of `safeTry`");
+      })();
+    }
+    _unsafeUnwrap(config2) {
+      throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config2);
+    }
+    _unsafeUnwrapErr(_) {
+      return this.error;
+    }
+    *[Symbol.iterator]() {
+      const self2 = this;
+      yield self2;
+      return self2;
+    }
+  };
+  var fromThrowable = Result.fromThrowable;
+
   // src/files/FileFetcher.ts
   var FileFetcher = class {
     constructor(session4) {
@@ -35730,6 +36225,42 @@ _:patch
         body: newContent
       });
     }
+    createNewFile(container2, name9) {
+      const encodedName = encodeURIComponent(name9);
+      const url7 = container2.uri + encodedName;
+      const contentType4 = "text/turtle";
+      return ResultAsync.fromPromise(
+        this.session.authenticatedFetch(url7, {
+          method: "PUT",
+          headers: {
+            "Content-Type": contentType4,
+            "If-None-Match": "*"
+          }
+        }),
+        (e) => networkProblem("The file could not be created", e)
+      ).andThen(
+        (response6) => response6.ok ? ok({
+          url: url7,
+          name: name9,
+          contentType: contentType4
+        }) : err(httpProblem("The file could not be created", response6))
+      );
+    }
+    createNewFolder(container2, name9) {
+      const encodedName = encodeURIComponent(name9);
+      const url7 = container2.uri + encodedName + "/";
+      return ResultAsync.fromPromise(
+        this.session.authenticatedFetch(url7, {
+          method: "PUT"
+        }),
+        (e) => networkProblem("The folder could not be created", e)
+      ).andThen(
+        (response6) => response6.ok ? ok({
+          url: url7,
+          name: name9
+        }) : err(httpProblem("The folder could not be created", response6))
+      );
+    }
   };
 
   // src/modules/contacts.ts
@@ -35785,7 +36316,8 @@ _:patch
     if (isTooGeneric(url7.hash)) {
       return (getFilename(url7) || url7.host + url7.pathname) + url7.hash;
     }
-    return labelFromFragment(url7.hash) || getFilename(url7) || url7.host;
+    const name9 = labelFromFragment(url7.hash) || getFilename(url7) || url7.host;
+    return name9.endsWith("/") ? name9.slice(0, -1) : name9;
   }
   function labelFromFragment(fragment) {
     return fragment ? fragment.split("#")[1] : null;
@@ -35797,9 +36329,10 @@ _:patch
   function getFilename(url7) {
     if (url7.pathname.endsWith("/")) {
       const containerName = url7.pathname.split("/").at(-2);
-      return containerName ? containerName + "/" : null;
+      return containerName ? decodeURIComponent(containerName) + "/" : null;
     } else {
-      return url7.pathname.split("/").pop();
+      const name9 = url7.pathname.split("/").pop();
+      return name9 ? decodeURIComponent(name9) : null;
     }
   }
 
@@ -57793,10 +58326,7 @@ _:patch
       );
       return contains3.map((content5) => ({
         uri: content5.object.value,
-        name: content5.object.value.replace(
-          new RegExp(`${this.uri}([^/]*)/?`),
-          "$1"
-        )
+        name: labelFromUri(content5.object.value)
       }));
     }
   };