@jdlien/validator-utils 1.1.1 → 1.1.3

package/dist/validator-utils.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Utilities used by the Validator class.
+ *
+ * @format
+ */
+type DateParts = {
+    year: number;
+    month: number;
+    day: number;
+};
+export declare function isFormControl(el: any): boolean;
+interface ValidationResult {
+    valid: boolean;
+    error?: boolean;
+    messages: string[];
+}
+export declare function isType(el: HTMLInputElement | HTMLTextAreaElement, types: string | string[]): boolean;
+export declare function momentToFPFormat(format: string): string;
+export declare function monthToNumber(str: string | number): number;
+export declare function yearToFull(year: number | string): number;
+export declare function parseDate(value: string | Date): Date;
+export declare function guessDatePart(num: number, knownMeanings?: (string | null)[]): string[];
+export declare function guessDateParts(str: string): DateParts;
+export declare function parseTime(value: string): {
+    hour: number;
+    minute: number;
+    second: number;
+} | null;
+export declare function parseTimeToString(value: string, format?: string): string;
+export declare function formatDateTime(date: Date | string, format?: string): string;
+export declare function parseDateToString(value: string | Date, format?: string): string;
+export declare function isDate(value: string | Date): boolean;
+export declare function isDateInRange(date: Date, range: string): boolean;
+export declare function isTime(value: string): boolean;
+export declare function isEmail(value: string): boolean;
+export declare function parseNANPTel(value: string): string;
+export declare function isNANPTel(value: string): boolean;
+export declare function parseInteger(value: string): string;
+export declare function isNumber(value: string): boolean;
+export declare function parseNumber(value: string): string;
+export declare function isInteger(value: string): boolean;
+export declare function parseUrl(value: string): string;
+export declare function isUrl(value: string): boolean;
+export declare function parseZip(value: string): string;
+export declare function isZip(value: string): boolean;
+export declare function parsePostalCA(value: string): string;
+export declare function isPostalCA(value: string): boolean;
+export declare function isColor(value: string): boolean;
+export declare function parseColor(value: string): string;
+export declare function normalizeValidationResult(res: boolean | string | {
+    valid: boolean;
+    message?: string;
+    messages?: string | string[];
+    error?: boolean;
+}): ValidationResult;
+export {};

package/dist/validator-utils.js

@@ -1 +1,570 @@
-(function(i,f){typeof exports=="object"&&typeof module<"u"?f(exports):typeof define=="function"&&define.amd?define(["exports"],f):(i=typeof globalThis<"u"?globalThis:i||self,f(i.validatorUtils={}))})(this,function(i){"use strict";function f(e){return e instanceof HTMLInputElement||e instanceof HTMLSelectElement||e instanceof HTMLTextAreaElement}function R(e,n){typeof n=="string"&&(n=[n]);const t=e.dataset.type||"",r=e.type;return!!(n.includes(t)||n.includes(r))}function T(e){return e.replace(/YYYY/g,"Y").replace(/YY/g,"y").replace(/MMMM/g,"F").replace(/MMM/g,"{3}").replace(/MM/g,"{2}").replace(/M/g,"n").replace(/DD/g,"{5}").replace(/D/g,"j").replace(/dddd/g,"l").replace(/ddd/g,"D").replace(/dd/g,"D").replace(/d/g,"w").replace(/HH/g,"{6}").replace(/H/g,"G").replace(/hh/g,"h").replace(/mm/g,"i").replace(/m/g,"i").replace(/ss/g,"S").replace(/s/g,"s").replace(/A/gi,"K").replace(/\{3\}/g,"M").replace(/\{2\}/g,"m").replace(/\{5\}/g,"d").replace(/\{6\}/g,"H")}function M(e){const n=parseInt(e);if(typeof e=="number"||!isNaN(n))return n-1;const t=new Date(`1 ${e} 2000`).getMonth();if(!isNaN(t))return t;const r={ja:0,en:0,fe:1,fé:1,ap:3,ab:3,av:3,mai:4,juin:5,juil:6,au:7,ag:7,ao:7,se:8,o:9,n:10,d:11};for(const l in r)if(e.toLowerCase().startsWith(l))return r[l];throw new Error("Invalid month name: "+e)}function y(e){return typeof e=="string"&&(e=parseInt(e.replace(/\D/g,""))),e>99?e:e<(new Date().getFullYear()+20)%100?e+2e3:e+1900}function m(e){if(e instanceof Date)return e;e=e.trim().toLowerCase();let n=0,t=0,r=0,l=0,s=0,a=0;const d=new RegExp(/\d{1,2}\:\d\d(?:\:\d\ds?)?\s?(?:[a|p]m?)?/gi);if(d.test(e)){const c=e.match(d)[0];e=e.replace(c,"").trim();const g=p(c);if(g!==null&&({hour:l,minute:s,second:a}=g),e.length<=2){const D=new Date;return new Date(D.getFullYear(),D.getMonth(),D.getDate(),l,s,a)}}const u=/(^|\b)(mo|tu|we|th|fr|sa|su|lu|mard|mer|jeu|ve|dom)[\w]*\.?/gi;e=e.replace(u,"").trim();const o=new Date(new Date().setHours(0,0,0,0));if(/(now|today)/.test(e))return o;if(e.includes("tomorrow"))return new Date(o.setDate(o.getDate()+1));e.length===8&&(e=e.replace(/(\d\d\d\d)(\d\d)(\d\d)/,"$1-$2-$3")),e.length===6&&(e=e.replace(/(\d\d)(\d\d)(\d\d)/,y(e.slice(0,2))+"-$2-$3"));try{({year:n,month:t,day:r}=S(e))}catch{return new Date("")}return new Date(n,t-1,r,l,s,a)}function N(e,n=[null,null,null]){const t=r=>r.filter(l=>!n.includes(l));return e===0||e>31?t(["y"]):e>12?t(["d","y"]):e>=1&&e<=12?t(["m","d","y"]):[]}function S(e){const n=e.split(/[\s-/:.,]+/).filter(s=>s!=="");if(n.length<3){if(e.match(/\d{4}/)!==null)throw new Error("Invalid Date");n.unshift(String(new Date().getFullYear()))}const t={year:0,month:0,day:0};function r(s,a){s==="year"?t.year=y(a):t[s]=a}let l=0;for(;!(t.year&&t.month&&t.day);){e:for(const s of n){if(l++,/^[a-zA-Zé]+$/.test(s)){t.month||r("month",M(s)+1);continue}if(/^'\d\d$/.test(s)||/^\d{3,5}$/.test(s)){t.year||r("year",parseInt(s.replace(/'/,"")));continue}const a=parseInt(s);if(isNaN(a))throw console.error(`not date because ${s} isNaN`),new Error("Invalid Date");const d=N(a,[t.year?"y":null,t.month?"m":null,t.day?"d":null]);if(d.length==1){if(d[0]==="m"&&!t.month){r("month",a);continue e}if(d[0]==="d"&&!t.day){r("day",a);continue e}if(d[0]==="y"&&!t.year){r("year",a);continue e}}l>3&&(!t.month&&d.includes("m")?r("month",a):!t.day&&d.includes("d")&&r("day",a))}if(l>6)throw new Error("Invalid Date")}if(t.year&&t.month&&t.day)return t;throw new Error("Invalid Date")}function p(e){if(e=e.trim().toLowerCase(),e==="now"){const o=new Date;return{hour:o.getHours(),minute:o.getMinutes(),second:o.getSeconds()}}const n=e.match(/(\d{3,4})/);if(n){const o=n[1].length,c=n[1].slice(0,o==3?1:2),g=n[1].slice(-2);e=e.replace(n[1],c+":"+g)}const t=new RegExp(/^(\d{1,2})(?::(\d{1,2}))?\s*(?:(a|p)m?)?$/i);if(t.test(e)){const o=e.match(t);if(o===null)return null;e=o[1]+":"+(o[2]||"00")+(o[3]||"")}const r=new RegExp(/^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?\s*(?:(a|p)m?)?$/i);if(!r.test(e))return null;const l=e.match(r);if(l===null)return null;const s=parseInt(l[1]),a=parseInt(l[2]),d=l[3]?parseInt(l[3]):0,u=l[4];return isNaN(s)||isNaN(a)||isNaN(d)?null:u==="p"&&s<12?{hour:s+12,minute:a,second:d}:u==="a"&&s===12?{hour:0,minute:a,second:d}:s<0||s>23||a<0||a>59||d<0||d>59?null:{hour:s,minute:a,second:d}}function k(e,n="h:mm A"){const t=p(e);if(t){const r=new Date;return r.setHours(t.hour),r.setMinutes(t.minute),r.setSeconds(t.second),r.setMilliseconds(0),w(r,n)}return""}function w(e,n="YYYY-MM-DD"){if(e=m(e),isNaN(e.getTime()))return"";const t={y:e.getFullYear(),M:e.getMonth(),D:e.getDate(),W:e.getDay(),H:e.getHours(),m:e.getMinutes(),s:e.getSeconds(),ms:e.getMilliseconds()},r=(o,c=2)=>(o+"").padStart(c,"0"),l=()=>t.H%12||12,s=o=>o<12?"AM":"PM",a=o=>"January|February|March|April|May|June|July|August|September|October|November|December".split("|")[o];function d(o,c=0){const g="Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday".split("|");return c?g[o].slice(0,c):g[o]}const u={YY:String(t.y).slice(-2),YYYY:t.y,M:t.M+1,MM:r(t.M+1),MMMM:a(t.M),MMM:a(t.M).slice(0,3),D:String(t.D),DD:r(t.D),d:String(t.W),dd:d(t.W,2),ddd:d(t.W,3),dddd:d(t.W),H:String(t.H),HH:r(t.H),h:l(),hh:r(l()),A:s(t.H),a:s(t.H).toLowerCase(),m:String(t.m),mm:r(t.m),s:String(t.s),ss:r(t.s),SSS:r(t.ms,3)};return n.replace(/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,(o,c)=>c||u[o])}function $(e,n){const t=m(e);return isNaN(t.getTime())?"":((!n||n.length===0)&&(n="YYYY-MMM-DD"),w(t,n))}function x(e){if(typeof e!="string"&&!(e instanceof Date))return!1;let n=m(e);return n==null?!1:!isNaN(n.getTime())}function A(e,n){return!(n==="past"&&e>new Date||n==="future"&&e.getTime()<new Date().setHours(0,0,0,0))}function E(e){let n=p(e);return n===null?!1:!isNaN(n.hour)&&!isNaN(n.minute)&&!isNaN(n.second)}function C(e){if(e.length>255||!new RegExp(/^.+@.+\.[a-zA-Z0-9]{2,}$/).test(e))return!1;let t="";return t+="^([a-zA-Z0-9!#$%'*+/=?^_`{|}~-]+",t+="(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*",t+="|",t+='"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*"',t+=")@(",t+="(",t+="(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+",t+="[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?",t+=")",t+=")$",new RegExp(t).test(e)}function Y(e){return e=e.replace(/^[^2-90]+/g,""),e=e.replace(/(\d\d\d).*?(\d\d\d).*?(\d\d\d\d)(.*)/,"$1-$2-$3$4"),e}function H(e){return/^\d\d\d-\d\d\d-\d\d\d\d$/.test(e)}function P(e){return e.replace(/[^0-9]/g,"")}function I(e){return/^\-?\d*\.?\d*$/.test(e)}function Z(e){return e.replace(/[^\-0-9.]/g,"").replace(/(^-)|(-)/g,(n,t)=>t?"-":"").replace(/(\..*)\./g,"$1")}function z(e){return/^\-?\d*$/.test(e)}function F(e){return e=e.trim(),new RegExp("^(?:[a-z+]+:)?//","i").test(e)?e:"https://"+e}function L(e){return new RegExp("^(?:[-a-z+]+:)?//","i").test(e)}function j(e){return e=e.replace(/[^0-9]/g,"").replace(/(.{5})(.*)/,"$1-$2").trim(),e.length===6&&(e=e.replace(/-/,"")),e}function q(e){return new RegExp(/^\d{5}(-\d{4})?$/).test(e)}function W(e){return e=e.toUpperCase().replace(/[^A-Z0-9]/g,"").replace(/(.{3})\s*(.*)/,"$1 $2").trim(),e}function J(e){return new RegExp(/^[ABCEGHJKLMNPRSTVXY][0-9][ABCEGHJKLMNPRSTVWXYZ] ?[0-9][ABCEGHJKLMNPRSTVWXYZ][0-9]$/).test(e)}function U(e){return["transparent","currentColor"].includes(e)?!0:typeof e!="string"||!e.trim()?!1:typeof CSS=="object"&&typeof CSS.supports=="function"?CSS.supports("color",e):V(e)}function V(e){const n=new RegExp(/^rgba?\(\s*(\d{1,3}%?,\s*){2}\d{1,3}%?\s*(?:,\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/),t=new RegExp(/^hsla?\(\s*\d+(deg|grad|rad|turn)?,\s*\d{1,3}%,\s*\s*\d{1,3}%(?:,\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/),r=new RegExp(/^rgba?\(\s*(\d{1,3}%?\s+){2}\d{1,3}%?\s*(?:\s*\/\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/),l=new RegExp(/^hsla?\(\s*\d+(deg|grad|rad|turn)?\s+\d{1,3}%\s+\s*\d{1,3}%(?:\s*\/\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/),s=new RegExp(/^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i);let a="aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen";const d=new RegExp(`^(${a})$`,"i");return n.test(e)||t.test(e)||r.test(e)||l.test(e)||s.test(e)||d.test(e)}let h=null;const b=new Map;function G(e){if(e=e.trim().toLowerCase(),["transparent","currentcolor"].includes(e))return e;if(b.has(e))return b.get(e);h===null&&(h=document.createElement("canvas"),h.willReadFrequently=!0);let n=h.getContext("2d");if(!n)throw new Error("Can't get context from colorCanvas");n.fillStyle=e,n.fillRect(0,0,1,1);let t=n.getImageData(0,0,1,1).data,r="#"+("000000"+(t[0]<<16|t[1]<<8|t[2]).toString(16)).slice(-6);return b.set(e,r),r}function K(e){let n={valid:!1,error:!1,messages:[]};return typeof e=="boolean"?{valid:e,error:!1,messages:[]}:typeof e=="string"?{valid:!1,error:!1,messages:[e]}:(typeof e.valid=="boolean"&&(n.valid=e.valid),typeof e.message=="string"&&(n.messages=[e.message]),typeof e.messages=="string"&&(n.messages=[e.messages]),Array.isArray(e.messages)&&(n.messages=e.messages),e.error===!0&&(n.error=!0),n)}i.formatDateTime=w,i.isColor=U,i.isDate=x,i.isDateInRange=A,i.isEmail=C,i.isFormControl=f,i.isInteger=z,i.isNANPTel=H,i.isNumber=I,i.isPostalCA=J,i.isTime=E,i.isType=R,i.isUrl=L,i.isZip=q,i.momentToFPFormat=T,i.monthToNumber=M,i.normalizeValidationResult=K,i.parseColor=G,i.parseDate=m,i.parseDateToString=$,i.parseInteger=P,i.parseNANPTel=Y,i.parseNumber=Z,i.parsePostalCA=W,i.parseTime=p,i.parseTimeToString=k,i.parseUrl=F,i.parseZip=j,i.yearToFull=y,Object.defineProperty(i,Symbol.toStringTag,{value:"Module"})});
+/**
+ * Utilities used by the Validator class.
+ *
+ * @format
+ */
+export function isFormControl(el) {
+    return (el instanceof HTMLInputElement ||
+        el instanceof HTMLSelectElement ||
+        el instanceof HTMLTextAreaElement);
+}
+// Checks if an element has a type or data-type attribute matching
+// one of the types in the passed array
+export function isType(el, types) {
+    if (typeof types === 'string')
+        types = [types];
+    const dataType = el.dataset.type || '';
+    const type = el.type;
+    if (types.includes(dataType))
+        return true;
+    if (types.includes(type))
+        return true;
+    return false;
+}
+// Converts moment.js-style formats strings to the flatpickr format
+// https://flatpickr.js.org/formatting/
+// Useful to use FlatPickr in conjunction with Validator
+// Not comprehensive but covers common format strings
+export function momentToFPFormat(format) {
+    return format
+        .replace(/YYYY/g, 'Y')
+        .replace(/YY/g, 'y')
+        .replace(/MMMM/g, 'F')
+        .replace(/MMM/g, '{3}')
+        .replace(/MM/g, '{2}')
+        .replace(/M/g, 'n')
+        .replace(/DD/g, '{5}')
+        .replace(/D/g, 'j')
+        .replace(/dddd/g, 'l')
+        .replace(/ddd/g, 'D')
+        .replace(/dd/g, 'D')
+        .replace(/d/g, 'w')
+        .replace(/HH/g, '{6}')
+        .replace(/H/g, 'G')
+        .replace(/hh/g, 'h')
+        .replace(/mm/g, 'i')
+        .replace(/m/g, 'i')
+        .replace(/ss/g, 'S')
+        .replace(/s/g, 's')
+        .replace(/A/gi, 'K')
+        .replace(/\{3\}/g, 'M')
+        .replace(/\{2\}/g, 'm')
+        .replace(/\{5\}/g, 'd')
+        .replace(/\{6\}/g, 'H');
+}
+// Converts month name to zero-based month number
+export function monthToNumber(str) {
+    const num = parseInt(str);
+    if (typeof str === 'number' || !isNaN(num))
+        return num - 1;
+    const m = new Date(`1 ${str} 2000`).getMonth();
+    if (!isNaN(m))
+        return m;
+    const dict = {
+        ja: 0,
+        en: 0,
+        fe: 1,
+        fé: 1,
+        ap: 3,
+        ab: 3,
+        av: 3,
+        mai: 4,
+        juin: 5,
+        juil: 6,
+        au: 7,
+        ag: 7,
+        ao: 7,
+        se: 8,
+        o: 9,
+        n: 10,
+        d: 11,
+    };
+    for (const key in dict) {
+        if (str.toLowerCase().startsWith(key))
+            return dict[key];
+    }
+    throw new Error('Invalid month name: ' + str);
+}
+// Convert two-digit year to a four digit year
+export function yearToFull(year) {
+    if (typeof year === 'string')
+        year = parseInt(year.replace(/\D/g, ''));
+    if (year > 99)
+        return year;
+    // If year less than 20 years in the future, assume the 21st century
+    if (year < (new Date().getFullYear() + 20) % 100)
+        return year + 2000;
+    return year + 1900;
+}
+// Parses a string and returns the most plausible date
+export function parseDate(value) {
+    if (value instanceof Date)
+        return value;
+    value = value.trim().toLowerCase();
+    let year = 0;
+    let month = 0;
+    let day = 0;
+    let hour = 0;
+    let minute = 0;
+    let second = 0;
+    const timeRE = new RegExp(/\d{1,2}\:\d\d(?:\:\d\ds?)?\s?(?:[a|p]m?)?/gi);
+    // If the value contains a time, set the time variables
+    if (timeRE.test(value)) {
+        const timeStr = value.match(timeRE)[0];
+        // Remove the time from the string
+        value = value.replace(timeStr, '').trim();
+        const timeParts = parseTime(timeStr);
+        // Assign the time to the variables
+        if (timeParts !== null)
+            ({ hour, minute, second } = timeParts);
+        // If the value seems to be a time only, return a date with this time.
+        if (value.length <= 2) {
+            const now = new Date();
+            return new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, minute, second);
+        }
+    }
+    // Strip day of the week from the string in English, French, or Spanish
+    const dayOfWeekRegex = /(^|\b)(mo|tu|we|th|fr|sa|su|lu|mard|mer|jeu|ve|dom)[\w]*\.?/gi;
+    value = value.replace(dayOfWeekRegex, '').trim();
+    // Convert now and today to the current date at midnight
+    const today = new Date(new Date().setHours(0, 0, 0, 0));
+    if (/(now|today)/.test(value))
+        return today;
+    if (value.includes('tomorrow'))
+        return new Date(today.setDate(today.getDate() + 1));
+    // Handle a undelimited 6 or 8-digit number and treat it as YYYYMMDD
+    if (value.length === 8)
+        value = value.replace(/(\d\d\d\d)(\d\d)(\d\d)/, '$1-$2-$3');
+    if (value.length === 6)
+        value = value.replace(/(\d\d)(\d\d)(\d\d)/, yearToFull(value.slice(0, 2)) + '-$2-$3');
+    try {
+        ;
+        ({ year, month, day } = guessDateParts(value));
+    }
+    catch (e) {
+        return new Date('');
+    }
+    // Return date (month is 0-based)
+    return new Date(year, month - 1, day, hour, minute, second);
+} // end parseDate
+// Returns array of possible meanings for a token in a date string
+// Pass an array of known parameters to exclude them from the guess
+// Assumes months are 1-based.
+export function guessDatePart(num, knownMeanings = [null, null, null]) {
+    const unknown = (arr) => arr.filter((i) => !knownMeanings.includes(i));
+    if (num === 0 || num > 31)
+        return unknown(['y']);
+    if (num > 12)
+        return unknown(['d', 'y']);
+    if (num >= 1 && num <= 12)
+        return unknown(['m', 'd', 'y']);
+    return [];
+}
+// Returns most likely meanings of each part of a date. Assumes 1-based months
+export function guessDateParts(str) {
+    const tokens = str.split(/[\s-/:.,]+/).filter((i) => i !== '');
+    // If two tokens, add a year to the beginning
+    if (tokens.length < 3) {
+        // If one of the tokens is a 4-digit number, don't have enough info to guess the date
+        if (str.match(/\d{4}/) !== null)
+            throw new Error('Invalid Date');
+        else
+            tokens.unshift(String(new Date().getFullYear()));
+    }
+    const date = { year: 0, month: 0, day: 0 };
+    function assignPart(part, num) {
+        if (part === 'year')
+            date.year = yearToFull(num);
+        else
+            date[part] = num;
+    }
+    let count = 0;
+    while (!(date.year && date.month && date.day)) {
+        tokenLoop: for (const token of tokens) {
+            count++;
+            // If word
+            if (/^[a-zA-Zé]+$/.test(token)) {
+                if (!date.month)
+                    assignPart('month', monthToNumber(token) + 1);
+                continue;
+            }
+            // If the token is a year
+            if (/^'\d\d$/.test(token) || /^\d{3,5}$/.test(token)) {
+                if (!date.year)
+                    assignPart('year', parseInt(token.replace(/'/, '')));
+                continue;
+            }
+            // If the token is a number
+            const num = parseInt(token);
+            if (isNaN(num)) {
+                console.error(`not date because ${token} isNaN`);
+                throw new Error('Invalid Date');
+            }
+            const meanings = guessDatePart(num, [
+                date.year ? 'y' : null,
+                date.month ? 'm' : null,
+                date.day ? 'd' : null,
+            ]);
+            if (meanings.length == 1) {
+                if (meanings[0] === 'm' && !date.month) {
+                    assignPart('month', num);
+                    continue tokenLoop;
+                }
+                if (meanings[0] === 'd' && !date.day) {
+                    assignPart('day', num);
+                    continue tokenLoop;
+                }
+                if (meanings[0] === 'y' && !date.year) {
+                    assignPart('year', num);
+                    continue tokenLoop;
+                }
+            }
+            // If we have no idea what the token is after going through all of them
+            // set token to the first thing it could be starting with month
+            if (count > 3) {
+                if (!date.month && meanings.includes('m'))
+                    assignPart('month', num);
+                else if (!date.day && meanings.includes('d'))
+                    assignPart('day', num);
+                // If the previous two lines ran, the year will be assigned on the next iteration
+            }
+        }
+        // Should never take more than six iterations to figure out a valid date
+        if (count > 6)
+            throw new Error('Invalid Date');
+    }
+    if (date.year && date.month && date.day)
+        return date;
+    /* c8 ignore next */
+    throw new Error('Invalid Date');
+}
+// A simplified version of apps-date.ts's parseTime function.
+export function parseTime(value) {
+    // if "now" or "today" is in the string, return the current time
+    value = value.trim().toLowerCase();
+    if (value === 'now') {
+        const now = new Date();
+        return { hour: now.getHours(), minute: now.getMinutes(), second: now.getSeconds() };
+    }
+    // If there is a 3-4 digit number, assume it's a time and add a colon
+    const timeParts = value.match(/(\d{3,4})/);
+    if (timeParts) {
+        const length = timeParts[1].length;
+        const hour = timeParts[1].slice(0, length == 3 ? 1 : 2);
+        const minutes = timeParts[1].slice(-2);
+        value = value.replace(timeParts[1], hour + ':' + minutes);
+    }
+    // Match a simple time without minutes or seconds and optional am/pm
+    const shortTimeRegex = new RegExp(/^(\d{1,2})(?::(\d{1,2}))?\s*(?:(a|p)m?)?$/i);
+    if (shortTimeRegex.test(value)) {
+        const shortParts = value.match(shortTimeRegex);
+        /* c8 ignore next */
+        if (shortParts === null)
+            return null;
+        value = shortParts[1] + ':' + (shortParts[2] || '00') + (shortParts[3] || '');
+    }
+    // Regex to match time in 0:0 format with optional seconds and am/pm
+    const timeRegex = new RegExp(/^(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?\s*(?:(a|p)m?)?$/i);
+    if (!timeRegex.test(value))
+        return null;
+    const parts = value.match(timeRegex);
+    /* c8 ignore next */
+    if (parts === null)
+        return null;
+    const hour = parseInt(parts[1]);
+    const minute = parseInt(parts[2]);
+    const second = parts[3] ? parseInt(parts[3]) : 0;
+    const ampm = parts[4];
+    /* c8 ignore next */
+    if (isNaN(hour) || isNaN(minute) || isNaN(second))
+        return null;
+    if (ampm === 'p' && hour < 12)
+        return { hour: hour + 12, minute, second };
+    if (ampm === 'a' && hour === 12)
+        return { hour: 0, minute, second };
+    /* c8 ignore next 3 */
+    if (hour < 0 || hour > 23)
+        return null;
+    if (minute < 0 || minute > 59)
+        return null;
+    if (second < 0 || second > 59)
+        return null;
+    return { hour, minute, second };
+} // parseTime
+export function parseTimeToString(value, format = 'h:mm A') {
+    const time = parseTime(value);
+    if (time) {
+        const date = new Date();
+        date.setHours(time.hour);
+        date.setMinutes(time.minute);
+        date.setSeconds(time.second);
+        date.setMilliseconds(0);
+        return formatDateTime(date, format);
+    }
+    return '';
+}
+// Accepts a date or date-like string and returns a formatted date string
+// Uses moment-compatible format strings
+export function formatDateTime(date, format = 'YYYY-MM-DD') {
+    // Ensure the date is a valid date object
+    date = parseDate(date);
+    // if date is an invalid date object, return empty string
+    if (isNaN(date.getTime()))
+        return '';
+    const d = {
+        y: date.getFullYear(),
+        M: date.getMonth(),
+        D: date.getDate(),
+        W: date.getDay(),
+        H: date.getHours(),
+        m: date.getMinutes(),
+        s: date.getSeconds(),
+        ms: date.getMilliseconds(),
+    };
+    const pad = (n, w = 2) => (n + '').padStart(w, '0');
+    const getH = () => d.H % 12 || 12;
+    const getMeridiem = (hour) => (hour < 12 ? 'AM' : 'PM');
+    const monthToString = (month) => 'January|February|March|April|May|June|July|August|September|October|November|December'.split('|')[month];
+    function dayToString(day, len = 0) {
+        const days = 'Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday'.split('|');
+        return len ? days[day].slice(0, len) : days[day];
+    }
+    const matches = {
+        YY: String(d.y).slice(-2),
+        YYYY: d.y,
+        M: d.M + 1,
+        MM: pad(d.M + 1),
+        MMMM: monthToString(d.M),
+        MMM: monthToString(d.M).slice(0, 3),
+        D: String(d.D),
+        DD: pad(d.D),
+        d: String(d.W),
+        dd: dayToString(d.W, 2),
+        ddd: dayToString(d.W, 3),
+        dddd: dayToString(d.W),
+        H: String(d.H),
+        HH: pad(d.H),
+        h: getH(),
+        hh: pad(getH()),
+        A: getMeridiem(d.H),
+        a: getMeridiem(d.H).toLowerCase(),
+        m: String(d.m),
+        mm: pad(d.m),
+        s: String(d.s),
+        ss: pad(d.s),
+        SSS: pad(d.ms, 3),
+    };
+    return format.replace(/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, (match, $1) => $1 || matches[match]);
+} // end formatDateTime
+export function parseDateToString(value, format) {
+    const date = parseDate(value);
+    if (isNaN(date.getTime()))
+        return '';
+    // if the format is undefined or has length of 0, set it to the default format
+    if (!format || format.length === 0)
+        format = 'YYYY-MMM-DD';
+    return formatDateTime(date, format);
+}
+// Check if a the value of a specified input is a valid date and is in a specified date range
+export function isDate(value) {
+    if (typeof value !== 'string' && !(value instanceof Date))
+        return false;
+    let date = parseDate(value);
+    if (date === null || date === undefined)
+        return false;
+    return !isNaN(date.getTime());
+}
+// Check if a date is within the specified range
+export function isDateInRange(date, range) {
+    if (range === 'past' && date > new Date())
+        return false;
+    if (range === 'future' && date.getTime() < new Date().setHours(0, 0, 0, 0))
+        return false;
+    // In the future, may add support for ranges like 'last 30 days' or 'next 3 months'
+    // or specific dates like '2019-01-01 to 2019-12-31'
+    return true;
+}
+export function isTime(value) {
+    let timeObj = parseTime(value);
+    if (timeObj === null)
+        return false;
+    return !isNaN(timeObj.hour) && !isNaN(timeObj.minute) && !isNaN(timeObj.second);
+}
+// Input validation for email fields
+export function isEmail(value) {
+    // Emails cannot be longer than 255 characters
+    if (value.length > 255)
+        return false;
+    // This is a relatively simple regex just to check that an email has a valid TLD
+    // It will not catch all invalid emails, the next regex does that
+    let emailTLDRegex = new RegExp(/^.+@.+\.[a-zA-Z0-9]{2,}$/);
+    if (!emailTLDRegex.test(value))
+        return false;
+    // A comprehensive regular expression to check for valid emails. Does not allow for unicode characters.
+    let re = '';
+    // Begin local part. Allow alphanumeric characters and some special characters
+    re += "^([a-zA-Z0-9!#$%'*+/=?^_`{|}~-]+";
+    // Allow dot separated sequences of the above characters (representing multiple labels in the local part)
+    re += "(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*";
+    // Allow a quoted string (using either single or double quotes)
+    re += '|';
+    re +=
+        '"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*"';
+    // End of local part and begin domain part of email address
+    re += ')@(';
+    // Domain part can be either a sequence of labels, separated by dots, ending with a TLD
+    re += '(';
+    re += '(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+';
+    // TLD must be at least 2 characters long
+    re += '[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?';
+    re += ')';
+    // Or, it can be an address within square brackets but
+    // we will not allow this - real people shouldn't be using IP addresses in email addresses
+    re += ')$'; // End of string
+    let emailRegex = new RegExp(re);
+    return emailRegex.test(value);
+}
+// Parse a North American Numbering Plan phone number (xxx-xxx-xxxx)
+export function parseNANPTel(value) {
+    // first character regex, strip anything that isn't part of the area code
+    value = value.replace(/^[^2-90]+/g, '');
+    // now the first number should be for the area code
+    value = value.replace(/(\d\d\d).*?(\d\d\d).*?(\d\d\d\d)(.*)/, '$1-$2-$3$4');
+    return value;
+}
+// Checks that the phone number is valid in North American Numbering Plan
+export function isNANPTel(value) {
+    return /^\d\d\d-\d\d\d-\d\d\d\d$/.test(value);
+}
+export function parseInteger(value) {
+    return value.replace(/[^0-9]/g, '');
+}
+export function isNumber(value) {
+    return /^\-?\d*\.?\d*$/.test(value);
+}
+export function parseNumber(value) {
+    return value
+        .replace(/[^\-0-9.]/g, '') // all but digits, hyphens, and periods
+        .replace(/(^-)|(-)/g, (_match, p1) => (p1 ? '-' : '')) // all but the first hyphen
+        .replace(/(\..*)\./g, '$1'); // periods after a first one
+}
+export function isInteger(value) {
+    return /^\-?\d*$/.test(value);
+}
+// If the string isn't already a valid url, prepends 'https://'
+export function parseUrl(value) {
+    value = value.trim();
+    const urlRegex = new RegExp('^(?:[a-z+]+:)?//', 'i');
+    if (urlRegex.test(value))
+        return value;
+    else
+        return 'https://' + value;
+}
+// Checks if this is a valid URL in a protocol agnostic way,
+// allows for protocol-relative absolute URLs (eg //example.com)
+export function isUrl(value) {
+    const urlRegex = new RegExp('^(?:[-a-z+]+:)?//', 'i');
+    return urlRegex.test(value);
+}
+export function parseZip(value) {
+    value = value
+        .replace(/[^0-9]/g, '')
+        .replace(/(.{5})(.*)/, '$1-$2')
+        .trim();
+    // If the zip code has 6 characters, remove a hyphen
+    if (value.length === 6)
+        value = value.replace(/-/, '');
+    return value;
+}
+export function isZip(value) {
+    const zipRegex = new RegExp(/^\d{5}(-\d{4})?$/);
+    return zipRegex.test(value);
+}
+export function parsePostalCA(value) {
+    value = value
+        .toUpperCase()
+        .replace(/[^A-Z0-9]/g, '')
+        .replace(/(.{3})\s*(.*)/, '$1 $2')
+        .trim();
+    return value;
+}
+export function isPostalCA(value) {
+    const postalRegex = new RegExp(/^[ABCEGHJKLMNPRSTVXY][0-9][ABCEGHJKLMNPRSTVWXYZ] ?[0-9][ABCEGHJKLMNPRSTVWXYZ][0-9]$/);
+    return postalRegex.test(value);
+}
+// Checks if the value is a valid CSS color
+// Falls back to a regex if CSS.supports isn't available
+export function isColor(value) {
+    if (['transparent', 'currentColor'].includes(value))
+        return true;
+    if (typeof value !== 'string' || !value.trim())
+        return false;
+    if (typeof CSS === 'object' && typeof CSS.supports === 'function') {
+        return CSS.supports('color', value);
+    }
+    // If CSS.supports isn't available, use regexes to check for valid rgb or hsl color values
+    // Not as comprehensive as the CSS.supports method, but should work in older browsers
+    return isColorRegex(value);
+}
+function isColorRegex(value) {
+    const rgbRegex = new RegExp(/^rgba?\(\s*(\d{1,3}%?,\s*){2}\d{1,3}%?\s*(?:,\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/);
+    const hslRegex = new RegExp(/^hsla?\(\s*\d+(deg|grad|rad|turn)?,\s*\d{1,3}%,\s*\s*\d{1,3}%(?:,\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/);
+    // Support for the newer space-separated syntax
+    const rgbSpaceRegex = new RegExp(/^rgba?\(\s*(\d{1,3}%?\s+){2}\d{1,3}%?\s*(?:\s*\/\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/);
+    const hslSpaceRegex = new RegExp(/^hsla?\(\s*\d+(deg|grad|rad|turn)?\s+\d{1,3}%\s+\s*\d{1,3}%(?:\s*\/\s*(\.\d+|0+(\.\d+)?|1(\.0+)?|0|1\.0|\d{1,2}(\.\d*)?%|100%))?\s*\)$/);
+    // Hex color regex (short and long formats with and without alpha)
+    const hexRegex = new RegExp(/^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
+    let colors = `aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen`;
+    const colorNameRegex = new RegExp(`^(${colors})$`, 'i');
+    return (rgbRegex.test(value) ||
+        hslRegex.test(value) ||
+        rgbSpaceRegex.test(value) ||
+        hslSpaceRegex.test(value) ||
+        hexRegex.test(value) ||
+        colorNameRegex.test(value));
+}
+// Used to convert color names to hex values
+let colorCanvas = null;
+// Cache of color names to hex values to reduce reads to canvas
+const colorCache = new Map();
+// Uses a Canvas element to convert a color name to a hex value
+export function parseColor(value) {
+    value = value.trim().toLowerCase();
+    if (['transparent', 'currentcolor'].includes(value))
+        return value;
+    if (colorCache.has(value))
+        return colorCache.get(value);
+    if (colorCanvas === null) {
+        colorCanvas = document.createElement('canvas');
+        colorCanvas.willReadFrequently = true;
+    }
+    let ctx = colorCanvas.getContext('2d');
+    if (!ctx)
+        throw new Error("Can't get context from colorCanvas");
+    ctx.fillStyle = value;
+    ctx.fillRect(0, 0, 1, 1);
+    let d = ctx.getImageData(0, 0, 1, 1).data;
+    let hex = '#' + ('000000' + ((d[0] << 16) | (d[1] << 8) | d[2]).toString(16)).slice(-6);
+    colorCache.set(value, hex);
+    return hex;
+}
+// Homogenizes the return of a custom validation function to a ValidationResult
+// that has a boolean valid property and messages array of strings
+export function normalizeValidationResult(res) {
+    let result = { valid: false, error: false, messages: [] };
+    if (typeof res === 'boolean')
+        return { valid: res, error: false, messages: [] };
+    if (typeof res === 'string')
+        return { valid: false, error: false, messages: [res] };
+    if (typeof res.valid === 'boolean')
+        result.valid = res.valid;
+    if (typeof res.message === 'string')
+        result.messages = [res.message];
+    if (typeof res.messages === 'string')
+        result.messages = [res.messages];
+    if (Array.isArray(res.messages))
+        result.messages = res.messages;
+    if (res.error === true)
+        result.error = true;
+    return result;
+}

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@jdlien/validator-utils",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "type": "module",
   "module": "dist/validator-utils.js",
+  "types": "dist/validator-utils.d.ts",
   "files": [
     "dist"
   ],
   "description": "Validation and sanitization functions used by @jdlien/Validator.",
   "scripts": {
     "dev": "vite",
-    "build": "tsc && vite build",
+    "build": "vite build && tsc --declaration",
     "preview": "vite preview",
     "test": "vitest",
     "coverage": "vitest --coverage"