@pod-os/core 0.20.1-rc.e23505f.0 → 0.20.1-rc.f98c05a.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,499 @@ 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;
+
 // src/files/FileFetcher.ts
 var FileFetcher = class {
   constructor(session4) {
@@ -2768,6 +3261,42 @@ var FileFetcher = class {
       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
@@ -2816,7 +3345,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 +3358,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 +25340,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 +25486,10 @@ export {
   Thing,
   UriService,
   WebIdProfile,
+  httpProblem,
   labelFromUri,
-  listKnownTerms
+  listKnownTerms,
+  networkProblem
 };
 /*! Bundled license information: