@rogolev/value 0.0.3 → 0.0.5

package/src/helpers/array/array_udiff_assoc.mjs

@@ -0,0 +1,71 @@
+import array_udiff_uassoc from './array_udiff_uassoc.mjs';
+
+/**
+ * Вычисляет расхождение между массивами с использованием пользовательской функции сравнения для значений и ассоциативного сравнения ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_udiff_assoc` используется для вычисления расхождения между массивами с использованием пользовательской функции сравнения для значений и ассоциативного сравнения ключей.
+ * Она возвращает ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `original_array` (object): Исходный массив.
+ * - `...arrays` (object): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 1. Сравнение массивов с использованием пользовательской функции сравнения:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: 2, c: 3 };
+ *    const array1 = { a: 1, b: 2 };
+ *    const result = array_udiff_assoc(value_compare_func, original_array, array1);
+ *    console.log(result); // { c: 3 }
+ *    ```
+ *
+ * 2. Обработка пустых массивов:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = {};
+ *    const array1 = {};
+ *    const result = array_udiff_assoc(value_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_udiff_assoc('not a function', 'not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value_compare_func" должен быть функцией.
+ *    }
+ *    ```
+ *
+ * 4. Сравнение массивов с различными типами данных:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: '2', c: true };
+ *    const array1 = { a: 1, b: 2, d: false };
+ *    const result = array_udiff_assoc(value_compare_func, original_array, array1);
+ *    console.log(result); // { b: '2', c: true }
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает ассоциативный массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_udiff_assoc(value_compare_func, original_array, ...arrays) {
+    return array_udiff_uassoc(value_compare_func, (a, b) => a === b, original_array, ...arrays);
+}

package/src/helpers/array/array_udiff_uassoc.mjs

@@ -0,0 +1,124 @@
+import is_array from '../is_array.mjs';
+import is_function from '../is_function.mjs';
+
+/**
+ * Вычисляет расхождение между массивами с использованием пользовательских функций сравнения для значений и ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_udiff_uassoc` используется для вычисления расхождения между массивами с использованием пользовательских функций сравнения для значений и ключей.
+ * Она возвращает массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `key_compare_func` (function): Функция для сравнения ключей.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 1. Сравнение массивов с использованием пользовательских функций сравнения:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const key_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: 2, c: 3 };
+ *    const array1 = { a: 1, b: 2 };
+ *    const array2 = { d: 4 };
+ *    const result = array_udiff_uassoc(value_compare_func, key_compare_func, original_array, array1, array2);
+ *    console.log(result); // { c: 3 }
+ *    ```
+ *
+ * 2. Обработка пустых массивов:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const key_compare_func = (a, b) => a === b;
+ *    const original_array = {};
+ *    const array1 = {};
+ *    const result = array_udiff_uassoc(value_compare_func, key_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_udiff_uassoc('not a function', 'not a function', 'not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value_compare_func" должен быть функцией.
+ *    }
+ *    ```
+ *
+ * 4. Сравнение массивов с различными типами данных:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const key_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: '2', c: true };
+ *    const array1 = { a: 1, b: 2, d: false };
+ *    const result = array_udiff_uassoc(value_compare_func, key_compare_func, original_array, array1);
+ *    console.log(result); // { b: '2', c: true }
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {function} key_compare_func Функция для сравнения ключей.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые отсутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_udiff_uassoc(
+    value_compare_func,
+    key_compare_func,
+    original_array,
+    ...arrays
+) {
+    if (!is_function(value_compare_func)) {
+        throw new TypeError('Параметр "value_compare_func" должен быть функцией.');
+    }
+
+    if (!is_function(key_compare_func)) {
+        throw new TypeError('Параметр "key_compare_func" должен быть функцией.');
+    }
+
+    if (!is_array(original_array)) {
+        throw new TypeError('Параметр "original_array" должен быть массивом.');
+    }
+
+    if (!arrays.every((array) => is_array(array))) {
+        throw new TypeError('Параметр "arrays" должен быть массивом.');
+    }
+
+    const result = {};
+
+    // Перебираем исходный массив
+    original: for (const original_key in original_array) {
+        const original_value = original_array[original_key];
+
+        // Каждую пару ключ-значение из исходного массива мы сравниваем с парами из исходных массивов.
+        // Если совпадение найдено, переходим к следующей паре ключ-значение из исходного массива.
+        for (const array of arrays) {
+            for (const key in array) {
+                const value = array[key];
+
+                if (
+                    key_compare_func(original_key, key) &&
+                    value_compare_func(original_value, value)
+                ) {
+                    continue original;
+                }
+            }
+        }
+
+        // Если совпадений не найдено, записываем пару ключ-значение из исходного массива в расхождение.
+        result[original_key] = original_value;
+    }
+
+    return result;
+}

package/src/helpers/array/array_uintersect.mjs

@@ -0,0 +1,72 @@
+import array_uintersect_uassoc from './array_uintersect_uassoc.mjs';
+
+/**
+ * Вычисляет пересечение между массивами с использованием пользовательской функции сравнения для значений.
+ *
+ * ### Описание
+ *
+ * Функция `array_uintersect` используется для вычисления пересечения между массивами с использованием пользовательской функции сравнения для значений.
+ * Она возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 1. Сравнение массивов с использованием пользовательской функции сравнения:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: 2, c: 3 };
+ *    const array1 = { a: 1, b: 2 };
+ *    const array2 = { b: 2, c: 3 };
+ *    const result = array_uintersect(value_compare_func, original_array, array1, array2);
+ *    console.log(result); // { a: 1, b: 2, c: 3 }
+ *    ```
+ *
+ * 2. Обработка пустых массивов:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = {};
+ *    const array1 = {};
+ *    const result = array_uintersect(value_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_uintersect('not a function', 'not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value_compare_func" должен быть функцией.
+ *    }
+ *    ```
+ *
+ * 4. Сравнение массивов с различными типами данных:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: '2', c: true };
+ *    const array1 = { a: 1, b: 2, d: false };
+ *    const result = array_uintersect(value_compare_func, original_array, array1);
+ *    console.log(result); // { a: 1 }
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_uintersect(value_compare_func, original_array, ...arrays) {
+    return array_uintersect_uassoc(value_compare_func, () => true, original_array, ...arrays);
+}

package/src/helpers/array/array_uintersect_assoc.mjs

@@ -0,0 +1,77 @@
+import array_uintersect_uassoc from './array_uintersect_uassoc.mjs';
+
+/**
+ * Вычисляет пересечение между массивами с использованием пользовательской функции сравнения для значений и стандартной функции сравнения для ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_uintersect_assoc` используется для вычисления пересечения между массивами с использованием пользовательской функции сравнения для значений и стандартной функции сравнения для ключей.
+ * Она возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 1. Сравнение массивов с использованием пользовательской функции сравнения:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: 2, c: 3 };
+ *    const array1 = { a: 1, b: 2 };
+ *    const array2 = { b: 2, c: 3 };
+ *    const result = array_uintersect_assoc(value_compare_func, original_array, array1, array2);
+ *    console.log(result); // { a: 1, b: 2, c: 3 }
+ *    ```
+ *
+ * 2. Обработка пустых массивов:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = {};
+ *    const array1 = {};
+ *    const result = array_uintersect_assoc(value_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_uintersect_assoc('not a function', 'not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value_compare_func" должен быть функцией.
+ *    }
+ *    ```
+ *
+ * 4. Сравнение массивов с различными типами данных:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: '2', c: true };
+ *    const array1 = { a: 1, b: 2, d: false };
+ *    const result = array_uintersect_assoc(value_compare_func, original_array, array1);
+ *    console.log(result); // { a: 1 }
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_uintersect_assoc(value_compare_func, original_array, ...arrays) {
+    return array_uintersect_uassoc(
+        value_compare_func,
+        (a, b) => a === b,
+        original_array,
+        ...arrays,
+    );
+}

package/src/helpers/array/array_uintersect_uassoc.mjs

@@ -0,0 +1,121 @@
+import is_array from '../is_array.mjs';
+import is_function from '../is_function.mjs';
+
+/**
+ * Вычисляет пересечение между массивами с использованием пользовательских функций сравнения для значений и ключей.
+ *
+ * ### Описание
+ *
+ * Функция `array_uintersect_uassoc` используется для вычисления пересечения между массивами с использованием пользовательских функций сравнения для значений и ключей.
+ * Она возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Параметры
+ *
+ * - `value_compare_func` (function): Функция для сравнения значений.
+ * - `key_compare_func` (function): Функция для сравнения ключей.
+ * - `original_array` (array): Исходный массив.
+ * - `...arrays` (array): Массивы для сравнения.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ *
+ * ### Примеры использования
+ *
+ * 1. Сравнение массивов с использованием пользовательских функций сравнения:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const key_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: 2, c: 3 };
+ *    const array1 = { a: 1, b: 2 };
+ *    const array2 = { b: 2, c: 3 };
+ *    const result = array_uintersect_uassoc(value_compare_func, key_compare_func, original_array, array1, array2);
+ *    console.log(result); // { a: 1, b: 2, c: 3 }
+ *    ```
+ *
+ * 2. Обработка пустых массивов:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const key_compare_func = (a, b) => a === b;
+ *    const original_array = {};
+ *    const array1 = {};
+ *    const result = array_uintersect_uassoc(value_compare_func, key_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_uintersect_uassoc('not a function', 'not a function', 'not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "value_compare_func" должен быть функцией.
+ *    }
+ *    ```
+ *
+ * 4. Сравнение массивов с различными типами данных:
+ *
+ *    ```js
+ *    const value_compare_func = (a, b) => a === b;
+ *    const key_compare_func = (a, b) => a === b;
+ *    const original_array = { a: 1, b: '2', c: true };
+ *    const array1 = { a: 1, b: 2, d: false };
+ *    const result = array_uintersect_uassoc(value_compare_func, key_compare_func, original_array, array1);
+ *    console.log(result); // {}
+ *    ```
+ *
+ * @param {function} value_compare_func Функция для сравнения значений.
+ * @param {function} key_compare_func Функция для сравнения ключей.
+ * @param {object} original_array Исходный массив.
+ * @param {...object} arrays Массивы для сравнения.
+ * @returns {object} Возвращает массив, содержащий элементы из первого массива, которые присутствуют в других массивах.
+ * @throws {TypeError} Если параметры не являются функциями или массивами.
+ */
+export default function array_uintersect_uassoc(
+    value_compare_func,
+    key_compare_func,
+    original_array,
+    ...arrays
+) {
+    if (!is_function(value_compare_func)) {
+        throw new TypeError('Параметр "value_compare_func" должен быть функцией.');
+    }
+
+    if (!is_function(key_compare_func)) {
+        throw new TypeError('Параметр "key_compare_func" должен быть функцией.');
+    }
+
+    if (!is_array(original_array)) {
+        throw new TypeError('Параметр "original_array" должен быть массивом.');
+    }
+
+    if (!arrays.every((v) => is_array(v))) {
+        throw new TypeError('Параметр "arrays" должен быть массивом.');
+    }
+
+    const result = {};
+
+    // Перебираем исходный массив
+    for (const original_key in original_array) {
+        const original_value = original_array[original_key];
+
+        // Каждую пару ключ-значение из исходного массива мы сравниваем с парами из массивов для сравнения.
+        // Если совпадение найдено, записываем ее в результат.
+        for (const array of arrays) {
+            for (const key in array) {
+                const value = array[key];
+
+                if (
+                    key_compare_func(original_key, key) &&
+                    value_compare_func(original_value, value)
+                ) {
+                    result[original_key] = original_value;
+                }
+            }
+        }
+    }
+
+    return result;
+}

package/src/helpers/array/array_unique.mjs

@@ -0,0 +1,77 @@
+import array from '../array.mjs';
+import is_array from '../is_array.mjs';
+import is_list from '../is_list.mjs';
+
+/**
+ * Удаляет дублирующиеся значения из массива.
+ *
+ * ### Описание
+ *
+ * Функция `array_unique` используется для удаления дублирующихся значений из массива.
+ * Она поддерживает как обычные массивы, так и ассоциативные массивы (объекты с ключами и значениями).
+ *
+ * ### Параметры
+ *
+ * - `arr` (object): Исходный массив.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает новый массив без дублирующихся значений.
+ *
+ * ### Примеры использования
+ *
+ * 1. Удаление дублирующихся значений из обычного массива:
+ *
+ *    ```js
+ *    const array = [1, 2, 2, 3, 4, 4, 5];
+ *    const result = array_unique(array);
+ *    console.log(result); // [1, 2, 3, 4, 5]
+ *    ```
+ *
+ * 2. Удаление дублирующихся значений из ассоциативного массива:
+ *
+ *    ```js
+ *    const array = { a: 1, b: 2, c: 2, d: 3, e: 4, f: 4, g: 5 };
+ *    const result = array_unique(array);
+ *    console.log(result); // { a: 1, b: 2, d: 3, e: 4, g: 5 }
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_unique('not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "arr" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив.
+ * @returns {object} Возвращает новый массив без дублирующихся значений.
+ * @throws {TypeError} Если параметр не является массивом.
+ */
+export default function array_unique(arr) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    if (is_list(arr)) {
+        return arr.reduce((carry, v) => {
+            if (!carry.includes(v)) {
+                carry.push(v);
+            }
+
+            return carry;
+        }, []);
+    }
+
+    const result = array({});
+
+    for (const [k, v] of Object.entries(arr)) {
+        if (!Object.values(result).includes(v)) {
+            result[k] = v;
+        }
+    }
+
+    return result;
+}

package/src/helpers/array/array_unshift.mjs

@@ -0,0 +1,64 @@
+import is_array from '../is_array.mjs';
+import array_splice from './array_splice.mjs';
+
+/**
+ * Добавляет один или несколько элементов в начало массива.
+ *
+ * ### Описание
+ *
+ * Функция `array_unshift` используется для добавления одного или нескольких элементов в начало массива.
+ * Она поддерживает как обычные массивы, так и ассоциативные массивы (объекты с ключами и значениями).
+ *
+ * ### Параметры
+ *
+ * - `arr` (object): Исходный массив.
+ * - `...values` (any[]): Элементы для добавления в начало массива.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает новую длину массива после добавления элементов.
+ *
+ * ### Примеры использования
+ *
+ * 1. Добавление элементов в обычный массив:
+ *
+ *    ```js
+ *    const array = [2, 3, 4];
+ *    const result = array_unshift(array, 0, 1);
+ *    console.log(result); // 5
+ *    console.log(array); // [0, 1, 2, 3, 4]
+ *    ```
+ *
+ * 2. Добавление элементов в ассоциативный массив:
+ *
+ *    ```js
+ *    const array = { b: 2, c: 3 };
+ *    const result = array_unshift(array, { a: 1 });
+ *    console.log(result); // 3
+ *    console.log(array); // { a: 1, b: 2, c: 3 }
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_unshift('not an array', 1);
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "arr" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив.
+ * @param {...any} values Элементы для добавления в начало массива.
+ * @returns {number} Возвращает новую длину массива после добавления элементов.
+ * @throws {TypeError} Если параметр не является массивом.
+ */
+export default function array_unshift(arr, ...values) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    array_splice(arr, 0, 0, ...values);
+
+    return Object.keys(arr).length;
+}

package/src/helpers/array/array_values.mjs

@@ -0,0 +1,57 @@
+import is_array from '../is_array.mjs';
+
+/**
+ * Возвращает массив значений из переданного массива или объекта.
+ *
+ * ### Описание
+ *
+ * Функция `array_values` используется для извлечения всех значений из переданного массива или объекта.
+ * Она поддерживает как обычные массивы, так и ассоциативные массивы (объекты с ключами и значениями).
+ *
+ * ### Параметры
+ *
+ * - `arr` (object): Исходный массив или объект.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает массив значений из переданного массива или объекта.
+ *
+ * ### Примеры использования
+ *
+ * 1. Извлечение значений из обычного массива:
+ *
+ *    ```js
+ *    const array = [1, 2, 3];
+ *    const result = array_values(array);
+ *    console.log(result); // [1, 2, 3]
+ *    ```
+ *
+ * 2. Извлечение значений из ассоциативного массива:
+ *
+ *    ```js
+ *    const array = { a: 1, b: 2, c: 3 };
+ *    const result = array_values(array);
+ *    console.log(result); // [1, 2, 3]
+ *    ```
+ *
+ * 3. Обработка значений, не являющихся массивами:
+ *
+ *    ```js
+ *    try {
+ *        const result = array_values('not an array');
+ *    } catch (e) {
+ *        console.error(e.message); // Параметр "arr" должен быть массивом.
+ *    }
+ *    ```
+ *
+ * @param {object} arr Исходный массив или объект.
+ * @returns {any[]} Возвращает массив значений из переданного массива или объекта.
+ * @throws {TypeError} Если параметр не является массивом или объектом.
+ */
+export default function array_values(arr) {
+    if (!is_array(arr)) {
+        throw new TypeError('Параметр "arr" должен быть массивом.');
+    }
+
+    return Object.values(arr);
+}