Initial commit - Dutchie dispensary scraper

frontend/node_modules/es-toolkit/dist/math/clamp.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Clamps a number within the inclusive upper bound.
+ *
+ * This function takes a number and a maximum bound, and returns the number clamped within the specified upper bound.
+ * If only one bound is provided, it returns the minimum of the value and the bound.
+ *
+ * @param {number} value - The number to clamp.
+ * @param {number} maximum - The maximum bound to clamp the number.
+ * @returns {number} The clamped number within the specified upper bound.
+ *
+ * @example
+ * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5
+ */
+declare function clamp(value: number, maximum: number): number;
+/**
+ * Clamps a number within the inclusive lower and upper bounds.
+ *
+ * This function takes a number and two bounds, and returns the number clamped within the specified bounds.
+ *
+ * @param {number} value - The number to clamp.
+ * @param {number} minimum - The minimum bound to clamp the number.
+ * @param {number} maximum - The maximum bound to clamp the number.
+ * @returns {number} The clamped number within the specified bounds.
+ *
+ * @example
+ * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15
+ * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5
+ * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15
+ */
+declare function clamp(value: number, minimum: number, maximum: number): number;
+
+export { clamp };

frontend/node_modules/es-toolkit/dist/math/clamp.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Clamps a number within the inclusive upper bound.
+ *
+ * This function takes a number and a maximum bound, and returns the number clamped within the specified upper bound.
+ * If only one bound is provided, it returns the minimum of the value and the bound.
+ *
+ * @param {number} value - The number to clamp.
+ * @param {number} maximum - The maximum bound to clamp the number.
+ * @returns {number} The clamped number within the specified upper bound.
+ *
+ * @example
+ * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5
+ */
+declare function clamp(value: number, maximum: number): number;
+/**
+ * Clamps a number within the inclusive lower and upper bounds.
+ *
+ * This function takes a number and two bounds, and returns the number clamped within the specified bounds.
+ *
+ * @param {number} value - The number to clamp.
+ * @param {number} minimum - The minimum bound to clamp the number.
+ * @param {number} maximum - The maximum bound to clamp the number.
+ * @returns {number} The clamped number within the specified bounds.
+ *
+ * @example
+ * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15
+ * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5
+ * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15
+ */
+declare function clamp(value: number, minimum: number, maximum: number): number;
+
+export { clamp };

frontend/node_modules/es-toolkit/dist/math/clamp.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function clamp(value, bound1, bound2) {
+    if (bound2 == null) {
+        return Math.min(value, bound1);
+    }
+    return Math.min(Math.max(value, bound1), bound2);
+}
+
+exports.clamp = clamp;

frontend/node_modules/es-toolkit/dist/math/clamp.mjs

@@ -0,0 +1,8 @@
+function clamp(value, bound1, bound2) {
+    if (bound2 == null) {
+        return Math.min(value, bound1);
+    }
+    return Math.min(Math.max(value, bound1), bound2);
+}
+
+export { clamp };

frontend/node_modules/es-toolkit/dist/math/inRange.d.mts

@@ -0,0 +1,27 @@
+/**
+ * Checks if the value is less than the maximum.
+ *
+ * @param {number} value The value to check.
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 5); // result will be true.
+ * const result2 = inRange(5, 5); // result2 will be false.
+ */
+declare function inRange(value: number, maximum: number): boolean;
+/**
+ * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} value The value to check.
+ * @param {number} minimum The lower bound of the range (inclusive).
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is within the specified range, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 2, 5); // result will be true.
+ * const result2 = inRange(1, 2, 5); // result2 will be false.
+ */
+declare function inRange(value: number, minimum: number, maximum: number): boolean;
+
+export { inRange };

frontend/node_modules/es-toolkit/dist/math/inRange.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if the value is less than the maximum.
+ *
+ * @param {number} value The value to check.
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is less than the maximum, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 5); // result will be true.
+ * const result2 = inRange(5, 5); // result2 will be false.
+ */
+declare function inRange(value: number, maximum: number): boolean;
+/**
+ * Checks if the value is within the range defined by minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} value The value to check.
+ * @param {number} minimum The lower bound of the range (inclusive).
+ * @param {number} maximum The upper bound of the range (exclusive).
+ * @returns {boolean} `true` if the value is within the specified range, otherwise `false`.
+ *
+ * @example
+ * const result = inRange(3, 2, 5); // result will be true.
+ * const result2 = inRange(1, 2, 5); // result2 will be false.
+ */
+declare function inRange(value: number, minimum: number, maximum: number): boolean;
+
+export { inRange };

frontend/node_modules/es-toolkit/dist/math/inRange.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function inRange(value, minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('The maximum value must be greater than the minimum value.');
+    }
+    return minimum <= value && value < maximum;
+}
+
+exports.inRange = inRange;

frontend/node_modules/es-toolkit/dist/math/inRange.mjs

@@ -0,0 +1,12 @@
+function inRange(value, minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('The maximum value must be greater than the minimum value.');
+    }
+    return minimum <= value && value < maximum;
+}
+
+export { inRange };

frontend/node_modules/es-toolkit/dist/math/index.d.mts

@@ -0,0 +1,13 @@
+export { clamp } from './clamp.mjs';
+export { inRange } from './inRange.mjs';
+export { mean } from './mean.mjs';
+export { meanBy } from './meanBy.mjs';
+export { median } from './median.mjs';
+export { medianBy } from './medianBy.mjs';
+export { random } from './random.mjs';
+export { randomInt } from './randomInt.mjs';
+export { range } from './range.mjs';
+export { rangeRight } from './rangeRight.mjs';
+export { round } from './round.mjs';
+export { sum } from './sum.mjs';
+export { sumBy } from './sumBy.mjs';

frontend/node_modules/es-toolkit/dist/math/index.d.ts

@@ -0,0 +1,13 @@
+export { clamp } from './clamp.js';
+export { inRange } from './inRange.js';
+export { mean } from './mean.js';
+export { meanBy } from './meanBy.js';
+export { median } from './median.js';
+export { medianBy } from './medianBy.js';
+export { random } from './random.js';
+export { randomInt } from './randomInt.js';
+export { range } from './range.js';
+export { rangeRight } from './rangeRight.js';
+export { round } from './round.js';
+export { sum } from './sum.js';
+export { sumBy } from './sumBy.js';

frontend/node_modules/es-toolkit/dist/math/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const clamp = require('./clamp.js');
+const inRange = require('./inRange.js');
+const mean = require('./mean.js');
+const meanBy = require('./meanBy.js');
+const median = require('./median.js');
+const medianBy = require('./medianBy.js');
+const random = require('./random.js');
+const randomInt = require('./randomInt.js');
+const range = require('./range.js');
+const rangeRight = require('./rangeRight.js');
+const round = require('./round.js');
+const sum = require('./sum.js');
+const sumBy = require('./sumBy.js');
+
+
+
+exports.clamp = clamp.clamp;
+exports.inRange = inRange.inRange;
+exports.mean = mean.mean;
+exports.meanBy = meanBy.meanBy;
+exports.median = median.median;
+exports.medianBy = medianBy.medianBy;
+exports.random = random.random;
+exports.randomInt = randomInt.randomInt;
+exports.range = range.range;
+exports.rangeRight = rangeRight.rangeRight;
+exports.round = round.round;
+exports.sum = sum.sum;
+exports.sumBy = sumBy.sumBy;

frontend/node_modules/es-toolkit/dist/math/index.mjs

@@ -0,0 +1,13 @@
+export { clamp } from './clamp.mjs';
+export { inRange } from './inRange.mjs';
+export { mean } from './mean.mjs';
+export { meanBy } from './meanBy.mjs';
+export { median } from './median.mjs';
+export { medianBy } from './medianBy.mjs';
+export { random } from './random.mjs';
+export { randomInt } from './randomInt.mjs';
+export { range } from './range.mjs';
+export { rangeRight } from './rangeRight.mjs';
+export { round } from './round.mjs';
+export { sum } from './sum.mjs';
+export { sumBy } from './sumBy.mjs';

frontend/node_modules/es-toolkit/dist/math/mean.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Calculates the average of an array of numbers.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the average.
+ * @returns {number} The average of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = mean(numbers);
+ * // result will be 3
+ */
+declare function mean(nums: readonly number[]): number;
+
+export { mean };

frontend/node_modules/es-toolkit/dist/math/mean.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Calculates the average of an array of numbers.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the average.
+ * @returns {number} The average of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = mean(numbers);
+ * // result will be 3
+ */
+declare function mean(nums: readonly number[]): number;
+
+export { mean };

frontend/node_modules/es-toolkit/dist/math/mean.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sum = require('./sum.js');
+
+function mean(nums) {
+    return sum.sum(nums) / nums.length;
+}
+
+exports.mean = mean;

frontend/node_modules/es-toolkit/dist/math/mean.mjs

@@ -0,0 +1,7 @@
+import { sum } from './sum.mjs';
+
+function mean(nums) {
+    return sum(nums) / nums.length;
+}
+
+export { mean };

frontend/node_modules/es-toolkit/dist/math/meanBy.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Calculates the average of an array of numbers when applying
+ * the `getValue` function to each element.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the average.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The average of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2
+ * meanBy([], x => x.a); // Returns: NaN
+ */
+declare function meanBy<T>(items: readonly T[], getValue: (element: T) => number): number;
+
+export { meanBy };

frontend/node_modules/es-toolkit/dist/math/meanBy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Calculates the average of an array of numbers when applying
+ * the `getValue` function to each element.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the average.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The average of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2
+ * meanBy([], x => x.a); // Returns: NaN
+ */
+declare function meanBy<T>(items: readonly T[], getValue: (element: T) => number): number;
+
+export { meanBy };

frontend/node_modules/es-toolkit/dist/math/meanBy.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const sumBy = require('./sumBy.js');
+
+function meanBy(items, getValue) {
+    return sumBy.sumBy(items, item => getValue(item)) / items.length;
+}
+
+exports.meanBy = meanBy;

frontend/node_modules/es-toolkit/dist/math/meanBy.mjs

@@ -0,0 +1,7 @@
+import { sumBy } from './sumBy.mjs';
+
+function meanBy(items, getValue) {
+    return sumBy(items, item => getValue(item)) / items.length;
+}
+
+export { meanBy };

frontend/node_modules/es-toolkit/dist/math/median.d.mts

@@ -0,0 +1,25 @@
+/**
+ * Calculates the median of an array of numbers.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the median.
+ * @returns {number} The median of all the numbers in the array.
+ *
+ * @example
+ * const arrayWithOddNumberOfElements = [1, 2, 3, 4, 5];
+ * const result = median(arrayWithOddNumberOfElements);
+ * // result will be 3
+ *
+ * @example
+ * const arrayWithEvenNumberOfElements = [1, 2, 3, 4];
+ * const result = median(arrayWithEvenNumberOfElements);
+ * // result will be 2.5
+ */
+declare function median(nums: readonly number[]): number;
+
+export { median };

frontend/node_modules/es-toolkit/dist/math/median.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Calculates the median of an array of numbers.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @param {number[]} nums - An array of numbers to calculate the median.
+ * @returns {number} The median of all the numbers in the array.
+ *
+ * @example
+ * const arrayWithOddNumberOfElements = [1, 2, 3, 4, 5];
+ * const result = median(arrayWithOddNumberOfElements);
+ * // result will be 3
+ *
+ * @example
+ * const arrayWithEvenNumberOfElements = [1, 2, 3, 4];
+ * const result = median(arrayWithEvenNumberOfElements);
+ * // result will be 2.5
+ */
+declare function median(nums: readonly number[]): number;
+
+export { median };

frontend/node_modules/es-toolkit/dist/math/median.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function median(nums) {
+    if (nums.length === 0) {
+        return NaN;
+    }
+    const sorted = nums.slice().sort((a, b) => a - b);
+    const middleIndex = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2;
+    }
+    else {
+        return sorted[middleIndex];
+    }
+}
+
+exports.median = median;

frontend/node_modules/es-toolkit/dist/math/median.mjs

@@ -0,0 +1,15 @@
+function median(nums) {
+    if (nums.length === 0) {
+        return NaN;
+    }
+    const sorted = nums.slice().sort((a, b) => a - b);
+    const middleIndex = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2;
+    }
+    else {
+        return sorted[middleIndex];
+    }
+}
+
+export { median };

frontend/node_modules/es-toolkit/dist/math/medianBy.d.mts

@@ -0,0 +1,23 @@
+/**
+ * Calculates the median of an array of elements when applying
+ * the `getValue` function to each element.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the median.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The median of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }], x => x.a); // Returns: 3
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }], x => x.a); // Returns: 2.5
+ * medianBy([], x => x.a); // Returns: NaN
+ */
+declare function medianBy<T>(items: readonly T[], getValue: (element: T) => number): number;
+
+export { medianBy };

frontend/node_modules/es-toolkit/dist/math/medianBy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Calculates the median of an array of elements when applying
+ * the `getValue` function to each element.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the median.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The median of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }], x => x.a); // Returns: 3
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }], x => x.a); // Returns: 2.5
+ * medianBy([], x => x.a); // Returns: NaN
+ */
+declare function medianBy<T>(items: readonly T[], getValue: (element: T) => number): number;
+
+export { medianBy };

frontend/node_modules/es-toolkit/dist/math/medianBy.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const median = require('./median.js');
+
+function medianBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return median.median(nums);
+}
+
+exports.medianBy = medianBy;

frontend/node_modules/es-toolkit/dist/math/medianBy.mjs

@@ -0,0 +1,8 @@
+import { median } from './median.mjs';
+
+function medianBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return median(nums);
+}
+
+export { medianBy };

frontend/node_modules/es-toolkit/dist/math/random.d.mts

@@ -0,0 +1,30 @@
+/**
+ * Generate a random number within the given range.
+ *
+ * If only one argument is provided, a number between `0` and the given number is returned.
+ *
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between 0 (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `0`.
+ *
+ * @example
+ * const result1 = random(5); // Returns a random number between 0 and 5.
+ * const result2 = random(0); // If the `maximum` is less than or equal to 0, an error is thrown.
+ */
+declare function random(maximum: number): number;
+/**
+ * Generate a random number within the given range.
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result1 = random(0, 5); // Returns a random number between 0 and 5.
+ * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown.
+ * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.
+ */
+declare function random(minimum: number, maximum: number): number;
+
+export { random };

frontend/node_modules/es-toolkit/dist/math/random.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generate a random number within the given range.
+ *
+ * If only one argument is provided, a number between `0` and the given number is returned.
+ *
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between 0 (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `0`.
+ *
+ * @example
+ * const result1 = random(5); // Returns a random number between 0 and 5.
+ * const result2 = random(0); // If the `maximum` is less than or equal to 0, an error is thrown.
+ */
+declare function random(maximum: number): number;
+/**
+ * Generate a random number within the given range.
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result1 = random(0, 5); // Returns a random number between 0 and 5.
+ * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown.
+ * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.
+ */
+declare function random(minimum: number, maximum: number): number;
+
+export { random };

frontend/node_modules/es-toolkit/dist/math/random.js

@@ -0,0 +1,16 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function random(minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('Invalid input: The maximum value must be greater than the minimum value.');
+    }
+    return Math.random() * (maximum - minimum) + minimum;
+}
+
+exports.random = random;

frontend/node_modules/es-toolkit/dist/math/random.mjs

@@ -0,0 +1,12 @@
+function random(minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('Invalid input: The maximum value must be greater than the minimum value.');
+    }
+    return Math.random() * (maximum - minimum) + minimum;
+}
+
+export { random };

frontend/node_modules/es-toolkit/dist/math/randomInt.d.mts

@@ -0,0 +1,26 @@
+/**
+ * Generates a random integer between 0 (inclusive) and the given maximum (exclusive).
+ *
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between 0 (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `0`.
+ *
+ * @example
+ * const result = randomInt(5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ */
+declare function randomInt(maximum: number): number;
+/**
+ * Generates a random integer between minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ * const result2 = randomInt(5, 0); // This will throw an error
+ */
+declare function randomInt(minimum: number, maximum: number): number;
+
+export { randomInt };

frontend/node_modules/es-toolkit/dist/math/randomInt.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Generates a random integer between 0 (inclusive) and the given maximum (exclusive).
+ *
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between 0 (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `0`.
+ *
+ * @example
+ * const result = randomInt(5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ */
+declare function randomInt(maximum: number): number;
+/**
+ * Generates a random integer between minimum (inclusive) and maximum (exclusive).
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ * const result2 = randomInt(5, 0); // This will throw an error
+ */
+declare function randomInt(minimum: number, maximum: number): number;
+
+export { randomInt };

frontend/node_modules/es-toolkit/dist/math/randomInt.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const random = require('./random.js');
+
+function randomInt(minimum, maximum) {
+    return Math.floor(random.random(minimum, maximum));
+}
+
+exports.randomInt = randomInt;

frontend/node_modules/es-toolkit/dist/math/randomInt.mjs

@@ -0,0 +1,7 @@
+import { random } from './random.mjs';
+
+function randomInt(minimum, maximum) {
+    return Math.floor(random(minimum, maximum));
+}
+
+export { randomInt };

frontend/node_modules/es-toolkit/dist/math/range.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Returns an array of numbers from `0` (inclusive) to `end` (exclusive), incrementing by `1`.
+ *
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `0` (inclusive) to `end` (exclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [0, 1, 2, 3]
+ * range(4);
+ */
+declare function range(end: number): number[];
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `1`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * range(1, 4);
+ */
+declare function range(start: number, end: number): number[];
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with the specified `step`.
+ *
+ * @example
+ * // Returns [0, 5, 10, 15]
+ * range(0, 20, 5);
+ */
+declare function range(start: number, end: number, step: number): number[];
+
+export { range };

frontend/node_modules/es-toolkit/dist/math/range.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Returns an array of numbers from `0` (inclusive) to `end` (exclusive), incrementing by `1`.
+ *
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `0` (inclusive) to `end` (exclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [0, 1, 2, 3]
+ * range(4);
+ */
+declare function range(end: number): number[];
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `1`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * range(1, 4);
+ */
+declare function range(start: number, end: number): number[];
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with the specified `step`.
+ *
+ * @example
+ * // Returns [0, 5, 10, 15]
+ * range(0, 20, 5);
+ */
+declare function range(start: number, end: number, step: number): number[];
+
+export { range };

frontend/node_modules/es-toolkit/dist/math/range.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function range(start, end, step = 1) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + i * step;
+    }
+    return result;
+}
+
+exports.range = range;

frontend/node_modules/es-toolkit/dist/math/range.mjs

@@ -0,0 +1,17 @@
+function range(start, end, step = 1) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + i * step;
+    }
+    return result;
+}
+
+export { range };

frontend/node_modules/es-toolkit/dist/math/rangeRight.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Returns an array of numbers from `end` (exclusive) to `0` (inclusive), decrementing by `1`.
+ *
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `0` (inclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [3, 2, 1, 0]
+ * rangeRight(4);
+ */
+declare function rangeRight(end: number): number[];
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `1`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [3, 2, 1]
+ * rangeRight(1, 4);
+ */
+declare function rangeRight(start: number, end: number): number[];
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with the specified `step`.
+ *
+ * @example
+ * // Returns [15, 10, 5, 0]
+ * rangeRight(0, 20, 5);
+ */
+declare function rangeRight(start: number, end: number, step: number): number[];
+
+export { rangeRight };

frontend/node_modules/es-toolkit/dist/math/rangeRight.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Returns an array of numbers from `end` (exclusive) to `0` (inclusive), decrementing by `1`.
+ *
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `0` (inclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [3, 2, 1, 0]
+ * rangeRight(4);
+ */
+declare function rangeRight(end: number): number[];
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `1`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with a step of `1`.
+ *
+ * @example
+ * // Returns [3, 2, 1]
+ * rangeRight(1, 4);
+ */
+declare function rangeRight(start: number, end: number): number[];
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with the specified `step`.
+ *
+ * @example
+ * // Returns [15, 10, 5, 0]
+ * rangeRight(0, 20, 5);
+ */
+declare function rangeRight(start: number, end: number, step: number): number[];
+
+export { rangeRight };

frontend/node_modules/es-toolkit/dist/math/rangeRight.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function rangeRight(start, end, step = 1) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + (length - i - 1) * step;
+    }
+    return result;
+}
+
+exports.rangeRight = rangeRight;

frontend/node_modules/es-toolkit/dist/math/rangeRight.mjs

@@ -0,0 +1,17 @@
+function rangeRight(start, end, step = 1) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + (length - i - 1) * step;
+    }
+    return result;
+}
+
+export { rangeRight };

frontend/node_modules/es-toolkit/dist/math/round.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Rounds a number to a specified precision.
+ *
+ * This function takes a number and an optional precision value, and returns the number rounded
+ * to the specified number of decimal places.
+ *
+ * @param {number} value - The number to round.
+ * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0.
+ * @returns {number} The rounded number.
+ * @throws {Error} Throws an error if `Precision` is not integer.
+ *
+ * @example
+ * const result1 = round(1.2345); // result1 will be 1
+ * const result2 = round(1.2345, 2); // result2 will be 1.23
+ * const result3 = round(1.2345, 3); // result3 will be 1.235
+ * const result4 = round(1.2345, 3.1); // This will throw an error
+ */
+declare function round(value: number, precision?: number): number;
+
+export { round };

frontend/node_modules/es-toolkit/dist/math/round.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rounds a number to a specified precision.
+ *
+ * This function takes a number and an optional precision value, and returns the number rounded
+ * to the specified number of decimal places.
+ *
+ * @param {number} value - The number to round.
+ * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0.
+ * @returns {number} The rounded number.
+ * @throws {Error} Throws an error if `Precision` is not integer.
+ *
+ * @example
+ * const result1 = round(1.2345); // result1 will be 1
+ * const result2 = round(1.2345, 2); // result2 will be 1.23
+ * const result3 = round(1.2345, 3); // result3 will be 1.235
+ * const result4 = round(1.2345, 3.1); // This will throw an error
+ */
+declare function round(value: number, precision?: number): number;
+
+export { round };

frontend/node_modules/es-toolkit/dist/math/round.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function round(value, precision = 0) {
+    if (!Number.isInteger(precision)) {
+        throw new Error('Precision must be an integer.');
+    }
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
+}
+
+exports.round = round;

frontend/node_modules/es-toolkit/dist/math/round.mjs

@@ -0,0 +1,9 @@
+function round(value, precision = 0) {
+    if (!Number.isInteger(precision)) {
+        throw new Error('Precision must be an integer.');
+    }
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
+}
+
+export { round };

frontend/node_modules/es-toolkit/dist/math/sum.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Calculates the sum of an array of numbers.
+ *
+ * This function takes an array of numbers and returns the sum of all the elements in the array.
+ *
+ * @param {number[]} nums - An array of numbers to be summed.
+ * @returns {number} The sum of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = sum(numbers);
+ * // result will be 15
+ */
+declare function sum(nums: readonly number[]): number;
+
+export { sum };

frontend/node_modules/es-toolkit/dist/math/sum.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Calculates the sum of an array of numbers.
+ *
+ * This function takes an array of numbers and returns the sum of all the elements in the array.
+ *
+ * @param {number[]} nums - An array of numbers to be summed.
+ * @returns {number} The sum of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = sum(numbers);
+ * // result will be 15
+ */
+declare function sum(nums: readonly number[]): number;
+
+export { sum };

frontend/node_modules/es-toolkit/dist/math/sum.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function sum(nums) {
+    let result = 0;
+    for (let i = 0; i < nums.length; i++) {
+        result += nums[i];
+    }
+    return result;
+}
+
+exports.sum = sum;

frontend/node_modules/es-toolkit/dist/math/sum.mjs

@@ -0,0 +1,9 @@
+function sum(nums) {
+    let result = 0;
+    for (let i = 0; i < nums.length; i++) {
+        result += nums[i];
+    }
+    return result;
+}
+
+export { sum };

frontend/node_modules/es-toolkit/dist/math/sumBy.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Calculates the sum of an array of numbers when applying
+ * the `getValue` function to each element.
+ *
+ * If the array is empty, this function returns `0`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} items - An array to calculate the sum.
+ * @param {(element: T, index: number) => number} getValue - A function that selects a numeric value from each element.
+ *   It receives the element and its zero‑based index in the array.
+ * @returns {number} The sum of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], (x, i) => x.a * i); // Returns: 8
+ * sumBy([], () => 1); // Returns: 0
+ */
+declare function sumBy<T>(items: readonly T[], getValue: (element: T, index: number) => number): number;
+
+export { sumBy };

frontend/node_modules/es-toolkit/dist/math/sumBy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Calculates the sum of an array of numbers when applying
+ * the `getValue` function to each element.
+ *
+ * If the array is empty, this function returns `0`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {readonly T[]} items - An array to calculate the sum.
+ * @param {(element: T, index: number) => number} getValue - A function that selects a numeric value from each element.
+ *   It receives the element and its zero‑based index in the array.
+ * @returns {number} The sum of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], (x, i) => x.a * i); // Returns: 8
+ * sumBy([], () => 1); // Returns: 0
+ */
+declare function sumBy<T>(items: readonly T[], getValue: (element: T, index: number) => number): number;
+
+export { sumBy };

frontend/node_modules/es-toolkit/dist/math/sumBy.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function sumBy(items, getValue) {
+    let result = 0;
+    for (let i = 0; i < items.length; i++) {
+        result += getValue(items[i], i);
+    }
+    return result;
+}
+
+exports.sumBy = sumBy;

frontend/node_modules/es-toolkit/dist/math/sumBy.mjs

@@ -0,0 +1,9 @@
+function sumBy(items, getValue) {
+    let result = 0;
+    for (let i = 0; i < items.length; i++) {
+        result += getValue(items[i], i);
+    }
+    return result;
+}
+
+export { sumBy };