@esposter/shared 4.0.0 → 4.1.0

package/dist/index.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { ResultAsync, fromThrowable } from "neverthrow";
 import { parse } from "node-html-parser";
-import baseSanitizeHtml from "sanitize-html";
+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) {
@@ -42,6 +43,53 @@ var WordFilteredError = class extends Error {
 	}
 };
 //#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/message/MentionType.ts
 let MentionType = /* @__PURE__ */ function(MentionType) {
 	MentionType["Role"] = "role";
@@ -49,6 +97,13 @@ let MentionType = /* @__PURE__ */ function(MentionType) {
 	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";
@@ -106,17 +161,6 @@ var ItemMetadata = class {
 	updatedAt = /* @__PURE__ */ new Date();
 };
 //#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/util/reactivity/getRawData.ts
 const getRawData = (data) => {
 	const raw = data && data.__v_raw;
@@ -153,6 +197,15 @@ const getResult = (callback) => fromThrowable(callback, toAppError)();
 //#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
@@ -160,11 +213,7 @@ const noop = () => {};
 const withFinalizer = (callback, finalizer) => {
 	const callbackResult = getResult(callback);
 	if (finalizer) getResult(finalizer).match(noop, (error) => {
-		callbackResult.match(() => {
-			throw error;
-		}, () => {
-			console.error(error);
-		});
+		reportFinalizerError(callbackResult, error);
 	});
 	return callbackResult.match((value) => value, (error) => {
 		throw error;
@@ -175,17 +224,142 @@ const withFinalizer = (callback, finalizer) => {
 const withFinalizerAsync = async (callback, finalizer) => {
 	const callbackResult = await getResultAsync(async () => callback());
 	if (finalizer) await getResultAsync(async () => finalizer()).match(noop, (error) => {
-		callbackResult.match(() => {
-			throw error;
-		}, () => {
-			console.error(error);
-		});
+		reportFinalizerError(callbackResult, error);
 	});
 	return callbackResult.match((value) => value, (error) => {
 		throw error;
 	});
 };
 //#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, console.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/message/constants.ts
 const MENTION_ID_ATTRIBUTE = "data-id";
 const MENTION_ITEM_TYPE_ATTRIBUTE = "data-mention-type";
@@ -197,35 +371,905 @@ 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/sanitizeHtml/sanitizeHtml.ts
-const appendStyle = (style, declarations) => style ? `${style}; ${declarations}` : declarations;
-const transformCellAlign = (tagName, attribs) => {
-	if (attribs.align) {
-		attribs.style = appendStyle(attribs.style, `text-align:${attribs.align}`);
-		delete attribs.align;
+//#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).replace(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-11";
+//#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 {
-		attribs,
-		tagName
-	};
+	return candidates.length > 0 ? candidates.join(", ") : void 0;
 };
-const transformLink = (tagName, attribs) => ({
-	attribs: {
-		...attribs,
-		rel: "noopener noreferrer nofollow",
-		target: "_blank"
-	},
-	tagName
+//#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 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;
+		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 = {
@@ -236,33 +1280,30 @@ const TABLE_ALLOWED_STYLES = {
 	td: { "text-align": TEXT_ALIGN_REGEXES },
 	th: { "text-align": TEXT_ALIGN_REGEXES }
 };
-const sanitizeHtml = (...[html, options]) => baseSanitizeHtml(html, {
-	...options,
+const sanitizeHtml = (html, options) => filterHtml(html, {
 	allowedAttributes: {
-		...options?.allowedAttributes || baseSanitizeHtml.defaults.allowedAttributes,
-		a: [
+		...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
 	},
-	transformTags: {
-		...options?.transformTags,
+	allowedTags: options?.allowedTags ?? DEFAULT_ALLOWED_TAGS,
+	transformAttributes: {
+		...options?.transformAttributes,
 		a: transformLink,
-		table: (tagName, attribs) => ({
-			attribs: {
-				...attribs,
-				style: appendStyle(attribs.style, "width:100%; border-collapse: collapse;")
-			},
-			tagName
-		}),
+		table: transformTable,
 		td: transformCellAlign,
 		th: transformCellAlign
 	}
@@ -276,22 +1317,20 @@ const COLOR_REGEXES = [
 ];
 const sanitizeTextHtml = (html) => sanitizeHtml(html, {
 	allowedAttributes: {
-		code: ["class"],
 		input: [
 			"checked",
 			"disabled",
 			"type"
 		],
 		li: ["data-checked", "data-type"],
-		pre: ["class"],
 		span: [
-			"class",
 			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"]
@@ -307,21 +1346,15 @@ const sanitizeTextHtml = (html) => sanitizeHtml(html, {
 		color: COLOR_REGEXES
 	} },
 	allowedTags: [
-		...baseSanitizeHtml.defaults.allowedTags,
+		...DEFAULT_ALLOWED_TAGS,
 		"input",
 		"label"
 	],
-	transformTags: { input: (tagName, { checked }) => {
-		const attribs = {
-			disabled: "",
-			type: "checkbox"
-		};
-		if (checked !== void 0) attribs.checked = checked;
-		return {
-			attribs,
-			tagName
-		};
-	} }
+	transformAttributes: { input: ({ checked }) => ({
+		...checked === void 0 ? {} : { checked },
+		disabled: "",
+		type: "checkbox"
+	}) }
 });
 //#endregion
 //#region src/services/shared/applyItemMetadataMixin.ts
@@ -424,11 +1457,6 @@ const chunkBySerializedSize = (items, maxBytes, maxCount) => {
 	return chunks;
 };
 //#endregion
-//#region src/util/array/takeOne.ts
-const takeOne = (values, index = 0) => {
-	return values[index];
-};
-//#endregion
 //#region src/util/date/getZonedDateTime.ts
 const getZonedDateTime = (date) => Temporal.Instant.fromEpochMilliseconds(date.getTime()).toZonedDateTimeISO(Temporal.Now.timeZoneId());
 //#endregion
@@ -496,6 +1524,57 @@ const getOrCreate = (map, key, create) => {
 	return value;
 };
 //#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/object/checkIsPlainObject.ts
 const checkIsPlainObject = (data) => {
 	if (typeof data !== "object" || data === null) return false;
@@ -521,6 +1600,31 @@ const jsonDateParse = (text) => JSON.parse(text, (_key, value) => {
 //#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 [];
@@ -539,6 +1643,206 @@ const settleAll = async (tasks, concurrencyLimit = tasks.length) => {
 //#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",
@@ -611,4 +1915,4 @@ const exhaustiveGuard = (value) => {
 	throw new InvalidOperationError("Read", exhaustiveGuard.name, JSON.stringify(value));
 };
 //#endregion
-export { ALL_SPECIAL_VALUES, CUSTOM_EMOJI_ID_ATTRIBUTE, CUSTOM_EMOJI_NAME_ATTRIBUTE, DEFAULT_COMPRESSION_LEVEL, ForbiddenError, GIBIBYTE, ID_SEPARATOR, InvalidOperationError, ItemMetadata, KIBIBYTE, MAX_READ_LIMIT, MAX_WINDOW_LOG, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_SELECTOR, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MIN_WINDOW_LOG, MentionType, NotFoundError, NotInitializedError, Operation, RoutePath, SITE_NAME, Serializable, UUIDV4_REGEX, WordFilteredError, applyItemMetadataMixin, capitalize, checkIsNestedInteraction, checkIsPlainObject, checkIsServer, chunk, chunkBySerializedSize, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, encodeUrlSubDelimiters, exhaustiveGuard, getDecodedUriComponent, getEndOfDay, getMentions, getOrCreate, getPropertyNames, getRawData, getResult, getResultAsync, getSynchronizedFunction, getWindowLog, getZonedDateTime, hrtime, html, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, sanitizeHtml, sanitizeTextHtml, settleAll, sleep, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, waitForSynchronizedFunctions, withFinalizer, withFinalizerAsync };
+export { ALL_SPECIAL_VALUES, 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, 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, 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, applyItemMetadataMixin, capitalize, charset, checkContainsProfanity, checkIsAllowedUrl, checkIsCustomMethod, checkIsDeepEqual, checkIsNestedInteraction, checkIsPlainObject, checkIsSameBytes, checkIsSameValueZero, checkIsServer, checkIsUnsafeUrlCharacter, checkIsWhitespaceCharacter, chunk, chunkBySerializedSize, collectText, contentType, createEvictingPromiseCache, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, dedent, 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, renderNode, reportFinalizerError, requestToPromise, sanitizeHtml, sanitizeTextHtml, settleAll, sleep, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, waitForSynchronizedFunctions, withFinalizer, withFinalizerAsync, wrapDatabase, wrapIndex, wrapObjectStore, wrapTransaction, wrapUpgradeDatabase, wrapUpgradeTransaction };