Upload folder using huggingface_hub (part 34)

tools/ui/node_modules/es-toolkit/dist/compat/array/partition.d.ts

@@ -0,0 +1,51 @@
+import { ValueIteratee } from "../_internal/ValueIteratee.js";
+import { ValueIteratorTypeGuard } from "../_internal/ValueIteratorTypeGuard.js";
+
+//#region src/compat/array/partition.d.ts
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * predicate returns truthy for, while the second of which contains elements predicate returns falsey for.
+ * The predicate is invoked with one argument: (value).
+ *
+ * @template T, U
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {(value: T) => value is U} callback - The function invoked per iteration.
+ * @returns {[U[], Array<Exclude<T, U>>]} Returns the array of grouped elements.
+ *
+ * @example
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
+ */
+declare function partition<T, U extends T>(collection: ArrayLike<T> | null | undefined, callback: ValueIteratorTypeGuard<T, U>): [U[], Array<Exclude<T, U>>];
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * predicate returns truthy for, while the second of which contains elements predicate returns falsey for.
+ * The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The collection to iterate over.
+ * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>} callback - The function invoked per iteration.
+ * @returns {[T[], T[]]} Returns the array of grouped elements.
+ *
+ * @example
+ * partition([1, 2, 3, 4], n => n % 2 === 0);
+ * // => [[2, 4], [1, 3]]
+ */
+declare function partition<T>(collection: ArrayLike<T> | null | undefined, callback: ValueIteratee<T>): [T[], T[]];
+/**
+ * Creates an array of elements split into two groups, the first of which contains elements
+ * predicate returns truthy for, while the second of which contains elements predicate returns falsey for.
+ * The predicate is invoked with one argument: (value).
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The collection to iterate over.
+ * @param {((value: T[keyof T]) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T[keyof T]>} callback - The function invoked per iteration.
+ * @returns {[Array<T[keyof T]>, Array<T[keyof T]>]} Returns the array of grouped elements.
+ *
+ * @example
+ * partition({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
+ * // => [[2], [1, 3]]
+ */
+declare function partition<T extends object>(collection: T | null | undefined, callback: ValueIteratee<T[keyof T]>): [Array<T[keyof T]>, Array<T[keyof T]>];
+//#endregion
+export { partition };

tools/ui/node_modules/es-toolkit/dist/compat/array/partition.js

@@ -0,0 +1,42 @@
+const require_identity = require("../../function/identity.js");
+const require_isArrayLike = require("../predicate/isArrayLike.js");
+const require_iteratee = require("../util/iteratee.js");
+//#region src/compat/array/partition.ts
+/**
+* Creates an array of elements split into two groups, the first of which contains elements
+* `predicate` returns truthy for, the second of which contains elements
+* `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+*
+* @template T
+* @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+* @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+* @returns {[T[], T[]]} - Returns the array of grouped elements.
+*
+* @example
+* partition([{ a: 1 }, { a: 2 }, { b: 1 }], 'a');
+* // => [[{ a: 1 }, { a: 2 }], [{ b: 1 }]]
+*
+* partition([{ a: 1 }, { a: 2 }, { b: 1 }], { b: 1 });
+* // => [[{ b: 1 }], [{ a: 1 }, { a: 2 }]]
+*
+* partition({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false })
+* // => [[{ a: 2, b: false }], [{ a: 0, b: true }, { a: 1, b: true }]]
+*
+* partition([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
+* // => [[{ a: 2 }], [{ a: 1 }, { a: 3 }]]
+*/
+function partition(source, predicate = require_identity.identity) {
+	if (!source) return [[], []];
+	const collection = require_isArrayLike.isArrayLike(source) ? source : Object.values(source);
+	predicate = require_iteratee.iteratee(predicate);
+	const matched = [];
+	const unmatched = [];
+	for (let i = 0; i < collection.length; i++) {
+		const value = collection[i];
+		if (predicate(value)) matched.push(value);
+		else unmatched.push(value);
+	}
+	return [matched, unmatched];
+}
+//#endregion
+exports.partition = partition;

tools/ui/node_modules/es-toolkit/dist/compat/array/partition.mjs

@@ -0,0 +1,42 @@
+import { identity } from "../../function/identity.mjs";
+import { isArrayLike } from "../predicate/isArrayLike.mjs";
+import { iteratee } from "../util/iteratee.mjs";
+//#region src/compat/array/partition.ts
+/**
+* Creates an array of elements split into two groups, the first of which contains elements
+* `predicate` returns truthy for, the second of which contains elements
+* `predicate` returns falsy for. The predicate is invoked with one argument: (value).
+*
+* @template T
+* @param {ArrayLike<T> | T | null | undefined} source - The array or object to iterate over.
+* @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+* @returns {[T[], T[]]} - Returns the array of grouped elements.
+*
+* @example
+* partition([{ a: 1 }, { a: 2 }, { b: 1 }], 'a');
+* // => [[{ a: 1 }, { a: 2 }], [{ b: 1 }]]
+*
+* partition([{ a: 1 }, { a: 2 }, { b: 1 }], { b: 1 });
+* // => [[{ b: 1 }], [{ a: 1 }, { a: 2 }]]
+*
+* partition({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false })
+* // => [[{ a: 2, b: false }], [{ a: 0, b: true }, { a: 1, b: true }]]
+*
+* partition([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
+* // => [[{ a: 2 }], [{ a: 1 }, { a: 3 }]]
+*/
+function partition(source, predicate = identity) {
+	if (!source) return [[], []];
+	const collection = isArrayLike(source) ? source : Object.values(source);
+	predicate = iteratee(predicate);
+	const matched = [];
+	const unmatched = [];
+	for (let i = 0; i < collection.length; i++) {
+		const value = collection[i];
+		if (predicate(value)) matched.push(value);
+		else unmatched.push(value);
+	}
+	return [matched, unmatched];
+}
+//#endregion
+export { partition };

tools/ui/node_modules/es-toolkit/dist/compat/array/pull.d.mts

@@ -0,0 +1,39 @@
+//#region src/compat/array/pull.d.ts
+/**
+ * Removes all provided values from array using SameValueZero for equality comparisons.
+ *
+ * **Note:** Unlike `_.without`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {...T[]} values - The values to remove.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pull<T>(array: T[], ...values: T[]): T[];
+/**
+ * Removes all provided values from array using SameValueZero for equality comparisons.
+ *
+ * **Note:** Unlike `_.without`, this method mutates `array`.
+ *
+ * @template L
+ * @param {L} array - The array to modify.
+ * @param {...L[0][]} values - The values to remove.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pull<L extends ArrayLike<any>>(array: L extends readonly any[] ? never : L, ...values: Array<L[0]>): L;
+//#endregion
+export { pull };

tools/ui/node_modules/es-toolkit/dist/compat/array/pull.d.ts

@@ -0,0 +1,39 @@
+//#region src/compat/array/pull.d.ts
+/**
+ * Removes all provided values from array using SameValueZero for equality comparisons.
+ *
+ * **Note:** Unlike `_.without`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {...T[]} values - The values to remove.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pull<T>(array: T[], ...values: T[]): T[];
+/**
+ * Removes all provided values from array using SameValueZero for equality comparisons.
+ *
+ * **Note:** Unlike `_.without`, this method mutates `array`.
+ *
+ * @template L
+ * @param {L} array - The array to modify.
+ * @param {...L[0][]} values - The values to remove.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pull(array, 2, 3);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pull<L extends ArrayLike<any>>(array: L extends readonly any[] ? never : L, ...values: Array<L[0]>): L;
+//#endregion
+export { pull };

tools/ui/node_modules/es-toolkit/dist/compat/array/pull.js

@@ -0,0 +1,23 @@
+const require_pull = require("../../array/pull.js");
+//#region src/compat/array/pull.ts
+/**
+* Removes all specified values from an array.
+*
+* This function changes `arr` in place.
+* If you want to remove values without modifying the original array, use `difference`.
+*
+* @template T, U
+* @param {T[]} arr - The array to modify.
+* @param {...unknown[]} valuesToRemove - The values to remove from the array.
+* @returns {T[]} The modified array with the specified values removed.
+*
+* @example
+* const numbers = [1, 2, 3, 4, 5, 2, 4];
+* pull(numbers, [2, 4]);
+* console.log(numbers); // [1, 3, 5]
+*/
+function pull(arr, ...valuesToRemove) {
+	return require_pull.pull(arr, valuesToRemove);
+}
+//#endregion
+exports.pull = pull;

tools/ui/node_modules/es-toolkit/dist/compat/array/pull.mjs

@@ -0,0 +1,23 @@
+import { pull as pull$1 } from "../../array/pull.mjs";
+//#region src/compat/array/pull.ts
+/**
+* Removes all specified values from an array.
+*
+* This function changes `arr` in place.
+* If you want to remove values without modifying the original array, use `difference`.
+*
+* @template T, U
+* @param {T[]} arr - The array to modify.
+* @param {...unknown[]} valuesToRemove - The values to remove from the array.
+* @returns {T[]} The modified array with the specified values removed.
+*
+* @example
+* const numbers = [1, 2, 3, 4, 5, 2, 4];
+* pull(numbers, [2, 4]);
+* console.log(numbers); // [1, 3, 5]
+*/
+function pull(arr, ...valuesToRemove) {
+	return pull$1(arr, valuesToRemove);
+}
+//#endregion
+export { pull };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAll.d.mts

@@ -0,0 +1,42 @@
+import { MutableList } from "../_internal/MutableList.mjs";
+import { RejectReadonly } from "../_internal/RejectReadonly.mjs";
+
+//#region src/compat/array/pullAll.d.ts
+/**
+ * This method is like `_.pull` except that it accepts an array of values to remove.
+ *
+ * **Note:** Unlike `_.difference`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<T>} [values] - The values to remove.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pullAll(array, [2, 3]);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pullAll<T>(array: T[], values?: ArrayLike<T>): T[];
+/**
+ * This method is like `_.pull` except that it accepts an array of values to remove.
+ *
+ * **Note:** Unlike `_.difference`, this method mutates `array`.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {List<L[0]>} [values] - The values to remove.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pullAll(array, [2, 3]);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pullAll<L extends MutableList<any>>(array: RejectReadonly<L>, values?: ArrayLike<L[0]>): L;
+//#endregion
+export { pullAll };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAll.d.ts

@@ -0,0 +1,42 @@
+import { MutableList } from "../_internal/MutableList.js";
+import { RejectReadonly } from "../_internal/RejectReadonly.js";
+
+//#region src/compat/array/pullAll.d.ts
+/**
+ * This method is like `_.pull` except that it accepts an array of values to remove.
+ *
+ * **Note:** Unlike `_.difference`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<T>} [values] - The values to remove.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pullAll(array, [2, 3]);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pullAll<T>(array: T[], values?: ArrayLike<T>): T[];
+/**
+ * This method is like `_.pull` except that it accepts an array of values to remove.
+ *
+ * **Note:** Unlike `_.difference`, this method mutates `array`.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {List<L[0]>} [values] - The values to remove.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [1, 2, 3, 1, 2, 3];
+ *
+ * pullAll(array, [2, 3]);
+ * console.log(array);
+ * // => [1, 1]
+ */
+declare function pullAll<L extends MutableList<any>>(array: RejectReadonly<L>, values?: ArrayLike<L[0]>): L;
+//#endregion
+export { pullAll };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAll.js

@@ -0,0 +1,23 @@
+const require_pull = require("../../array/pull.js");
+//#region src/compat/array/pullAll.ts
+/**
+* Removes all specified values from an array.
+*
+* This function changes `arr` in place.
+* If you want to remove values without modifying the original array, use `difference`.
+*
+* @template T
+* @param {T[]} arr - The array to modify.
+* @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+* @returns {T[]} The modified array with the specified values removed.
+*
+* @example
+* const numbers = [1, 2, 3, 4, 5, 2, 4];
+* pullAll(numbers, [2, 4]);
+* console.log(numbers); // [1, 3, 5]
+*/
+function pullAll(arr, valuesToRemove = []) {
+	return require_pull.pull(arr, Array.from(valuesToRemove));
+}
+//#endregion
+exports.pullAll = pullAll;

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAll.mjs

@@ -0,0 +1,23 @@
+import { pull } from "../../array/pull.mjs";
+//#region src/compat/array/pullAll.ts
+/**
+* Removes all specified values from an array.
+*
+* This function changes `arr` in place.
+* If you want to remove values without modifying the original array, use `difference`.
+*
+* @template T
+* @param {T[]} arr - The array to modify.
+* @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+* @returns {T[]} The modified array with the specified values removed.
+*
+* @example
+* const numbers = [1, 2, 3, 4, 5, 2, 4];
+* pullAll(numbers, [2, 4]);
+* console.log(numbers); // [1, 3, 5]
+*/
+function pullAll(arr, valuesToRemove = []) {
+	return pull(arr, Array.from(valuesToRemove));
+}
+//#endregion
+export { pullAll };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.mts

@@ -0,0 +1,87 @@
+import { ValueIteratee } from "../_internal/ValueIteratee.mjs";
+import { MutableList } from "../_internal/MutableList.mjs";
+import { RejectReadonly } from "../_internal/RejectReadonly.mjs";
+
+//#region src/compat/array/pullAllBy.d.ts
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<T>} [values] - The values to remove.
+ * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>} [iteratee] - The iteratee invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<T>(array: T[], values?: ArrayLike<T>, iteratee?: ValueIteratee<T>): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {ArrayLike<L[0]>} [values] - The values to remove.
+ * @param {ValueIteratee<L[0]>} [iteratee] - The iteratee invoked per element.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<L extends MutableList<any>>(array: RejectReadonly<L>, values?: ArrayLike<L[0]>, iteratee?: ValueIteratee<L[0]>): L;
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T, U
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<U>} values - The values to remove.
+ * @param {((value: T | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T | U>} iteratee - The iteratee invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<T, U>(array: T[], values: ArrayLike<U>, iteratee: ValueIteratee<T | U>): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template L, U
+ * @param {L} array - The array to modify.
+ * @param {ArrayLike<U>} values - The values to remove.
+ * @param {((value: L[0] | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial<L[0] | U>} iteratee - The iteratee invoked per element.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<L extends ArrayLike<any>, U>(array: L extends readonly any[] ? never : L, values: ArrayLike<U>, iteratee: ValueIteratee<L[0] | U>): L;
+//#endregion
+export { pullAllBy };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllBy.d.ts

@@ -0,0 +1,87 @@
+import { ValueIteratee } from "../_internal/ValueIteratee.js";
+import { MutableList } from "../_internal/MutableList.js";
+import { RejectReadonly } from "../_internal/RejectReadonly.js";
+
+//#region src/compat/array/pullAllBy.d.ts
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<T>} [values] - The values to remove.
+ * @param {((value: T) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T>} [iteratee] - The iteratee invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<T>(array: T[], values?: ArrayLike<T>, iteratee?: ValueIteratee<T>): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {ArrayLike<L[0]>} [values] - The values to remove.
+ * @param {ValueIteratee<L[0]>} [iteratee] - The iteratee invoked per element.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<L extends MutableList<any>>(array: RejectReadonly<L>, values?: ArrayLike<L[0]>, iteratee?: ValueIteratee<L[0]>): L;
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template T, U
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<U>} values - The values to remove.
+ * @param {((value: T | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial<T | U>} iteratee - The iteratee invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<T, U>(array: T[], values: ArrayLike<U>, iteratee: ValueIteratee<T | U>): T[];
+/**
+ * Removes all specified values from an array using an iteratee function.
+ *
+ * This function changes `arr` in place.
+ * If you want to remove values without modifying the original array, use `differenceBy`.
+ *
+ * @template L, U
+ * @param {L} array - The array to modify.
+ * @param {ArrayLike<U>} values - The values to remove.
+ * @param {((value: L[0] | U) => unknown) | PropertyKey | [PropertyKey, any] | Partial<L[0] | U>} iteratee - The iteratee invoked per element.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
+ *
+ * pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
+ * console.log(array);
+ * // => [{ 'x': 2 }]
+ */
+declare function pullAllBy<L extends ArrayLike<any>, U>(array: L extends readonly any[] ? never : L, values: ArrayLike<U>, iteratee: ValueIteratee<L[0] | U>): L;
+//#endregion
+export { pullAllBy };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllBy.js

@@ -0,0 +1,43 @@
+const require_iteratee = require("../util/iteratee.js");
+//#region src/compat/array/pullAllBy.ts
+/**
+* Removes all specified values from an array using an iteratee function.
+*
+* This function changes `arr` in place.
+* If you want to remove values without modifying the original array, use `differenceBy`.
+*
+* @template T
+* @param {T[]} arr - The array to modify.
+* @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+* @param {keyof T} getValue - The key of the property to match against each element.
+* @returns {T[]} The modified array with the specified values removed.
+*
+* @example
+* // Using a iteratee function
+* const items = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 1 }];
+* const result = pullAllBy(items, [{ value: 1 }, { value: 3 }], obj => obj.value);
+* console.log(result); // [{ value: 2 }]
+*
+* // Using a property name
+* const items = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 1 }];
+* const result = pullAllBy(items, [{ value: 1 }, { value: 3 }], 'value');
+* console.log(result); // [{ value: 2 }]
+*/
+function pullAllBy(arr, valuesToRemove, _getValue) {
+	const getValue = require_iteratee.iteratee(_getValue);
+	const valuesSet = new Set(Array.from(valuesToRemove).map((x) => getValue(x)));
+	let resultIndex = 0;
+	for (let i = 0; i < arr.length; i++) {
+		const value = getValue(arr[i]);
+		if (valuesSet.has(value)) continue;
+		if (!Object.hasOwn(arr, i)) {
+			delete arr[resultIndex++];
+			continue;
+		}
+		arr[resultIndex++] = arr[i];
+	}
+	arr.length = resultIndex;
+	return arr;
+}
+//#endregion
+exports.pullAllBy = pullAllBy;

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllBy.mjs

@@ -0,0 +1,43 @@
+import { iteratee } from "../util/iteratee.mjs";
+//#region src/compat/array/pullAllBy.ts
+/**
+* Removes all specified values from an array using an iteratee function.
+*
+* This function changes `arr` in place.
+* If you want to remove values without modifying the original array, use `differenceBy`.
+*
+* @template T
+* @param {T[]} arr - The array to modify.
+* @param {ArrayLike<T>} valuesToRemove - The values to remove from the array.
+* @param {keyof T} getValue - The key of the property to match against each element.
+* @returns {T[]} The modified array with the specified values removed.
+*
+* @example
+* // Using a iteratee function
+* const items = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 1 }];
+* const result = pullAllBy(items, [{ value: 1 }, { value: 3 }], obj => obj.value);
+* console.log(result); // [{ value: 2 }]
+*
+* // Using a property name
+* const items = [{ value: 1 }, { value: 2 }, { value: 3 }, { value: 1 }];
+* const result = pullAllBy(items, [{ value: 1 }, { value: 3 }], 'value');
+* console.log(result); // [{ value: 2 }]
+*/
+function pullAllBy(arr, valuesToRemove, _getValue) {
+	const getValue = iteratee(_getValue);
+	const valuesSet = new Set(Array.from(valuesToRemove).map((x) => getValue(x)));
+	let resultIndex = 0;
+	for (let i = 0; i < arr.length; i++) {
+		const value = getValue(arr[i]);
+		if (valuesSet.has(value)) continue;
+		if (!Object.hasOwn(arr, i)) {
+			delete arr[resultIndex++];
+			continue;
+		}
+		arr[resultIndex++] = arr[i];
+	}
+	arr.length = resultIndex;
+	return arr;
+}
+//#endregion
+export { pullAllBy };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.mts

@@ -0,0 +1,90 @@
+import { MutableList } from "../_internal/MutableList.mjs";
+import { RejectReadonly } from "../_internal/RejectReadonly.mjs";
+
+//#region src/compat/array/pullAllWith.d.ts
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<T>} [values] - The values to remove.
+ * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<T>(array: T[], values?: ArrayLike<T>, comparator?: (a: T, b: T) => boolean): T[];
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {List<L[0]>} [values] - The values to remove.
+ * @param {Comparator<L[0]>} [comparator] - The comparator invoked per element.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<L extends MutableList<any>>(array: RejectReadonly<L>, values?: ArrayLike<L[0]>, comparator?: (a: L[0], b: L[0]) => boolean): L;
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template T, U
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<U>} values - The values to remove.
+ * @param {(a: T, b: U) => boolean} comparator - The comparator invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<T, U>(array: T[], values: ArrayLike<U>, comparator: (a: T, b: U) => boolean): T[];
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template L1, L2
+ * @param {RejectReadonly<L1>} array - The array to modify.
+ * @param {List<L2>} values - The values to remove.
+ * @param {Comparator2<L1[0], L2>} comparator - The comparator invoked per element.
+ * @returns {L1} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<L1 extends MutableList<any>, L2>(array: RejectReadonly<L1>, values: ArrayLike<L2>, comparator: (a: L1[0], b: L2) => boolean): L1;
+//#endregion
+export { pullAllWith };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllWith.d.ts

@@ -0,0 +1,90 @@
+import { MutableList } from "../_internal/MutableList.js";
+import { RejectReadonly } from "../_internal/RejectReadonly.js";
+
+//#region src/compat/array/pullAllWith.d.ts
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<T>} [values] - The values to remove.
+ * @param {(a: T, b: T) => boolean} [comparator] - The comparator invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<T>(array: T[], values?: ArrayLike<T>, comparator?: (a: T, b: T) => boolean): T[];
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {List<L[0]>} [values] - The values to remove.
+ * @param {Comparator<L[0]>} [comparator] - The comparator invoked per element.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<L extends MutableList<any>>(array: RejectReadonly<L>, values?: ArrayLike<L[0]>, comparator?: (a: L[0], b: L[0]) => boolean): L;
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template T, U
+ * @param {T[]} array - The array to modify.
+ * @param {ArrayLike<U>} values - The values to remove.
+ * @param {(a: T, b: U) => boolean} comparator - The comparator invoked per element.
+ * @returns {T[]} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<T, U>(array: T[], values: ArrayLike<U>, comparator: (a: T, b: U) => boolean): T[];
+/**
+ * This method is like `_.pullAll` except that it accepts `comparator` which is
+ * invoked to compare elements of array to values. The comparator is invoked with
+ * two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
+ *
+ * @template L1, L2
+ * @param {RejectReadonly<L1>} array - The array to modify.
+ * @param {List<L2>} values - The values to remove.
+ * @param {Comparator2<L1[0], L2>} comparator - The comparator invoked per element.
+ * @returns {L1} Returns `array`.
+ *
+ * @example
+ * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
+ *
+ * pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
+ * console.log(array);
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
+ */
+declare function pullAllWith<L1 extends MutableList<any>, L2>(array: RejectReadonly<L1>, values: ArrayLike<L2>, comparator: (a: L1[0], b: L2) => boolean): L1;
+//#endregion
+export { pullAllWith };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllWith.js

@@ -0,0 +1,44 @@
+const require_isEqualsSameValueZero = require("../../_internal/isEqualsSameValueZero.js");
+require("../util/eq.js");
+const require_copyArray = require("../_internal/copyArray.js");
+//#region src/compat/array/pullAllWith.ts
+/**
+* Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+*
+* @template T
+* @param {T[] | ArrayLike<T>} array - The array to modify.
+* @param {T[] | ArrayLike<T>} values - The values to remove from the array.
+* @param {(a: T, b: T) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+* @returns {T[] | ArrayLike<T>} - The array with specified values removed.
+*
+* @example
+* import pullAllWith from './pullAllWith';
+* import isEqual from '../predicate';
+*
+* const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+* const valuesToRemove = [{ x: 3, y: 4 }];
+*
+* const result = pullAllWith(array, valuesToRemove, isEqual);
+*
+* console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+* console.log(array);  // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+*/
+function pullAllWith(array, values, comparator) {
+	if (array?.length == null || values?.length == null) return array;
+	if (array === values) values = require_copyArray.default(values);
+	let resultLength = 0;
+	if (comparator == null) comparator = (a, b) => require_isEqualsSameValueZero.isEqualsSameValueZero(a, b);
+	const valuesArray = Array.isArray(values) ? values : Array.from(values);
+	const hasUndefined = valuesArray.includes(void 0);
+	for (let i = 0; i < array.length; i++) {
+		if (i in array) {
+			if (!valuesArray.some((value) => comparator(array[i], value))) array[resultLength++] = array[i];
+			continue;
+		}
+		if (!hasUndefined) delete array[resultLength++];
+	}
+	array.length = resultLength;
+	return array;
+}
+//#endregion
+exports.pullAllWith = pullAllWith;

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAllWith.mjs

@@ -0,0 +1,44 @@
+import { isEqualsSameValueZero } from "../../_internal/isEqualsSameValueZero.mjs";
+import "../util/eq.mjs";
+import copyArray from "../_internal/copyArray.mjs";
+//#region src/compat/array/pullAllWith.ts
+/**
+* Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+*
+* @template T
+* @param {T[] | ArrayLike<T>} array - The array to modify.
+* @param {T[] | ArrayLike<T>} values - The values to remove from the array.
+* @param {(a: T, b: T) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+* @returns {T[] | ArrayLike<T>} - The array with specified values removed.
+*
+* @example
+* import pullAllWith from './pullAllWith';
+* import isEqual from '../predicate';
+*
+* const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+* const valuesToRemove = [{ x: 3, y: 4 }];
+*
+* const result = pullAllWith(array, valuesToRemove, isEqual);
+*
+* console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+* console.log(array);  // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+*/
+function pullAllWith(array, values, comparator) {
+	if (array?.length == null || values?.length == null) return array;
+	if (array === values) values = copyArray(values);
+	let resultLength = 0;
+	if (comparator == null) comparator = (a, b) => isEqualsSameValueZero(a, b);
+	const valuesArray = Array.isArray(values) ? values : Array.from(values);
+	const hasUndefined = valuesArray.includes(void 0);
+	for (let i = 0; i < array.length; i++) {
+		if (i in array) {
+			if (!valuesArray.some((value) => comparator(array[i], value))) array[resultLength++] = array[i];
+			continue;
+		}
+		if (!hasUndefined) delete array[resultLength++];
+	}
+	array.length = resultLength;
+	return array;
+}
+//#endregion
+export { pullAllWith };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAt.d.mts

@@ -0,0 +1,51 @@
+import { MutableList } from "../_internal/MutableList.mjs";
+import { RejectReadonly } from "../_internal/RejectReadonly.mjs";
+import { Many } from "../_internal/Many.mjs";
+
+//#region src/compat/array/pullAt.d.ts
+/**
+ * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
+ * Indexes may be specified as an array of indexes or as individual arguments.
+ *
+ * **Note:** Unlike `_.at`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {...Array<number | number[]>} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes.
+ * @returns {T[]} Returns the new array of removed elements.
+ *
+ * @example
+ * var array = [5, 10, 15, 20];
+ * var evens = pullAt(array, 1, 3);
+ *
+ * console.log(array);
+ * // => [5, 15]
+ *
+ * console.log(evens);
+ * // => [10, 20]
+ */
+declare function pullAt<T>(array: T[], ...indexes: Array<Many<number>>): T[];
+/**
+ * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
+ * Indexes may be specified as an array of indexes or as individual arguments.
+ *
+ * **Note:** Unlike `_.at`, this method mutates `array`.
+ *
+ * @template L
+ * @param {L} array - The array to modify.
+ * @param {...Array<number | number[]>} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes.
+ * @returns {L} Returns the new array of removed elements.
+ *
+ * @example
+ * var array = [5, 10, 15, 20];
+ * var evens = pullAt(array, 1, 3);
+ *
+ * console.log(array);
+ * // => [5, 15]
+ *
+ * console.log(evens);
+ * // => [10, 20]
+ */
+declare function pullAt<L extends MutableList<any>>(array: RejectReadonly<L>, ...indexes: Array<Many<number>>): L;
+//#endregion
+export { pullAt };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAt.d.ts

@@ -0,0 +1,51 @@
+import { MutableList } from "../_internal/MutableList.js";
+import { RejectReadonly } from "../_internal/RejectReadonly.js";
+import { Many } from "../_internal/Many.js";
+
+//#region src/compat/array/pullAt.d.ts
+/**
+ * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
+ * Indexes may be specified as an array of indexes or as individual arguments.
+ *
+ * **Note:** Unlike `_.at`, this method mutates `array`.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {...Array<number | number[]>} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes.
+ * @returns {T[]} Returns the new array of removed elements.
+ *
+ * @example
+ * var array = [5, 10, 15, 20];
+ * var evens = pullAt(array, 1, 3);
+ *
+ * console.log(array);
+ * // => [5, 15]
+ *
+ * console.log(evens);
+ * // => [10, 20]
+ */
+declare function pullAt<T>(array: T[], ...indexes: Array<Many<number>>): T[];
+/**
+ * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
+ * Indexes may be specified as an array of indexes or as individual arguments.
+ *
+ * **Note:** Unlike `_.at`, this method mutates `array`.
+ *
+ * @template L
+ * @param {L} array - The array to modify.
+ * @param {...Array<number | number[]>} indexes - The indexes of elements to remove, specified as individual indexes or arrays of indexes.
+ * @returns {L} Returns the new array of removed elements.
+ *
+ * @example
+ * var array = [5, 10, 15, 20];
+ * var evens = pullAt(array, 1, 3);
+ *
+ * console.log(array);
+ * // => [5, 15]
+ *
+ * console.log(evens);
+ * // => [10, 20]
+ */
+declare function pullAt<L extends MutableList<any>>(array: RejectReadonly<L>, ...indexes: Array<Many<number>>): L;
+//#endregion
+export { pullAt };

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAt.js

@@ -0,0 +1,44 @@
+const require_isArray = require("../predicate/isArray.js");
+const require_toKey = require("../_internal/toKey.js");
+const require_toPath = require("../util/toPath.js");
+const require_isIndex = require("../_internal/isIndex.js");
+const require_flattenDepth = require("./flattenDepth.js");
+const require_isKey = require("../_internal/isKey.js");
+const require_at = require("../object/at.js");
+const require_unset = require("../object/unset.js");
+//#region src/compat/array/pullAt.ts
+/**
+* Removes elements from an array at specified indices and returns the removed elements.
+*
+* @template T
+* @param {ArrayLike<T>} array - The array from which elements will be removed.
+* @param {Array<number | readonly number[] | string | readonly string[]>} _indices - An array of indices specifying the positions of elements to remove.
+* @returns {ArrayLike<T>} An array containing the elements that were removed from the original array.
+*
+* @example
+* const numbers = [10, 20, 30, 40, 50];
+* const removed = pullAt(numbers, [1, 3, 4]);
+* console.log(removed); // [20, 40, 50]
+* console.log(numbers); // [10, 30]
+*/
+function pullAt(array, ..._indices) {
+	const indices = require_flattenDepth.flattenDepth(_indices, 1);
+	if (!array) return Array(indices.length);
+	const result = require_at.at(array, indices);
+	const indicesToPull = indices.map((index) => require_isIndex.isIndex(index, array.length) ? Number(index) : index).sort((a, b) => b - a);
+	for (const index of new Set(indicesToPull)) {
+		if (require_isIndex.isIndex(index, array.length)) {
+			Array.prototype.splice.call(array, index, 1);
+			continue;
+		}
+		if (require_isKey.isKey(index, array)) {
+			delete array[require_toKey.toKey(index)];
+			continue;
+		}
+		const path = require_isArray.isArray(index) ? index : require_toPath.toPath(index);
+		require_unset.unset(array, path);
+	}
+	return result;
+}
+//#endregion
+exports.pullAt = pullAt;

tools/ui/node_modules/es-toolkit/dist/compat/array/pullAt.mjs

@@ -0,0 +1,43 @@
+import { isArray } from "../predicate/isArray.mjs";
+import { toKey } from "../_internal/toKey.mjs";
+import { toPath } from "../util/toPath.mjs";
+import { isIndex } from "../_internal/isIndex.mjs";
+import { flattenDepth } from "./flattenDepth.mjs";
+import { isKey } from "../_internal/isKey.mjs";
+import { at } from "../object/at.mjs";
+import { unset } from "../object/unset.mjs";
+//#region src/compat/array/pullAt.ts
+/**
+* Removes elements from an array at specified indices and returns the removed elements.
+*
+* @template T
+* @param {ArrayLike<T>} array - The array from which elements will be removed.
+* @param {Array<number | readonly number[] | string | readonly string[]>} _indices - An array of indices specifying the positions of elements to remove.
+* @returns {ArrayLike<T>} An array containing the elements that were removed from the original array.
+*
+* @example
+* const numbers = [10, 20, 30, 40, 50];
+* const removed = pullAt(numbers, [1, 3, 4]);
+* console.log(removed); // [20, 40, 50]
+* console.log(numbers); // [10, 30]
+*/
+function pullAt(array, ..._indices) {
+	const indices = flattenDepth(_indices, 1);
+	if (!array) return Array(indices.length);
+	const result = at(array, indices);
+	const indicesToPull = indices.map((index) => isIndex(index, array.length) ? Number(index) : index).sort((a, b) => b - a);
+	for (const index of new Set(indicesToPull)) {
+		if (isIndex(index, array.length)) {
+			Array.prototype.splice.call(array, index, 1);
+			continue;
+		}
+		if (isKey(index, array)) {
+			delete array[toKey(index)];
+			continue;
+		}
+		unset(array, isArray(index) ? index : toPath(index));
+	}
+	return result;
+}
+//#endregion
+export { pullAt };

tools/ui/node_modules/es-toolkit/dist/compat/array/reduce.d.mts

@@ -0,0 +1,81 @@
+import { MemoListIterator } from "../_internal/MemoListIterator.mjs";
+import { MemoObjectIterator } from "../_internal/MemoObjectIterator.mjs";
+
+//#region src/compat/array/reduce.d.ts
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * @param {T[] | null | undefined} collection - The array to iterate over
+ * @param {MemoListIterator<T, U, T[]>} callback - The function invoked per iteration
+ * @param {U} accumulator - The initial value
+ * @returns {U} Returns the accumulated value
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * reduce(array, (acc, value) => acc + value, 0); // => 6
+ */
+declare function reduce<T, U>(collection: T[] | null | undefined, callback: MemoListIterator<T, U, T[]>, accumulator: U): U;
+/**
+ * Reduces an array-like object to a single value using an iteratee function.
+ *
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like object to iterate over
+ * @param {MemoListIterator<T, U, ArrayLike<T>>} callback - The function invoked per iteration
+ * @param {U} accumulator - The initial value
+ * @returns {U} Returns the accumulated value
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value, 0); // => 6
+ */
+declare function reduce<T, U>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, U, ArrayLike<T>>, accumulator: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T | null | undefined} collection - The object to iterate over
+ * @param {MemoObjectIterator<T[keyof T], U, T>} callback - The function invoked per iteration
+ * @param {U} accumulator - The initial value
+ * @returns {U} Returns the accumulated value
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value, 0); // => 6
+ */
+declare function reduce<T extends object, U>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], U, T>, accumulator: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * @param {T[] | null | undefined} collection - The array to iterate over
+ * @param {MemoListIterator<T, T, T[]>} callback - The function invoked per iteration
+ * @returns {T | undefined} Returns the accumulated value
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * reduce(array, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: T[] | null | undefined, callback: MemoListIterator<T, T, T[]>): T | undefined;
+/**
+ * Reduces an array-like object to a single value using an iteratee function.
+ *
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like object to iterate over
+ * @param {MemoListIterator<T, T, ArrayLike<T>>} callback - The function invoked per iteration
+ * @returns {T | undefined} Returns the accumulated value
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, T, ArrayLike<T>>): T | undefined;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T | null | undefined} collection - The object to iterate over
+ * @param {MemoObjectIterator<T[keyof T], T[keyof T], T>} callback - The function invoked per iteration
+ * @returns {T[keyof T] | undefined} Returns the accumulated value
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T extends object>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;
+//#endregion
+export { reduce };

tools/ui/node_modules/es-toolkit/dist/compat/array/reduce.d.ts

@@ -0,0 +1,81 @@
+import { MemoListIterator } from "../_internal/MemoListIterator.js";
+import { MemoObjectIterator } from "../_internal/MemoObjectIterator.js";
+
+//#region src/compat/array/reduce.d.ts
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * @param {T[] | null | undefined} collection - The array to iterate over
+ * @param {MemoListIterator<T, U, T[]>} callback - The function invoked per iteration
+ * @param {U} accumulator - The initial value
+ * @returns {U} Returns the accumulated value
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * reduce(array, (acc, value) => acc + value, 0); // => 6
+ */
+declare function reduce<T, U>(collection: T[] | null | undefined, callback: MemoListIterator<T, U, T[]>, accumulator: U): U;
+/**
+ * Reduces an array-like object to a single value using an iteratee function.
+ *
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like object to iterate over
+ * @param {MemoListIterator<T, U, ArrayLike<T>>} callback - The function invoked per iteration
+ * @param {U} accumulator - The initial value
+ * @returns {U} Returns the accumulated value
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value, 0); // => 6
+ */
+declare function reduce<T, U>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, U, ArrayLike<T>>, accumulator: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T | null | undefined} collection - The object to iterate over
+ * @param {MemoObjectIterator<T[keyof T], U, T>} callback - The function invoked per iteration
+ * @param {U} accumulator - The initial value
+ * @returns {U} Returns the accumulated value
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value, 0); // => 6
+ */
+declare function reduce<T extends object, U>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], U, T>, accumulator: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function.
+ *
+ * @param {T[] | null | undefined} collection - The array to iterate over
+ * @param {MemoListIterator<T, T, T[]>} callback - The function invoked per iteration
+ * @returns {T | undefined} Returns the accumulated value
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * reduce(array, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: T[] | null | undefined, callback: MemoListIterator<T, T, T[]>): T | undefined;
+/**
+ * Reduces an array-like object to a single value using an iteratee function.
+ *
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like object to iterate over
+ * @param {MemoListIterator<T, T, ArrayLike<T>>} callback - The function invoked per iteration
+ * @returns {T | undefined} Returns the accumulated value
+ *
+ * @example
+ * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
+ * reduce(arrayLike, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, T, ArrayLike<T>>): T | undefined;
+/**
+ * Reduces an object to a single value using an iteratee function.
+ *
+ * @param {T | null | undefined} collection - The object to iterate over
+ * @param {MemoObjectIterator<T[keyof T], T[keyof T], T>} callback - The function invoked per iteration
+ * @returns {T[keyof T] | undefined} Returns the accumulated value
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reduce(obj, (acc, value) => acc + value); // => 6
+ */
+declare function reduce<T extends object>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;
+//#endregion
+export { reduce };

tools/ui/node_modules/es-toolkit/dist/compat/array/reduce.js

@@ -0,0 +1,53 @@
+const require_identity = require("../../function/identity.js");
+const require_range = require("../../math/range.js");
+const require_isArrayLike = require("../predicate/isArrayLike.js");
+//#region src/compat/array/reduce.ts
+/**
+* Reduces a collection to a single value using an iteratee function.
+*
+* @param {T[] | ArrayLike<T> | Record<string, T> | null | undefined} collection - The collection to iterate over.
+* @param {((accumulator: any, value: any, index: PropertyKey, collection: any) => any) | PropertyKey | object} iteratee - The function invoked per iteration or the key to reduce over.
+* @param {any} initialValue - The initial value.
+* @returns {any} - Returns the accumulated value.
+*
+* @example
+* // Using a reducer function
+* const array = [1, 2, 3];
+* reduce(array, (acc, value) => acc + value, 0); // => 6
+*
+* @example
+* // Using a reducer function with initialValue
+* const array = [1, 2, 3];
+* reduce(array, (acc, value) => acc + value % 2 === 0, true); // => false
+*
+* @example
+* // Using an object as the collection
+* const obj = { a: 1, b: 2, c: 3 };
+* reduce(obj, (acc, value) => acc + value, 0); // => 6
+*/
+function reduce(collection, iteratee = require_identity.identity, accumulator) {
+	if (!collection) return accumulator;
+	let keys;
+	let startIndex = 0;
+	if (require_isArrayLike.isArrayLike(collection)) {
+		keys = require_range.range(0, collection.length);
+		if (accumulator == null && collection.length > 0) {
+			accumulator = collection[0];
+			startIndex += 1;
+		}
+	} else {
+		keys = Object.keys(collection);
+		if (accumulator == null) {
+			accumulator = collection[keys[0]];
+			startIndex += 1;
+		}
+	}
+	for (let i = startIndex; i < keys.length; i++) {
+		const key = keys[i];
+		const value = collection[key];
+		accumulator = iteratee(accumulator, value, key, collection);
+	}
+	return accumulator;
+}
+//#endregion
+exports.reduce = reduce;

tools/ui/node_modules/es-toolkit/dist/compat/array/reduce.mjs

@@ -0,0 +1,53 @@
+import { identity } from "../../function/identity.mjs";
+import { range } from "../../math/range.mjs";
+import { isArrayLike } from "../predicate/isArrayLike.mjs";
+//#region src/compat/array/reduce.ts
+/**
+* Reduces a collection to a single value using an iteratee function.
+*
+* @param {T[] | ArrayLike<T> | Record<string, T> | null | undefined} collection - The collection to iterate over.
+* @param {((accumulator: any, value: any, index: PropertyKey, collection: any) => any) | PropertyKey | object} iteratee - The function invoked per iteration or the key to reduce over.
+* @param {any} initialValue - The initial value.
+* @returns {any} - Returns the accumulated value.
+*
+* @example
+* // Using a reducer function
+* const array = [1, 2, 3];
+* reduce(array, (acc, value) => acc + value, 0); // => 6
+*
+* @example
+* // Using a reducer function with initialValue
+* const array = [1, 2, 3];
+* reduce(array, (acc, value) => acc + value % 2 === 0, true); // => false
+*
+* @example
+* // Using an object as the collection
+* const obj = { a: 1, b: 2, c: 3 };
+* reduce(obj, (acc, value) => acc + value, 0); // => 6
+*/
+function reduce(collection, iteratee = identity, accumulator) {
+	if (!collection) return accumulator;
+	let keys;
+	let startIndex = 0;
+	if (isArrayLike(collection)) {
+		keys = range(0, collection.length);
+		if (accumulator == null && collection.length > 0) {
+			accumulator = collection[0];
+			startIndex += 1;
+		}
+	} else {
+		keys = Object.keys(collection);
+		if (accumulator == null) {
+			accumulator = collection[keys[0]];
+			startIndex += 1;
+		}
+	}
+	for (let i = startIndex; i < keys.length; i++) {
+		const key = keys[i];
+		const value = collection[key];
+		accumulator = iteratee(accumulator, value, key, collection);
+	}
+	return accumulator;
+}
+//#endregion
+export { reduce };

tools/ui/node_modules/es-toolkit/dist/compat/array/reduceRight.d.mts

@@ -0,0 +1,119 @@
+import { MemoListIterator } from "../_internal/MemoListIterator.mjs";
+import { MemoObjectIterator } from "../_internal/MemoObjectIterator.mjs";
+
+//#region src/compat/array/reduceRight.d.ts
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @template T, U
+ * @param {T[] | null | undefined} collection - The array to iterate over.
+ * @param {MemoListIterator<T, U, T[]>} callback - The function invoked per iteration.
+ * @param {U} accumulator - The initial value.
+ * @returns {U} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value, 0);
+ * // => 6
+ */
+declare function reduceRight<T, U>(collection: T[] | null | undefined, callback: MemoListIterator<T, U, T[]>, accumulator: U): U;
+/**
+ * Reduces an array-like collection to a single value using an iteratee function, starting from the right.
+ *
+ * @template T, U
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like collection to iterate over.
+ * @param {MemoListIterator<T, U, ArrayLike<T>>} callback - The function invoked per iteration.
+ * @param {U} accumulator - The initial value.
+ * @returns {U} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value, 0);
+ * // => 6
+ */
+declare function reduceRight<T, U>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, U, ArrayLike<T>>, accumulator: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @template T, U
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {MemoObjectIterator<T[keyof T], U, T>} callback - The function invoked per iteration.
+ * @param {U} accumulator - The initial value.
+ * @returns {U} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value, 0);
+ * // => 6
+ */
+declare function reduceRight<T extends object, U>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], U, T>, accumulator: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @template T
+ * @param {T[] | null | undefined} collection - The array to iterate over.
+ * @param {MemoListIterator<T, T, T[]>} callback - The function invoked per iteration.
+ * @returns {T | undefined} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value);
+ * // => 6
+ */
+declare function reduceRight<T>(collection: T[] | null | undefined, callback: MemoListIterator<T, T, T[]>): T | undefined;
+/**
+ * Reduces an array-like collection to a single value using an iteratee function, starting from the right.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like collection to iterate over.
+ * @param {MemoListIterator<T, T, ArrayLike<T>>} callback - The function invoked per iteration.
+ * @returns {T | undefined} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value);
+ * // => 6
+ */
+declare function reduceRight<T>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, T, ArrayLike<T>>): T | undefined;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {MemoObjectIterator<T[keyof T], T[keyof T], T>} callback - The function invoked per iteration.
+ * @returns {T[keyof T] | undefined} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value);
+ * // => 6
+ */
+declare function reduceRight<T extends object>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;
+//#endregion
+export { reduceRight };

tools/ui/node_modules/es-toolkit/dist/compat/array/reduceRight.d.ts

@@ -0,0 +1,119 @@
+import { MemoListIterator } from "../_internal/MemoListIterator.js";
+import { MemoObjectIterator } from "../_internal/MemoObjectIterator.js";
+
+//#region src/compat/array/reduceRight.d.ts
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @template T, U
+ * @param {T[] | null | undefined} collection - The array to iterate over.
+ * @param {MemoListIterator<T, U, T[]>} callback - The function invoked per iteration.
+ * @param {U} accumulator - The initial value.
+ * @returns {U} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value, 0);
+ * // => 6
+ */
+declare function reduceRight<T, U>(collection: T[] | null | undefined, callback: MemoListIterator<T, U, T[]>, accumulator: U): U;
+/**
+ * Reduces an array-like collection to a single value using an iteratee function, starting from the right.
+ *
+ * @template T, U
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like collection to iterate over.
+ * @param {MemoListIterator<T, U, ArrayLike<T>>} callback - The function invoked per iteration.
+ * @param {U} accumulator - The initial value.
+ * @returns {U} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value, 0);
+ * // => 6
+ */
+declare function reduceRight<T, U>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, U, ArrayLike<T>>, accumulator: U): U;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @template T, U
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {MemoObjectIterator<T[keyof T], U, T>} callback - The function invoked per iteration.
+ * @param {U} accumulator - The initial value.
+ * @returns {U} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value, 0);
+ * // => 6
+ */
+declare function reduceRight<T extends object, U>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], U, T>, accumulator: U): U;
+/**
+ * Reduces an array to a single value using an iteratee function, starting from the right.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * The `reduceRight()` function goes through each element in an array from right to left and applies a special function (called a "reducer") to them, one by one.
+ * This function takes the result of the previous step and the current element to perform a calculation.
+ * After going through all the elements, the function gives you one final result.
+ *
+ * When the `reduceRight()` function starts, there's no previous result to use.
+ * If you provide an initial value, it starts with that.
+ * If not, it uses the last element of the array and begins with the second to last element for the calculation.
+ *
+ * @template T
+ * @param {T[] | null | undefined} collection - The array to iterate over.
+ * @param {MemoListIterator<T, T, T[]>} callback - The function invoked per iteration.
+ * @returns {T | undefined} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value);
+ * // => 6
+ */
+declare function reduceRight<T>(collection: T[] | null | undefined, callback: MemoListIterator<T, T, T[]>): T | undefined;
+/**
+ * Reduces an array-like collection to a single value using an iteratee function, starting from the right.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection - The array-like collection to iterate over.
+ * @param {MemoListIterator<T, T, ArrayLike<T>>} callback - The function invoked per iteration.
+ * @returns {T | undefined} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight([1, 2, 3], (acc, value) => acc + value);
+ * // => 6
+ */
+declare function reduceRight<T>(collection: ArrayLike<T> | null | undefined, callback: MemoListIterator<T, T, ArrayLike<T>>): T | undefined;
+/**
+ * Reduces an object to a single value using an iteratee function, starting from the right.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to iterate over.
+ * @param {MemoObjectIterator<T[keyof T], T[keyof T], T>} callback - The function invoked per iteration.
+ * @returns {T[keyof T] | undefined} Returns the accumulated value.
+ *
+ * @example
+ * reduceRight({ a: 1, b: 2, c: 3 }, (acc, value) => acc + value);
+ * // => 6
+ */
+declare function reduceRight<T extends object>(collection: T | null | undefined, callback: MemoObjectIterator<T[keyof T], T[keyof T], T>): T[keyof T] | undefined;
+//#endregion
+export { reduceRight };

tools/ui/node_modules/es-toolkit/dist/compat/array/reduceRight.js

@@ -0,0 +1,53 @@
+const require_identity = require("../../function/identity.js");
+const require_range = require("../../math/range.js");
+const require_isArrayLike = require("../predicate/isArrayLike.js");
+//#region src/compat/array/reduceRight.ts
+/**
+* Reduces a collection to a single value using an iteratee function, starting from the right.
+*
+* @param {T[] | ArrayLike<T> | Record<string, T> | null | undefined} collection - The collection to iterate over.
+* @param {((accumulator: any, value: any, index: PropertyKey, collection: any) => any) | PropertyKey | object} iteratee - The function invoked per iteration or the key to reduce over.
+* @param {any} initialValue - The initial value.
+* @returns {any} - Returns the accumulated value.
+*
+* @example
+* // Using a reducer function
+* const array = [1, 2, 3];
+* reduceRight(array, (acc, value) => acc + value, 0); // => 6
+*
+* @example
+* // Using a reducer function with initialValue
+* const array = [1, 2, 3];
+* reduceRight(array, (acc, value) => acc + value % 2 === 0, true); // => false
+*
+* @example
+* // Using an object as the collection
+* const obj = { a: 1, b: 2, c: 3 };
+* reduceRight(obj, (acc, value) => acc + value, 0); // => 6
+*/
+function reduceRight(collection, iteratee = require_identity.identity, accumulator) {
+	if (!collection) return accumulator;
+	let keys;
+	let startIndex;
+	if (require_isArrayLike.isArrayLike(collection)) {
+		keys = require_range.range(0, collection.length).reverse();
+		if (accumulator == null && collection.length > 0) {
+			accumulator = collection[collection.length - 1];
+			startIndex = 1;
+		} else startIndex = 0;
+	} else {
+		keys = Object.keys(collection).reverse();
+		if (accumulator == null) {
+			accumulator = collection[keys[0]];
+			startIndex = 1;
+		} else startIndex = 0;
+	}
+	for (let i = startIndex; i < keys.length; i++) {
+		const key = keys[i];
+		const value = collection[key];
+		accumulator = iteratee(accumulator, value, key, collection);
+	}
+	return accumulator;
+}
+//#endregion
+exports.reduceRight = reduceRight;

tools/ui/node_modules/es-toolkit/dist/compat/array/reduceRight.mjs

@@ -0,0 +1,53 @@
+import { identity } from "../../function/identity.mjs";
+import { range } from "../../math/range.mjs";
+import { isArrayLike } from "../predicate/isArrayLike.mjs";
+//#region src/compat/array/reduceRight.ts
+/**
+* Reduces a collection to a single value using an iteratee function, starting from the right.
+*
+* @param {T[] | ArrayLike<T> | Record<string, T> | null | undefined} collection - The collection to iterate over.
+* @param {((accumulator: any, value: any, index: PropertyKey, collection: any) => any) | PropertyKey | object} iteratee - The function invoked per iteration or the key to reduce over.
+* @param {any} initialValue - The initial value.
+* @returns {any} - Returns the accumulated value.
+*
+* @example
+* // Using a reducer function
+* const array = [1, 2, 3];
+* reduceRight(array, (acc, value) => acc + value, 0); // => 6
+*
+* @example
+* // Using a reducer function with initialValue
+* const array = [1, 2, 3];
+* reduceRight(array, (acc, value) => acc + value % 2 === 0, true); // => false
+*
+* @example
+* // Using an object as the collection
+* const obj = { a: 1, b: 2, c: 3 };
+* reduceRight(obj, (acc, value) => acc + value, 0); // => 6
+*/
+function reduceRight(collection, iteratee = identity, accumulator) {
+	if (!collection) return accumulator;
+	let keys;
+	let startIndex;
+	if (isArrayLike(collection)) {
+		keys = range(0, collection.length).reverse();
+		if (accumulator == null && collection.length > 0) {
+			accumulator = collection[collection.length - 1];
+			startIndex = 1;
+		} else startIndex = 0;
+	} else {
+		keys = Object.keys(collection).reverse();
+		if (accumulator == null) {
+			accumulator = collection[keys[0]];
+			startIndex = 1;
+		} else startIndex = 0;
+	}
+	for (let i = startIndex; i < keys.length; i++) {
+		const key = keys[i];
+		const value = collection[key];
+		accumulator = iteratee(accumulator, value, key, collection);
+	}
+	return accumulator;
+}
+//#endregion
+export { reduceRight };

tools/ui/node_modules/es-toolkit/dist/compat/array/reject.d.mts

@@ -0,0 +1,51 @@
+import { StringIterator } from "../_internal/StringIterator.mjs";
+import { ListIterateeCustom } from "../_internal/ListIterateeCustom.mjs";
+import { ObjectIterateeCustom } from "../_internal/ObjectIteratee.mjs";
+
+//#region src/compat/array/reject.d.ts
+/**
+ * Iterates over the collection and rejects elements based on the given predicate.
+ * If a function is provided, it is invoked for each element in the collection.
+ *
+ * @param {string | null | undefined} collection The string to iterate over
+ * @param {StringIterator<boolean>} [predicate] The function invoked per iteration
+ * @returns {string[]} Returns a new array of characters that do not satisfy the predicate
+ * @example
+ * reject('abc', char => char === 'b')
+ * // => ['a', 'c']
+ */
+declare function reject(collection: string | null | undefined, predicate?: StringIterator<boolean>): string[];
+/**
+ * Iterates over the collection and rejects elements based on the given predicate.
+ * If a function is provided, it is invoked for each element in the collection.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection The array-like to iterate over
+ * @param {ListIterateeCustom<T, boolean>} [predicate] The function invoked per iteration
+ * @returns {T[]} Returns a new array of elements that do not satisfy the predicate
+ * @example
+ * reject([1, 2, 3], num => num % 2 === 0)
+ * // => [1, 3]
+ *
+ * reject([{ a: 1 }, { a: 2 }, { b: 1 }], 'a')
+ * // => [{ b: 1 }]
+ */
+declare function reject<T>(collection: ArrayLike<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): T[];
+/**
+ * Iterates over the collection and rejects elements based on the given predicate.
+ * If a function is provided, it is invoked for each element in the collection.
+ *
+ * @template T
+ * @param {T | null | undefined} collection The object to iterate over
+ * @param {ObjectIterateeCustom<T, boolean>} [predicate] The function invoked per iteration
+ * @returns {Array<T[keyof T]>} Returns a new array of elements that do not satisfy the predicate
+ * @example
+ * reject({ a: 1, b: 2, c: 3 }, value => value % 2 === 0)
+ * // => [1, 3]
+ *
+ * reject({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false })
+ * // => [{ a: 0, b: true }, { a: 1, b: true }]
+ */
+declare function reject<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): Array<T[keyof T]>;
+//#endregion
+export { reject };

tools/ui/node_modules/es-toolkit/dist/compat/array/reject.d.ts

@@ -0,0 +1,51 @@
+import { StringIterator } from "../_internal/StringIterator.js";
+import { ListIterateeCustom } from "../_internal/ListIterateeCustom.js";
+import { ObjectIterateeCustom } from "../_internal/ObjectIteratee.js";
+
+//#region src/compat/array/reject.d.ts
+/**
+ * Iterates over the collection and rejects elements based on the given predicate.
+ * If a function is provided, it is invoked for each element in the collection.
+ *
+ * @param {string | null | undefined} collection The string to iterate over
+ * @param {StringIterator<boolean>} [predicate] The function invoked per iteration
+ * @returns {string[]} Returns a new array of characters that do not satisfy the predicate
+ * @example
+ * reject('abc', char => char === 'b')
+ * // => ['a', 'c']
+ */
+declare function reject(collection: string | null | undefined, predicate?: StringIterator<boolean>): string[];
+/**
+ * Iterates over the collection and rejects elements based on the given predicate.
+ * If a function is provided, it is invoked for each element in the collection.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} collection The array-like to iterate over
+ * @param {ListIterateeCustom<T, boolean>} [predicate] The function invoked per iteration
+ * @returns {T[]} Returns a new array of elements that do not satisfy the predicate
+ * @example
+ * reject([1, 2, 3], num => num % 2 === 0)
+ * // => [1, 3]
+ *
+ * reject([{ a: 1 }, { a: 2 }, { b: 1 }], 'a')
+ * // => [{ b: 1 }]
+ */
+declare function reject<T>(collection: ArrayLike<T> | null | undefined, predicate?: ListIterateeCustom<T, boolean>): T[];
+/**
+ * Iterates over the collection and rejects elements based on the given predicate.
+ * If a function is provided, it is invoked for each element in the collection.
+ *
+ * @template T
+ * @param {T | null | undefined} collection The object to iterate over
+ * @param {ObjectIterateeCustom<T, boolean>} [predicate] The function invoked per iteration
+ * @returns {Array<T[keyof T]>} Returns a new array of elements that do not satisfy the predicate
+ * @example
+ * reject({ a: 1, b: 2, c: 3 }, value => value % 2 === 0)
+ * // => [1, 3]
+ *
+ * reject({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false })
+ * // => [{ a: 0, b: true }, { a: 1, b: true }]
+ */
+declare function reject<T extends object>(collection: T | null | undefined, predicate?: ObjectIterateeCustom<T, boolean>): Array<T[keyof T]>;
+//#endregion
+export { reject };

tools/ui/node_modules/es-toolkit/dist/compat/array/reject.js

@@ -0,0 +1,32 @@
+const require_identity = require("../../function/identity.js");
+const require_iteratee = require("../util/iteratee.js");
+const require_filter = require("./filter.js");
+const require_negate = require("../function/negate.js");
+//#region src/compat/array/reject.ts
+/**
+* Iterates over the collection and rejects elements based on the given predicate.
+* If a function is provided, it is invoked for each element in the collection.
+*
+* @template T
+* @param {ArrayLike<T> | Record<any, any> | null | undefined} source - The array or object to iterate over.
+* @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+* @returns {T[]} - Returns a new array of elements that do not satisfy the predicate.
+*
+* @example
+* reject([{ a: 1 }, { a: 2 }, { b: 1 }], 'a');
+* // => [{ b: 1 }]
+*
+* reject([{ a: 1 }, { a: 2 }, { b: 1 }], { b: 1 });
+* // => [{ a: 1 }, { a: 2 }]
+*
+* reject({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false })
+* // => [{ a: 0, b: true }, { a: 1, b: true }]
+*
+* reject([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
+* // => [{ a: 1 }, { a: 3 }]
+*/
+function reject(source, predicate = require_identity.identity) {
+	return require_filter.filter(source, require_negate.negate(require_iteratee.iteratee(predicate)));
+}
+//#endregion
+exports.reject = reject;

tools/ui/node_modules/es-toolkit/dist/compat/array/reject.mjs

@@ -0,0 +1,32 @@
+import { identity } from "../../function/identity.mjs";
+import { iteratee } from "../util/iteratee.mjs";
+import { filter } from "./filter.mjs";
+import { negate } from "../function/negate.mjs";
+//#region src/compat/array/reject.ts
+/**
+* Iterates over the collection and rejects elements based on the given predicate.
+* If a function is provided, it is invoked for each element in the collection.
+*
+* @template T
+* @param {ArrayLike<T> | Record<any, any> | null | undefined} source - The array or object to iterate over.
+* @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | PropertyKey} [predicate=identity] - The function invoked per iteration.
+* @returns {T[]} - Returns a new array of elements that do not satisfy the predicate.
+*
+* @example
+* reject([{ a: 1 }, { a: 2 }, { b: 1 }], 'a');
+* // => [{ b: 1 }]
+*
+* reject([{ a: 1 }, { a: 2 }, { b: 1 }], { b: 1 });
+* // => [{ a: 1 }, { a: 2 }]
+*
+* reject({ item1: { a: 0, b: true }, item2: { a: 1, b: true }, item3: { a: 2, b: false }}, { b: false })
+* // => [{ a: 0, b: true }, { a: 1, b: true }]
+*
+* reject([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
+* // => [{ a: 1 }, { a: 3 }]
+*/
+function reject(source, predicate = identity) {
+	return filter(source, negate(iteratee(predicate)));
+}
+//#endregion
+export { reject };

tools/ui/node_modules/es-toolkit/dist/compat/array/remove.d.mts

@@ -0,0 +1,22 @@
+import { ListIteratee } from "../_internal/ListIteratee.mjs";
+import { MutableList } from "../_internal/MutableList.mjs";
+import { RejectReadonly } from "../_internal/RejectReadonly.mjs";
+
+//#region src/compat/array/remove.d.ts
+/**
+ * Removes all elements from array that predicate returns truthy for and returns an array of the removed elements.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {ListIteratee<L[0]>} [predicate] - The function invoked per iteration.
+ * @returns {Array<L[0]>} Returns the new array of removed elements.
+ *
+ * @example
+ * const array = [1, 2, 3, 4];
+ * const evens = remove(array, n => n % 2 === 0);
+ * console.log(array); // => [1, 3]
+ * console.log(evens); // => [2, 4]
+ */
+declare function remove<L extends MutableList<any>>(array: RejectReadonly<L>, predicate?: ListIteratee<L[0]>): Array<L[0]>;
+//#endregion
+export { remove };

tools/ui/node_modules/es-toolkit/dist/compat/array/remove.d.ts

@@ -0,0 +1,22 @@
+import { ListIteratee } from "../_internal/ListIteratee.js";
+import { MutableList } from "../_internal/MutableList.js";
+import { RejectReadonly } from "../_internal/RejectReadonly.js";
+
+//#region src/compat/array/remove.d.ts
+/**
+ * Removes all elements from array that predicate returns truthy for and returns an array of the removed elements.
+ *
+ * @template L
+ * @param {RejectReadonly<L>} array - The array to modify.
+ * @param {ListIteratee<L[0]>} [predicate] - The function invoked per iteration.
+ * @returns {Array<L[0]>} Returns the new array of removed elements.
+ *
+ * @example
+ * const array = [1, 2, 3, 4];
+ * const evens = remove(array, n => n % 2 === 0);
+ * console.log(array); // => [1, 3]
+ * console.log(evens); // => [2, 4]
+ */
+declare function remove<L extends MutableList<any>>(array: RejectReadonly<L>, predicate?: ListIteratee<L[0]>): Array<L[0]>;
+//#endregion
+export { remove };

tools/ui/node_modules/es-toolkit/dist/compat/array/remove.js

@@ -0,0 +1,36 @@
+const require_remove = require("../../array/remove.js");
+const require_identity = require("../../function/identity.js");
+const require_iteratee = require("../util/iteratee.js");
+//#region src/compat/array/remove.ts
+/**
+* Removes elements from an array based on various criteria.
+*
+* @param {ArrayLike<T>} arr - The array to iterate over.
+* @param {(value: T, index: number, arr: ArrayLike<T>) => boolean | Partial<T> | [keyof T, unknown] | keyof T} shouldRemoveElement - The function invoked per iteration, a partial object, a property-value pair, or a key to match against each element.
+* @returns {T[]} - Returns the modified array with the specified elements removed.
+*
+* @example
+* // Using a predicate function
+* const numbers = [1, 2, 3, 4, 5];
+* remove(numbers, value => value % 2 === 0); // => [1, 3, 5]
+*
+* @example
+* // Using a partial object
+* const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+* remove(objects, { a: 1 }); // => [{ a: 2 }, { a: 3 }]
+*
+* @example
+* // Using a property-value pair
+* const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+* remove(objects, ['a', 1]); // => [{ a: 2 }, { a: 3 }]
+*
+* @example
+* // Using a property key
+* const objects = [{ a: 0 }, { a: 1 }];
+* remove(objects, 'a'); // => [{ a: 0 }]
+*/
+function remove(arr, shouldRemoveElement = require_identity.identity) {
+	return require_remove.remove(arr, require_iteratee.iteratee(shouldRemoveElement));
+}
+//#endregion
+exports.remove = remove;

tools/ui/node_modules/es-toolkit/dist/compat/array/remove.mjs

@@ -0,0 +1,36 @@
+import { remove as remove$1 } from "../../array/remove.mjs";
+import { identity } from "../../function/identity.mjs";
+import { iteratee } from "../util/iteratee.mjs";
+//#region src/compat/array/remove.ts
+/**
+* Removes elements from an array based on various criteria.
+*
+* @param {ArrayLike<T>} arr - The array to iterate over.
+* @param {(value: T, index: number, arr: ArrayLike<T>) => boolean | Partial<T> | [keyof T, unknown] | keyof T} shouldRemoveElement - The function invoked per iteration, a partial object, a property-value pair, or a key to match against each element.
+* @returns {T[]} - Returns the modified array with the specified elements removed.
+*
+* @example
+* // Using a predicate function
+* const numbers = [1, 2, 3, 4, 5];
+* remove(numbers, value => value % 2 === 0); // => [1, 3, 5]
+*
+* @example
+* // Using a partial object
+* const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+* remove(objects, { a: 1 }); // => [{ a: 2 }, { a: 3 }]
+*
+* @example
+* // Using a property-value pair
+* const objects = [{ a: 1 }, { a: 2 }, { a: 3 }];
+* remove(objects, ['a', 1]); // => [{ a: 2 }, { a: 3 }]
+*
+* @example
+* // Using a property key
+* const objects = [{ a: 0 }, { a: 1 }];
+* remove(objects, 'a'); // => [{ a: 0 }]
+*/
+function remove(arr, shouldRemoveElement = identity) {
+	return remove$1(arr, iteratee(shouldRemoveElement));
+}
+//#endregion
+export { remove };

tools/ui/node_modules/es-toolkit/dist/compat/array/reverse.d.mts

@@ -0,0 +1,19 @@
+import { MutableList } from "../_internal/MutableList.mjs";
+import { RejectReadonly } from "../_internal/RejectReadonly.mjs";
+
+//#region src/compat/array/reverse.d.ts
+/**
+ * Reverses `array` so that the first element becomes the last, the second element becomes the second to last, and so on.
+ *
+ * @template L
+ * @param {L extends readonly any[] ? never : L} array - The array to reverse.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * reverse(array);
+ * // => [3, 2, 1]
+ */
+declare function reverse<L extends MutableList<any>>(array: RejectReadonly<L>): L;
+//#endregion
+export { reverse };

tools/ui/node_modules/es-toolkit/dist/compat/array/reverse.d.ts

@@ -0,0 +1,19 @@
+import { MutableList } from "../_internal/MutableList.js";
+import { RejectReadonly } from "../_internal/RejectReadonly.js";
+
+//#region src/compat/array/reverse.d.ts
+/**
+ * Reverses `array` so that the first element becomes the last, the second element becomes the second to last, and so on.
+ *
+ * @template L
+ * @param {L extends readonly any[] ? never : L} array - The array to reverse.
+ * @returns {L} Returns `array`.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * reverse(array);
+ * // => [3, 2, 1]
+ */
+declare function reverse<L extends MutableList<any>>(array: RejectReadonly<L>): L;
+//#endregion
+export { reverse };

tools/ui/node_modules/es-toolkit/dist/compat/array/reverse.js

@@ -0,0 +1,28 @@
+//#region src/compat/array/reverse.ts
+/**
+* Reverses the elements of an array in place.
+*
+* This function takes an array and reverses its elements in place, modifying the original array.
+* If the input is `null` or `undefined`, it returns the input as is.
+*
+* @template T - The type of elements in the array.
+* @param {T[] | null | undefined} array - The array to reverse. If `null` or `undefined`, the input is returned as is.
+* @returns {T[] | null | undefined} The reversed array, or `null`/`undefined` if the input was `null`/`undefined`.
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const reversedArray = reverse(array);
+* // reversedArray is [5, 4, 3, 2, 1], and array is also modified to [5, 4, 3, 2, 1].
+*
+* const emptyArray = reverse([]);
+* // emptyArray is [].
+*
+* const nullArray = reverse(null);
+* // nullArray is null.
+*/
+function reverse(array) {
+	if (array == null) return array;
+	return array.reverse();
+}
+//#endregion
+exports.reverse = reverse;

tools/ui/node_modules/es-toolkit/dist/compat/array/reverse.mjs

@@ -0,0 +1,28 @@
+//#region src/compat/array/reverse.ts
+/**
+* Reverses the elements of an array in place.
+*
+* This function takes an array and reverses its elements in place, modifying the original array.
+* If the input is `null` or `undefined`, it returns the input as is.
+*
+* @template T - The type of elements in the array.
+* @param {T[] | null | undefined} array - The array to reverse. If `null` or `undefined`, the input is returned as is.
+* @returns {T[] | null | undefined} The reversed array, or `null`/`undefined` if the input was `null`/`undefined`.
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const reversedArray = reverse(array);
+* // reversedArray is [5, 4, 3, 2, 1], and array is also modified to [5, 4, 3, 2, 1].
+*
+* const emptyArray = reverse([]);
+* // emptyArray is [].
+*
+* const nullArray = reverse(null);
+* // nullArray is null.
+*/
+function reverse(array) {
+	if (array == null) return array;
+	return array.reverse();
+}
+//#endregion
+export { reverse };

tools/ui/node_modules/es-toolkit/dist/compat/array/sample.d.mts

@@ -0,0 +1,39 @@
+//#region src/compat/array/sample.d.ts
+/**
+ * Gets a random element from collection.
+ *
+ * @template T
+ * @param {readonly [T, ...T[]]} collection - The collection to sample.
+ * @returns {T} Returns the random element.
+ *
+ * @example
+ * sample([1, 2, 3, 4]);
+ * // => 2
+ */
+declare function sample<T>(collection: readonly [T, ...T[]]): T;
+/**
+ * Gets a random element from collection.
+ *
+ * @template T
+ * @param {Record<string, T> | Record<number, T> | null | undefined} collection - The collection to sample.
+ * @returns {T | undefined} Returns the random element.
+ *
+ * @example
+ * sample({ 'a': 1, 'b': 2, 'c': 3 });
+ * // => 2
+ */
+declare function sample<T>(collection: Record<string, T> | Record<number, T> | null | undefined): T | undefined;
+/**
+ * Gets a random element from collection.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The collection to sample.
+ * @returns {T[keyof T] | undefined} Returns the random element.
+ *
+ * @example
+ * sample({ 'a': 1, 'b': 2, 'c': 3 });
+ * // => 2
+ */
+declare function sample<T extends object>(collection: T | null | undefined): T[keyof T] | undefined;
+//#endregion
+export { sample };

tools/ui/node_modules/es-toolkit/dist/compat/array/sample.d.ts

@@ -0,0 +1,39 @@
+//#region src/compat/array/sample.d.ts
+/**
+ * Gets a random element from collection.
+ *
+ * @template T
+ * @param {readonly [T, ...T[]]} collection - The collection to sample.
+ * @returns {T} Returns the random element.
+ *
+ * @example
+ * sample([1, 2, 3, 4]);
+ * // => 2
+ */
+declare function sample<T>(collection: readonly [T, ...T[]]): T;
+/**
+ * Gets a random element from collection.
+ *
+ * @template T
+ * @param {Record<string, T> | Record<number, T> | null | undefined} collection - The collection to sample.
+ * @returns {T | undefined} Returns the random element.
+ *
+ * @example
+ * sample({ 'a': 1, 'b': 2, 'c': 3 });
+ * // => 2
+ */
+declare function sample<T>(collection: Record<string, T> | Record<number, T> | null | undefined): T | undefined;
+/**
+ * Gets a random element from collection.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The collection to sample.
+ * @returns {T[keyof T] | undefined} Returns the random element.
+ *
+ * @example
+ * sample({ 'a': 1, 'b': 2, 'c': 3 });
+ * // => 2
+ */
+declare function sample<T extends object>(collection: T | null | undefined): T[keyof T] | undefined;
+//#endregion
+export { sample };

tools/ui/node_modules/es-toolkit/dist/compat/array/sample.js

@@ -0,0 +1,21 @@
+const require_sample = require("../../array/sample.js");
+const require_toArray = require("../_internal/toArray.js");
+const require_isArrayLike = require("../predicate/isArrayLike.js");
+//#region src/compat/array/sample.ts
+/**
+* The implementation for the overloaded sample function.
+*
+* This function takes an array, string, or object and returns a single element selected randomly.
+* If the input is empty, or if it's null or undefined, the function returns `undefined`.
+*
+* @template T - The type of elements in the collection.
+* @param {ArrayLike<T> | Record<string, T>} collection - The collection to sample from.
+* @returns {T | string | undefined} A random element from the collection, or `undefined` if the collection is empty or invalid.
+*/
+function sample(collection) {
+	if (collection == null) return;
+	if (require_isArrayLike.isArrayLike(collection)) return require_sample.sample(require_toArray.toArray(collection));
+	return require_sample.sample(Object.values(collection));
+}
+//#endregion
+exports.sample = sample;

tools/ui/node_modules/es-toolkit/dist/compat/array/sample.mjs

@@ -0,0 +1,21 @@
+import { sample as sample$1 } from "../../array/sample.mjs";
+import { toArray } from "../_internal/toArray.mjs";
+import { isArrayLike } from "../predicate/isArrayLike.mjs";
+//#region src/compat/array/sample.ts
+/**
+* The implementation for the overloaded sample function.
+*
+* This function takes an array, string, or object and returns a single element selected randomly.
+* If the input is empty, or if it's null or undefined, the function returns `undefined`.
+*
+* @template T - The type of elements in the collection.
+* @param {ArrayLike<T> | Record<string, T>} collection - The collection to sample from.
+* @returns {T | string | undefined} A random element from the collection, or `undefined` if the collection is empty or invalid.
+*/
+function sample(collection) {
+	if (collection == null) return;
+	if (isArrayLike(collection)) return sample$1(toArray(collection));
+	return sample$1(Object.values(collection));
+}
+//#endregion
+export { sample };

tools/ui/node_modules/es-toolkit/dist/compat/array/sampleSize.d.mts

@@ -0,0 +1,29 @@
+//#region src/compat/array/sampleSize.d.ts
+/**
+ * Returns a sample element array of a specified size from a collection.
+ *
+ * @template T
+ * @param {Record<string, T> | Record<number, T> | null | undefined} collection - The collection to sample from.
+ * @param {number} [n] - The size of sample.
+ * @returns {T[]} A new array with sample size applied.
+ *
+ * @example
+ * sampleSize([1, 2, 3], 2);
+ * // => [2, 3] (example, actual result will vary)
+ */
+declare function sampleSize<T>(collection: Record<string, T> | Record<number, T> | null | undefined, n?: number): T[];
+/**
+ * Returns a sample element array of a specified size from an object.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to sample from.
+ * @param {number} [n] - The size of sample.
+ * @returns {Array<T[keyof T]>} A new array with sample size applied.
+ *
+ * @example
+ * sampleSize({ a: 1, b: 2, c: 3 }, 2);
+ * // => [2, 3] (example, actual result will vary)
+ */
+declare function sampleSize<T extends object>(collection: T | null | undefined, n?: number): Array<T[keyof T]>;
+//#endregion
+export { sampleSize };

tools/ui/node_modules/es-toolkit/dist/compat/array/sampleSize.d.ts

@@ -0,0 +1,29 @@
+//#region src/compat/array/sampleSize.d.ts
+/**
+ * Returns a sample element array of a specified size from a collection.
+ *
+ * @template T
+ * @param {Record<string, T> | Record<number, T> | null | undefined} collection - The collection to sample from.
+ * @param {number} [n] - The size of sample.
+ * @returns {T[]} A new array with sample size applied.
+ *
+ * @example
+ * sampleSize([1, 2, 3], 2);
+ * // => [2, 3] (example, actual result will vary)
+ */
+declare function sampleSize<T>(collection: Record<string, T> | Record<number, T> | null | undefined, n?: number): T[];
+/**
+ * Returns a sample element array of a specified size from an object.
+ *
+ * @template T
+ * @param {T | null | undefined} collection - The object to sample from.
+ * @param {number} [n] - The size of sample.
+ * @returns {Array<T[keyof T]>} A new array with sample size applied.
+ *
+ * @example
+ * sampleSize({ a: 1, b: 2, c: 3 }, 2);
+ * // => [2, 3] (example, actual result will vary)
+ */
+declare function sampleSize<T extends object>(collection: T | null | undefined, n?: number): Array<T[keyof T]>;
+//#endregion
+export { sampleSize };

tools/ui/node_modules/es-toolkit/dist/compat/array/sampleSize.js

@@ -0,0 +1,31 @@
+const require_sampleSize = require("../../array/sampleSize.js");
+const require_toInteger = require("../util/toInteger.js");
+const require_isIterateeCall = require("../_internal/isIterateeCall.js");
+const require_clamp = require("../math/clamp.js");
+const require_toArray = require("../util/toArray.js");
+//#region src/compat/array/sampleSize.ts
+/**
+* Returns a sample element array of a specified `size`.
+*
+* This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
+*
+* {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algorithm}
+*
+* @template T - The type of elements in the array.
+* @param {Record<string, T> | Record<number, T> | T | null | undefined} collection - The array to sample from.
+* @param {number} size - The size of sample.
+* @returns {Array<T[keyof T]> | T[]} A new array with sample size applied.
+*
+* @example
+* const result = sampleSize([1, 2, 3], 2)
+* // result will be an array containing two of the elements from the collection.
+* // [1, 2] or [1, 3] or [2, 3]
+*/
+function sampleSize(collection, size, guard) {
+	const arrayCollection = require_toArray.toArray(collection);
+	if (guard ? require_isIterateeCall.isIterateeCall(collection, size, guard) : size === void 0) size = 1;
+	else size = require_clamp.clamp(require_toInteger.toInteger(size), 0, arrayCollection.length);
+	return require_sampleSize.sampleSize(arrayCollection, size);
+}
+//#endregion
+exports.sampleSize = sampleSize;