Upload folder using huggingface_hub (part 35)

tools/ui/node_modules/es-toolkit/dist/compat/util/toSafeInteger.d.ts

@@ -0,0 +1,21 @@
+//#region src/compat/util/toSafeInteger.d.ts
+/**
+ * Converts `value` to a safe integer.
+ *
+ * A safe integer can be compared and represented correctly.
+ *
+ * @param {any} value - The value to convert.
+ * @returns {number} Returns the value converted to a safe integer.
+ *
+ * @example
+ * toSafeInteger(3.2); // => 3
+ * toSafeInteger(Number.MAX_VALUE); // => 9007199254740991
+ * toSafeInteger(Infinity); // => 9007199254740991
+ * toSafeInteger('3.2'); // => 3
+ * toSafeInteger(NaN); // => 0
+ * toSafeInteger(null); // => 0
+ * toSafeInteger(-Infinity); // => -9007199254740991
+ */
+declare function toSafeInteger(value: any): number;
+//#endregion
+export { toSafeInteger };

tools/ui/node_modules/es-toolkit/dist/compat/util/toSafeInteger.js

@@ -0,0 +1,27 @@
+const require_toInteger = require("./toInteger.js");
+const require_clamp = require("../math/clamp.js");
+const require_MAX_SAFE_INTEGER = require("../_internal/MAX_SAFE_INTEGER.js");
+//#region src/compat/util/toSafeInteger.ts
+/**
+* Converts `value` to a safe integer.
+*
+* A safe integer can be compared and represented correctly.
+*
+* @param {any} value - The value to convert.
+* @returns {number} Returns the value converted to a safe integer.
+*
+* @example
+* toSafeInteger(3.2); // => 3
+* toSafeInteger(Number.MAX_VALUE); // => 9007199254740991
+* toSafeInteger(Infinity); // => 9007199254740991
+* toSafeInteger('3.2'); // => 3
+* toSafeInteger(NaN); // => 0
+* toSafeInteger(null); // => 0
+* toSafeInteger(-Infinity); // => -9007199254740991
+*/
+function toSafeInteger(value) {
+	if (value == null) return 0;
+	return require_clamp.clamp(require_toInteger.toInteger(value), -require_MAX_SAFE_INTEGER.MAX_SAFE_INTEGER, require_MAX_SAFE_INTEGER.MAX_SAFE_INTEGER);
+}
+//#endregion
+exports.toSafeInteger = toSafeInteger;

tools/ui/node_modules/es-toolkit/dist/compat/util/toSafeInteger.mjs

@@ -0,0 +1,27 @@
+import { toInteger } from "./toInteger.mjs";
+import { clamp } from "../math/clamp.mjs";
+import { MAX_SAFE_INTEGER } from "../_internal/MAX_SAFE_INTEGER.mjs";
+//#region src/compat/util/toSafeInteger.ts
+/**
+* Converts `value` to a safe integer.
+*
+* A safe integer can be compared and represented correctly.
+*
+* @param {any} value - The value to convert.
+* @returns {number} Returns the value converted to a safe integer.
+*
+* @example
+* toSafeInteger(3.2); // => 3
+* toSafeInteger(Number.MAX_VALUE); // => 9007199254740991
+* toSafeInteger(Infinity); // => 9007199254740991
+* toSafeInteger('3.2'); // => 3
+* toSafeInteger(NaN); // => 0
+* toSafeInteger(null); // => 0
+* toSafeInteger(-Infinity); // => -9007199254740991
+*/
+function toSafeInteger(value) {
+	if (value == null) return 0;
+	return clamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+}
+//#endregion
+export { toSafeInteger };

tools/ui/node_modules/es-toolkit/dist/compat/util/toString.d.mts

@@ -0,0 +1,20 @@
+//#region src/compat/util/toString.d.ts
+/**
+ * Converts `value` to a string.
+ *
+ * An empty string is returned for `null` and `undefined` values.
+ * The sign of `-0` is preserved.
+ *
+ * @param {any} value - The value to convert.
+ * @returns {string} Returns the converted string.
+ *
+ * @example
+ * toString(null) // returns ''
+ * toString(undefined) // returns ''
+ * toString(-0) // returns '-0'
+ * toString([1, 2, -0]) // returns '1,2,-0'
+ * toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)'
+ */
+declare function toString(value: any): string;
+//#endregion
+export { toString };

tools/ui/node_modules/es-toolkit/dist/compat/util/toString.d.ts

@@ -0,0 +1,20 @@
+//#region src/compat/util/toString.d.ts
+/**
+ * Converts `value` to a string.
+ *
+ * An empty string is returned for `null` and `undefined` values.
+ * The sign of `-0` is preserved.
+ *
+ * @param {any} value - The value to convert.
+ * @returns {string} Returns the converted string.
+ *
+ * @example
+ * toString(null) // returns ''
+ * toString(undefined) // returns ''
+ * toString(-0) // returns '-0'
+ * toString([1, 2, -0]) // returns '1,2,-0'
+ * toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)'
+ */
+declare function toString(value: any): string;
+//#endregion
+export { toString };

tools/ui/node_modules/es-toolkit/dist/compat/util/toString.js

@@ -0,0 +1,27 @@
+//#region src/compat/util/toString.ts
+/**
+* Converts `value` to a string.
+*
+* An empty string is returned for `null` and `undefined` values.
+* The sign of `-0` is preserved.
+*
+* @param {any} value - The value to convert.
+* @returns {string} Returns the converted string.
+*
+* @example
+* toString(null) // returns ''
+* toString(undefined) // returns ''
+* toString(-0) // returns '-0'
+* toString([1, 2, -0]) // returns '1,2,-0'
+* toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)'
+*/
+function toString(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(toString).join(",");
+	const result = String(value);
+	if (result === "0" && Object.is(Number(value), -0)) return "-0";
+	return result;
+}
+//#endregion
+exports.toString = toString;

tools/ui/node_modules/es-toolkit/dist/compat/util/toString.mjs

@@ -0,0 +1,27 @@
+//#region src/compat/util/toString.ts
+/**
+* Converts `value` to a string.
+*
+* An empty string is returned for `null` and `undefined` values.
+* The sign of `-0` is preserved.
+*
+* @param {any} value - The value to convert.
+* @returns {string} Returns the converted string.
+*
+* @example
+* toString(null) // returns ''
+* toString(undefined) // returns ''
+* toString(-0) // returns '-0'
+* toString([1, 2, -0]) // returns '1,2,-0'
+* toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)'
+*/
+function toString(value) {
+	if (value == null) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map(toString).join(",");
+	const result = String(value);
+	if (result === "0" && Object.is(Number(value), -0)) return "-0";
+	return result;
+}
+//#endregion
+export { toString };

tools/ui/node_modules/es-toolkit/dist/compat/util/uniqueId.d.mts

@@ -0,0 +1,26 @@
+//#region src/compat/util/uniqueId.d.ts
+/**
+ * Generates a unique identifier, optionally prefixed with a given string.
+ *
+ * @param {string} [prefix] - An optional string to prefix the unique identifier.
+ *                            If not provided or not a string, only the unique
+ *                            numeric identifier is returned.
+ * @returns {string} A string containing the unique identifier, with the optional
+ *                   prefix if provided.
+ *
+ * @example
+ * // Generate a unique ID with a prefix
+ * uniqueId('user_');  // => 'user_1'
+ *
+ * @example
+ * // Generate a unique ID without a prefix
+ * uniqueId();  // => '2'
+ *
+ * @example
+ * // Subsequent calls increment the internal counter
+ * uniqueId('item_');  // => 'item_3'
+ * uniqueId();         // => '4'
+ */
+declare function uniqueId(prefix?: string): string;
+//#endregion
+export { uniqueId };

tools/ui/node_modules/es-toolkit/dist/compat/util/uniqueId.d.ts

@@ -0,0 +1,26 @@
+//#region src/compat/util/uniqueId.d.ts
+/**
+ * Generates a unique identifier, optionally prefixed with a given string.
+ *
+ * @param {string} [prefix] - An optional string to prefix the unique identifier.
+ *                            If not provided or not a string, only the unique
+ *                            numeric identifier is returned.
+ * @returns {string} A string containing the unique identifier, with the optional
+ *                   prefix if provided.
+ *
+ * @example
+ * // Generate a unique ID with a prefix
+ * uniqueId('user_');  // => 'user_1'
+ *
+ * @example
+ * // Generate a unique ID without a prefix
+ * uniqueId();  // => '2'
+ *
+ * @example
+ * // Subsequent calls increment the internal counter
+ * uniqueId('item_');  // => 'item_3'
+ * uniqueId();         // => '4'
+ */
+declare function uniqueId(prefix?: string): string;
+//#endregion
+export { uniqueId };

tools/ui/node_modules/es-toolkit/dist/compat/util/uniqueId.js

@@ -0,0 +1,30 @@
+//#region src/compat/util/uniqueId.ts
+/** Counter used to generate unique numeric identifiers. */
+let idCounter = 0;
+/**
+* Generates a unique identifier, optionally prefixed with a given string.
+*
+* @param {string} [prefix] - An optional string to prefix the unique identifier.
+*                            If not provided or not a string, only the unique
+*                            numeric identifier is returned.
+* @returns {string} A string containing the unique identifier, with the optional
+*                   prefix if provided.
+*
+* @example
+* // Generate a unique ID with a prefix
+* uniqueId('user_');  // => 'user_1'
+*
+* @example
+* // Generate a unique ID without a prefix
+* uniqueId();  // => '2'
+*
+* @example
+* // Subsequent calls increment the internal counter
+* uniqueId('item_');  // => 'item_3'
+* uniqueId();         // => '4'
+*/
+function uniqueId(prefix = "") {
+	return `${prefix}${++idCounter}`;
+}
+//#endregion
+exports.uniqueId = uniqueId;

tools/ui/node_modules/es-toolkit/dist/compat/util/uniqueId.mjs

@@ -0,0 +1,30 @@
+//#region src/compat/util/uniqueId.ts
+/** Counter used to generate unique numeric identifiers. */
+let idCounter = 0;
+/**
+* Generates a unique identifier, optionally prefixed with a given string.
+*
+* @param {string} [prefix] - An optional string to prefix the unique identifier.
+*                            If not provided or not a string, only the unique
+*                            numeric identifier is returned.
+* @returns {string} A string containing the unique identifier, with the optional
+*                   prefix if provided.
+*
+* @example
+* // Generate a unique ID with a prefix
+* uniqueId('user_');  // => 'user_1'
+*
+* @example
+* // Generate a unique ID without a prefix
+* uniqueId();  // => '2'
+*
+* @example
+* // Subsequent calls increment the internal counter
+* uniqueId('item_');  // => 'item_3'
+* uniqueId();         // => '4'
+*/
+function uniqueId(prefix = "") {
+	return `${prefix}${++idCounter}`;
+}
+//#endregion
+export { uniqueId };

tools/ui/node_modules/es-toolkit/dist/error/AbortError.d.mts

@@ -0,0 +1,12 @@
+import { DOMException } from "../_internal/DOMException.mjs";
+
+//#region src/error/AbortError.d.ts
+/**
+ * An error class representing an aborted operation.
+ * @augments DOMException
+ */
+declare class AbortError extends DOMException {
+  constructor(message?: string);
+}
+//#endregion
+export { AbortError };

tools/ui/node_modules/es-toolkit/dist/error/AbortError.d.ts

@@ -0,0 +1,12 @@
+import { DOMException } from "../_internal/DOMException.js";
+
+//#region src/error/AbortError.d.ts
+/**
+ * An error class representing an aborted operation.
+ * @augments DOMException
+ */
+declare class AbortError extends DOMException {
+  constructor(message?: string);
+}
+//#endregion
+export { AbortError };

tools/ui/node_modules/es-toolkit/dist/error/AbortError.js

@@ -0,0 +1,13 @@
+const require_DOMException = require("../_internal/DOMException.js");
+//#region src/error/AbortError.ts
+/**
+* An error class representing an aborted operation.
+* @augments DOMException
+*/
+var AbortError = class extends require_DOMException.DOMException {
+	constructor(message = "The operation was aborted") {
+		super(message);
+	}
+};
+//#endregion
+exports.AbortError = AbortError;

tools/ui/node_modules/es-toolkit/dist/error/AbortError.mjs

@@ -0,0 +1,13 @@
+import { DOMException } from "../_internal/DOMException.mjs";
+//#region src/error/AbortError.ts
+/**
+* An error class representing an aborted operation.
+* @augments DOMException
+*/
+var AbortError = class extends DOMException {
+	constructor(message = "The operation was aborted") {
+		super(message);
+	}
+};
+//#endregion
+export { AbortError };

tools/ui/node_modules/es-toolkit/dist/error/TimeoutError.d.mts

@@ -0,0 +1,12 @@
+import { DOMException } from "../_internal/DOMException.mjs";
+
+//#region src/error/TimeoutError.d.ts
+/**
+ * An error class representing a timeout operation.
+ * @augments DOMException
+ */
+declare class TimeoutError extends DOMException {
+  constructor(message?: string);
+}
+//#endregion
+export { TimeoutError };

tools/ui/node_modules/es-toolkit/dist/error/TimeoutError.d.ts

@@ -0,0 +1,12 @@
+import { DOMException } from "../_internal/DOMException.js";
+
+//#region src/error/TimeoutError.d.ts
+/**
+ * An error class representing a timeout operation.
+ * @augments DOMException
+ */
+declare class TimeoutError extends DOMException {
+  constructor(message?: string);
+}
+//#endregion
+export { TimeoutError };

tools/ui/node_modules/es-toolkit/dist/error/TimeoutError.js

@@ -0,0 +1,13 @@
+const require_DOMException = require("../_internal/DOMException.js");
+//#region src/error/TimeoutError.ts
+/**
+* An error class representing a timeout operation.
+* @augments DOMException
+*/
+var TimeoutError = class extends require_DOMException.DOMException {
+	constructor(message = "The operation was timed out") {
+		super(message);
+	}
+};
+//#endregion
+exports.TimeoutError = TimeoutError;

tools/ui/node_modules/es-toolkit/dist/error/TimeoutError.mjs

@@ -0,0 +1,13 @@
+import { DOMException } from "../_internal/DOMException.mjs";
+//#region src/error/TimeoutError.ts
+/**
+* An error class representing a timeout operation.
+* @augments DOMException
+*/
+var TimeoutError = class extends DOMException {
+	constructor(message = "The operation was timed out") {
+		super(message);
+	}
+};
+//#endregion
+export { TimeoutError };

tools/ui/node_modules/es-toolkit/dist/error/index.d.mts

@@ -0,0 +1,3 @@
+import { AbortError } from "./AbortError.mjs";
+import { TimeoutError } from "./TimeoutError.mjs";
+export { AbortError, TimeoutError };

tools/ui/node_modules/es-toolkit/dist/error/index.d.ts

@@ -0,0 +1,3 @@
+import { AbortError } from "./AbortError.js";
+import { TimeoutError } from "./TimeoutError.js";
+export { AbortError, TimeoutError };

tools/ui/node_modules/es-toolkit/dist/error/index.js

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_AbortError = require("./AbortError.js");
+const require_TimeoutError = require("./TimeoutError.js");
+exports.AbortError = require_AbortError.AbortError;
+exports.TimeoutError = require_TimeoutError.TimeoutError;

tools/ui/node_modules/es-toolkit/dist/error/index.mjs

@@ -0,0 +1,3 @@
+import { AbortError } from "./AbortError.mjs";
+import { TimeoutError } from "./TimeoutError.mjs";
+export { AbortError, TimeoutError };

tools/ui/node_modules/es-toolkit/dist/function/after.d.mts

@@ -0,0 +1,32 @@
+//#region src/function/after.d.ts
+/**
+ * Creates a function that only executes starting from the `n`-th call.
+ * The provided function will be invoked starting from the `n`-th call.
+ *
+ * This is particularly useful for scenarios involving events or asynchronous operations
+ * where an action should occur only after a certain number of invocations.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of calls required for `func` to execute.
+ * @param {F} func - The function to be invoked.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` starting from the `n`-th call.
+ * - Returns `undefined` if fewer than `n` calls have been made.
+ * @throws {Error} - Throws an error if `n` is negative.
+ * @example
+ *
+ * const afterFn = after(3, () => {
+ *  console.log("called")
+ * });
+ *
+ * // Will not log anything.
+ * afterFn()
+ * // Will not log anything.
+ * afterFn()
+ * // Will log 'called'.
+ * afterFn()
+ */
+declare function after<F extends (...args: any[]) => any>(n: number, func: F): (...args: Parameters<F>) => ReturnType<F> | undefined;
+//#endregion
+export { after };

tools/ui/node_modules/es-toolkit/dist/function/after.d.ts

@@ -0,0 +1,32 @@
+//#region src/function/after.d.ts
+/**
+ * Creates a function that only executes starting from the `n`-th call.
+ * The provided function will be invoked starting from the `n`-th call.
+ *
+ * This is particularly useful for scenarios involving events or asynchronous operations
+ * where an action should occur only after a certain number of invocations.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of calls required for `func` to execute.
+ * @param {F} func - The function to be invoked.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` starting from the `n`-th call.
+ * - Returns `undefined` if fewer than `n` calls have been made.
+ * @throws {Error} - Throws an error if `n` is negative.
+ * @example
+ *
+ * const afterFn = after(3, () => {
+ *  console.log("called")
+ * });
+ *
+ * // Will not log anything.
+ * afterFn()
+ * // Will not log anything.
+ * afterFn()
+ * // Will log 'called'.
+ * afterFn()
+ */
+declare function after<F extends (...args: any[]) => any>(n: number, func: F): (...args: Parameters<F>) => ReturnType<F> | undefined;
+//#endregion
+export { after };

tools/ui/node_modules/es-toolkit/dist/function/after.js

@@ -0,0 +1,38 @@
+//#region src/function/after.ts
+/**
+* Creates a function that only executes starting from the `n`-th call.
+* The provided function will be invoked starting from the `n`-th call.
+*
+* This is particularly useful for scenarios involving events or asynchronous operations
+* where an action should occur only after a certain number of invocations.
+*
+* @template F - The type of the function to be invoked.
+* @param {number} n - The number of calls required for `func` to execute.
+* @param {F} func - The function to be invoked.
+* @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+* - Tracks the number of calls.
+* - Invokes `func` starting from the `n`-th call.
+* - Returns `undefined` if fewer than `n` calls have been made.
+* @throws {Error} - Throws an error if `n` is negative.
+* @example
+*
+* const afterFn = after(3, () => {
+*  console.log("called")
+* });
+*
+* // Will not log anything.
+* afterFn()
+* // Will not log anything.
+* afterFn()
+* // Will log 'called'.
+* afterFn()
+*/
+function after(n, func) {
+	if (!Number.isInteger(n) || n < 0) throw new Error(`n must be a non-negative integer.`);
+	let counter = 0;
+	return (...args) => {
+		if (++counter >= n) return func(...args);
+	};
+}
+//#endregion
+exports.after = after;

tools/ui/node_modules/es-toolkit/dist/function/after.mjs

@@ -0,0 +1,38 @@
+//#region src/function/after.ts
+/**
+* Creates a function that only executes starting from the `n`-th call.
+* The provided function will be invoked starting from the `n`-th call.
+*
+* This is particularly useful for scenarios involving events or asynchronous operations
+* where an action should occur only after a certain number of invocations.
+*
+* @template F - The type of the function to be invoked.
+* @param {number} n - The number of calls required for `func` to execute.
+* @param {F} func - The function to be invoked.
+* @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+* - Tracks the number of calls.
+* - Invokes `func` starting from the `n`-th call.
+* - Returns `undefined` if fewer than `n` calls have been made.
+* @throws {Error} - Throws an error if `n` is negative.
+* @example
+*
+* const afterFn = after(3, () => {
+*  console.log("called")
+* });
+*
+* // Will not log anything.
+* afterFn()
+* // Will not log anything.
+* afterFn()
+* // Will log 'called'.
+* afterFn()
+*/
+function after(n, func) {
+	if (!Number.isInteger(n) || n < 0) throw new Error(`n must be a non-negative integer.`);
+	let counter = 0;
+	return (...args) => {
+		if (++counter >= n) return func(...args);
+	};
+}
+//#endregion
+export { after };

tools/ui/node_modules/es-toolkit/dist/function/ary.d.mts

@@ -0,0 +1,22 @@
+//#region src/function/ary.d.ts
+/**
+ * Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.
+ *
+ * @template F - The type of the function.
+ * @param {F} func - The function to cap arguments for.
+ * @param {number} n - The arity cap.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+ *
+ * @example
+ * function fn(a: number, b: number, c: number) {
+ *   return Array.from(arguments);
+ * }
+ *
+ * ary(fn, 0)(1, 2, 3) // []
+ * ary(fn, 1)(1, 2, 3) // [1]
+ * ary(fn, 2)(1, 2, 3) // [1, 2]
+ * ary(fn, 3)(1, 2, 3) // [1, 2, 3]
+ */
+declare function ary<F extends (...args: any[]) => any>(func: F, n: number): (...args: any[]) => ReturnType<F>;
+//#endregion
+export { ary };

tools/ui/node_modules/es-toolkit/dist/function/ary.d.ts

@@ -0,0 +1,22 @@
+//#region src/function/ary.d.ts
+/**
+ * Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.
+ *
+ * @template F - The type of the function.
+ * @param {F} func - The function to cap arguments for.
+ * @param {number} n - The arity cap.
+ * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+ *
+ * @example
+ * function fn(a: number, b: number, c: number) {
+ *   return Array.from(arguments);
+ * }
+ *
+ * ary(fn, 0)(1, 2, 3) // []
+ * ary(fn, 1)(1, 2, 3) // [1]
+ * ary(fn, 2)(1, 2, 3) // [1, 2]
+ * ary(fn, 3)(1, 2, 3) // [1, 2, 3]
+ */
+declare function ary<F extends (...args: any[]) => any>(func: F, n: number): (...args: any[]) => ReturnType<F>;
+//#endregion
+export { ary };

tools/ui/node_modules/es-toolkit/dist/function/ary.js

@@ -0,0 +1,26 @@
+//#region src/function/ary.ts
+/**
+* Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.
+*
+* @template F - The type of the function.
+* @param {F} func - The function to cap arguments for.
+* @param {number} n - The arity cap.
+* @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+*
+* @example
+* function fn(a: number, b: number, c: number) {
+*   return Array.from(arguments);
+* }
+*
+* ary(fn, 0)(1, 2, 3) // []
+* ary(fn, 1)(1, 2, 3) // [1]
+* ary(fn, 2)(1, 2, 3) // [1, 2]
+* ary(fn, 3)(1, 2, 3) // [1, 2, 3]
+*/
+function ary(func, n) {
+	return function(...args) {
+		return func.apply(this, args.slice(0, n));
+	};
+}
+//#endregion
+exports.ary = ary;

tools/ui/node_modules/es-toolkit/dist/function/ary.mjs

@@ -0,0 +1,26 @@
+//#region src/function/ary.ts
+/**
+* Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.
+*
+* @template F - The type of the function.
+* @param {F} func - The function to cap arguments for.
+* @param {number} n - The arity cap.
+* @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
+*
+* @example
+* function fn(a: number, b: number, c: number) {
+*   return Array.from(arguments);
+* }
+*
+* ary(fn, 0)(1, 2, 3) // []
+* ary(fn, 1)(1, 2, 3) // [1]
+* ary(fn, 2)(1, 2, 3) // [1, 2]
+* ary(fn, 3)(1, 2, 3) // [1, 2, 3]
+*/
+function ary(func, n) {
+	return function(...args) {
+		return func.apply(this, args.slice(0, n));
+	};
+}
+//#endregion
+export { ary };

tools/ui/node_modules/es-toolkit/dist/function/asyncNoop.d.mts

@@ -0,0 +1,13 @@
+//#region src/function/asyncNoop.d.ts
+/**
+ * An asynchronous no-operation function that does nothing.
+ * This can be used as a placeholder or default function.
+ *
+ * @example
+ * asyncNoop(); // Does nothing
+ *
+ * @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+ */
+declare function asyncNoop(): Promise<void>;
+//#endregion
+export { asyncNoop };

tools/ui/node_modules/es-toolkit/dist/function/asyncNoop.d.ts

@@ -0,0 +1,13 @@
+//#region src/function/asyncNoop.d.ts
+/**
+ * An asynchronous no-operation function that does nothing.
+ * This can be used as a placeholder or default function.
+ *
+ * @example
+ * asyncNoop(); // Does nothing
+ *
+ * @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+ */
+declare function asyncNoop(): Promise<void>;
+//#endregion
+export { asyncNoop };

tools/ui/node_modules/es-toolkit/dist/function/asyncNoop.js

@@ -0,0 +1,13 @@
+//#region src/function/asyncNoop.ts
+/**
+* An asynchronous no-operation function that does nothing.
+* This can be used as a placeholder or default function.
+*
+* @example
+* asyncNoop(); // Does nothing
+*
+* @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+*/
+async function asyncNoop() {}
+//#endregion
+exports.asyncNoop = asyncNoop;

tools/ui/node_modules/es-toolkit/dist/function/asyncNoop.mjs

@@ -0,0 +1,13 @@
+//#region src/function/asyncNoop.ts
+/**
+* An asynchronous no-operation function that does nothing.
+* This can be used as a placeholder or default function.
+*
+* @example
+* asyncNoop(); // Does nothing
+*
+* @returns {Promise<void>} This function returns a Promise that resolves to undefined.
+*/
+async function asyncNoop() {}
+//#endregion
+export { asyncNoop };

tools/ui/node_modules/es-toolkit/dist/function/before.d.mts

@@ -0,0 +1,32 @@
+//#region src/function/before.d.ts
+/**
+ * Creates a function that limits the number of times the given function (`func`) can be called.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+ * - If `n` is 0, `func` will never be called.
+ * - If `n` is a positive integer, `func` will be called up to `n-1` times.
+ * @param {F} func - The function to be called with the limit applied.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` until the `n-1`-th call.
+ * - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls.
+ * @throws {Error} - Throw an error if `n` is negative.
+ * @example
+ *
+ * const beforeFn = before(3, () => {
+ *  console.log("called");
+ * })
+ *
+ * // Will log 'called'.
+ * beforeFn();
+ *
+ * // Will log 'called'.
+ * beforeFn();
+ *
+ * // Will not log anything.
+ * beforeFn();
+ */
+declare function before<F extends (...args: any[]) => any>(n: number, func: F): (...args: Parameters<F>) => ReturnType<F> | undefined;
+//#endregion
+export { before };

tools/ui/node_modules/es-toolkit/dist/function/before.d.ts

@@ -0,0 +1,32 @@
+//#region src/function/before.d.ts
+/**
+ * Creates a function that limits the number of times the given function (`func`) can be called.
+ *
+ * @template F - The type of the function to be invoked.
+ * @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+ * - If `n` is 0, `func` will never be called.
+ * - If `n` is a positive integer, `func` will be called up to `n-1` times.
+ * @param {F} func - The function to be called with the limit applied.
+ * @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+ * - Tracks the number of calls.
+ * - Invokes `func` until the `n-1`-th call.
+ * - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls.
+ * @throws {Error} - Throw an error if `n` is negative.
+ * @example
+ *
+ * const beforeFn = before(3, () => {
+ *  console.log("called");
+ * })
+ *
+ * // Will log 'called'.
+ * beforeFn();
+ *
+ * // Will log 'called'.
+ * beforeFn();
+ *
+ * // Will not log anything.
+ * beforeFn();
+ */
+declare function before<F extends (...args: any[]) => any>(n: number, func: F): (...args: Parameters<F>) => ReturnType<F> | undefined;
+//#endregion
+export { before };

tools/ui/node_modules/es-toolkit/dist/function/before.js

@@ -0,0 +1,38 @@
+//#region src/function/before.ts
+/**
+* Creates a function that limits the number of times the given function (`func`) can be called.
+*
+* @template F - The type of the function to be invoked.
+* @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+* - If `n` is 0, `func` will never be called.
+* - If `n` is a positive integer, `func` will be called up to `n-1` times.
+* @param {F} func - The function to be called with the limit applied.
+* @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+* - Tracks the number of calls.
+* - Invokes `func` until the `n-1`-th call.
+* - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls.
+* @throws {Error} - Throw an error if `n` is negative.
+* @example
+*
+* const beforeFn = before(3, () => {
+*  console.log("called");
+* })
+*
+* // Will log 'called'.
+* beforeFn();
+*
+* // Will log 'called'.
+* beforeFn();
+*
+* // Will not log anything.
+* beforeFn();
+*/
+function before(n, func) {
+	if (!Number.isInteger(n) || n < 0) throw new Error("n must be a non-negative integer.");
+	let counter = 0;
+	return (...args) => {
+		if (++counter < n) return func(...args);
+	};
+}
+//#endregion
+exports.before = before;

tools/ui/node_modules/es-toolkit/dist/function/before.mjs

@@ -0,0 +1,38 @@
+//#region src/function/before.ts
+/**
+* Creates a function that limits the number of times the given function (`func`) can be called.
+*
+* @template F - The type of the function to be invoked.
+* @param {number} n - The number of times the returned function is allowed to call `func` before stopping.
+* - If `n` is 0, `func` will never be called.
+* - If `n` is a positive integer, `func` will be called up to `n-1` times.
+* @param {F} func - The function to be called with the limit applied.
+* @returns {(...args: Parameters<F>) => ReturnType<F> | undefined} - A new function that:
+* - Tracks the number of calls.
+* - Invokes `func` until the `n-1`-th call.
+* - Returns `undefined` if the number of calls reaches or exceeds `n`, stopping further calls.
+* @throws {Error} - Throw an error if `n` is negative.
+* @example
+*
+* const beforeFn = before(3, () => {
+*  console.log("called");
+* })
+*
+* // Will log 'called'.
+* beforeFn();
+*
+* // Will log 'called'.
+* beforeFn();
+*
+* // Will not log anything.
+* beforeFn();
+*/
+function before(n, func) {
+	if (!Number.isInteger(n) || n < 0) throw new Error("n must be a non-negative integer.");
+	let counter = 0;
+	return (...args) => {
+		if (++counter < n) return func(...args);
+	};
+}
+//#endregion
+export { before };

tools/ui/node_modules/es-toolkit/dist/function/curry.d.mts

@@ -0,0 +1,127 @@
+//#region src/function/curry.d.ts
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const curriedNoArgFunc = curry(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curry<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curry(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curry<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *   return a + b;
+ * }
+ * const curriedTwoArgFunc = curry(twoArgFunc);
+ * const add5 = curriedTwoArgFunc(5);
+ * console.log(add5(10)); // 15
+ */
+declare function curry<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ * const curriedThreeArgFunc = curry(threeArgFunc);
+ * const add1 = curriedThreeArgFunc(1);
+ * const add3 = add1(2);
+ * console.log(add3(3)); // 6
+ */
+declare function curry<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add3 = add1(2);
+ * const add6 = add3(3);
+ * console.log(add6(4)); // 10
+ */
+declare function curry<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return a + b + c + d + e;
+ * }
+ * const curriedFiveArgFunc = curry(fiveArgFunc);
+ * const add1 = curriedFiveArgFunc(1);
+ * const add3 = add1(2);
+ * const add6 = add3(3);
+ * const add10 = add6(4);
+ * console.log(add10(5)); // 15
+ */
+declare function curry<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curry(sum);
+ *
+ * // The parameter `a` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5);
+ */
+declare function curry(func: (...args: any[]) => any): (...args: any[]) => any;
+//#endregion
+export { curry };

tools/ui/node_modules/es-toolkit/dist/function/curry.d.ts

@@ -0,0 +1,127 @@
+//#region src/function/curry.d.ts
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const curriedNoArgFunc = curry(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curry<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curry(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curry<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *   return a + b;
+ * }
+ * const curriedTwoArgFunc = curry(twoArgFunc);
+ * const add5 = curriedTwoArgFunc(5);
+ * console.log(add5(10)); // 15
+ */
+declare function curry<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ * const curriedThreeArgFunc = curry(threeArgFunc);
+ * const add1 = curriedThreeArgFunc(1);
+ * const add3 = add1(2);
+ * console.log(add3(3)); // 6
+ */
+declare function curry<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add3 = add1(2);
+ * const add6 = add3(3);
+ * console.log(add6(4)); // 10
+ */
+declare function curry<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return a + b + c + d + e;
+ * }
+ * const curriedFiveArgFunc = curry(fiveArgFunc);
+ * const add1 = curriedFiveArgFunc(1);
+ * const add3 = add1(2);
+ * const add6 = add3(3);
+ * const add10 = add6(4);
+ * console.log(add10(5)); // 15
+ */
+declare function curry<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curry(sum);
+ *
+ * // The parameter `a` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5);
+ */
+declare function curry(func: (...args: any[]) => any): (...args: any[]) => any;
+//#endregion
+export { curry };

tools/ui/node_modules/es-toolkit/dist/function/curry.js

@@ -0,0 +1,41 @@
+//#region src/function/curry.ts
+/**
+* Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+* This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+*
+* @param {(...args: any[]) => any} func - The function to curry.
+* @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+*
+* @example
+* function sum(a: number, b: number, c: number) {
+*   return a + b + c;
+* }
+*
+* const curriedSum = curry(sum);
+*
+* // The parameter `a` should be given the value `10`.
+* const add10 = curriedSum(10);
+*
+* // The parameter `b` should be given the value `15`.
+* const add25 = add10(15);
+*
+* // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+* const result = add25(5);
+*/
+function curry(func) {
+	if (func.length === 0 || func.length === 1) return func;
+	return function(arg) {
+		return makeCurry(func, func.length, [arg]);
+	};
+}
+function makeCurry(origin, argsLength, args) {
+	if (args.length === argsLength) return origin(...args);
+	else {
+		const next = function(arg) {
+			return makeCurry(origin, argsLength, [...args, arg]);
+		};
+		return next;
+	}
+}
+//#endregion
+exports.curry = curry;

tools/ui/node_modules/es-toolkit/dist/function/curry.mjs

@@ -0,0 +1,41 @@
+//#region src/function/curry.ts
+/**
+* Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+* This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+*
+* @param {(...args: any[]) => any} func - The function to curry.
+* @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+*
+* @example
+* function sum(a: number, b: number, c: number) {
+*   return a + b + c;
+* }
+*
+* const curriedSum = curry(sum);
+*
+* // The parameter `a` should be given the value `10`.
+* const add10 = curriedSum(10);
+*
+* // The parameter `b` should be given the value `15`.
+* const add25 = add10(15);
+*
+* // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+* const result = add25(5);
+*/
+function curry(func) {
+	if (func.length === 0 || func.length === 1) return func;
+	return function(arg) {
+		return makeCurry(func, func.length, [arg]);
+	};
+}
+function makeCurry(origin, argsLength, args) {
+	if (args.length === argsLength) return origin(...args);
+	else {
+		const next = function(arg) {
+			return makeCurry(origin, argsLength, [...args, arg]);
+		};
+		return next;
+	}
+}
+//#endregion
+export { curry };

tools/ui/node_modules/es-toolkit/dist/function/curryRight.d.mts

@@ -0,0 +1,141 @@
+//#region src/function/curryRight.d.ts
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ * const curriedNoArgFunc = curryRight(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curryRight<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curryRight(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curryRight<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *  return [a, b];
+ * }
+ * const curriedTwoArgFunc = curryRight(twoArgFunc);
+ * const func = curriedTwoArgFunc(1);
+ * console.log(func(2)); // [2, 1]
+ */
+declare function curryRight<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return [a, b, c];
+ * }
+ * const curriedThreeArgFunc = curryRight(threeArgFunc);
+ * const func = curriedThreeArgFunc(1);
+ * const func2 = func(2);
+ * console.log(func2(3)); // [3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *  return [a, b, c, d];
+ * }
+ * const curriedFourArgFunc = curryRight(fourArgFunc);
+ * const func = curriedFourArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * console.log(func3(4)); // [4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return [a, b, c, d, e];
+ * }
+ * const curriedFiveArgFunc = curryRight(fiveArgFunc);
+ * const func = curriedFiveArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * const func4 = func3(4);
+ * console.log(func4(5)); // [5, 4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curryRight(sum);
+ *
+ * // The parameter `c` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5); // 30
+ */
+declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any;
+//#endregion
+export { curryRight };

tools/ui/node_modules/es-toolkit/dist/function/curryRight.d.ts

@@ -0,0 +1,141 @@
+//#region src/function/curryRight.d.ts
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *  return 42;
+ * }
+ * const curriedNoArgFunc = curryRight(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curryRight<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curryRight(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curryRight<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *  return [a, b];
+ * }
+ * const curriedTwoArgFunc = curryRight(twoArgFunc);
+ * const func = curriedTwoArgFunc(1);
+ * console.log(func(2)); // [2, 1]
+ */
+declare function curryRight<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3) => R} func - The function to curry.
+ * @returns {(p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function threeArgFunc(a: number, b: number, c: number) {
+ *   return [a, b, c];
+ * }
+ * const curriedThreeArgFunc = curryRight(threeArgFunc);
+ * const func = curriedThreeArgFunc(1);
+ * const func2 = func(2);
+ * console.log(func2(3)); // [3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *  return [a, b, c, d];
+ * }
+ * const curriedFourArgFunc = curryRight(fourArgFunc);
+ * const func = curriedFourArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * console.log(func3(4)); // [4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return [a, b, c, d, e];
+ * }
+ * const curriedFiveArgFunc = curryRight(fiveArgFunc);
+ * const func = curriedFiveArgFunc(1);
+ * const func2 = func(2);
+ * const func3 = func2(3);
+ * const func4 = func3(4);
+ * console.log(func4(5)); // [5, 4, 3, 2, 1]
+ */
+declare function curryRight<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p5: P5) => (p4: P4) => (p3: P3) => (p2: P2) => (p1: P1) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * Unlike `curry`, this function curries the function from right to left.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curryRight(sum);
+ *
+ * // The parameter `c` should be given the value `10`.
+ * const add10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const add25 = add10(15);
+ *
+ * // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = add25(5); // 30
+ */
+declare function curryRight(func: (...args: any[]) => any): (...args: any[]) => any;
+//#endregion
+export { curryRight };

tools/ui/node_modules/es-toolkit/dist/function/curryRight.js

@@ -0,0 +1,43 @@
+//#region src/function/curryRight.ts
+/**
+* Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+* This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+*
+* Unlike `curry`, this function curries the function from right to left.
+*
+* @param {(...args: any[]) => any} func - The function to curry.
+* @returns {(...args: any[]) => any} A curried function.
+*
+* @example
+* function sum(a: number, b: number, c: number) {
+*   return a + b + c;
+* }
+*
+* const curriedSum = curryRight(sum);
+*
+* // The parameter `c` should be given the value `10`.
+* const add10 = curriedSum(10);
+*
+* // The parameter `b` should be given the value `15`.
+* const add25 = add10(15);
+*
+* // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+* const result = add25(5); // 30
+*/
+function curryRight(func) {
+	if (func.length === 0 || func.length === 1) return func;
+	return function(arg) {
+		return makeCurryRight(func, func.length, [arg]);
+	};
+}
+function makeCurryRight(origin, argsLength, args) {
+	if (args.length === argsLength) return origin(...args);
+	else {
+		const next = function(arg) {
+			return makeCurryRight(origin, argsLength, [arg, ...args]);
+		};
+		return next;
+	}
+}
+//#endregion
+exports.curryRight = curryRight;

tools/ui/node_modules/es-toolkit/dist/function/curryRight.mjs

@@ -0,0 +1,43 @@
+//#region src/function/curryRight.ts
+/**
+* Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+* This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+*
+* Unlike `curry`, this function curries the function from right to left.
+*
+* @param {(...args: any[]) => any} func - The function to curry.
+* @returns {(...args: any[]) => any} A curried function.
+*
+* @example
+* function sum(a: number, b: number, c: number) {
+*   return a + b + c;
+* }
+*
+* const curriedSum = curryRight(sum);
+*
+* // The parameter `c` should be given the value `10`.
+* const add10 = curriedSum(10);
+*
+* // The parameter `b` should be given the value `15`.
+* const add25 = add10(15);
+*
+* // The parameter `a` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+* const result = add25(5); // 30
+*/
+function curryRight(func) {
+	if (func.length === 0 || func.length === 1) return func;
+	return function(arg) {
+		return makeCurryRight(func, func.length, [arg]);
+	};
+}
+function makeCurryRight(origin, argsLength, args) {
+	if (args.length === argsLength) return origin(...args);
+	else {
+		const next = function(arg) {
+			return makeCurryRight(origin, argsLength, [arg, ...args]);
+		};
+		return next;
+	}
+}
+//#endregion
+export { curryRight };

tools/ui/node_modules/es-toolkit/dist/function/debounce.d.mts

@@ -0,0 +1,78 @@
+//#region src/function/debounce.d.ts
+interface DebounceOptions {
+  /**
+   * An optional AbortSignal to cancel the debounced function.
+   */
+  signal?: AbortSignal;
+  /**
+   * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+   * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+   * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+   * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+   * @default ["trailing"]
+   */
+  edges?: Array<'leading' | 'trailing'>;
+}
+interface DebouncedFunction<F extends (...args: any[]) => void> {
+  (...args: Parameters<F>): void;
+  /**
+   * Schedules the execution of the debounced function after the specified debounce delay.
+   * This method resets any existing timer, ensuring that the function is only invoked
+   * after the delay has elapsed since the last call to the debounced function.
+   * It is typically called internally whenever the debounced function is invoked.
+   *
+   * @returns {void}
+   */
+  schedule: () => void;
+  /**
+   * Cancels any pending execution of the debounced function.
+   * This method clears the active timer and resets any stored context or arguments.
+   */
+  cancel: () => void;
+  /**
+   * Immediately invokes the debounced function if there is a pending execution.
+   * This method executes the function right away if there is a pending execution.
+   */
+  flush: () => void;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, {
+  signal,
+  edges
+}?: DebounceOptions): DebouncedFunction<F>;
+//#endregion
+export { DebounceOptions, DebouncedFunction, debounce };

tools/ui/node_modules/es-toolkit/dist/function/debounce.d.ts

@@ -0,0 +1,78 @@
+//#region src/function/debounce.d.ts
+interface DebounceOptions {
+  /**
+   * An optional AbortSignal to cancel the debounced function.
+   */
+  signal?: AbortSignal;
+  /**
+   * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+   * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+   * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+   * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+   * @default ["trailing"]
+   */
+  edges?: Array<'leading' | 'trailing'>;
+}
+interface DebouncedFunction<F extends (...args: any[]) => void> {
+  (...args: Parameters<F>): void;
+  /**
+   * Schedules the execution of the debounced function after the specified debounce delay.
+   * This method resets any existing timer, ensuring that the function is only invoked
+   * after the delay has elapsed since the last call to the debounced function.
+   * It is typically called internally whenever the debounced function is invoked.
+   *
+   * @returns {void}
+   */
+  schedule: () => void;
+  /**
+   * Cancels any pending execution of the debounced function.
+   * This method clears the active timer and resets any stored context or arguments.
+   */
+  cancel: () => void;
+  /**
+   * Immediately invokes the debounced function if there is a pending execution.
+   * This method executes the function right away if there is a pending execution.
+   */
+  flush: () => void;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, {
+  signal,
+  edges
+}?: DebounceOptions): DebouncedFunction<F>;
+//#endregion
+export { DebounceOptions, DebouncedFunction, debounce };

tools/ui/node_modules/es-toolkit/dist/function/debounce.js

@@ -0,0 +1,90 @@
+//#region src/function/debounce.ts
+/**
+* Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+* have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+* method to cancel any pending execution.
+*
+* @template F - The type of function.
+* @param {F} func - The function to debounce.
+* @param {number} debounceMs - The number of milliseconds to delay.
+* @param {DebounceOptions} options - The options object
+* @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+* @returns A new debounced function with a `cancel` method.
+*
+* @example
+* const debouncedFunction = debounce(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' after 1 second if not called again in that time
+* debouncedFunction();
+*
+* // Will not log anything as the previous call is canceled
+* debouncedFunction.cancel();
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const signal = controller.signal;
+* const debouncedWithSignal = debounce(() => {
+*  console.log('Function executed');
+* }, 1000, { signal });
+*
+* debouncedWithSignal();
+*
+* // Will cancel the debounced function call
+* controller.abort();
+*/
+function debounce(func, debounceMs, { signal, edges } = {}) {
+	let pendingThis = void 0;
+	let pendingArgs = null;
+	const leading = edges != null && edges.includes("leading");
+	const trailing = edges == null || edges.includes("trailing");
+	const invoke = () => {
+		if (pendingArgs !== null) {
+			func.apply(pendingThis, pendingArgs);
+			pendingThis = void 0;
+			pendingArgs = null;
+		}
+	};
+	const onTimerEnd = () => {
+		if (trailing) invoke();
+		cancel();
+	};
+	let timeoutId = null;
+	const schedule = () => {
+		if (timeoutId != null) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			timeoutId = null;
+			onTimerEnd();
+		}, debounceMs);
+	};
+	const cancelTimer = () => {
+		if (timeoutId !== null) {
+			clearTimeout(timeoutId);
+			timeoutId = null;
+		}
+	};
+	const cancel = () => {
+		cancelTimer();
+		pendingThis = void 0;
+		pendingArgs = null;
+	};
+	const flush = () => {
+		invoke();
+	};
+	const debounced = function(...args) {
+		if (signal?.aborted) return;
+		pendingThis = this;
+		pendingArgs = args;
+		const isFirstCall = timeoutId == null;
+		schedule();
+		if (leading && isFirstCall) invoke();
+	};
+	debounced.schedule = schedule;
+	debounced.cancel = cancel;
+	debounced.flush = flush;
+	signal?.addEventListener("abort", cancel, { once: true });
+	return debounced;
+}
+//#endregion
+exports.debounce = debounce;