@kanun-hq/plugin-file 0.1.0

package/dist/index.js

@@ -0,0 +1,665 @@
+import { statSync } from "node:fs";
+import { extname } from "node:path";
+import { imageSize } from "image-size";
+import { deepFind, deepSet, definePlugin, getValidatorContext, useValidatorContext } from "kanun";
+
+//#region src/adapters.ts
+const dynamicImport = new Function("specifier", "return import(specifier)");
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBlobLike$1(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFileLike$1(value) {
+	if (isBlobLike$1(value)) return true;
+	if (!isRecord$1(value)) return false;
+	return [
+		"buffer",
+		"fieldname",
+		"filename",
+		"mimetype",
+		"name",
+		"originalname",
+		"path",
+		"size",
+		"type"
+	].some((key) => typeof value[key] !== "undefined");
+}
+function isFileArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((item) => isFileLike$1(item));
+}
+function hasNamedFiles(value) {
+	return Object.keys(value).length > 0;
+}
+function appendNamedFile(target, field, value) {
+	if (!field) return;
+	const current = target[field];
+	if (typeof current === "undefined") {
+		target[field] = value;
+		return;
+	}
+	if (Array.isArray(current)) {
+		current.push(value);
+		return;
+	}
+	target[field] = [current, value];
+}
+function extractNamedFilesFromRecord(value) {
+	if (!isRecord$1(value)) return {};
+	const files = {};
+	for (const [key, entry] of Object.entries(value)) if (isFileLike$1(entry) || isFileArray(entry)) files[key] = entry;
+	return files;
+}
+function extractFilesFromFormData(formData) {
+	const files = {};
+	formData.forEach((entry, field) => {
+		if (isBlobLike$1(entry)) appendNamedFile(files, field, entry);
+	});
+	return files;
+}
+function mergeRequestFiles(validator, requestFiles, extraContext) {
+	const currentContext = validator.getContext();
+	const existingRequestFiles = isRecord$1(currentContext.requestFiles) ? currentContext.requestFiles : {};
+	return validator.withContext({
+		...currentContext,
+		...extraContext,
+		requestFiles: {
+			...existingRequestFiles,
+			...requestFiles
+		}
+	});
+}
+function useRequestFilesContext(requestFiles, extraContext) {
+	const currentContext = getValidatorContext();
+	const existingRequestFiles = isRecord$1(currentContext.requestFiles) ? currentContext.requestFiles : {};
+	return useValidatorContext({
+		...extraContext,
+		requestFiles: {
+			...existingRequestFiles,
+			...requestFiles
+		}
+	});
+}
+function extractExpressRequestFiles(request) {
+	const requestFiles = extractNamedFilesFromRecord(request.files);
+	if (Array.isArray(request.files)) for (const file of request.files) appendNamedFile(requestFiles, isRecord$1(file) && typeof file.fieldname === "string" ? file.fieldname : "file", file);
+	if (typeof request.file !== "undefined") appendNamedFile(requestFiles, isRecord$1(request.file) && typeof request.file.fieldname === "string" ? request.file.fieldname : "file", request.file);
+	return requestFiles;
+}
+/**
+* Attaches uploaded files from an Express-like request object to the validator 
+* context under `requestFiles`. It supports both `request.file` 
+* and `request.files` properties, normalizing them into a consistent format. 
+* The original request object is also included in the context for plugin use.
+* 
+* @param validator     The validator instance to attach the files to.
+* @param request       The Express-like request object containing the uploaded files.
+* @returns             The validator instance with the updated context.
+*/
+function withExpressUploadContext(validator, request) {
+	return mergeRequestFiles(validator, extractExpressRequestFiles(request), {
+		express: request,
+		request
+	});
+}
+/**
+* Attaches uploaded files from an Express-like request object to the validator 
+* context for use within validation rules. 
+* 
+* @param request   The Express-like request object containing the uploaded files.
+* @returns         A context object containing the uploaded files and the original request.
+*/
+function useExpressUploadContext(request) {
+	return useRequestFilesContext(extractExpressRequestFiles(request), {
+		express: request,
+		request
+	});
+}
+/**
+* Normalizes a multipart file part from Fastify into a consistent file-like object. 
+* 
+* @param part 
+* @returns 
+*/
+async function normalizeFastifyMultipartFile(part) {
+	if (!isRecord$1(part)) return part;
+	if (typeof part.toBuffer === "function") {
+		const buffer = await part.toBuffer();
+		return {
+			buffer,
+			encoding: part.encoding,
+			fieldname: part.fieldname,
+			filename: part.filename,
+			mimetype: part.mimetype,
+			originalname: part.filename,
+			size: buffer.byteLength,
+			type: part.mimetype
+		};
+	}
+	return part;
+}
+/**
+* Extracts uploaded files from a Fastify-like request object, supporting various ways that files may be provided (e.g., `request.files()`, `request.parts()`, `request.file()`, and nested `request.raw.files`). 
+* 
+* @param request 
+* @returns 
+*/
+async function extractFastifyRequestFiles(request) {
+	const requestFiles = extractNamedFilesFromRecord(request.body);
+	if (typeof request.files === "function") {
+		for await (const part of request.files()) {
+			const normalized = await normalizeFastifyMultipartFile(part);
+			appendNamedFile(requestFiles, isRecord$1(normalized) && typeof normalized.fieldname === "string" ? normalized.fieldname : "file", normalized);
+		}
+		return requestFiles;
+	}
+	if (typeof request.parts === "function") {
+		for await (const part of request.parts()) if (isRecord$1(part) && (part.type === "file" || typeof part.filename === "string" || typeof part.toBuffer === "function")) {
+			const normalized = await normalizeFastifyMultipartFile(part);
+			appendNamedFile(requestFiles, isRecord$1(normalized) && typeof normalized.fieldname === "string" ? normalized.fieldname : "file", normalized);
+		}
+		return requestFiles;
+	}
+	Object.assign(requestFiles, extractNamedFilesFromRecord(request.files));
+	Object.assign(requestFiles, extractNamedFilesFromRecord(isRecord$1(request.raw) ? request.raw.files : void 0));
+	const singleFile = typeof request.file === "function" ? await request.file() : request.file;
+	if (typeof singleFile !== "undefined") {
+		const normalized = await normalizeFastifyMultipartFile(singleFile);
+		appendNamedFile(requestFiles, isRecord$1(normalized) && typeof normalized.fieldname === "string" ? normalized.fieldname : "file", normalized);
+	}
+	return requestFiles;
+}
+/**
+* Attaches uploaded files from a Fastify-like request object to the validator context under `requestFiles`. 
+* It supports multiple ways that files may be provided (e.g., `request.files()`, 
+* `request.parts()`, `request.file()`, and nested `request.raw.files`), normalizing 
+* them into a consistent format. The original request object is also included in 
+* the context for plugin use.
+* 
+* @param validator 
+* @param request 
+* @returns 
+*/
+async function withFastifyUploadContext(validator, request) {
+	return mergeRequestFiles(validator, await extractFastifyRequestFiles(request), {
+		fastify: request,
+		request
+	});
+}
+/**
+* Attaches uploaded files from a Fastify-like request object to the validator 
+* context for use within validation rules.
+* 
+* @param request 
+* @returns 
+*/
+async function useFastifyUploadContext(request) {
+	return useRequestFilesContext(await extractFastifyRequestFiles(request), {
+		fastify: request,
+		request
+	});
+}
+/**
+* Extracts the parsed body from a Hono-like context, which may contain uploaded files. 
+* 
+* @param context 
+* @returns 
+*/
+async function extractHonoParsedBody(context) {
+	return typeof context.req?.parseBody === "function" ? await context.req.parseBody({ all: true }) : {};
+}
+/**
+* Attaches uploaded files from a Hono-like context to the validator context under `requestFiles`.
+* 
+* @param validator 
+* @param context 
+* @returns 
+*/
+async function withHonoUploadContext(validator, context) {
+	return mergeRequestFiles(validator, extractNamedFilesFromRecord(await extractHonoParsedBody(context)), {
+		hono: context,
+		request: context.req
+	});
+}
+/**
+* Attaches uploaded files from a Hono-like context to the validator context for use within validation rules.
+* 
+* @param context 
+* @returns 
+*/
+async function useHonoUploadContext(context) {
+	return useRequestFilesContext(extractNamedFilesFromRecord(await extractHonoParsedBody(context)), {
+		hono: context,
+		request: context.req
+	});
+}
+/**
+* Extracts uploaded files from an H3-like event, supporting multiple sources such as 
+* `event.context.requestFiles`, `request.formData()`, and multipart parsing when available. 
+* It normalizes the files into a consistent format for use in the validator context.
+* 
+* @param event 
+* @returns 
+*/
+async function readH3MultipartFiles(event) {
+	try {
+		const h3 = await dynamicImport("h3");
+		const parts = typeof h3.readMultipartFormData === "function" ? await h3.readMultipartFormData(event) : void 0;
+		if (!Array.isArray(parts)) return {};
+		const files = {};
+		for (const part of parts) {
+			if (!part || typeof part.name !== "string") continue;
+			appendNamedFile(files, part.name, {
+				buffer: part.data,
+				filename: part.filename,
+				mimetype: part.type,
+				name: part.name,
+				originalname: part.filename,
+				size: part.data?.byteLength,
+				type: part.type
+			});
+		}
+		return files;
+	} catch {
+		return {};
+	}
+}
+/**
+* Extracts uploaded files from an H3-like event, checking multiple sources such as 
+* `event.context.requestFiles`, `request.formData()`, and multipart parsing when available. 
+* It normalizes the files into a consistent format for use in the validator context.
+* 
+* @param event 
+* @returns 
+*/
+async function extractH3RequestFiles(event) {
+	let requestFiles = extractNamedFilesFromRecord(event.context?.requestFiles);
+	if (!hasNamedFiles(requestFiles)) {
+		const request = event.req ?? event.request;
+		if (typeof request?.formData === "function") requestFiles = extractFilesFromFormData(await request.formData());
+	}
+	if (!hasNamedFiles(requestFiles)) requestFiles = await readH3MultipartFiles(event);
+	return requestFiles;
+}
+/**
+* Read files from multiple sources on the 
+* event, including `event.context.requestFiles`, `request.formData()`, and multipart 
+* parsing when available. It merges found files into the validator context 
+* under `requestFiles` and also attaches the original event and request for plugin use.
+* 
+* @param validator     The validator instance to which the files will be added.
+* @param event         The H3 event containing potential file uploads.
+* @returns             The validator instance with the merged file context.
+*/
+async function withH3UploadContext(validator, event) {
+	return mergeRequestFiles(validator, await extractH3RequestFiles(event), {
+		h3: event,
+		request: event.req ?? event.request
+	});
+}
+/**
+* Uses files from multiple sources on the event, including
+* `event.context.requestFiles`, `request.formData()`, and multipart parsing when available. 
+* 
+* @param event 
+* @returns 
+*/
+async function useH3UploadContext(event) {
+	return useRequestFilesContext(await extractH3RequestFiles(event), {
+		h3: event,
+		request: event.req ?? event.request
+	});
+}
+
+//#endregion
+//#region src/index.ts
+const IMAGE_EXTENSIONS = new Set([
+	"avif",
+	"bmp",
+	"gif",
+	"heic",
+	"heif",
+	"jpeg",
+	"jpg",
+	"png",
+	"svg",
+	"tiff",
+	"webp"
+]);
+const MIME_BY_EXTENSION = {
+	avif: "image/avif",
+	bmp: "image/bmp",
+	gif: "image/gif",
+	heic: "image/heic",
+	heif: "image/heif",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	mpg: "video/mpeg",
+	mpeg: "video/mpeg",
+	png: "image/png",
+	svg: "image/svg+xml",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	webp: "image/webp"
+};
+let pluginOptions = {};
+let installed = false;
+/**
+* Check if the given value is a record (plain object).
+* 
+* @param value 
+* @returns 
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Check if the given value is a file or an array of files.
+* 
+* @param value 
+* @returns 
+*/
+function isFileLike(value) {
+	if (!isRecord(value)) return false;
+	return [
+		"buffer",
+		"filename",
+		"height",
+		"mimetype",
+		"name",
+		"originalname",
+		"path",
+		"size",
+		"type",
+		"width"
+	].some((key) => typeof value[key] !== "undefined");
+}
+/**
+* Normalize the given value into an array of files.
+* 
+* @param value     The value to normalize
+* @returns         An array of FileLike objects
+*/
+function normalizeFiles(value) {
+	if (Array.isArray(value)) return value.filter(isFileLike);
+	return isFileLike(value) ? [value] : [];
+}
+/**
+* Resolve the candidate files for the given attribute and context. T
+* 
+* @param value 
+* @param attribute 
+* @param context 
+* @returns 
+*/
+async function resolveCandidateFiles(value, attribute, context) {
+	if (typeof value !== "undefined") return value;
+	if (pluginOptions.resolveFiles) {
+		const resolved = await pluginOptions.resolveFiles({
+			attribute,
+			context: context.context,
+			data: context.data,
+			value
+		});
+		if (typeof resolved !== "undefined") return resolved;
+	}
+	return deepFind(context.context.requestFiles ?? {}, attribute);
+}
+async function resolveFiles(value, attribute, context) {
+	const candidates = await resolveCandidateFiles(value, attribute, context);
+	return {
+		candidates,
+		files: normalizeFiles(candidates)
+	};
+}
+function isBlobLike(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isArrayBufferReadable(value) {
+	return isRecord(value) && typeof value.arrayBuffer === "function";
+}
+async function getBuffer(file) {
+	if (file.buffer instanceof Uint8Array || Buffer.isBuffer(file.buffer)) return file.buffer;
+	if (file.buffer instanceof ArrayBuffer) return Buffer.from(file.buffer);
+	if (isBlobLike(file) || isArrayBufferReadable(file)) return Buffer.from(await file.arrayBuffer());
+}
+function getExtension(file) {
+	const name = [
+		file.originalname,
+		file.filename,
+		file.name,
+		file.path
+	].find((candidate) => typeof candidate === "string" && candidate.length > 0);
+	if (!name) return;
+	return extname(name).replace(".", "").toLowerCase();
+}
+function getMimeType(file) {
+	const explicit = [file.mimetype, file.type].find((candidate) => typeof candidate === "string" && candidate.length > 0);
+	if (explicit) return explicit.toLowerCase();
+	const extension = getExtension(file);
+	if (!extension) return;
+	return MIME_BY_EXTENSION[extension];
+}
+function getFileSizeInKilobytes(file) {
+	if (typeof file.size === "number" && Number.isFinite(file.size)) return file.size / 1024;
+	if (typeof file.path === "string") try {
+		return statSync(file.path).size / 1024;
+	} catch {
+		return -1;
+	}
+	return -1;
+}
+async function getImageDimensions(file) {
+	if (typeof file.width === "number" && Number.isFinite(file.width) && typeof file.height === "number" && Number.isFinite(file.height)) return {
+		height: file.height,
+		width: file.width
+	};
+	const source = await getBuffer(file) ?? file.path;
+	if (!source) return;
+	try {
+		const dimensions = imageSize(source);
+		if (typeof dimensions.width === "number" && typeof dimensions.height === "number") return {
+			height: dimensions.height,
+			width: dimensions.width
+		};
+	} catch {
+		return;
+	}
+}
+function isImageFile(file) {
+	if (getMimeType(file)?.startsWith("image/")) return true;
+	const extension = getExtension(file);
+	return typeof extension === "string" && IMAGE_EXTENSIONS.has(extension);
+}
+function parseNumericConstraint(value) {
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseRatio(value) {
+	if (value.includes("/")) {
+		const [left, right] = value.split("/", 2).map(Number);
+		if (!Number.isFinite(left) || !Number.isFinite(right) || right === 0) return;
+		return left / right;
+	}
+	return parseNumericConstraint(value);
+}
+/**
+* Parse the dimension constraints from the given parameters. Supported parameters are:
+* - min_width
+* - max_width
+* - min_height
+* - max_height
+* - ratio (can be a single number or a ratio in the form of "width/height")
+* 
+* @param parameters 
+* @returns 
+*/
+function parseDimensionConstraints(parameters) {
+	const constraints = {};
+	for (const parameter of parameters) {
+		const [name, rawValue] = parameter.split("=", 2);
+		if (!name || !rawValue) continue;
+		if (name === "min_width") constraints.minWidth = parseNumericConstraint(rawValue);
+		if (name === "max_width") constraints.maxWidth = parseNumericConstraint(rawValue);
+		if (name === "min_height") constraints.minHeight = parseNumericConstraint(rawValue);
+		if (name === "max_height") constraints.maxHeight = parseNumericConstraint(rawValue);
+		if (name === "ratio") constraints.ratio = parseRatio(rawValue);
+	}
+	return constraints;
+}
+/**
+* Check if the given image dimensions satisfy the given constraints.
+* 
+* @param dimensions    The dimensions of the image.
+* @param constraints   The constraints to check against.
+* @returns             True if the dimensions satisfy the constraints, false otherwise.
+*/
+function matchesDimensions(dimensions, constraints) {
+	if (typeof constraints.minWidth === "number" && dimensions.width < constraints.minWidth) return false;
+	if (typeof constraints.maxWidth === "number" && dimensions.width > constraints.maxWidth) return false;
+	if (typeof constraints.minHeight === "number" && dimensions.height < constraints.minHeight) return false;
+	if (typeof constraints.maxHeight === "number" && dimensions.height > constraints.maxHeight) return false;
+	if (typeof constraints.ratio === "number") {
+		const actualRatio = dimensions.width / dimensions.height;
+		if (Math.abs(actualRatio - constraints.ratio) > .01) return false;
+	}
+	return true;
+}
+/**
+* Replace the placeholders in the dimensions message with the actual constraint values.
+* 
+* @param message 
+* @param parameters 
+* @returns 
+*/
+function replaceDimensionsMessage(message, parameters) {
+	const values = Object.fromEntries(parameters.map((parameter) => parameter.split("=", 2)).filter(([key, value]) => key && value));
+	return message.replace(":min_width", values.min_width ?? "").replace(":min_height", values.min_height ?? "").replace(":max_width", values.max_width ?? "").replace(":max_height", values.max_height ?? "").replace(":ratio", values.ratio ?? "");
+}
+/**
+* Normalize the given rule input into an array of rules. 
+* 
+* @param rules 
+* @returns 
+*/
+function normalizeRuleInput(rules) {
+	if (Array.isArray(rules)) return rules.flatMap((rule) => rule.split("|")).filter(Boolean);
+	return rules.split("|").filter(Boolean);
+}
+/**
+* Create the validation rules for a wildcard attribute based on the given item and 
+* collection rules. 
+* 
+* @param attribute             The name of the attribute.
+* @param itemRules             The rules to apply to each individual file.
+* @param collectionRules       The rules to apply to the array of files as a whole.
+* @returns                     An object containing the normalized rules for the attribute.
+*/
+function createWildcardFileRules(attribute, itemRules, collectionRules = "files") {
+	return {
+		[attribute]: normalizeRuleInput(collectionRules),
+		[`${attribute}.*`]: normalizeRuleInput(itemRules)
+	};
+}
+/**
+* Sync the files from the request context to the validator's data.
+* 
+* @param validator 
+* @param attributes 
+* @returns 
+*/
+function syncRequestFilesToData(validator, attributes) {
+	const requestFiles = validator.getContext().requestFiles ?? {};
+	const nextData = { ...validator.getData() };
+	const keys = attributes && attributes.length > 0 ? attributes : Object.keys(requestFiles);
+	for (const key of keys) {
+		const fileValue = deepFind(requestFiles, key);
+		if (typeof fileValue !== "undefined" && typeof deepFind(nextData, key) === "undefined") deepSet(nextData, key, fileValue);
+	}
+	return validator.setData(nextData);
+}
+/**
+* Create the file validator plugin with the given options.
+* 
+* @param options 
+* @returns 
+*/
+function createFileValidatorPlugin(options = {}) {
+	pluginOptions = options;
+	return definePlugin({
+		name: "@kanun/plugin-file",
+		install: ({ extendTranslations, registerRule, registerValueInspector }) => {
+			registerValueInspector({
+				type: "file",
+				matches: isFileLike,
+				size: (value) => getFileSizeInKilobytes(value)
+			});
+			if (!installed) {
+				extendTranslations({ en: {
+					dimensions: "The :attribute must satisfy the image dimension constraints. min_width=:min_width, min_height=:min_height, max_width=:max_width, max_height=:max_height, ratio=:ratio.",
+					extensions: "The :attribute must have one of the following extensions: :values.",
+					file: "The :attribute must be a valid file.",
+					files: "The :attribute must contain valid files.",
+					image: "The :attribute must be an image.",
+					max: { file: "The :attribute must not be greater than :max kilobytes." },
+					mimes: "The :attribute must be a file of type: :values.",
+					mimetypes: "The :attribute must be a file of type: :values.",
+					min: { file: "The :attribute must be at least :min kilobytes." },
+					size: { file: "The :attribute must be :size kilobytes." }
+				} });
+				registerRule("file", async function(value, _parameters, attribute = "") {
+					const { candidates, files } = await resolveFiles(value, attribute, this);
+					return !Array.isArray(candidates) && files.length === 1;
+				});
+				registerRule("files", async function(value, _parameters, attribute = "") {
+					const { candidates, files } = await resolveFiles(value, attribute, this);
+					return Array.isArray(candidates) && files.length > 0 && files.length === candidates.length;
+				});
+				registerRule("image", async function(value, _parameters, attribute = "") {
+					const { files } = await resolveFiles(value, attribute, this);
+					return files.length > 0 && files.every((file) => isImageFile(file));
+				});
+				registerRule("extensions", async function(value, parameters = [], attribute = "") {
+					const { files } = await resolveFiles(value, attribute, this);
+					const allowed = new Set(parameters.map((parameter) => parameter.toLowerCase().replace(".", "")));
+					return files.length > 0 && files.every((file) => {
+						const extension = getExtension(file);
+						return typeof extension === "string" && allowed.has(extension);
+					});
+				}, (message, parameters) => message.replace(":values", parameters.join(", ")));
+				registerRule("mimetypes", async function(value, parameters = [], attribute = "") {
+					const { files } = await resolveFiles(value, attribute, this);
+					const allowed = new Set(parameters.map((parameter) => parameter.toLowerCase()));
+					return files.length > 0 && files.every((file) => {
+						const mimeType = getMimeType(file);
+						return typeof mimeType === "string" && allowed.has(mimeType);
+					});
+				}, (message, parameters) => message.replace(":values", parameters.join(", ")));
+				registerRule("mimes", async function(value, parameters = [], attribute = "") {
+					const { files } = await resolveFiles(value, attribute, this);
+					const allowed = new Set(parameters.map((parameter) => parameter.toLowerCase().replace(".", "")));
+					return files.length > 0 && files.every((file) => {
+						const extension = getExtension(file);
+						return typeof extension === "string" && allowed.has(extension);
+					});
+				}, (message, parameters) => message.replace(":values", parameters.join(", ")));
+				registerRule("dimensions", async function(value, parameters = [], attribute = "") {
+					const { files } = await resolveFiles(value, attribute, this);
+					if (files.length === 0) return false;
+					const constraints = parseDimensionConstraints(parameters);
+					for (const file of files) {
+						const dimensions = await getImageDimensions(file);
+						if (!dimensions || !matchesDimensions(dimensions, constraints)) return false;
+					}
+					return true;
+				}, replaceDimensionsMessage);
+				installed = true;
+			}
+		}
+	});
+}
+const fileValidatorPlugin = createFileValidatorPlugin();
+
+//#endregion
+export { createFileValidatorPlugin, createWildcardFileRules, fileValidatorPlugin, syncRequestFilesToData, useExpressUploadContext, useFastifyUploadContext, useH3UploadContext, useHonoUploadContext, withExpressUploadContext, withFastifyUploadContext, withH3UploadContext, withHonoUploadContext };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kanun-hq/plugin-file",
+  "version": "0.1.0",
+  "description": "File validation plugin for Kanun.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "homepage": "https://arkstack-hq.github.io/kanun",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arkstack-hq/kanun.git",
+    "directory": "packages/file"
+  },
+  "keywords": [
+    "kanun",
+    "validation",
+    "file",
+    "upload",
+    "plugin"
+  ],
+  "dependencies": {
+    "image-size": "^2.0.2",
+    "kanun": "1.0.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint src --ext .ts"
+  }
+}