complete-common 1.0.0 → 1.1.0

package/dist/functions/utils.d.cts

@@ -0,0 +1,131 @@
+/**
+ * Helper functions that do not belong to any category in particular.
+ *
+ * @module
+ */
+/**
+ * Helper function to get an iterator of integers with the specified range, inclusive on the lower
+ * end and exclusive on the high end. (The "e" in the function name stands for exclusive.) Thus,
+ * this function works in the same way as the built-in `range` function from Python.
+ *
+ * If the end is lower than the start, then an empty range will be returned.
+ *
+ * For example:
+ *
+ * - `eRange(2)` returns `[0, 1]`.
+ * - `eRange(3)` returns `[0, 1, 2]`.
+ * - `eRange(-3)` returns `[0, -1, -2]`.
+ * - `eRange(1, 3)` returns `[1, 2]`.
+ * - `eRange(2, 5)` returns `[2, 3, 4]`.
+ * - `eRange(5, 2)` returns `[]`.
+ * - `eRange(3, 3)` returns `[]`.
+ *
+ * If you want an array instead of an iterator, use the spread operator like this:
+ *
+ * ```ts
+ * const myArray = [...eRange(1, 3)];
+ * ```
+ *
+ * @param start The integer to start at.
+ * @param end Optional. The integer to end at. If not specified, then the start will be 0 and the
+ *            first argument will be the end.
+ * @param increment Optional. The increment to use. Default is 1.
+ */
+export declare function eRange(start: number, end?: number, increment?: number): Generator<number>;
+/**
+ * Helper function to get an array of integers with the specified range, inclusive on both ends.
+ * (The "i" in the function name stands for inclusive.)
+ *
+ * If the end is lower than the start, then an empty range will be returned.
+ *
+ * For example:
+ *
+ * - `iRange(2)` returns `[0, 1, 2]`.
+ * - `iRange(3)` returns `[0, 1, 2, 3]`.
+ * - `iRange(-3)` returns `[0, -1, -2, -3]`.
+ * - `iRange(1, 3)` returns `[1, 2, 3]`.
+ * - `iRange(2, 5)` returns `[2, 3, 4, 5]`.
+ * - `iRange(5, 2)` returns `[]`.
+ * - `iRange(3, 3)` returns `[3]`.
+ *
+ * If you want an array instead of an iterator, use the spread operator like this:
+ *
+ * ```ts
+ * const myArray = [...iRange(1, 3)];
+ * ```
+ *
+ * @param start The integer to start at.
+ * @param end Optional. The integer to end at. If not specified, then the start will be 0 and the
+ *            first argument will be the end.
+ * @param increment Optional. The increment to use. Default is 1.
+ */
+export declare function iRange(start: number, end?: number, increment?: number): Generator<number>;
+/** From: https://stackoverflow.com/questions/61526746 */
+export declare function isKeyOf<T extends object>(key: PropertyKey, target: T): key is keyof T;
+/**
+ * Helper function to perform a no-op. This can be useful in order to make a trailing return valid
+ * in functions that use the early return pattern.
+ */
+export declare function noop(): void;
+/**
+ * This is a more reliable version of `Number.parseFloat`:
+ *
+ * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
+ *   TypeScript type narrowing patterns.
+ * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
+ *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ * - Non-strings will result in undefined instead of being coerced to a number.
+ *
+ * @param string A string to convert to an integer.
+ */
+export declare function parseFloatSafe(string: string): number | undefined;
+/**
+ * This is a more reliable version of `Number.parseInt`:
+ *
+ * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
+ *   TypeScript type narrowing patterns.
+ * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
+ *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ * - Non-strings will result in undefined instead of being coerced to a number.
+ *
+ * If you have to use a radix other than 10, use the vanilla `Number.parseInt` function instead,
+ * because this function ensures that the string contains no letters.
+ */
+export declare function parseIntSafe(string: string): number | undefined;
+/**
+ * Helper function to repeat code N times. This is faster to type and cleaner than using a for loop.
+ *
+ * For example:
+ *
+ * ```ts
+ * repeat(10, () => {
+ *   foo();
+ * });
+ * ```
+ *
+ * The repeated function is passed the index of the iteration, if needed:
+ *
+ * ```ts
+ * repeat(3, (i) => {
+ *   console.log(i); // Prints "0", "1", "2"
+ * });
+ * ```
+ */
+export declare function repeat(num: number, func: (i: number) => void): void;
+/**
+ * Helper function to signify that the enclosing code block is not yet complete. Using this function
+ * is similar to writing a "TODO" comment, but it has the benefit of preventing ESLint errors due to
+ * unused variables or early returns.
+ *
+ * When you see this function, it simply means that the programmer intends to add in more code to
+ * this spot later.
+ *
+ * This function is variadic, meaning that you can pass as many arguments as you want. (This is
+ * useful as a means to prevent unused variables.)
+ *
+ * This function does not actually do anything. (It is an "empty" function.)
+ *
+ * @allowEmptyVariadic
+ */
+export declare function todo(...args: readonly unknown[]): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/functions/utils.d.mts

@@ -0,0 +1,131 @@
+/**
+ * Helper functions that do not belong to any category in particular.
+ *
+ * @module
+ */
+/**
+ * Helper function to get an iterator of integers with the specified range, inclusive on the lower
+ * end and exclusive on the high end. (The "e" in the function name stands for exclusive.) Thus,
+ * this function works in the same way as the built-in `range` function from Python.
+ *
+ * If the end is lower than the start, then an empty range will be returned.
+ *
+ * For example:
+ *
+ * - `eRange(2)` returns `[0, 1]`.
+ * - `eRange(3)` returns `[0, 1, 2]`.
+ * - `eRange(-3)` returns `[0, -1, -2]`.
+ * - `eRange(1, 3)` returns `[1, 2]`.
+ * - `eRange(2, 5)` returns `[2, 3, 4]`.
+ * - `eRange(5, 2)` returns `[]`.
+ * - `eRange(3, 3)` returns `[]`.
+ *
+ * If you want an array instead of an iterator, use the spread operator like this:
+ *
+ * ```ts
+ * const myArray = [...eRange(1, 3)];
+ * ```
+ *
+ * @param start The integer to start at.
+ * @param end Optional. The integer to end at. If not specified, then the start will be 0 and the
+ *            first argument will be the end.
+ * @param increment Optional. The increment to use. Default is 1.
+ */
+export declare function eRange(start: number, end?: number, increment?: number): Generator<number>;
+/**
+ * Helper function to get an array of integers with the specified range, inclusive on both ends.
+ * (The "i" in the function name stands for inclusive.)
+ *
+ * If the end is lower than the start, then an empty range will be returned.
+ *
+ * For example:
+ *
+ * - `iRange(2)` returns `[0, 1, 2]`.
+ * - `iRange(3)` returns `[0, 1, 2, 3]`.
+ * - `iRange(-3)` returns `[0, -1, -2, -3]`.
+ * - `iRange(1, 3)` returns `[1, 2, 3]`.
+ * - `iRange(2, 5)` returns `[2, 3, 4, 5]`.
+ * - `iRange(5, 2)` returns `[]`.
+ * - `iRange(3, 3)` returns `[3]`.
+ *
+ * If you want an array instead of an iterator, use the spread operator like this:
+ *
+ * ```ts
+ * const myArray = [...iRange(1, 3)];
+ * ```
+ *
+ * @param start The integer to start at.
+ * @param end Optional. The integer to end at. If not specified, then the start will be 0 and the
+ *            first argument will be the end.
+ * @param increment Optional. The increment to use. Default is 1.
+ */
+export declare function iRange(start: number, end?: number, increment?: number): Generator<number>;
+/** From: https://stackoverflow.com/questions/61526746 */
+export declare function isKeyOf<T extends object>(key: PropertyKey, target: T): key is keyof T;
+/**
+ * Helper function to perform a no-op. This can be useful in order to make a trailing return valid
+ * in functions that use the early return pattern.
+ */
+export declare function noop(): void;
+/**
+ * This is a more reliable version of `Number.parseFloat`:
+ *
+ * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
+ *   TypeScript type narrowing patterns.
+ * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
+ *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ * - Non-strings will result in undefined instead of being coerced to a number.
+ *
+ * @param string A string to convert to an integer.
+ */
+export declare function parseFloatSafe(string: string): number | undefined;
+/**
+ * This is a more reliable version of `Number.parseInt`:
+ *
+ * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
+ *   TypeScript type narrowing patterns.
+ * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
+ *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ * - Non-strings will result in undefined instead of being coerced to a number.
+ *
+ * If you have to use a radix other than 10, use the vanilla `Number.parseInt` function instead,
+ * because this function ensures that the string contains no letters.
+ */
+export declare function parseIntSafe(string: string): number | undefined;
+/**
+ * Helper function to repeat code N times. This is faster to type and cleaner than using a for loop.
+ *
+ * For example:
+ *
+ * ```ts
+ * repeat(10, () => {
+ *   foo();
+ * });
+ * ```
+ *
+ * The repeated function is passed the index of the iteration, if needed:
+ *
+ * ```ts
+ * repeat(3, (i) => {
+ *   console.log(i); // Prints "0", "1", "2"
+ * });
+ * ```
+ */
+export declare function repeat(num: number, func: (i: number) => void): void;
+/**
+ * Helper function to signify that the enclosing code block is not yet complete. Using this function
+ * is similar to writing a "TODO" comment, but it has the benefit of preventing ESLint errors due to
+ * unused variables or early returns.
+ *
+ * When you see this function, it simply means that the programmer intends to add in more code to
+ * this spot later.
+ *
+ * This function is variadic, meaning that you can pass as many arguments as you want. (This is
+ * useful as a means to prevent unused variables.)
+ *
+ * This function does not actually do anything. (It is an "empty" function.)
+ *
+ * @allowEmptyVariadic
+ */
+export declare function todo(...args: readonly unknown[]): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/functions/utils.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Helper functions that do not belong to any category in particular.
+ *
+ * @module
+ */
+/**
+ * Helper function to get an iterator of integers with the specified range, inclusive on the lower
+ * end and exclusive on the high end. (The "e" in the function name stands for exclusive.) Thus,
+ * this function works in the same way as the built-in `range` function from Python.
+ *
+ * If the end is lower than the start, then an empty range will be returned.
+ *
+ * For example:
+ *
+ * - `eRange(2)` returns `[0, 1]`.
+ * - `eRange(3)` returns `[0, 1, 2]`.
+ * - `eRange(-3)` returns `[0, -1, -2]`.
+ * - `eRange(1, 3)` returns `[1, 2]`.
+ * - `eRange(2, 5)` returns `[2, 3, 4]`.
+ * - `eRange(5, 2)` returns `[]`.
+ * - `eRange(3, 3)` returns `[]`.
+ *
+ * If you want an array instead of an iterator, use the spread operator like this:
+ *
+ * ```ts
+ * const myArray = [...eRange(1, 3)];
+ * ```
+ *
+ * @param start The integer to start at.
+ * @param end Optional. The integer to end at. If not specified, then the start will be 0 and the
+ *            first argument will be the end.
+ * @param increment Optional. The increment to use. Default is 1.
+ */
+export declare function eRange(start: number, end?: number, increment?: number): Generator<number>;
+/**
+ * Helper function to get an array of integers with the specified range, inclusive on both ends.
+ * (The "i" in the function name stands for inclusive.)
+ *
+ * If the end is lower than the start, then an empty range will be returned.
+ *
+ * For example:
+ *
+ * - `iRange(2)` returns `[0, 1, 2]`.
+ * - `iRange(3)` returns `[0, 1, 2, 3]`.
+ * - `iRange(-3)` returns `[0, -1, -2, -3]`.
+ * - `iRange(1, 3)` returns `[1, 2, 3]`.
+ * - `iRange(2, 5)` returns `[2, 3, 4, 5]`.
+ * - `iRange(5, 2)` returns `[]`.
+ * - `iRange(3, 3)` returns `[3]`.
+ *
+ * If you want an array instead of an iterator, use the spread operator like this:
+ *
+ * ```ts
+ * const myArray = [...iRange(1, 3)];
+ * ```
+ *
+ * @param start The integer to start at.
+ * @param end Optional. The integer to end at. If not specified, then the start will be 0 and the
+ *            first argument will be the end.
+ * @param increment Optional. The increment to use. Default is 1.
+ */
+export declare function iRange(start: number, end?: number, increment?: number): Generator<number>;
+/** From: https://stackoverflow.com/questions/61526746 */
+export declare function isKeyOf<T extends object>(key: PropertyKey, target: T): key is keyof T;
+/**
+ * Helper function to perform a no-op. This can be useful in order to make a trailing return valid
+ * in functions that use the early return pattern.
+ */
+export declare function noop(): void;
+/**
+ * This is a more reliable version of `Number.parseFloat`:
+ *
+ * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
+ *   TypeScript type narrowing patterns.
+ * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
+ *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ * - Non-strings will result in undefined instead of being coerced to a number.
+ *
+ * @param string A string to convert to an integer.
+ */
+export declare function parseFloatSafe(string: string): number | undefined;
+/**
+ * This is a more reliable version of `Number.parseInt`:
+ *
+ * - `undefined` is returned instead of `Number.NaN`, which is helpful in conjunction with
+ *   TypeScript type narrowing patterns.
+ * - Strings that are a mixture of numbers and letters will result in undefined instead of the part
+ *   of the string that is the number. (e.g. "1a" --> undefined instead of "1a" --> 1)
+ * - Non-strings will result in undefined instead of being coerced to a number.
+ *
+ * If you have to use a radix other than 10, use the vanilla `Number.parseInt` function instead,
+ * because this function ensures that the string contains no letters.
+ */
+export declare function parseIntSafe(string: string): number | undefined;
+/**
+ * Helper function to repeat code N times. This is faster to type and cleaner than using a for loop.
+ *
+ * For example:
+ *
+ * ```ts
+ * repeat(10, () => {
+ *   foo();
+ * });
+ * ```
+ *
+ * The repeated function is passed the index of the iteration, if needed:
+ *
+ * ```ts
+ * repeat(3, (i) => {
+ *   console.log(i); // Prints "0", "1", "2"
+ * });
+ * ```
+ */
+export declare function repeat(num: number, func: (i: number) => void): void;
+/**
+ * Helper function to signify that the enclosing code block is not yet complete. Using this function
+ * is similar to writing a "TODO" comment, but it has the benefit of preventing ESLint errors due to
+ * unused variables or early returns.
+ *
+ * When you see this function, it simply means that the programmer intends to add in more code to
+ * this spot later.
+ *
+ * This function is variadic, meaning that you can pass as many arguments as you want. (This is
+ * useful as a means to prevent unused variables.)
+ *
+ * This function does not actually do anything. (It is an "empty" function.)
+ *
+ * @allowEmptyVariadic
+ */
+export declare function todo(...args: readonly unknown[]): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/functions/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/functions/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAiB,MAAM,CACrB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,SAAS,SAAI,GACZ,SAAS,CAAC,MAAM,CAAC,CASnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAiB,MAAM,CACrB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,SAAS,SAAI,GACZ,SAAS,CAAC,MAAM,CAAC,CAQnB;AAED,yDAAyD;AACzD,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,CAAC,GACR,GAAG,IAAI,MAAM,CAAC,CAEhB;AAED;;;GAGG;AAEH,wBAAgB,IAAI,IAAI,IAAI,CAAG;AAE/B;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAcjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAc/D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAInE;AAED;;;;;;;;;;;;;;GAcG;AAEH,wBAAgB,IAAI,CAAC,GAAG,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI,CAAG"}

package/dist/functions/utils.test.d.cts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/functions/utils.test.d.mts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/functions/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/functions/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../src/functions/utils.test.ts"],"names":[],"mappings":""}

package/dist/index.cjs

@@ -6,25 +6,21 @@ const HOUR_IN_MILLISECONDS = 60 * MINUTE_IN_MILLISECONDS;
 
 const ReadonlySet = Set;
 
-function getRandomInt(min, max, exceptions = []) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  if (min > max) {
-    const oldMin = min;
-    const oldMax = max;
-    min = oldMax;
-    max = oldMin;
-  }
-  const exceptionsSet = new ReadonlySet(exceptions);
-  let randomInt;
-  do {
-    randomInt = Math.floor(Math.random() * (max - min + 1)) + min;
-  } while (exceptionsSet.has(randomInt));
-  return randomInt;
+function isObject(variable) {
+  return typeof variable === "object" && variable !== null && !Array.isArray(variable);
 }
 
-const FLOAT_REGEX = /^-?\d*\.?\d+$/;
-const INTEGER_REGEX = /^-?\d+$/;
+const TYPES_TO_VALIDATION_FUNCTIONS = {
+  string: (val) => typeof val === "string",
+  number: (val) => typeof val === "number",
+  boolean: (val) => typeof val === "boolean",
+  object: (val) => val !== null && typeof val === "object",
+  array: (val) => Array.isArray(val),
+  null: (val) => val === null,
+  undefined: (val) => val === void 0,
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  function: (val) => typeof val === "function"
+};
 function assertDefined(value, ...[msg]) {
   if (value === void 0) {
     throw new TypeError(msg);
@@ -35,56 +31,33 @@ function assertNotNull(value, ...[msg]) {
     throw new TypeError(msg);
   }
 }
-function* eRange(start, end, increment = 1) {
-  if (end === void 0) {
-    yield* eRange(0, start, increment);
-    return;
-  }
-  for (let i = start; i < end; i += increment) {
-    yield i;
-  }
-}
-function* iRange(start, end, increment = 1) {
-  if (end === void 0) {
-    yield* iRange(0, start, increment);
-    return;
-  }
-  const exclusiveEnd = end + 1;
-  yield* eRange(start, exclusiveEnd, increment);
-}
-function isKeyOf(key, target) {
-  return key in target;
-}
-function noop() {
-}
-function parseFloatSafe(string) {
-  if (typeof string !== "string") {
-    return void 0;
-  }
-  const trimmedString = string.trim();
-  if (FLOAT_REGEX.exec(trimmedString) === null) {
-    return void 0;
+function assertObject(value, msg) {
+  if (!isObject(value)) {
+    throw new TypeError(msg);
   }
-  const number = Number.parseFloat(trimmedString);
-  return Number.isNaN(number) ? void 0 : number;
 }
-function parseIntSafe(string) {
-  if (typeof string !== "string") {
-    return void 0;
-  }
-  const trimmedString = string.trim();
-  if (INTEGER_REGEX.exec(trimmedString) === null) {
-    return void 0;
+function assertType(value, type, msg) {
+  const validationFunction = TYPES_TO_VALIDATION_FUNCTIONS[type];
+  if (!validationFunction(value)) {
+    throw new TypeError(msg);
   }
-  const number = Number.parseInt(trimmedString, 10);
-  return Number.isNaN(number) ? void 0 : number;
 }
-function repeat(num, func) {
-  for (let i = 0; i < num; i++) {
-    func(i);
+
+function getRandomInt(min, max, exceptions = []) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  if (min > max) {
+    const oldMin = min;
+    const oldMax = max;
+    min = oldMax;
+    max = oldMin;
   }
-}
-function todo(...args) {
+  const exceptionsSet = new ReadonlySet(exceptions);
+  let randomInt;
+  do {
+    randomInt = Math.floor(Math.random() * (max - min + 1)) + min;
+  } while (exceptionsSet.has(randomInt));
+  return randomInt;
 }
 
 function arrayCopyTwoDimensional(array) {
@@ -117,7 +90,7 @@ function arrayRemoveInPlace(array, ...elementsToRemove) {
   const removedElements = [];
   for (const element of elementsToRemove) {
     const index = array.indexOf(element);
-    if (index > -1) {
+    if (index !== -1) {
       const removedElement = array.splice(index, 1);
       removedElements.push(...removedElement);
     }
@@ -219,16 +192,6 @@ function mapFind(map, predicate) {
   }
   return void 0;
 }
-function objectToMap(object) {
-  const map = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(object)) {
-    map.set(key, value);
-  }
-  return map;
-}
-function objectToReadonlyMap(object) {
-  return objectToMap(object);
-}
 
 function clamp(num, min, max) {
   return Math.max(min, Math.min(num, max));
@@ -245,6 +208,26 @@ function objectFilter(object, predicate) {
   }
   return array;
 }
+function objectToMap(object) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(object)) {
+    map.set(key, value);
+  }
+  return map;
+}
+function objectToReadonlyMap(object) {
+  return objectToMap(object);
+}
+function objectToReverseMap(object) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(object)) {
+    map.set(value, key);
+  }
+  return map;
+}
+function objectToReverseReadonlyMap(object) {
+  return objectToReverseMap(object);
+}
 
 function addSetsToSet(mainSet, ...setsToAdd) {
   for (const set of setsToAdd) {
@@ -308,6 +291,60 @@ function sortCaseInsensitive(array) {
   return newArray;
 }
 
+const FLOAT_REGEX = /^-?\d*\.?\d+$/;
+const INTEGER_REGEX = /^-?\d+$/;
+function* eRange(start, end, increment = 1) {
+  if (end === void 0) {
+    yield* eRange(0, start, increment);
+    return;
+  }
+  for (let i = start; i < end; i += increment) {
+    yield i;
+  }
+}
+function* iRange(start, end, increment = 1) {
+  if (end === void 0) {
+    yield* iRange(0, start, increment);
+    return;
+  }
+  const exclusiveEnd = end + 1;
+  yield* eRange(start, exclusiveEnd, increment);
+}
+function isKeyOf(key, target) {
+  return key in target;
+}
+function noop() {
+}
+function parseFloatSafe(string) {
+  if (typeof string !== "string") {
+    return void 0;
+  }
+  const trimmedString = string.trim();
+  if (FLOAT_REGEX.exec(trimmedString) === null) {
+    return void 0;
+  }
+  const number = Number.parseFloat(trimmedString);
+  return Number.isNaN(number) ? void 0 : number;
+}
+function parseIntSafe(string) {
+  if (typeof string !== "string") {
+    return void 0;
+  }
+  const trimmedString = string.trim();
+  if (INTEGER_REGEX.exec(trimmedString) === null) {
+    return void 0;
+  }
+  const number = Number.parseInt(trimmedString, 10);
+  return Number.isNaN(number) ? void 0 : number;
+}
+function repeat(num, func) {
+  for (let i = 0; i < num; i++) {
+    func(i);
+  }
+}
+function todo(...args) {
+}
+
 const DIACRITIC_REGEX = /\p{Diacritic}/u;
 const EMOJI_REGEX = /(\p{Extended_Pictographic}|\p{Emoji_Component})/u;
 const FIRST_LETTER_CAPITALIZED_REGEX = /^\p{Lu}/u;
@@ -449,6 +486,13 @@ function truncateString(string, maxLength) {
   return string.slice(0, maxLength);
 }
 
+function getElapsedSeconds(startTime) {
+  const endTime = Date.now();
+  const elapsedMilliseconds = endTime - startTime;
+  const elapsedSeconds = elapsedMilliseconds / 1e3;
+  return Math.floor(elapsedSeconds);
+}
+
 function* tupleEntries(tuple) {
   yield* tuple.entries();
 }
@@ -456,10 +500,6 @@ function* tupleKeys(tuple) {
   yield* tuple.keys();
 }
 
-function isObject(variable) {
-  return typeof variable === "object" && variable !== null && !Array.isArray(variable);
-}
-
 const ReadonlyMap = Map;
 
 exports.HOUR_IN_MILLISECONDS = HOUR_IN_MILLISECONDS;
@@ -474,6 +514,8 @@ exports.arrayRemove = arrayRemove;
 exports.arrayRemoveInPlace = arrayRemoveInPlace;
 exports.assertDefined = assertDefined;
 exports.assertNotNull = assertNotNull;
+exports.assertObject = assertObject;
+exports.assertType = assertType;
 exports.capitalizeFirstLetter = capitalizeFirstLetter;
 exports.clamp = clamp;
 exports.combineSets = combineSets;
@@ -482,6 +524,7 @@ exports.eRange = eRange;
 exports.emptyArray = emptyArray;
 exports.escapeHTMLCharacters = escapeHTMLCharacters;
 exports.filterMap = filterMap;
+exports.getElapsedSeconds = getElapsedSeconds;
 exports.getEnumEntries = getEnumEntries;
 exports.getEnumKeys = getEnumKeys;
 exports.getEnumValues = getEnumValues;
@@ -513,6 +556,8 @@ exports.objectKeysToReadonlySet = objectKeysToReadonlySet;
 exports.objectKeysToSet = objectKeysToSet;
 exports.objectToMap = objectToMap;
 exports.objectToReadonlyMap = objectToReadonlyMap;
+exports.objectToReverseMap = objectToReverseMap;
+exports.objectToReverseReadonlyMap = objectToReverseReadonlyMap;
 exports.objectValuesToReadonlySet = objectValuesToReadonlySet;
 exports.objectValuesToSet = objectValuesToSet;
 exports.parseFloatSafe = parseFloatSafe;