@wistia/utils 0.0.0-stage → 0.17.0

package/dist/index.mjs

@@ -0,0 +1,1833 @@
+
+/*
+ * @license @wistia/utils v0.17.0
+ *
+ * Copyright (c) 2023-2026, Wistia, Inc. and its affiliates.
+ *
+ * This source code is unlicensed, all rights reserved.
+ */
+
+//#region src/guards/isNull.ts
+/**
+* Checks if the provided value is null.
+*
+* @param value - The value to check.
+* @returns True if the value is null, false otherwise.
+*
+* @example
+* isNull(null);      // true
+* isNull(undefined); // false
+*
+* @category Primitives
+*/
+const isNull = (value) => value === null;
+//#endregion
+//#region src/guards/isUndefined.ts
+/**
+* Checks if the provided value is undefined.
+*
+* @param value - The value to check.
+* @returns True if the value is undefined, false otherwise.
+*
+* @example
+* isUndefined(undefined); // true
+* isUndefined(null);      // false
+*
+* @category Primitives
+*/
+const isUndefined = (value) => value === void 0;
+//#endregion
+//#region src/guards/isNil.ts
+/**
+* Checks if the provided value is null or undefined.
+*
+* @param value - The value to check.
+* @returns True if the value is null or undefined, false otherwise.
+*
+* @example
+* isNil(null); // true
+* isNil(0);    // false
+*
+* @category Primitives
+*/
+const isNil = (value) => isNull(value) || isUndefined(value);
+//#endregion
+//#region src/guards/isNotNil.ts
+/**
+* Checks if the provided value is neither null nor undefined.
+*
+* @param value - The value to check.
+* @returns True if the value is not null or undefined, false otherwise.
+*
+* @remarks
+* Common in `.filter(isNotNil)` to drop `null`/`undefined` from arrays
+* with narrowing.
+*
+* @example
+* isNotNil(0);    // true
+* isNotNil(null); // false
+*
+* const items: (string | null)[] = ['a', null, 'b'];
+* const clean: string[] = items.filter(isNotNil); // ['a', 'b']
+*
+* @category Negated
+*/
+const isNotNil = (value) => !isNil(value);
+//#endregion
+//#region src/guards/isRecord.ts
+/**
+* Checks if the provided value is a non-null object that is not an array.
+*
+* @param value - The value to check.
+* @returns True if the value is an object (but not an array), false otherwise.
+*
+* @example
+* isRecord({}); // true
+* isRecord([]); // false
+*
+* @category Records
+*/
+const isRecord = (value) => isNotNil(value) && typeof value === "object" && !Array.isArray(value);
+//#endregion
+//#region src/guards/isNonEmptyRecord.ts
+/**
+* Checks if the provided value is an object with at least one own property.
+*
+* @param value - The value to check.
+* @returns True if the value is a non-empty object, false otherwise.
+*
+* @example
+* isNonEmptyRecord({ a: 1 }); // true
+* isNonEmptyRecord({});       // false
+*
+* @category Records
+*/
+const isNonEmptyRecord = (value) => isRecord(value) && Object.keys(value).length > 0;
+//#endregion
+//#region src/guards/hasKey.ts
+/**
+* Curried function that tests if an input is an object
+* _and_ that a key that was passed in is a property of that object.
+*
+* @param value - The input object to test.
+* @param key - The key to test if it is a property of the input record.
+* @returns A function that takes an unknown input and then tests if the
+* input is an object and whether the key is a property of that object or not.
+*
+* @example
+* hasKey({ a: 1 }, 'a'); // true
+* hasKey({ a: 1 }, 'b'); // false
+*
+* @category Records
+*/
+const hasKey = (value, key) => isNonEmptyRecord(value) && key in value;
+//#endregion
+//#region src/guards/isArray.ts
+/**
+* Checks if the provided value is an array.
+*
+* @param value - The value to check.
+* @returns True if the value is an array, false otherwise.
+*
+* @example
+* isArray([1, 2]); // true
+* isArray('abc');  // false
+*
+* @category Arrays
+*/
+const isArray = (value) => isNotNil(value) && typeof value === "object" && Array.isArray(value);
+//#endregion
+//#region src/guards/isFunction.ts
+/**
+* Checks if the provided value is a function.
+*
+* @param value - The value to check.
+* @returns True if the value is a function, false otherwise.
+*
+* @example
+* isFunction(() => {}); // true
+* isFunction({});       // false
+*
+* @category Primitives
+*/
+const isFunction = (value) => isNotNil(value) && typeof value === "function";
+//#endregion
+//#region src/guards/isAsyncFunction.ts
+/**
+* Checks if the provided value is an async function.
+*
+* @param value - The value to check.
+* @returns True if the value is an async function, false otherwise.
+*
+* @remarks
+* Detection relies on `constructor.name === 'AsyncFunction'` and is a
+* heuristic: async functions transpiled to regular functions return false,
+* async generator functions return false, and a forged `constructor`
+* property can fool the check. Bound async functions return true, since
+* `bind` preserves the prototype chain. Synchronous functions that return
+* promises also return false.
+*
+* @example
+* isAsyncFunction(async () => {}); // true
+* isAsyncFunction(() => {});       // false
+*
+* @category Primitives
+*/
+const isAsyncFunction = (value) => {
+	return isFunction(value) && value.constructor?.name === "AsyncFunction";
+};
+//#endregion
+//#region src/guards/isBigInt.ts
+/**
+* Checks if the provided value is a bigint.
+*
+* @param value - The value to check.
+* @returns True if the value is a bigint, false otherwise.
+*
+* @example
+* isBigInt(10n); // true
+* isBigInt(10);  // false
+*
+* @category Primitives
+*/
+const isBigInt = (value) => typeof value === "bigint";
+//#endregion
+//#region src/guards/isBoolean.ts
+/**
+* Checks if the provided value is a boolean.
+*
+* @param value - The value to check.
+* @returns True if the value is a boolean, false otherwise.
+*
+* @example
+* isBoolean(true); // true
+* isBoolean(1);    // false
+*
+* @category Primitives
+*/
+const isBoolean = (value) => isNotNil(value) && typeof value === "boolean";
+//#endregion
+//#region src/guards/isDate.ts
+/**
+* Checks if the provided value is an instance of Date.
+*
+* @param value - The value to check.
+* @returns True if the value is a Date instance, false otherwise.
+*
+* @remarks
+* Matches `Date` instances only. Does not parse date strings or
+* accept numeric timestamps.
+*
+* @example
+* isDate(new Date());   // true
+* isDate('2024-01-01'); // false
+*
+* @category Primitives
+*/
+const isDate = (value) => {
+	return isNotNil(value) && value instanceof Date;
+};
+//#endregion
+//#region src/guards/isEmptyArray.ts
+/**
+* Checks if the provided value is an empty array.
+*
+* @param value - The value to check.
+* @returns True if the value is an empty array, false otherwise.
+*
+* @example
+* isEmptyArray([]);  // true
+* isEmptyArray([1]); // false
+*
+* @category Arrays
+*/
+const isEmptyArray = (value) => isArray(value) && value.length === 0;
+//#endregion
+//#region src/guards/isEmptyRecord.ts
+/**
+* Checks if the provided value is an object with no own properties.
+*
+* @param value - The value to check.
+* @returns True if the value is an empty object, false otherwise.
+*
+* @example
+* isEmptyRecord({});       // true
+* isEmptyRecord({ a: 1 }); // false
+*
+* @category Records
+*/
+const isEmptyRecord = (value) => isRecord(value) && Object.keys(value).length === 0;
+//#endregion
+//#region src/guards/isString.ts
+/**
+* Checks if the provided value is a string.
+*
+* @param value - The value to check.
+* @returns True if the value is a string, false otherwise.
+*
+* @example
+* isString('hi'); // true
+* isString(42);   // false
+*
+* @category Primitives
+*/
+const isString = (value) => typeof value === "string";
+//#endregion
+//#region src/guards/isEmptyString.ts
+/**
+* Checks if the provided value is an empty string.
+*
+* @param value - The value to check.
+* @returns True if the value is an empty string, false otherwise.
+*
+* @example
+* isEmptyString('');  // true
+* isEmptyString('a'); // false
+*
+* @category Strings
+*/
+const isEmptyString = (value) => isString(value) && value === "";
+//#endregion
+//#region src/guards/isError.ts
+/**
+* Checks if the provided value is an instance of Error.
+*
+* @param value - The value to check.
+* @returns True if the value is an Error instance, false otherwise.
+*
+* @remarks
+* Matches subclasses of `Error` too (e.g. `TypeError`, custom errors).
+*
+* @example
+* isError(new Error('boom')); // true
+* isError('boom');            // false
+*
+* @category Primitives
+*/
+const isError = (value) => {
+	return isNotNil(value) && value instanceof Error;
+};
+//#endregion
+//#region src/guards/_falsyValues.ts
+const FALSY_VALUES = [
+	false,
+	0,
+	-0,
+	0n,
+	"",
+	null,
+	void 0,
+	NaN
+];
+//#endregion
+//#region src/guards/isFalsy.ts
+/**
+* Checks if the provided value is falsy.
+*
+* @param value - The value to check.
+* @returns True if the value is falsy, false otherwise.
+*
+* @remarks
+* Returns true for `false`, `0`, `-0`, `0n`, `''`, `null`, `undefined`,
+* and `NaN`.
+*
+* @example
+* isFalsy(0); // true
+* isFalsy(1); // false
+*
+* @category Truthy / falsy
+*/
+const isFalsy = (value) => FALSY_VALUES.includes(value) || Number.isNaN(value);
+//#endregion
+//#region src/guards/isNumber.ts
+/**
+* Checks if the provided value is a number.
+*
+* @param value - The value to check.
+* @returns True if the value is a number, false otherwise.
+*
+* @remarks
+* `NaN` is a `number`, so `isNumber(NaN)` is true. Use `isInteger` or
+* combine with `!isNaN(value)` if you need a finite number.
+*
+* @example
+* isNumber(1);   // true
+* isNumber('1'); // false
+*
+* @category Primitives
+*/
+const isNumber = (value) => typeof value === "number";
+//#endregion
+//#region src/guards/isFiniteNumber.ts
+/**
+* Checks if the provided value is a finite number.
+*
+* @param value - The value to check.
+* @returns True if the value is a finite number, false otherwise.
+*
+* @example
+* isFiniteNumber(42);       // true
+* isFiniteNumber(Infinity); // false
+*
+* @category Primitives
+*/
+const isFiniteNumber = (value) => isNumber(value) && Number.isFinite(value);
+//#endregion
+//#region src/guards/isHtmlButtonElement.ts
+/**
+* Checks if the provided value is an HTMLButtonElement.
+*
+* @param value - The value to check.
+* @returns True if the value is an HTMLButtonElement, false otherwise.
+*
+* @example
+* isHtmlButtonElement(document.createElement('button')); // true
+* isHtmlButtonElement(document.createElement('div'));    // false
+*
+* @category DOM
+*/
+const isHtmlButtonElement = (value) => value instanceof HTMLButtonElement;
+//#endregion
+//#region src/guards/isHtmlElement.ts
+/**
+* Checks if the provided value is an HTMLElement.
+*
+* @param value - The value to check.
+* @returns True if the value is an HTMLElement, false otherwise.
+*
+* @example
+* isHtmlElement(document.body); // true
+* isHtmlElement('div');         // false
+*
+* @category DOM
+*/
+const isHtmlElement = (value) => value instanceof HTMLElement;
+//#endregion
+//#region src/guards/isHtmlInputElement.ts
+/**
+* Checks if the provided value is an HTMLInputElement.
+*
+* @param value - The value to check.
+* @returns True if the value is an HTMLInputElement, false otherwise.
+*
+* @example
+* isHtmlInputElement(document.createElement('input')); // true
+* isHtmlInputElement(document.createElement('div'));   // false
+*
+* @category DOM
+*/
+const isHtmlInputElement = (value) => value instanceof HTMLInputElement;
+//#endregion
+//#region src/guards/isHtmlVideoElement.ts
+/**
+* Checks if the provided value is an HTMLVideoElement.
+*
+* @param value - The value to check.
+* @returns True if the value is an HTMLVideoElement, false otherwise.
+*
+* @example
+* isHtmlVideoElement(document.createElement('video')); // true
+* isHtmlVideoElement(document.createElement('div'));   // false
+*
+* @category DOM
+*/
+const isHtmlVideoElement = (value) => value instanceof HTMLVideoElement;
+//#endregion
+//#region src/guards/isInteger.ts
+/**
+* Checks if the provided value is an integer.
+*
+* @param value - The value to check.
+* @returns True if the value is an integer, false otherwise.
+*
+* @remarks
+* Uses `Number.isInteger`, so non-finite values (`NaN`, `Infinity`)
+* return false.
+*
+* @example
+* isInteger(5);   // true
+* isInteger(5.5); // false
+*
+* @category Primitives
+*/
+const isInteger = (value) => Number.isInteger(value);
+//#endregion
+//#region src/guards/isIterable.ts
+/**
+* Checks if the provided value implements the iterable protocol.
+*
+* @param value - The value to check.
+* @returns True if the value is iterable, false otherwise.
+*
+* @remarks
+* Strings are iterable and return true. Plain objects without
+* `Symbol.iterator` return false.
+*
+* @example
+* isIterable([1, 2, 3]); // true
+* isIterable({});        // false
+*
+* @category Primitives
+*/
+const isIterable = (value) => {
+	if (!isNotNil(value)) return false;
+	return typeof value[Symbol.iterator] === "function";
+};
+//#endregion
+//#region src/guards/isMap.ts
+/**
+* Checks if the provided value is an instance of Map.
+*
+* @param value - The value to check.
+* @returns True if the value is a Map instance, false otherwise.
+*
+* @remarks
+* WeakMap instances return false.
+*
+* @example
+* isMap(new Map()); // true
+* isMap({});        // false
+*
+* @category Primitives
+*/
+const isMap = (value) => {
+	return isNotNil(value) && value instanceof Map;
+};
+//#endregion
+//#region src/guards/isMouseEvent.ts
+/**
+* Checks if the provided value is a MouseEvent.
+*
+* @param value - The value to check.
+* @returns True if the value is a MouseEvent, false otherwise.
+*
+* @example
+* isMouseEvent(new MouseEvent('click')); // true
+* isMouseEvent(new Event('change'));     // false
+*
+* @category DOM
+*/
+const isMouseEvent = (value) => value instanceof MouseEvent;
+//#endregion
+//#region src/guards/isNaN.ts
+/**
+* Checks if the provided value is NaN (Not a Number).
+*
+* @param value - The value to check.
+* @returns True if the value is NaN, false otherwise.
+*
+* @remarks
+* Uses `Number.isNaN` (not the coercive global `isNaN`), so only the
+* literal `NaN` value returns true.
+*
+* @example
+* isNaN(Number.NaN); // true
+* isNaN(0);          // false
+*
+* @category Primitives
+*/
+const isNaN = (value) => Number.isNaN(value);
+//#endregion
+//#region src/guards/isNonBlankString.ts
+/**
+* Checks if the provided value is a non-blank string (not empty and not whitespace-only).
+* Use {@link isNonEmptyString} when whitespace-only strings are acceptable (e.g. preserving
+* intentional formatting).
+*
+* @param value - The value to check.
+* @returns True if the value is a string with at least one non-whitespace character, false otherwise.
+*
+* @example
+* isNonBlankString('a');   // true
+* isNonBlankString('   '); // false
+*
+* @category Strings
+*/
+const isNonBlankString = (value) => isString(value) && value.trim() !== "";
+//#endregion
+//#region src/guards/isNonEmptyArray.ts
+/**
+* Checks if the provided value is a non-empty array.
+*
+* @param value - The value to check. Can be null or undefined.
+* @returns True if the value is a non-empty array, false otherwise.
+*
+* @example
+* isNonEmptyArray([1]); // true
+* isNonEmptyArray([]);  // false
+*
+* @category Arrays
+*/
+const isNonEmptyArray = (value) => isArray(value) && value.length > 0;
+//#endregion
+//#region src/guards/isNonEmptyString.ts
+/**
+* Checks if the provided value is a non-empty string. Whitespace-only strings like `"   "` pass.
+* Use {@link isNonBlankString} when whitespace-only strings should be rejected (e.g. user input
+* validation).
+*
+* @param value - The value to check.
+* @returns True if the value is a non-empty string, false otherwise.
+*
+* @example
+* isNonEmptyString('a'); // true
+* isNonEmptyString('');  // false
+*
+* @category Strings
+*/
+const isNonEmptyString = (value) => isString(value) && !isEmptyString(value);
+//#endregion
+//#region src/guards/isNonNaNNumber.ts
+/**
+* Checks if the provided value is a number that is not NaN.
+*
+* @param value - The value to check.
+* @returns True if the value is a number and not NaN, false otherwise.
+*
+* @example
+* isNonNaNNumber(42);         // true
+* isNonNaNNumber(Number.NaN); // false
+*
+* @category Primitives
+*/
+const isNonNaNNumber = (value) => isNumber(value) && !isNaN(value);
+//#endregion
+//#region src/guards/isNotArray.ts
+/**
+* Checks if the provided value is not an array.
+*
+* @param value - The value to check.
+* @returns True if the value is not an array, false otherwise.
+*
+* @example
+* isNotArray('x'); // true
+* isNotArray([]);  // false
+*
+* @category Negated
+*/
+const isNotArray = (value) => !isArray(value);
+//#endregion
+//#region src/guards/isNotBoolean.ts
+/**
+* Checks if the provided value is not a boolean.
+*
+* @param value - The value to check.
+* @returns True if the value is not a boolean, false otherwise.
+*
+* @example
+* isNotBoolean(1);    // true
+* isNotBoolean(true); // false
+*
+* @category Negated
+*/
+const isNotBoolean = (value) => !isBoolean(value);
+//#endregion
+//#region src/guards/isNotFunction.ts
+/**
+* Checks if the provided value is not a function.
+*
+* @param value - The value to check.
+* @returns True if the value is not a function, false otherwise.
+*
+* @example
+* isNotFunction(1);        // true
+* isNotFunction(() => {}); // false
+*
+* @category Negated
+*/
+const isNotFunction = (value) => !isFunction(value);
+//#endregion
+//#region src/guards/isNotNull.ts
+/**
+* Checks if the provided value is not null.
+*
+* @param value - The value to check.
+* @returns True if the value is not null, false otherwise.
+*
+* @example
+* isNotNull(undefined); // true
+* isNotNull(null);      // false
+*
+* @category Negated
+*/
+const isNotNull = (value) => !isNull(value);
+//#endregion
+//#region src/guards/isNotNumber.ts
+/**
+* Checks if the provided value is not a number.
+*
+* @param value - The value to check.
+* @returns True if the value is not a number, false otherwise.
+*
+* @example
+* isNotNumber('1'); // true
+* isNotNumber(1);   // false
+*
+* @category Negated
+*/
+const isNotNumber = (value) => !isNumber(value);
+//#endregion
+//#region src/guards/isNotRecord.ts
+/**
+* Checks if the provided value is not an object.
+*
+* @param value - The value to check.
+* @returns True if the value is not a record (object), false otherwise.
+*
+* @example
+* isNotRecord([]); // true
+* isNotRecord({}); // false
+*
+* @category Negated
+*/
+const isNotRecord = (value) => !isRecord(value);
+//#endregion
+//#region src/guards/isNotString.ts
+/**
+* Checks if the provided value is not a string.
+*
+* @param value - The value to check.
+* @returns True if the value is not a string, false otherwise.
+*
+* @example
+* isNotString(1);   // true
+* isNotString('a'); // false
+*
+* @category Negated
+*/
+const isNotString = (value) => !isString(value);
+//#endregion
+//#region src/guards/isNotUndefined.ts
+/**
+* Checks if the provided value is not undefined.
+*
+* @param value - The value to check.
+* @returns True if the value is not undefined, false otherwise.
+*
+* @example
+* isNotUndefined(null);      // true
+* isNotUndefined(undefined); // false
+*
+* @category Negated
+*/
+const isNotUndefined = (value) => !isUndefined(value);
+//#endregion
+//#region src/guards/isVoid.ts
+/**
+* Checks if the provided value is void.
+*
+* @param value - The value to check.
+* @returns True if the value is void (undefined), false otherwise.
+*
+* @example
+* isVoid(undefined); // true
+* isVoid(0);         // false
+*
+* @category Primitives
+*/
+const isVoid = (value) => value === void 0;
+//#endregion
+//#region src/guards/isNotVoid.ts
+/**
+* Checks if the provided value is not void.
+*
+* @param value - The value to check.
+* @returns True if the value is not void (defined), false otherwise.
+*
+* @example
+* isNotVoid(0);         // true
+* isNotVoid(undefined); // false
+*
+* @category Negated
+*/
+const isNotVoid = (value) => !isVoid(value);
+//#endregion
+//#region src/guards/isPlainObject.ts
+/**
+* Checks if the provided value is a plain object created with `{}` or `Object.create(null)`.
+* Returns false for arrays, `Date`, `Map`, `RegExp`, boxed primitives, and class instances.
+*
+* @param value - The value to check.
+* @returns True if the value is a plain object, false otherwise.
+*
+* @example
+* isPlainObject({});         // true
+* isPlainObject(new Date()); // false
+*
+* @category Records
+*/
+const isPlainObject = (value) => {
+	if (isNil(value) || typeof value !== "object") return false;
+	if (isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+//#endregion
+//#region src/guards/isPromise.ts
+/**
+* Checks if the provided value is a Promise, including promise-like objects
+* that implement `then`, `catch`, and `finally`.
+*
+* @param value - The value to check.
+* @returns True if the value is a Promise or promise-like object, false otherwise.
+*
+* @remarks
+* The full `Promise` method surface is required so the narrowed type is
+* accurate: `then`, `catch`, and `finally` must all be functions. Thenables
+* that only implement a subset are rejected.
+*
+* @example
+* isPromise(Promise.resolve()); // true
+* isPromise({ then: () => 1 }); // false
+*
+* @category Primitives
+*/
+const isPromise = (value) => {
+	if (!isNotNil(value)) return false;
+	const candidate = value;
+	return typeof candidate.then === "function" && typeof candidate.catch === "function" && typeof candidate.finally === "function";
+};
+//#endregion
+//#region src/guards/isRegExp.ts
+/**
+* Checks if the provided value is an instance of RegExp.
+*
+* @param value - The value to check.
+* @returns True if the value is a RegExp instance, false otherwise.
+*
+* @example
+* isRegExp(/abc/);   // true
+* isRegExp('/abc/'); // false
+*
+* @category Primitives
+*/
+const isRegExp = (value) => {
+	return isNotNil(value) && value instanceof RegExp;
+};
+//#endregion
+//#region src/guards/isSet.ts
+/**
+* Checks if the provided value is an instance of Set.
+*
+* @param value - The value to check.
+* @returns True if the value is a Set instance, false otherwise.
+*
+* @remarks
+* WeakSet instances return false.
+*
+* @example
+* isSet(new Set()); // true
+* isSet([]);        // false
+*
+* @category Primitives
+*/
+const isSet = (value) => {
+	return isNotNil(value) && value instanceof Set;
+};
+//#endregion
+//#region src/guards/isSvgElement.ts
+/**
+* Checks if the provided value is an SVGElement.
+*
+* @param value - The value to check.
+* @returns True if the value is an SVGElement, false otherwise.
+*
+* @example
+* isSvgElement(document.createElementNS('http://www.w3.org/2000/svg', 'svg')); // true
+* isSvgElement(document.createElement('div'));                                // false
+*
+* @category DOM
+*/
+const isSvgElement = (value) => value instanceof SVGElement;
+//#endregion
+//#region src/guards/isSymbol.ts
+/**
+* Checks if the provided value is a symbol.
+*
+* @param value - The value to check.
+* @returns True if the value is a symbol, false otherwise.
+*
+* @example
+* isSymbol(Symbol('a')); // true
+* isSymbol('symbol');    // false
+*
+* @category Primitives
+*/
+const isSymbol = (value) => typeof value === "symbol";
+//#endregion
+//#region src/guards/isTextNode.ts
+/**
+* Checks if the provided value is a Text node.
+*
+* @param value - The value to check.
+* @returns True if the value is a Text node, false otherwise.
+*
+* @example
+* isTextNode(document.createTextNode('hi')); // true
+* isTextNode(document.createElement('div')); // false
+*
+* @category DOM
+*/
+const isTextNode = (value) => value.nodeName === "#text";
+//#endregion
+//#region src/guards/isTruthy.ts
+/**
+* Checks if the provided value is truthy.
+*
+* @param value - The value to check.
+* @returns True if the value is truthy, false otherwise.
+*
+* @remarks
+* The complement of `isFalsy`. Does not provide narrowing on its own;
+* use `isNotNil` or a specific positive guard when narrowing matters.
+*
+* @example
+* isTruthy(1); // true
+* isTruthy(0); // false
+*
+* @category Truthy / falsy
+*/
+const isTruthy = (value) => !FALSY_VALUES.includes(value) && !Number.isNaN(value);
+//#endregion
+//#region src/guards/isWeakMap.ts
+/**
+* Checks if the provided value is an instance of WeakMap.
+*
+* @param value - The value to check.
+* @returns True if the value is a WeakMap instance, false otherwise.
+*
+* @remarks
+* Map instances return false. Narrows to `WeakMap<WeakKey, unknown>`, since
+* weak collections accept non-registered symbols as keys (ES2023).
+*
+* @example
+* isWeakMap(new WeakMap()); // true
+* isWeakMap(new Map());     // false
+*
+* @category Primitives
+*/
+const isWeakMap = (value) => {
+	return isNotNil(value) && value instanceof WeakMap;
+};
+//#endregion
+//#region src/guards/isWeakSet.ts
+/**
+* Checks if the provided value is an instance of WeakSet.
+*
+* @param value - The value to check.
+* @returns True if the value is a WeakSet instance, false otherwise.
+*
+* @remarks
+* Set instances return false. Narrows to `WeakSet<WeakKey>`, since weak
+* collections accept non-registered symbols as members (ES2023).
+*
+* @example
+* isWeakSet(new WeakSet()); // true
+* isWeakSet(new Set());     // false
+*
+* @category Primitives
+*/
+const isWeakSet = (value) => {
+	return isNotNil(value) && value instanceof WeakSet;
+};
+//#endregion
+//#region src/guards/readonlyArrayIncludes.ts
+/**
+* Checks if a readonly array includes the given element, with type narrowing.
+*
+* @param arr - The readonly array to search.
+* @param elem - The element to search for.
+* @returns True if the array includes the element, false otherwise.
+*
+* @example
+* const arr = ['a', 'b'] as const;
+* readonlyArrayIncludes(arr, 'a'); // true
+* readonlyArrayIncludes(arr, 'z'); // false
+*
+* @category Arrays
+*/
+const readonlyArrayIncludes = (arr, elem) => arr.includes(elem);
+//#endregion
+//#region src/utilities/asyncNoOpFn.ts
+/**
+* An async function that does nothing. Useful as a default or placeholder
+* callback where a promise is expected.
+*
+* @returns A promise that resolves to `undefined`.
+*
+* @example
+* await asyncNoOpFn(); // undefined
+*/
+const asyncNoOpFn = async () => {};
+//#endregion
+//#region src/utilities/_constants.ts
+const defaultLocales = ["en-US"];
+const defaultTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+const milisecondsInSecond = 1e3;
+const millisecondsInDay = 86400 * milisecondsInSecond;
+//#endregion
+//#region src/utilities/buildTimeDuration.ts
+/**
+* Returns an object representing a duration in seconds, minutes and hours.
+*
+* @param numberOfMilliseconds - The duration in milliseconds.
+* @returns The duration split into hours, minutes and seconds.
+*
+* @example
+* buildTimeDuration(3723000); // { hours: 1, minutes: 2, seconds: 3 }
+*/
+const buildTimeDuration = (numberOfMilliseconds) => {
+	const numberOfSeconds = Math.floor(numberOfMilliseconds / milisecondsInSecond);
+	const numberOfMinutes = Math.floor(numberOfSeconds / 60);
+	const numberOfHours = Math.floor(numberOfMinutes / 60);
+	return {
+		seconds: numberOfSeconds - numberOfMinutes * 60,
+		minutes: numberOfMinutes - numberOfHours * 60,
+		hours: numberOfHours
+	};
+};
+//#endregion
+//#region src/utilities/coerceToBoolean.ts
+/**
+* Converts the boolean string values 'true' and 'false' into the
+* corresponding boolean. Any other value is coerced with `Boolean()`.
+*
+* @param value - The value to coerce.
+* @returns The value as a boolean.
+*
+* @example
+* coerceToBoolean('true');  // true
+* coerceToBoolean('false'); // false
+* coerceToBoolean(0);       // false
+*/
+const coerceToBoolean = (value) => {
+	if (value === "true" || value === "false") return value === "true";
+	return Boolean(value);
+};
+//#endregion
+//#region src/utilities/_isInvalidDate.ts
+/**
+* Checks whether a value is not a usable Date. Note that the Unix epoch
+* (getTime() === 0) is treated as invalid.
+*
+* @param date - The value to check.
+* @returns True if the value is not a Date, is an invalid Date, or is the Unix epoch.
+*/
+const isInvalidDate = (date) => {
+	if (!isDate(date)) return true;
+	const time = date.getTime();
+	return time === 0 || Number.isNaN(time);
+};
+//#endregion
+//#region src/utilities/dateOnlyISOString.ts
+/**
+* Converts a Date object into a date only string formatted to ISO 8601,
+* e.g. '2021-06-03'.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* dateOnlyISOString(new Date(2011, 11, 15)); // '2011-12-15'
+*/
+const dateOnlyISOString = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	try {
+		const partsAsObject = new Intl.DateTimeFormat(defaultLocales, {
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			timeZone
+		}).formatToParts(date).reduce((map, obj) => {
+			map[obj.type] = obj.value;
+			return map;
+		}, {});
+		return `${partsAsObject.year}-${partsAsObject.month}-${partsAsObject.day}`;
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/dateOnlyString.ts
+/**
+* Converts a Date object into a date only string, e.g. 'Jun 3, 2021',
+* or 'Jun 3' if omitYear is true. Formats with the en-US locale.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @param options.omitYear - If true, display the date without the year.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* dateOnlyString(new Date(2011, 11, 15)); // 'Dec 15, 2011'
+*/
+const dateOnlyString = (date, { timeZone = defaultTimeZone, omitYear = false } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	const formatOptions = omitYear ? {
+		month: "short",
+		day: "numeric",
+		timeZone
+	} : {
+		dateStyle: "medium",
+		timeZone
+	};
+	try {
+		return new Intl.DateTimeFormat(defaultLocales, formatOptions).format(date);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/dateOnlyStringForSentence.ts
+/**
+* Converts a Date object into a date only string for use in a sentence,
+* e.g. 'June 3, 2021'. Formats with the en-US locale.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* dateOnlyStringForSentence(new Date(2011, 11, 15)); // 'December 15, 2011'
+*/
+const dateOnlyStringForSentence = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	try {
+		return new Intl.DateTimeFormat(defaultLocales, {
+			dateStyle: "long",
+			timeZone
+		}).format(date);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/dateOnlyStringNumeric.ts
+/**
+* Converts a Date object into a date only string formatted numerically,
+* e.g. '06/03/2021'. Formats with the en-US locale.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* dateOnlyStringNumeric(new Date(2011, 11, 15)); // '12/15/2011'
+*/
+const dateOnlyStringNumeric = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	try {
+		return new Intl.DateTimeFormat(defaultLocales, {
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			timeZone
+		}).format(date);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/dateTimeToDate.ts
+/**
+* Converts a plain object of date and time parts into a Date object.
+*
+* @param dateTime - The date parts to convert.
+* @returns The converted Date, or null if year, month, or dayOfMonth is missing.
+*
+* @example
+* dateTimeToDate({ year: 2015, month: 10, dayOfMonth: 7, hours: 4, minutes: 15 });
+* // new Date(2015, 10, 7, 4, 15)
+*/
+const dateTimeToDate = (dateTime) => {
+	const { year, month, dayOfMonth, hours, minutes } = dateTime ?? {};
+	if (year !== void 0 && month !== void 0 && dayOfMonth !== void 0) return new Date(year, month, dayOfMonth, hours ?? 0, minutes ?? 0);
+	return null;
+};
+//#endregion
+//#region src/utilities/dateTimeToISO.ts
+/**
+* Converts a plain object of date and time parts into an ISO-8601 string.
+*
+* @param dateTime - The date parts to convert.
+* @returns The ISO-8601 string, or null if year, month, or dayOfMonth is missing.
+*
+* @example
+* dateTimeToISO({ year: 2015, month: 10, dayOfMonth: 7, hours: 4, minutes: 15 });
+* // '2015-11-07T04:15:00.000Z' (in UTC)
+*/
+const dateTimeToISO = (dateTime) => dateTimeToDate(dateTime)?.toISOString() ?? null;
+//#endregion
+//#region src/utilities/dateToDateTime.ts
+/**
+* Converts a Date object into a plain object of its local date and time parts.
+*
+* @param date - The Date object to convert.
+* @returns The date parts, or null if the value is not a Date.
+*
+* @example
+* dateToDateTime(new Date(2011, 11, 15, 3, 10));
+* // { year: 2011, month: 11, dayOfMonth: 15, hours: 3, minutes: 10 }
+*/
+const dateToDateTime = (date) => {
+	if (!isDate(date)) return null;
+	return {
+		year: date.getFullYear(),
+		month: date.getMonth(),
+		dayOfMonth: date.getDate(),
+		hours: date.getHours(),
+		minutes: date.getMinutes()
+	};
+};
+//#endregion
+//#region src/utilities/dateTimeRounded.ts
+/**
+* Rounds a Date up to the next half hour boundary.
+*
+* @param dateTime - The Date to round.
+* @param toISOString - Whether to return an ISO-8601 string instead of a Date.
+* @returns The rounded value as a string or Date depending on toISOString.
+*
+* @example
+* dateTimeRounded(new Date(2015, 10, 7, 0, 10));        // '2015-11-07T00:30:00.000Z' (in UTC)
+* dateTimeRounded(new Date(2015, 10, 7, 0, 40), false); // new Date(2015, 10, 7, 1, 0)
+*/
+const dateTimeRounded = (dateTime, toISOString = true) => {
+	const first30Min = dateTime.getMinutes() <= 30;
+	const hours = first30Min ? dateTime.getHours() : dateTime.getHours() + 1;
+	const minutes = first30Min ? 30 : 0;
+	const dateWithTime = {
+		...dateToDateTime(dateTime),
+		hours,
+		minutes
+	};
+	if (toISOString) return dateTimeToISO(dateWithTime);
+	return dateTimeToDate(dateWithTime);
+};
+//#endregion
+//#region src/utilities/dateTimeString.ts
+/**
+* Converts a Date, timestamp, or date string into a date and time string,
+* e.g. 'Jun 3, 2021, 11:52 AM'. Formats with the en-US locale.
+*
+* NOTE: you should probably use timeAgoString when trying to display
+* an updated/created timestamp.
+*
+* @param date - The Date, timestamp, or date string to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @param options.omitYear - If true, display the date without the year.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* dateTimeString(new Date(2011, 11, 15, 7, 30)); // 'Dec 15, 2011, 7:30 AM'
+*/
+const dateTimeString = (date, { timeZone = defaultTimeZone, omitYear = false } = {}) => {
+	if (isNil(date)) return "";
+	const formattedDate = new Date(date);
+	if (isInvalidDate(formattedDate)) return "";
+	try {
+		const baseOptions = {
+			month: "short",
+			day: "numeric",
+			hour: "numeric",
+			minute: "2-digit",
+			timeZone
+		};
+		const options = omitYear ? baseOptions : {
+			...baseOptions,
+			year: "numeric"
+		};
+		return formattedDate.toLocaleDateString(defaultLocales, options);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/dateTimeStringForSentence.ts
+/**
+* Converts a Date object into a date and time string for use in a sentence,
+* e.g. 'June 3, 2021, 11:52 AM'. Formats with the en-US locale.
+*
+* NOTE: you should probably use timeAgoString when trying to display
+* an updated/created timestamp.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* dateTimeStringForSentence(new Date(2011, 11, 15, 7, 30)); // 'December 15, 2011, 7:30 AM'
+*/
+const dateTimeStringForSentence = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	try {
+		const { year, month, day, hour, minute, dayPeriod } = new Intl.DateTimeFormat(defaultLocales, {
+			month: "long",
+			day: "numeric",
+			year: "numeric",
+			hour: "numeric",
+			minute: "2-digit",
+			timeZone
+		}).formatToParts(date).reduce((acc, part) => {
+			if (part.type !== "literal") acc[part.type] = part.value;
+			return acc;
+		}, {});
+		return `${month} ${day}, ${year}, ${hour}:${minute} ${dayPeriod}`;
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/dateUTCOffset.ts
+/**
+* Given a date, shows the UTC offset of the current time zone, e.g. '+02:00'.
+*
+* @param date - The Date to calculate the offset for.
+* @returns The UTC offset string.
+*
+* @example
+* dateUTCOffset(new Date(2011, 11, 15)); // '+00:00' (when run in UTC)
+*/
+const dateUTCOffset = (date) => {
+	const offsetInHours = date.getTimezoneOffset() / 60 * -1;
+	const hours = Math.round(offsetInHours);
+	const minutes = (offsetInHours - hours) * 60;
+	return `${hours >= 0 ? "+" : ""}${`${hours}`.padStart(2, "0")}:${`${minutes}`.padStart(2, "0")}`;
+};
+//#endregion
+//#region src/utilities/dayOfWeekString.ts
+/**
+* Converts a Date object into a day of the week string, e.g. 'Thursday'.
+* Formats with the en-US locale.
+*
+* @param date - The Date to format.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @returns The formatted day of the week, or '' for null or invalid input.
+*
+* @example
+* dayOfWeekString(new Date(2011, 11, 15)); // 'Thursday'
+*/
+const dayOfWeekString = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (date === null) return "";
+	try {
+		return new Intl.DateTimeFormat(defaultLocales, {
+			weekday: "long",
+			timeZone
+		}).format(date);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/deepMerge.ts
+const UNSAFE_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const cloneIfArray = (value) => isArray(value) ? [...value] : value;
+/**
+* Deeply merges objects without mutating them, inferring the return type from
+* the inputs. Plain objects are merged recursively, arrays are concatenated
+* with duplicate items removed (by reference for object items), and all other
+* values (including class instances) are overwritten in the order of the
+* provided arguments. The prototype-polluting keys `__proto__`, `constructor`,
+* and `prototype` are dropped. Symbol-keyed properties are not merged.
+*
+* @param objects - The objects to merge.
+* @returns A new object containing the merged result.
+* @throws TypeError when an argument is an array.
+*
+* @example
+* deepMerge({ a: { b: 1 }, c: [1] }, { a: { d: 2 }, c: [2] });
+* // { a: { b: 1, d: 2 }, c: [1, 2] }
+*/
+const deepMerge = (...objects) => {
+	const result = {};
+	for (const current of objects) {
+		if (isArray(current)) throw new TypeError("Arguments provided to deepMerge must be objects, not arrays.");
+		const safeKeys = Object.keys(current).filter((key) => !UNSAFE_KEYS.has(key));
+		for (const key of safeKeys) {
+			const existing = result[key];
+			const incoming = current[key];
+			if (isArray(existing) && isArray(incoming)) result[key] = [.../* @__PURE__ */ new Set([...existing, ...incoming])];
+			else if (isPlainObject(existing) && isPlainObject(incoming)) result[key] = deepMerge(existing, incoming);
+			else if (isPlainObject(incoming)) result[key] = deepMerge(incoming);
+			else result[key] = cloneIfArray(incoming);
+		}
+	}
+	return result;
+};
+//#endregion
+//#region src/utilities/getObjectEntries.ts
+/**
+* Returns the entries of an object with strongly typed keys and values.
+*
+* @param obj - The object to get entries from.
+* @returns An array of [key, value] tuples.
+*
+* @example
+* getObjectEntries({ a: 1, b: 2 }); // [['a', 1], ['b', 2]]
+*/
+const getObjectEntries = (obj) => Object.keys(obj).map((key) => [key, obj[key]]);
+//#endregion
+//#region src/utilities/getObjectKeys.ts
+/**
+* Returns the keys of an object with strongly typed key type.
+*
+* @param obj - The object to get keys from.
+* @returns An array of the object's keys.
+*
+* @example
+* getObjectKeys({ a: 1, b: 2 }); // ['a', 'b']
+*/
+const getObjectKeys = (obj) => Object.keys(obj);
+//#endregion
+//#region src/utilities/getObjectValues.ts
+/**
+* Returns the values of an object with strongly typed value type.
+*
+* @param obj - The object to get values from.
+* @returns An array of the object's values.
+*
+* @example
+* getObjectValues({ a: 1, b: 2 }); // [1, 2]
+*/
+const getObjectValues = (obj) => Object.values(obj);
+//#endregion
+//#region src/utilities/isEmail.ts
+/**
+* Loosely validates an email address string.
+*
+* @param value - The string to validate.
+* @returns True if the string appears to be an email address, false otherwise.
+*
+* @example
+* isEmail('user@example.com'); // true
+* isEmail('user@example');     // false
+*/
+const isEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+//#endregion
+//#region src/utilities/isUrl.ts
+/**
+* Loosely validates a URL string.
+*
+* @param value - The value to validate.
+* @returns True if the value appears to be a URL, false otherwise.
+*
+* @example
+* isUrl('https://wistia.com'); // true
+* isUrl('not a url');          // false
+*/
+const isUrl = (value) => {
+	const protocolAndDomain = /^(?:\w+:)?\/\/(\S+)$/;
+	const localhostDomain = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
+	const nonLocalhostDomain = /^[^\s.]+\.\S{2,}$/;
+	if (!isString(value)) return false;
+	const remaining = protocolAndDomain.exec(value)?.[1];
+	if (remaining === void 0) return false;
+	return localhostDomain.test(remaining) || nonLocalhostDomain.test(remaining);
+};
+//#endregion
+//#region src/utilities/_padTimeInteger.ts
+/**
+* Pads an integer with a leading zero.
+*
+* @param num - The integer to pad.
+* @returns The integer as a string with padding.
+*/
+const padTimeInteger = (num) => num.toString().padStart(2, "0");
+//#endregion
+//#region src/utilities/mediaDurationString.ts
+/**
+* A string representation of a duration for a media. Assumes most medias
+* are under an hour so only shows hours if media is over an hour.
+*
+* @param numberOfMilliseconds - The duration in milliseconds.
+* @returns The formatted duration string.
+*
+* @example
+* mediaDurationString(234230);   // '3:54'
+* mediaDurationString(23423000); // '6:30:23'
+*/
+const mediaDurationString = (numberOfMilliseconds) => {
+	const { hours, minutes, seconds } = buildTimeDuration(numberOfMilliseconds);
+	if (hours < 1) return `${minutes}:${padTimeInteger(seconds)}`;
+	return `${hours}:${padTimeInteger(minutes)}:${padTimeInteger(seconds)}`;
+};
+//#endregion
+//#region src/utilities/millisecondsToDurationISOString.ts
+/**
+* Given a number of milliseconds, returns the ISO 8601 duration string
+* rounded down from the number of seconds.
+*
+* @param numberOfMilliseconds - The duration in milliseconds.
+* @returns The ISO 8601 duration string.
+*
+* @example
+* millisecondsToDurationISOString(33000);   // 'PT33S'
+* millisecondsToDurationISOString(3605000); // 'PT1H5S'
+*/
+const millisecondsToDurationISOString = (numberOfMilliseconds) => {
+	const { seconds, minutes, hours } = buildTimeDuration(numberOfMilliseconds);
+	let string = "PT";
+	if (hours) string += `${hours}H`;
+	if (minutes) string += `${minutes}M`;
+	if (seconds) string += `${seconds}S`;
+	if (!(seconds || minutes || hours)) string += "0S";
+	return string;
+};
+//#endregion
+//#region src/utilities/monthDayStringNumeric.ts
+/**
+* Converts a Date object into a month and day string formatted numerically,
+* e.g. '06/03'. Formats with the en-US locale.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the date in. Defaults to the current time zone.
+* @returns The formatted date string, or '' for invalid input.
+*
+* @example
+* monthDayStringNumeric(new Date(2011, 11, 15)); // '12/15'
+*/
+const monthDayStringNumeric = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	try {
+		return new Intl.DateTimeFormat(defaultLocales, {
+			month: "2-digit",
+			day: "2-digit",
+			timeZone
+		}).format(date);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/noOpFn.ts
+/**
+* A function that does nothing. Useful as a default or placeholder callback.
+*
+* @returns Nothing.
+*
+* @example
+* noOpFn(); // undefined
+*/
+const noOpFn = () => {};
+//#endregion
+//#region src/utilities/noOpFnReturningFalse.ts
+/**
+* A function that does nothing and returns `false`. Useful as a default or
+* placeholder callback where `false` is expected.
+*
+* @returns `false`.
+*
+* @example
+* noOpFnReturningFalse(); // false
+*/
+const noOpFnReturningFalse = () => false;
+//#endregion
+//#region src/utilities/noOpFnReturningNull.ts
+/**
+* A function that does nothing and returns `null`. Useful as a default or
+* placeholder callback where `null` is expected.
+*
+* @returns `null`.
+*
+* @example
+* noOpFnReturningNull(); // null
+*/
+const noOpFnReturningNull = () => null;
+//#endregion
+//#region src/utilities/parseDateString.ts
+const MONTH_NAMES = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+const MONTH_ABBREVIATIONS = MONTH_NAMES.map((name) => name.slice(0, 3));
+const startOfDay = (date) => {
+	const result = new Date(date);
+	result.setHours(0, 0, 0, 0);
+	return result;
+};
+const startOfToday = () => startOfDay(/* @__PURE__ */ new Date());
+const startOfTomorrow = () => {
+	const tomorrow = startOfToday();
+	tomorrow.setDate(tomorrow.getDate() + 1);
+	return tomorrow;
+};
+const monthIndexIn = (names, value) => names.findIndex((name) => name.toLowerCase() === value.toLowerCase());
+const toNumberOrUndefined = (value) => value === void 0 ? void 0 : Number(value);
+const DATE_PATTERNS = [
+	{
+		regex: new RegExp(`^(${MONTH_ABBREVIATIONS.join("|")}) (\\d{1,2})(?:, (\\d{1,4}))?$`, "i"),
+		toParts: ([, month, day, year]) => ({
+			monthIndex: monthIndexIn(MONTH_ABBREVIATIONS, String(month)),
+			day: Number(day),
+			year: toNumberOrUndefined(year)
+		})
+	},
+	{
+		regex: new RegExp(`^(${MONTH_NAMES.join("|")}) (\\d{1,2})(?:, (\\d{1,4}))?$`, "i"),
+		toParts: ([, month, day, year]) => ({
+			monthIndex: monthIndexIn(MONTH_NAMES, String(month)),
+			day: Number(day),
+			year: toNumberOrUndefined(year)
+		})
+	},
+	{
+		regex: /^(\d{1,2})\/(\d{1,2})(?:\/(\d{1,4}))?$/,
+		toParts: ([, month, day, year]) => ({
+			monthIndex: Number(month) - 1,
+			day: Number(day),
+			year: toNumberOrUndefined(year)
+		})
+	},
+	{
+		regex: /^(\d{1,2})-(\d{1,2})(?:-(\d{1,4}))?$/,
+		toParts: ([, month, day, year]) => ({
+			monthIndex: Number(month) - 1,
+			day: Number(day),
+			year: toNumberOrUndefined(year)
+		})
+	},
+	{
+		regex: /^(\d{1,4})-(\d{1,2})-(\d{1,2})$/,
+		toParts: ([, year, month, day]) => ({
+			monthIndex: Number(month) - 1,
+			day: Number(day),
+			year: Number(year)
+		})
+	}
+];
+const toValidDate = ({ monthIndex, day, year }, referenceDate) => {
+	if (year === 0) return null;
+	const resolvedYear = year ?? referenceDate.getFullYear();
+	const date = new Date(referenceDate.getFullYear(), 0, 1);
+	date.setFullYear(resolvedYear, monthIndex, day);
+	return date.getFullYear() === resolvedYear && date.getMonth() === monthIndex && date.getDate() === day ? date : null;
+};
+/**
+* Loosely parses a human-entered date string into a Date at local midnight.
+* Accepts 'today' and 'tomorrow', month name prefixes (resolved to the next
+* 1st of that month), and common numeric and month-name formats, with a
+* native Date fallback for anything else.
+*
+* @param str - The date string to parse.
+* @returns The parsed Date at local midnight, or null if unparseable.
+*
+* @example
+* parseDateString('Jan 5, 2025'); // Date for 2025-01-05 at local midnight
+* parseDateString('garbage');     // null
+*/
+const parseDateString = (str) => {
+	const trimmed = str.trim();
+	if (!trimmed) return null;
+	const lower = trimmed.toLowerCase();
+	if (lower === "today") return startOfToday();
+	if (lower === "tomorrow") return startOfTomorrow();
+	const monthIndex = MONTH_NAMES.findIndex((name) => name.toLowerCase().startsWith(lower));
+	if (monthIndex !== -1) {
+		const today = startOfToday();
+		let date = new Date(today.getFullYear(), monthIndex, 1);
+		if (date.getTime() < Date.now()) date = new Date(today.getFullYear() + 1, monthIndex, 1);
+		return date;
+	}
+	const referenceDate = /* @__PURE__ */ new Date();
+	for (const { regex, toParts } of DATE_PATTERNS) {
+		const match = trimmed.match(regex);
+		if (match) {
+			const parsed = toValidDate(toParts(match), referenceDate);
+			if (parsed !== null) return parsed;
+		}
+	}
+	const native = new Date(trimmed);
+	if (!Number.isNaN(native.getTime())) return startOfDay(native);
+	return null;
+};
+//#endregion
+//#region src/utilities/sessionDurationString.ts
+/**
+* A string representation of a duration for a user session. Assumes that
+* sessions may or may not be more than an hour. To prevent confusion all
+* times show hours, even those that are less than an hour.
+*
+* @param numberOfMilliseconds - The duration in milliseconds.
+* @returns The formatted duration string.
+*
+* @example
+* sessionDurationString(2342300); // '0:39:02'
+*/
+const sessionDurationString = (numberOfMilliseconds) => {
+	const { hours, minutes, seconds } = buildTimeDuration(numberOfMilliseconds);
+	return `${hours}:${padTimeInteger(minutes)}:${padTimeInteger(seconds)}`;
+};
+//#endregion
+//#region src/utilities/stripExtension.ts
+/**
+* Removes the file extension from a string.
+*
+* @param str - The string to remove the file extension from.
+* @returns The string without its file extension.
+*
+* @example
+* stripExtension('config.yml');      // 'config'
+* stripExtension('example.test.ts'); // 'example.test'
+*/
+const stripExtension = (str) => (str || "").replace(/\.[^/.]{1,4}$/, "");
+//#endregion
+//#region src/utilities/_getLocalDateParts.ts
+/**
+* Get local year, month, day parts from a Date using Intl.DateTimeFormat.
+* This ignores the time of day (hours, minutes, etc.).
+*
+* @param date - The Date to extract parts from.
+* @returns The numeric year, month (1-based) and day.
+*/
+const getLocalDateParts = (date) => {
+	const partsAsObject = new Intl.DateTimeFormat(defaultLocales, {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		timeZone: defaultTimeZone
+	}).formatToParts(date).reduce((map, part) => {
+		map[part.type] = part.value;
+		return map;
+	}, {});
+	return {
+		year: Math.trunc(Number(partsAsObject.year)),
+		month: Math.trunc(Number(partsAsObject.month)),
+		day: Math.trunc(Number(partsAsObject.day))
+	};
+};
+//#endregion
+//#region src/utilities/_differenceInCalendarDays.ts
+/**
+* Returns the difference in calendar days between two dates in local time,
+* ignoring the time of day.
+*
+* @param dateLeft - The later date (or timestamp).
+* @param dateRight - The earlier date (or timestamp).
+* @returns The number of calendar days (can be negative).
+*/
+const differenceInCalendarDays = (dateLeft, dateRight) => {
+	const leftDate = isDate(dateLeft) ? dateLeft : new Date(dateLeft);
+	const rightDate = isDate(dateRight) ? dateRight : new Date(dateRight);
+	if (Number.isNaN(leftDate.getTime()) || Number.isNaN(rightDate.getTime())) return NaN;
+	const { year: y1, month: m1, day: d1 } = getLocalDateParts(leftDate);
+	const { year: y2, month: m2, day: d2 } = getLocalDateParts(rightDate);
+	const msDiff = new Date(y1, m1 - 1, d1).getTime() - new Date(y2, m2 - 1, d2).getTime();
+	return Math.round(msDiff / millisecondsInDay);
+};
+//#endregion
+//#region src/utilities/timeAgoString.ts
+/**
+* Shows time ago relative to current time, e.g. '< 1 minute ago',
+* '33 minutes ago', 'Today, 3:30 PM', 'Yesterday, 6:22 AM',
+* 'Nov 11, 11:32 AM', or 'Feb 23, 2020, 1:55 PM'. When includeTime is
+* false: 'Today', 'Yesterday', 'on Thursday', 'Nov 11', 'Feb 23, 2020'.
+*
+* NOTE: timeAgoString doesn't support multiple time zones since doing so
+* would complicate calculations for whether to use "Today" or "Yesterday".
+*
+* @param date - The date relative to now.
+* @param options - Formatting options.
+* @param options.nowAnchor - The date used to calculate relative to now. Defaults to the current date but can be overwritten for tests.
+* @param options.includeTime - Whether to include the time in the output. Defaults to true.
+* @returns The relative date string, or '' for invalid input.
+*
+* @example
+* timeAgoString(new Date(Date.now() - 30_000)); // '< 1 minute ago'
+*/
+const timeAgoString = (date, { nowAnchor = /* @__PURE__ */ new Date(), includeTime = true } = {}) => {
+	if (isInvalidDate(date)) return "";
+	const minutesAgo = (nowAnchor.valueOf() - date.valueOf()) / (60 * milisecondsInSecond);
+	const minutesAgoRounded = Math.round(minutesAgo);
+	const differenceInDays = differenceInCalendarDays(nowAnchor, date);
+	const isSameYear = date.getFullYear() === nowAnchor.getFullYear();
+	if (minutesAgo < 0) return dateTimeString(date);
+	if (minutesAgo < 1) return "< 1 minute ago";
+	if (minutesAgoRounded < 2) return "1 minute ago";
+	if (minutesAgoRounded <= 60) return `${minutesAgoRounded} minutes ago`;
+	if (differenceInDays === 0) return includeTime ? `Today, ${Intl.DateTimeFormat(defaultLocales, {
+		hour: "numeric",
+		minute: "2-digit"
+	}).format(date)}` : "Today";
+	if (differenceInDays === 1) return includeTime ? `Yesterday, ${Intl.DateTimeFormat(defaultLocales, {
+		hour: "numeric",
+		minute: "2-digit"
+	}).format(date)}` : "Yesterday";
+	if (differenceInDays < 7 && !includeTime) return `on ${dayOfWeekString(date)}`;
+	return includeTime ? dateTimeString(date, { omitYear: isSameYear }) : dateOnlyString(date, { omitYear: false });
+};
+//#endregion
+//#region src/utilities/timeOnlyString.ts
+/**
+* Converts a Date object into a time only string, e.g. '7:30 AM'.
+* Formats with the en-US locale.
+*
+* @param date - The Date to format; gracefully handles any value.
+* @param options - Formatting options.
+* @param options.timeZone - The time zone to display the time in. Defaults to the current time zone.
+* @returns The formatted time string, or '' for invalid input.
+*
+* @example
+* timeOnlyString(new Date(2011, 11, 15, 7, 30)); // '7:30 AM'
+*/
+const timeOnlyString = (date, { timeZone = defaultTimeZone } = {}) => {
+	if (!isDate(date) || isInvalidDate(date)) return "";
+	try {
+		return new Intl.DateTimeFormat(defaultLocales, {
+			timeStyle: "short",
+			timeZone
+		}).format(date);
+	} catch (error) {
+		console.error(error);
+		return "";
+	}
+};
+//#endregion
+//#region src/utilities/tupleIncludes.ts
+/**
+* Checks if a tuple includes the given item, with type narrowing.
+*
+* @param tuple - The tuple to search.
+* @param item - The item to search for.
+* @returns True if the tuple includes the item, false otherwise.
+*
+* @example
+* const tuple = ['x', 'y'] as const;
+* tupleIncludes(tuple, 'x'); // true
+* tupleIncludes(tuple, 'z'); // false
+*/
+const tupleIncludes = (tuple, item) => tuple.includes(item);
+//#endregion
+export { asyncNoOpFn, buildTimeDuration, coerceToBoolean, dateOnlyISOString, dateOnlyString, dateOnlyStringForSentence, dateOnlyStringNumeric, dateTimeRounded, dateTimeString, dateTimeStringForSentence, dateTimeToDate, dateTimeToISO, dateToDateTime, dateUTCOffset, dayOfWeekString, deepMerge, getObjectEntries, getObjectKeys, getObjectValues, hasKey, isArray, isAsyncFunction, isBigInt, isBoolean, isDate, isEmail, isEmptyArray, isEmptyRecord, isEmptyString, isError, isFalsy, isFiniteNumber, isFunction, isHtmlButtonElement, isHtmlElement, isHtmlInputElement, isHtmlVideoElement, isInteger, isIterable, isMap, isMouseEvent, isNaN, isNil, isNonBlankString, isNonEmptyArray, isNonEmptyRecord, isNonEmptyString, isNonNaNNumber, isNotArray, isNotBoolean, isNotFunction, isNotNil, isNotNull, isNotNumber, isNotRecord, isNotString, isNotUndefined, isNotVoid, isNull, isNumber, isPlainObject, isPromise, isRecord, isRegExp, isSet, isString, isSvgElement, isSymbol, isTextNode, isTruthy, isUndefined, isUrl, isVoid, isWeakMap, isWeakSet, mediaDurationString, millisecondsToDurationISOString, monthDayStringNumeric, noOpFn, noOpFnReturningFalse, noOpFnReturningNull, parseDateString, readonlyArrayIncludes, sessionDurationString, stripExtension, timeAgoString, timeOnlyString, tupleIncludes };
+
+//# sourceMappingURL=index.mjs.map