ivl 0.1.4 → 0.1.6

package/README.md

@@ -4,49 +4,51 @@ Main focus is on speed and flexibility of the validation rules
 
 Supports asynchronous rule validation by default. Use `getInputErrorsSync` and `getSchemaErrorsSync` for better performance if you don't need to support asynchronous checks on your inputs. 
 # Main functionality
-Write your own custom validators to exactly match your usecase using a simple object:
+Write your own custom validators to exactly match your use case using a simple object:
 ```javascript
 const my_rules = {
-	"Input must be more than 4": (i) => i > 4,
-	"Input must be divisible by 10": (i) => i % 10
+  "Input must be more than 40": (i) => i > 40,
+  "Input must be divisible by 10": (i) => !(i % 10)
 }
-```
-The input will be checked against your rule set and return all failing rules names as a string array.
+console.log(getInputErrors(50, my_rules)); // []
+console.log(getInputErrors(11, my_rules)); // ["Input must be more than 40", "Input must be divisible by 10"]
+console.log(getInputErrors(30, my_rules)) // ["Input must be more than 40"]
 
+```
 
 ## Frontend example
 ```javascript
 // src/index.ts
 import { getInputErrorsSync, getInputErrors } from 'ivl';
 import type { RULES } from 'ivl';
-import { matchesRegex, stringBetween, type } from 'ivl/helpers';
+import { matchesRegex, minLength, maxLength, isType } from 'ivl/helpers';
 
-// This is also exportable from 'ivl/patterns'
+// This pattern is also exportable from 'ivl/patterns'
 const EMAIL_PATTERN = /^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/;
 
 const EMAIL_REQUIREMENTS: RULES = {
-	"Must be string": type('string'),
-	"Must be less then 100 characters": stringBetween(),
-	"Not a valid email address": matchesRegex(EMAIL_PATTERN),
-	"That email is already in use": async (i) => {
-		// Fetch info from whatever backend and make a decision based on that asynchronously
-		const email_in_use = await fetch(`https://mybackend/email-exists/${i}`)
-		return !email_in_use // We will return true if the email is not already taken
-	}
+  "Must be string": isType('string'),
+  "Must be less then 100 characters": maxLength(100),
+  "Not a valid email address": matchesRegex(EMAIL_PATTERN),
+  "That email is already in use": async (i) => {
+    // Fetch info from whatever backend and make a decision based on that asynchronously
+    const email_in_use = await fetch(`https://mybackend/email-exists/${i}`)
+    return !email_in_use // We will return true if the email is not already taken
+  }
 };
 
 const PASSWORD_REQUIREMENTS: RULES = {
-	"Must be string": type('string'),
-	"Must be at least 8 characters": stringBetween(Infinity, 8),
-	"Must contain at least one upper case character": matchesRegex(/(?=.*[A-Z])/),
-	"Must contain at least one lower case character": matchesRegex(/(?=.*[a-z])/),
+  "Must be string": isType('string'),
+  "Must be at least 8 characters": minLength(Infinity, 8),
+  "Must contain at least one upper case character": matchesRegex(/(?=.*[A-Z])/),
+  "Must contain at least one lower case character": matchesRegex(/(?=.*[a-z])/),
 }
 
 // You can of course expand on your existing rules: 
 const STRONG_PASSWORD_REQUIREMENTS: RULES = {
-	...PASSWORD_REQUIREMENTS,
-	"Must contain at least one digit": matchesRegex(/(?=.*\d)/),
-	"Must contain at least one symbol": matchesRegex(/[^\w]/),
+  ...PASSWORD_REQUIREMENTS,
+  "Must contain at least one digit": matchesRegex(/(?=.*\d)/),
+  "Must contain at least one symbol": matchesRegex(/[^\w]/),
 };
 
 const email_value = "some-value";
@@ -64,39 +66,47 @@ console.log({email_errors, pw_errors, strong_pw_errors});
 
 ```typescript
 // rules.ts
+
+import { isType, minLength, maxLength, matchesRegex } from 'ivl/helpers';
+import { checkValueInDatabase } from 'my-database-controller';
+
+const existsInDatabase = (key: string, table: string, exists: boolean = true): RULE =>
+  async (value) =>
+    exists != !(await checkValueInDatabase(value as string, key, table)).length
+
 const EMAIL_REQUIREMENTS = {
-	"Must be string": type('string'),
-	"Must be less then 100 characters": stringBetween(),
-	"Not a valid email address": matchesRegex(EMAIL_PATTERN),
+  "Must be string": isType('string'),
+  "Must be less then 100 characters": maxLength(100),
+  "Not a valid email address": matchesRegex(EMAIL_PATTERN),
 };
 
 const PASSWORD_REQUIREMENTS = {
-	"Must be string": type('string'),
-	"Must be at least 8 characters": stringBetween(Infinity, 8),
-	"Must contain at least one upper case character": matchesRegex(/(?=.*[A-Z])/),
-	"Must contain at least one lower case character": matchesRegex(/(?=.*[a-z])/),
-	"Must contain at least one digit": matchesRegex(/(?=.*\d)/),
-	"Must contain at least one symbol": matchesRegex(/[^\w]/),
+  "Must be string": isType('string'),
+  "Must be at least 8 characters": minLength(8),
+  "Must contain at least one upper case character": matchesRegex(/(?=.*[A-Z])/),
+  "Must contain at least one lower case character": matchesRegex(/(?=.*[a-z])/),
+  "Must contain at least one digit": matchesRegex(/(?=.*\d)/),
+  "Must contain at least one symbol": matchesRegex(/[^\w]/),
 };
 
-export const LOGIN_SCHEMA =  {
-	email: EMAIL_REQUIREMENTS,
-	password: PASSWORD_REQUIREMENTS
+export const LOGIN_SCHEMA: SCHEMA =  {
+  email: EMAIL_REQUIREMENTS,
+  password: PASSWORD_REQUIREMENTS
 }
 
-export const REGISTER_SCHEMA = {
-	organization_name: {} // Pass in an empty rule set, so the value can be whatever
-	email: {
-		...EMAIL_REQUIREMENTS,
-		"Email already registered": checkValueInDatabase('email','users', false)
-	},
-	password: PASSWORD_REQUIREMENTS
+export const REGISTER_SCHEMA: SCHEMA = {
+  organization_name: {} // Pass in an empty rule set, so the value can be whatever
+  email: {
+    ...EMAIL_REQUIREMENTS,
+    "Email already registered": existsInDatabase('email','users', false)
+  },
+  password: PASSWORD_REQUIREMENTS
 }
 
 export const INVITATION_PARAM: SCHEMA = {
-	code: {
-		"Not a valid invitation": existsInDatabase('code', 'invitation')
-	}
+  code: {
+    "Not a valid invitation": existsInDatabase('code', 'invitation')
+  }
 }
 
 ```
@@ -112,43 +122,43 @@ import { LOGIN_SCHEMA, REGISTER_SCHEMA, INVITATION_PARAM } from './rules.ts'
 
 // Wrapper for hono validator middleware
 const validateWrapper = (schema: SCHEMA, error: ClientErrorStatusCode | RedirectStatusCode = 400, strict = true) =>
-	async (value: any, c: Context) => {
-		const jwt = c.get('jwtPayload'); // Pass jwt to the validator so we could use its value when checking input validation rules
-		const errors = await getSchemaErrors(value, schema, strict, jwt);
-		if (Object.values(errors).filter((e) => e.length).length) {
-			throw new HTTPException(error, {
-				message: JSON.stringify(errors),
-			})
-		}
-		return value
-	}
+  async (value: any, c: Context) => {
+    const jwt = c.get('jwtPayload'); // Pass jwt to the validator so we could use its value when checking input validation rules
+    const errors = await getSchemaErrors(value, schema, {strict:true}, jwt);
+    if (Object.values(errors).filter((e) => e.length).length) {
+      throw new HTTPException(error, {
+        message: JSON.stringify(errors),
+      });
+    }
+    return value;
+  }
 
 const app = new Hono();
 
 app.use(jwt({
-	secret: "some-secret-value",
-	cookie: 'token'
-}))
+  secret: "some-secret-value",
+  cookie: 'token'
+}));
 
 app.post('/login',
-	validator('json', validateWrapper(LOGIN_SCHEMA)),
-	(c) => c.text("Success"));
+  validator('json', validateWrapper(LOGIN_SCHEMA)),
+  (c) => c.text("Success"));
 
 app.all('/logout', (c) => c.text("Success"));
 
 app.put('/register', 
-	validator('json', validateWrapper(REGISTER_SCHEMA)),
-	(c) => c.text("Success"));
+  validator('json', validateWrapper(REGISTER_SCHEMA)),
+  (c) => c.text("Success"));
 
 // This first validates the invitation parameter against our database
 // And then validates the body of the request
 app.put('/register/:invitation_code',
-	validator('param', validateWrapper(INVITATION_PARAM)),
-	validator('json', validateWrapper(
-		// Registering via invitation needs all the same values except organization name - inherit parts of rule sets, as opposed to extending the rule set as shown above
-				(({ organization_name, ...invite_schema }) => invite_schema)(REGISTRATION_SCHEMA)
-)),
-	(c)=> c.text("Success")))
+  validator('param', validateWrapper(INVITATION_PARAM)),
+  validator('json', validateWrapper(
+    // Registering via invitation needs all the same values except organization name - inherit parts of rule sets, as opposed to extending the rule set as shown above
+    (({ organization_name, ...invite_schema }) => invite_schema)(REGISTRATION_SCHEMA)
+  )),
+  (c)=> c.text("Success"));
 
 export default app;
 ```

package/lib/helpers/index.d.ts

@@ -1,14 +1,20 @@
 // Generated by dts-bundle-generator v8.1.1
 
+export type RULE_SYNC = (value: unknown, ...overload: unknown[]) => boolean;
 export type RULE = (value: unknown, ...overload: unknown[]) => boolean | Promise<boolean>;
 export type RULES = {
 	[index: string]: RULE;
 };
-export declare const type: (type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function") => RULE;
-export declare const matchesRegex: (regex: RegExp) => (value: unknown) => boolean;
-export declare const stringBetween: (max?: number, min?: number) => (s: unknown) => boolean;
-export declare const numberBetween: (max?: number, min?: number) => (i: unknown) => boolean;
-export declare const acceptAny: (rules?: RULE[]) => (i: unknown, ...extra: unknown[]) => Promise<boolean>;
+export declare const isType: (type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function") => RULE_SYNC;
+export declare const matchesRegex: (regex: RegExp) => RULE_SYNC;
+export declare const max: (max_value?: number) => RULE_SYNC;
+export declare const min: (min_value?: number) => RULE_SYNC;
+export declare const maxLength: (max_length?: number) => RULE_SYNC;
+export declare const minLength: (min_length?: number) => RULE_SYNC;
+export declare const stringBetween: (max?: number, min?: number) => RULE_SYNC;
+export declare const numberBetween: (max?: number, min?: number) => RULE_SYNC;
+export declare const acceptAny: (rules?: RULE[]) => RULE;
+export declare const acceptAnySync: (rules?: RULE_SYNC[]) => RULE_SYNC;
 export declare const allowUndefined: (rules: RULES) => {};
 export declare const preprocess: (fn: Function, rules: RULES) => {};
 

package/lib/helpers/index.js

@@ -1 +1 @@
-var u=(e)=>(n)=>typeof n===e,i=(e)=>(n)=>typeof n==="string"&&e.test(n),p=(e=100,n=0)=>(t)=>typeof t==="string"&&t.length>=n&&t.length<e,f=(e=100,n=1)=>(t)=>typeof t==="number"&&t>=n&&t<e,w=(e=[])=>async(n,...t)=>(await Promise.all(e.map((o)=>o.call(void 0,n,...t)))).some((o)=>o);var a=(e)=>Object.entries(e).reduce((n,[t,o])=>({...n,[t]:(r,...c)=>typeof r==="undefined"?!0:o(r,...c)}),{}),l=(e,n)=>Object.entries(n).reduce((t,[o,r])=>({...t,[o]:(c,...s)=>r(e(c),...s)}),{});export{u as type,p as stringBetween,l as preprocess,f as numberBetween,i as matchesRegex,a as allowUndefined,w as acceptAny};
+var s=(n)=>n!==null&&typeof n==="object"&&("length"in n)&&typeof n.length==="number",p=(n)=>(e)=>typeof e===n,i=(n)=>(e)=>typeof e==="string"&&n.test(e),m=(n=1/0)=>(e)=>typeof e==="number"&&e<=n,f=(n=-1/0)=>(e)=>typeof e==="number"&&e>=n,w=(n=1/0)=>(e)=>s(e)&&e.length<=n,y=(n=1/0)=>(e)=>s(e)&&e.length>=n,a=(n=100,e=0)=>(t)=>typeof t==="string"&&t.length>=e&&t.length<n,L=(n=100,e=1)=>(t)=>typeof t==="number"&&t>=e&&t<n,h=(n=[])=>async(e,...t)=>(await Promise.all(n.map((o)=>o(void 0,e,...t)))).some((o)=>o),R=(n=[])=>(e,...t)=>n.map((o)=>o(void 0,e,...t)).some((o)=>o);var g=(n)=>Object.entries(n).reduce((e,[t,o])=>({...e,[t]:(r,...u)=>typeof r==="undefined"?!0:o(r,...u)}),{}),l=(n,e)=>Object.entries(e).reduce((t,[o,r])=>({...t,[o]:(u,...c)=>r(n(u),...c)}),{});export{a as stringBetween,l as preprocess,L as numberBetween,y as minLength,f as min,w as maxLength,m as max,i as matchesRegex,p as isType,g as allowUndefined,R as acceptAnySync,h as acceptAny};

package/lib/index.d.ts

@@ -1,31 +1,36 @@
 // Generated by dts-bundle-generator v8.1.1
 
-export type RULE = (value: unknown, ...overload: unknown[]) => boolean | Promise<boolean>;
 export type RULE_SYNC = (value: unknown, ...overload: unknown[]) => boolean;
-export type RULES = {
-	[index: string]: RULE;
-};
+export type RULE = (value: unknown, ...overload: unknown[]) => boolean | Promise<boolean>;
 export type RULES_SYNC = {
 	[index: string]: RULE_SYNC;
 };
-export type SCHEMA = {
-	[index: string]: RULES;
+export type RULES = {
+	[index: string]: RULE;
 };
 export type SCHEMA_SYNC = {
 	[index: string]: RULES_SYNC;
 };
+export type SCHEMA = {
+	[index: string]: RULES;
+};
 export type CHECKABLE_OBJECT = {
 	[index: string]: unknown;
 };
-export type CHECKED_SCHEMA = Promise<{
-	[index: string]: string[];
-}>;
+/**
+ * @arg {boolean} strict --- Don't allow object to have keys not included in the schema
+ * @arg {boolean} break_early --- Return the first error found
+ */
+export type SCHEMA_OPTIONS = {
+	strict?: boolean;
+};
 export type CHECKED_SCHEMA_SYNC = {
 	[index: string]: string[];
 };
+export type CHECKED_SCHEMA = Promise<CHECKED_SCHEMA_SYNC>;
 export declare const getValueErrors: (value: unknown, rules: RULES, ...overload: unknown[]) => Promise<string[]>;
-export declare const getSchemaErrors: (object: CHECKABLE_OBJECT, schema: SCHEMA, strict?: Boolean, ...overload: unknown[]) => CHECKED_SCHEMA;
+export declare const getSchemaErrors: (object: CHECKABLE_OBJECT, schema: SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA;
 export declare const getValueErrorsSync: (value: unknown, rules: RULES_SYNC, ...overload: unknown[]) => string[];
-export declare const getSchemaErrorsSync: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC, strict?: Boolean, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC;
+export declare const getSchemaErrorsSync: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC;
 
 export {};

package/lib/index.js

@@ -1 +1 @@
-var U=async(E,S,...L)=>{const p={};return Object.entries(S).forEach(([n,x])=>{p[n]=Promise.resolve().then(()=>x(E,...L)).then((C)=>p[n]=C).catch(()=>{p[n]=!1})}),await Promise.allSettled(Object.values(p)),Object.entries(p).reduce((n,[x,C])=>C?n:[...n,x],[])},N=async(E,S,L=!1,...p)=>{const n={};if(Object.entries(S).forEach(([x,C])=>{n[x]=U(E[x],C,...p).then((i)=>{n[x]=i}).catch((i)=>{n[x]=i})}),L){const x=Object.keys(E),C=new Set(Object.keys(S));x.filter((R)=>!C.has(R)).forEach((R)=>{n[R]=["Key not allowed"]})}return await Promise.allSettled(Object.values(n)),n},H=(E,S,...L)=>Object.entries(S).reduce((p,[n,x])=>x(E,...L)?p:[...p,n],[]),Y=(E,S,L=!1,...p)=>{const n=Object.entries(S).reduce((x,[C,i])=>({...x,[C]:H(E[C],i,...p)}),{});if(L){const x=Object.keys(E),C=new Set(Object.keys(S));x.filter((R)=>!C.has(R)).forEach((R)=>{n[R]=["Key not allowed"]})}return n};export{H as getValueErrorsSync,U as getValueErrors,Y as getSchemaErrorsSync,N as getSchemaErrors};
+var W={strict:!1},X=async(B,G,...J)=>{const q={};return Object.entries(G).forEach(([x,f])=>{q[x]=Promise.resolve(!1).then(()=>f(B,...J)).then((z)=>q[x]=z).catch(()=>q[x]=!1)}),await Promise.allSettled(Object.values(q)),Object.entries(q).reduce((x,[f,z])=>z?x:[...x,f],[])},Z=async(B,G,J=W,...q)=>{const x={};if(Object.entries(G).forEach(([f,z])=>{x[f]=X(B[f],z,...q).then((K)=>{x[f]=K}).catch((K)=>{x[f]=K})}),J.strict){const f=Object.keys(B),z=new Set(Object.keys(G));f.filter((Q)=>!z.has(Q)).forEach((Q)=>{x[Q]=["Key not allowed"]})}return await Promise.allSettled(Object.values(x)),x},Y=(B,G,...J)=>Object.entries(G).reduce((q,[x,f])=>{try{return f(B,...J)?q:[...q,x]}catch(z){return[...q,x]}},[]),$=(B,G,J=W,...q)=>{const x=Object.entries(G).reduce((f,[z,K])=>({...f,[z]:Y(B[z],K,...q)}),{});if(J.strict){const f=Object.keys(B),z=new Set(Object.keys(G));f.filter((Q)=>!z.has(Q)).forEach((Q)=>{x[Q]=["Key not allowed"]})}return x};export{Y as getValueErrorsSync,X as getValueErrors,$ as getSchemaErrorsSync,Z as getSchemaErrors};

package/lib/patterns/index.d.ts

@@ -1,7 +1,11 @@
 // Generated by dts-bundle-generator v8.1.1
 
 export declare const EMAIL_PATTERN: RegExp;
-export declare const TIMESTAMP_PATTERN: RegExp;
+export declare const MYSQL_TIMESTAMP_PATTERN: RegExp;
 export declare const URL_PATTERN: RegExp;
+export declare const ISO_8601_DATETIME_PATTERN_STRICT: RegExp;
+export declare const ISO_8601_DATETIME_PATTERN: RegExp;
+export declare const ISO_8601_TIME_PATTERN: RegExp;
+export declare const RFC_2822_TIMESTAMP_PATTERN: RegExp;
 
 export {};

package/lib/patterns/index.js

@@ -1 +1 @@
-var T=/^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/,s=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,t=/^(https?:\/\/)?([^\s$.?#].[^\s]*)\.[a-z]{2,}(\/[^\s]*)?$/i;export{t as URL_PATTERN,s as TIMESTAMP_PATTERN,T as EMAIL_PATTERN};
+var x=/^[\w.%+-]+@[\w.-]+\.[a-zA-Z]{1,}$/,c=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,d=/^(https?:\/\/)?([^\s$.?#].[^\s]*)\.[a-z]{2,}(\/[^\s]*)?$/i,f=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))$/,j=/^(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+)|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d)|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d)$/,k=/^(2[0-3]|[01][0-9]):?([0-5][0-9]):?([0-5][0-9])(Z|[+-](?:2[0-3]|[01][0-9])(?::?(?:[0-5][0-9]))?)$/,l=/^(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+)?(0[1-9]|[1-2]?[0-9]|3[01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(19[0-9]{2}|[2-9][0-9]{3})\s+(2[0-3]|[0-1][0-9]):([0-5][0-9])(?::(60|[0-5][0-9]))?\s+([-\+][0-9]{2}[0-5][0-9]|(?:UT|GMT|(?:E|C|M|P)(?:ST|DT)|[A-IK-Z]))(\s+|\(([^\(\)]+|\\\(|\\\))*\))*$/;export{d as URL_PATTERN,l as RFC_2822_TIMESTAMP_PATTERN,c as MYSQL_TIMESTAMP_PATTERN,k as ISO_8601_TIME_PATTERN,f as ISO_8601_DATETIME_PATTERN_STRICT,j as ISO_8601_DATETIME_PATTERN,x as EMAIL_PATTERN};

package/package.json

@@ -1,52 +1,57 @@
 {
-	"name": "ivl",
-	"version": "0.1.4",
-	"main": "lib/index.js",
-	"types": "lib/index.d.ts",
-	"description": "Lightweight input validation",
-	"author": {
-		"name": "Oskar Voorel",
-		"email": "oskar@voorel.com"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/Oskar-V/validator.git"
-	},
-	"bugs": {
-		"url": "https://github.com/Oskar-V/validator/issues/new"
-	},
-	"scripts": {
-		"build": "bun run build.mjs",
-		"prepublishOnly": "bun run build"
-	},
-	"files": [
-		"lib"
-	],
-	"keywords": [
-		"validation",
-		"typescript",
-		"schema",
-		"input"
-	],
-	"exports": {
-		".": {
-			"types": "./lib/index.d.ts",
-			"default": "./lib/index.js"
-		},
-		"./patterns": {
-			"types": "./lib/patterns/index.d.ts",
-			"default": "./lib/patterns/index.js"
-		},
-		"./helpers": {
-			"types": "./lib/helpers/index.d.ts",
-			"default": "./lib/helpers/index.js"
-		}
-	},
-	"sideEffects": "false",
-	"license": "MIT",
-	"devDependencies": {
-		"@types/bun": "^1.0.0",
-		"bun-plugin-dts": "^0.2.1",
-		"typescript": "^5.2.2"
-	}
+  "name": "ivl",
+  "version": "0.1.6",
+  "author": {
+    "name": "Oskar Voorel",
+    "email": "oskar@voorel.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Oskar-V/validator.git"
+  },
+  "main": "lib/index.js",
+  "devDependencies": {
+    "@types/bun": "^1.0.0",
+    "bun-plugin-dts": "^0.2.1",
+    "mitata": "^0.1.11",
+    "typescript": "^5.2.2",
+    "yup": "^1.4.0",
+    "zod": "^3.23.8"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./patterns": {
+      "types": "./lib/patterns/index.d.ts",
+      "default": "./lib/patterns/index.js"
+    },
+    "./helpers": {
+      "types": "./lib/helpers/index.d.ts",
+      "default": "./lib/helpers/index.js"
+    }
+  },
+  "bugs": {
+    "url": "https://github.com/Oskar-V/validator/issues/new"
+  },
+  "description": "Lightweight input validation",
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/Oskar-V/validator",
+  "keywords": [
+    "validation",
+    "typescript",
+    "schema",
+    "input"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "rm -rf ./lib && bun run build.mjs",
+    "prepublishOnly": "bun run build",
+    "benchmark": "bun run ./benchmark/index.ts"
+  },
+  "sideEffects": "false",
+  "types": "lib/index.d.ts"
 }