@valkyriestudios/utils 12.20.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,28 +20,53 @@ finally {
     if (typeof DEFAULT_TZ !== 'string')
         DEFAULT_TZ = 'UTC';
 }
-const escape_rgx = /\[[\s\S]+?]/g;
+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 DOY(d) {
-    return ((d - new Date(d.getFullYear(), 0, 0)) / 86400000) | 0;
+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)}`;
+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(date.getTime() + zone_offset_cache[ckey]);
-    const client_time = date.getTime();
+        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) {
         throw new Error(`format: Invalid zone passed - ${zone}`);
     }
-    const offset = zone_time - client_time;
+    const offset = zone_time - time;
     zone_offset_cache[ckey] = offset;
-    return new Date(client_time + offset);
+    return new Date(time + offset);
 }
 function runIntl(loc, token, props, val) {
     const hash = loc + ':' + token;
@@ -61,6 +92,11 @@ const Tokens = [
             return (val < 10 ? '0' : '') + val;
         }],
     ['M', d => d.getMonth() + 1],
+    ['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;
@@ -103,31 +139,43 @@ const Tokens = [
     ['t', (d, loc) => runIntl(loc, 't', { timeStyle: 'short' }, d)],
     ['T', (d, loc) => runIntl(loc, 'T', { timeStyle: 'medium' }, d)],
 ]
+    .map(el => [el[0], el[1], el[0].length])
     .sort((a, b) => a[0].length > b[0].length ? -1 : 1);
 function getSpecChain(spec) {
     if (spec_cache[spec] !== undefined)
         return spec_cache[spec];
-    const spec_chain = [];
+    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++) {
         const [token] = Tokens[i];
-        let pos = spec.indexOf(token);
+        let pos = base.indexOf(token);
         const token_len = token.length;
         while (pos !== -1) {
             if (!matched_positions.has(pos)) {
-                spec_chain.push(Tokens[i]);
+                chain.push(Tokens[i]);
                 for (let j = 0; j < token_len; j++) {
                     matched_positions.add(pos + j);
                 }
             }
-            pos = spec.indexOf(token, pos + 1);
+            pos = base.indexOf(token, pos + 1);
         }
     }
-    const result = spec_chain.length ? spec_chain : null;
+    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')
@@ -136,35 +184,55 @@ function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ) {
         throw new TypeError('format: locale must be a string');
     if (typeof zone !== 'string')
         throw new TypeError('format: zone must be a string');
-    let formatted_string = spec;
-    const escaped_acc = [];
-    let escaped_count = 0;
-    if (formatted_string.indexOf('[') >= 0) {
-        formatted_string = formatted_string.replace(escape_rgx, match => {
-            const escape_token = '$R' + escaped_count++ + '$';
-            escaped_acc.push([escape_token, match.slice(1, -1)]);
-            return escape_token;
-        });
-    }
-    const spec_chain = getSpecChain(formatted_string);
-    if (!spec_chain)
+    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 [token, formatter] = spec_chain[i];
-        let pos = formatted_string.indexOf(token);
+    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) {
-            formatted_string = formatted_string.slice(0, pos) +
-                formatter(d, locale) +
-                formatted_string.slice(pos + token.length);
-            pos = formatted_string.indexOf(token, pos + token.length);
+            base = base.slice(0, pos) +
+                formatted_val +
+                base.slice(pos + chain[i][2]);
+            pos = base.indexOf(chain[i][0], pos + chain[i][2]);
         }
     }
-    if (escaped_count) {
-        for (let i = 0; i < escaped_count; i++) {
-            const escape_token = escaped_acc[i];
-            formatted_string = formatted_string.replace(escape_token[0], escape_token[1]);
-        }
+    for (let i = 0; i < repl_len; i++) {
+        base = base.replace(repl[i][0], repl[i][1]);
     }
-    return formatted_string;
+    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

@@ -4,10 +4,11 @@ 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, isDateFormat as isFormat, isDateFormat, 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.isDateFormat = exports.isFormat = 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");
@@ -15,6 +15,8 @@ Object.defineProperty(exports, "isDateFormat", { enumerable: true, get: function
 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

@@ -6,7 +6,6 @@
  *
  * @param {unknown} input - String to format (eg: '2024-08-01')
  * @param {string} spec - Spec to validate (Eg: 'YYYY-MM-DD')
- * @returns {boolean} Whether or not the input is valid according to the spec
  */
 declare function isDateFormat(input: unknown, spec: string): input is string;
 export { isDateFormat, isDateFormat as default };

package/date/isLeap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check whether or not a provided value is a leap year
+ *
+ * @param {Date} val - Value to verify
+ */
+declare function isLeap(val: Date): boolean;
+export { isLeap, isLeap as default };

package/date/isLeap.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLeap = isLeap;
+exports.default = isLeap;
+const is_1 = require("./is");
+function isLeap(val) {
+    if (!(0, is_1.isDate)(val))
+        return false;
+    const year = val.getUTCFullYear();
+    return (((year % 4) === 0) && ((year % 100) !== 0)) || ((year % 400) === 0);
+}

package/date/nowUnix.d.ts

@@ -1,7 +1,5 @@
 /**
  * Compute the current unix timestamp in seconds
- *
- * @returns Current unix timestamp in seconds
  */
 declare function nowUnix(): number;
 export { nowUnix, nowUnix as default };

package/date/nowUnixMs.d.ts

@@ -1,7 +1,5 @@
 /**
  * Compute the current unix timestamp in milliseconds
- *
- * @returns Current unix timestamp in milliseconds
  */
 declare function nowUnixMs(): number;
 export { nowUnixMs, nowUnixMs as default };

package/date/setTimeUTC.d.ts

@@ -8,8 +8,7 @@ export type TimeProps = {
  * Sets the time on a provided date object and returns it
  *
  * @param {Date} val - Date to set the time for
- * @param {Time} props - Time props to set the time to
- * @returns {Date} New date with provided amount of key added
+ * @param {TimeProps} props - Time props to set the time to
  */
 declare function setTimeUTC(val: Date, props: TimeProps): Date;
 export { setTimeUTC, setTimeUTC as default };

package/date/startOfUTC.d.ts

@@ -1,10 +1,9 @@
+export type StartOfUTCKey = '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 start of UTC of provided key
  *
- * @param val - Date to set to start of
- * @param key - (default='millisecond') Key to set
- *
- * @returns New date set to start of key
+ * @param {Date} val - Date to set to start of
+ * @param {StartOfUTCKey} key - (default='millisecond') Key to set
  */
-declare function startOfUTC(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 startOfUTC(val: Date, key?: StartOfUTCKey): Date;
 export { startOfUTC, startOfUTC as default };

package/date/toUTC.d.ts

@@ -1,9 +1,7 @@
 /**
  * Sets a passed date to UTC
  *
- * @param val - Date to set to UTC
- *
- * @returns New date object set to the UTC contents of the passed date
+ * @param {Date} val - Date to set to UTC
  */
 declare function toUTC(val: Date): Date;
 export { toUTC, toUTC as default };

package/date/toUnix.d.ts

@@ -1,9 +1,7 @@
 /**
  * Returns the unix time in seconds of the passed date
  *
- * @param val - Date to get the unix time for
- *
- * @returns Unix time in seconds
+ * @param {Date} val - Date to get the unix time for
  */
 declare function toUnix(val: Date): number;
 export { toUnix, toUnix as default };

package/deep/freeze.d.ts

@@ -9,9 +9,7 @@ type Frozen<T> = {
 /**
  * Recursively freezes all properties of an object
  *
- * @param obj - Object to deep freeze
- *
- * @returns Deeply frozen object
+ * @param {deepInput} obj - Object to deep freeze
  */
 declare function deepFreeze<T extends deepInput>(obj: T): Frozen<T>;
 export { deepFreeze, deepFreeze as default };

package/deep/get.d.ts

@@ -1,3 +1,8 @@
+type ObjectType = {
+    [key: string]: any;
+};
+type ArrayType = any[];
+type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
 /**
  * Get a property's value deep inside the structure of an array/object
  *
@@ -16,14 +21,7 @@
  * @param val - Object/Array to get the value from
  * @param path - Path string to deeply get the value at
  * @param get_parent - If passed as true retrieves the parent of where the value lives
- *
- * @returns Value stored at property or undefined
  * @throws {TypeError}
  */
-type ObjectType = {
-    [key: string]: any;
-};
-type ArrayType = any[];
-type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
 declare function deepGet<T extends ObjectType | ArrayType, P extends string>(obj: T, path: P, get_parent?: boolean): DeepGetResult<T, P> | undefined;
 export { deepGet, deepGet as default };

package/deep/seal.d.ts

@@ -9,9 +9,7 @@ type Sealed<T> = {
 /**
  * Recursively seals all properties of an object
  *
- * @param obj - Object to deep seal
- *
- * @returns Deeply sealed object
+ * @param {deepInput} obj - Object to deep seal
  */
 declare function deepSeal<T extends deepInput>(obj: T): Sealed<T>;
 export { deepSeal, deepSeal as default };

package/deep/set.d.ts

@@ -31,7 +31,6 @@
  * @param path - Path string to deeply set the value at
  * @param value - Value to set (if using defineProperty can be an accessor object)
  * @param define - Whether or not the property should be directly assigned or set using Object.defineProperty
- *
  * @returns True or false depending on whether or not the property was set correctly
  * @throws {TypeError}
  */