@valkyriestudios/utils 12.19.0 → 12.21.0

package/array/dedupe.d.ts

@@ -9,8 +9,6 @@ type DedupeOptions<T> = {
  *
  * @param {Array} val - Array to dedupe
  * @param {DedupeOptions?} opts - Dedupe options
- *
- * @returns Deduped array
  */
 declare function dedupe<T>(val: T[], opts?: DedupeOptions<T>): T[];
 export { dedupe, dedupe as default };

package/array/groupBy.d.ts

@@ -17,7 +17,6 @@ type Handler<T> = (val: T) => string | number | boolean;
  *
  * @param {T[]} arr - Array to group
  * @param {Handler<T>|keyof T} handler - String or a function, determines what to group by
- * @returns {Record<string, T[]>}
  */
 declare function groupBy<T extends Record<string, any>>(arr: T[], handler: Handler<T> | keyof T): Record<string, T[]>;
 export { groupBy, groupBy as default };

package/array/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is an array
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is an array
+ * @param {unknown} val - Value to verify
  */
 declare function isArray(val: unknown): val is unknown[];
 export { isArray, isArray as default };

package/array/isNotEmpty.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is an array with content
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is an array with content
+ * @param {unknown} val - Value to verify
  */
 declare function isNotEmptyArray(val: unknown): val is unknown[];
 export { isNotEmptyArray, isNotEmptyArray as default };

package/array/join.d.ts

@@ -35,8 +35,6 @@ interface joinOptions {
  *
  * @param {unknown[]} val - Array of values to join
  * @param {joinOptions?} opts - Join options
- *
- * @returns Joined array as string
  */
 declare function join(val: unknown[], opts?: joinOptions): string;
 export { join, join as default };

package/array/join.js

@@ -4,6 +4,7 @@ exports.join = join;
 exports.default = join;
 const round_1 = require("../number/round");
 const isIntegerAboveOrEqual_1 = require("../number/isIntegerAboveOrEqual");
+const SPACE_RGX = /(\s){2,}/g;
 function join(val, opts) {
     if (!Array.isArray(val) || !val.length)
         return '';
@@ -18,11 +19,11 @@ function join(val, opts) {
         const el = val[i];
         if (typeof el === 'string' && el.trim().length) {
             const trimmed = VALTRIM ? el.trim() : el;
-            result = `${result}${hasVal ? DELIM : ''}${INNERTRIM ? trimmed.replace(/(\s){2,}/g, ' ') : trimmed}`;
+            result = result + (hasVal ? DELIM : '') + (INNERTRIM ? trimmed.replace(SPACE_RGX, ' ') : trimmed);
             hasVal = true;
         }
         else if (Number.isFinite(el)) {
-            result = `${result}${hasVal ? DELIM : ''}${VALROUND !== false ? (0, round_1.round)(el, VALROUND) : el}`;
+            result = result + (hasVal ? DELIM : '') + (VALROUND !== false ? (0, round_1.round)(el, VALROUND) : el);
             hasVal = true;
         }
     }

package/array/mapFn.js

@@ -16,7 +16,7 @@ function mapFn(arr, fn, opts) {
         hash = fn(el);
         if (!Number.isFinite(hash) && !(typeof hash === 'string' && hash.trim().length))
             continue;
-        hash = `${hash}`;
+        hash = hash + '';
         map[hash] = MERGE && map[hash] !== undefined ? { ...map[hash], ...el } : el;
     }
     return map;

package/array/mapPrimitive.d.ts

@@ -31,8 +31,6 @@ type mapReturn = Record<string, string | number>;
  *
  * @param {unknown[]} val - Array to map
  * @param {mapOptions?} opts - Options object to override built-in defaults
- *
- * @returns {mapReturn} KV-Map object
  */
 declare function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
 export { mapPrimitive, mapPrimitive as default };

package/array/sort.d.ts

@@ -54,8 +54,6 @@ type sortByFunction = (el: Record<string, any>) => string;
  * @param {string|sortByFunction} by - Either a string (key) or a function
  * @param {'desc'|'asc'} dir - (default='asc') Direction to sort in (asc or desc)
  * @param {sortOptions} opts - Sort options
- *
- * @returns Sorted array
  * @throws {Error}
  */
 declare function sort<T extends {

package/array/split.d.ts

@@ -12,8 +12,6 @@ type SplitOptions<T> = {
  * @param {Array} val - Array to split
  * @param {number} size - Size of batches
  * @param {SplitOptions?} opts - Split options
- *
- * @returns Split batches
  */
 declare function split<T>(arr: T[], size: number, opts?: SplitOptions<T>): T[][];
 export { split, split as default };

package/boolean/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is a boolean
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is a boolean
+ * @param {unknown} val - Value to verify
  */
 declare function isBoolean(val: unknown): val is boolean;
 export { isBoolean, isBoolean as default };

package/date/addUTC.d.ts

@@ -1,11 +1,10 @@
+export type AddUTCKey = 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond';
 /**
  * Adds the provided amount of a specific key to the provided date
  *
- * @param val - Date to set to end of
- * @param amount - (default=0) Amount of key to add
- * @param key - (default='millisecond') Key to set
- *
- * @returns New date with provided amount of key added
+ * @param {Date} val - Date to set to end of
+ * @param {number} amount - (default=0) Amount of key to add
+ * @param {AddUTCKey} key - (default='millisecond') Key to set
  */
-declare function addUTC(val: Date, amt?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
+declare function addUTC(val: Date, amt?: number, key?: AddUTCKey): Date;
 export { addUTC, addUTC as default };

package/date/diff.d.ts

@@ -1,11 +1,10 @@
+export type DiffKey = 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds';
 /**
  * Compute the diff between two dates in the provided key
  *
- * @param val_a - Date to diff against
- * @param val_b - Date to diff with
- * @param key - (default='millisecond') Key to diff in
- *
- * @returns Numerical diff between two dates
+ * @param {Date} val_a - Date to diff against
+ * @param {Date} val_b - Date to diff with
+ * @param {DiffKey} key - (default='millisecond') Key to diff in
  */
-declare function diff(val_a: Date, val_b: Date, key?: 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds'): number;
+declare function diff(val_a: Date, val_b: Date, key?: DiffKey): number;
 export { diff, diff as default };

package/date/endOfUTC.d.ts

@@ -1,10 +1,9 @@
+export type EndOfUTCKey = 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
 /**
  * Sets the provided date to end of UTC of provided key
  *
- * @param val - Date to set to end of
- * @param key - (default='millisecond') Key to set
- *
- * @returns New date set to end of key
+ * @param {Date} val - Date to set to end of
+ * @param {EndOfUTCKey} key - (default='millisecond') Key to set
  */
-declare function endOfUTC(val: Date, key?: 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'): Date;
+declare function endOfUTC(val: Date, key?: EndOfUTCKey): Date;
 export { endOfUTC, endOfUTC as default };

package/date/format.d.ts

@@ -1,3 +1,9 @@
+declare const WEEK_STARTS: {
+    readonly mon: "mon";
+    readonly sun: "sun";
+    readonly sat: "sat";
+};
+export type WEEK_START = keyof typeof WEEK_STARTS;
 /**
  * Formats the provided date according to a specific spec
  *
@@ -5,8 +11,16 @@
  * @param {string} spec - Spec to format the date to
  * @param {string} locale - Locale to format the date in (only used in certain tokens such as dddd and MMMM)
  * @param {string} zone - (default=current timezone) Pass the timezone to convert into. If not passed no conversion will happen
- * @returns {string} Formatted date as string
+ * @param {string} sow - (default='mon') Start of week (only useful when working with the 'W' and 'w' tokens for week numbers
  * @throws {TypeError} When provided invalid payload
  */
-declare function format(val: Date, spec: string, locale?: string, zone?: string): string;
+declare function format(val: Date, spec: string, locale?: string, zone?: string, sow?: WEEK_START): string;
+declare namespace format {
+    var getLocale: () => string;
+    var setLocale: (locale: string) => void;
+    var getZone: () => string;
+    var setZone: (zone: string) => void;
+    var getStartOfWeek: () => "mon" | "sun" | "sat";
+    var setStartOfWeek: (sow: WEEK_START) => void;
+}
 export { format, format as default };

package/date/format.js

@@ -3,8 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 exports.default = format;
 const is_1 = require("./is");
-const DEFAULT_LOCALE = 'en-US';
+const WEEK_STARTS = {
+    mon: 'mon',
+    sun: 'sun',
+    sat: 'sat',
+};
+let DEFAULT_LOCALE = 'en-US';
 let DEFAULT_TZ = 'UTC';
+let DEFAULT_SOW = 'mon';
 try {
     DEFAULT_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone;
 }
@@ -14,37 +20,61 @@ finally {
     if (typeof DEFAULT_TZ !== 'string')
         DEFAULT_TZ = 'UTC';
 }
-const escape_rgx = /\[[\s\S]+?]/g;
-const intl_formatters = new Map();
-const spec_cache = new Map();
-const zone_offset_cache = new Map();
-function DOY(d) {
-    return ((d - new Date(d.getFullYear(), 0, 0)) / 86400000) | 0;
+const ESCAPE_RGX = /\[[\s\S]+?]/g;
+const intl_formatters = Object.create(null);
+const spec_cache = Object.create(null);
+const zone_offset_cache = Object.create(null);
+function WeekNr(d, sow) {
+    const date = new Date(d.valueOf());
+    switch (sow) {
+        case 'sun':
+        case 'sat': {
+            const OFFSET = sow === 'sat' ? 1 : 0;
+            const jan1 = new Date(Date.UTC(date.getUTCFullYear(), 0, 1));
+            const near = new Date(date.getTime() - (((date.getDay() + OFFSET) % 7) * 86400000));
+            const first = new Date(jan1.getTime() - (((jan1.getDay() + OFFSET) % 7) * 86400000));
+            return 1 + Math.floor((near.valueOf() - first.valueOf()) / 604800000);
+        }
+        default: {
+            date.setDate(date.getDate() - ((d.getDay() + 6) % 7) + 3);
+            const date_thu = date.valueOf();
+            date.setMonth(0, 1);
+            if (date.getDay() !== 4)
+                date.setMonth(0, (1 + ((4 - date.getDay()) + 7)) % 7);
+            return 1 + Math.ceil((date_thu - date.valueOf()) / 604800000);
+        }
+    }
 }
-function toZone(date, zone) {
-    const ckey = `${zone}:${date.getUTCFullYear()}${DOY(date)}`;
-    if (zone_offset_cache.has(ckey))
-        return new Date(date.getTime() + zone_offset_cache.get(ckey));
-    const client_time = date.getTime();
-    let zone_time = false;
+function toZone(d, zone) {
+    const year = d.getUTCFullYear();
+    const month = d.getUTCMonth();
+    const day = d.getUTCDate();
+    const time = d.getTime();
+    const daysInMonths = [31, (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    let doy = day;
+    for (let i = 0; i <= month; i++)
+        doy += daysInMonths[i];
+    const ckey = zone + ':' + year + ':' + doy;
+    if (zone_offset_cache[ckey] !== undefined)
+        return new Date(time + zone_offset_cache[ckey]);
+    let zone_time = null;
     try {
-        zone_time = new Date(date.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime();
+        zone_time = new Date(d.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime();
     }
     catch (err) {
-    }
-    if (!Number.isInteger(zone_time))
         throw new Error(`format: Invalid zone passed - ${zone}`);
-    const offset = zone_time - client_time;
-    zone_offset_cache.set(ckey, offset);
-    return new Date(client_time + offset);
+    }
+    const offset = zone_time - time;
+    zone_offset_cache[ckey] = offset;
+    return new Date(time + offset);
 }
 function runIntl(loc, token, props, val) {
-    const hash = `${loc}:${token}`;
-    let formatter = intl_formatters.get(hash);
+    const hash = loc + ':' + token;
+    let formatter = intl_formatters[hash];
     if (!formatter) {
         try {
             formatter = new Intl.DateTimeFormat(loc, props);
-            intl_formatters.set(hash, formatter);
+            intl_formatters[hash] = formatter;
         }
         catch (err) {
             throw new Error(`format: Failed to run conversion for ${token} with locale ${loc}`);
@@ -57,21 +87,51 @@ const Tokens = [
     ['Q', d => ((d.getMonth() + 3) / 3) | 0],
     ['MMMM', (d, loc) => runIntl(loc, 'MMMM', { month: 'long' }, d)],
     ['MMM', (d, loc) => runIntl(loc, 'MMM', { month: 'short' }, d)],
-    ['MM', d => `${d.getMonth() + 1}`.padStart(2, '0')],
+    ['MM', d => {
+            const val = d.getMonth() + 1;
+            return (val < 10 ? '0' : '') + val;
+        }],
     ['M', d => d.getMonth() + 1],
-    ['DD', d => `${d.getDate()}`.padStart(2, '0')],
+    ['WW', (d, loc, sow) => {
+            const val = WeekNr(d, sow);
+            return (val < 10 ? '0' : '') + val;
+        }],
+    ['W', (d, loc, sow) => WeekNr(d, sow)],
+    ['DD', d => {
+            const val = d.getDate();
+            return (val < 10 ? '0' : '') + val;
+        }],
     ['D', d => d.getDate()],
     ['dddd', (d, loc) => runIntl(loc, 'dddd', { weekday: 'long' }, d)],
     ['ddd', (d, loc) => runIntl(loc, 'ddd', { weekday: 'short' }, d)],
-    ['HH', d => `${d.getHours()}`.padStart(2, '0')],
+    ['HH', d => {
+            const val = d.getHours();
+            return (val < 10 ? '0' : '') + val;
+        }],
     ['H', d => d.getHours()],
-    ['hh', d => `${((d.getHours() + 11) % 12) + 1}`.padStart(2, '0')],
+    ['hh', d => {
+            const val = ((d.getHours() + 11) % 12) + 1;
+            return (val < 10 ? '0' : '') + val;
+        }],
     ['h', d => ((d.getHours() + 11) % 12) + 1],
-    ['mm', d => `${d.getMinutes()}`.padStart(2, '0')],
+    ['mm', d => {
+            const val = d.getMinutes();
+            return (val < 10 ? '0' : '') + val;
+        }],
     ['m', d => d.getMinutes()],
-    ['ss', d => `${d.getSeconds()}`.padStart(2, '0')],
+    ['ss', d => {
+            const val = d.getSeconds();
+            return (val < 10 ? '0' : '') + val;
+        }],
     ['s', d => d.getSeconds()],
-    ['SSS', d => `${d.getMilliseconds()}`.padStart(3, '0')],
+    ['SSS', d => {
+            const val = d.getMilliseconds();
+            return val < 10
+                ? '00' + val
+                : val < 100
+                    ? '0' + val
+                    : val;
+        }],
     ['A', d => d.getHours() < 12 ? 'AM' : 'PM'],
     ['a', d => d.getHours() < 12 ? 'am' : 'pm'],
     ['l', (d, loc) => runIntl(loc, 'l', { dateStyle: 'short' }, d)],
@@ -79,58 +139,100 @@ const Tokens = [
     ['t', (d, loc) => runIntl(loc, 't', { timeStyle: 'short' }, d)],
     ['T', (d, loc) => runIntl(loc, 'T', { timeStyle: 'medium' }, d)],
 ]
-    .sort((a, b) => a[0].length > b[0].length ? -1 : 1)
-    .map((el) => [el[0], new RegExp(el[0], 'g'), el[1]]);
+    .map(el => [el[0], el[1], el[0].length])
+    .sort((a, b) => a[0].length > b[0].length ? -1 : 1);
 function getSpecChain(spec) {
-    let spec_chain = spec_cache.get(spec);
-    if (spec_chain)
-        return spec_chain;
-    spec_chain = [];
-    let cursor;
-    let spec_cursor = spec;
+    if (spec_cache[spec] !== undefined)
+        return spec_cache[spec];
+    let base = spec;
+    const repl = [];
+    let repl_len = 0;
+    if (base.indexOf('[') >= 0) {
+        base = base.replace(ESCAPE_RGX, match => {
+            const escape_token = '$R' + repl_len++ + '$';
+            repl.push([escape_token, match.slice(1, -1)]);
+            return escape_token;
+        });
+    }
+    const chain = [];
+    const matched_positions = new Set();
     for (let i = 0; i < Tokens.length; i++) {
-        cursor = Tokens[i];
-        if (spec_cursor.indexOf(cursor[0]) < 0)
-            continue;
-        spec_chain.push(cursor);
-        spec_cursor = spec_cursor.replace(cursor[1], '');
+        const [token] = Tokens[i];
+        let pos = base.indexOf(token);
+        const token_len = token.length;
+        while (pos !== -1) {
+            if (!matched_positions.has(pos)) {
+                chain.push(Tokens[i]);
+                for (let j = 0; j < token_len; j++) {
+                    matched_positions.add(pos + j);
+                }
+            }
+            pos = base.indexOf(token, pos + 1);
+        }
     }
-    if (spec_chain.length === 0)
-        return false;
-    spec_cache.set(spec, spec_chain);
-    return spec_chain;
+    const chain_len = chain.length;
+    const result = chain_len ? { base, chain, chain_len, repl, repl_len } : null;
+    spec_cache[spec] = result;
+    return result;
 }
-function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ) {
+function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ, sow = DEFAULT_SOW) {
     if (!(0, is_1.isDate)(val))
         throw new TypeError('format: val must be a Date');
-    if (typeof spec !== 'string' || !spec.trim().length)
-        throw new TypeError('format: spec must be a non-empty string');
-    if (typeof locale !== 'string' || !locale.trim().length)
-        throw new TypeError('format: locale must be a non-empty string');
-    if (typeof zone !== 'string' || !zone.trim().length)
-        throw new TypeError('format: zone must be a non-empty string');
-    let formatted_string = spec;
-    const escaped_acc = [];
-    if (formatted_string.indexOf('[') >= 0) {
-        formatted_string = formatted_string.replace(escape_rgx, match => {
-            const escape_token = `$R${escaped_acc.length}$`;
-            escaped_acc.push([escape_token, match.replace('[', '').replace(']', '')]);
-            return escape_token;
-        });
-    }
-    const spec_chain = getSpecChain(formatted_string);
-    if (!spec_chain)
+    if (typeof spec !== 'string')
+        throw new TypeError('format: spec must be a string');
+    if (typeof locale !== 'string')
+        throw new TypeError('format: locale must be a string');
+    if (typeof zone !== 'string')
+        throw new TypeError('format: zone must be a string');
+    const n_spec = getSpecChain(spec);
+    if (!n_spec)
         return val.toISOString();
     const d = toZone(val, zone);
-    for (let i = 0; i < spec_chain.length; i++) {
-        const el = spec_chain[i];
-        formatted_string = formatted_string.replace(el[1], el[2](d, locale));
-    }
-    if (escaped_acc.length) {
-        for (let i = 0; i < escaped_acc.length; i++) {
-            const escape_token = escaped_acc[i];
-            formatted_string = formatted_string.replace(escape_token[0], escape_token[1]);
+    let base = n_spec.base;
+    const { chain_len, chain, repl_len, repl } = n_spec;
+    for (let i = 0; i < chain_len; i++) {
+        let pos = base.indexOf(chain[i][0]);
+        const formatted_val = chain[i][1](d, locale, sow);
+        while (pos !== -1) {
+            base = base.slice(0, pos) +
+                formatted_val +
+                base.slice(pos + chain[i][2]);
+            pos = base.indexOf(chain[i][0], pos + chain[i][2]);
         }
     }
-    return formatted_string;
+    for (let i = 0; i < repl_len; i++) {
+        base = base.replace(repl[i][0], repl[i][1]);
+    }
+    return base;
 }
+format.getLocale = function () {
+    return DEFAULT_LOCALE;
+};
+format.setLocale = function (locale) {
+    if (typeof locale !== 'string' || !locale.trim().length)
+        throw new Error('format/setLocale: locale should be a string');
+    DEFAULT_LOCALE = locale.trim();
+};
+format.getZone = function () {
+    return DEFAULT_TZ;
+};
+format.setZone = function (zone) {
+    if (typeof zone !== 'string')
+        throw new Error('format/setZone: zone should be a string');
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: zone });
+        DEFAULT_TZ = zone;
+    }
+    catch {
+        throw new Error(`format/setZone: '${zone}' is not a valid zone`);
+    }
+};
+format.getStartOfWeek = function () {
+    return DEFAULT_SOW;
+};
+format.setStartOfWeek = function (sow) {
+    if (typeof sow !== 'string' ||
+        !Object.values(WEEK_STARTS).includes(sow))
+        throw new Error('format/setStartOfWeek: sow should be a valid start of week');
+    DEFAULT_SOW = sow;
+};

package/date/index.d.ts

@@ -2,11 +2,13 @@ import { addUTC } from './addUTC';
 import { diff } from './diff';
 import { endOfUTC } from './endOfUTC';
 import { format } from './format';
+import { isDateFormat } from './isFormat';
 import { isDate } from './is';
+import { isLeap } from './isLeap';
 import { nowUnix } from './nowUnix';
 import { nowUnixMs } from './nowUnixMs';
 import { setTimeUTC } from './setTimeUTC';
 import { startOfUTC } from './startOfUTC';
 import { toUnix } from './toUnix';
 import { toUTC } from './toUTC';
-export { addUTC, diff, endOfUTC, format, isDate, isDate as is, nowUnix, nowUnixMs, setTimeUTC, startOfUTC, toUnix, toUTC };
+export { addUTC, diff, endOfUTC, format, isDateFormat as isFormat, isDateFormat, isDate, isDate as is, isLeap, nowUnix, nowUnixMs, setTimeUTC, startOfUTC, toUnix, toUTC };

package/date/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toUTC = exports.toUnix = exports.startOfUTC = exports.setTimeUTC = exports.nowUnixMs = exports.nowUnix = exports.is = exports.isDate = exports.format = exports.endOfUTC = exports.diff = exports.addUTC = void 0;
+exports.toUTC = exports.toUnix = exports.startOfUTC = exports.setTimeUTC = exports.nowUnixMs = exports.nowUnix = exports.isLeap = exports.is = exports.isDate = exports.isDateFormat = exports.isFormat = exports.format = exports.endOfUTC = exports.diff = exports.addUTC = void 0;
 const addUTC_1 = require("./addUTC");
 Object.defineProperty(exports, "addUTC", { enumerable: true, get: function () { return addUTC_1.addUTC; } });
 const diff_1 = require("./diff");
@@ -9,9 +9,14 @@ const endOfUTC_1 = require("./endOfUTC");
 Object.defineProperty(exports, "endOfUTC", { enumerable: true, get: function () { return endOfUTC_1.endOfUTC; } });
 const format_1 = require("./format");
 Object.defineProperty(exports, "format", { enumerable: true, get: function () { return format_1.format; } });
+const isFormat_1 = require("./isFormat");
+Object.defineProperty(exports, "isFormat", { enumerable: true, get: function () { return isFormat_1.isDateFormat; } });
+Object.defineProperty(exports, "isDateFormat", { enumerable: true, get: function () { return isFormat_1.isDateFormat; } });
 const is_1 = require("./is");
 Object.defineProperty(exports, "isDate", { enumerable: true, get: function () { return is_1.isDate; } });
 Object.defineProperty(exports, "is", { enumerable: true, get: function () { return is_1.isDate; } });
+const isLeap_1 = require("./isLeap");
+Object.defineProperty(exports, "isLeap", { enumerable: true, get: function () { return isLeap_1.isLeap; } });
 const nowUnix_1 = require("./nowUnix");
 Object.defineProperty(exports, "nowUnix", { enumerable: true, get: function () { return nowUnix_1.nowUnix; } });
 const nowUnixMs_1 = require("./nowUnixMs");

package/date/is.d.ts

@@ -1,9 +1,7 @@
 /**
  * Check whether or not a provided value is a Date
  *
- * @param val - Value to verify
- *
- * @returns Whether or not the value is a Date
+ * @param {unknown} val - Value to verify
  */
 declare function isDate(val: unknown): val is Date;
 export { isDate, isDate as default };

package/date/isFormat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks if a given string is in a particular format
+ * Eg:
+ *  isDateFormat('2024-02-09', 'YYYY-MM-DD'); // true
+ *  isDateFormat('2024-02-09T14:30', 'YYYY-MM-DD'); // false
+ *
+ * @param {unknown} input - String to format (eg: '2024-08-01')
+ * @param {string} spec - Spec to validate (Eg: 'YYYY-MM-DD')
+ */
+declare function isDateFormat(input: unknown, spec: string): input is string;
+export { isDateFormat, isDateFormat as default };