@archi-code/validation 0.0.0-stage → 3.0.0-alpha.1

package/dist/cjs/validators/isVAT.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vatMatchers = void 0;
+exports.isVAT = isVAT;
+const errors_1 = require("../helpers/errors");
+const hasOwn_1 = require("../helpers/hasOwn");
+const string_1 = require("../convert/string");
+const algorithms = require("../helpers/algorithms");
+const config_1 = require("../helpers/config");
+const AU = (str) => {
+    const match = str.match(/^(AU)?(\d{11})$/);
+    if (!match) {
+        return false;
+    }
+    const weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    str = str.replace(/^AU/, '');
+    const ABN = (parseInt(str.slice(0, 1), 10) - 1).toString() + str.slice(1);
+    let total = 0;
+    for (let i = 0; i < 11; i++) {
+        total += weights[i] * Number(ABN.charAt(i));
+    }
+    return total !== 0 && total % 89 === 0;
+};
+const CH = (str) => {
+    const hasValidCheckNumber = (digits) => {
+        const checkDigit = digits.pop();
+        const weights = [5, 4, 3, 2, 7, 6, 5, 4];
+        const calculatedCheckNumber = (11 - (digits.reduce((acc, el, idx) => acc + el * weights[idx], 0) % 11)) % 11;
+        return checkDigit === calculatedCheckNumber;
+    };
+    return (/^(CHE[- ]?)?(\d{9}|(\d{3}\.\d{3}\.\d{3})|(\d{3} \d{3} \d{3})) ?(TVA|MWST|IVA)?$/.test(str) &&
+        hasValidCheckNumber(str.match(/\d/g).map((el) => +el)));
+};
+const PT = (str) => {
+    const match = str.match(/^(PT)?(\d{9})$/);
+    if (!match) {
+        return false;
+    }
+    const tin = match[2];
+    const checksum = 11 -
+        (algorithms.reverseMultiplyAndSum(tin
+            .split('')
+            .slice(0, 8)
+            .map((a) => parseInt(a, 10)), 9) %
+            11);
+    if (checksum > 9) {
+        return parseInt(tin[8], 10) === 0;
+    }
+    return checksum === parseInt(tin[8], 10);
+};
+exports.vatMatchers = {
+    AT: (str) => /^(AT)?U\d{8}$/.test(str),
+    BE: (str) => /^(BE)?\d{10}$/.test(str),
+    BG: (str) => /^(BG)?\d{9,10}$/.test(str),
+    HR: (str) => /^(HR)?\d{11}$/.test(str),
+    CY: (str) => /^(CY)?[0-9A-Za-z]{9}$/.test(str),
+    CZ: (str) => /^(CZ)?\d{8,10}$/.test(str),
+    DK: (str) => /^(DK)?\d{8}$/.test(str),
+    EE: (str) => /^(EE)?\d{9}$/.test(str),
+    FI: (str) => /^(FI)?\d{8}$/.test(str),
+    FR: (str) => /^(FR)([A-Z0-9]{2}\d{9})$/.test(str),
+    DE: (str) => /^(DE)?\d{9}$/.test(str),
+    EL: (str) => /^(EL)?\d{9}$/.test(str),
+    HU: (str) => /^(HU)?\d{8}$/.test(str),
+    IE: (str) => /^(IE)?\d{7}\w{1}(W)?$/.test(str),
+    IT: (str) => /^(IT)?\d{11}$/.test(str),
+    LV: (str) => /^(LV)?\d{11}$/.test(str),
+    LT: (str) => /^(LT)?\d{9,12}$/.test(str),
+    LU: (str) => /^(LU)?\d{8}$/.test(str),
+    MT: (str) => /^(MT)?\d{8}$/.test(str),
+    NL: (str) => /^(NL)?\d{9}B\d{2}$/.test(str),
+    PL: (str) => /^(PL)?(\d{10}|(\d{3}-\d{3}-\d{2}-\d{2})|(\d{3}-\d{2}-\d{2}-\d{3}))$/.test(str),
+    PT,
+    RO: (str) => /^(RO)?\d{2,10}$/.test(str),
+    SK: (str) => /^(SK)?\d{10}$/.test(str),
+    SI: (str) => /^(SI)?\d{8}$/.test(str),
+    ES: (str) => /^(ES)?\w\d{7}[A-Z]$/.test(str),
+    SE: (str) => /^(SE)?\d{12}$/.test(str),
+    AL: (str) => /^(AL)?\w{9}[A-Z]$/.test(str),
+    MK: (str) => /^(MK)?\d{13}$/.test(str),
+    AU,
+    BY: (str) => /^(УНП )?\d{9}$/.test(str),
+    CA: (str) => /^(CA)?\d{9}$/.test(str),
+    IS: (str) => /^(IS)?\d{5,6}$/.test(str),
+    IN: (str) => /^(IN)?\d{15}$/.test(str),
+    ID: (str) => /^(ID)?(\d{15}|(\d{2}\.\d{3}\.\d{3}\.\d{1}-\d{3}\.\d{3}))$/.test(str),
+    IL: (str) => /^(IL)?\d{9}$/.test(str),
+    KZ: (str) => /^(KZ)?\d{12}$/.test(str),
+    NZ: (str) => /^(NZ)?\d{9}$/.test(str),
+    NG: (str) => /^(NG)?(\d{12}|(\d{8}-\d{4}))$/.test(str),
+    NO: (str) => /^(NO)?\d{9}MVA$/.test(str),
+    PH: (str) => /^(PH)?(\d{12}|\d{3} \d{3} \d{3} \d{3})$/.test(str),
+    RU: (str) => /^(RU)?(\d{10}|\d{12})$/.test(str),
+    SM: (str) => /^(SM)?\d{5}$/.test(str),
+    SA: (str) => /^(SA)?\d{15}$/.test(str),
+    RS: (str) => /^(RS)?\d{9}$/.test(str),
+    CH,
+    TR: (str) => /^(TR)?\d{10}$/.test(str),
+    UA: (str) => /^(UA)?\d{12}$/.test(str),
+    GB: (str) => /^GB((\d{3} \d{4} ([0-8][0-9]|9[0-6]))|(\d{9} \d{3})|(((GD[0-4])|(HA[5-9]))[0-9]{2}))$/.test(str),
+    UZ: (str) => /^(UZ)?\d{9}$/.test(str),
+    AR: (str) => /^(AR)?\d{11}$/.test(str),
+    BO: (str) => /^(BO)?\d{7}$/.test(str),
+    BR: (str) => /^(BR)?((\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2})|(\d{3}\.\d{3}\.\d{3}-\d{2}))$/.test(str),
+    CL: (str) => /^(CL)?\d{8}-\d{1}$/.test(str),
+    CO: (str) => /^(CO)?\d{10}$/.test(str),
+    CR: (str) => /^(CR)?\d{9,12}$/.test(str),
+    EC: (str) => /^(EC)?\d{13}$/.test(str),
+    SV: (str) => /^(SV)?\d{4}-\d{6}-\d{3}-\d{1}$/.test(str),
+    GT: (str) => /^(GT)?\d{7}-\d{1}$/.test(str),
+    HN: (str) => /^HN$/.test(str),
+    MX: (str) => /^(MX)?\w{3,4}\d{6}\w{3}$/.test(str),
+    NI: (str) => /^(NI)?\d{3}-\d{6}-\d{4}\w{1}$/.test(str),
+    PA: (str) => /^(PA)?[0-9A-Z-]*\d[0-9A-Z-]*$/.test(str),
+    PY: (str) => /^(PY)?\d{6,8}-\d{1}$/.test(str),
+    PE: (str) => /^(PE)?\d{11}$/.test(str),
+    DO: (str) => /^(DO)?(\d{11}|(\d{3}-\d{7}-\d{1})|[145]{1}\d{8}|([145]{1})-\d{2}-\d{5}-\d{1})$/.test(str),
+    UY: (str) => /^(UY)?\d{12}$/.test(str),
+    VE: (str) => /^(VE)?[JGVE]{1}-(\d{9}|(\d{8}-\d{1}))$/.test(str),
+};
+function isVAT(value, options) {
+    const { countryCode } = (0, config_1.optionsOf)(options);
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (typeof countryCode !== 'string')
+        throw new errors_1.ValidationConfigError('countryCode must be a string');
+    if ((0, hasOwn_1.hasOwn)(exports.vatMatchers, countryCode)) {
+        return exports.vatMatchers[countryCode](str);
+    }
+    throw new errors_1.ValidationConfigError(`Invalid country code: '${(0, config_1.configText)(countryCode)}'`);
+}

package/dist/cjs/validators/isVariableWidth.d.ts

@@ -0,0 +1 @@
+export declare function isVariableWidth(value: unknown): boolean;

package/dist/cjs/validators/isVariableWidth.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVariableWidth = isVariableWidth;
+const string_1 = require("../convert/string");
+const isFullWidth_1 = require("./isFullWidth");
+const isHalfWidth_1 = require("./isHalfWidth");
+function isVariableWidth(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return isFullWidth_1.fullWidth.test(str) && isHalfWidth_1.halfWidth.test(str);
+}

package/dist/cjs/validators/isWhitelisted.d.ts

@@ -0,0 +1,4 @@
+export interface IsWhitelistedOptions {
+    chars: string | string[];
+}
+export declare function isWhitelisted(value: unknown, options: IsWhitelistedOptions): boolean;

package/dist/cjs/validators/isWhitelisted.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWhitelisted = isWhitelisted;
+const string_1 = require("../convert/string");
+const config_1 = require("../helpers/config");
+const errors_1 = require("../helpers/errors");
+function isWhitelisted(value, options) {
+    const { chars } = (0, config_1.optionsOf)(options);
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (typeof chars !== 'string' && !Array.isArray(chars)) {
+        throw new errors_1.ValidationConfigError(`chars must be a string or an array, got ${(0, config_1.configText)(chars)}`);
+    }
+    for (let i = str.length - 1; i >= 0; i--) {
+        if (chars.indexOf(str[i]) === -1) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/cjs/validators/matches.d.ts

@@ -0,0 +1,5 @@
+export interface MatchesOptions {
+    pattern: RegExp | string;
+    modifiers?: string;
+}
+export declare function matches(value: unknown, options: MatchesOptions): boolean;

package/dist/cjs/validators/matches.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matches = matches;
+const string_1 = require("../convert/string");
+const config_1 = require("../helpers/config");
+const errors_1 = require("../helpers/errors");
+function matches(value, options) {
+    const { pattern, modifiers } = (0, config_1.optionsOf)(options);
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (Object.prototype.toString.call(pattern) === '[object RegExp]') {
+        pattern.lastIndex = 0;
+        return !!str.match(pattern);
+    }
+    if (typeof pattern !== 'string') {
+        throw new errors_1.ValidationConfigError(`pattern must be a RegExp or a string, got ${(0, config_1.configText)(pattern)}`);
+    }
+    let regex;
+    try {
+        regex = new RegExp(pattern, modifiers);
+    }
+    catch {
+        throw new errors_1.ValidationConfigError(`Invalid pattern '${pattern}' or modifiers '${(0, config_1.configText)(modifiers)}'`);
+    }
+    return !!str.match(regex);
+}

package/dist/esm/canBe/array.d.ts

@@ -0,0 +1 @@
+export declare function canBeArray(v: unknown): boolean;

package/dist/esm/canBe/array.js

@@ -0,0 +1,4 @@
+import { toArray } from '../convert/array.js';
+export function canBeArray(v) {
+    return toArray(v).ok;
+}

package/dist/esm/canBe/boolean.d.ts

@@ -0,0 +1 @@
+export declare function canBeBoolean(v: unknown): boolean;

package/dist/esm/canBe/boolean.js

@@ -0,0 +1,4 @@
+import { toBoolean } from '../convert/boolean.js';
+export function canBeBoolean(v) {
+    return toBoolean(v).ok;
+}

package/dist/esm/canBe/date.d.ts

@@ -0,0 +1 @@
+export declare function canBeDate(v: unknown): boolean;

package/dist/esm/canBe/date.js

@@ -0,0 +1,4 @@
+import { toDate } from '../convert/date.js';
+export function canBeDate(v) {
+    return toDate(v).ok;
+}

package/dist/esm/canBe/enum.d.ts

@@ -0,0 +1 @@
+export declare function canBeEnum(v: unknown, options: readonly string[]): boolean;

package/dist/esm/canBe/enum.js

@@ -0,0 +1,4 @@
+import { toEnum } from '../convert/enum.js';
+export function canBeEnum(v, options) {
+    return toEnum(v, options).ok;
+}

package/dist/esm/canBe/float.d.ts

@@ -0,0 +1 @@
+export declare function canBeFloat(v: unknown): boolean;

package/dist/esm/canBe/float.js

@@ -0,0 +1,4 @@
+import { toFloat } from '../convert/float.js';
+export function canBeFloat(v) {
+    return toFloat(v).ok;
+}

package/dist/esm/canBe/index.d.ts

@@ -0,0 +1,8 @@
+export { canBeString } from './string.js';
+export { canBeBoolean } from './boolean.js';
+export { canBeInteger } from './integer.js';
+export { canBeFloat } from './float.js';
+export { canBeDate } from './date.js';
+export { canBeJson, canBeJsonObject } from './json.js';
+export { canBeArray } from './array.js';
+export { canBeEnum } from './enum.js';

package/dist/esm/canBe/index.js

@@ -0,0 +1,8 @@
+export { canBeString } from './string.js';
+export { canBeBoolean } from './boolean.js';
+export { canBeInteger } from './integer.js';
+export { canBeFloat } from './float.js';
+export { canBeDate } from './date.js';
+export { canBeJson, canBeJsonObject } from './json.js';
+export { canBeArray } from './array.js';
+export { canBeEnum } from './enum.js';

package/dist/esm/canBe/integer.d.ts

@@ -0,0 +1 @@
+export declare function canBeInteger(v: unknown): boolean;

package/dist/esm/canBe/integer.js

@@ -0,0 +1,4 @@
+import { toInteger } from '../convert/integer.js';
+export function canBeInteger(v) {
+    return toInteger(v).ok;
+}

package/dist/esm/canBe/json.d.ts

@@ -0,0 +1,2 @@
+export declare function canBeJson(v: unknown): boolean;
+export declare const canBeJsonObject: typeof canBeJson;

package/dist/esm/canBe/json.js

@@ -0,0 +1,5 @@
+import { toJson } from '../convert/json.js';
+export function canBeJson(v) {
+    return toJson(v).ok;
+}
+export const canBeJsonObject = canBeJson;

package/dist/esm/canBe/string.d.ts

@@ -0,0 +1 @@
+export declare function canBeString(v: unknown): boolean;

package/dist/esm/canBe/string.js

@@ -0,0 +1,4 @@
+import { toString } from '../convert/string.js';
+export function canBeString(v) {
+    return toString(v).ok;
+}

package/dist/esm/convert/any-to-string.d.ts

@@ -0,0 +1 @@
+export declare function anyToString(value: any): string;

package/dist/esm/convert/any-to-string.js

@@ -0,0 +1,61 @@
+import { toString } from './string.js';
+export function anyToString(value) {
+    try {
+        return describe(value, new WeakSet());
+    }
+    catch {
+        return '[Unrepresentable value]';
+    }
+}
+function describe(value, seen) {
+    const text = toString(value);
+    if (text.ok) {
+        return text.value;
+    }
+    else if (value === null) {
+        return 'null';
+    }
+    else if (value === undefined) {
+        return 'undefined';
+    }
+    else if (typeof value === 'number' && isNaN(value)) {
+        return 'NaN';
+    }
+    else if (value instanceof Date) {
+        return isNaN(value.getTime()) ? 'Date(Invalid)' : `Date(${value.toISOString()})`;
+    }
+    else if (value instanceof Map || value instanceof Set) {
+        if (seen.has(value))
+            return '[Circular]';
+        seen.add(value);
+        const described = value instanceof Map
+            ? `Map({${Array.from(value, ([key, val]) => `${describe(key, seen)}: ${describe(val, seen)}`).join(', ')}})`
+            : `Set(${Array.from(value, (item) => describe(item, seen)).join(', ')})`;
+        seen.delete(value);
+        return described;
+    }
+    else if (value instanceof RegExp) {
+        return `RegExp(${value.toString()})`;
+    }
+    else if (value instanceof Error) {
+        return `new ${value.name}(${value.message})`;
+    }
+    else if (value instanceof Promise) {
+        return 'Promise';
+    }
+    else if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value) || value.toString();
+        }
+        catch {
+            return '[Circular or too complex to stringify]';
+        }
+    }
+    else if (typeof value === 'function') {
+        return `Function(${value.name || 'anonymous'})`;
+    }
+    else if (typeof value === 'symbol') {
+        return value.toString();
+    }
+    return String(value);
+}

package/dist/esm/convert/array.d.ts

@@ -0,0 +1,2 @@
+import type { Converted } from './result.js';
+export declare function toArray(v: unknown): Converted<unknown[]>;

package/dist/esm/convert/array.js

@@ -0,0 +1,22 @@
+import { ConvertMessages, failure, success } from './result.js';
+export function toArray(v) {
+    let isArray;
+    try {
+        isArray = Array.isArray(v);
+    }
+    catch {
+        return failure(ConvertMessages.ARRAY);
+    }
+    if (isArray)
+        return success(v);
+    if (typeof v !== 'string')
+        return failure(ConvertMessages.ARRAY);
+    let parsed;
+    try {
+        parsed = JSON.parse(v);
+    }
+    catch {
+        return failure(ConvertMessages.ARRAY);
+    }
+    return Array.isArray(parsed) ? success(parsed) : failure(ConvertMessages.ARRAY);
+}

package/dist/esm/convert/boolean.d.ts

@@ -0,0 +1,5 @@
+import type { Converted } from './result.js';
+export interface BooleanConvertOptions {
+    mode?: 'default' | 'strict' | 'loose';
+}
+export declare function toBoolean(v: unknown, options?: BooleanConvertOptions): Converted<boolean>;

package/dist/esm/convert/boolean.js

@@ -0,0 +1,27 @@
+import { ConvertMessages, failure, success } from './result.js';
+const TRUE_VALUES = { default: ['true', '1'], strict: ['true', '1'], loose: ['true', '1', 'yes'] };
+const FALSE_VALUES = {
+    default: ['false', '0'],
+    strict: ['false', '0'],
+    loose: ['false', '0', 'no'],
+};
+export function toBoolean(v, options) {
+    if (typeof v === 'boolean')
+        return success(v);
+    if (typeof v === 'number') {
+        if (v === 1)
+            return success(true);
+        if (v === 0)
+            return success(false);
+        return failure(ConvertMessages.BOOLEAN);
+    }
+    if (typeof v === 'string') {
+        const mode = options?.mode === 'strict' || options?.mode === 'loose' ? options.mode : 'default';
+        const s = mode === 'strict' ? v : mode === 'loose' ? v.toLowerCase() : v.trim().toLowerCase();
+        if (TRUE_VALUES[mode].includes(s))
+            return success(true);
+        if (FALSE_VALUES[mode].includes(s))
+            return success(false);
+    }
+    return failure(ConvertMessages.BOOLEAN);
+}

package/dist/esm/convert/date.d.ts

@@ -0,0 +1,11 @@
+import type { Converted } from './result.js';
+export declare function isCalendarDate(year: number, month: number, day: number): boolean;
+export interface DateConvertOptions {
+    format?: string;
+    delimiters?: string[];
+    strictMode?: boolean;
+    twoDigitYearPivot?: number;
+    iso?: boolean;
+    lax?: boolean;
+}
+export declare function toDate(v: unknown, options?: DateConvertOptions): Converted<Date>;

package/dist/esm/convert/date.js

@@ -0,0 +1,158 @@
+import { ConvertMessages, failure, success } from './result.js';
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeapYear(year) {
+    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
+export function isCalendarDate(year, month, day) {
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    return day <= (month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1]);
+}
+function validTime(hour, minute, second) {
+    return Number(hour ?? 0) <= 23 && Number(minute ?? 0) <= 59 && Number(second ?? 0) <= 59;
+}
+function validZone(zone) {
+    return (zone === undefined ||
+        zone === 'Z' ||
+        (Number(zone.slice(1, 3)) <= 23 && Number(zone.slice(4, 6)) <= 59));
+}
+function validInstant(d) {
+    return isNaN(d.getTime()) ? failure(ConvertMessages.DATE) : success(d);
+}
+function pinZonelessTimeToUtc(isoText, time, zone) {
+    return time !== undefined && zone === undefined ? `${isoText}Z` : isoText;
+}
+const DATE_FORMAT = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2}):(\d{2})(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
+export function toDate(v, options) {
+    try {
+        if (options?.lax)
+            return toDateLax(v);
+        if (options?.iso)
+            return toDateIso(v);
+        return toDateByFormat(v, options);
+    }
+    catch {
+        return failure(ConvertMessages.DATE);
+    }
+}
+function toDateIso(v) {
+    if (v instanceof Date)
+        return validInstant(v);
+    if (typeof v !== 'string')
+        return failure(ConvertMessages.DATE);
+    const m = DATE_FORMAT.exec(v);
+    if (m === null)
+        return failure(ConvertMessages.DATE);
+    if (!isCalendarDate(Number(m[1]), Number(m[2]), Number(m[3])))
+        return failure(ConvertMessages.DATE);
+    const hasTime = m[4] !== undefined;
+    if (hasTime && (!validTime(m[4], m[5], m[6]) || !validZone(m[8])))
+        return failure(ConvertMessages.DATE);
+    return validInstant(new Date(pinZonelessTimeToUtc(v.replace(' ', 'T'), m[4], m[8])));
+}
+const ISO_DATE_TIME = /^(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})?)?$/;
+const DATE_TO_STRING = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{2} -?\d{4,6} \d{2}:\d{2}:\d{2} GMT[+-](?:[01]\d|2[0-3])[0-5]\d(?: \(.+\))?$/;
+const DATE_TO_UTC_STRING = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) -?\d{4,6} \d{2}:\d{2}:\d{2} GMT$/;
+function toDateLax(v) {
+    if (v instanceof Date)
+        return validInstant(v);
+    if (typeof v !== 'string')
+        return failure(ConvertMessages.DATE);
+    const m = ISO_DATE_TIME.exec(v);
+    if (m !== null) {
+        const month = m[2] === undefined ? 1 : Number(m[2]);
+        const day = m[3] === undefined ? 1 : Number(m[3]);
+        if (!isCalendarDate(Number(m[1]), month, day))
+            return failure(ConvertMessages.DATE);
+        if (!validTime(m[4], m[5], m[6]) || !validZone(m[7]))
+            return failure(ConvertMessages.DATE);
+        return validInstant(new Date(pinZonelessTimeToUtc(v, m[4], m[7])));
+    }
+    if (DATE_TO_STRING.test(v) || DATE_TO_UTC_STRING.test(v))
+        return validInstant(new Date(v));
+    return failure(ConvertMessages.DATE);
+}
+const default_date_options = {
+    format: 'YYYY/MM/DD',
+    delimiters: ['/', '-'],
+    strictMode: false,
+};
+const validFormatRegex = /(^(y{4}|y{2})[./-](m{1,2})[./-](d{1,2})$)|(^(m{1,2})[./-](d{1,2})[./-]((y{4}|y{2})$))|(^(d{1,2})[./-](m{1,2})[./-]((y{4}|y{2})$))/i;
+function isValidFormat(format) {
+    return validFormatRegex.test(format);
+}
+function zip(date, format) {
+    const zippedArr = [], len = Math.max(date.length, format.length);
+    for (let i = 0; i < len; i++) {
+        zippedArr.push([date[i], format[i]]);
+    }
+    return zippedArr;
+}
+function withDefaults(options) {
+    const merged = { ...options };
+    for (const key of Object.keys(default_date_options)) {
+        if (merged[key] === undefined)
+            merged[key] = default_date_options[key];
+    }
+    return merged;
+}
+function currentTwoDigitYear() {
+    return new Date().getFullYear() % 100;
+}
+function toDateByFormat(input, options) {
+    const mergedOptions = withDefaults(options);
+    if (typeof input === 'string' && isValidFormat(mergedOptions.format)) {
+        if (mergedOptions.strictMode && input.length !== mergedOptions.format.length) {
+            return failure(ConvertMessages.DATE);
+        }
+        if (!Array.isArray(mergedOptions.delimiters))
+            return failure(ConvertMessages.DATE);
+        const formatDelimiter = mergedOptions.delimiters.find((delimiter) => mergedOptions.format.indexOf(delimiter) !== -1);
+        if (formatDelimiter === undefined)
+            return failure(ConvertMessages.DATE);
+        const dateDelimiter = mergedOptions.strictMode
+            ? formatDelimiter
+            : mergedOptions.delimiters.find((delimiter) => input.indexOf(delimiter) !== -1);
+        const dateAndFormat = zip(input.split(dateDelimiter), mergedOptions.format.toLowerCase().split(formatDelimiter));
+        const dateObj = {};
+        for (const [dateWord, formatWord] of dateAndFormat) {
+            if (!dateWord || !formatWord || dateWord.length !== formatWord.length) {
+                return failure(ConvertMessages.DATE);
+            }
+            dateObj[formatWord.charAt(0)] = dateWord;
+        }
+        let fullYear = dateObj.y;
+        if (fullYear.startsWith('-')) {
+            return failure(ConvertMessages.DATE);
+        }
+        if (dateObj.y.length === 2) {
+            const parsedYear = parseInt(dateObj.y, 10);
+            if (isNaN(parsedYear)) {
+                return failure(ConvertMessages.DATE);
+            }
+            const pivot = mergedOptions.twoDigitYearPivot ?? currentTwoDigitYear();
+            if (parsedYear < pivot) {
+                fullYear = `20${dateObj.y}`;
+            }
+            else {
+                fullYear = `19${dateObj.y}`;
+            }
+        }
+        let month = dateObj.m;
+        if (dateObj.m.length === 1) {
+            month = `0${dateObj.m}`;
+        }
+        let day = dateObj.d;
+        if (dateObj.d.length === 1) {
+            day = `0${dateObj.d}`;
+        }
+        const date = new Date(`${fullYear}-${month}-${day}T00:00:00.000Z`);
+        return date.getUTCDate() === +dateObj.d ? success(date) : failure(ConvertMessages.DATE);
+    }
+    if (!mergedOptions.strictMode) {
+        return Object.prototype.toString.call(input) === '[object Date]' && isFinite(input)
+            ? success(input)
+            : failure(ConvertMessages.DATE);
+    }
+    return failure(ConvertMessages.DATE);
+}

package/dist/esm/convert/enum.d.ts

@@ -0,0 +1,2 @@
+import type { Converted } from './result.js';
+export declare function toEnum<T extends string>(v: unknown, options: readonly T[]): Converted<T>;

package/dist/esm/convert/enum.js

@@ -0,0 +1,8 @@
+import { ConvertMessages, failure, success } from './result.js';
+export function toEnum(v, options) {
+    if (typeof v !== 'string' && typeof v !== 'number' && typeof v !== 'boolean')
+        return failure(ConvertMessages.ENUM);
+    const key = String(v);
+    const index = options.indexOf(key);
+    return index === -1 ? failure(ConvertMessages.ENUM) : success(options[index]);
+}

package/dist/esm/convert/float.d.ts

@@ -0,0 +1,6 @@
+import type { Converted } from './result.js';
+export interface FloatConvertOptions {
+    syntax?: 'default' | 'validator';
+    decimalSeparator?: string;
+}
+export declare function toFloat(v: unknown, options?: FloatConvertOptions): Converted<number>;