@discordkit/core 3.1.0 → 4.0.0

package/dist/validations/fileUpload.mjs

@@ -0,0 +1,114 @@
+import { isObject } from "../utils/isObject.mjs";
+import * as v from "valibot";
+//#region src/validations/fileUpload.ts
+/** Type guard — true if `val` looks like a {@link FileUpload}. */
+const isFileUpload = (val) => {
+	if (!isObject(val)) return false;
+	const record = val;
+	return typeof record.filename === `string` && typeof record.content?.arrayBuffer === `function`;
+};
+/**
+* Valibot schema for a single file upload. Validates the shape and
+* surfaces a clean TypeScript type to consumers.
+*/
+const fileUpload = v.pipe(v.custom(isFileUpload, `Expected a FileUpload object`), v.title(`fileUpload`));
+/**
+* Walks a value and returns all {@link FileUpload}s within it, along
+* with the path each one occupies.
+*/
+const collectFileUploads = (val, path = []) => {
+	if (isFileUpload(val)) return [{
+		path,
+		file: val
+	}];
+	if (Array.isArray(val)) return val.flatMap((item, i) => collectFileUploads(item, [...path, i]));
+	if (isObject(val)) return Object.entries(val).flatMap(([key, item]) => collectFileUploads(item, [...path, key]));
+	return [];
+};
+/**
+* Returns a deep copy of `body` with the value at `path` replaced by
+* `replacement`. Pure: never mutates `body` or any of its children.
+*/
+const replaceAtPath = (body, path, replacement) => {
+	if (path.length === 0) return replacement;
+	const [head, ...rest] = path;
+	if (Array.isArray(body)) return body.map((item, index) => index === head ? replaceAtPath(item, rest, replacement) : item);
+	if (isObject(body)) return Object.fromEntries(Object.entries(body).map(([key, item]) => [key, key === head ? replaceAtPath(item, rest, replacement) : item]));
+	return body;
+};
+/**
+* Given a body that contains one or more {@link FileUpload}s, produce
+* a `FormData` payload Discord can consume.
+*
+* Files are appended as `files[n]` parts; the rest of the body is
+* snake_cased and JSON-stringified into a `payload_json` part.
+*
+* Each FileUpload in the body is replaced by its attachment placeholder
+* `{ id: n }` so that an `attachments` array (if present) can reference
+* uploads by index. Discord matches these placeholders to the
+* corresponding `files[n]` parts.
+*/
+const toMultipartBody = (body, toSnakeKeys) => {
+	const uploads = collectFileUploads(body);
+	if (uploads.length === 0) throw new Error(`toMultipartBody called with a body containing no FileUploads`);
+	const payload = uploads.reduce((acc, { path }, index) => replaceAtPath(acc, path, { id: index }), body);
+	const fileEntries = uploads.map(({ file }, index) => {
+		const blob = file.contentType && file.content.type !== file.contentType ? new Blob([file.content], { type: file.contentType }) : file.content;
+		return [
+			`files[${index}]`,
+			blob,
+			file.filename
+		];
+	});
+	const payloadJson = new Blob([JSON.stringify(toSnakeKeys(payload))], { type: `application/json` });
+	const form = new FormData();
+	fileEntries.forEach(([name, blob, filename]) => form.append(name, blob, filename));
+	form.append(`payload_json`, payloadJson);
+	return form;
+};
+/**
+* Sentinel symbol used to mark a validated body as multipart-eligible.
+* Read by the request layer at serialization time.
+*
+* The marker is attached as a non-enumerable property on the parsed
+* body so it doesn't leak into JSON serialization or the TypeScript
+* output type.
+*/
+const MULTIPART_MARKER = Symbol.for(`@discordkit/core/multipart`);
+/**
+* Returns true if `body` should be serialized as `multipart/form-data`.
+*
+* Two signals trigger multipart serialization:
+*
+* 1. **Schema-tagged** — the body was parsed by a {@link multipart}-wrapped
+*    schema and at least one {@link FileUpload} was present. The wrapper
+*    stamps a non-enumerable {@link MULTIPART_MARKER} on the parsed value.
+*    This is the fast path for the validated flow (e.g., `toValidated`).
+*
+* 2. **Value-detected** — the body contains a {@link FileUpload} anywhere
+*    in its shape, regardless of whether it was validated. This safety net
+*    keeps consumers who bypass validation from silently dropping their
+*    files into a JSON body where `Blob` would serialize as `{}`.
+*
+* Either signal switches the request to multipart.
+*/
+const shouldSerializeAsMultipart = (body) => {
+	if (typeof body !== `object` || body === null) return false;
+	if (body[MULTIPART_MARKER] === true) return true;
+	return collectFileUploads(body).length > 0;
+};
+function multipart(entries, options) {
+	const base = v.object(entries);
+	const inner = options?.partial ? v.partial(base) : base;
+	return v.pipe(inner, v.transform((parsed) => {
+		if (!(collectFileUploads(parsed).length > 0)) return parsed;
+		return Object.defineProperty(parsed, MULTIPART_MARKER, {
+			value: true,
+			enumerable: false,
+			configurable: false,
+			writable: false
+		});
+	}));
+}
+//#endregion
+export { MULTIPART_MARKER, collectFileUploads, fileUpload, isFileUpload, multipart, shouldSerializeAsMultipart, toMultipartBody };

package/dist/validations/hasMimeType.d.mts

@@ -0,0 +1,16 @@
+import { CheckAction } from "valibot";
+
+//#region src/validations/hasMimeType.d.ts
+/**
+ * Validation action to check if the given `datauri` string
+ * has one of the provided [MIME types](https://en.wikipedia.org/wiki/Media_type)
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const hasMimeType: (/** an array of MIME types to validate against */
+
+requirement: Array<`${string}/${string}`>, /** an optional error message on failed validation */
+
+message?: "Received badly formatted Data URI") => CheckAction<string, typeof message>;
+//#endregion
+export { hasMimeType };

package/dist/validations/hasMimeType.mjs

@@ -0,0 +1,16 @@
+import { extractDataURIMetadata } from "./datauri.mjs";
+import { check } from "valibot";
+//#region src/validations/hasMimeType.ts
+/**
+* Validation action to check if the given `datauri` string
+* has one of the provided [MIME types](https://en.wikipedia.org/wiki/Media_type)
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const hasMimeType = (requirement, message = `Received badly formatted Data URI`) => check((input) => {
+	const { mimeType } = extractDataURIMetadata(input);
+	if (typeof mimeType === `undefined`) return false;
+	return requirement.includes(mimeType);
+}, message);
+//#endregion
+export { hasMimeType };

package/dist/validations/hasSize.d.mts

@@ -0,0 +1,10 @@
+import { CheckAction } from "valibot";
+
+//#region src/validations/hasSize.d.ts
+/** @__NO_SIDE_EFFECTS__ */
+declare const hasSize: (size: number | {
+  min?: number;
+  max?: number;
+}, message?: "Data URI is the incorrect size") => CheckAction<string, typeof message>;
+//#endregion
+export { hasSize };

package/dist/validations/hasSize.mjs

@@ -0,0 +1,12 @@
+import { extractDataURIMetadata, toBase64 } from "./datauri.mjs";
+import { check } from "valibot";
+//#region src/validations/hasSize.ts
+/** @__NO_SIDE_EFFECTS__ */
+const hasSize = (size, message = `Data URI is the incorrect size`) => check((dataURI) => {
+	const { data } = extractDataURIMetadata(dataURI);
+	if (typeof data === `undefined`) throw new Error(`Received badly formatted Data URI`);
+	const actual = toBase64(data).length;
+	return typeof size === `number` ? size === actual : actual >= (size.min ?? 0) && actual <= (size.max ?? Infinity);
+}, message);
+//#endregion
+export { hasSize };

package/dist/validations/index.d.mts

@@ -0,0 +1,15 @@
+import { Flags, bitfield } from "./bitfield.mjs";
+import { asDigits } from "./asDigits.mjs";
+import { asInteger } from "./asInteger.mjs";
+import { boundedArray } from "./boundedArray.mjs";
+import { boundedInteger } from "./boundedInteger.mjs";
+import { boundedString } from "./boundedString.mjs";
+import { datauri, datauriRegex, extractDataURIMetadata, toBase64 } from "./datauri.mjs";
+import { FileUpload, MULTIPART_MARKER, collectFileUploads, fileUpload, isFileUpload, multipart, shouldSerializeAsMultipart, toMultipartBody } from "./fileUpload.mjs";
+import { hasMimeType } from "./hasMimeType.mjs";
+import { omitFields, partialSchema, pickFields, requiredFields, schema, variantSchema } from "./schema.mjs";
+import { toBlob } from "./toBlob.mjs";
+import { DISCORD_EPOCH, snowflake, snowflakeToDate } from "./snowflake.mjs";
+import { timestamp } from "./timestamp.mjs";
+import { url } from "./url.mjs";
+export { DISCORD_EPOCH, FileUpload, Flags, MULTIPART_MARKER, asDigits, asInteger, bitfield, boundedArray, boundedInteger, boundedString, collectFileUploads, datauri, datauriRegex, extractDataURIMetadata, fileUpload, hasMimeType, isFileUpload, multipart, omitFields, partialSchema, pickFields, requiredFields, schema, shouldSerializeAsMultipart, snowflake, snowflakeToDate, timestamp, toBase64, toBlob, toMultipartBody, url, variantSchema };

package/dist/validations/index.mjs

@@ -0,0 +1,15 @@
+import { MULTIPART_MARKER, collectFileUploads, fileUpload, isFileUpload, multipart, shouldSerializeAsMultipart, toMultipartBody } from "./fileUpload.mjs";
+import { asDigits } from "./asDigits.mjs";
+import { asInteger } from "./asInteger.mjs";
+import { bitfield } from "./bitfield.mjs";
+import { boundedArray } from "./boundedArray.mjs";
+import { boundedInteger } from "./boundedInteger.mjs";
+import { boundedString } from "./boundedString.mjs";
+import { datauri, datauriRegex, extractDataURIMetadata, toBase64 } from "./datauri.mjs";
+import { hasMimeType } from "./hasMimeType.mjs";
+import { omitFields, partialSchema, pickFields, requiredFields, schema, variantSchema } from "./schema.mjs";
+import { toBlob } from "./toBlob.mjs";
+import { DISCORD_EPOCH, snowflake, snowflakeToDate } from "./snowflake.mjs";
+import { timestamp } from "./timestamp.mjs";
+import { url } from "./url.mjs";
+export { DISCORD_EPOCH, MULTIPART_MARKER, asDigits, asInteger, bitfield, boundedArray, boundedInteger, boundedString, collectFileUploads, datauri, datauriRegex, extractDataURIMetadata, fileUpload, hasMimeType, isFileUpload, multipart, omitFields, partialSchema, pickFields, requiredFields, schema, shouldSerializeAsMultipart, snowflake, snowflakeToDate, timestamp, toBase64, toBlob, toMultipartBody, url, variantSchema };

package/dist/validations/schema.d.mts

@@ -0,0 +1,102 @@
+import * as v from "valibot";
+
+//#region src/validations/schema.d.ts
+/**
+ * Annotate a schema's *published* type as `v.GenericSchema<T>` so
+ * downstream `.d.ts` emit stops inlining the inner `ObjectSchema`'s
+ * entries map and instead references `T` by name. The runtime value
+ * is unchanged.
+ *
+ * Use at every type-defining schema export:
+ *
+ * ```ts
+ * const _userSchema = v.object({...});
+ * export interface User extends v.InferOutput<typeof _userSchema> {}
+ * export const userSchema = schema<User>(_userSchema);
+ * ```
+ *
+ * **Why this exists**
+ *
+ * Without annotation, `typeof userSchema` is the full
+ * `v.ObjectSchema<{ id: v.GenericSchema<string>, ... }>` shape. Every
+ * downstream file that references `userSchema` (Guild, Application,
+ * Member, …) re-inlines that entries map into its own emitted
+ * declarations. This causes:
+ *
+ *   - dramatic duplication of nested object shapes in `.d.ts` output
+ *   - slow IDE hover (tsserver expands the full shape on every
+ *     reference)
+ *   - occasional TS2502 / type-too-complex errors on deeply circular
+ *     schemas (Channel, Message, …)
+ *
+ * After annotation, downstream `.d.ts` files reference `User` by
+ * name from `./user/types/User.d.mts` and never inline its body.
+ *
+ * **Trade-off**
+ *
+ * `v.partial(userSchema)`, `v.pick(userSchema, [...])`, `v.omit(...)`,
+ * and `userSchema.entries.id` stop type-checking because the constraint
+ * is `ObjectSchema<...>` not `GenericSchema<T>`. Use the
+ * {@link partialSchema}, {@link pickFields}, {@link omitFields},
+ * {@link requiredFields}, and {@link variantSchema} helpers below for
+ * the common cases.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const schema: <T>(s: v.GenericSchema<unknown>) => v.GenericSchema<T>;
+/**
+ * Make every key of `T` optional, both at the type level and at
+ * runtime. Equivalent to Valibot's `v.partial`, but accepts an
+ * annotated `GenericSchema<T>` (which `v.partial` would reject because
+ * its constraint is `ObjectSchema<...>`).
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const partialSchema: <T>(s: v.GenericSchema<T>) => v.GenericSchema<Partial<T>>;
+/**
+ * Pick a subset of fields from `T` at both type and runtime levels.
+ * Equivalent to Valibot's `v.pick`. See {@link partialSchema}.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const pickFields: <T, K extends keyof T & string>(s: v.GenericSchema<T>, keys: readonly K[]) => v.GenericSchema<Pick<T, K>>;
+/**
+ * Omit a subset of fields from `T` at both type and runtime levels.
+ * Equivalent to Valibot's `v.omit`. See {@link partialSchema}.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const omitFields: <T, K extends keyof T & string>(s: v.GenericSchema<T>, keys: readonly K[]) => v.GenericSchema<Omit<T, K>>;
+/**
+ * Mark a subset of fields on `T` as required at both type and runtime
+ * levels. Equivalent to Valibot's `v.required`. See {@link partialSchema}.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const requiredFields: <T, K extends keyof T & string>(s: v.GenericSchema<T>, keys: readonly K[]) => v.GenericSchema<T & Required<Pick<T, K>>>;
+/**
+ * Build a discriminated union schema. Equivalent to Valibot's
+ * `v.variant`, but accepts annotated `GenericSchema<T>` variants
+ * (which `v.variant` would reject because its constraint is
+ * `ObjectSchema<...>`).
+ *
+ * Prefer `v.variant` whenever variants share a literal discriminator
+ * field — it dispatches on that field at runtime, producing focused
+ * error messages and O(1) validation, vs. {@link v.union}'s O(n)
+ * try-each behavior.
+ *
+ * @example
+ * ```ts
+ * export const channelSchema = variantSchema<Channel>(`type`, [
+ *   guildTextChannelSchema,
+ *   guildVoiceChannelSchema,
+ *   threadChannelSchema,
+ *   // ...
+ * ]);
+ * ```
+ *
+ * @__NO_SIDE_EFFECTS__
+ */
+declare const variantSchema: <T>(key: keyof T & string, schemas: ReadonlyArray<v.GenericSchema<unknown>>) => v.GenericSchema<T>;
+//#endregion
+export { omitFields, partialSchema, pickFields, requiredFields, schema, variantSchema };

package/dist/validations/schema.mjs

@@ -0,0 +1,109 @@
+import * as v from "valibot";
+//#region src/validations/schema.ts
+/**
+* Annotate a schema's *published* type as `v.GenericSchema<T>` so
+* downstream `.d.ts` emit stops inlining the inner `ObjectSchema`'s
+* entries map and instead references `T` by name. The runtime value
+* is unchanged.
+*
+* Use at every type-defining schema export:
+*
+* ```ts
+* const _userSchema = v.object({...});
+* export interface User extends v.InferOutput<typeof _userSchema> {}
+* export const userSchema = schema<User>(_userSchema);
+* ```
+*
+* **Why this exists**
+*
+* Without annotation, `typeof userSchema` is the full
+* `v.ObjectSchema<{ id: v.GenericSchema<string>, ... }>` shape. Every
+* downstream file that references `userSchema` (Guild, Application,
+* Member, …) re-inlines that entries map into its own emitted
+* declarations. This causes:
+*
+*   - dramatic duplication of nested object shapes in `.d.ts` output
+*   - slow IDE hover (tsserver expands the full shape on every
+*     reference)
+*   - occasional TS2502 / type-too-complex errors on deeply circular
+*     schemas (Channel, Message, …)
+*
+* After annotation, downstream `.d.ts` files reference `User` by
+* name from `./user/types/User.d.mts` and never inline its body.
+*
+* **Trade-off**
+*
+* `v.partial(userSchema)`, `v.pick(userSchema, [...])`, `v.omit(...)`,
+* and `userSchema.entries.id` stop type-checking because the constraint
+* is `ObjectSchema<...>` not `GenericSchema<T>`. Use the
+* {@link partialSchema}, {@link pickFields}, {@link omitFields},
+* {@link requiredFields}, and {@link variantSchema} helpers below for
+* the common cases.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const schema = (s) => s;
+/**
+* Make every key of `T` optional, both at the type level and at
+* runtime. Equivalent to Valibot's `v.partial`, but accepts an
+* annotated `GenericSchema<T>` (which `v.partial` would reject because
+* its constraint is `ObjectSchema<...>`).
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const partialSchema = (s) => v.partial(s);
+/**
+* Pick a subset of fields from `T` at both type and runtime levels.
+* Equivalent to Valibot's `v.pick`. See {@link partialSchema}.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const pickFields = (s, keys) => {
+	return v.pick(s, keys);
+};
+/**
+* Omit a subset of fields from `T` at both type and runtime levels.
+* Equivalent to Valibot's `v.omit`. See {@link partialSchema}.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const omitFields = (s, keys) => {
+	return v.omit(s, keys);
+};
+/**
+* Mark a subset of fields on `T` as required at both type and runtime
+* levels. Equivalent to Valibot's `v.required`. See {@link partialSchema}.
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const requiredFields = (s, keys) => {
+	return v.required(s, keys);
+};
+/**
+* Build a discriminated union schema. Equivalent to Valibot's
+* `v.variant`, but accepts annotated `GenericSchema<T>` variants
+* (which `v.variant` would reject because its constraint is
+* `ObjectSchema<...>`).
+*
+* Prefer `v.variant` whenever variants share a literal discriminator
+* field — it dispatches on that field at runtime, producing focused
+* error messages and O(1) validation, vs. {@link v.union}'s O(n)
+* try-each behavior.
+*
+* @example
+* ```ts
+* export const channelSchema = variantSchema<Channel>(`type`, [
+*   guildTextChannelSchema,
+*   guildVoiceChannelSchema,
+*   threadChannelSchema,
+*   // ...
+* ]);
+* ```
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const variantSchema = (key, schemas) => {
+	return v.variant(key, schemas);
+};
+//#endregion
+export { omitFields, partialSchema, pickFields, requiredFields, schema, variantSchema };

package/dist/validations/{snowflake.d.ts → snowflake.d.mts}

@@ -1,18 +1,18 @@
 import * as v from "valibot";
+
+//#region src/validations/snowflake.d.ts
 /** UNIX timestamp representing the first second of 2015 */
-export declare const DISCORD_EPOCH = 1420070400000n;
+declare const DISCORD_EPOCH = 1420070400000n;
 /**
  * Converts a `snowflake` string to a Date relative to the given epoch
  *
  * Uses Discord's epoch by default
  *
  * https://discord.com/developers/docs/reference#snowflakes
+ *
+ * @__NO_SIDE_EFFECTS__
  */
-export declare const snowflakeToDate: (
-/** A snowflake string to convert */
-val: string | number | bigint, 
-/** time in milliseconds to use as the epoch to derive a Date from */
-epoch?: bigint) => Date;
+declare const snowflakeToDate: (/** A snowflake string to convert */val: string | number | bigint, /** time in milliseconds to use as the epoch to derive a Date from */epoch?: bigint) => Date;
 /**
  * An up to 64-bit unsigned numeric value derived from a timestamp which
  * serves as a unique identifier within Discord.
@@ -22,4 +22,6 @@ epoch?: bigint) => Date;
  * by checking if it's derived timestamp is a valid time at or after
  * the Discord epoch (the first second of 2015, ie: `1420070400000`).
  */
-export declare const snowflake: v.GenericSchema<string>;
+declare const snowflake: v.GenericSchema<string>;
+//#endregion
+export { DISCORD_EPOCH, snowflake, snowflakeToDate };

package/dist/validations/snowflake.mjs

@@ -0,0 +1,28 @@
+import { isNonNullable } from "../utils/isNonNullable.mjs";
+import { isNumericString } from "../utils/isNumericString.mjs";
+import * as v from "valibot";
+//#region src/validations/snowflake.ts
+/** UNIX timestamp representing the first second of 2015 */
+const DISCORD_EPOCH = 1420070400000n;
+/**
+* Converts a `snowflake` string to a Date relative to the given epoch
+*
+* Uses Discord's epoch by default
+*
+* https://discord.com/developers/docs/reference#snowflakes
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const snowflakeToDate = (val, epoch = DISCORD_EPOCH) => new Date(Number((BigInt(val) >> 22n) + epoch));
+/**
+* An up to 64-bit unsigned numeric value derived from a timestamp which
+* serves as a unique identifier within Discord.
+*
+* Validates whether a given `number`, `bigint`, or numeric `string` is
+* a valid [Snowflake](https://discord.com/developers/docs/reference#snowflakes)
+* by checking if it's derived timestamp is a valid time at or after
+* the Discord epoch (the first second of 2015, ie: `1420070400000`).
+*/
+const snowflake = v.pipe(v.custom((val) => isNonNullable(val) && (typeof val === `bigint` || typeof val === `number` || isNumericString(val)) && snowflakeToDate(val).getTime() >= 1420070400000n, `Invalid Snowflake`), v.title(`snowflake`));
+//#endregion
+export { DISCORD_EPOCH, snowflake, snowflakeToDate };

package/dist/validations/{timestamp.d.ts → timestamp.d.mts}

@@ -1,3 +1,7 @@
 import * as v from "valibot";
+
+//#region src/validations/timestamp.d.ts
 /** An [ISO8601](https://www.loc.gov/standards/datetime/iso-tc154-wg5_n0038_iso_wd_8601-1_2016-02-16.pdf) timestamp */
-export declare const timestamp: v.GenericSchema<string>;
+declare const timestamp: v.GenericSchema<string>;
+//#endregion
+export { timestamp };

package/dist/validations/timestamp.mjs

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+//#region src/validations/timestamp.ts
+/** An [ISO8601](https://www.loc.gov/standards/datetime/iso-tc154-wg5_n0038_iso_wd_8601-1_2016-02-16.pdf) timestamp */
+const timestamp = v.message(v.pipe(v.string(), v.isoTimestamp()), (issue) => `Expected a valid timestamp, received: ${issue.received}`);
+//#endregion
+export { timestamp };

package/dist/validations/toBlob.d.mts

@@ -0,0 +1,9 @@
+import * as _$valibot from "valibot";
+
+//#region src/validations/toBlob.d.ts
+/**
+ * Transforms a `datauri` string to a Blob
+ */
+declare const toBlob: _$valibot.TransformAction<string, Blob>;
+//#endregion
+export { toBlob };

package/dist/validations/toBlob.mjs

@@ -0,0 +1,17 @@
+import { extractDataURIMetadata, toBase64 } from "./datauri.mjs";
+import { transform } from "valibot";
+//#region src/validations/toBlob.ts
+/**
+* Transforms a `datauri` string to a Blob
+*/
+const toBlob = transform((dataURI) => {
+	const { mimeType, data } = extractDataURIMetadata(dataURI);
+	if (typeof mimeType === `undefined` || typeof data === `undefined`) throw new Error(`Received badly formatted Data URI`);
+	const base64 = toBase64(data);
+	const ab = new ArrayBuffer(base64.length);
+	const ia = new Uint8Array(ab);
+	for (let i = 0; i < base64.length; i++) ia[i] = base64.charCodeAt(i);
+	return new Blob([ab], { type: mimeType });
+});
+//#endregion
+export { toBlob };

package/dist/validations/url.d.mts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+
+//#region src/validations/url.d.ts
+declare const url: v.GenericSchema<string>;
+//#endregion
+export { url };

package/dist/validations/url.mjs

@@ -0,0 +1,5 @@
+import * as v from "valibot";
+//#region src/validations/url.ts
+const url = v.message(v.pipe(v.string(), v.url()), (issue) => `Expected a valid URL, received: ${issue.received}`);
+//#endregion
+export { url };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@discordkit/core",
   "description": "Core utility functions for Discordkit",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "license": "MIT",
   "author": "Drake Costa <drake@saeris.gg> (https://saeris.gg)",
   "keywords": [
@@ -20,21 +20,16 @@
     "registry": "https://registry.npmjs.org"
   },
   "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "imports": {
-    "#mock-utils": "../../scripts/mock-utils.ts",
-    "#test-utils": "../../scripts/test-utils.ts"
-  },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "development": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     },
     "./*": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
+      "development": "./src/*.ts",
+      "types": "./dist/*.d.mts",
+      "import": "./dist/*.mjs"
     },
     "./package.json": "./package.json"
   },
@@ -42,18 +37,13 @@
     "dist/**/*"
   ],
   "sideEffects": false,
-  "scripts": {
-    "dev": "yarn build --watch --declarationmap",
-    "build": "tsc",
-    "lint": "eslint --cache"
-  },
   "peerDependencies": {
-    "valibot": ">= 1.0.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.8.3"
+    "valibot": ">= 1.4.0"
   },
   "dependencies": {
-    "type-fest": "^4.41.0"
+    "type-fest": "^5.6.0"
+  },
+  "devDependencies": {
+    "@discordkit/test-utils": "^0.0.0"
   }
-}
+}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./requests/index.js";
-export * from "./validations/index.js";

package/dist/index.js

@@ -1,3 +0,0 @@
-export * from "./requests/index.js";
-export * from "./validations/index.js";
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC"}

package/dist/requests/DiscordSession.d.ts

@@ -1,16 +0,0 @@
-export declare const endpoint = "https://discord.com/api/v10/";
-/** @internal */
-export declare class DiscordSession {
-    #private;
-    endpoint: string;
-    get ready(): boolean;
-    constructor(authToken?: `${`Bot` | `Bearer`} ${string}` | null);
-    /**
-     * Clears the current session details, then attempts to set
-     * new session values
-     */
-    setToken: (token: `${`Bot` | `Bearer`} ${string}`) => this;
-    clearSession: () => this;
-    getSession: () => string;
-}
-export declare const discord: DiscordSession;