ivl 0.1.5 → 0.2.0

package/README.md

@@ -2,51 +2,76 @@
 This is a lightweight library for user input validation.
 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. 
+By default it automatically detects and supports async rules in your rule sets.
+
+If your rule set and/or object are very large or complex, you may want to use 
+`getInputErrorsSync`/`getSchemaErrorsSync` or `getInputErrorsAsync`/`getSchemaErrorsAsync` for improved performance on synchronous and asynchronous rule sets respectively.
+
+Use synchronous versions of the functions 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)
 }
+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"]
+
+```
+# Installing
+### Bun.js
+```typescript
+bun add ivl
 ```
-The input will be checked against your rule set and return all failing rules names as a string array.
 
+### yarn
+```typescript
+yarn add ivl
+```
 
+### npm
+```typescript
+npm install ivl
+```
+---
+# Usage examples
 ## 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(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,40 +89,48 @@ 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')
+  }
+};
 
 ```
 
@@ -108,47 +141,47 @@ import { jwt } from 'hono/jwt';
 import { validator } from 'hono/validator';
 import { getSchemaErrors } from 'ivl';
 import type { SCHEMA } from 'ivl';
-import { LOGIN_SCHEMA, REGISTER_SCHEMA, INVITATION_PARAM } from './rules.ts'
+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,16 +1,20 @@
 // 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 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 acceptAnySync: (rules?: RULE_SYNC[]) => (i: unknown, ...extra: unknown[]) => 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,p=(e)=>(n)=>typeof n==="string"&&e.test(n),i=(e=100,n=0)=>(o)=>typeof o==="string"&&o.length>=n&&o.length<e,f=(e=100,n=1)=>(o)=>typeof o==="number"&&o>=n&&o<e,w=(e=[])=>async(n,...o)=>(await Promise.all(e.map((t)=>t.call(void 0,n,...o)))).some((t)=>t),a=(e=[])=>(n,...o)=>e.map((t)=>t.call(void 0,n,...o)).some((t)=>t);var l=(e)=>Object.entries(e).reduce((n,[o,t])=>({...n,[o]:(c,...r)=>typeof c==="undefined"?!0:t(c,...r)}),{}),d=(e,n)=>Object.entries(n).reduce((o,[t,c])=>({...o,[t]:(r,...s)=>c(e(r),...s)}),{});export{u as type,i as stringBetween,d as preprocess,f as numberBetween,p as matchesRegex,l as allowUndefined,a as acceptAnySync,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,39 @@
 // 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 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 type CHECKED_SCHEMA = Promise<CHECKED_SCHEMA_SYNC>;
+export declare const hasAsyncFunction: (obj: Record<string, unknown>) => boolean;
+export declare const getValueErrorsAsync: (value: unknown, rules: RULES, ...overload: unknown[]) => Promise<string[]>;
+export declare const getSchemaErrorsAsync: (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 declare const getValueErrors: (value: unknown, rules: RULES | RULES_SYNC, ...overload: unknown[]) => string[] | Promise<string[]>;
+export declare const getSchemaErrors: (object: CHECKABLE_OBJECT, schema: SCHEMA_SYNC | SCHEMA, options?: SCHEMA_OPTIONS, ...overload: unknown[]) => CHECKED_SCHEMA_SYNC | CHECKED_SCHEMA;
 
 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])=>{try{return x(E,...L)?p:[...p,n]}catch(C){return[...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=(q)=>Object.values(q).some((x)=>typeof x==="function"&&x.constructor.name==="AsyncFunction"),Y=async(q,x,...G)=>{const z={};return Object.entries(x).forEach(([f,B])=>{z[f]=Promise.resolve(!1).then(()=>B(q,...G)).then((J)=>z[f]=J).catch(()=>z[f]=!1)}),await Promise.allSettled(Object.values(z)),Object.entries(z).reduce((f,[B,J])=>J?f:[...f,B],[])},$=async(q,x,G=W,...z)=>{const f={};if(Object.entries(x).forEach(([B,J])=>{f[B]=Y(q[B],J,...z).then((K)=>{f[B]=K}).catch((K)=>{f[B]=K})}),G.strict){const B=Object.keys(q),J=new Set(Object.keys(x));B.filter((Q)=>!J.has(Q)).forEach((Q)=>{f[Q]=["Key not allowed"]})}return await Promise.allSettled(Object.values(f)),f},Z=(q,x,...G)=>Object.entries(x).reduce((z,[f,B])=>{try{return B(q,...G)?z:[...z,f]}catch(J){return[...z,f]}},[]),R=(q,x,G=W,...z)=>{const f=Object.entries(x).reduce((B,[J,K])=>({...B,[J]:Z(q[J],K,...z)}),{});if(G.strict){const B=Object.keys(q),J=new Set(Object.keys(x));B.filter((Q)=>!J.has(Q)).forEach((Q)=>{f[Q]=["Key not allowed"]})}return f},C=(q,x,...G)=>{if(X(x))return Y(q,x,...G);return Z(q,x,...G)},H=(q,x,G=W,...z)=>{if(Object.values(x).some(X))return $(q,x,G,...z);return R(q,x,G,...z)};export{X as hasAsyncFunction,Z as getValueErrorsSync,Y as getValueErrorsAsync,C as getValueErrors,R as getSchemaErrorsSync,$ as getSchemaErrorsAsync,H as getSchemaErrors};

package/lib/patterns/index.d.ts

@@ -1,7 +1,15 @@
 // 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 declare const CONTAINS_LOWERCASE_CHARACTER_PATTERN: RegExp;
+export declare const CONTAINS_UPPERCASE_CHARACTER_PATTERN: RegExp;
+export declare const CONTAINS_DIGIT_CHARACTER_PATTERN: RegExp;
+export declare const CONTAINS_SYMBOL_CHARACTER_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+|\(([^\(\)]+|\\\(|\\\))*\))*$/,m=/(?=.*[a-z])/,p=/(?=.*[A-Z])/,q=/(?=.*\d)/,r=/[^\w]/;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,p as CONTAINS_UPPERCASE_CHARACTER_PATTERN,r as CONTAINS_SYMBOL_CHARACTER_PATTERN,m as CONTAINS_LOWERCASE_CHARACTER_PATTERN,q as CONTAINS_DIGIT_CHARACTER_PATTERN};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ivl",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "author": {
     "name": "Oskar Voorel",
     "email": "oskar@voorel.com"
@@ -11,7 +11,7 @@
   },
   "main": "lib/index.js",
   "devDependencies": {
-    "@types/bun": "^1.0.0",
+    "@types/bun": "latest",
     "bun-plugin-dts": "^0.2.1",
     "mitata": "^0.1.11",
     "typescript": "^5.2.2",
@@ -48,7 +48,7 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "bun run build.mjs",
+    "build": "rm -rf ./lib && bun run build.mjs",
     "prepublishOnly": "bun run build",
     "benchmark": "bun run ./benchmark/index.ts"
   },