@esposter/shared 4.2.0 → 4.3.2

package/dist/index.js

@@ -0,0 +1,2197 @@
+import { z } from "zod";
+import { ResultAsync, fromThrowable } from "neverthrow";
+import { parse } from "node-html-parser";
+import mimeDatabase from "mime-db/db.json" with { type: "json" };
+import { defaultTreeAdapter, html as html$1, parseFragment } from "parse5";
+//#region src/models/error/ForbiddenError.ts
+var ForbiddenError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ForbiddenError";
+	}
+};
+//#endregion
+//#region src/models/error/InvalidOperationError.ts
+var InvalidOperationError = class extends Error {
+	constructor(operation, name, message) {
+		super(`Invalid operation: ${operation}, name: ${name}, ${message}`);
+		this.name = "InvalidOperationError";
+	}
+};
+//#endregion
+//#region src/models/error/NotFoundError.ts
+var NotFoundError = class extends Error {
+	constructor(name, id) {
+		super(`${name} is not found for id: ${id}`);
+		this.name = "NotFoundError";
+	}
+};
+//#endregion
+//#region src/models/error/NotInitializedError.ts
+var NotInitializedError = class extends Error {
+	constructor(name) {
+		super(`${name} is not initialized`);
+		this.name = "NotInitializedError";
+	}
+};
+//#endregion
+//#region src/models/error/WordFilteredError.ts
+var WordFilteredError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WordFilteredError";
+	}
+};
+//#endregion
+//#region src/models/shared/Operation.ts
+let Operation = /* @__PURE__ */ function(Operation) {
+	Operation["Create"] = "Create";
+	Operation["Delete"] = "Delete";
+	Operation["Push"] = "Push";
+	Operation["Read"] = "Read";
+	Operation["Unshift"] = "Unshift";
+	Operation["Update"] = "Update";
+	return Operation;
+}({});
+//#endregion
+//#region src/models/eventEmitter/TypedEventEmitter.ts
+var TypedEventEmitter = class {
+	#entriesMap = /* @__PURE__ */ new Map();
+	emit(event, ...args) {
+		const entries = this.#entriesMap.get(event) ?? [];
+		if (entries.length === 0) return false;
+		this.#setEntries(event, entries.filter((entry) => !entry.isOnce));
+		for (const { listener } of entries) listener(...args);
+		return true;
+	}
+	off(event, listener) {
+		this.#setEntries(event, (this.#entriesMap.get(event) ?? []).filter((entry) => entry.listener !== listener));
+	}
+	on(event, listener) {
+		this.#addEntry(event, listener, false);
+	}
+	once(event, listener) {
+		this.#addEntry(event, listener, true);
+	}
+	removeAllListeners(event) {
+		if (event === void 0) this.#entriesMap.clear();
+		else this.#entriesMap.delete(event);
+	}
+	#addEntry(event, listener, isOnce) {
+		if (typeof listener !== "function") throw new InvalidOperationError("Create", String(event), "The listener must be a function");
+		this.#setEntries(event, [...this.#entriesMap.get(event) ?? [], {
+			isOnce,
+			listener
+		}]);
+	}
+	#setEntries(event, entries) {
+		if (entries.length === 0) this.#entriesMap.delete(event);
+		else this.#entriesMap.set(event, entries);
+	}
+};
+//#endregion
+//#region src/models/jsonPatch/JsonPatchOperationType.ts
+let JsonPatchOperationType = /* @__PURE__ */ function(JsonPatchOperationType) {
+	JsonPatchOperationType["Add"] = "add";
+	JsonPatchOperationType["Copy"] = "copy";
+	JsonPatchOperationType["Move"] = "move";
+	JsonPatchOperationType["Remove"] = "remove";
+	JsonPatchOperationType["Replace"] = "replace";
+	JsonPatchOperationType["Test"] = "test";
+	return JsonPatchOperationType;
+}({});
+//#endregion
+//#region src/models/message/MentionType.ts
+let MentionType = /* @__PURE__ */ function(MentionType) {
+	MentionType["Role"] = "role";
+	MentionType["User"] = "user";
+	return MentionType;
+}({});
+//#endregion
+//#region src/models/object/ObjectMethod.ts
+let ObjectMethod = /* @__PURE__ */ function(ObjectMethod) {
+	ObjectMethod["ToString"] = "toString";
+	ObjectMethod["ValueOf"] = "valueOf";
+	return ObjectMethod;
+}({});
+//#endregion
+//#region src/services/app/constants.ts
+const MAX_READ_LIMIT = 1e3;
+const SITE_NAME = "Esposter";
+const KIBIBYTE = 1024;
+const GIBIBYTE = KIBIBYTE ** 2 * KIBIBYTE;
+//#endregion
+//#region src/models/router/RoutePath.ts
+const RoutePath = {
+	About: "/about",
+	Achievements: "/achievements",
+	Anime: "/anime",
+	Calls: (id) => `/calls/${id}`,
+	CallsIndex: "/calls",
+	Clicker: "/clicker",
+	Dungeons: "/dungeons",
+	FluidSimulator: "/fluid-simulator",
+	Genshin: "/genshin",
+	Github: `https://github.com/${SITE_NAME}/${SITE_NAME}`,
+	Index: "/",
+	Login: "/login",
+	Messages: (id) => `/messages/${id}`,
+	MessagesDraftsAndSent: "/messages/draftsandsent",
+	MessagesFriends: "/messages/friends",
+	MessagesIndex: "/messages",
+	MessagesInvite: (code) => `/messages/invite/${code}`,
+	MessagesMessage: (id, rowKey) => `/messages/${id}/${rowKey}`,
+	MessagesThread: (id, rowKey) => `/messages/${id}/thread/${rowKey}`,
+	Post: (id) => `/post/${id}`,
+	PostCreate: "/post/create",
+	PostUpdate: (id) => `/post/update/${id}`,
+	PrivacyPolicy: "/privacy-policy",
+	Resource: (id) => `/resource-explorer/${id}`,
+	ResourceExplorer: "/resource-explorer",
+	ResourceExplorerAll: "/resource-explorer/all",
+	ResourceExplorerCreate: "/resource-explorer/create",
+	ResourceExplorerCreateType: (type) => `/resource-explorer/create/${type}`,
+	ResourceExplorerFavorites: "/resource-explorer/favorites",
+	ResourceExplorerRecents: "/resource-explorer/recents",
+	ResourceExplorerRecycleBin: "/resource-explorer/recycle-bin",
+	ResourceExplorerTags: "/resource-explorer/tags",
+	ResourceItems: (id) => `/resource-explorer/${id}/items`,
+	User: (id) => `/user/${id}`,
+	UserSettings: "/user/settings",
+	View: (type, id) => `/view/${type}/${id}`
+};
+//#endregion
+//#region src/models/shared/ItemEntityType.ts
+const createItemEntityTypeSchema = (schema) => z.object({ type: schema });
+//#endregion
+//#region src/models/shared/ItemMetadata.ts
+var ItemMetadata = class {
+	createdAt = /* @__PURE__ */ new Date();
+	deletedAt = null;
+	updatedAt = /* @__PURE__ */ new Date();
+};
+//#endregion
+//#region src/util/reactivity/getRawData.ts
+const getRawData = (data) => {
+	const raw = data && data.__v_raw;
+	return raw ? getRawData(raw) : data;
+};
+//#endregion
+//#region src/util/reactivity/toRawDeep.ts
+const toRawDeep = (data) => {
+	const rawData = getRawData(data);
+	for (const key in rawData) if (Object.hasOwn(rawData, key)) {
+		const value = rawData[key];
+		if (value !== null && typeof value === "object") rawData[key] = toRawDeep(value);
+	}
+	return rawData;
+};
+//#endregion
+//#region src/models/shared/Serializable.ts
+var Serializable = class {
+	toJSON() {
+		return structuredClone(toRawDeep(this));
+	}
+};
+//#endregion
+//#region src/services/error/toAppError.ts
+const toAppError = (error) => {
+	if (error instanceof Error) return error;
+	else if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") return new Error(error.message, { cause: error });
+	else return new Error(String(error), { cause: error });
+};
+//#endregion
+//#region src/services/error/getResult.ts
+const getResult = (callback) => fromThrowable(callback, toAppError)();
+//#endregion
+//#region src/services/error/getResultAsync.ts
+const getResultAsync = (callback) => ResultAsync.fromThrowable(callback, toAppError)();
+//#endregion
+//#region src/services/error/reportFinalizerError.ts
+const reportFinalizerError = (callbackResult, finalizerError) => {
+	callbackResult.match(() => {
+		throw finalizerError;
+	}, () => {
+		console.error(finalizerError);
+	});
+};
+//#endregion
+//#region src/util/function/noop.ts
+const noop = () => {};
+//#endregion
+//#region src/services/error/withFinalizer.ts
+const withFinalizer = (callback, finalizer) => {
+	const callbackResult = getResult(callback);
+	if (finalizer) getResult(finalizer).match(noop, (error) => {
+		reportFinalizerError(callbackResult, error);
+	});
+	return callbackResult.match((value) => value, (error) => {
+		throw error;
+	});
+};
+//#endregion
+//#region src/services/error/withFinalizerAsync.ts
+const withFinalizerAsync = async (callback, finalizer) => {
+	const callbackResult = await getResultAsync(async () => callback());
+	if (finalizer) await getResultAsync(async () => finalizer()).match(noop, (error) => {
+		reportFinalizerError(callbackResult, error);
+	});
+	return callbackResult.match((value) => value, (error) => {
+		throw error;
+	});
+};
+//#endregion
+//#region src/services/history/createHistory.ts
+const createHistory = (limit) => ({
+	future: [],
+	limit,
+	past: []
+});
+//#endregion
+//#region src/services/history/pushHistory.ts
+const pushHistory = (history, entry) => {
+	const past = [...history.past, entry];
+	return {
+		future: [],
+		limit: history.limit,
+		past: past.slice(Math.max(past.length - history.limit, 0))
+	};
+};
+//#endregion
+//#region src/services/history/redoHistory.ts
+const redoHistory = (history) => {
+	const [entry] = history.future;
+	if (entry === void 0) return { history };
+	return {
+		entry,
+		history: {
+			...pushHistory(history, entry),
+			future: history.future.slice(1)
+		}
+	};
+};
+//#endregion
+//#region src/services/history/undoHistory.ts
+const undoHistory = (history) => {
+	const entry = history.past.at(-1);
+	if (entry === void 0) return { history };
+	return {
+		entry,
+		history: {
+			future: [entry, ...history.future],
+			limit: history.limit,
+			past: history.past.slice(0, -1)
+		}
+	};
+};
+//#endregion
+//#region src/services/indexedDb/getRequestError.ts
+const getRequestError = (request) => request.error ?? new DOMException("The request failed without an error", "UnknownError");
+//#endregion
+//#region src/services/indexedDb/getTransactionDone.ts
+const getTransactionDone = (transaction) => new Promise((resolve, reject) => {
+	transaction.addEventListener("complete", () => {
+		resolve();
+	});
+	transaction.addEventListener("abort", () => {
+		reject(transaction.error ?? new DOMException("The transaction was aborted", "AbortError"));
+	});
+});
+//#endregion
+//#region src/services/indexedDb/requestToPromise.ts
+const requestToPromise = (request) => new Promise((resolve, reject) => {
+	request.addEventListener("success", () => {
+		resolve(request.result);
+	});
+	request.addEventListener("error", () => {
+		reject(getRequestError(request));
+	});
+});
+//#endregion
+//#region src/services/indexedDb/wrapIndex.ts
+const wrapIndex = (index) => ({
+	getAll: (query, count) => requestToPromise(index.getAll(query, count)),
+	getAllKeys: (query, count) => requestToPromise(index.getAllKeys(query, count))
+});
+//#endregion
+//#region src/services/indexedDb/wrapObjectStore.ts
+const wrapObjectStore = (objectStore) => {
+	const reader = {
+		get: (key) => requestToPromise(objectStore.get(key)),
+		getAll: (query, count) => requestToPromise(objectStore.getAll(query, count)),
+		getAllKeys: (query, count) => requestToPromise(objectStore.getAllKeys(query, count)),
+		index: (name) => wrapIndex(objectStore.index(name))
+	};
+	const writer = {
+		delete: (query) => requestToPromise(objectStore.delete(query)),
+		put: (value, key) => requestToPromise(objectStore.put(value, key))
+	};
+	const creator = { createIndex: (name, keyPath, options) => {
+		objectStore.createIndex(name, keyPath, options);
+	} };
+	return {
+		...reader,
+		...writer,
+		...creator
+	};
+};
+//#endregion
+//#region src/services/indexedDb/getTransactionObjectStore.ts
+const getTransactionObjectStore = (transaction) => (name) => wrapObjectStore(transaction.objectStore(name));
+//#endregion
+//#region src/services/indexedDb/wrapTransaction.ts
+const wrapTransaction = (transaction) => ({
+	done: getTransactionDone(transaction),
+	objectStore: getTransactionObjectStore(transaction)
+});
+//#endregion
+//#region src/services/indexedDb/wrapDatabase.ts
+const wrapDatabase = (database) => {
+	const getReadonlyObjectStore = (storeName) => wrapObjectStore(database.transaction(storeName, "readonly").objectStore(storeName));
+	const getReadwriteObjectStore = (storeName) => wrapObjectStore(database.transaction(storeName, "readwrite").objectStore(storeName));
+	const transaction = (storeNames, mode, options) => {
+		const names = typeof storeNames === "string" ? storeNames : [...storeNames];
+		return wrapTransaction(database.transaction(names, mode, options));
+	};
+	return {
+		close: () => {
+			database.close();
+		},
+		delete: (storeName, query) => getReadwriteObjectStore(storeName).delete(query),
+		get: (storeName, key) => getReadonlyObjectStore(storeName).get(key),
+		getAll: (storeName, query, count) => getReadonlyObjectStore(storeName).getAll(query, count),
+		getAllKeys: (storeName, query, count) => getReadonlyObjectStore(storeName).getAllKeys(query, count),
+		name: database.name,
+		put: (storeName, value, key) => getReadwriteObjectStore(storeName).put(value, key),
+		transaction
+	};
+};
+//#endregion
+//#region src/services/indexedDb/wrapUpgradeDatabase.ts
+const wrapUpgradeDatabase = (database) => ({
+	...wrapDatabase(database),
+	createObjectStore: (name, options) => wrapObjectStore(database.createObjectStore(name, options))
+});
+//#endregion
+//#region src/services/indexedDb/wrapUpgradeTransaction.ts
+const wrapUpgradeTransaction = (transaction) => {
+	const done = getTransactionDone(transaction);
+	getResultAsync(() => done).match(noop, (error) => {
+		if (transaction.error) console.error(error);
+	});
+	return {
+		get done() {
+			return done;
+		},
+		objectStore: getTransactionObjectStore(transaction)
+	};
+};
+//#endregion
+//#region src/services/indexedDb/openDatabase.ts
+const openDatabase = (name, version, options = {}) => new Promise((resolve, reject) => {
+	const request = indexedDB.open(name, version);
+	request.addEventListener("blocked", (event) => {
+		options.blocked?.(event.oldVersion, event.newVersion);
+	});
+	request.addEventListener("upgradeneeded", (event) => {
+		const { transaction } = request;
+		if (!transaction) return;
+		getResult(() => options.upgrade?.(wrapUpgradeDatabase(request.result), event.oldVersion, event.newVersion, wrapUpgradeTransaction(transaction))).match(noop, (error) => {
+			console.error(error);
+			transaction.abort();
+		});
+	});
+	request.addEventListener("success", () => {
+		const database = request.result;
+		database.addEventListener("close", () => {
+			options.terminated?.();
+		});
+		database.addEventListener("versionchange", (event) => {
+			options.blocking?.(event.oldVersion, event.newVersion);
+		});
+		resolve(wrapDatabase(database));
+	});
+	request.addEventListener("error", () => {
+		reject(getRequestError(request));
+	});
+});
+//#endregion
+//#region src/services/jsonPatch/constants.ts
+const APPEND_SEGMENT = "-";
+const JSON_POINTER_REGEX = /^(?:\/(?:[^/~]|~[01])*)*$/u;
+//#endregion
+//#region src/services/jsonPatch/parseArrayIndex.ts
+const ARRAY_INDEX_REGEX = /^(?:0|[1-9]\d*)$/u;
+const parseArrayIndex = (segment, maxIndex) => {
+	const index = Number(segment);
+	return ARRAY_INDEX_REGEX.test(segment) && index <= maxIndex ? index : void 0;
+};
+//#endregion
+//#region src/services/jsonPatch/parseJsonPointer.ts
+const parseJsonPointer = (pointer) => {
+	if (pointer === "") return [];
+	else if (!JSON_POINTER_REGEX.test(pointer)) throw new InvalidOperationError("Read", pointer, "not a JSON Pointer");
+	return pointer.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+};
+//#endregion
+//#region src/services/jsonPatch/toJsonPointer.ts
+const toJsonPointer = (segments) => segments.map((segment) => `/${segment.replaceAll("~", "~0").replaceAll("/", "~1")}`).join("");
+//#endregion
+//#region src/util/object/checkIsPlainObject.ts
+const checkIsPlainObject = (data) => {
+	if (typeof data !== "object" || data === null) return false;
+	const prototype = Object.getPrototypeOf(data);
+	return prototype === null || prototype === Object.prototype;
+};
+//#endregion
+//#region src/services/jsonPatch/readJsonValue.ts
+const readJsonValue = (document, segments) => {
+	let value = document;
+	for (const segment of segments) {
+		const index = Array.isArray(value) ? parseArrayIndex(segment, value.length - 1) : void 0;
+		if (Array.isArray(value) && index !== void 0) value = value[index];
+		else if (checkIsPlainObject(value) && Object.hasOwn(value, segment)) value = value[segment];
+		else throw new InvalidOperationError("Read", toJsonPointer(segments), "no such member");
+	}
+	return value;
+};
+//#endregion
+//#region src/services/jsonPatch/updateJsonValue.ts
+const updateJsonValue = (document, segments, update) => {
+	const [segment, ...restSegments] = segments;
+	if (segment === void 0) return update(document);
+	const index = Array.isArray(document) ? parseArrayIndex(segment, document.length - 1) : void 0;
+	if (Array.isArray(document) && index !== void 0) return document.with(index, updateJsonValue(document[index], restSegments, update));
+	else if (checkIsPlainObject(document) && Object.hasOwn(document, segment)) return {
+		...document,
+		[segment]: updateJsonValue(document[segment], restSegments, update)
+	};
+	else throw new InvalidOperationError("Update", toJsonPointer(segments), "no such member");
+};
+//#endregion
+//#region src/services/jsonPatch/addJsonValue.ts
+const addJsonValue = (document, path, value) => {
+	const segments = parseJsonPointer(path);
+	const parentSegments = segments.slice(0, -1);
+	const key = segments.at(-1);
+	if (key === void 0) return {
+		document: value,
+		inverses: [{
+			op: "replace",
+			path,
+			value: document
+		}]
+	};
+	const parent = readJsonValue(document, parentSegments);
+	if (Array.isArray(parent)) {
+		const index = key === "-" ? parent.length : parseArrayIndex(key, parent.length);
+		if (index === void 0) throw new InvalidOperationError("Update", path, "no such index in the array");
+		return {
+			document: updateJsonValue(document, parentSegments, () => parent.toSpliced(index, 0, value)),
+			inverses: [{
+				op: "remove",
+				path: toJsonPointer([...parentSegments, `${index}`])
+			}]
+		};
+	} else if (checkIsPlainObject(parent)) return {
+		document: updateJsonValue(document, parentSegments, () => ({
+			...parent,
+			[key]: value
+		})),
+		inverses: [Object.hasOwn(parent, key) ? {
+			op: "replace",
+			path,
+			value: parent[key]
+		} : {
+			op: "remove",
+			path
+		}]
+	};
+	else throw new InvalidOperationError("Update", path, "its parent holds no members");
+};
+//#endregion
+//#region src/services/jsonPatch/removeJsonValue.ts
+const removeJsonValue = (document, path) => {
+	const segments = parseJsonPointer(path);
+	const parentSegments = segments.slice(0, -1);
+	const key = segments.at(-1);
+	if (key === void 0) throw new InvalidOperationError("Delete", path, "the root cannot be removed");
+	const parent = readJsonValue(document, parentSegments);
+	const index = Array.isArray(parent) ? parseArrayIndex(key, parent.length - 1) : void 0;
+	if (Array.isArray(parent) && index !== void 0) return {
+		document: updateJsonValue(document, parentSegments, () => parent.toSpliced(index, 1)),
+		inverses: [{
+			op: "add",
+			path,
+			value: parent[index]
+		}]
+	};
+	else if (checkIsPlainObject(parent) && Object.hasOwn(parent, key)) {
+		const { [key]: removedValue, ...restParent } = parent;
+		return {
+			document: updateJsonValue(document, parentSegments, () => restParent),
+			inverses: [{
+				op: "add",
+				path,
+				value: removedValue
+			}]
+		};
+	} else throw new InvalidOperationError("Delete", path, "no such member");
+};
+//#endregion
+//#region src/util/object/checkIsCustomMethod.ts
+const checkIsCustomMethod = (value, methodName) => {
+	const method = Reflect.get(value, methodName);
+	return typeof method === "function" && method !== Object.prototype[methodName];
+};
+//#endregion
+//#region src/util/object/checkIsSameBytes.ts
+const toBytes = (view) => ArrayBuffer.isView(view) ? new Uint8Array(view.buffer, view.byteOffset, view.byteLength) : new Uint8Array(view);
+const checkIsSameBytes = (first, second) => {
+	const firstBytes = toBytes(first);
+	const secondBytes = toBytes(second);
+	return firstBytes.length === secondBytes.length && firstBytes.every((byte, index) => byte === secondBytes[index]);
+};
+//#endregion
+//#region src/util/object/checkIsSameValueZero.ts
+const checkIsSameValueZero = (first, second) => first === second || Number.isNaN(first) && Number.isNaN(second);
+//#endregion
+//#region src/util/object/getEnumerableKeys.ts
+const getEnumerableKeys = (value) => Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+//#endregion
+//#region src/util/object/checkIsDeepEqual.ts
+const checkIsBinary = (value) => ArrayBuffer.isView(value) || value instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+const checkIsDeepEqual = (first, second) => {
+	if (first === second) return true;
+	if (typeof first !== "object" || typeof second !== "object" || first === null || second === null) return checkIsSameValueZero(first, second);
+	if (Object.getPrototypeOf(first) !== Object.getPrototypeOf(second)) return false;
+	if (Array.isArray(first) || Array.isArray(second)) {
+		if (!Array.isArray(first) || !Array.isArray(second) || first.length !== second.length) return false;
+		for (const [index, item] of first.entries()) if (!checkIsDeepEqual(item, second[index])) return false;
+		return true;
+	}
+	if (checkIsBinary(first) && checkIsBinary(second)) return checkIsSameBytes(first, second);
+	if (first instanceof RegExp && second instanceof RegExp) return first.source === second.source && first.flags === second.flags;
+	if (first instanceof WeakMap || first instanceof WeakSet || first instanceof Promise || first instanceof Blob) return false;
+	if (checkIsCustomMethod(first, "valueOf") && checkIsCustomMethod(second, "valueOf")) return checkIsSameValueZero(first.valueOf(), second.valueOf());
+	if (checkIsCustomMethod(first, "toString") && checkIsCustomMethod(second, "toString")) return first.toString() === second.toString();
+	if (first instanceof Map && second instanceof Map) {
+		if (first.size !== second.size) return false;
+		for (const [key, value] of first) if (!second.has(key) || !checkIsDeepEqual(value, second.get(key))) return false;
+		return true;
+	}
+	if (first instanceof Set && second instanceof Set) {
+		if (first.size !== second.size) return false;
+		for (const value of first) if (!second.has(value)) return false;
+		return true;
+	}
+	const firstKeys = getEnumerableKeys(first);
+	if (firstKeys.length !== getEnumerableKeys(second).length) return false;
+	return firstKeys.every((key) => Object.prototype.propertyIsEnumerable.call(second, key) && checkIsDeepEqual(Reflect.get(first, key), Reflect.get(second, key)));
+};
+//#endregion
+//#region src/util/validation/exhaustiveGuard.ts
+const exhaustiveGuard = (value) => {
+	throw new InvalidOperationError("Read", exhaustiveGuard.name, JSON.stringify(value));
+};
+//#endregion
+//#region src/services/jsonPatch/applyPatch.ts
+const applyPatch = (document, operation) => {
+	switch (operation.op) {
+		case "add": return addJsonValue(document, operation.path, operation.value);
+		case "copy": return addJsonValue(document, operation.path, readJsonValue(document, parseJsonPointer(operation.from)));
+		case "move": {
+			if (operation.from === operation.path) {
+				readJsonValue(document, parseJsonPointer(operation.from));
+				return {
+					document,
+					inverses: []
+				};
+			} else if (operation.path.startsWith(`${operation.from}/`)) throw new InvalidOperationError("Update", operation.path, "a value cannot move into itself");
+			const removed = removeJsonValue(document, operation.from);
+			const added = addJsonValue(removed.document, operation.path, readJsonValue(document, parseJsonPointer(operation.from)));
+			return {
+				document: added.document,
+				inverses: [...added.inverses, ...removed.inverses]
+			};
+		}
+		case "remove": return removeJsonValue(document, operation.path);
+		case "replace": {
+			const segments = parseJsonPointer(operation.path);
+			const replacedValue = readJsonValue(document, segments);
+			return {
+				document: updateJsonValue(document, segments, () => operation.value),
+				inverses: [{
+					op: "replace",
+					path: operation.path,
+					value: replacedValue
+				}]
+			};
+		}
+		case "test":
+			if (!checkIsDeepEqual(readJsonValue(document, parseJsonPointer(operation.path)), operation.value)) throw new InvalidOperationError("Read", operation.path, "the value differs from the test's");
+			return {
+				document,
+				inverses: []
+			};
+		default: return exhaustiveGuard(operation);
+	}
+};
+//#endregion
+//#region src/services/jsonPatch/applyPatches.ts
+const applyPatches = (document, operations) => {
+	let patchedDocument = document;
+	const inverseGroups = [];
+	for (const operation of operations) {
+		const result = applyPatch(patchedDocument, operation);
+		patchedDocument = result.document;
+		inverseGroups.push(result.inverses);
+	}
+	return {
+		document: patchedDocument,
+		inverses: inverseGroups.toReversed().flat()
+	};
+};
+//#endregion
+//#region src/services/message/constants.ts
+const MENTION_ID_ATTRIBUTE = "data-id";
+const MENTION_ITEM_TYPE_ATTRIBUTE = "data-mention-type";
+const MENTION_LABEL_ATTRIBUTE = "data-label";
+const MENTION_TYPE_ATTRIBUTE = "data-type";
+const MENTION_TYPE = "mention";
+const MENTION_SELECTOR = `span[${MENTION_TYPE_ATTRIBUTE}='${MENTION_TYPE}']`;
+const MENTION_HERE_ID = "@here";
+const MENTION_EVERYONE_ID = "@everyone";
+const CUSTOM_EMOJI_ID_ATTRIBUTE = "data-custom-emoji-id";
+const CUSTOM_EMOJI_NAME_ATTRIBUTE = "data-custom-emoji-name";
+const SPOILER_ATTRIBUTE = "data-spoiler";
+const SPOILER_SELECTOR = `span[${SPOILER_ATTRIBUTE}]`;
+//#endregion
+//#region src/services/message/getMentions.ts
+const getMentions = (message) => parse(message).querySelectorAll(MENTION_SELECTOR);
+//#endregion
+//#region src/services/mime/constants.ts
+const MEDIA_TYPE_REGEX = /^\s*(?<mediaType>[^;\s]*)(?:;|\s|$)/u;
+const PATH_SEPARATOR_REGEX = /[/\\]/u;
+const TEXT_MEDIA_TYPE_REGEX = /^text\//iu;
+const CHARSET_PARAMETER_REGEX = /;\s*charset=/iu;
+const DEFAULT_TEXT_CHARSET = "UTF-8";
+const FacetScoreMap = /* @__PURE__ */ new Map([
+	["prs.", 100],
+	["vnd.", 400],
+	["x-", 200],
+	["x.", 300]
+]);
+const DEFAULT_FACET_SCORE = 900;
+const SourceScoreMap = /* @__PURE__ */ new Map([
+	["apache", 20],
+	["iana", 40],
+	["nginx", 10]
+]);
+const DEFAULT_SOURCE_SCORE = 30;
+const TypeScoreMap = /* @__PURE__ */ new Map([
+	["application", 1],
+	["audio", 2],
+	["font", 2],
+	["video", 3]
+]);
+const DEFAULT_TYPE_SCORE = 0;
+//#endregion
+//#region src/services/mime/getMediaType.ts
+const getMediaType = (value) => MEDIA_TYPE_REGEX.exec(value)?.groups?.mediaType ?? "";
+//#endregion
+//#region src/services/mime/getMimeTypeEntryMap.ts
+let mimeTypeEntryMap;
+const getMimeTypeEntryMap = () => {
+	mimeTypeEntryMap ??= new Map(Object.entries(mimeDatabase));
+	return mimeTypeEntryMap;
+};
+//#endregion
+//#region src/services/mime/charset.ts
+const charset = (type) => {
+	const mediaType = getMediaType(type);
+	const dataCharset = getMimeTypeEntryMap().get(mediaType.toLowerCase())?.charset;
+	if (dataCharset) return dataCharset;
+	return TEXT_MEDIA_TYPE_REGEX.test(mediaType) ? DEFAULT_TEXT_CHARSET : false;
+};
+//#endregion
+//#region src/services/mime/getMimeScore.ts
+const getMimeScore = (mimeType, source = "") => {
+	if (mimeType === "application/octet-stream") return 0;
+	const [type = "", subtype = ""] = mimeType.split("/");
+	const facet = subtype.replace(/(?<prefix>\.|x-).*/u, "$<prefix>");
+	const facetScore = FacetScoreMap.get(facet) ?? 900;
+	const sourceScore = SourceScoreMap.get(source) ?? 30;
+	const typeScore = TypeScoreMap.get(type) ?? 0;
+	const lengthScore = 1 - mimeType.length / 100;
+	return facetScore + sourceScore + typeScore + lengthScore;
+};
+//#endregion
+//#region src/services/mime/getExtensionMimeTypeMap.ts
+let extensionMimeTypeMap;
+const getPreferredMimeType = (currentMimeType, candidateMimeType) => {
+	if (currentMimeType === void 0) return candidateMimeType;
+	const entryMap = getMimeTypeEntryMap();
+	return getMimeScore(currentMimeType, entryMap.get(currentMimeType)?.source) > getMimeScore(candidateMimeType, entryMap.get(candidateMimeType)?.source) ? currentMimeType : candidateMimeType;
+};
+const getExtensionMimeTypeMap = () => {
+	if (!extensionMimeTypeMap) {
+		const map = /* @__PURE__ */ new Map();
+		for (const [mimeType, { extensions = [] }] of getMimeTypeEntryMap()) for (const extension of extensions) map.set(extension, getPreferredMimeType(map.get(extension), mimeType));
+		extensionMimeTypeMap = map;
+	}
+	return extensionMimeTypeMap;
+};
+//#endregion
+//#region src/services/mime/lookup.ts
+const getExtension = (path) => {
+	const name = path.split(PATH_SEPARATOR_REGEX).at(-1) ?? "";
+	const dotIndex = name.lastIndexOf(".");
+	if (path === name) return name.slice(dotIndex + 1);
+	return dotIndex > 0 ? name.slice(dotIndex + 1) : "";
+};
+const lookup = (path) => {
+	const extension = getExtension(path).toLowerCase();
+	if (!extension) return false;
+	return getExtensionMimeTypeMap().get(extension) ?? false;
+};
+//#endregion
+//#region src/services/mime/contentType.ts
+const contentType = (value) => {
+	const mediaType = value.includes("/") ? value : lookup(value);
+	if (!mediaType) return false;
+	if (CHARSET_PARAMETER_REGEX.test(mediaType)) return mediaType;
+	const mediaCharset = charset(mediaType);
+	return mediaCharset ? `${mediaType}; charset=${mediaCharset.toLowerCase()}` : mediaType;
+};
+//#endregion
+//#region src/services/mime/extension.ts
+const extension = (type) => getMimeTypeEntryMap().get(getMediaType(type).toLowerCase())?.extensions?.[0] ?? false;
+//#endregion
+//#region src/services/prettier/css.ts
+const css = String.raw;
+//#endregion
+//#region src/services/prettier/html.ts
+const html = String.raw;
+//#endregion
+//#region src/services/profanity/englishProfaneWords.ts
+const englishProfaneWords = [
+	"4r5e",
+	"5h1t",
+	"5hit",
+	"a55",
+	"anal",
+	"anus",
+	"ar5e",
+	"arrse",
+	"arse",
+	"arses",
+	"ass",
+	"ass-fucker",
+	"asses",
+	"assfucker",
+	"assfukka",
+	"asshole",
+	"assholes",
+	"asswhole",
+	"a_s_s",
+	"a$$",
+	"as$",
+	"a$s",
+	"b!tch",
+	"b00bs",
+	"b17ch",
+	"b1tch",
+	"ballbag",
+	"balls",
+	"ballsack",
+	"bastard",
+	"beastial",
+	"beastiality",
+	"bellend",
+	"bestial",
+	"bestiality",
+	"bi+ch",
+	"biatch",
+	"bitch",
+	"bitchboy",
+	"bitcher",
+	"bitchers",
+	"bitches",
+	"bitchin",
+	"bitching",
+	"bloody",
+	"blow job",
+	"blowjob",
+	"blowjobs",
+	"boiolas",
+	"bollock",
+	"bollok",
+	"boner",
+	"boob",
+	"boobs",
+	"booobs",
+	"boooobs",
+	"booooobs",
+	"booooooobs",
+	"breasts",
+	"buceta",
+	"bugger",
+	"bullshit",
+	"bum",
+	"butt",
+	"butts",
+	"butthole",
+	"buttmuch",
+	"buttplug",
+	"c0ck",
+	"c0cksucker",
+	"carpet muncher",
+	"cawk",
+	"chink",
+	"cipa",
+	"cl1t",
+	"clit",
+	"clitoris",
+	"clits",
+	"cnut",
+	"cock",
+	"cock-sucker",
+	"cockface",
+	"cockhead",
+	"cockmunch",
+	"cockmuncher",
+	"cocks",
+	"cocksuck",
+	"cocksucked",
+	"cocksucker",
+	"cocksucking",
+	"cocksucks",
+	"cocksuka",
+	"cocksukka",
+	"cok",
+	"cokmuncher",
+	"coksucka",
+	"coon",
+	"cox",
+	"crap",
+	"cum",
+	"cummer",
+	"cumming",
+	"cums",
+	"cumshot",
+	"cunilingus",
+	"cunillingus",
+	"cunnilingus",
+	"cunt",
+	"cuntlick",
+	"cuntlicker",
+	"cuntlicking",
+	"cunts",
+	"cyalis",
+	"cyberfuc",
+	"cyberfuck",
+	"cyberfucked",
+	"cyberfucker",
+	"cyberfuckers",
+	"cyberfucking",
+	"d1ck",
+	"damn",
+	"dick",
+	"dickhead",
+	"dildo",
+	"dildos",
+	"dink",
+	"dinks",
+	"dirsa",
+	"dlck",
+	"dog-fucker",
+	"doggin",
+	"dogging",
+	"donkeyribber",
+	"doosh",
+	"duche",
+	"dyke",
+	"ejaculate",
+	"ejaculated",
+	"ejaculates",
+	"ejaculating",
+	"ejaculatings",
+	"ejaculation",
+	"ejakulate",
+	"f u c k",
+	"f u c k e r",
+	"f4nny",
+	"fag",
+	"fagging",
+	"faggitt",
+	"faggot",
+	"faggs",
+	"fagot",
+	"fagots",
+	"fags",
+	"fanny",
+	"fannyflaps",
+	"fannyfucker",
+	"fanyy",
+	"fatass",
+	"fcuk",
+	"fcuker",
+	"fcuking",
+	"feck",
+	"fecker",
+	"felching",
+	"fellate",
+	"fellatio",
+	"fingerfuck",
+	"fingerfucked",
+	"fingerfucker",
+	"fingerfuckers",
+	"fingerfucking",
+	"fingerfucks",
+	"fistfuck",
+	"fistfucked",
+	"fistfucker",
+	"fistfuckers",
+	"fistfucking",
+	"fistfuckings",
+	"fistfucks",
+	"flange",
+	"fook",
+	"fooker",
+	"fuck",
+	"fucka",
+	"fucked",
+	"fucker",
+	"fuckers",
+	"fuckhead",
+	"fuckheads",
+	"fuckin",
+	"fucking",
+	"fuckings",
+	"fuckingshitmotherfucker",
+	"fuckme",
+	"fucks",
+	"fuckwhit",
+	"fuckwit",
+	"fudge packer",
+	"fudgepacker",
+	"fuk",
+	"fuker",
+	"fukker",
+	"fukkin",
+	"fuks",
+	"fukwhit",
+	"fukwit",
+	"fux",
+	"fux0r",
+	"f_u_c_k",
+	"gangbang",
+	"gangbanged",
+	"gangbangs",
+	"gaylord",
+	"gaysex",
+	"goatse",
+	"god-dam",
+	"god-damned",
+	"goddamn",
+	"goddamned",
+	"hardcoresex",
+	"headass",
+	"hoar",
+	"hoare",
+	"hoer",
+	"hoes",
+	"homo",
+	"hore",
+	"horniest",
+	"horny",
+	"hotsex",
+	"jack-off",
+	"jackoff",
+	"jap",
+	"jerk-off",
+	"jism",
+	"jiz",
+	"jizm",
+	"jizz",
+	"kawk",
+	"knobead",
+	"knobed",
+	"knobend",
+	"knobhead",
+	"knobjocky",
+	"knobjokey",
+	"kock",
+	"kondum",
+	"kondums",
+	"kum",
+	"kummer",
+	"kumming",
+	"kums",
+	"kunilingus",
+	"l3i+ch",
+	"l3itch",
+	"labia",
+	"lust",
+	"lusting",
+	"m0f0",
+	"m0fo",
+	"m45terbate",
+	"ma5terb8",
+	"ma5terbate",
+	"masochist",
+	"master-bate",
+	"masterb8",
+	"masterbat*",
+	"masterbat3",
+	"masterbate",
+	"masterbation",
+	"masterbations",
+	"masturbate",
+	"mo-fo",
+	"mof0",
+	"mofo",
+	"mothafuck",
+	"mothafucka",
+	"mothafuckas",
+	"mothafuckaz",
+	"mothafucked",
+	"mothafucker",
+	"mothafuckers",
+	"mothafuckin",
+	"mothafucking",
+	"mothafuckings",
+	"mothafucks",
+	"motherfuck",
+	"motherfucked",
+	"motherfucker",
+	"motherfuckers",
+	"motherfuckin",
+	"motherfucking",
+	"motherfuckings",
+	"motherfuckka",
+	"motherfucks",
+	"muff",
+	"muthafecker",
+	"muthafuckker",
+	"mutherfucker",
+	"n1gga",
+	"n1gger",
+	"nazi",
+	"nigg3r",
+	"nigg4h",
+	"nigga",
+	"niggah",
+	"niggas",
+	"niggaz",
+	"nigger",
+	"niggers",
+	"nob",
+	"nob jokey",
+	"nobhead",
+	"nobjocky",
+	"nobjokey",
+	"numbnuts",
+	"nutsack",
+	"orgasim",
+	"orgasims",
+	"orgasm",
+	"orgasms",
+	"p0rn",
+	"pawn",
+	"pecker",
+	"penis",
+	"penisfucker",
+	"phonesex",
+	"phuck",
+	"phuk",
+	"phuked",
+	"phuking",
+	"phukked",
+	"phukking",
+	"phuks",
+	"phuq",
+	"pigfucker",
+	"pimpis",
+	"piss",
+	"pissed",
+	"pisser",
+	"pissers",
+	"pisses",
+	"pissflaps",
+	"pissin",
+	"pissing",
+	"pissoff",
+	"poop",
+	"porn",
+	"porno",
+	"pornography",
+	"pornos",
+	"prick",
+	"pricks",
+	"pron",
+	"pube",
+	"pusse",
+	"pussi",
+	"pussies",
+	"pussy",
+	"pussys",
+	"rectum",
+	"retard",
+	"rimjaw",
+	"rimming",
+	"s hit",
+	"s.o.b.",
+	"sadist",
+	"schlong",
+	"screwing",
+	"scroat",
+	"scrote",
+	"scrotum",
+	"semen",
+	"sex",
+	"sh!+",
+	"sh!t",
+	"sh1t",
+	"shag",
+	"shagger",
+	"shaggin",
+	"shagging",
+	"shemale",
+	"shi+",
+	"shit",
+	"shitdick",
+	"shite",
+	"shited",
+	"shitey",
+	"shitfuck",
+	"shitfull",
+	"shithead",
+	"shiting",
+	"shitings",
+	"shits",
+	"shitted",
+	"shitter",
+	"shitters",
+	"shitting",
+	"shittings",
+	"shitty",
+	"skank",
+	"slut",
+	"sluts",
+	"smegma",
+	"smut",
+	"snatch",
+	"son-of-a-bitch",
+	"spac",
+	"spunk",
+	"s_h_i_t",
+	"t1tt1e5",
+	"t1tties",
+	"teets",
+	"teez",
+	"testical",
+	"testicle",
+	"tit",
+	"titfuck",
+	"tits",
+	"titt",
+	"tittie5",
+	"tittiefucker",
+	"titties",
+	"tittyfuck",
+	"tittywank",
+	"titwank",
+	"tosser",
+	"turd",
+	"tw4t",
+	"twat",
+	"twathead",
+	"twatty",
+	"twunt",
+	"twunter",
+	"v14gra",
+	"v1gra",
+	"vagina",
+	"viagra",
+	"vulva",
+	"w00se",
+	"wang",
+	"wank",
+	"wanker",
+	"wanky",
+	"whoar",
+	"whore",
+	"willies",
+	"willy"
+];
+//#endregion
+//#region src/services/profanity/checkContainsProfanity.ts
+const WORD_CHARACTER_CLASS = String.raw`\p{L}\p{N}\p{M}`;
+const PROFANE_WORD_ALTERNATION = englishProfaneWords.map((word) => word.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`)).join("|");
+const WHOLE_WORD_PROFANITY_REGEX = new RegExp(`(?<![${WORD_CHARACTER_CLASS}])(?:${PROFANE_WORD_ALTERNATION})(?![${WORD_CHARACTER_CLASS}])`, "iu");
+const SUBSTRING_PROFANITY_REGEX = new RegExp(PROFANE_WORD_ALTERNATION, "iu");
+const checkContainsProfanity = (text, { isWholeWord = true } = {}) => {
+	if (typeof text !== "string") return false;
+	return (isWholeWord ? WHOLE_WORD_PROFANITY_REGEX : SUBSTRING_PROFANITY_REGEX).test(text);
+};
+//#endregion
+//#region src/services/sanitizeHtml/checkIsWhitespaceCharacter.ts
+const checkIsWhitespaceCharacter = (character) => character.trim() === "";
+//#endregion
+//#region src/services/sanitizeHtml/checkIsUnsafeUrlCharacter.ts
+const FIRST_PRINTABLE_CODE_POINT = 32;
+const DELETE_CODE_POINT = 127;
+const LAST_C1_CONTROL_CODE_POINT = 159;
+const GRAVE_ACCENT = "`";
+const checkIsUnsafeUrlCharacter = (character) => {
+	const codePoint = character.codePointAt(0) ?? 0;
+	return checkIsWhitespaceCharacter(character) || codePoint < FIRST_PRINTABLE_CODE_POINT || codePoint >= DELETE_CODE_POINT && codePoint <= LAST_C1_CONTROL_CODE_POINT || character === GRAVE_ACCENT;
+};
+//#endregion
+//#region src/util/array/takeOne.ts
+const takeOne = (values, index = 0) => {
+	return values[index];
+};
+//#endregion
+//#region src/services/sanitizeHtml/checkIsAllowedUrl.ts
+const PATH_DELIMITER_REGEX = /[/?#]/u;
+const NON_SCHEME_CHARACTERS_REGEX = /[^a-z\d+.-]/giu;
+const SCHEME_SEPARATOR = ":";
+const checkIsAllowedUrl = (url, allowedSchemes) => {
+	const normalizedUrl = url.split("").filter((character) => !checkIsUnsafeUrlCharacter(character)).join("");
+	const beforePath = takeOne(normalizedUrl.split(PATH_DELIMITER_REGEX), 0);
+	const separatorIndex = beforePath.indexOf(SCHEME_SEPARATOR);
+	if (separatorIndex === -1) return true;
+	const scheme = beforePath.slice(0, separatorIndex).replaceAll(NON_SCHEME_CHARACTERS_REGEX, "").toLowerCase();
+	return allowedSchemes.includes(scheme);
+};
+//#endregion
+//#region src/services/sanitizeHtml/constants.ts
+const HTML_NAMESPACE = html$1.NS.HTML;
+const DEFAULT_ALLOWED_TAGS = [
+	"address",
+	"article",
+	"aside",
+	"footer",
+	"header",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"hgroup",
+	"main",
+	"nav",
+	"section",
+	"blockquote",
+	"dd",
+	"div",
+	"dl",
+	"dt",
+	"figcaption",
+	"figure",
+	"hr",
+	"li",
+	"menu",
+	"ol",
+	"p",
+	"pre",
+	"ul",
+	"a",
+	"abbr",
+	"b",
+	"bdi",
+	"bdo",
+	"br",
+	"cite",
+	"code",
+	"data",
+	"dfn",
+	"em",
+	"i",
+	"kbd",
+	"mark",
+	"q",
+	"rb",
+	"rp",
+	"rt",
+	"rtc",
+	"ruby",
+	"s",
+	"samp",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"u",
+	"var",
+	"wbr",
+	"caption",
+	"col",
+	"colgroup",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr"
+];
+const DEFAULT_LINK_ATTRIBUTES = [
+	"href",
+	"name",
+	"target"
+];
+const DEFAULT_ALLOWED_ATTRIBUTES = { a: DEFAULT_LINK_ATTRIBUTES };
+const DEFAULT_ALLOWED_SCHEMES = [
+	"http",
+	"https",
+	"ftp",
+	"mailto",
+	"tel"
+];
+const NON_TEXT_TAGS = [
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"option",
+	"plaintext",
+	"script",
+	"style",
+	"textarea",
+	"title",
+	"xmp"
+];
+const VOID_TAGS = [
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+];
+const URL_ATTRIBUTES = [
+	"action",
+	"background",
+	"cite",
+	"data",
+	"formaction",
+	"href",
+	"icon",
+	"longdesc",
+	"manifest",
+	"poster",
+	"src"
+];
+const SRCSET_ATTRIBUTE = "srcset";
+const IMPORTANT_REGEX = /!\s*important$/iu;
+const MAX_NESTING_DEPTH = 256;
+const SRCSET_DESCRIPTOR_REGEX = /^(?:\d+w|\d*\.?\d+x|\d+h)$/u;
+const ESCAPED_TEXT_CHARACTERS_REGEX = /[&<>]/gu;
+const ESCAPED_ATTRIBUTE_CHARACTERS_REGEX = /[&"<>]/gu;
+const SANITIZER_ADVISORY_WATCH_SINCE = "2026-10-21";
+//#endregion
+//#region src/services/sanitizeHtml/getChildNodes.ts
+const getChildNodes = (element) => "content" in element ? element.content.childNodes : element.childNodes;
+//#endregion
+//#region src/services/sanitizeHtml/collectText.ts
+const collectText = (nodes, depth) => depth > 256 ? "" : nodes.map((node) => {
+	if ("value" in node) return node.value;
+	if (!("tagName" in node) || NON_TEXT_TAGS.includes(node.tagName)) return "";
+	return collectText(getChildNodes(node), depth + 1);
+}).join("");
+//#endregion
+//#region src/services/sanitizeHtml/escapeCharacters.ts
+const NON_BREAKING_SPACE = String.fromCodePoint(160);
+const escapeCharacters = (value, charactersRegex, entities) => value.replace(charactersRegex, (character) => entities[character] ?? character).replaceAll(NON_BREAKING_SPACE, "&nbsp;");
+//#endregion
+//#region src/services/sanitizeHtml/escapeAttribute.ts
+const ESCAPED_ATTRIBUTE_CHARACTERS = {
+	"\"": "&quot;",
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const escapeAttribute = (value) => escapeCharacters(value, ESCAPED_ATTRIBUTE_CHARACTERS_REGEX, ESCAPED_ATTRIBUTE_CHARACTERS);
+//#endregion
+//#region src/services/sanitizeHtml/escapeText.ts
+const ESCAPED_TEXT_CHARACTERS = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;"
+};
+const escapeText = (text) => escapeCharacters(text, ESCAPED_TEXT_CHARACTERS_REGEX, ESCAPED_TEXT_CHARACTERS);
+//#endregion
+//#region src/services/sanitizeHtml/matchesClassPattern.ts
+const matchesClassPattern = (className, pattern) => pattern.endsWith("*") ? className.startsWith(pattern.slice(0, -1)) : className === pattern;
+//#endregion
+//#region src/services/sanitizeHtml/filterClasses.ts
+const filterClasses = (value, patterns) => {
+	if (!patterns) return void 0;
+	const classNames = value.split(/\s+/u).filter((className) => className && patterns.some((pattern) => matchesClassPattern(className, pattern)));
+	return classNames.length > 0 ? classNames.join(" ") : void 0;
+};
+//#endregion
+//#region src/services/sanitizeHtml/filterSrcset.ts
+const COMMA = ",";
+const OPENING_PARENTHESIS = "(";
+const CLOSING_PARENTHESIS = ")";
+const filterSrcset = (value, allowedSchemes) => {
+	const candidates = [];
+	let position = 0;
+	while (position < value.length) {
+		while (position < value.length && (checkIsWhitespaceCharacter(value.charAt(position)) || value.charAt(position) === COMMA)) position++;
+		const urlStart = position;
+		while (position < value.length && !checkIsWhitespaceCharacter(value.charAt(position))) position++;
+		let url = value.slice(urlStart, position);
+		let descriptorText = "";
+		if (url.endsWith(COMMA)) url = url.replace(/,+$/u, "");
+		else {
+			const descriptorStart = position;
+			let isInParentheses = false;
+			while (position < value.length && (isInParentheses || value.charAt(position) !== COMMA)) {
+				if (value.charAt(position) === OPENING_PARENTHESIS) isInParentheses = true;
+				else if (value.charAt(position) === CLOSING_PARENTHESIS) isInParentheses = false;
+				position++;
+			}
+			descriptorText = value.slice(descriptorStart, position);
+			position++;
+		}
+		const descriptors = descriptorText.trim().split(/\s+/u).filter(Boolean);
+		if (!url || !checkIsAllowedUrl(url, allowedSchemes)) continue;
+		if (descriptors.length > 1 || descriptors.some((descriptor) => !SRCSET_DESCRIPTOR_REGEX.test(descriptor))) continue;
+		candidates.push([url, ...descriptors].join(" "));
+	}
+	return candidates.length > 0 ? candidates.join(", ") : void 0;
+};
+//#endregion
+//#region src/services/sanitizeHtml/filterStyle.ts
+const DECLARATION_SEPARATOR = ";";
+const PROPERTY_SEPARATOR = ":";
+const IMPORTANT_SUFFIX = "!important";
+const filterStyle = (value, rules) => {
+	if (!rules) return void 0;
+	const declarations = /* @__PURE__ */ new Map();
+	for (const declaration of value.split(DECLARATION_SEPARATOR)) {
+		const separatorIndex = declaration.indexOf(PROPERTY_SEPARATOR);
+		if (separatorIndex === -1) continue;
+		const property = declaration.slice(0, separatorIndex).trim().toLowerCase();
+		if (!Object.hasOwn(rules, property)) continue;
+		const rawValue = declaration.slice(separatorIndex + 1).trim();
+		const important = IMPORTANT_REGEX.test(rawValue);
+		const propertyValue = rawValue.replace(IMPORTANT_REGEX, "").trim();
+		if (!(rules[property] ?? []).some((rule) => rule.test(propertyValue))) continue;
+		if (declarations.get(property)?.important && !important) continue;
+		declarations.set(property, {
+			important,
+			propertyValue
+		});
+	}
+	if (declarations.size === 0) return void 0;
+	return Array.from(declarations, ([property, { important, propertyValue }]) => `${property}${PROPERTY_SEPARATOR}${propertyValue}${important ? IMPORTANT_SUFFIX : ""}`).join(DECLARATION_SEPARATOR);
+};
+//#endregion
+//#region src/services/sanitizeHtml/filterAttributes.ts
+const getTagPolicy = (tagPolicies, tagName) => Object.hasOwn(tagPolicies, tagName) ? tagPolicies[tagName] : void 0;
+const checkIsMetaRefresh = (tagName, attributes) => tagName === "meta" && attributes["http-equiv"]?.trim().toLowerCase() === "refresh";
+const filterAttributes = (element, policy) => {
+	const { tagName } = element;
+	const allowedAttributes = getTagPolicy(policy.allowedAttributes, tagName) ?? [];
+	const isClassAllowed = Object.hasOwn(policy.allowedClasses, tagName);
+	const parsedAttributes = Object.fromEntries(element.attrs.map(({ name, value }) => [name, value]));
+	const transform = getTagPolicy(policy.transformAttributes, tagName);
+	const attributes = transform ? transform(parsedAttributes) : parsedAttributes;
+	const kept = {};
+	for (const [name, value] of Object.entries(attributes)) {
+		if (name === "class" ? !isClassAllowed : !allowedAttributes.includes(name)) continue;
+		if (name === "content" && checkIsMetaRefresh(tagName, attributes)) continue;
+		const filteredValue = filterValue(tagName, name, value, policy);
+		if (filteredValue !== void 0) kept[name] = filteredValue;
+	}
+	return kept;
+};
+const filterValue = (tagName, name, value, policy) => {
+	if (name === "style") return filterStyle(value, getTagPolicy(policy.allowedStyles, tagName));
+	if (name === "class") return filterClasses(value, getTagPolicy(policy.allowedClasses, tagName));
+	if (name === "srcset") return filterSrcset(value, policy.allowedSchemes);
+	if (URL_ATTRIBUTES.includes(name)) return checkIsAllowedUrl(value, policy.allowedSchemes) ? value : void 0;
+	return value;
+};
+//#endregion
+//#region src/services/sanitizeHtml/renderNode.ts
+const renderNode = (node, policy, depth) => {
+	if (node.nodeName === "#text") return escapeText(node.value);
+	if (!("tagName" in node) || depth > 256) return "";
+	const element = node;
+	const children = getChildNodes(element).map((child) => renderNode(child, policy, depth + 1)).join("");
+	if (!(element.namespaceURI === HTML_NAMESPACE && !NON_TEXT_TAGS.includes(element.tagName) && policy.allowedTags.includes(element.tagName))) return NON_TEXT_TAGS.includes(element.tagName) ? "" : children;
+	const attributes = Object.entries(filterAttributes(element, policy)).map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`).join("");
+	const opening = `<${element.tagName}${attributes}>`;
+	return VOID_TAGS.includes(element.tagName) ? opening : `${opening}${children}</${element.tagName}>`;
+};
+//#endregion
+//#region src/services/sanitizeHtml/filterHtml.ts
+const filterHtml = (html, policy) => {
+	const context = defaultTreeAdapter.createElement("body", HTML_NAMESPACE, []);
+	const childNodes = parseFragment(context, html, {}).childNodes;
+	const output = childNodes.map((node) => renderNode(node, policy, 0)).join("");
+	return parseFragment(context, output, {}).childNodes.map((node) => renderNode(node, policy, 0)).join("") === output ? output : escapeText(collectText(childNodes, 0));
+};
+//#endregion
+//#region src/services/sanitizeHtml/sanitizeHtml.ts
+const appendStyle = (style, declarations) => style ? `${style}; ${declarations}` : declarations;
+const transformCellAlign = ({ align, ...attributes }) => align ? {
+	...attributes,
+	style: appendStyle(attributes.style, `text-align:${align}`)
+} : attributes;
+const transformLink = (attributes) => ({
+	...attributes,
+	rel: "noopener noreferrer nofollow",
+	target: "_blank"
+});
+const transformTable = (attributes) => ({
+	...attributes,
+	style: appendStyle(attributes.style, "width:100%; border-collapse: collapse;")
+});
+const TEXT_ALIGN_REGEXES = [/^(?:left|right|center|justify)$/u];
+const TABLE_ALLOWED_STYLES = {
+	table: {
+		"border-collapse": [/^collapse$/u],
+		width: [/^100%$/u]
+	},
+	td: { "text-align": TEXT_ALIGN_REGEXES },
+	th: { "text-align": TEXT_ALIGN_REGEXES }
+};
+const sanitizeHtml = (html, options) => filterHtml(html, {
+	allowedAttributes: {
+		...options?.allowedAttributes ?? DEFAULT_ALLOWED_ATTRIBUTES,
+		a: [.../* @__PURE__ */ new Set([
+			...options?.allowedAttributes?.a ?? DEFAULT_LINK_ATTRIBUTES,
+			"href",
+			"rel",
+			"target"
+		])],
+		table: ["style"],
+		td: ["style"],
+		th: ["style"]
+	},
+	allowedClasses: options?.allowedClasses ?? {},
+	allowedSchemes: DEFAULT_ALLOWED_SCHEMES,
+	allowedStyles: {
+		...options?.allowedStyles,
+		...TABLE_ALLOWED_STYLES
+	},
+	allowedTags: options?.allowedTags ?? DEFAULT_ALLOWED_TAGS,
+	transformAttributes: {
+		...options?.transformAttributes,
+		a: transformLink,
+		table: transformTable,
+		td: transformCellAlign,
+		th: transformCellAlign
+	}
+});
+//#endregion
+//#region src/services/sanitizeHtml/sanitizeTextHtml.ts
+const COLOR_REGEXES = [
+	/^#[\da-fA-F]{3,8}$/u,
+	/^rgba?\(\d{1,3},\s*\d{1,3},\s*\d{1,3}(?:,\s*[\d.]+)?\)$/u,
+	/^[a-z]+$/iu
+];
+const sanitizeTextHtml = (html) => sanitizeHtml(html, {
+	allowedAttributes: {
+		input: [
+			"checked",
+			"disabled",
+			"type"
+		],
+		li: ["data-checked", "data-type"],
+		span: [
+			CUSTOM_EMOJI_ID_ATTRIBUTE,
+			CUSTOM_EMOJI_NAME_ATTRIBUTE,
+			MENTION_ID_ATTRIBUTE,
+			MENTION_ITEM_TYPE_ATTRIBUTE,
+			MENTION_LABEL_ATTRIBUTE,
+			MENTION_TYPE_ATTRIBUTE,
+			SPOILER_ATTRIBUTE,
+			"style"
+		],
+		ul: ["data-type"]
+	},
+	allowedClasses: {
+		code: ["language-*"],
+		pre: ["language-*"],
+		span: ["hljs*"]
+	},
+	allowedStyles: { span: {
+		"background-color": COLOR_REGEXES,
+		"border-radius": [/^[\d.]+(?<unit>px|em|rem|%)$/u],
+		color: COLOR_REGEXES
+	} },
+	allowedTags: [
+		...DEFAULT_ALLOWED_TAGS,
+		"input",
+		"label"
+	],
+	transformAttributes: { input: ({ checked }) => ({
+		...checked === void 0 ? {} : { checked },
+		disabled: "",
+		type: "checkbox"
+	}) }
+});
+//#endregion
+//#region src/services/shared/applyItemMetadataMixin.ts
+const applyItemMetadataMixin = (Base) => class ItemWithMetadata extends Base {
+	createdAt = /* @__PURE__ */ new Date();
+	deletedAt = null;
+	updatedAt = /* @__PURE__ */ new Date();
+};
+//#endregion
+//#region src/util/text/normalizeString.ts
+const normalizeString = (value) => value?.trim() ?? "";
+//#endregion
+//#region src/services/zod/createNormalizedStringSchema.ts
+const createNormalizedStringSchema = (maxLength, schema = z.string()) => schema.transform(normalizeString).pipe(z.string().max(maxLength));
+//#endregion
+//#region src/util/id/constants.ts
+const ID_SEPARATOR = "|";
+//#endregion
+//#region src/services/zod/createUniqueArraySchema.ts
+const getItemKey = (item, key) => {
+	const record = item;
+	return typeof key === "string" ? record[key] : key.map((part) => record[part]).join("|");
+};
+const createUniqueArraySchema = (schema, key) => schema.array().refine((array) => new Set(key === void 0 ? array : array.map((item) => getItemKey(item, key))).size === array.length, { error: "Array items must be unique" });
+//#endregion
+//#region src/services/zstd/constants.ts
+const DEFAULT_COMPRESSION_LEVEL = 12;
+const MIN_WINDOW_LOG = 10;
+const MAX_WINDOW_LOG = 27;
+//#endregion
+//#region src/services/zstd/getWindowLog.ts
+const getWindowLog = (dictionaryByteCount, inputByteCount) => Math.min(27, Math.max(10, Math.ceil(Math.log2(dictionaryByteCount + inputByteCount + 1))));
+//#endregion
+//#region src/test/constants.ts
+const ALL_SPECIAL_VALUES = [
+	{
+		isPlainObject: true,
+		value: {}
+	},
+	{
+		isPlainObject: true,
+		value: Object.create(null)
+	},
+	{
+		isPlainObject: false,
+		value: []
+	},
+	{
+		isPlainObject: false,
+		value: /* @__PURE__ */ new Date()
+	},
+	{
+		isPlainObject: false,
+		value: null
+	},
+	{
+		isPlainObject: false,
+		value: void 0
+	},
+	{
+		isPlainObject: false,
+		value: ""
+	},
+	{
+		isPlainObject: false,
+		value: 0
+	},
+	{
+		isPlainObject: false,
+		value: Symbol("")
+	},
+	{
+		isPlainObject: false,
+		value: noop
+	},
+	{
+		isPlainObject: false,
+		value: /(?:)/u
+	}
+];
+//#endregion
+//#region src/util/array/chunk.ts
+const chunk = (array, size) => {
+	const chunks = [];
+	for (let index = 0; index < array.length; index += size) chunks.push(array.slice(index, index + size));
+	return chunks;
+};
+//#endregion
+//#region src/util/array/chunkBySerializedSize.ts
+const ARRAY_SERIALIZATION_BYTES = 1;
+const chunkBySerializedSize = (items, maxBytes, maxCount) => {
+	const textEncoder = new TextEncoder();
+	const chunks = [];
+	let currentChunk = [];
+	let currentBytes = ARRAY_SERIALIZATION_BYTES;
+	for (const item of items) {
+		const itemBytes = textEncoder.encode(JSON.stringify(item)).length + 1;
+		if (currentChunk.length > 0 && (currentChunk.length === maxCount || currentBytes + itemBytes > maxBytes)) {
+			chunks.push(currentChunk);
+			currentChunk = [];
+			currentBytes = ARRAY_SERIALIZATION_BYTES;
+		}
+		currentChunk.push(item);
+		currentBytes += itemBytes;
+	}
+	if (currentChunk.length > 0) chunks.push(currentChunk);
+	return chunks;
+};
+//#endregion
+//#region src/util/array/takeRandom.ts
+const takeRandom = (values, random) => takeOne(values, Math.floor(random() * values.length));
+//#endregion
+//#region src/util/date/getZonedDateTime.ts
+const getZonedDateTime = (date) => Temporal.Instant.fromEpochMilliseconds(date.getTime()).toZonedDateTimeISO(Temporal.Now.timeZoneId());
+//#endregion
+//#region src/util/date/getEndOfDay.ts
+const getEndOfDay = (date) => /* @__PURE__ */ new Date(getZonedDateTime(date).startOfDay().add({ days: 1 }).epochMilliseconds - 1);
+//#endregion
+//#region src/util/dom/checkIsNestedControl.ts
+const NESTED_INTERACTION_SELECTOR = [
+	"a[href]",
+	"button",
+	"dialog",
+	"input",
+	"label",
+	"select",
+	"summary",
+	"textarea",
+	"[contenteditable='']",
+	"[contenteditable='plaintext-only']",
+	"[contenteditable='true']",
+	"[data-nested-interaction]",
+	"[role='button']",
+	"[role='checkbox']",
+	"[role='dialog']",
+	"[role='link']",
+	"[role='menu']",
+	"[role='menuitem']",
+	"[role='option']",
+	"[role='switch']",
+	"[role='tab']"
+].join(", ");
+const checkIsNestedControl = (event) => {
+	const { currentTarget, target } = event;
+	if (!(currentTarget instanceof Element) || !(target instanceof Element)) return false;
+	const interactiveElement = target.closest(NESTED_INTERACTION_SELECTOR);
+	return Boolean(interactiveElement && interactiveElement !== currentTarget && currentTarget.contains(interactiveElement));
+};
+//#endregion
+//#region src/util/dom/checkIsNestedInteraction.ts
+const checkIsNestedInteraction = (event) => checkIsNestedControl(event) || Boolean(window.getSelection()?.toString());
+//#endregion
+//#region src/util/dom/downloadUrl.ts
+const downloadUrl = (url, filename) => {
+	const anchor = window.document.createElement("a");
+	anchor.href = url;
+	anchor.download = filename;
+	anchor.click();
+};
+//#endregion
+//#region src/util/dom/downloadFile.ts
+const downloadFile = (filename, blobPart, type) => {
+	const url = URL.createObjectURL(new Blob([blobPart], { type }));
+	downloadUrl(url, filename);
+	window.setTimeout(() => {
+		URL.revokeObjectURL(url);
+	}, 0);
+};
+//#endregion
+//#region src/util/environment/checkIsServer.ts
+const checkIsServer = () => typeof window === "undefined";
+//#endregion
+//#region src/util/function/getSynchronizedFunction.ts
+const pendingPromises = /* @__PURE__ */ new Set();
+const getSynchronizedFunction = (asyncFunction) => (...args) => {
+	const promise = asyncFunction(...args).finally(() => {
+		pendingPromises.delete(promise);
+	});
+	pendingPromises.add(promise);
+};
+const waitForSynchronizedFunctions = async () => {
+	await Promise.allSettled(pendingPromises);
+};
+//#endregion
+//#region src/util/id/uuid/constants.ts
+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/map/getOrCreate.ts
+const getOrCreate = (map, key, create) => {
+	if (map.has(key)) return map.get(key);
+	const value = create();
+	map.set(key, value);
+	return value;
+};
+//#endregion
+//#region src/util/object/clonePlainDeep.ts
+const clone = (data, copies) => {
+	if (!Array.isArray(data) && !checkIsPlainObject(data)) return data;
+	else if (copies.has(data)) return copies.get(data);
+	else if (Array.isArray(data)) {
+		const copy = [];
+		copies.set(data, copy);
+		for (const [index, item] of data.entries()) copy[index] = clone(item, copies);
+		return copy;
+	} else {
+		const copy = {};
+		copies.set(data, copy);
+		for (const [key, value] of Object.entries(data)) copy[key] = clone(value, copies);
+		return copy;
+	}
+};
+const clonePlainDeep = (data) => clone(data, /* @__PURE__ */ new WeakMap());
+//#endregion
+//#region src/util/object/getPropertyNames.ts
+const getPropertyNames = () => new Proxy({}, { get: (_target, property) => property });
+//#endregion
+//#region src/util/object/jsonDateParse.ts
+const ISO_DATE_REGEX = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hours>\d{2}):(?<minutes>\d{2}):(?<seconds>\d{2}(?:\.{0,1}\d*))(?:Z|(?<sign>\+|-)(?<offset>[\d|:]*))?$/u;
+const MS_AJAX_DATE_REGEX = /^\/Date\((?<timestamp>-?\d+(?:[-+]\d+)?)\)[/\\]$/u;
+const jsonDateParse = (text) => JSON.parse(text, (_key, value) => {
+	if (typeof value !== "string") return value;
+	else if (ISO_DATE_REGEX.test(value)) return new Date(value);
+	const msAjaxDateMatch = MS_AJAX_DATE_REGEX.exec(value);
+	if (!msAjaxDateMatch) return value;
+	const timestampParts = takeOne(msAjaxDateMatch, 1).split(/[-+,.]/u);
+	return new Date(timestampParts[0] ? Number(timestampParts[0]) : 0 - Number(timestampParts[1]));
+});
+//#endregion
+//#region src/util/object/mergeObjectsStrict.ts
+const mergeObjectsStrict = (...objects) => Object.assign({}, ...objects);
+//#endregion
+//#region src/util/object/omitDeep.ts
+const checkIsWalkable = (value) => Object.prototype.toString.call(value) === "[object Object]";
+const omitValue = (value, omittedKeys) => {
+	if (Array.isArray(value)) return value.map((element) => omitValue(element, omittedKeys));
+	if (!checkIsWalkable(value)) return value;
+	const omittedValue = {};
+	for (const [key, propertyValue] of Object.entries(value)) if (!omittedKeys.has(key)) omittedValue[key] = omitValue(propertyValue, omittedKeys);
+	return omittedValue;
+};
+const omitDeep = (value, ...keys) => omitValue(value, new Set(keys));
+//#endregion
+//#region src/util/promise/createEvictingPromiseCache.ts
+const createEvictingPromiseCache = (getKey, load) => {
+	const promiseMap = /* @__PURE__ */ new Map();
+	return (...args) => {
+		const key = getKey(...args);
+		const promise = promiseMap.get(key) ?? load(...args);
+		promiseMap.set(key, promise);
+		return getResultAsync(() => promise).match((value) => value, (error) => {
+			if (promiseMap.get(key) === promise) promiseMap.delete(key);
+			throw error;
+		});
+	};
+};
+//#endregion
+//#region src/util/promise/settleAll.ts
+const settleAll = async (tasks, concurrencyLimit = tasks.length) => {
+	if (tasks.length === 0) return [];
+	const values = [];
+	for (const tasksChunk of chunk(tasks, concurrencyLimit)) {
+		const results = await Promise.allSettled(tasksChunk.map((task) => Promise.try(task)));
+		const reasons = [];
+		for (const result of results) if (result.status === "rejected") reasons.push(result.reason);
+		else values.push(result.value);
+		if (reasons.length === 1) throw takeOne(reasons);
+		else if (reasons.length > 1) throw new AggregateError(reasons, toAppError(takeOne(reasons)).message);
+	}
+	return values;
+};
+//#endregion
+//#region src/util/text/capitalize.ts
+const capitalize = (string) => `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
+//#endregion
+//#region src/util/text/dedent.ts
+const ESCAPE_CHARACTER = "\\";
+const LINE_FEED = "\n";
+const LINE_FEED_CHARACTER = {
+	escapable: false,
+	value: LINE_FEED
+};
+const HEXADECIMAL_REGEX = /^[\da-fA-F]$/u;
+const WHITESPACE_REGEX = /^\s$/u;
+const BRACED_CODE_POINT_MAXIMUM_DIGITS = 6;
+const CODE_POINT_MAXIMUM = 1114111;
+const HEXADECIMAL_BYTE_DIGITS = 2;
+const HEXADECIMAL_UNIT_DIGITS = 4;
+const escapeValueMap = {
+	"0": "\0",
+	$: "$",
+	"\\": "\\",
+	"`": "`",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	",
+	v: "\v",
+	"{": "{"
+};
+const toCharacters = (text, escapable) => text.split("").map((value) => ({
+	escapable,
+	value
+}));
+const isWhitespace = (character) => WHITESPACE_REGEX.test(character.value);
+const alignValue = (value, precedingText) => {
+	const currentLine = precedingText.slice(precedingText.lastIndexOf(LINE_FEED) + 1);
+	const indentation = /^\s+/u.exec(currentLine)?.[0];
+	return indentation ? value.replaceAll(LINE_FEED, `${LINE_FEED}${indentation}`) : value;
+};
+const isEscapeStart = (characters, index) => {
+	const character = characters[index];
+	const next = characters[index + 1];
+	return character?.escapable === true && character.value === ESCAPE_CHARACTER && next?.escapable === true;
+};
+const removeLineContinuations = (characters) => {
+	const result = [];
+	let index = 0;
+	while (index < characters.length) {
+		const character = characters[index];
+		if (!character) break;
+		if (isEscapeStart(characters, index)) {
+			const next = characters[index + 1];
+			if (next?.value === LINE_FEED) {
+				index += 2;
+				while (characters[index]?.escapable === true && (characters[index]?.value === " " || characters[index]?.value === "	")) index++;
+			} else {
+				result.push(character, ...next ? [next] : []);
+				index += 2;
+			}
+		} else {
+			result.push(character);
+			index++;
+		}
+	}
+	return result;
+};
+const splitLines = (characters) => {
+	const lines = [];
+	let line = [];
+	for (const character of characters) if (character.value === LINE_FEED) {
+		lines.push(line);
+		line = [];
+	} else line.push(character);
+	lines.push(line);
+	return lines;
+};
+const getIndentation = (line) => {
+	const indentation = line.findIndex((character) => !isWhitespace(character));
+	return indentation > 0 ? indentation : void 0;
+};
+const dedentCharacters = (characters) => {
+	const lines = splitLines(characters);
+	const indentations = lines.map((line) => getIndentation(line)).filter((indentation) => indentation !== void 0);
+	if (indentations.length === 0) return characters;
+	const minimumIndentation = Math.min(...indentations);
+	const result = [];
+	for (const [index, line] of lines.entries()) {
+		if (index > 0) result.push(LINE_FEED_CHARACTER);
+		const first = line[0]?.value;
+		result.push(...first === " " || first === "	" ? line.slice(minimumIndentation) : line);
+	}
+	return result;
+};
+const trimCharacters = (characters) => {
+	const start = characters.findIndex((character) => !isWhitespace(character));
+	if (start === -1) return [];
+	return characters.slice(start, characters.findLastIndex((character) => !isWhitespace(character)) + 1);
+};
+const readHexadecimal = (characters, start, digits) => {
+	let hexadecimal = "";
+	for (let index = start; index < start + digits; index++) {
+		const character = characters[index];
+		if (character?.escapable !== true || !HEXADECIMAL_REGEX.test(character.value)) return void 0;
+		hexadecimal += character.value;
+	}
+	return hexadecimal;
+};
+const readBracedCodePoint = (characters, index) => {
+	if (characters[index + 2]?.value !== "{") return void 0;
+	let digits = "";
+	let cursor = index + 3;
+	while (digits.length < BRACED_CODE_POINT_MAXIMUM_DIGITS && HEXADECIMAL_REGEX.test(characters[cursor]?.value ?? "")) {
+		digits += characters[cursor]?.value;
+		cursor++;
+	}
+	const closing = characters[cursor];
+	if (digits.length === 0 || closing?.escapable !== true || closing.value !== "}") return void 0;
+	const codePoint = Number.parseInt(digits, 16);
+	if (codePoint > CODE_POINT_MAXIMUM) return void 0;
+	return {
+		length: cursor - index + 1,
+		text: String.fromCodePoint(codePoint)
+	};
+};
+const fromHexadecimal = (hexadecimal) => String.fromCodePoint(Number.parseInt(hexadecimal, 16));
+const readEscape = (characters, index) => {
+	const character = characters[index];
+	if (!character) return {
+		length: 0,
+		text: ""
+	};
+	if (!isEscapeStart(characters, index)) return {
+		length: 1,
+		text: character.value
+	};
+	const next = characters[index + 1];
+	const escapeValue = next ? escapeValueMap[next.value] : void 0;
+	if (escapeValue !== void 0) return {
+		length: 2,
+		text: escapeValue
+	};
+	if (next?.value === "x") {
+		const hexadecimal = readHexadecimal(characters, index + 2, HEXADECIMAL_BYTE_DIGITS);
+		if (hexadecimal !== void 0) return {
+			length: 4,
+			text: fromHexadecimal(hexadecimal)
+		};
+	}
+	if (next?.value === "u") {
+		const braced = readBracedCodePoint(characters, index);
+		if (braced) return braced;
+		const hexadecimal = readHexadecimal(characters, index + 2, HEXADECIMAL_UNIT_DIGITS);
+		if (hexadecimal !== void 0) return {
+			length: 6,
+			text: fromHexadecimal(hexadecimal)
+		};
+	}
+	return {
+		length: 1,
+		text: character.value
+	};
+};
+const cookCharacters = (characters) => {
+	let result = "";
+	let index = 0;
+	while (index < characters.length) {
+		const cooked = readEscape(characters, index);
+		result += cooked.text;
+		index += cooked.length;
+	}
+	return result;
+};
+const createDedent = (options) => {
+	const dedent = (strings, ...values) => {
+		const isTemplate = typeof strings !== "string";
+		const raws = isTemplate ? strings.raw : [strings];
+		const { alignValues = false, escapeSpecialCharacters = isTemplate, trimWhitespace = true } = options;
+		let precedingText = "";
+		const parts = [];
+		for (const [index, raw] of raws.entries()) {
+			parts.push(toCharacters(raw, true));
+			precedingText += raw;
+			if (index < values.length) {
+				const value = String(values[index]);
+				const alignedValue = alignValues ? alignValue(value, precedingText) : value;
+				parts.push(toCharacters(alignedValue, false));
+				precedingText += alignedValue;
+			}
+		}
+		let characters = parts.flat();
+		if (escapeSpecialCharacters) characters = removeLineContinuations(characters);
+		characters = dedentCharacters(characters);
+		if (trimWhitespace) characters = trimCharacters(characters);
+		return escapeSpecialCharacters ? cookCharacters(characters) : characters.map((character) => character.value).join("");
+	};
+	dedent.withOptions = (newOptions) => createDedent({
+		...options,
+		...newOptions
+	});
+	return dedent;
+};
+const dedent = createDedent({});
+//#endregion
+//#region src/util/text/encodeUrlSubDelimiters.ts
+const EncodedSubDelimiterMap = {
+	"!": "%21",
+	"'": "%27",
+	"(": "%28",
+	")": "%29",
+	"*": "%2A"
+};
+const encodeUrlSubDelimiters = (value) => Object.entries(EncodedSubDelimiterMap).reduce((encoded, [subDelimiter, encodedSubDelimiter]) => encoded.replaceAll(subDelimiter, encodedSubDelimiter), value);
+//#endregion
+//#region src/util/text/getDecodedUriComponent.ts
+const getDecodedUriComponent = (value, fallback) => getResult(() => decodeURIComponent(value)).unwrapOr(fallback);
+//#endregion
+//#region src/util/text/streamToText.ts
+const streamToText = async (readable) => {
+	readable.setEncoding("utf8");
+	let data = "";
+	for await (const chunk of readable) data += chunk.toString();
+	return data;
+};
+//#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]+/gu)?.map((x) => x.toLowerCase()).join("-") ?? "";
+//#endregion
+//#region src/util/text/truncate.ts
+const SUFFIX = "...";
+const truncate = (string, length) => {
+	if (string.length <= length) return string;
+	else if (length < 3) return string.slice(0, length);
+	else return `${string.slice(0, length - 3)}${SUFFIX}`;
+};
+//#endregion
+//#region src/util/text/uncapitalize.ts
+const uncapitalize = (string) => `${string.charAt(0).toLowerCase()}${string.slice(1)}`;
+//#endregion
+//#region src/util/time/constants.ts
+const MILLISECONDS_PER_SECOND = 1e3;
+//#endregion
+//#region src/util/time/hrtime.ts
+const hrtime = (previousHrTime) => {
+	if (checkIsServer()) return process.hrtime(previousHrTime);
+	const clocktime = performance.now() * .001;
+	let seconds = Math.floor(clocktime);
+	let nanoseconds = Math.floor(clocktime % 1 * 1e9);
+	if (previousHrTime) {
+		seconds -= previousHrTime[0];
+		nanoseconds -= previousHrTime[1];
+		if (nanoseconds < 0) {
+			seconds--;
+			nanoseconds += 1e9;
+		}
+	}
+	return [seconds, nanoseconds];
+};
+//#endregion
+//#region src/util/time/now.ts
+const loadNanoseconds = hrtime();
+const loadMilliseconds = Date.now();
+const now = () => {
+	const [seconds, nanoseconds] = hrtime(loadNanoseconds);
+	return (BigInt(loadMilliseconds) * 10n ** 6n + (BigInt(seconds) * 10n ** 9n + BigInt(nanoseconds))).toString();
+};
+//#endregion
+//#region src/util/time/sleep.ts
+const sleep = (durationMs) => new Promise((resolve) => {
+	setTimeout(() => {
+		resolve();
+	}, durationMs);
+});
+//#endregion
+export { ALL_SPECIAL_VALUES, APPEND_SEGMENT, CHARSET_PARAMETER_REGEX, CUSTOM_EMOJI_ID_ATTRIBUTE, CUSTOM_EMOJI_NAME_ATTRIBUTE, DEFAULT_ALLOWED_ATTRIBUTES, DEFAULT_ALLOWED_SCHEMES, DEFAULT_ALLOWED_TAGS, DEFAULT_COMPRESSION_LEVEL, DEFAULT_FACET_SCORE, DEFAULT_LINK_ATTRIBUTES, DEFAULT_SOURCE_SCORE, DEFAULT_TEXT_CHARSET, DEFAULT_TYPE_SCORE, ESCAPED_ATTRIBUTE_CHARACTERS_REGEX, ESCAPED_TEXT_CHARACTERS_REGEX, FacetScoreMap, ForbiddenError, GIBIBYTE, HTML_NAMESPACE, ID_SEPARATOR, IMPORTANT_REGEX, InvalidOperationError, ItemMetadata, JSON_POINTER_REGEX, JsonPatchOperationType, KIBIBYTE, MAX_NESTING_DEPTH, MAX_READ_LIMIT, MAX_WINDOW_LOG, MEDIA_TYPE_REGEX, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_SELECTOR, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MILLISECONDS_PER_SECOND, MIN_WINDOW_LOG, MentionType, NON_TEXT_TAGS, NotFoundError, NotInitializedError, ObjectMethod, Operation, PATH_SEPARATOR_REGEX, RoutePath, SANITIZER_ADVISORY_WATCH_SINCE, SITE_NAME, SPOILER_ATTRIBUTE, SPOILER_SELECTOR, SRCSET_ATTRIBUTE, SRCSET_DESCRIPTOR_REGEX, Serializable, SourceScoreMap, TEXT_MEDIA_TYPE_REGEX, TypeScoreMap, TypedEventEmitter, URL_ATTRIBUTES, UUIDV4_REGEX, VOID_TAGS, WordFilteredError, addJsonValue, applyItemMetadataMixin, applyPatch, applyPatches, capitalize, charset, checkContainsProfanity, checkIsAllowedUrl, checkIsCustomMethod, checkIsDeepEqual, checkIsNestedControl, checkIsNestedInteraction, checkIsPlainObject, checkIsSameBytes, checkIsSameValueZero, checkIsServer, checkIsUnsafeUrlCharacter, checkIsWhitespaceCharacter, chunk, chunkBySerializedSize, clonePlainDeep, collectText, contentType, createEvictingPromiseCache, createHistory, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, dedent, downloadFile, downloadUrl, encodeUrlSubDelimiters, englishProfaneWords, escapeAttribute, escapeCharacters, escapeText, exhaustiveGuard, extension, filterAttributes, filterClasses, filterHtml, filterSrcset, filterStyle, getChildNodes, getDecodedUriComponent, getEndOfDay, getEnumerableKeys, getExtensionMimeTypeMap, getMediaType, getMentions, getMimeScore, getMimeTypeEntryMap, getOrCreate, getPropertyNames, getRawData, getRequestError, getResult, getResultAsync, getSynchronizedFunction, getTransactionDone, getTransactionObjectStore, getWindowLog, getZonedDateTime, hrtime, html, jsonDateParse, lookup, matchesClassPattern, mergeObjectsStrict, noop, normalizeString, now, omitDeep, openDatabase, parseArrayIndex, parseJsonPointer, pushHistory, readJsonValue, redoHistory, removeJsonValue, renderNode, reportFinalizerError, requestToPromise, sanitizeHtml, sanitizeTextHtml, settleAll, sleep, streamToText, takeOne, takeRandom, toAppError, toJsonPointer, toKebabCase, toRawDeep, truncate, uncapitalize, undoHistory, updateJsonValue, waitForSynchronizedFunctions, withFinalizer, withFinalizerAsync, wrapDatabase, wrapIndex, wrapObjectStore, wrapTransaction, wrapUpgradeDatabase, wrapUpgradeTransaction };