@pod-os/core 0.20.1-rc.4df0acf.0 → 0.20.1-rc.b417220.0

package/dist/index.js

@@ -1878,8 +1878,8 @@ function createErrorClass(createImpl) {
 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;
@@ -1945,12 +1945,12 @@ var Subscription = (function() {
             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);
               }
             }
           }
@@ -2057,13 +2057,13 @@ var timeoutProvider = {
 };
 
 // ../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;
     }
   });
 }
@@ -2110,10 +2110,10 @@ function errorContext(cb) {
     cb();
   }
 }
-function captureError(err) {
+function captureError(err2) {
   if (config.useDeprecatedSynchronousErrorHandling && context) {
     context.errorThrown = true;
-    context.error = err;
+    context.error = err2;
   }
 }
 
@@ -2143,12 +2143,12 @@ var Subscriber = (function(_super) {
       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() {
@@ -2169,9 +2169,9 @@ var Subscriber = (function(_super) {
   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();
     }
@@ -2203,16 +2203,16 @@ var ConsumerObserver = (function() {
       }
     }
   };
-  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() {
@@ -2266,8 +2266,8 @@ function handleUnhandledError(error4) {
     reportUnhandledError(error4);
   }
 }
-function defaultErrorHandler(err) {
-  throw err;
+function defaultErrorHandler(err2) {
+  throw err2;
 }
 function handleStoppedNotification(notification2, subscriber3) {
   var onStoppedNotification = config.onStoppedNotification;
@@ -2332,8 +2332,8 @@ var Observable = (function() {
   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) {
@@ -2344,8 +2344,8 @@ var Observable = (function() {
         next: function(value7) {
           try {
             next4(value7);
-          } catch (err) {
-            reject(err);
+          } catch (err2) {
+            reject(err2);
             subscriber3.unsubscribe();
           }
         },
@@ -2376,8 +2376,8 @@ var Observable = (function() {
       var value7;
       _this.subscribe(function(x) {
         return value7 = x;
-      }, function(err) {
-        return reject(err);
+      }, function(err2) {
+        return reject(err2);
       }, function() {
         return resolve(value7);
       });
@@ -2409,8 +2409,8 @@ function operate(init) {
       return source8.lift(function(liftedSource) {
         try {
           return init(liftedSource, this);
-        } catch (err) {
-          this.error(err);
+        } catch (err2) {
+          this.error(err2);
         }
       });
     }
@@ -2431,15 +2431,15 @@ var OperatorSubscriber = (function(_super) {
     _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();
       }
@@ -2447,8 +2447,8 @@ var OperatorSubscriber = (function(_super) {
     _this._complete = onComplete ? function() {
       try {
         onComplete();
-      } catch (err) {
-        destination2.error(err);
+      } catch (err2) {
+        destination2.error(err2);
       } finally {
         this.unsubscribe();
       }
@@ -2524,16 +2524,16 @@ var Subject = (function(_super) {
       }
     });
   };
-  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);
         }
       }
     });
@@ -2615,9 +2615,9 @@ var AnonymousSubject = (function(_super) {
     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;
@@ -2680,11 +2680,11 @@ function tap(observerOrNext, error4, complete2) {
       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) {
@@ -2731,6 +2731,958 @@ var HttpStatus = class {
   }
 };
 
+// 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 self = this;
+    yield self;
+    return self;
+  }
+};
+var fromThrowable = Result.fromThrowable;
+
+// ../node_modules/mime/dist/types/standard.js
+var types = {
+  "application/andrew-inset": ["ez"],
+  "application/appinstaller": ["appinstaller"],
+  "application/applixware": ["aw"],
+  "application/appx": ["appx"],
+  "application/appxbundle": ["appxbundle"],
+  "application/atom+xml": ["atom"],
+  "application/atomcat+xml": ["atomcat"],
+  "application/atomdeleted+xml": ["atomdeleted"],
+  "application/atomsvc+xml": ["atomsvc"],
+  "application/atsc-dwd+xml": ["dwd"],
+  "application/atsc-held+xml": ["held"],
+  "application/atsc-rsat+xml": ["rsat"],
+  "application/automationml-aml+xml": ["aml"],
+  "application/automationml-amlx+zip": ["amlx"],
+  "application/bdoc": ["bdoc"],
+  "application/calendar+xml": ["xcs"],
+  "application/ccxml+xml": ["ccxml"],
+  "application/cdfx+xml": ["cdfx"],
+  "application/cdmi-capability": ["cdmia"],
+  "application/cdmi-container": ["cdmic"],
+  "application/cdmi-domain": ["cdmid"],
+  "application/cdmi-object": ["cdmio"],
+  "application/cdmi-queue": ["cdmiq"],
+  "application/cpl+xml": ["cpl"],
+  "application/cu-seeme": ["cu"],
+  "application/cwl": ["cwl"],
+  "application/dash+xml": ["mpd"],
+  "application/dash-patch+xml": ["mpp"],
+  "application/davmount+xml": ["davmount"],
+  "application/dicom": ["dcm"],
+  "application/docbook+xml": ["dbk"],
+  "application/dssc+der": ["dssc"],
+  "application/dssc+xml": ["xdssc"],
+  "application/ecmascript": ["ecma"],
+  "application/emma+xml": ["emma"],
+  "application/emotionml+xml": ["emotionml"],
+  "application/epub+zip": ["epub"],
+  "application/exi": ["exi"],
+  "application/express": ["exp"],
+  "application/fdf": ["fdf"],
+  "application/fdt+xml": ["fdt"],
+  "application/font-tdpfr": ["pfr"],
+  "application/geo+json": ["geojson"],
+  "application/gml+xml": ["gml"],
+  "application/gpx+xml": ["gpx"],
+  "application/gxf": ["gxf"],
+  "application/gzip": ["gz"],
+  "application/hjson": ["hjson"],
+  "application/hyperstudio": ["stk"],
+  "application/inkml+xml": ["ink", "inkml"],
+  "application/ipfix": ["ipfix"],
+  "application/its+xml": ["its"],
+  "application/java-archive": ["jar", "war", "ear"],
+  "application/java-serialized-object": ["ser"],
+  "application/java-vm": ["class"],
+  "application/javascript": ["*js"],
+  "application/json": ["json", "map"],
+  "application/json5": ["json5"],
+  "application/jsonml+json": ["jsonml"],
+  "application/ld+json": ["jsonld"],
+  "application/lgr+xml": ["lgr"],
+  "application/lost+xml": ["lostxml"],
+  "application/mac-binhex40": ["hqx"],
+  "application/mac-compactpro": ["cpt"],
+  "application/mads+xml": ["mads"],
+  "application/manifest+json": ["webmanifest"],
+  "application/marc": ["mrc"],
+  "application/marcxml+xml": ["mrcx"],
+  "application/mathematica": ["ma", "nb", "mb"],
+  "application/mathml+xml": ["mathml"],
+  "application/mbox": ["mbox"],
+  "application/media-policy-dataset+xml": ["mpf"],
+  "application/mediaservercontrol+xml": ["mscml"],
+  "application/metalink+xml": ["metalink"],
+  "application/metalink4+xml": ["meta4"],
+  "application/mets+xml": ["mets"],
+  "application/mmt-aei+xml": ["maei"],
+  "application/mmt-usd+xml": ["musd"],
+  "application/mods+xml": ["mods"],
+  "application/mp21": ["m21", "mp21"],
+  "application/mp4": ["*mp4", "*mpg4", "mp4s", "m4p"],
+  "application/msix": ["msix"],
+  "application/msixbundle": ["msixbundle"],
+  "application/msword": ["doc", "dot"],
+  "application/mxf": ["mxf"],
+  "application/n-quads": ["nq"],
+  "application/n-triples": ["nt"],
+  "application/node": ["cjs"],
+  "application/octet-stream": [
+    "bin",
+    "dms",
+    "lrf",
+    "mar",
+    "so",
+    "dist",
+    "distz",
+    "pkg",
+    "bpk",
+    "dump",
+    "elc",
+    "deploy",
+    "exe",
+    "dll",
+    "deb",
+    "dmg",
+    "iso",
+    "img",
+    "msi",
+    "msp",
+    "msm",
+    "buffer"
+  ],
+  "application/oda": ["oda"],
+  "application/oebps-package+xml": ["opf"],
+  "application/ogg": ["ogx"],
+  "application/omdoc+xml": ["omdoc"],
+  "application/onenote": [
+    "onetoc",
+    "onetoc2",
+    "onetmp",
+    "onepkg",
+    "one",
+    "onea"
+  ],
+  "application/oxps": ["oxps"],
+  "application/p2p-overlay+xml": ["relo"],
+  "application/patch-ops-error+xml": ["xer"],
+  "application/pdf": ["pdf"],
+  "application/pgp-encrypted": ["pgp"],
+  "application/pgp-keys": ["asc"],
+  "application/pgp-signature": ["sig", "*asc"],
+  "application/pics-rules": ["prf"],
+  "application/pkcs10": ["p10"],
+  "application/pkcs7-mime": ["p7m", "p7c"],
+  "application/pkcs7-signature": ["p7s"],
+  "application/pkcs8": ["p8"],
+  "application/pkix-attr-cert": ["ac"],
+  "application/pkix-cert": ["cer"],
+  "application/pkix-crl": ["crl"],
+  "application/pkix-pkipath": ["pkipath"],
+  "application/pkixcmp": ["pki"],
+  "application/pls+xml": ["pls"],
+  "application/postscript": ["ai", "eps", "ps"],
+  "application/provenance+xml": ["provx"],
+  "application/pskc+xml": ["pskcxml"],
+  "application/raml+yaml": ["raml"],
+  "application/rdf+xml": ["rdf", "owl"],
+  "application/reginfo+xml": ["rif"],
+  "application/relax-ng-compact-syntax": ["rnc"],
+  "application/resource-lists+xml": ["rl"],
+  "application/resource-lists-diff+xml": ["rld"],
+  "application/rls-services+xml": ["rs"],
+  "application/route-apd+xml": ["rapd"],
+  "application/route-s-tsid+xml": ["sls"],
+  "application/route-usd+xml": ["rusd"],
+  "application/rpki-ghostbusters": ["gbr"],
+  "application/rpki-manifest": ["mft"],
+  "application/rpki-roa": ["roa"],
+  "application/rsd+xml": ["rsd"],
+  "application/rss+xml": ["rss"],
+  "application/rtf": ["rtf"],
+  "application/sbml+xml": ["sbml"],
+  "application/scvp-cv-request": ["scq"],
+  "application/scvp-cv-response": ["scs"],
+  "application/scvp-vp-request": ["spq"],
+  "application/scvp-vp-response": ["spp"],
+  "application/sdp": ["sdp"],
+  "application/senml+xml": ["senmlx"],
+  "application/sensml+xml": ["sensmlx"],
+  "application/set-payment-initiation": ["setpay"],
+  "application/set-registration-initiation": ["setreg"],
+  "application/shf+xml": ["shf"],
+  "application/sieve": ["siv", "sieve"],
+  "application/smil+xml": ["smi", "smil"],
+  "application/sparql-query": ["rq"],
+  "application/sparql-results+xml": ["srx"],
+  "application/sql": ["sql"],
+  "application/srgs": ["gram"],
+  "application/srgs+xml": ["grxml"],
+  "application/sru+xml": ["sru"],
+  "application/ssdl+xml": ["ssdl"],
+  "application/ssml+xml": ["ssml"],
+  "application/swid+xml": ["swidtag"],
+  "application/tei+xml": ["tei", "teicorpus"],
+  "application/thraud+xml": ["tfi"],
+  "application/timestamped-data": ["tsd"],
+  "application/toml": ["toml"],
+  "application/trig": ["trig"],
+  "application/ttml+xml": ["ttml"],
+  "application/ubjson": ["ubj"],
+  "application/urc-ressheet+xml": ["rsheet"],
+  "application/urc-targetdesc+xml": ["td"],
+  "application/voicexml+xml": ["vxml"],
+  "application/wasm": ["wasm"],
+  "application/watcherinfo+xml": ["wif"],
+  "application/widget": ["wgt"],
+  "application/winhlp": ["hlp"],
+  "application/wsdl+xml": ["wsdl"],
+  "application/wspolicy+xml": ["wspolicy"],
+  "application/xaml+xml": ["xaml"],
+  "application/xcap-att+xml": ["xav"],
+  "application/xcap-caps+xml": ["xca"],
+  "application/xcap-diff+xml": ["xdf"],
+  "application/xcap-el+xml": ["xel"],
+  "application/xcap-ns+xml": ["xns"],
+  "application/xenc+xml": ["xenc"],
+  "application/xfdf": ["xfdf"],
+  "application/xhtml+xml": ["xhtml", "xht"],
+  "application/xliff+xml": ["xlf"],
+  "application/xml": ["xml", "xsl", "xsd", "rng"],
+  "application/xml-dtd": ["dtd"],
+  "application/xop+xml": ["xop"],
+  "application/xproc+xml": ["xpl"],
+  "application/xslt+xml": ["*xsl", "xslt"],
+  "application/xspf+xml": ["xspf"],
+  "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"],
+  "application/yang": ["yang"],
+  "application/yin+xml": ["yin"],
+  "application/zip": ["zip"],
+  "application/zip+dotlottie": ["lottie"],
+  "audio/3gpp": ["*3gpp"],
+  "audio/aac": ["adts", "aac"],
+  "audio/adpcm": ["adp"],
+  "audio/amr": ["amr"],
+  "audio/basic": ["au", "snd"],
+  "audio/midi": ["mid", "midi", "kar", "rmi"],
+  "audio/mobile-xmf": ["mxmf"],
+  "audio/mp3": ["*mp3"],
+  "audio/mp4": ["m4a", "mp4a", "m4b"],
+  "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"],
+  "audio/ogg": ["oga", "ogg", "spx", "opus"],
+  "audio/s3m": ["s3m"],
+  "audio/silk": ["sil"],
+  "audio/wav": ["wav"],
+  "audio/wave": ["*wav"],
+  "audio/webm": ["weba"],
+  "audio/xm": ["xm"],
+  "font/collection": ["ttc"],
+  "font/otf": ["otf"],
+  "font/ttf": ["ttf"],
+  "font/woff": ["woff"],
+  "font/woff2": ["woff2"],
+  "image/aces": ["exr"],
+  "image/apng": ["apng"],
+  "image/avci": ["avci"],
+  "image/avcs": ["avcs"],
+  "image/avif": ["avif"],
+  "image/bmp": ["bmp", "dib"],
+  "image/cgm": ["cgm"],
+  "image/dicom-rle": ["drle"],
+  "image/dpx": ["dpx"],
+  "image/emf": ["emf"],
+  "image/fits": ["fits"],
+  "image/g3fax": ["g3"],
+  "image/gif": ["gif"],
+  "image/heic": ["heic"],
+  "image/heic-sequence": ["heics"],
+  "image/heif": ["heif"],
+  "image/heif-sequence": ["heifs"],
+  "image/hej2k": ["hej2"],
+  "image/ief": ["ief"],
+  "image/jaii": ["jaii"],
+  "image/jais": ["jais"],
+  "image/jls": ["jls"],
+  "image/jp2": ["jp2", "jpg2"],
+  "image/jpeg": ["jpg", "jpeg", "jpe"],
+  "image/jph": ["jph"],
+  "image/jphc": ["jhc"],
+  "image/jpm": ["jpm", "jpgm"],
+  "image/jpx": ["jpx", "jpf"],
+  "image/jxl": ["jxl"],
+  "image/jxr": ["jxr"],
+  "image/jxra": ["jxra"],
+  "image/jxrs": ["jxrs"],
+  "image/jxs": ["jxs"],
+  "image/jxsc": ["jxsc"],
+  "image/jxsi": ["jxsi"],
+  "image/jxss": ["jxss"],
+  "image/ktx": ["ktx"],
+  "image/ktx2": ["ktx2"],
+  "image/pjpeg": ["jfif"],
+  "image/png": ["png"],
+  "image/sgi": ["sgi"],
+  "image/svg+xml": ["svg", "svgz"],
+  "image/t38": ["t38"],
+  "image/tiff": ["tif", "tiff"],
+  "image/tiff-fx": ["tfx"],
+  "image/webp": ["webp"],
+  "image/wmf": ["wmf"],
+  "message/disposition-notification": ["disposition-notification"],
+  "message/global": ["u8msg"],
+  "message/global-delivery-status": ["u8dsn"],
+  "message/global-disposition-notification": ["u8mdn"],
+  "message/global-headers": ["u8hdr"],
+  "message/rfc822": ["eml", "mime", "mht", "mhtml"],
+  "model/3mf": ["3mf"],
+  "model/gltf+json": ["gltf"],
+  "model/gltf-binary": ["glb"],
+  "model/iges": ["igs", "iges"],
+  "model/jt": ["jt"],
+  "model/mesh": ["msh", "mesh", "silo"],
+  "model/mtl": ["mtl"],
+  "model/obj": ["obj"],
+  "model/prc": ["prc"],
+  "model/step": ["step", "stp", "stpnc", "p21", "210"],
+  "model/step+xml": ["stpx"],
+  "model/step+zip": ["stpz"],
+  "model/step-xml+zip": ["stpxz"],
+  "model/stl": ["stl"],
+  "model/u3d": ["u3d"],
+  "model/vrml": ["wrl", "vrml"],
+  "model/x3d+binary": ["*x3db", "x3dbz"],
+  "model/x3d+fastinfoset": ["x3db"],
+  "model/x3d+vrml": ["*x3dv", "x3dvz"],
+  "model/x3d+xml": ["x3d", "x3dz"],
+  "model/x3d-vrml": ["x3dv"],
+  "text/cache-manifest": ["appcache", "manifest"],
+  "text/calendar": ["ics", "ifb"],
+  "text/coffeescript": ["coffee", "litcoffee"],
+  "text/css": ["css"],
+  "text/csv": ["csv"],
+  "text/html": ["html", "htm", "shtml"],
+  "text/jade": ["jade"],
+  "text/javascript": ["js", "mjs"],
+  "text/jsx": ["jsx"],
+  "text/less": ["less"],
+  "text/markdown": ["md", "markdown"],
+  "text/mathml": ["mml"],
+  "text/mdx": ["mdx"],
+  "text/n3": ["n3"],
+  "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"],
+  "text/richtext": ["rtx"],
+  "text/rtf": ["*rtf"],
+  "text/sgml": ["sgml", "sgm"],
+  "text/shex": ["shex"],
+  "text/slim": ["slim", "slm"],
+  "text/spdx": ["spdx"],
+  "text/stylus": ["stylus", "styl"],
+  "text/tab-separated-values": ["tsv"],
+  "text/troff": ["t", "tr", "roff", "man", "me", "ms"],
+  "text/turtle": ["ttl"],
+  "text/uri-list": ["uri", "uris", "urls"],
+  "text/vcard": ["vcard"],
+  "text/vtt": ["vtt"],
+  "text/wgsl": ["wgsl"],
+  "text/xml": ["*xml"],
+  "text/yaml": ["yaml", "yml"],
+  "video/3gpp": ["3gp", "3gpp"],
+  "video/3gpp2": ["3g2"],
+  "video/h261": ["h261"],
+  "video/h263": ["h263"],
+  "video/h264": ["h264"],
+  "video/iso.segment": ["m4s"],
+  "video/jpeg": ["jpgv"],
+  "video/jpm": ["*jpm", "*jpgm"],
+  "video/mj2": ["mj2", "mjp2"],
+  "video/mp2t": ["ts", "m2t", "m2ts", "mts"],
+  "video/mp4": ["mp4", "mp4v", "mpg4"],
+  "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"],
+  "video/ogg": ["ogv"],
+  "video/quicktime": ["qt", "mov"],
+  "video/webm": ["webm"]
+};
+Object.freeze(types);
+var standard_default = types;
+
+// ../node_modules/mime/dist/src/Mime.js
+var __classPrivateFieldGet = function(receiver2, state2, kind2, f) {
+  if (kind2 === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state2 === "function" ? receiver2 !== state2 || !f : !state2.has(receiver2)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind2 === "m" ? f : kind2 === "a" ? f.call(receiver2) : f ? f.value : state2.get(receiver2);
+};
+var _Mime_extensionToType;
+var _Mime_typeToExtension;
+var _Mime_typeToExtensions;
+var Mime = class {
+  constructor(...args) {
+    _Mime_extensionToType.set(this, /* @__PURE__ */ new Map());
+    _Mime_typeToExtension.set(this, /* @__PURE__ */ new Map());
+    _Mime_typeToExtensions.set(this, /* @__PURE__ */ new Map());
+    for (const arg2 of args) {
+      this.define(arg2);
+    }
+  }
+  define(typeMap, force = false) {
+    for (let [type5, extensions] of Object.entries(typeMap)) {
+      type5 = type5.toLowerCase();
+      extensions = extensions.map((ext) => ext.toLowerCase());
+      if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type5)) {
+        __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type5, /* @__PURE__ */ new Set());
+      }
+      const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type5);
+      let first4 = true;
+      for (let extension3 of extensions) {
+        const starred = extension3.startsWith("*");
+        extension3 = starred ? extension3.slice(1) : extension3;
+        allExtensions?.add(extension3);
+        if (first4) {
+          __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type5, extension3);
+        }
+        first4 = false;
+        if (starred)
+          continue;
+        const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension3);
+        if (currentType && currentType != type5 && !force) {
+          throw new Error(`"${type5} -> ${extension3}" conflicts with "${currentType} -> ${extension3}". Pass \`force=true\` to override this definition.`);
+        }
+        __classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension3, type5);
+      }
+    }
+    return this;
+  }
+  getType(path3) {
+    if (typeof path3 !== "string")
+      return null;
+    const last3 = path3.replace(/^.*[/\\]/s, "").toLowerCase();
+    const ext = last3.replace(/^.*\./s, "").toLowerCase();
+    const hasPath = last3.length < path3.length;
+    const hasDot = ext.length < last3.length - 1;
+    if (!hasDot && hasPath)
+      return null;
+    return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
+  }
+  getExtension(type5) {
+    if (typeof type5 !== "string")
+      return null;
+    type5 = type5?.split?.(";")[0];
+    return (type5 && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type5.trim().toLowerCase())) ?? null;
+  }
+  getAllExtensions(type5) {
+    if (typeof type5 !== "string")
+      return null;
+    return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type5.toLowerCase()) ?? null;
+  }
+  _freeze() {
+    this.define = () => {
+      throw new Error("define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances");
+    };
+    Object.freeze(this);
+    for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) {
+      Object.freeze(extensions);
+    }
+    return this;
+  }
+  _getTestState() {
+    return {
+      types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
+      extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f")
+    };
+  }
+};
+_Mime_extensionToType = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtension = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtensions = /* @__PURE__ */ new WeakMap();
+var Mime_default = Mime;
+
+// ../node_modules/mime/dist/src/index_lite.js
+var index_lite_default = new Mime_default(standard_default)._freeze();
+
 // src/files/FileFetcher.ts
 var FileFetcher = class {
   constructor(session4) {
@@ -2768,6 +3720,42 @@ var FileFetcher = class {
       body: newContent
     });
   }
+  createNewFile(container2, name9) {
+    const encodedName = encodeURIComponent(name9);
+    const url7 = container2.uri + encodedName;
+    const contentTypeHeader = index_lite_default.getType(encodedName) ?? "text/turtle";
+    return ResultAsync.fromPromise(
+      this.session.authenticatedFetch(url7, {
+        method: "PUT",
+        headers: {
+          "Content-Type": contentTypeHeader,
+          "If-None-Match": "*"
+        }
+      }),
+      (e) => networkProblem("The file could not be created", e)
+    ).andThen(
+      (response6) => response6.ok ? ok({
+        url: url7,
+        name: name9,
+        contentType: contentTypeHeader
+      }) : 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
@@ -2816,7 +3804,8 @@ function labelFromUri(uri6) {
   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;
@@ -2828,9 +3817,10 @@ function isTooGeneric(fragment) {
 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;
   }
 }
 
@@ -24809,10 +25799,7 @@ var LdpContainer = class extends Thing {
     );
     return contains3.map((content5) => ({
       uri: content5.object.value,
-      name: content5.object.value.replace(
-        new RegExp(`${this.uri}([^/]*)/?`),
-        "$1"
-      )
+      name: labelFromUri(content5.object.value)
     }));
   }
 };
@@ -24958,8 +25945,10 @@ export {
   Thing,
   UriService,
   WebIdProfile,
+  httpProblem,
   labelFromUri,
-  listKnownTerms
+  listKnownTerms,
+  networkProblem
 };
 /*! Bundled license information: