@esposter/shared 2.22.0 → 2.24.0

package/dist/index.js

@@ -27,6 +27,9 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
+//#region src/util/function/noop.ts
+const noop = () => {};
+//#endregion
 //#region src/test/constants.ts
 const AllSpecialValues = [
 	{
@@ -67,11 +70,11 @@ const AllSpecialValues = [
 	},
 	{
 		isPlainObject: false,
-		value: () => {}
+		value: noop
 	},
 	{
 		isPlainObject: false,
-		value: /* @__PURE__ */ new RegExp("")
+		value: /(?:)/u
 	}
 ];
 //#endregion
@@ -122,6 +125,8 @@ const RoutePath = {
 	Achievements: "/achievements",
 	Anime: "/anime",
 	Calendar: "/calendar",
+	Calls: (id) => `/calls/${id}`,
+	CallsIndex: "/calls",
 	Clicker: "/clicker",
 	Dashboard: "/dashboard",
 	DashboardEditor: "/dashboard/editor",
@@ -180,9 +185,9 @@ let Operation = /* @__PURE__ */ function(Operation) {
 	return Operation;
 }({});
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+shared@3.5.33/node_modules/@vue/shared/dist/shared.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.34/node_modules/@vue/shared/dist/shared.esm-bundler.js
 /**
-* @vue/shared v3.5.33
+* @vue/shared v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -195,7 +200,6 @@ function makeMap(str) {
 const EMPTY_OBJ = Object.freeze({});
 Object.freeze([]);
 const NOOP = () => {};
-const NO = () => false;
 const extend = Object.assign;
 const remove = (arr, el) => {
 	const i = arr.indexOf(el);
@@ -226,18 +230,9 @@ const cacheStringFunction$1 = (fn) => {
 		return cache[str] || (cache[str] = fn(str));
 	});
 };
-const camelizeRE$1 = /-\w/g;
-cacheStringFunction$1((str) => {
-	return str.replace(camelizeRE$1, (c) => c.slice(1).toUpperCase());
-});
-const hyphenateRE$1 = /\B([A-Z])/g;
-cacheStringFunction$1((str) => str.replace(hyphenateRE$1, "-$1").toLowerCase());
 const capitalize$1 = cacheStringFunction$1((str) => {
 	return str.charAt(0).toUpperCase() + str.slice(1);
 });
-const toHandlerKey = cacheStringFunction$1((str) => {
-	return str ? `on${capitalize$1(str)}` : ``;
-});
 const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
 const def = (obj, key, value, writable = false) => {
 	Object.defineProperty(obj, key, {
@@ -252,9 +247,9 @@ const getGlobalThis = () => {
 	return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.33/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.34/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
 /**
-* @vue/reactivity v3.5.33
+* @vue/reactivity v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -1354,9 +1349,9 @@ function traverse(value, depth = Infinity, seen) {
 	return value;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.33/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.34/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
 /**
-* @vue/runtime-core v3.5.33
+* @vue/runtime-core v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -1828,34 +1823,6 @@ function createPathGetter(ctx, path) {
 }
 getGlobalThis().requestIdleCallback;
 getGlobalThis().cancelIdleCallback;
-function injectHook(type, hook, target = currentInstance, prepend = false) {
-	if (target) {
-		const hooks = target[type] || (target[type] = []);
-		const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-			pauseTracking();
-			const reset = setCurrentInstance(target);
-			const res = callWithAsyncErrorHandling(hook, target, type, args);
-			reset();
-			resetTracking();
-			return res;
-		});
-		if (prepend) hooks.unshift(wrappedHook);
-		else hooks.push(wrappedHook);
-		return wrappedHook;
-	} else warn$1(`${toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""))} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
-}
-const createHook = (lifecycle) => (hook, target = currentInstance) => {
-	if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
-};
-createHook("bm");
-createHook("m");
-createHook("bu");
-createHook("u");
-createHook("bum");
-createHook("um");
-createHook("sp");
-createHook("rtg");
-createHook("rtc");
 const getPublicInstance = (i) => {
 	if (!i) return null;
 	if (isStatefulComponent(i)) return getComponentPublicInstance(i);
@@ -1911,10 +1878,8 @@ const PublicInstanceProxyHandlers = {
 		const publicGetter = publicPropertiesMap[key];
 		let cssModule, globalProperties;
 		if (publicGetter) {
-			if (key === "$attrs") {
-				track(instance.attrs, "get", "");
-				markAttrsAccessed();
-			} else if (key === "$slots") track(instance, "get", key);
+			if (key === "$attrs") track(instance.attrs, "get", "");
+			else if (key === "$slots") track(instance, "get", key);
 			return publicGetter(instance);
 		} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
 		else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
@@ -2056,36 +2021,13 @@ function mergeWatchOptions(to, from) {
 	for (const key in from) merged[key] = mergeAsArray(to[key], from[key]);
 	return merged;
 }
-function createAppContext() {
-	return {
-		app: null,
-		config: {
-			isNativeTag: NO,
-			performance: false,
-			globalProperties: {},
-			optionMergeStrategies: {},
-			errorHandler: void 0,
-			warnHandler: void 0,
-			compilerOptions: {}
-		},
-		mixins: [],
-		components: {},
-		directives: {},
-		provides: /* @__PURE__ */ Object.create(null),
-		optionsCache: /* @__PURE__ */ new WeakMap(),
-		propsCache: /* @__PURE__ */ new WeakMap(),
-		emitsCache: /* @__PURE__ */ new WeakMap()
-	};
-}
 let currentApp = null;
-function markAttrsAccessed() {}
 const queuePostRenderEffect = queueEffectWithSuspense;
 function queueEffectWithSuspense(fn, suspense) {
 	if (suspense && suspense.pendingBranch) if (isArray(fn)) suspense.effects.push(...fn);
 	else suspense.effects.push(fn);
 	else queuePostFlushCb(fn);
 }
-createAppContext();
 let currentInstance = null;
 const getCurrentInstance = () => currentInstance || currentRenderingInstance;
 let internalSetCurrentInstance;
@@ -2313,9 +2255,9 @@ function initCustomFormatter() {
 	else window.devtoolsFormatters = [formatter];
 }
 //#endregion
-//#region ../../node_modules/.pnpm/vue@3.5.33_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+//#region ../../node_modules/.pnpm/vue@3.5.34_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
 /**
-* vue v3.5.33
+* vue v3.5.34
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -2329,18 +2271,6 @@ const getRawData = (data) => /* @__PURE__ */ isReactive(data) ? /* @__PURE__ */
 typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
 const toString = Object.prototype.toString;
 const isObject = (val) => toString.call(val) === "[object Object]";
-function cacheStringFunction(fn) {
-	const cache = Object.create(null);
-	return ((str) => {
-		return cache[str] || (cache[str] = fn(str));
-	});
-}
-const hyphenateRE = /\B([A-Z])/g;
-cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-const camelizeRE = /-(\w)/g;
-cacheStringFunction((str) => {
-	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-});
 //#endregion
 //#region src/util/reactivity/toRawDeep.ts
 const toRawDeep = (data) => {
@@ -2360,6 +2290,507 @@ var Serializable = class {
 	}
 };
 //#endregion
+//#region src/services/error/toAppError.ts
+const toAppError = (error) => {
+	if (error instanceof Error) return error;
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return new Error(error.message, { cause: error });
+	return new Error(String(error), { cause: error });
+};
+//#endregion
+//#region ../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
+const defaultErrorConfig = { withStackTrace: false };
+const createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+	return {
+		data: result.isOk() ? {
+			type: "Ok",
+			value: result.value
+		} : {
+			type: "Err",
+			value: result.error
+		},
+		message,
+		stack: config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0
+	};
+};
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+function __awaiter(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+}
+function __values(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(v) {
+	return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+	if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+	var g = generator.apply(thisArg, _arguments || []), i, q = [];
+	return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i;
+	function awaitReturn(f) {
+		return function(v) {
+			return Promise.resolve(v).then(f, reject);
+		};
+	}
+	function verb(n, f) {
+		if (g[n]) {
+			i[n] = function(v) {
+				return new Promise(function(a, b) {
+					q.push([
+						n,
+						v,
+						a,
+						b
+					]) > 1 || resume(n, v);
+				});
+			};
+			if (f) i[n] = f(i[n]);
+		}
+	}
+	function resume(n, v) {
+		try {
+			step(g[n](v));
+		} catch (e) {
+			settle(q[0][3], e);
+		}
+	}
+	function step(r) {
+		r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+	}
+	function fulfill(value) {
+		resume("next", value);
+	}
+	function reject(value) {
+		resume("throw", value);
+	}
+	function settle(f, v) {
+		if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+	}
+}
+function __asyncDelegator(o) {
+	var i, p;
+	return i = {}, verb("next"), verb("throw", function(e) {
+		throw e;
+	}), verb("return"), i[Symbol.iterator] = function() {
+		return this;
+	}, i;
+	function verb(n, f) {
+		i[n] = o[n] ? function(v) {
+			return (p = !p) ? {
+				value: __await(o[n](v)),
+				done: false
+			} : f ? f(v) : v;
+		} : 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 __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+		return this;
+	}, i);
+	function verb(n) {
+		i[n] = o[n] && function(v) {
+			return new Promise(function(resolve, reject) {
+				v = o[n](v), settle(resolve, reject, v.done, v.value);
+			});
+		};
+	}
+	function settle(resolve, reject, d, v) {
+		Promise.resolve(v).then(function(v) {
+			resolve({
+				value: v,
+				done: d
+			});
+		}, reject);
+	}
+}
+var ResultAsync = class ResultAsync {
+	constructor(res) {
+		this._promise = res;
+	}
+	static fromSafePromise(promise) {
+		return new ResultAsync(promise.then((value) => new Ok(value)));
+	}
+	static fromPromise(promise, errorFn) {
+		return new ResultAsync(promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e))));
+	}
+	static fromThrowable(fn, errorFn) {
+		return (...args) => {
+			return new ResultAsync(__awaiter(this, void 0, void 0, function* () {
+				try {
+					return new Ok(yield fn(...args));
+				} catch (error) {
+					return new Err(errorFn ? errorFn(error) : error);
+				}
+			}));
+		};
+	}
+	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));
+		})));
+	}
+	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;
+		}));
+	}
+	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(ok, _err) {
+		return this._promise.then((res) => res.match(ok, _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()))))));
+		});
+	}
+	then(successCallback, failureCallback) {
+		return this._promise.then(successCallback, failureCallback);
+	}
+	[Symbol.asyncIterator]() {
+		return __asyncGenerator(this, arguments, function* _a() {
+			const result = yield __await(this._promise);
+			if (result.isErr()) yield yield __await(errAsync(result.error));
+			return yield __await(result.value);
+		});
+	}
+};
+function errAsync(err) {
+	return new ResultAsync(Promise.resolve(new Err(err)));
+}
+ResultAsync.fromPromise;
+ResultAsync.fromSafePromise;
+ResultAsync.fromThrowable;
+/**
+* Short circuits on the FIRST Err value that we find
+*/
+const combineResultList = (resultList) => {
+	let acc = ok([]);
+	for (const result of resultList) if (result.isErr()) {
+		acc = err(result.error);
+		break;
+	} else acc.map((list) => list.push(result.value));
+	return acc;
+};
+const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+/**
+* Give a list of all the errors we find
+*/
+const combineResultListWithAllErrors = (resultList) => {
+	let acc = ok([]);
+	for (const result of resultList) if (result.isErr() && acc.isErr()) acc.error.push(result.error);
+	else if (result.isErr() && acc.isOk()) acc = err([result.error]);
+	else if (result.isOk() && acc.isOk()) acc.value.push(result.value);
+	return acc;
+};
+const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result) {
+	/**
+	* Wraps a function with a try catch, creating a new function with the same
+	* arguments but returning `Ok` if successful, `Err` if the function throws
+	*
+	* @param fn function to wrap with ok on success or err on failure
+	* @param errorFn when an error is thrown, this will wrap the error result if provided
+	*/
+	function fromThrowable(fn, errorFn) {
+		return (...args) => {
+			try {
+				return ok(fn(...args));
+			} catch (e) {
+				return err(errorFn ? errorFn(e) : e);
+			}
+		};
+	}
+	Result.fromThrowable = fromThrowable;
+	function combine(resultList) {
+		return combineResultList(resultList);
+	}
+	Result.combine = combine;
+	function combineWithAllErrors(resultList) {
+		return combineResultListWithAllErrors(resultList);
+	}
+	Result.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+function ok(value) {
+	return new Ok(value);
+}
+function err(err) {
+	return new Err(err);
+}
+var Ok = class {
+	constructor(value) {
+		this.value = value;
+	}
+	isOk() {
+		return true;
+	}
+	isErr() {
+		return !this.isOk();
+	}
+	map(f) {
+		return ok(f(this.value));
+	}
+	mapErr(_f) {
+		return ok(this.value);
+	}
+	andThen(f) {
+		return f(this.value);
+	}
+	andThrough(f) {
+		return f(this.value).map((_value) => this.value);
+	}
+	andTee(f) {
+		try {
+			f(this.value);
+		} catch (e) {}
+		return ok(this.value);
+	}
+	orTee(_f) {
+		return ok(this.value);
+	}
+	orElse(_f) {
+		return ok(this.value);
+	}
+	asyncAndThen(f) {
+		return f(this.value);
+	}
+	asyncAndThrough(f) {
+		return f(this.value).map(() => this.value);
+	}
+	asyncMap(f) {
+		return ResultAsync.fromSafePromise(f(this.value));
+	}
+	unwrapOr(_v) {
+		return this.value;
+	}
+	match(ok, _err) {
+		return ok(this.value);
+	}
+	safeUnwrap() {
+		const value = this.value;
+		return (function* () {
+			return value;
+		})();
+	}
+	_unsafeUnwrap(_) {
+		return this.value;
+	}
+	_unsafeUnwrapErr(config) {
+		throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+	}
+	*[Symbol.iterator]() {
+		return this.value;
+	}
+};
+var Err = class {
+	constructor(error) {
+		this.error = error;
+	}
+	isOk() {
+		return false;
+	}
+	isErr() {
+		return !this.isOk();
+	}
+	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);
+	}
+	andThen(_f) {
+		return err(this.error);
+	}
+	orElse(f) {
+		return f(this.error);
+	}
+	asyncAndThen(_f) {
+		return errAsync(this.error);
+	}
+	asyncAndThrough(_f) {
+		return errAsync(this.error);
+	}
+	asyncMap(_f) {
+		return errAsync(this.error);
+	}
+	unwrapOr(v) {
+		return v;
+	}
+	match(_ok, err) {
+		return err(this.error);
+	}
+	safeUnwrap() {
+		const error = this.error;
+		return (function* () {
+			yield err(error);
+			throw new Error("Do not use this generator out of `safeTry`");
+		})();
+	}
+	_unsafeUnwrap(config) {
+		throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+	}
+	_unsafeUnwrapErr(_) {
+		return this.error;
+	}
+	*[Symbol.iterator]() {
+		const self = this;
+		yield self;
+		return self;
+	}
+};
+const fromThrowable = Result.fromThrowable;
+//#endregion
+//#region src/services/error/getResult.ts
+const getResult = (fn) => fromThrowable(fn, toAppError)();
+//#endregion
+//#region src/services/error/getResultAsync.ts
+const getResultAsync = (fn) => ResultAsync.fromPromise(Promise.resolve().then(fn), toAppError);
+//#endregion
+//#region src/services/error/withFinalizer.ts
+const withFinalizer = (fn, finalizer) => {
+	const result = getResult(fn);
+	(finalizer ? getResult(finalizer) : void 0)?.match(noop, (error) => {
+		throw error;
+	});
+	return result.match((value) => value, (error) => {
+		throw error;
+	});
+};
+//#endregion
+//#region src/services/error/withFinalizerAsync.ts
+const withFinalizerAsync = async (fn, finalizer) => {
+	const result = await getResultAsync(async () => fn());
+	if (finalizer) await getResultAsync(async () => finalizer()).match(noop, (error) => {
+		if (result.isOk()) throw error;
+		console.error(error);
+	});
+	return result.match((value) => value, (error) => {
+		throw error;
+	});
+};
+//#endregion
 //#region src/services/message/constants.ts
 const MENTION_ID_ATTRIBUTE = "data-id";
 const MENTION_LABEL_ATTRIBUTE = "data-label";
@@ -2370,6 +2801,7 @@ const MENTION_EVERYONE_ID = "@everyone";
 //#endregion
 //#region ../../node_modules/.pnpm/he@1.2.0/node_modules/he/he.js
 var require_he = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
 	(function(root) {
 		var freeExports = typeof exports == "object" && exports;
 		var freeModule = typeof module == "object" && module && module.exports == freeExports && module;
@@ -14385,17 +14817,17 @@ const isPlainObject = (data) => {
 };
 //#endregion
 //#region src/util/object/jsonDateParse.ts
-const reISO = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.{0,1}\d*))(?:Z|(\+|-)([\d|:]*))?$/;
-const reMsAjax = /^\/Date\((d|-|.*)\)[/|\\]$/;
+const ISO_DATE_REGEX = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.{0,1}\d*))(?:Z|(\+|-)([\d|:]*))?$/u;
+const MS_AJAX_DATE_REGEX = /^\/Date\((-?\d+(?:[-+]\d+)?)\)[/\\]$/u;
 const jsonDateParse = (text) => JSON.parse(text, (_key, value) => {
 	let parsedValue = value;
 	if (typeof value === "string") {
-		let a = reISO.exec(value);
+		let a = ISO_DATE_REGEX.exec(value);
 		if (a) parsedValue = new Date(value);
 		else {
-			a = reMsAjax.exec(value);
+			a = MS_AJAX_DATE_REGEX.exec(value);
 			if (a) {
-				const b = takeOne(a, 1).split(/[-+,.]/);
+				const b = takeOne(a, 1).split(/[-+,.]/u);
 				parsedValue = new Date(b[0] ? Number(b[0]) : 0 - Number(b[1]));
 			}
 		}
@@ -14407,11 +14839,14 @@ const jsonDateParse = (text) => JSON.parse(text, (_key, value) => {
 const mergeObjectsStrict = (...objects) => Object.assign({}, ...objects);
 //#endregion
 //#region src/util/regex/escapeRegExp.ts
-const escapeRegExp = (string) => string.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+const escapeRegExp = (string) => string.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
 //#endregion
 //#region src/util/text/capitalize.ts
 const capitalize = (string) => `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
 //#endregion
+//#region src/util/text/normalizeString.ts
+const normalizeString = (value) => value?.trim() ?? "";
+//#endregion
 //#region src/util/text/streamToText.ts
 const streamToText = async (readable) => {
 	readable.setEncoding("utf8");
@@ -14421,7 +14856,7 @@ const streamToText = async (readable) => {
 };
 //#endregion
 //#region src/util/text/toKebabCase.ts
-const toKebabCase = (string) => string.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)?.map((x) => x.toLowerCase()).join("-") ?? "";
+const toKebabCase = (string) => string.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/gu)?.map((x) => x.toLowerCase()).join("-") ?? "";
 //#endregion
 //#region src/util/text/truncate.ts
 const truncate = (string, length) => string.length > length ? `${string.slice(0, length)}..."` : string;
@@ -14458,9 +14893,9 @@ const exhaustiveGuard = (value) => {
 //#endregion
 //#region src/util/id/uuid/constants.ts
 const NIL = "00000000-0000-0000-0000-000000000000";
-const UUIDV4_REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
+const UUIDV4_REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/iu;
 //#endregion
 //#region src/util/id/uuid/uuidValidateV4.ts
 const uuidValidateV4 = (uuid) => UUIDV4_REGEX.test(uuid);
 //#endregion
-export { AllSpecialValues, ForbiddenError, ID_SEPARATOR, InvalidOperationError, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, NIL, NotFoundError, NotInitializedError, Operation, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, UUIDV4_REGEX, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };
+export { AllSpecialValues, ForbiddenError, ID_SEPARATOR, InvalidOperationError, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, NIL, NotFoundError, NotInitializedError, Operation, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, UUIDV4_REGEX, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };