@fedify/botkit 0.3.0-dev.108

package/dist/bot-impl.js

@@ -0,0 +1,602 @@
+
+      import { Temporal, toTemporalInstant } from "@js-temporal/polyfill";
+      Date.prototype.toTemporalInstant = toTemporalInstant;
+    
+import deno_default from "./deno.js";
+import { isEmoji } from "./emoji.js";
+import { FollowRequestImpl } from "./follow-impl.js";
+import { createMessage, getMessageVisibility, isMessageObject, isQuoteLink, messageClasses } from "./message-impl.js";
+import { app } from "./pages.js";
+import { KvRepository } from "./repository.js";
+import { SessionImpl } from "./session-impl.js";
+import { Accept, Announce, Article, ChatMessage, Create, Emoji, EmojiReact, Endpoints, Follow, Image, Like, Link, Mention, Note, PUBLIC_COLLECTION, PropertyValue, Question, Reject, Service, Undo, isActor } from "@fedify/fedify/vocab";
+import { Object as Object$2, createFederation, generateCryptoKeyPair } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import mimeDb from "mime-db";
+import fs from "node:fs/promises";
+import { getXForwardedRequest } from "x-forwarded-fetch";
+
+//#region src/bot-impl.ts
+var BotImpl = class {
+	identifier;
+	class;
+	username;
+	name;
+	summary;
+	#summary;
+	icon;
+	image;
+	properties;
+	#properties;
+	followerPolicy;
+	customEmojis;
+	repository;
+	software;
+	behindProxy;
+	pages;
+	collectionWindow;
+	federation;
+	onFollow;
+	onUnfollow;
+	onAcceptFollow;
+	onRejectFollow;
+	onMention;
+	onReply;
+	onQuote;
+	onMessage;
+	onSharedMessage;
+	onLike;
+	onUnlike;
+	onReact;
+	onUnreact;
+	constructor(options) {
+		this.identifier = options.identifier ?? "bot";
+		this.class = options.class ?? Service;
+		this.username = options.username;
+		this.name = options.name;
+		this.summary = options.summary;
+		this.#summary = null;
+		this.icon = options.icon;
+		this.image = options.image;
+		this.properties = options.properties ?? {};
+		this.#properties = null;
+		this.followerPolicy = options.followerPolicy ?? "accept";
+		this.customEmojis = {};
+		this.repository = options.repository ?? new KvRepository(options.kv);
+		this.software = options.software;
+		this.pages = {
+			color: "green",
+			css: "",
+			...options.pages ?? {}
+		};
+		this.federation = createFederation({
+			kv: options.kv,
+			queue: options.queue,
+			userAgent: { software: `BotKit/${deno_default.version}` }
+		});
+		this.behindProxy = options.behindProxy ?? false;
+		this.collectionWindow = options.collectionWindow ?? 50;
+		this.initialize();
+	}
+	initialize() {
+		this.federation.setActorDispatcher("/ap/actor/{identifier}", this.dispatchActor.bind(this)).mapHandle(this.mapHandle.bind(this)).setKeyPairsDispatcher(this.dispatchActorKeyPairs.bind(this));
+		this.federation.setFollowersDispatcher("/ap/actor/{identifier}/followers", this.dispatchFollowers.bind(this)).setFirstCursor(this.getFollowersFirstCursor.bind(this)).setCounter(this.countFollowers.bind(this));
+		this.federation.setOutboxDispatcher("/ap/actor/{identifier}/outbox", this.dispatchOutbox.bind(this)).setFirstCursor(this.getOutboxFirstCursor.bind(this)).setCounter(this.countOutbox.bind(this));
+		this.federation.setObjectDispatcher(Follow, "/ap/follow/{id}", this.dispatchFollow.bind(this)).authorize(this.authorizeFollow.bind(this));
+		this.federation.setObjectDispatcher(Create, "/ap/create/{id}", this.dispatchCreate.bind(this));
+		this.federation.setObjectDispatcher(Article, "/ap/article/{id}", (ctx, values) => this.dispatchMessage(Article, ctx, values.id));
+		this.federation.setObjectDispatcher(ChatMessage, "/ap/chat-message/{id}", (ctx, values) => this.dispatchMessage(ChatMessage, ctx, values.id));
+		this.federation.setObjectDispatcher(Note, "/ap/note/{id}", (ctx, values) => this.dispatchMessage(Note, ctx, values.id));
+		this.federation.setObjectDispatcher(Question, "/ap/question/{id}", (ctx, values) => this.dispatchMessage(Question, ctx, values.id));
+		this.federation.setObjectDispatcher(Announce, "/ap/announce/{id}", this.dispatchAnnounce.bind(this));
+		this.federation.setObjectDispatcher(Emoji, "/ap/emoji/{name}", this.dispatchEmoji.bind(this));
+		this.federation.setInboxListeners("/ap/actor/{identifier}/inbox", "/ap/inbox").on(Follow, this.onFollowed.bind(this)).on(Undo, async (ctx, undo) => {
+			const object = await undo.getObject(ctx);
+			if (object instanceof Follow) await this.onUnfollowed(ctx, undo);
+			else if (object instanceof Like) await this.onUnliked(ctx, undo);
+			else {
+				const logger = getLogger([
+					"botkit",
+					"bot",
+					"inbox"
+				]);
+				logger.warn("The Undo object {undoId} is not about Follow or Like: {object}.", {
+					undoId: undo.id?.href,
+					object
+				});
+			}
+		}).on(Accept, this.onFollowAccepted.bind(this)).on(Reject, this.onFollowRejected.bind(this)).on(Create, this.onCreated.bind(this)).on(Announce, this.onAnnounced.bind(this)).on(Like, this.onLiked.bind(this)).setSharedKeyDispatcher(this.dispatchSharedKey.bind(this));
+		if (this.software != null) this.federation.setNodeInfoDispatcher("/nodeinfo/2.1", this.dispatchNodeInfo.bind(this));
+	}
+	async getActorSummary(session) {
+		if (this.summary == null) return null;
+		if (this.#summary == null) {
+			let summary = "";
+			const tags = [];
+			for await (const chunk of this.summary.getHtml(session)) summary += chunk;
+			for await (const tag of this.summary.getTags(session)) tags.push(tag);
+			return this.#summary = {
+				text: summary,
+				tags
+			};
+		}
+		return this.#summary;
+	}
+	async getActorProperties(session) {
+		if (this.#properties != null) return this.#properties;
+		const pairs = [];
+		const tags = [];
+		for (const name in this.properties) {
+			const value = this.properties[name];
+			const pair = new PropertyValue({
+				name,
+				value: (await Array.fromAsync(value.getHtml(session))).join("")
+			});
+			pairs.push(pair);
+			for await (const tag of value.getTags(session)) tags.push(tag);
+		}
+		return this.#properties = {
+			pairs,
+			tags
+		};
+	}
+	async dispatchActor(ctx, identifier) {
+		if (this.identifier !== identifier) return null;
+		const session = this.getSession(ctx);
+		const summary = await this.getActorSummary(session);
+		const { pairs, tags } = await this.getActorProperties(session);
+		const allTags = summary == null ? tags : [...tags, ...summary.tags];
+		const keyPairs = await ctx.getActorKeyPairs(identifier);
+		return new this.class({
+			id: ctx.getActorUri(identifier),
+			preferredUsername: this.username,
+			name: this.name,
+			summary: summary == null ? null : summary.text,
+			attachments: pairs,
+			tags: allTags.filter((tag, i) => allTags.findIndex((t) => t.name?.toString() === tag.name?.toString() && (t instanceof Link ? tag instanceof Link && t.href?.href === tag.href?.href : tag instanceof Object$2 && t.id?.href === tag.id?.href)) === i),
+			icon: this.icon == null ? null : this.icon instanceof Image ? this.icon : new Image({ url: this.icon }),
+			image: this.image == null ? null : this.image instanceof Image ? this.image : new Image({ url: this.image }),
+			inbox: ctx.getInboxUri(identifier),
+			endpoints: new Endpoints({ sharedInbox: ctx.getInboxUri() }),
+			followers: ctx.getFollowersUri(identifier),
+			outbox: ctx.getOutboxUri(identifier),
+			publicKey: keyPairs[0].cryptographicKey,
+			assertionMethods: keyPairs.map((pair) => pair.multikey),
+			url: new URL("/", ctx.origin)
+		});
+	}
+	mapHandle(_ctx, username) {
+		return username === this.username ? this.identifier : null;
+	}
+	async dispatchActorKeyPairs(_ctx, identifier) {
+		if (identifier !== this.identifier) return [];
+		let keyPairs = await this.repository.getKeyPairs();
+		if (keyPairs == null) {
+			const rsa = await generateCryptoKeyPair("RSASSA-PKCS1-v1_5");
+			const ed25519 = await generateCryptoKeyPair("Ed25519");
+			keyPairs = [rsa, ed25519];
+			await this.repository.setKeyPairs(keyPairs);
+		}
+		return keyPairs;
+	}
+	async dispatchFollowers(_ctx, identifier, cursor) {
+		if (identifier !== this.identifier) return null;
+		let followers;
+		let nextCursor;
+		if (cursor == null) {
+			followers = this.repository.getFollowers();
+			nextCursor = null;
+		} else {
+			const offset = cursor.match(/^\d+$/) ? parseInt(cursor) : 0;
+			followers = this.repository.getFollowers({
+				offset,
+				limit: this.collectionWindow
+			});
+			nextCursor = (offset + this.collectionWindow).toString();
+		}
+		const items = [];
+		let i = 0;
+		for await (const follower of followers) {
+			items.push(follower);
+			i++;
+		}
+		if (i < this.collectionWindow) nextCursor = null;
+		return {
+			items,
+			nextCursor
+		};
+	}
+	getFollowersFirstCursor(_ctx, identifier) {
+		if (identifier !== this.identifier) return null;
+		return "0";
+	}
+	async countFollowers(_ctx, identifier) {
+		if (identifier !== this.identifier) return null;
+		return await this.repository.countFollowers();
+	}
+	async getPermissionChecker(ctx) {
+		let owner;
+		try {
+			owner = await ctx.getSignedKeyOwner();
+		} catch {
+			owner = null;
+		}
+		let follower = false;
+		const ownerUri = owner?.id;
+		if (ownerUri != null) follower = await this.repository.hasFollower(ownerUri);
+		const followersUri = ctx.getFollowersUri(this.identifier);
+		return (object) => {
+			const recipients = [...object.toIds, ...object.ccIds].map((u) => u.href);
+			if (recipients.includes(PUBLIC_COLLECTION.href)) return true;
+			if (recipients.includes(followersUri.href) && follower) return true;
+			return ownerUri == null ? false : recipients.includes(ownerUri.href);
+		};
+	}
+	async dispatchOutbox(ctx, identifier, cursor) {
+		if (identifier !== this.identifier) return null;
+		const activities = this.repository.getMessages({
+			order: "newest",
+			until: cursor == null || cursor === "" ? void 0 : Temporal.Instant.from(cursor),
+			limit: cursor == null ? void 0 : this.collectionWindow + 1
+		});
+		const items = [];
+		const isVisible = await this.getPermissionChecker(ctx);
+		let i = 0;
+		let nextPublished = null;
+		for await (const activity of activities) {
+			if (cursor != null && i >= this.collectionWindow) {
+				nextPublished = activity.published ?? (await activity.getObject())?.published ?? null;
+				break;
+			}
+			if (isVisible(activity)) items.push(activity);
+			i++;
+		}
+		return {
+			items,
+			nextCursor: nextPublished?.toString() ?? null
+		};
+	}
+	getOutboxFirstCursor(_ctx, identifier) {
+		if (identifier !== this.identifier) return null;
+		return "";
+	}
+	async countOutbox(_ctx, identifier) {
+		if (identifier !== this.identifier) return null;
+		return await this.repository.countMessages();
+	}
+	async dispatchFollow(_ctx, values) {
+		const id = values.id;
+		const follow = await this.repository.getSentFollow(id);
+		return follow ?? null;
+	}
+	async authorizeFollow(_ctx, values, _signedKey, signedKeyOwner) {
+		if (signedKeyOwner == null || signedKeyOwner.id == null) return false;
+		const id = values.id;
+		const follow = await this.repository.getSentFollow(id);
+		if (follow == null) return false;
+		return signedKeyOwner.id.href === follow.objectId?.href || signedKeyOwner.id.href === follow.actorId?.href;
+	}
+	async dispatchCreate(ctx, values) {
+		const activity = await this.repository.getMessage(values.id);
+		if (!(activity instanceof Create)) return null;
+		const isVisible = await this.getPermissionChecker(ctx);
+		return isVisible(activity) ? activity : null;
+	}
+	async dispatchMessage(cls, ctx, id) {
+		const activity = await this.repository.getMessage(id);
+		if (!(activity instanceof Create)) return null;
+		if ("request" in ctx) {
+			const isVisible = await this.getPermissionChecker(ctx);
+			if (!isVisible(activity)) return null;
+		}
+		const object = await activity.getObject(ctx);
+		if (object == null || !(object instanceof cls)) return null;
+		return object;
+	}
+	async dispatchAnnounce(ctx, values) {
+		const activity = await this.repository.getMessage(values.id);
+		if (!(activity instanceof Announce)) return null;
+		const isVisible = await this.getPermissionChecker(ctx);
+		return isVisible(activity) ? activity : null;
+	}
+	dispatchEmoji(ctx, values) {
+		const customEmoji = this.customEmojis[values.name];
+		if (customEmoji == null) return null;
+		return this.getEmoji(ctx, values.name, customEmoji);
+	}
+	dispatchSharedKey(_ctx) {
+		return { identifier: this.identifier };
+	}
+	async onFollowed(ctx, follow) {
+		const botUri = ctx.getActorUri(this.identifier);
+		if (follow.actorId?.href === botUri.href || follow.objectId?.href !== botUri.href) return;
+		const follower = await follow.getActor({
+			contextLoader: ctx.contextLoader,
+			documentLoader: ctx.documentLoader,
+			suppressError: true
+		});
+		if (follower == null || follower.id == null) return;
+		const session = this.getSession(ctx);
+		const followRequest = new FollowRequestImpl(session, follow, follower);
+		await this.onFollow?.(session, followRequest);
+		if (followRequest.state === "pending") {
+			if (this.followerPolicy === "accept") await followRequest.accept();
+			else if (this.followerPolicy === "reject") await followRequest.reject();
+		}
+	}
+	async onUnfollowed(ctx, undo) {
+		const followId = undo.objectId;
+		if (followId == null || undo.actorId == null) return;
+		const follower = await this.repository.removeFollower(followId, undo.actorId);
+		if (this.onUnfollow != null && follower != null) {
+			const session = this.getSession(ctx);
+			await this.onUnfollow(session, follower);
+		}
+	}
+	async onFollowAccepted(ctx, accept) {
+		const parsedObj = ctx.parseUri(accept.objectId);
+		if (parsedObj?.type !== "object" || parsedObj.class !== Follow) return;
+		const follow = await this.repository.getSentFollow(parsedObj.values.id);
+		if (follow == null) return;
+		const followee = await follow.getObject(ctx);
+		if (!isActor(followee) || followee.id == null || followee.id.href !== accept.actorId?.href) return;
+		await this.repository.addFollowee(followee.id, follow);
+		if (this.onAcceptFollow != null) {
+			const session = this.getSession(ctx);
+			await this.onAcceptFollow(session, followee);
+		}
+	}
+	async onFollowRejected(ctx, reject) {
+		const parsedObj = ctx.parseUri(reject.objectId);
+		if (parsedObj?.type !== "object" || parsedObj.class !== Follow) return;
+		const id = parsedObj.values.id;
+		const follow = await this.repository.getSentFollow(id);
+		if (follow == null) return;
+		const followee = await follow.getObject(ctx);
+		if (!isActor(followee) || followee.id == null || followee.id.href !== reject.actorId?.href) return;
+		await this.repository.removeSentFollow(id);
+		if (this.onRejectFollow != null) {
+			const session = this.getSession(ctx);
+			await this.onRejectFollow(session, followee);
+		}
+	}
+	async onCreated(ctx, create) {
+		const object = await create.getObject(ctx);
+		if (!(object instanceof Article || object instanceof ChatMessage || object instanceof Note || object instanceof Question)) return;
+		const session = this.getSession(ctx);
+		let messageCache = null;
+		const getMessage = async () => {
+			if (messageCache != null) return messageCache;
+			return messageCache = await createMessage(object, session, {});
+		};
+		const replyTarget = ctx.parseUri(object.replyTargetId);
+		if (this.onReply != null && replyTarget?.type === "object" && messageClasses.includes(replyTarget.class)) {
+			const message = await getMessage();
+			if (message.visibility === "public" || message.visibility === "unlisted") await ctx.forwardActivity(this, "followers", {
+				skipIfUnsigned: true,
+				preferSharedInbox: true,
+				excludeBaseUris: [new URL(ctx.origin)]
+			});
+			await this.onReply(session, message);
+		}
+		let quoteUrl = null;
+		for await (const tag of object.getTags(ctx)) if (tag instanceof Link && isQuoteLink(tag)) {
+			quoteUrl = tag.href;
+			break;
+		}
+		if (quoteUrl == null) quoteUrl = object.quoteUrl;
+		const quoteTarget = ctx.parseUri(quoteUrl);
+		if (this.onQuote != null && quoteTarget?.type === "object" && messageClasses.includes(quoteTarget.class)) {
+			const message = await getMessage();
+			if (message.visibility === "public" || message.visibility === "unlisted") await ctx.forwardActivity(this, "followers", {
+				skipIfUnsigned: true,
+				preferSharedInbox: true,
+				excludeBaseUris: [new URL(ctx.origin)]
+			});
+			await this.onQuote(session, message);
+		}
+		for await (const tag of object.getTags(ctx)) if (tag instanceof Mention && tag.href != null && this.onMention != null) {
+			const parsed = ctx.parseUri(tag.href);
+			if (parsed?.type === "actor" && parsed.identifier === this.identifier) {
+				await this.onMention(session, await getMessage());
+				break;
+			}
+		}
+		if (this.onMessage != null) await this.onMessage(session, await getMessage());
+	}
+	async onAnnounced(ctx, announce) {
+		if (this.onSharedMessage == null || announce.id == null || announce.actorId == null) return;
+		const objectUri = ctx.parseUri(announce.objectId);
+		let object = null;
+		if (objectUri?.type === "object" && messageClasses.includes(objectUri.class)) {
+			const msg = await this.repository.getMessage(objectUri.values.id);
+			if (msg instanceof Create) object = await msg.getObject(ctx);
+		} else object = await announce.getObject(ctx);
+		if (!isMessageObject(object)) return;
+		const session = this.getSession(ctx);
+		const actor = announce.actorId.href == session.actorId.href ? await session.getActor() : await announce.getActor(ctx);
+		if (actor == null) return;
+		const original = await createMessage(object, session, {});
+		const sharedMessage = {
+			raw: announce,
+			id: announce.id,
+			actor,
+			visibility: getMessageVisibility(announce.toIds, announce.ccIds, actor),
+			original
+		};
+		await this.onSharedMessage(session, sharedMessage);
+	}
+	async #parseLike(ctx, like) {
+		if (like.id == null || like.actorId == null) return void 0;
+		const objectUri = ctx.parseUri(like.objectId);
+		let object = null;
+		if (objectUri?.type === "object" && messageClasses.includes(objectUri.class)) {
+			const msg = await this.repository.getMessage(objectUri.values.id);
+			if (msg instanceof Create) object = await msg.getObject(ctx);
+		} else object = await like.getObject(ctx);
+		if (!isMessageObject(object)) return void 0;
+		const session = this.getSession(ctx);
+		const actor = like.actorId.href == session.actorId.href ? await session.getActor() : await like.getActor(ctx);
+		if (actor == null) return;
+		const message = await createMessage(object, session, {});
+		return {
+			session,
+			like: {
+				raw: like,
+				id: like.id,
+				actor,
+				message
+			}
+		};
+	}
+	async onLiked(ctx, like) {
+		if (like.name != null) return this.onReacted(ctx, like);
+		if (this.onLike == null) return;
+		const sessionAndLike = await this.#parseLike(ctx, like);
+		if (sessionAndLike == null) return;
+		const { session, like: likeObject } = sessionAndLike;
+		await this.onLike(session, likeObject);
+	}
+	async onUnliked(ctx, undo) {
+		const like = await undo.getObject(ctx);
+		if (!(like instanceof Like)) return;
+		if (like.name != null) return this.onUnreacted(ctx, undo);
+		if (this.onUnlike == null) return;
+		if (undo.actorId?.href !== like.actorId?.href) return;
+		const sessionAndLike = await this.#parseLike(ctx, like);
+		if (sessionAndLike == null) return;
+		const { session, like: likeObject } = sessionAndLike;
+		await this.onUnlike(session, likeObject);
+	}
+	async #parseReaction(ctx, react) {
+		if (react.id == null || react.actorId == null || react.name == null) return void 0;
+		let emoji;
+		if (isEmoji(react.name)) emoji = react.name;
+		else if (typeof react.name === "string" && react.name.startsWith(":") && react.name.endsWith(":")) {
+			for await (const tag of react.getTags(ctx)) if (tag instanceof Emoji && tag.name === react.name) {
+				emoji = tag;
+				break;
+			}
+		}
+		if (emoji == null) return void 0;
+		const objectUri = ctx.parseUri(react.objectId);
+		let object = null;
+		if (objectUri?.type === "object" && messageClasses.includes(objectUri.class)) {
+			const msg = await this.repository.getMessage(objectUri.values.id);
+			if (msg instanceof Create) object = await msg.getObject(ctx);
+		} else object = await react.getObject(ctx);
+		if (!isMessageObject(object)) return void 0;
+		const session = this.getSession(ctx);
+		const actor = react.actorId.href == session.actorId.href ? await session.getActor() : await react.getActor(ctx);
+		if (actor == null) return;
+		const message = await createMessage(object, session, {});
+		return {
+			session,
+			reaction: {
+				raw: react,
+				id: react.id,
+				actor,
+				message,
+				emoji
+			}
+		};
+	}
+	async onReacted(ctx, react) {
+		if (this.onReact == null) return;
+		const sessionAndReaction = await this.#parseReaction(ctx, react);
+		if (sessionAndReaction == null) return;
+		const { session, reaction } = sessionAndReaction;
+		await this.onReact(session, reaction);
+	}
+	async onUnreacted(ctx, undo) {
+		if (this.onUnreact == null) return;
+		const react = await undo.getObject(ctx);
+		if (!(react instanceof EmojiReact || react instanceof Like)) return;
+		if (undo.actorId?.href !== react.actorId?.href) return;
+		const sessionAndReaction = await this.#parseReaction(ctx, react);
+		if (sessionAndReaction == null) return;
+		const { session, reaction } = sessionAndReaction;
+		await this.onUnreact(session, reaction);
+	}
+	dispatchNodeInfo(_ctx) {
+		return {
+			software: this.software,
+			protocols: ["activitypub"],
+			services: { outbound: ["atom1.0"] },
+			usage: {
+				users: {
+					total: 1,
+					activeMonth: 1,
+					activeHalfyear: 1
+				},
+				localPosts: 0,
+				localComments: 0
+			}
+		};
+	}
+	getSession(origin, contextData) {
+		const ctx = typeof origin === "string" || origin instanceof URL ? this.federation.createContext(new URL(origin), contextData) : origin;
+		return new SessionImpl(this, ctx);
+	}
+	async fetch(request, contextData) {
+		if (this.behindProxy) request = await getXForwardedRequest(request);
+		const url = new URL(request.url);
+		if (url.pathname.startsWith("/.well-known/") || url.pathname.startsWith("/ap/") || url.pathname.startsWith("/nodeinfo/")) return await this.federation.fetch(request, { contextData });
+		const match = /^\/emojis\/([a-z0-9-_]+)(?:$|\.)/.exec(url.pathname);
+		if (match != null) {
+			const customEmoji = this.customEmojis[match[1]];
+			if (customEmoji == null || !("file" in customEmoji)) return new Response("Not Found", { status: 404 });
+			let file;
+			try {
+				file = await fs.open(customEmoji.file, "r");
+			} catch (error) {
+				if (typeof error === "object" && error != null && "code" in error && error.code === "ENOENT") return new Response("Not Found", { status: 404 });
+				throw error;
+			}
+			const fileInfo = await file.stat();
+			return new Response(file.readableWebStream(), { headers: {
+				"Content-Type": customEmoji.type,
+				"Content-Length": fileInfo.size.toString(),
+				"Cache-Control": "public, max-age=31536000, immutable",
+				"Last-Modified": (fileInfo.mtime ?? /* @__PURE__ */ new Date()).toUTCString(),
+				"ETag": `"${fileInfo.mtime?.getTime().toString(36)}${fileInfo.size.toString(36)}"`
+			} });
+		}
+		return await app.fetch(request, {
+			bot: this,
+			contextData
+		});
+	}
+	getEmoji(ctx, name, data) {
+		let url;
+		if ("url" in data) url = new URL(data.url);
+		else {
+			const t = mimeDb[data.type];
+			url = new URL(`/emojis/${name}${t == null || t.extensions == null || t.extensions.length < 1 ? "" : `.${t.extensions[0]}`}`, ctx.origin);
+		}
+		return new Emoji({
+			id: ctx.getObjectUri(Emoji, { name }),
+			name: `:${name}:`,
+			icon: new Image({
+				mediaType: data.type,
+				url
+			})
+		});
+	}
+	addCustomEmoji(name, data) {
+		if (!name.match(/^[a-z0-9-_]+$/i)) throw new TypeError(`Invalid custom emoji name: ${name}. It must match /^[a-z0-9-_]+$/i.`);
+		else if (name in this.customEmojis) throw new TypeError(`Duplicate custom emoji name: ${name}`);
+		else if (!data.type.startsWith("image/")) throw new TypeError(`Unsupported media type: ${data.type}`);
+		this.customEmojis[name] = data;
+		return (session) => this.getEmoji(session.context, name, data);
+	}
+	addCustomEmojis(emojis) {
+		const emojiMap = {};
+		for (const name in emojis) emojiMap[name] = this.addCustomEmoji(name, emojis[name]);
+		return emojiMap;
+	}
+};
+
+//#endregion
+export { BotImpl };
+//# sourceMappingURL=bot-impl.js.map