Add files using upload-large-folder tool

astra_scene_test/X_03/node_modules/es-toolkit/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+exports.__exportAll = __exportAll;

astra_scene_test/X_03/node_modules/es-toolkit/dist/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/at.d.mts

@@ -0,0 +1,19 @@
+//#region src/array/at.d.ts
+/**
+ * Retrieves elements from an array at the specified indices.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param arr - The array to retrieve elements from.
+ * @param indices - An array of indices specifying the positions of elements to retrieve.
+ * @returns A new array containing the elements at the specified indices.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const result = at(numbers, [1, 3, 4]);
+ * console.log(result); // [20, 40, 50]
+ */
+declare function at<T>(arr: readonly T[], indices: readonly number[]): T[];
+//#endregion
+export { at };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/at.d.ts

@@ -0,0 +1,19 @@
+//#region src/array/at.d.ts
+/**
+ * Retrieves elements from an array at the specified indices.
+ *
+ * This function supports negative indices, which count from the end of the array.
+ *
+ * @template T
+ * @param arr - The array to retrieve elements from.
+ * @param indices - An array of indices specifying the positions of elements to retrieve.
+ * @returns A new array containing the elements at the specified indices.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const result = at(numbers, [1, 3, 4]);
+ * console.log(result); // [20, 40, 50]
+ */
+declare function at<T>(arr: readonly T[], indices: readonly number[]): T[];
+//#endregion
+export { at };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/at.js

@@ -0,0 +1,29 @@
+//#region src/array/at.ts
+/**
+* Retrieves elements from an array at the specified indices.
+*
+* This function supports negative indices, which count from the end of the array.
+*
+* @template T
+* @param arr - The array to retrieve elements from.
+* @param indices - An array of indices specifying the positions of elements to retrieve.
+* @returns A new array containing the elements at the specified indices.
+*
+* @example
+* const numbers = [10, 20, 30, 40, 50];
+* const result = at(numbers, [1, 3, 4]);
+* console.log(result); // [20, 40, 50]
+*/
+function at(arr, indices) {
+	const result = new Array(indices.length);
+	const length = arr.length;
+	for (let i = 0; i < indices.length; i++) {
+		let index = indices[i];
+		index = Number.isInteger(index) ? index : Math.trunc(index) || 0;
+		if (index < 0) index += length;
+		result[i] = arr[index];
+	}
+	return result;
+}
+//#endregion
+exports.at = at;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/at.mjs

@@ -0,0 +1,29 @@
+//#region src/array/at.ts
+/**
+* Retrieves elements from an array at the specified indices.
+*
+* This function supports negative indices, which count from the end of the array.
+*
+* @template T
+* @param arr - The array to retrieve elements from.
+* @param indices - An array of indices specifying the positions of elements to retrieve.
+* @returns A new array containing the elements at the specified indices.
+*
+* @example
+* const numbers = [10, 20, 30, 40, 50];
+* const result = at(numbers, [1, 3, 4]);
+* console.log(result); // [20, 40, 50]
+*/
+function at(arr, indices) {
+	const result = new Array(indices.length);
+	const length = arr.length;
+	for (let i = 0; i < indices.length; i++) {
+		let index = indices[i];
+		index = Number.isInteger(index) ? index : Math.trunc(index) || 0;
+		if (index < 0) index += length;
+		result[i] = arr[index];
+	}
+	return result;
+}
+//#endregion
+export { at };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/cartesianProduct.d.mts

@@ -0,0 +1,75 @@
+//#region src/array/cartesianProduct.d.ts
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T
+ * @param arr1 - The array to take the product of.
+ * @returns An array of single-element tuples.
+ */
+declare function cartesianProduct<T>(arr1: readonly T[]): Array<[T]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T, U
+ * @param arr1 - The first array to take the product of.
+ * @param arr2 - The second array to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ *
+ * @example
+ * cartesianProduct([1, 2], ['a', 'b']);
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): Array<[T, U]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T, U, V
+ * @param arr1 - The first array to take the product of.
+ * @param arr2 - The second array to take the product of.
+ * @param arr3 - The third array to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ */
+declare function cartesianProduct<T, U, V>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[]): Array<[T, U, V]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T, U, V, W
+ * @param arr1 - The first array to take the product of.
+ * @param arr2 - The second array to take the product of.
+ * @param arr3 - The third array to take the product of.
+ * @param arr4 - The fourth array to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ */
+declare function cartesianProduct<T, U, V, W>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): Array<[T, U, V, W]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * Returns every possible tuple formed by picking one element from each input array, in lexicographic order.
+ * The rightmost array advances fastest, like the digits of an odometer.
+ *
+ * If no arrays are passed, the result is `[[]]` (a single empty tuple).
+ * If any input array is empty, the result is `[]`.
+ *
+ * @template T
+ * @param arrs - The arrays to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ *
+ * @example
+ * cartesianProduct([1, 2], ['a', 'b']);
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ *
+ * @example
+ * cartesianProduct([0, 1], [0, 1], [0, 1]);
+ * // => [[0,0,0], [0,0,1], [0,1,0], [0,1,1], [1,0,0], [1,0,1], [1,1,0], [1,1,1]]
+ *
+ * @example
+ * cartesianProduct([1, 2, 3], []);
+ * // => []
+ *
+ * @example
+ * cartesianProduct();
+ * // => [[]]
+ */
+declare function cartesianProduct<T>(...arrs: Array<readonly T[]>): T[][];
+//#endregion
+export { cartesianProduct };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/cartesianProduct.d.ts

@@ -0,0 +1,75 @@
+//#region src/array/cartesianProduct.d.ts
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T
+ * @param arr1 - The array to take the product of.
+ * @returns An array of single-element tuples.
+ */
+declare function cartesianProduct<T>(arr1: readonly T[]): Array<[T]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T, U
+ * @param arr1 - The first array to take the product of.
+ * @param arr2 - The second array to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ *
+ * @example
+ * cartesianProduct([1, 2], ['a', 'b']);
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ */
+declare function cartesianProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): Array<[T, U]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T, U, V
+ * @param arr1 - The first array to take the product of.
+ * @param arr2 - The second array to take the product of.
+ * @param arr3 - The third array to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ */
+declare function cartesianProduct<T, U, V>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[]): Array<[T, U, V]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * @template T, U, V, W
+ * @param arr1 - The first array to take the product of.
+ * @param arr2 - The second array to take the product of.
+ * @param arr3 - The third array to take the product of.
+ * @param arr4 - The fourth array to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ */
+declare function cartesianProduct<T, U, V, W>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[], arr4: readonly W[]): Array<[T, U, V, W]>;
+/**
+ * Computes the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the input arrays.
+ *
+ * Returns every possible tuple formed by picking one element from each input array, in lexicographic order.
+ * The rightmost array advances fastest, like the digits of an odometer.
+ *
+ * If no arrays are passed, the result is `[[]]` (a single empty tuple).
+ * If any input array is empty, the result is `[]`.
+ *
+ * @template T
+ * @param arrs - The arrays to take the product of.
+ * @returns An array of tuples representing the Cartesian product.
+ *
+ * @example
+ * cartesianProduct([1, 2], ['a', 'b']);
+ * // => [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
+ *
+ * @example
+ * cartesianProduct([0, 1], [0, 1], [0, 1]);
+ * // => [[0,0,0], [0,0,1], [0,1,0], [0,1,1], [1,0,0], [1,0,1], [1,1,0], [1,1,1]]
+ *
+ * @example
+ * cartesianProduct([1, 2, 3], []);
+ * // => []
+ *
+ * @example
+ * cartesianProduct();
+ * // => [[]]
+ */
+declare function cartesianProduct<T>(...arrs: Array<readonly T[]>): T[][];
+//#endregion
+export { cartesianProduct };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/cartesianProduct.js

@@ -0,0 +1,23 @@
+//#region src/array/cartesianProduct.ts
+function cartesianProduct(...arrs) {
+	if (arrs.length === 0) return [[]];
+	let total = 1;
+	for (let i = 0; i < arrs.length; i++) total *= arrs[i].length;
+	if (total === 0) return [];
+	const n = arrs.length;
+	const result = Array(total);
+	for (let i = 0; i < total; i++) {
+		const tuple = Array(n);
+		let idx = i;
+		for (let j = n - 1; j >= 0; j--) {
+			const arr = arrs[j];
+			const len = arr.length;
+			tuple[j] = arr[idx % len];
+			idx = Math.floor(idx / len);
+		}
+		result[i] = tuple;
+	}
+	return result;
+}
+//#endregion
+exports.cartesianProduct = cartesianProduct;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/cartesianProduct.mjs

@@ -0,0 +1,23 @@
+//#region src/array/cartesianProduct.ts
+function cartesianProduct(...arrs) {
+	if (arrs.length === 0) return [[]];
+	let total = 1;
+	for (let i = 0; i < arrs.length; i++) total *= arrs[i].length;
+	if (total === 0) return [];
+	const n = arrs.length;
+	const result = Array(total);
+	for (let i = 0; i < total; i++) {
+		const tuple = Array(n);
+		let idx = i;
+		for (let j = n - 1; j >= 0; j--) {
+			const arr = arrs[j];
+			const len = arr.length;
+			tuple[j] = arr[idx % len];
+			idx = Math.floor(idx / len);
+		}
+		result[i] = tuple;
+	}
+	return result;
+}
+//#endregion
+export { cartesianProduct };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunk.d.mts

@@ -0,0 +1,27 @@
+//#region src/array/chunk.d.ts
+/**
+ * Splits an array into smaller arrays of a specified length.
+ *
+ * This function takes an input array and divides it into multiple smaller arrays,
+ * each of a specified length. If the input array cannot be evenly divided,
+ * the final sub-array will contain the remaining elements.
+ *
+ * @template T The type of elements in the array.
+ * @param arr - The array to be chunked into smaller arrays.
+ * @param size - The size of each smaller array. Must be a positive integer.
+ * @returns A two-dimensional array where each sub-array has a maximum length of `size`.
+ * @throws {Error} Throws an error if `size` is not a positive integer.
+ *
+ * @example
+ * // Splits an array of numbers into sub-arrays of length 2
+ * chunk([1, 2, 3, 4, 5], 2);
+ * // Returns: [[1, 2], [3, 4], [5]]
+ *
+ * @example
+ * // Splits an array of strings into sub-arrays of length 3
+ * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+ * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+ */
+declare function chunk<T>(arr: readonly T[], size: number): T[][];
+//#endregion
+export { chunk };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunk.d.ts

@@ -0,0 +1,27 @@
+//#region src/array/chunk.d.ts
+/**
+ * Splits an array into smaller arrays of a specified length.
+ *
+ * This function takes an input array and divides it into multiple smaller arrays,
+ * each of a specified length. If the input array cannot be evenly divided,
+ * the final sub-array will contain the remaining elements.
+ *
+ * @template T The type of elements in the array.
+ * @param arr - The array to be chunked into smaller arrays.
+ * @param size - The size of each smaller array. Must be a positive integer.
+ * @returns A two-dimensional array where each sub-array has a maximum length of `size`.
+ * @throws {Error} Throws an error if `size` is not a positive integer.
+ *
+ * @example
+ * // Splits an array of numbers into sub-arrays of length 2
+ * chunk([1, 2, 3, 4, 5], 2);
+ * // Returns: [[1, 2], [3, 4], [5]]
+ *
+ * @example
+ * // Splits an array of strings into sub-arrays of length 3
+ * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+ * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+ */
+declare function chunk<T>(arr: readonly T[], size: number): T[][];
+//#endregion
+export { chunk };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunk.js

@@ -0,0 +1,37 @@
+//#region src/array/chunk.ts
+/**
+* Splits an array into smaller arrays of a specified length.
+*
+* This function takes an input array and divides it into multiple smaller arrays,
+* each of a specified length. If the input array cannot be evenly divided,
+* the final sub-array will contain the remaining elements.
+*
+* @template T The type of elements in the array.
+* @param arr - The array to be chunked into smaller arrays.
+* @param size - The size of each smaller array. Must be a positive integer.
+* @returns A two-dimensional array where each sub-array has a maximum length of `size`.
+* @throws {Error} Throws an error if `size` is not a positive integer.
+*
+* @example
+* // Splits an array of numbers into sub-arrays of length 2
+* chunk([1, 2, 3, 4, 5], 2);
+* // Returns: [[1, 2], [3, 4], [5]]
+*
+* @example
+* // Splits an array of strings into sub-arrays of length 3
+* chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+* // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+*/
+function chunk(arr, size) {
+	if (!Number.isInteger(size) || size <= 0) throw new Error("Size must be an integer greater than zero.");
+	const chunkLength = Math.ceil(arr.length / size);
+	const result = Array(chunkLength);
+	for (let index = 0; index < chunkLength; index++) {
+		const start = index * size;
+		const end = start + size;
+		result[index] = arr.slice(start, end);
+	}
+	return result;
+}
+//#endregion
+exports.chunk = chunk;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunk.mjs

@@ -0,0 +1,37 @@
+//#region src/array/chunk.ts
+/**
+* Splits an array into smaller arrays of a specified length.
+*
+* This function takes an input array and divides it into multiple smaller arrays,
+* each of a specified length. If the input array cannot be evenly divided,
+* the final sub-array will contain the remaining elements.
+*
+* @template T The type of elements in the array.
+* @param arr - The array to be chunked into smaller arrays.
+* @param size - The size of each smaller array. Must be a positive integer.
+* @returns A two-dimensional array where each sub-array has a maximum length of `size`.
+* @throws {Error} Throws an error if `size` is not a positive integer.
+*
+* @example
+* // Splits an array of numbers into sub-arrays of length 2
+* chunk([1, 2, 3, 4, 5], 2);
+* // Returns: [[1, 2], [3, 4], [5]]
+*
+* @example
+* // Splits an array of strings into sub-arrays of length 3
+* chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+* // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
+*/
+function chunk(arr, size) {
+	if (!Number.isInteger(size) || size <= 0) throw new Error("Size must be an integer greater than zero.");
+	const chunkLength = Math.ceil(arr.length / size);
+	const result = Array(chunkLength);
+	for (let index = 0; index < chunkLength; index++) {
+		const start = index * size;
+		const end = start + size;
+		result[index] = arr.slice(start, end);
+	}
+	return result;
+}
+//#endregion
+export { chunk };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunkBy.d.mts

@@ -0,0 +1,32 @@
+//#region src/array/chunkBy.d.ts
+/**
+ * Splits an array into chunks of consecutive elements that share the same key.
+ *
+ * Walking left to right, each element's key is derived by `iteratee`. Whenever
+ * the key differs from the previous element's key, a new chunk is started;
+ * otherwise the element is appended to the current chunk. Keys are compared with
+ * `!==` (strict inequality), so equal primitives stay together while distinct
+ * object references always start a new chunk.
+ *
+ * Unlike {@link chunk}, which splits by a fixed size, `chunkBy` splits by a
+ * boundary condition, keeping runs of same-keyed elements together.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to split into chunks.
+ * @param iteratee - A function that derives the comparison key for each element.
+ * @returns A two-dimensional array where each sub-array is a run of consecutive
+ *   elements that produced the same key.
+ *
+ * @example
+ * // Group consecutive equal numbers
+ * chunkBy([1, 1, 2, 3, 3, 3], value => value);
+ * // Returns: [[1, 1], [2], [3, 3, 3]]
+ *
+ * @example
+ * // Group consecutive words by their length
+ * chunkBy(['a', 'b', 'cd', 'ef', 'g'], word => word.length);
+ * // Returns: [['a', 'b'], ['cd', 'ef'], ['g']]
+ */
+declare function chunkBy<T>(arr: readonly T[], iteratee: (value: T) => unknown): T[][];
+//#endregion
+export { chunkBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunkBy.d.ts

@@ -0,0 +1,32 @@
+//#region src/array/chunkBy.d.ts
+/**
+ * Splits an array into chunks of consecutive elements that share the same key.
+ *
+ * Walking left to right, each element's key is derived by `iteratee`. Whenever
+ * the key differs from the previous element's key, a new chunk is started;
+ * otherwise the element is appended to the current chunk. Keys are compared with
+ * `!==` (strict inequality), so equal primitives stay together while distinct
+ * object references always start a new chunk.
+ *
+ * Unlike {@link chunk}, which splits by a fixed size, `chunkBy` splits by a
+ * boundary condition, keeping runs of same-keyed elements together.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to split into chunks.
+ * @param iteratee - A function that derives the comparison key for each element.
+ * @returns A two-dimensional array where each sub-array is a run of consecutive
+ *   elements that produced the same key.
+ *
+ * @example
+ * // Group consecutive equal numbers
+ * chunkBy([1, 1, 2, 3, 3, 3], value => value);
+ * // Returns: [[1, 1], [2], [3, 3, 3]]
+ *
+ * @example
+ * // Group consecutive words by their length
+ * chunkBy(['a', 'b', 'cd', 'ef', 'g'], word => word.length);
+ * // Returns: [['a', 'b'], ['cd', 'ef'], ['g']]
+ */
+declare function chunkBy<T>(arr: readonly T[], iteratee: (value: T) => unknown): T[][];
+//#endregion
+export { chunkBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunkBy.js

@@ -0,0 +1,42 @@
+//#region src/array/chunkBy.ts
+/**
+* Splits an array into chunks of consecutive elements that share the same key.
+*
+* Walking left to right, each element's key is derived by `iteratee`. Whenever
+* the key differs from the previous element's key, a new chunk is started;
+* otherwise the element is appended to the current chunk. Keys are compared with
+* `!==` (strict inequality), so equal primitives stay together while distinct
+* object references always start a new chunk.
+*
+* Unlike {@link chunk}, which splits by a fixed size, `chunkBy` splits by a
+* boundary condition, keeping runs of same-keyed elements together.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array to split into chunks.
+* @param iteratee - A function that derives the comparison key for each element.
+* @returns A two-dimensional array where each sub-array is a run of consecutive
+*   elements that produced the same key.
+*
+* @example
+* // Group consecutive equal numbers
+* chunkBy([1, 1, 2, 3, 3, 3], value => value);
+* // Returns: [[1, 1], [2], [3, 3, 3]]
+*
+* @example
+* // Group consecutive words by their length
+* chunkBy(['a', 'b', 'cd', 'ef', 'g'], word => word.length);
+* // Returns: [['a', 'b'], ['cd', 'ef'], ['g']]
+*/
+function chunkBy(arr, iteratee) {
+	const result = [];
+	let prevKey;
+	for (let i = 0; i < arr.length; i++) {
+		const key = iteratee(arr[i]);
+		if (i === 0 || key !== prevKey) result.push([arr[i]]);
+		else result[result.length - 1].push(arr[i]);
+		prevKey = key;
+	}
+	return result;
+}
+//#endregion
+exports.chunkBy = chunkBy;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/chunkBy.mjs

@@ -0,0 +1,42 @@
+//#region src/array/chunkBy.ts
+/**
+* Splits an array into chunks of consecutive elements that share the same key.
+*
+* Walking left to right, each element's key is derived by `iteratee`. Whenever
+* the key differs from the previous element's key, a new chunk is started;
+* otherwise the element is appended to the current chunk. Keys are compared with
+* `!==` (strict inequality), so equal primitives stay together while distinct
+* object references always start a new chunk.
+*
+* Unlike {@link chunk}, which splits by a fixed size, `chunkBy` splits by a
+* boundary condition, keeping runs of same-keyed elements together.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array to split into chunks.
+* @param iteratee - A function that derives the comparison key for each element.
+* @returns A two-dimensional array where each sub-array is a run of consecutive
+*   elements that produced the same key.
+*
+* @example
+* // Group consecutive equal numbers
+* chunkBy([1, 1, 2, 3, 3, 3], value => value);
+* // Returns: [[1, 1], [2], [3, 3, 3]]
+*
+* @example
+* // Group consecutive words by their length
+* chunkBy(['a', 'b', 'cd', 'ef', 'g'], word => word.length);
+* // Returns: [['a', 'b'], ['cd', 'ef'], ['g']]
+*/
+function chunkBy(arr, iteratee) {
+	const result = [];
+	let prevKey;
+	for (let i = 0; i < arr.length; i++) {
+		const key = iteratee(arr[i]);
+		if (i === 0 || key !== prevKey) result.push([arr[i]]);
+		else result[result.length - 1].push(arr[i]);
+		prevKey = key;
+	}
+	return result;
+}
+//#endregion
+export { chunkBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/combinations.d.mts

@@ -0,0 +1,35 @@
+//#region src/array/combinations.d.ts
+/**
+ * Returns all `r`-length combinations of elements from the input array.
+ *
+ * Combinations are emitted in lexicographic order based on the position of elements in the input array.
+ * Elements are treated as unique by position, not by value, so duplicates in the input may produce
+ * combinations that look identical.
+ *
+ * The number of combinations is `n! / r! / (n - r)!` when `0 <= r <= n`, and zero when `r > n`.
+ *
+ * @template T
+ * @param arr - The input array.
+ * @param r - The length of each combination. Must be a non-negative integer.
+ * @returns An array of `r`-length combinations.
+ * @throws {Error} If `r` is not a non-negative integer.
+ *
+ * @example
+ * combinations(['A', 'B', 'C', 'D'], 2);
+ * // => [['A','B'], ['A','C'], ['A','D'], ['B','C'], ['B','D'], ['C','D']]
+ *
+ * @example
+ * combinations([1, 2, 3, 4], 3);
+ * // => [[1,2,3], [1,2,4], [1,3,4], [2,3,4]]
+ *
+ * @example
+ * combinations([1, 2, 3], 0);
+ * // => [[]]
+ *
+ * @example
+ * combinations([1, 2], 5);
+ * // => []
+ */
+declare function combinations<T>(arr: readonly T[], r: number): T[][];
+//#endregion
+export { combinations };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/combinations.d.ts

@@ -0,0 +1,35 @@
+//#region src/array/combinations.d.ts
+/**
+ * Returns all `r`-length combinations of elements from the input array.
+ *
+ * Combinations are emitted in lexicographic order based on the position of elements in the input array.
+ * Elements are treated as unique by position, not by value, so duplicates in the input may produce
+ * combinations that look identical.
+ *
+ * The number of combinations is `n! / r! / (n - r)!` when `0 <= r <= n`, and zero when `r > n`.
+ *
+ * @template T
+ * @param arr - The input array.
+ * @param r - The length of each combination. Must be a non-negative integer.
+ * @returns An array of `r`-length combinations.
+ * @throws {Error} If `r` is not a non-negative integer.
+ *
+ * @example
+ * combinations(['A', 'B', 'C', 'D'], 2);
+ * // => [['A','B'], ['A','C'], ['A','D'], ['B','C'], ['B','D'], ['C','D']]
+ *
+ * @example
+ * combinations([1, 2, 3, 4], 3);
+ * // => [[1,2,3], [1,2,4], [1,3,4], [2,3,4]]
+ *
+ * @example
+ * combinations([1, 2, 3], 0);
+ * // => [[]]
+ *
+ * @example
+ * combinations([1, 2], 5);
+ * // => []
+ */
+declare function combinations<T>(arr: readonly T[], r: number): T[][];
+//#endregion
+export { combinations };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/combinations.js

@@ -0,0 +1,53 @@
+//#region src/array/combinations.ts
+/**
+* Returns all `r`-length combinations of elements from the input array.
+*
+* Combinations are emitted in lexicographic order based on the position of elements in the input array.
+* Elements are treated as unique by position, not by value, so duplicates in the input may produce
+* combinations that look identical.
+*
+* The number of combinations is `n! / r! / (n - r)!` when `0 <= r <= n`, and zero when `r > n`.
+*
+* @template T
+* @param arr - The input array.
+* @param r - The length of each combination. Must be a non-negative integer.
+* @returns An array of `r`-length combinations.
+* @throws {Error} If `r` is not a non-negative integer.
+*
+* @example
+* combinations(['A', 'B', 'C', 'D'], 2);
+* // => [['A','B'], ['A','C'], ['A','D'], ['B','C'], ['B','D'], ['C','D']]
+*
+* @example
+* combinations([1, 2, 3, 4], 3);
+* // => [[1,2,3], [1,2,4], [1,3,4], [2,3,4]]
+*
+* @example
+* combinations([1, 2, 3], 0);
+* // => [[]]
+*
+* @example
+* combinations([1, 2], 5);
+* // => []
+*/
+function combinations(arr, r) {
+	if (!Number.isInteger(r) || r < 0) throw new Error("r must be a non-negative integer.");
+	const n = arr.length;
+	if (r > n) return [];
+	if (r === 0) return [[]];
+	const indices = Array(r);
+	for (let i = 0; i < r; i++) indices[i] = i;
+	const result = [];
+	while (true) {
+		const tuple = Array(r);
+		for (let i = 0; i < r; i++) tuple[i] = arr[indices[i]];
+		result.push(tuple);
+		let i = r - 1;
+		while (i >= 0 && indices[i] === i + n - r) i--;
+		if (i < 0) return result;
+		indices[i]++;
+		for (let j = i + 1; j < r; j++) indices[j] = indices[j - 1] + 1;
+	}
+}
+//#endregion
+exports.combinations = combinations;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/combinations.mjs

@@ -0,0 +1,53 @@
+//#region src/array/combinations.ts
+/**
+* Returns all `r`-length combinations of elements from the input array.
+*
+* Combinations are emitted in lexicographic order based on the position of elements in the input array.
+* Elements are treated as unique by position, not by value, so duplicates in the input may produce
+* combinations that look identical.
+*
+* The number of combinations is `n! / r! / (n - r)!` when `0 <= r <= n`, and zero when `r > n`.
+*
+* @template T
+* @param arr - The input array.
+* @param r - The length of each combination. Must be a non-negative integer.
+* @returns An array of `r`-length combinations.
+* @throws {Error} If `r` is not a non-negative integer.
+*
+* @example
+* combinations(['A', 'B', 'C', 'D'], 2);
+* // => [['A','B'], ['A','C'], ['A','D'], ['B','C'], ['B','D'], ['C','D']]
+*
+* @example
+* combinations([1, 2, 3, 4], 3);
+* // => [[1,2,3], [1,2,4], [1,3,4], [2,3,4]]
+*
+* @example
+* combinations([1, 2, 3], 0);
+* // => [[]]
+*
+* @example
+* combinations([1, 2], 5);
+* // => []
+*/
+function combinations(arr, r) {
+	if (!Number.isInteger(r) || r < 0) throw new Error("r must be a non-negative integer.");
+	const n = arr.length;
+	if (r > n) return [];
+	if (r === 0) return [[]];
+	const indices = Array(r);
+	for (let i = 0; i < r; i++) indices[i] = i;
+	const result = [];
+	while (true) {
+		const tuple = Array(r);
+		for (let i = 0; i < r; i++) tuple[i] = arr[indices[i]];
+		result.push(tuple);
+		let i = r - 1;
+		while (i >= 0 && indices[i] === i + n - r) i--;
+		if (i < 0) return result;
+		indices[i]++;
+		for (let j = i + 1; j < r; j++) indices[j] = indices[j - 1] + 1;
+	}
+}
+//#endregion
+export { combinations };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/compact.d.mts

@@ -0,0 +1,16 @@
+//#region src/array/compact.d.ts
+type NotFalsey<T> = Exclude<T, false | null | 0 | 0n | '' | undefined>;
+/**
+ * Removes falsey values (false, null, 0, -0, 0n, '', undefined, NaN) from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The input array to remove falsey values.
+ * @returns A new array with all falsey values removed.
+ *
+ * @example
+ * compact([0, -0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+ * Returns: [1, 2, 3, 4, 5]
+ */
+declare function compact<T>(arr: readonly T[]): Array<NotFalsey<T>>;
+//#endregion
+export { compact };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/compact.d.ts

@@ -0,0 +1,16 @@
+//#region src/array/compact.d.ts
+type NotFalsey<T> = Exclude<T, false | null | 0 | 0n | '' | undefined>;
+/**
+ * Removes falsey values (false, null, 0, -0, 0n, '', undefined, NaN) from an array.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The input array to remove falsey values.
+ * @returns A new array with all falsey values removed.
+ *
+ * @example
+ * compact([0, -0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+ * Returns: [1, 2, 3, 4, 5]
+ */
+declare function compact<T>(arr: readonly T[]): Array<NotFalsey<T>>;
+//#endregion
+export { compact };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/compact.js

@@ -0,0 +1,22 @@
+//#region src/array/compact.ts
+/**
+* Removes falsey values (false, null, 0, -0, 0n, '', undefined, NaN) from an array.
+*
+* @template T - The type of elements in the array.
+* @param arr - The input array to remove falsey values.
+* @returns A new array with all falsey values removed.
+*
+* @example
+* compact([0, -0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+* Returns: [1, 2, 3, 4, 5]
+*/
+function compact(arr) {
+	const result = [];
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		if (item) result.push(item);
+	}
+	return result;
+}
+//#endregion
+exports.compact = compact;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/compact.mjs

@@ -0,0 +1,22 @@
+//#region src/array/compact.ts
+/**
+* Removes falsey values (false, null, 0, -0, 0n, '', undefined, NaN) from an array.
+*
+* @template T - The type of elements in the array.
+* @param arr - The input array to remove falsey values.
+* @returns A new array with all falsey values removed.
+*
+* @example
+* compact([0, -0, 0n, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+* Returns: [1, 2, 3, 4, 5]
+*/
+function compact(arr) {
+	const result = [];
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		if (item) result.push(item);
+	}
+	return result;
+}
+//#endregion
+export { compact };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/countBy.d.mts

@@ -0,0 +1,37 @@
+//#region src/array/countBy.d.ts
+/**
+ * Count the occurrences of each item in an array
+ * based on a transformation function.
+ *
+ * This function takes an array and a transformation function
+ * that converts each item in the array to a key. It then
+ * counts the occurrences of each transformed item and returns
+ * an object with the transformed items as keys and the counts
+ * as values.
+ *
+ * @template T - The type of the items in the input array.
+ * @template K - The type of keys.
+ * @param arr - The input array to count occurrences.
+ * @param mapper - The transformation function that maps each item, its index, and the array to a key.
+ * @returns An object containing the transformed items as keys and the
+ * counts as values.
+ *
+ * @example
+ * const array = ['a', 'b', 'c', 'a', 'b', 'a'];
+ * const result = countBy(array, x => x);
+ * // result will be { a: 3, b: 2, c: 1 }
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
+ * // result will be { odd: 3, even: 2 }
+ *
+ * @example
+ * // Using index parameter
+ * const array = ['a', 'b', 'c', 'd'];
+ * const result = countBy(array, (item, index) => index < 2 ? 'first' : 'rest');
+ * // result will be { first: 2, rest: 2 }
+ */
+declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T, index: number, array: readonly T[]) => K): Record<K, number>;
+//#endregion
+export { countBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/countBy.d.ts

@@ -0,0 +1,37 @@
+//#region src/array/countBy.d.ts
+/**
+ * Count the occurrences of each item in an array
+ * based on a transformation function.
+ *
+ * This function takes an array and a transformation function
+ * that converts each item in the array to a key. It then
+ * counts the occurrences of each transformed item and returns
+ * an object with the transformed items as keys and the counts
+ * as values.
+ *
+ * @template T - The type of the items in the input array.
+ * @template K - The type of keys.
+ * @param arr - The input array to count occurrences.
+ * @param mapper - The transformation function that maps each item, its index, and the array to a key.
+ * @returns An object containing the transformed items as keys and the
+ * counts as values.
+ *
+ * @example
+ * const array = ['a', 'b', 'c', 'a', 'b', 'a'];
+ * const result = countBy(array, x => x);
+ * // result will be { a: 3, b: 2, c: 1 }
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
+ * // result will be { odd: 3, even: 2 }
+ *
+ * @example
+ * // Using index parameter
+ * const array = ['a', 'b', 'c', 'd'];
+ * const result = countBy(array, (item, index) => index < 2 ? 'first' : 'rest');
+ * // result will be { first: 2, rest: 2 }
+ */
+declare function countBy<T, K extends PropertyKey>(arr: readonly T[], mapper: (item: T, index: number, array: readonly T[]) => K): Record<K, number>;
+//#endregion
+export { countBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/countBy.js

@@ -0,0 +1,45 @@
+//#region src/array/countBy.ts
+/**
+* Count the occurrences of each item in an array
+* based on a transformation function.
+*
+* This function takes an array and a transformation function
+* that converts each item in the array to a key. It then
+* counts the occurrences of each transformed item and returns
+* an object with the transformed items as keys and the counts
+* as values.
+*
+* @template T - The type of the items in the input array.
+* @template K - The type of keys.
+* @param arr - The input array to count occurrences.
+* @param mapper - The transformation function that maps each item, its index, and the array to a key.
+* @returns An object containing the transformed items as keys and the
+* counts as values.
+*
+* @example
+* const array = ['a', 'b', 'c', 'a', 'b', 'a'];
+* const result = countBy(array, x => x);
+* // result will be { a: 3, b: 2, c: 1 }
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
+* // result will be { odd: 3, even: 2 }
+*
+* @example
+* // Using index parameter
+* const array = ['a', 'b', 'c', 'd'];
+* const result = countBy(array, (item, index) => index < 2 ? 'first' : 'rest');
+* // result will be { first: 2, rest: 2 }
+*/
+function countBy(arr, mapper) {
+	const result = {};
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		const key = mapper(item, i, arr);
+		result[key] = (result[key] ?? 0) + 1;
+	}
+	return result;
+}
+//#endregion
+exports.countBy = countBy;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/countBy.mjs

@@ -0,0 +1,45 @@
+//#region src/array/countBy.ts
+/**
+* Count the occurrences of each item in an array
+* based on a transformation function.
+*
+* This function takes an array and a transformation function
+* that converts each item in the array to a key. It then
+* counts the occurrences of each transformed item and returns
+* an object with the transformed items as keys and the counts
+* as values.
+*
+* @template T - The type of the items in the input array.
+* @template K - The type of keys.
+* @param arr - The input array to count occurrences.
+* @param mapper - The transformation function that maps each item, its index, and the array to a key.
+* @returns An object containing the transformed items as keys and the
+* counts as values.
+*
+* @example
+* const array = ['a', 'b', 'c', 'a', 'b', 'a'];
+* const result = countBy(array, x => x);
+* // result will be { a: 3, b: 2, c: 1 }
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const result = countBy(array, item => item % 2 === 0 ? 'even' : 'odd');
+* // result will be { odd: 3, even: 2 }
+*
+* @example
+* // Using index parameter
+* const array = ['a', 'b', 'c', 'd'];
+* const result = countBy(array, (item, index) => index < 2 ? 'first' : 'rest');
+* // result will be { first: 2, rest: 2 }
+*/
+function countBy(arr, mapper) {
+	const result = {};
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		const key = mapper(item, i, arr);
+		result[key] = (result[key] ?? 0) + 1;
+	}
+	return result;
+}
+//#endregion
+export { countBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/difference.d.mts

@@ -0,0 +1,26 @@
+//#region src/array/difference.d.ts
+/**
+ * Computes the difference between two arrays.
+ *
+ * This function takes two arrays and returns a new array containing the elements
+ * that are present in the first array but not in the second array. It effectively
+ * filters out any elements from the first array that also appear in the second array.
+ *
+ * @template T
+ * @param firstArr - The array from which to derive the difference. This is the primary array
+ * from which elements will be compared and filtered.
+ * @param secondArr - The array containing elements to be excluded from the first array.
+ * Each element in this array will be checked against the first array, and if a match is found,
+ * that element will be excluded from the result.
+ * @returns A new array containing the elements that are present in the first array but not
+ * in the second array.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [2, 4];
+ * const result = difference(array1, array2);
+ * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
+ */
+declare function difference<T>(firstArr: readonly T[], secondArr: readonly T[]): T[];
+//#endregion
+export { difference };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/difference.d.ts

@@ -0,0 +1,26 @@
+//#region src/array/difference.d.ts
+/**
+ * Computes the difference between two arrays.
+ *
+ * This function takes two arrays and returns a new array containing the elements
+ * that are present in the first array but not in the second array. It effectively
+ * filters out any elements from the first array that also appear in the second array.
+ *
+ * @template T
+ * @param firstArr - The array from which to derive the difference. This is the primary array
+ * from which elements will be compared and filtered.
+ * @param secondArr - The array containing elements to be excluded from the first array.
+ * Each element in this array will be checked against the first array, and if a match is found,
+ * that element will be excluded from the result.
+ * @returns A new array containing the elements that are present in the first array but not
+ * in the second array.
+ *
+ * @example
+ * const array1 = [1, 2, 3, 4, 5];
+ * const array2 = [2, 4];
+ * const result = difference(array1, array2);
+ * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
+ */
+declare function difference<T>(firstArr: readonly T[], secondArr: readonly T[]): T[];
+//#endregion
+export { difference };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/difference.js

@@ -0,0 +1,29 @@
+//#region src/array/difference.ts
+/**
+* Computes the difference between two arrays.
+*
+* This function takes two arrays and returns a new array containing the elements
+* that are present in the first array but not in the second array. It effectively
+* filters out any elements from the first array that also appear in the second array.
+*
+* @template T
+* @param firstArr - The array from which to derive the difference. This is the primary array
+* from which elements will be compared and filtered.
+* @param secondArr - The array containing elements to be excluded from the first array.
+* Each element in this array will be checked against the first array, and if a match is found,
+* that element will be excluded from the result.
+* @returns A new array containing the elements that are present in the first array but not
+* in the second array.
+*
+* @example
+* const array1 = [1, 2, 3, 4, 5];
+* const array2 = [2, 4];
+* const result = difference(array1, array2);
+* // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
+*/
+function difference(firstArr, secondArr) {
+	const secondSet = new Set(secondArr);
+	return firstArr.filter((item) => !secondSet.has(item));
+}
+//#endregion
+exports.difference = difference;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/difference.mjs

@@ -0,0 +1,29 @@
+//#region src/array/difference.ts
+/**
+* Computes the difference between two arrays.
+*
+* This function takes two arrays and returns a new array containing the elements
+* that are present in the first array but not in the second array. It effectively
+* filters out any elements from the first array that also appear in the second array.
+*
+* @template T
+* @param firstArr - The array from which to derive the difference. This is the primary array
+* from which elements will be compared and filtered.
+* @param secondArr - The array containing elements to be excluded from the first array.
+* Each element in this array will be checked against the first array, and if a match is found,
+* that element will be excluded from the result.
+* @returns A new array containing the elements that are present in the first array but not
+* in the second array.
+*
+* @example
+* const array1 = [1, 2, 3, 4, 5];
+* const array2 = [2, 4];
+* const result = difference(array1, array2);
+* // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.
+*/
+function difference(firstArr, secondArr) {
+	const secondSet = new Set(secondArr);
+	return firstArr.filter((item) => !secondSet.has(item));
+}
+//#endregion
+export { difference };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceBy.d.mts

@@ -0,0 +1,36 @@
+//#region src/array/differenceBy.d.ts
+/**
+ * Computes the difference between two arrays after mapping their elements through a provided function.
+ *
+ * This function takes two arrays and a mapper function. It returns a new array containing the elements
+ * that are present in the first array but not in the second array, based on the identity calculated
+ * by the mapper function.
+ *
+ * Essentially, it filters out any elements from the first array that, when
+ * mapped, match an element in the mapped version of the second array.
+ *
+ * @template T, U
+ * @param firstArr - The primary array from which to derive the difference.
+ * @param secondArr - The array containing elements to be excluded from the first array.
+ * @param mapper - The function to map the elements of both arrays. This function
+ * is applied to each element in both arrays, and the comparison is made based on the mapped values.
+ * @returns A new array containing the elements from the first array that do not have a corresponding
+ * mapped identity in the second array.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const mapper = item => item.id;
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
+ */
+declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (value: T | U) => unknown): T[];
+//#endregion
+export { differenceBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceBy.d.ts

@@ -0,0 +1,36 @@
+//#region src/array/differenceBy.d.ts
+/**
+ * Computes the difference between two arrays after mapping their elements through a provided function.
+ *
+ * This function takes two arrays and a mapper function. It returns a new array containing the elements
+ * that are present in the first array but not in the second array, based on the identity calculated
+ * by the mapper function.
+ *
+ * Essentially, it filters out any elements from the first array that, when
+ * mapped, match an element in the mapped version of the second array.
+ *
+ * @template T, U
+ * @param firstArr - The primary array from which to derive the difference.
+ * @param secondArr - The array containing elements to be excluded from the first array.
+ * @param mapper - The function to map the elements of both arrays. This function
+ * is applied to each element in both arrays, and the comparison is made based on the mapped values.
+ * @returns A new array containing the elements from the first array that do not have a corresponding
+ * mapped identity in the second array.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const mapper = item => item.id;
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const mapper = item => (typeof item === 'object' ? item.id : item);
+ * const result = differenceBy(array1, array2, mapper);
+ * // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
+ */
+declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (value: T | U) => unknown): T[];
+//#endregion
+export { differenceBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceBy.js

@@ -0,0 +1,41 @@
+//#region src/array/differenceBy.ts
+/**
+* Computes the difference between two arrays after mapping their elements through a provided function.
+*
+* This function takes two arrays and a mapper function. It returns a new array containing the elements
+* that are present in the first array but not in the second array, based on the identity calculated
+* by the mapper function.
+*
+* Essentially, it filters out any elements from the first array that, when
+* mapped, match an element in the mapped version of the second array.
+*
+* @template T, U
+* @param firstArr - The primary array from which to derive the difference.
+* @param secondArr - The array containing elements to be excluded from the first array.
+* @param mapper - The function to map the elements of both arrays. This function
+* is applied to each element in both arrays, and the comparison is made based on the mapped values.
+* @returns A new array containing the elements from the first array that do not have a corresponding
+* mapped identity in the second array.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [{ id: 2 }, { id: 4 }];
+* const mapper = item => item.id;
+* const result = differenceBy(array1, array2, mapper);
+* // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [2, 4];
+* const mapper = item => (typeof item === 'object' ? item.id : item);
+* const result = differenceBy(array1, array2, mapper);
+* // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
+*/
+function differenceBy(firstArr, secondArr, mapper) {
+	const mappedSecondSet = new Set(secondArr.map((item) => mapper(item)));
+	return firstArr.filter((item) => {
+		return !mappedSecondSet.has(mapper(item));
+	});
+}
+//#endregion
+exports.differenceBy = differenceBy;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceBy.mjs

@@ -0,0 +1,41 @@
+//#region src/array/differenceBy.ts
+/**
+* Computes the difference between two arrays after mapping their elements through a provided function.
+*
+* This function takes two arrays and a mapper function. It returns a new array containing the elements
+* that are present in the first array but not in the second array, based on the identity calculated
+* by the mapper function.
+*
+* Essentially, it filters out any elements from the first array that, when
+* mapped, match an element in the mapped version of the second array.
+*
+* @template T, U
+* @param firstArr - The primary array from which to derive the difference.
+* @param secondArr - The array containing elements to be excluded from the first array.
+* @param mapper - The function to map the elements of both arrays. This function
+* is applied to each element in both arrays, and the comparison is made based on the mapped values.
+* @returns A new array containing the elements from the first array that do not have a corresponding
+* mapped identity in the second array.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [{ id: 2 }, { id: 4 }];
+* const mapper = item => item.id;
+* const result = differenceBy(array1, array2, mapper);
+* // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [2, 4];
+* const mapper = item => (typeof item === 'object' ? item.id : item);
+* const result = differenceBy(array1, array2, mapper);
+* // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
+*/
+function differenceBy(firstArr, secondArr, mapper) {
+	const mappedSecondSet = new Set(secondArr.map((item) => mapper(item)));
+	return firstArr.filter((item) => {
+		return !mappedSecondSet.has(mapper(item));
+	});
+}
+//#endregion
+export { differenceBy };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceWith.d.mts

@@ -0,0 +1,32 @@
+//#region src/array/differenceWith.d.ts
+/**
+ * Computes the difference between two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom comparison function. It returns a new array containing
+ * the elements that are present in the first array but not in the second array. The comparison to determine
+ * if elements are equal is made using the provided custom function.
+ *
+ * @template T, U
+ * @param firstArr - The array from which to get the difference.
+ * @param secondArr - The array containing elements to exclude from the first array.
+ * @param areItemsEqual - A function to determine if two items are equal.
+ * @returns A new array containing the elements from the first array that do not match any elements in the second array
+ * according to the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
+ */
+declare function differenceWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
+//#endregion
+export { differenceWith };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceWith.d.ts

@@ -0,0 +1,32 @@
+//#region src/array/differenceWith.d.ts
+/**
+ * Computes the difference between two arrays based on a custom equality function.
+ *
+ * This function takes two arrays and a custom comparison function. It returns a new array containing
+ * the elements that are present in the first array but not in the second array. The comparison to determine
+ * if elements are equal is made using the provided custom function.
+ *
+ * @template T, U
+ * @param firstArr - The array from which to get the difference.
+ * @param secondArr - The array containing elements to exclude from the first array.
+ * @param areItemsEqual - A function to determine if two items are equal.
+ * @returns A new array containing the elements from the first array that do not match any elements in the second array
+ * according to the custom equality function.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [{ id: 2 }, { id: 4 }];
+ * const areItemsEqual = (a, b) => a.id === b.id;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+ *
+ * @example
+ * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * const array2 = [2, 4];
+ * const areItemsEqual = (a, b) => a.id === b;
+ * const result = differenceWith(array1, array2, areItemsEqual);
+ * // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
+ */
+declare function differenceWith<T, U>(firstArr: readonly T[], secondArr: readonly U[], areItemsEqual: (x: T, y: U) => boolean): T[];
+//#endregion
+export { differenceWith };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceWith.js

@@ -0,0 +1,38 @@
+//#region src/array/differenceWith.ts
+/**
+* Computes the difference between two arrays based on a custom equality function.
+*
+* This function takes two arrays and a custom comparison function. It returns a new array containing
+* the elements that are present in the first array but not in the second array. The comparison to determine
+* if elements are equal is made using the provided custom function.
+*
+* @template T, U
+* @param firstArr - The array from which to get the difference.
+* @param secondArr - The array containing elements to exclude from the first array.
+* @param areItemsEqual - A function to determine if two items are equal.
+* @returns A new array containing the elements from the first array that do not match any elements in the second array
+* according to the custom equality function.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [{ id: 2 }, { id: 4 }];
+* const areItemsEqual = (a, b) => a.id === b.id;
+* const result = differenceWith(array1, array2, areItemsEqual);
+* // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [2, 4];
+* const areItemsEqual = (a, b) => a.id === b;
+* const result = differenceWith(array1, array2, areItemsEqual);
+* // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
+*/
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+	return firstArr.filter((firstItem) => {
+		return secondArr.every((secondItem) => {
+			return !areItemsEqual(firstItem, secondItem);
+		});
+	});
+}
+//#endregion
+exports.differenceWith = differenceWith;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/differenceWith.mjs

@@ -0,0 +1,38 @@
+//#region src/array/differenceWith.ts
+/**
+* Computes the difference between two arrays based on a custom equality function.
+*
+* This function takes two arrays and a custom comparison function. It returns a new array containing
+* the elements that are present in the first array but not in the second array. The comparison to determine
+* if elements are equal is made using the provided custom function.
+*
+* @template T, U
+* @param firstArr - The array from which to get the difference.
+* @param secondArr - The array containing elements to exclude from the first array.
+* @param areItemsEqual - A function to determine if two items are equal.
+* @returns A new array containing the elements from the first array that do not match any elements in the second array
+* according to the custom equality function.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [{ id: 2 }, { id: 4 }];
+* const areItemsEqual = (a, b) => a.id === b.id;
+* const result = differenceWith(array1, array2, areItemsEqual);
+* // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.
+*
+* @example
+* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* const array2 = [2, 4];
+* const areItemsEqual = (a, b) => a.id === b;
+* const result = differenceWith(array1, array2, areItemsEqual);
+* // result will be [{ id: 1 }, { id: 3 }] since the element with id 2 is considered equal to the second array's element and is excluded from the result.
+*/
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+	return firstArr.filter((firstItem) => {
+		return secondArr.every((secondItem) => {
+			return !areItemsEqual(firstItem, secondItem);
+		});
+	});
+}
+//#endregion
+export { differenceWith };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/drop.d.mts

@@ -0,0 +1,20 @@
+//#region src/array/drop.d.ts
+/**
+ * Removes a specified number of elements from the beginning of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the start.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the beginning of the array.
+ * @returns A new array with the specified number of elements removed from the start.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = drop(array, 2);
+ * // result will be [3, 4, 5] since the first two elements are dropped.
+ */
+declare function drop<T>(arr: readonly T[], itemsCount: number): T[];
+//#endregion
+export { drop };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/drop.d.ts

@@ -0,0 +1,20 @@
+//#region src/array/drop.d.ts
+/**
+ * Removes a specified number of elements from the beginning of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the start.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the beginning of the array.
+ * @returns A new array with the specified number of elements removed from the start.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = drop(array, 2);
+ * // result will be [3, 4, 5] since the first two elements are dropped.
+ */
+declare function drop<T>(arr: readonly T[], itemsCount: number): T[];
+//#endregion
+export { drop };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/drop.js

@@ -0,0 +1,23 @@
+//#region src/array/drop.ts
+/**
+* Removes a specified number of elements from the beginning of an array and returns the rest.
+*
+* This function takes an array and a number, and returns a new array with the specified number
+* of elements removed from the start.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array from which to drop elements.
+* @param itemsCount - The number of elements to drop from the beginning of the array.
+* @returns A new array with the specified number of elements removed from the start.
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const result = drop(array, 2);
+* // result will be [3, 4, 5] since the first two elements are dropped.
+*/
+function drop(arr, itemsCount) {
+	itemsCount = Math.max(itemsCount, 0);
+	return arr.slice(itemsCount);
+}
+//#endregion
+exports.drop = drop;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/drop.mjs

@@ -0,0 +1,23 @@
+//#region src/array/drop.ts
+/**
+* Removes a specified number of elements from the beginning of an array and returns the rest.
+*
+* This function takes an array and a number, and returns a new array with the specified number
+* of elements removed from the start.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array from which to drop elements.
+* @param itemsCount - The number of elements to drop from the beginning of the array.
+* @returns A new array with the specified number of elements removed from the start.
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const result = drop(array, 2);
+* // result will be [3, 4, 5] since the first two elements are dropped.
+*/
+function drop(arr, itemsCount) {
+	itemsCount = Math.max(itemsCount, 0);
+	return arr.slice(itemsCount);
+}
+//#endregion
+export { drop };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/dropRight.d.mts

@@ -0,0 +1,20 @@
+//#region src/array/dropRight.d.ts
+/**
+ * Removes a specified number of elements from the end of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the end.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the end of the array.
+ * @returns A new array with the specified number of elements removed from the end.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropRight(array, 2);
+ * // result will be [1, 2, 3] since the last two elements are dropped.
+ */
+declare function dropRight<T>(arr: readonly T[], itemsCount: number): T[];
+//#endregion
+export { dropRight };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/dropRight.d.ts

@@ -0,0 +1,20 @@
+//#region src/array/dropRight.d.ts
+/**
+ * Removes a specified number of elements from the end of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the end.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array from which to drop elements.
+ * @param itemsCount - The number of elements to drop from the end of the array.
+ * @returns A new array with the specified number of elements removed from the end.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = dropRight(array, 2);
+ * // result will be [1, 2, 3] since the last two elements are dropped.
+ */
+declare function dropRight<T>(arr: readonly T[], itemsCount: number): T[];
+//#endregion
+export { dropRight };

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/dropRight.js

@@ -0,0 +1,24 @@
+//#region src/array/dropRight.ts
+/**
+* Removes a specified number of elements from the end of an array and returns the rest.
+*
+* This function takes an array and a number, and returns a new array with the specified number
+* of elements removed from the end.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array from which to drop elements.
+* @param itemsCount - The number of elements to drop from the end of the array.
+* @returns A new array with the specified number of elements removed from the end.
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const result = dropRight(array, 2);
+* // result will be [1, 2, 3] since the last two elements are dropped.
+*/
+function dropRight(arr, itemsCount) {
+	itemsCount = Math.min(-itemsCount, 0);
+	if (itemsCount === 0) return arr.slice();
+	return arr.slice(0, itemsCount);
+}
+//#endregion
+exports.dropRight = dropRight;

astra_scene_test/X_03/node_modules/es-toolkit/dist/array/dropRight.mjs

@@ -0,0 +1,24 @@
+//#region src/array/dropRight.ts
+/**
+* Removes a specified number of elements from the end of an array and returns the rest.
+*
+* This function takes an array and a number, and returns a new array with the specified number
+* of elements removed from the end.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array from which to drop elements.
+* @param itemsCount - The number of elements to drop from the end of the array.
+* @returns A new array with the specified number of elements removed from the end.
+*
+* @example
+* const array = [1, 2, 3, 4, 5];
+* const result = dropRight(array, 2);
+* // result will be [1, 2, 3] since the last two elements are dropped.
+*/
+function dropRight(arr, itemsCount) {
+	itemsCount = Math.min(-itemsCount, 0);
+	if (itemsCount === 0) return arr.slice();
+	return arr.slice(0, itemsCount);
+}
+//#endregion
+export { dropRight };