@seedcord/core 0.1.3 → 0.2.0-next.0

package/dist/index.cjs

@@ -1,889 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_subscribers = require('./subscribers-6x4xw39Z.cjs');
-const require_publishDefault = require('./publishDefault-D52iT8mF.cjs');
-const require_cursor = require('./cursor-DFgJ70_B.cjs');
-const require_phases = require('./phases-8qiiLKjS.cjs');
-require("reflect-metadata");
-let _discordjs_builders = require("@discordjs/builders");
-let _seedcord_logger = require("@seedcord/logger");
-let discord_api_types_v10 = require("discord-api-types/v10");
-let _seedcord_errors = require("@seedcord/errors");
-let _seedcord_errors_internal = require("@seedcord/errors/internal");
-let _seedcord_utils = require("@seedcord/utils");
-
-//#region src/decorators/Command.ts
-function RegisterCommand(scope, guilds = []) {
-	return (ctor) => {
-		const existingMeta = Reflect.getOwnMetadata(require_publishDefault.CommandMetadataKey, ctor);
-		if (existingMeta) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.DecoratorCommandAlreadyRegistered, [
-			ctor.name,
-			existingMeta.scope,
-			scope
-		]);
-		if (scope === "global" && guilds.length > 0) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.DecoratorCommandGlobalWithGuilds);
-		if (scope === "guild" && (!Array.isArray(guilds) || guilds.length === 0)) throw new _seedcord_errors_internal.SeedcordError(_seedcord_errors.SeedcordErrorCode.DecoratorCommandGuildWithoutGuilds);
-		const meta = scope === "global" ? { scope } : {
-			scope,
-			guilds
-		};
-		Reflect.defineMetadata(require_publishDefault.CommandMetadataKey, meta, ctor);
-	};
-}
-
-//#endregion
-//#region src/decorators/routes.ts
-/**
-* Routes one or more slash commands to a `SlashHandler`.
-*
-* Pass the same route string(s) as the handler's generic. A single command reads `this.options`, several
-* commands branch with `this.match`. The decorator routes and the generic must match exactly. Listing
-* fewer or more than the handler declares is a compile error. Subcommands use a slash path.
-*
-* @param routes - The route string(s) this handler serves, e.g. `'ban'`, `'ban', 'kick'`, or `'demo/setup'`.
-* @decorator
-* @example
-* ```ts
-* \@SlashRoute('ban')
-* class BanHandler extends SlashHandler<'ban'> {
-*     async execute() {
-*         const target = this.options.getUser('target');
-*     }
-* }
-* ```
-*/
-function SlashRoute(...routes) {
-	return function(constructor) {
-		require_cursor.storeInteractionRoute("slash", routes, constructor);
-	};
-}
-/**
-* Routes one or more commands' autocomplete to an `AutocompleteHandler`.
-*
-* Pass the same command route string(s) as the handler's generic. One command branches with `this.match`
-* over its autocompletable fields, several commands share one handler whose arms span every command's
-* fields. Listing fewer or more commands than the handler declares is a compile error, since the
-* decorator routes and the generic must match exactly.
-*
-* @param routes - The command route string(s) this handler serves, e.g. `'search'` or `'search', 'find'`.
-* @decorator
-* @example
-* ```ts
-* \@AutocompleteRoute('search')
-* class SearchAutocomplete extends AutocompleteHandler<'search'> {
-*     async execute() {
-*         await this.match({ query: (value, respond) => respond([{ name: value, value }]) });
-*     }
-* }
-* ```
-*/
-function AutocompleteRoute(...routes) {
-	return function(constructor) {
-		require_cursor.storeInteractionRoute("autocomplete", routes, constructor);
-	};
-}
-/**
-* Routes one or more context-menu commands to a `ContextMenuHandler`.
-*
-* Pass the kind (`ApplicationCommandType.User` or `ApplicationCommandType.Message`) and the command name(s),
-* each checked against that kind's registry. A typo there is a compile error. The handler's generic must
-* declare the same kind, cross-checked both directions. Context menus carry no options, so a multi-name
-* handler reads `this.target` uniformly with no branch.
-*
-* @param kind - The context-menu kind, `ApplicationCommandType.User` or `ApplicationCommandType.Message`.
-* @param names - The command name(s) this handler serves, keyed off the matching registry.
-* @decorator
-* @example
-* ```ts
-* \@ContextMenuRoute(ApplicationCommandType.User, 'View Profile')
-* class ViewProfile extends ContextMenuHandler<ApplicationCommandType.User> {
-*     async execute() {
-*         const user = this.target;
-*     }
-* }
-* ```
-*/
-function ContextMenuRoute(kind, ...names) {
-	return function(constructor) {
-		require_cursor.storeInteractionRoute(require_cursor.contextMenuRouteOf(kind), names, constructor);
-	};
-}
-/**
-* Routes button interactions to handler classes.
-*
-* Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
-* generic. Passing different definitions to the decorator and the generic is a compile error. Routing
-* matches the stable prefix, so a wire minted from an older shape still reaches the handler, where
-* reading this.params throws StaleCustomId and the controller boundary turns it into a reply.
-*
-* @param defs - The customId definition(s) this handler decodes, one per route.
-* @decorator
-*/
-function ButtonRoute(...defs) {
-	return function(constructor) {
-		require_cursor.storeComponentRoute("button", defs, constructor);
-	};
-}
-/**
-* Routes modal submissions to handler classes.
-*
-* Pass the {@link CustomId} definition(s) this handler decodes and list the same ones in the handler's
-* generic. Passing different definitions to the decorator and the generic is a compile error. Routing
-* matches the stable prefix here too, throwing StaleCustomId on read the same as a button route.
-*
-* @param defs - The customId definition(s) this handler decodes, one per route.
-* @decorator
-*/
-function ModalRoute(...defs) {
-	return function(constructor) {
-		require_cursor.storeComponentRoute("modal", defs, constructor);
-	};
-}
-/**
-* Routes select menu interactions to handler classes.
-*
-* Pass the select kind and the {@link CustomId} definition(s) this handler decodes. The handler's
-* generic must list the same kind and definitions, or it is a compile error.
-*
-* @param type - Select menu kind from {@link SelectMenuKind}.
-* @param defs - The customId definition(s) this handler decodes, one per route.
-* @decorator
-*
-* @example
-* ```typescript
-* \@SelectMenuRoute(SelectMenuKind.User, AssignId)
-* class AssignSelect extends SelectMenuHandler<SelectMenuKind.User, [typeof AssignId]> {}
-* ```
-*/
-function SelectMenuRoute(type, ...defs) {
-	return function(constructor) {
-		require_cursor.storeComponentRoute(require_cursor.selectMenuRouteOf(type), defs, constructor);
-	};
-}
-
-//#endregion
-//#region src/dispatch/DispatchContext.ts
-/**
-* A typed bag allocated once per interaction dispatch and handed to the handler. The middleware and i18n
-* work reads and writes it through {@link DispatchState}. Today the bag is empty, so it only carries the
-* dispatched `routeId`.
-*/
-var DispatchContext = class {
-	routeId;
-	state = {};
-	constructor(routeId) {
-		this.routeId = routeId;
-	}
-	set(key, value) {
-		this.state[key] = value;
-	}
-	get(key) {
-		return this.state[key];
-	}
-};
-
-//#endregion
-//#region src/handlers/BaseHandler.ts
-/**
-* Base class every transport handler extends. Don't register handlers directly. Use the more specific
-* handler subclasses.
-*
-* @typeParam Event - The event or interaction this handler processes
-* @typeParam TCore - The transport's Core
-*/
-var BaseHandler = class {
-	core;
-	event;
-	logger;
-	dispatch;
-	constructor(event, core, dispatch, channel) {
-		this.core = core;
-		this.event = event;
-		this.logger = new _seedcord_logger.Logger(this.constructor.name, { channel });
-		this.dispatch = dispatch;
-	}
-};
-
-//#endregion
-//#region src/handlers/RepliableHandler.ts
-/**
-* Shared base the repliable handlers on both transports extend. Defines the reply members over the sender
-* the transport builds.
-*
-* @typeParam Event - The repliable interaction type this handler processes
-* @typeParam TCore - The transport's Core
-* @typeParam TMessage - The transport's created-message lens
-* @typeParam TNative - The transport's own file forms, beyond the portable `ReplyFile`
-* @typeParam TSender - The transport's reply sender
-*/
-var RepliableHandler = class extends BaseHandler {
-	sender;
-	routeId;
-	constructor(event, core, dispatch) {
-		super(event, core, dispatch, "interactions");
-		this.routeId = dispatch?.routeId ?? this.constructor.name;
-		this.sender = this.buildSender(event, core, this.routeId);
-	}
-	/** @internal The dispatcher's fault boundary replies through the live ack state. */
-	getSender() {
-		return this.sender;
-	}
-	/** Send the initial response, exactly once. */
-	reply(response, opts) {
-		return this.sender.reply(response, opts);
-	}
-	/** Show a "thinking" placeholder, then fill it later with {@link edit}. */
-	defer(opts) {
-		return this.sender.defer(opts);
-	}
-	/** Send a new message once the interaction is acknowledged. */
-	followUp(response, opts) {
-		return this.sender.followUp(response, opts);
-	}
-	edit(targetOrResponse, maybeResponse) {
-		if (maybeResponse === void 0) return this.sender.edit(targetOrResponse);
-		return this.sender.edit(targetOrResponse, maybeResponse);
-	}
-	/** Routes to reply, followUp, or edit based on the current ack state. */
-	send(response, opts) {
-		return this.sender.send(response, opts);
-	}
-	/** Delete the initial reply or deferred placeholder. Pass a target to delete a message a prior send returned. */
-	delete(target) {
-		return target === void 0 ? this.sender.delete() : this.sender.delete(target);
-	}
-};
-
-//#endregion
-//#region src/stops/Fault.ts
-/**
-* A generic fault you throw after catching an error you do not have a specific message for.
-*
-* The user sees a fixed generic reply with the tracking uuid, never the cause. `report` defaults to
-* `true`, so the framework logs it and publishes it to the `handledException` bus. Pass `report: false`
-* to show the generic reply without the bus publish. The original error is stored as the standard
-* `cause`, so the real stack reaches the webhook. When the user should see a real message for a fault,
-* subclass {@link Notice} and write your own `render` instead.
-*
-* The framework also renders this for an unhandled throw, where it points the user at
-* `ctx.developerUsername`.
-*
-* @example
-* ```ts
-* import { Fault } from '@seedcord/gateway';
-*
-* try {
-*     await db.write(record);
-* } catch (cause) {
-*     // user sees the generic reply with the uuid, and the real error rides along as cause for the webhook
-*     throw new Fault({ cause });
-*
-*     // pass report: false to show the same reply without publishing to the handledException bus
-*     // throw new Fault({ cause, report: false });
-* }
-* ```
-*/
-var Fault = class extends require_cursor.Notice {
-	constructor(options) {
-		super("A fault occurred", options?.cause === void 0 ? void 0 : { cause: options.cause });
-		this.report = options?.report ?? true;
-	}
-	render(ctx) {
-		const contact = ctx.developerUsername ?? "the developer";
-		return { components: [new require_cursor.NoticeCard(`Something went wrong. Please reach out to ${contact} with a way to reproduce the error and the following:\n### UUID: \`${ctx.uuid}\``, "Error").component] };
-	}
-};
-
-//#endregion
-//#region src/gates/combinators.ts
-function and(...gates) {
-	return require_cursor.defineGate(gates.map((gate) => gate.name).join(" & "), async (ctx) => {
-		for (const gate of gates) await require_cursor.runCheck(gate, ctx);
-	});
-}
-function isOrOptions(arg) {
-	return !("check" in arg);
-}
-function or(...args) {
-	const last = args.at(-1);
-	const options = last !== void 0 && isOrOptions(last) ? last : void 0;
-	const gates = options ? args.slice(0, -1) : args;
-	return require_cursor.defineGate(gates.map((gate) => gate.name).join(" | "), async (ctx) => {
-		const summaries = [];
-		let everyArmHasSummary = true;
-		for (const gate of gates) {
-			const mark = require_cursor.markCommits(ctx);
-			try {
-				await require_cursor.runCheck(gate, ctx);
-				return;
-			} catch (error) {
-				if (error instanceof require_cursor.Notice && !(error instanceof Fault) && !error.report) {
-					require_cursor.rollbackCommits(ctx, mark);
-					if (error.summary === void 0) everyArmHasSummary = false;
-					else summaries.push(error.summary);
-					continue;
-				}
-				throw error;
-			}
-		}
-		if (options) throw typeof options.fail === "function" ? options.fail(ctx) : options.fail;
-		if (everyArmHasSummary && summaries.length > 0) throw new require_cursor.NeedsAny(summaries);
-		throw new require_cursor.NotAllowed();
-	});
-}
-
-//#endregion
-//#region src/gates/catalog/access.ts
-/**
-* Passes only for a user id listed in `config.ownerIds`, else refuses.
-*
-* Agnostic, so it attaches to interaction and event handlers alike. With no `ownerIds` configured it refuses every caller. Pass {@link GateNoticeOptions} to reword or replace the refusal.
-*
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
-*
-* @see the `@Gated` decorator from `seedcord`
-*
-* @example
-* ```ts
-* \@Gated(OwnerOnly())
-* \@SlashRoute('shutdown')
-* class ShutdownHandler extends SlashHandler<'shutdown'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*
-* @example
-* ```ts
-* // reword the refusal, keeping the embed styling
-* OwnerOnly({ message: 'Owners only.' });
-* ```
-*/
-function OwnerOnly(options) {
-	return require_cursor.defineGate("OwnerOnly", (ctx) => {
-		const owners = ctx.core.config.ownerIds ?? [];
-		if (ctx.userId !== null && owners.includes(ctx.userId)) return;
-		throw require_cursor.pickNotice(options, (message) => new require_cursor.NotOwner(message));
-	});
-}
-/**
-* Passes inside a guild, else refuses.
-*
-* Agnostic. Attaches to any handler kind. Often paired with `RequirePermissions` in an {@link and}.
-*
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
-*
-* @see the `@Gated` decorator from `seedcord`
-*
-* @example
-* ```ts
-* import { PermissionFlagsBits } from 'discord.js';
-*
-* \@Gated(GuildOnly(), RequirePermissions([PermissionFlagsBits.Administrator]))
-* \@SlashRoute('maintenance')
-* class Maintenance extends SlashHandler<'maintenance'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-function GuildOnly(options) {
-	return require_cursor.defineGate("GuildOnly", (ctx) => {
-		if (ctx.guildId) return;
-		throw require_cursor.pickNotice(options, (message) => new require_cursor.NotInGuild(message));
-	});
-}
-/**
-* Passes in a direct message, else refuses.
-*
-* Agnostic, fitting any handler kind. The inverse of {@link GuildOnly}, so combining the two in an {@link and} can never pass.
-*
-* @param options - Reword the default refusal with `message`, or replace it with `notice`.
-*
-* @see the `@Gated` decorator from `seedcord`
-*
-* @example
-* ```ts
-* \@Gated(DmOnly())
-* \@SlashRoute('verify')
-* class VerifyHandler extends SlashHandler<'verify'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-function DmOnly(options) {
-	return require_cursor.defineGate("DmOnly", (ctx) => {
-		if (!ctx.guildId) return;
-		throw require_cursor.pickNotice(options, (message) => new require_cursor.NotInDm(message));
-	});
-}
-
-//#endregion
-//#region src/gates/catalog/Cooldown.ts
-let anonSeq = 0;
-function scopeValue(ctx, per) {
-	if (per === "guild") return ctx.guildId ?? "global";
-	if (per === "channel") return ctx.channelId ?? "global";
-	return ctx.userId ?? "global";
-}
-/**
-* Allows `limit` uses per window, scoped by `per`. A number `duration` is **seconds**, and a string is
-* a duration like `30m` or `24h`. An unparseable string throws a **SeedcordTypeError** at construction. The
-* slot is charged in commit, only after the whole gate set passes, so a later refusal never burns the cooldown.
-* That split also means two requests racing the same key can both pass before either charges the slot.
-* The key combines the handler's route with the window settings, keeping two different handlers on separate
-* windows. Reword the refusal with {@link CooldownOptions.message} or replace it with {@link CooldownOptions.notice}.
-*
-* @param duration - A number is seconds, and a string is a duration like `30m` or `24h`. An unparseable string throws a **SeedcordTypeError**.
-* @param options - Sets the scope with `per`, the uses per window with `limit`, and the refusal text with `message` or `notice`.
-*
-* @see the `@Gated` decorator from `seedcord`
-* @see {@link IRateLimiter}
-*
-* @example
-* ```ts
-* // a number argument is SECONDS
-* \@Gated(Cooldown(5))
-* \@SlashRoute('daily')
-* class DailyHandler extends SlashHandler<'daily'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*
-* @example
-* ```ts
-* // a string is a duration, here scoped per guild (the default is per user)
-* Cooldown('30m', { per: 'guild' });
-* ```
-*
-* @example
-* ```ts
-* // a burst, 3 uses per 10 minutes per user, then it refuses until a slot frees
-* \@Gated(Cooldown('10m', { limit: 3 }))
-* \@SlashRoute('report')
-* class ReportHandler extends SlashHandler<'report'> {
-*     async execute() {
-*         // ...
-*     }
-* }
-* ```
-*/
-function Cooldown(duration, options) {
-	let windowMs;
-	if (typeof duration === "number") windowMs = duration * 1e3;
-	else {
-		const parsed = (0, _seedcord_utils.parseDuration)(duration);
-		if (parsed === null) throw new _seedcord_errors_internal.SeedcordTypeError(_seedcord_errors.SeedcordErrorCode.GateInvalidCooldownDuration, [duration]);
-		windowMs = parsed;
-	}
-	if (windowMs <= 0) throw new _seedcord_errors_internal.SeedcordTypeError(_seedcord_errors.SeedcordErrorCode.GateInvalidCooldownDuration, [String(duration)]);
-	const per = options?.per ?? "user";
-	const window = options?.limit === void 0 ? { windowMs } : {
-		windowMs,
-		limit: options.limit
-	};
-	const anonId = anonSeq++;
-	const keyOf = (ctx) => `cooldown:${ctx.routeId ?? `anon${anonId}`}:${per}:w${windowMs}:l${options?.limit ?? 1}:${scopeValue(ctx, per)}`;
-	return require_cursor.defineEffectGate("Cooldown", async (ctx) => {
-		const result = await ctx.core.rateLimiter.peek(keyOf(ctx), window);
-		if (!result.limited) return;
-		if (options?.notice) throw options.notice(result.resetAt);
-		throw new require_cursor.OnCooldown(result.resetAt, options?.message?.(result.resetAt));
-	}, async (ctx) => {
-		await ctx.core.rateLimiter.charge(keyOf(ctx), window);
-	});
-}
-
-//#endregion
-//#region src/permissions/assert.ts
-/**
-* Refuses when the subject is missing a permission in `scope`, or with `inverse` when it holds one.
-* The Administrator bit passes any scope, and on the inverse arm it reports every bit in `scope`.
-*
-* The caller computes `permissions`, gateway off a discord.js role, member, or channel, and HTTP off the
-* bitfield the interaction payload carries.
-*
-* @throws A {@link Notice} listing the missing or present permissions.
-*
-* @example
-* ```ts
-* import { assertPermissions } from '@seedcord/core';
-* import { PermissionFlagsBits } from 'discord-api-types/v10';
-*
-* // gateway, the bits come off a discord.js member
-* assertPermissions({
-*     subject: `<@${member.id}>`,
-*     permissions: member.permissions.bitfield,
-*     scope: [PermissionFlagsBits.BanMembers]
-* });
-* ```
-*
-* @example
-* ```ts
-* // HTTP, the payload carries the member's bits as a string
-* assertPermissions({
-*     subject: `<@${this.event.member.user.id}>`,
-*     permissions: BigInt(this.event.member.permissions),
-*     scope: [PermissionFlagsBits.ManageMessages]
-* });
-* ```
-*
-* @example
-* ```ts
-* // inverse, refuse a role that carries Administrator
-* assertPermissions({
-*     subject: `<@&${role.id}>`,
-*     permissions: role.permissions.bitfield,
-*     scope: [PermissionFlagsBits.Administrator],
-*     inverse: true
-* });
-* ```
-*
-* @example
-* ```ts
-* import { Notice } from '@seedcord/core';
-*
-* // a replacement notice takes the same three arguments the default one does
-* class CannotBan extends Notice {
-*     public constructor(
-*         message: string | undefined,
-*         private readonly subject: string,
-*         private readonly missing: readonly string[]
-*     ) {
-*         super(message ?? 'You cannot ban here.');
-*     }
-*
-*     public render(): ReplyResponse {
-*         return { components: [new BanDenied(this.subject, this.missing).component] };
-*     }
-* }
-*
-* assertPermissions({
-*     subject: `<@${member.id}>`,
-*     permissions: member.permissions.bitfield,
-*     scope: [PermissionFlagsBits.BanMembers],
-*     missingNotice: CannotBan
-* });
-* ```
-*/
-function assertPermissions(check) {
-	const { subject, permissions, scope, inverse = false, missingNotice, dangerousNotice } = check;
-	if (inverse) {
-		const present = require_cursor.presentNames(permissions, scope);
-		if (present.length === 0) return;
-		throw new (dangerousNotice ?? require_cursor.HasDangerousPermissions)(void 0, subject, present);
-	}
-	if (require_cursor.hasAll(permissions, scope)) return;
-	throw new (missingNotice ?? require_cursor.MissingPermissions)(void 0, subject, require_cursor.missingNames(permissions, scope));
-}
-
-//#endregion
-//#region src/permissions/mergeRoles.ts
-/**
-* The role ids a member holds after adding and removing the given sets. Removals win over additions.
-*
-* This does not write the roles. Apply the result with `member.roles.set()` on gateway, or PATCH the member over HTTP.
-*
-* @param current - The role ids the member holds.
-* @param add - The role ids to add.
-* @param remove - The role ids to remove.
-* @returns The merged role ids.
-*
-* @example
-* ```ts
-* import { mergeRoles } from '@seedcord/core';
-*
-* // gateway
-* const ids = mergeRoles(member.roles.cache.map((role) => role.id), ['123'], ['456']);
-* await member.roles.set(ids);
-* ```
-*/
-function mergeRoles(current, add, remove) {
-	return [...new Set(current).union(new Set(add)).difference(new Set(remove))];
-}
-
-//#endregion
-//#region src/pagination/paginate.ts
-/**
-* Pure page math, usable headless. Clamps `page` into range and slices the window.
-*
-* @param items - The full list to page over.
-* @param page - The requested zero-based page, clamped into `[0, totalPages - 1]`.
-* @param perPage - The page size. Must be a positive integer.
-* @returns The sliced {@link PageView}, with `totalPages` always known.
-* @throws SeedcordRangeError when `perPage` is not a positive integer.
-*/
-function paginate(items, page, perPage) {
-	if (!Number.isSafeInteger(perPage) || perPage <= 0) throw new _seedcord_errors_internal.SeedcordRangeError(_seedcord_errors.SeedcordErrorCode.PaginationInvalidPerPage, [perPage]);
-	const totalPages = Math.max(1, Math.ceil(items.length / perPage));
-	const clamped = Math.min(Math.max(Math.trunc(page), 0), totalPages - 1);
-	const start = clamped * perPage;
-	return {
-		items: items.slice(start, start + perPage),
-		page: clamped,
-		perPage,
-		totalPages,
-		hasPrev: clamped > 0,
-		hasNext: clamped < totalPages - 1
-	};
-}
-
-//#endregion
-//#region src/pagination/controls.ts
-const DEFAULT_LABEL = {
-	first: "First",
-	prev: "Prev",
-	indicator: "",
-	next: "Next",
-	last: "Last"
-};
-const CONTROL_SLOT = {
-	first: 0,
-	prev: 1,
-	indicator: 2,
-	next: 3,
-	last: 4
-};
-const MAX_BUTTONS_PER_ROW = 5;
-var Controls = class {
-	cursor;
-	view;
-	constructor(cursor, view) {
-		this.cursor = cursor;
-		this.view = view;
-	}
-	button(key, cosmetics) {
-		const { target, disabled } = this.navState(key);
-		const defaultLabel = key === "indicator" ? this.indicatorText() : DEFAULT_LABEL[key];
-		const label = cosmetics?.label ?? (key === "indicator" || !cosmetics?.emoji ? defaultLabel : void 0);
-		const button = new _discordjs_builders.ButtonBuilder().setCustomId(this.cursor.encode({
-			page: Math.min(Math.max(0, target), require_cursor.PAGE_MAX),
-			slot: CONTROL_SLOT[key]
-		})).setStyle(cosmetics?.style ?? discord_api_types_v10.ButtonStyle.Secondary).setDisabled(disabled);
-		if (label !== void 0) button.setLabel(label);
-		if (cosmetics?.emoji) button.setEmoji(cosmetics.emoji);
-		return button;
-	}
-	navState(key) {
-		const { page, totalPages, hasPrev, hasNext } = this.view;
-		const knownTotal = totalPages !== void 0;
-		return {
-			target: {
-				first: 0,
-				prev: page - 1,
-				indicator: page,
-				next: page + 1,
-				last: knownTotal ? totalPages - 1 : page
-			}[key],
-			disabled: {
-				first: !hasPrev,
-				prev: !hasPrev,
-				indicator: true,
-				next: !hasNext || page + 1 > 1e6,
-				last: !hasNext || !knownTotal || totalPages - 1 > 1e6
-			}[key]
-		};
-	}
-	row(...keys) {
-		if (keys.length === 0) throw new _seedcord_errors_internal.SeedcordRangeError(_seedcord_errors.SeedcordErrorCode.PaginationEmptyControls);
-		if (keys.length > MAX_BUTTONS_PER_ROW) throw new _seedcord_errors_internal.SeedcordRangeError(_seedcord_errors.SeedcordErrorCode.PaginationTooManyControls, [keys.length]);
-		const seen = /* @__PURE__ */ new Set();
-		for (const key of keys) {
-			if (seen.has(key)) throw new _seedcord_errors_internal.SeedcordTypeError(_seedcord_errors.SeedcordErrorCode.PaginationDuplicateControls, [key]);
-			seen.add(key);
-		}
-		return new _discordjs_builders.ActionRowBuilder().addComponents(keys.map((key) => this.button(key)));
-	}
-	indicatorText() {
-		const { page, totalPages } = this.view;
-		return totalPages === void 0 ? `Page ${page + 1}` : `Page ${page + 1} of ${totalPages}`;
-	}
-};
-
-//#endregion
-//#region src/pagination/render.ts
-var PageContainer = class extends require_publishDefault.BuilderComponent {
-	constructor(view, renderItem, controlRow) {
-		super("container");
-		const base = view.page * view.perPage;
-		let lines = [];
-		const flush = () => {
-			if (lines.length === 0) return;
-			this.instance.addTextDisplayComponents(new _discordjs_builders.TextDisplayBuilder().setContent(lines.join("\n")));
-			lines = [];
-		};
-		view.items.forEach((item, offset) => {
-			const rendered = renderItem(item, base + offset);
-			if (typeof rendered === "string") {
-				lines.push(rendered);
-				return;
-			}
-			flush();
-			this.instance.addSectionComponents(rendered.component);
-		});
-		flush();
-		this.instance.addActionRowComponents(controlRow);
-	}
-};
-function toReplyResponse(renderable) {
-	if (typeof renderable === "string") return { components: [new _discordjs_builders.TextDisplayBuilder().setContent(renderable)] };
-	if (Array.isArray(renderable)) return { components: renderable };
-	return renderable;
-}
-const ARRAY_KEYS = [
-	"first",
-	"prev",
-	"indicator",
-	"next",
-	"last"
-];
-const CURSOR_KEYS = [
-	"prev",
-	"indicator",
-	"next"
-];
-function renderPage(view, cursor, config) {
-	const controls = new Controls(cursor, view);
-	if (config.render) return toReplyResponse(config.render(view, controls));
-	const renderItem = config.renderItem ?? String;
-	const row = controls.row(...view.totalPages === void 0 ? CURSOR_KEYS : ARRAY_KEYS);
-	return { components: [new PageContainer(view, renderItem, row).component] };
-}
-
-//#endregion
-//#region src/pagination/PaginatorBase.ts
-/**
-* Holds a paginator's cursor and renders one page. Each transport extends this to add the nav handler and
-* the method that sends the first page.
-*
-* @typeParam Item - The item type, inferred from the source.
-* @typeParam Prefix - The route prefix, inferred from `config.prefix`.
-* @typeParam Ctx - The transport's page context.
-*/
-var PaginatorBase = class {
-	/** The page cursor, pass it to your `@ButtonRoute`. */
-	cursor;
-	config;
-	constructor(config) {
-		this.cursor = require_cursor.pageCursor(config.prefix);
-		this.config = config;
-	}
-	/** Render a page as a {@link ReplyResponse}. To post it elsewhere, add `flags: MessageFlags.IsComponentsV2`. */
-	async page(ctx, n) {
-		const view = await this.config.source.page(ctx, n);
-		return renderPage(view, this.cursor, this.config);
-	}
-};
-
-//#endregion
-//#region src/pagination/sources.ts
-const DEFAULT_PER_PAGE = 10;
-function perPageOf(opts) {
-	const perPage = opts?.perPage ?? DEFAULT_PER_PAGE;
-	if (!Number.isSafeInteger(perPage) || perPage <= 0) throw new _seedcord_errors_internal.SeedcordRangeError(_seedcord_errors.SeedcordErrorCode.PaginationInvalidPerPage, [perPage]);
-	return perPage;
-}
-/**
-* A source for a bounded list you can load whole. It loads the full list on every click, then slices the
-* page via {@link paginate}, so the real total is known (a real last button, "Page X of Y"). Cache inside
-* your loader if the load is expensive.
-*
-* @typeParam Item - The item type, inferred from the loader's return.
-* @typeParam Ctx - The transport's page context. Each transport exports a subclass that fixes it.
-*/
-var ArraySource = class {
-	load;
-	perPage;
-	constructor(load, opts) {
-		this.load = load;
-		this.perPage = perPageOf(opts);
-	}
-	async page(ctx, n) {
-		return paginate(await this.load(ctx), n, this.perPage);
-	}
-};
-/**
-* A source for a large or unknown-length set you fetch one page at a time (SQL LIMIT/OFFSET, a paged API).
-* The fetcher receives the page index and the page size and reports whether a next page exists. A cursor
-* source has no cheap total, so `totalPages` is undefined, the last button is omitted, and the indicator
-* reads "Page X".
-*
-* @typeParam Item - The item type, inferred from the fetcher's slice.
-* @typeParam Ctx - The transport's page context. Each transport exports a subclass that fixes it.
-*/
-var CursorSource = class {
-	fetch;
-	perPage;
-	constructor(fetch, opts) {
-		this.fetch = fetch;
-		this.perPage = perPageOf(opts);
-	}
-	async page(ctx, n) {
-		const page = Math.max(0, Math.trunc(n));
-		const { items, hasNext } = await this.fetch(ctx, page, this.perPage);
-		return {
-			items: [...items],
-			page,
-			perPage: this.perPage,
-			hasPrev: page > 0,
-			hasNext
-		};
-	}
-};
-
-//#endregion
-//#region src/index.ts
-/** Package version */
-const version = "0.1.3";
-
-//#endregion
-exports.ArraySource = ArraySource;
-exports.AutocompleteRoute = AutocompleteRoute;
-exports.BaseHandler = BaseHandler;
-exports.BuilderComponent = require_publishDefault.BuilderComponent;
-exports.Bus = require_subscribers.Bus;
-exports.ButtonRoute = ButtonRoute;
-exports.Commands = require_cursor.Commands;
-exports.ContextMenuRoute = ContextMenuRoute;
-exports.ContextMenus = require_cursor.ContextMenus;
-exports.Cooldown = Cooldown;
-exports.CursorSource = CursorSource;
-exports.CustomId = require_cursor.CustomId;
-exports.DispatchContext = DispatchContext;
-exports.DmOnly = DmOnly;
-exports.Fault = Fault;
-exports.GuildOnly = GuildOnly;
-exports.ModalRoute = ModalRoute;
-exports.Notice = require_cursor.Notice;
-exports.OwnerOnly = OwnerOnly;
-exports.PaginatorBase = PaginatorBase;
-exports.RegisterCommand = RegisterCommand;
-exports.RepliableHandler = RepliableHandler;
-exports.RequireBotPermissions = require_cursor.RequireBotPermissions;
-exports.RequirePermissions = require_cursor.RequirePermissions;
-exports.RequireRole = require_cursor.RequireRole;
-exports.RowComponent = require_publishDefault.RowComponent;
-exports.SelectMenuKind = require_cursor.SelectMenuKind;
-exports.SelectMenuRoute = SelectMenuRoute;
-exports.ShutdownPhase = require_phases.ShutdownPhase;
-exports.Silence = require_cursor.Silence;
-exports.SlashRoute = SlashRoute;
-exports.StartupPhase = require_phases.StartupPhase;
-exports.Subscribe = require_subscribers.Subscribe;
-exports.Subscriber = require_subscribers.Subscriber;
-exports.WebhookLog = require_subscribers.WebhookLog;
-exports.WebhookUrl = require_subscribers.WebhookUrl;
-exports.and = and;
-exports.assertPermissions = assertPermissions;
-exports.defineEffectGate = require_cursor.defineEffectGate;
-exports.defineGate = require_cursor.defineGate;
-exports.mergeRoles = mergeRoles;
-exports.or = or;
-exports.paginate = paginate;
-exports.version = version;
-//# sourceMappingURL=index.cjs.map