@dxtmisha/wiki 0.39.1 → 0.39.2

package/src/media/functional/functional-basic/functions/isFunction/isFunction.en.mdx

@@ -0,0 +1,25 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isFunction - Check if value is a function'/>
+
+# `isFunction`
+
+Determines whether the provided value is an executable function (including arrow functions, asynchronous functions, and generator functions).
+
+The check operates primarily via the `instanceof Function` operator, with a fallback safety check against `typeof callback === 'function'`.
+
+**Parameters:**
+- `callback: T` — The variable to be tested.
+
+**Returns:**
+`boolean` — Yields `true` when the argument is a valid function, returning `false` otherwise. Functions as a dedicated TypeScript type guard narrowing the type specifically down to `FunctionArgs<any, any>`.
+
+```typescript
+import { isFunction } from '@dxtmisha/functional-basic'
+
+const myLogger = () => console.log('Hi!')
+
+console.log(isFunction(myLogger)) // true
+console.log(isFunction({ myLogger })) // false
+console.log(isFunction('myLogger')) // false
+```

package/src/media/functional/functional-basic/functions/isFunction/isFunction.ru.mdx

@@ -0,0 +1,25 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isFunction - Проверка на функцию'/>
+
+# `isFunction`
+
+Определяет, является ли переданное значение исполняемой функцией (включая стрелочные, асинхронные функции и функции-генераторы).
+
+Проверка осуществляется с использованием оператора `instanceof Function`, а также запасной проверки `typeof callback === 'function'`.
+
+**Параметры:**
+- `callback: T` — Значение для проверки.
+
+**Возвращает:**
+`boolean` — Вернет `true`, если аргумент является функцией, и `false` в противном случае. Также работает как защитник типа (type guard), сужая тип до `FunctionArgs<any, any>`.
+
+```typescript
+import { isFunction } from '@dxtmisha/functional-basic'
+
+const myLogger = () => console.log('Hi!')
+
+console.log(isFunction(myLogger)) // true
+console.log(isFunction({ myLogger })) // false
+console.log(isFunction('myLogger')) // false
+```

package/src/media/functional/functional-basic/functions/isFunction/isFunction.vi.mdx

@@ -0,0 +1,25 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isFunction - Kiểm tra kiểu hàm'/>
+
+# `isFunction`
+
+Trực tiếp định hình xem thông số truyền tải có phải là một chức năng khả thi chạy dạng hàm/function hay không (bao hàm luôn cả hàm mũi tên arrow function, hàm bất đồng bộ async function, và cả chức năng sinh generator function).
+
+Cuộc điều kiểm này tuân lệnh vận hành dưới phép kiểm tra chuyên biệt `instanceof Function`, hỗ trợ cùng phương pháp hậu bị truyền thống `typeof callback === 'function'`.
+
+**Tham số:**
+- `callback: T` — Biến cần được định chuẩn.
+
+**Trả về:**
+`boolean` — Hồi báo kết quả `true` chỉ khi thông số truyền đúng thật là định dạng một hàm. Đóng luôn vai trò rào chắn kiểu bảo hộ TypeScript nhằm rẽ gọn biến xuống riêng diện mạo `FunctionArgs<any, any>`.
+
+```typescript
+import { isFunction } from '@dxtmisha/functional-basic'
+
+const myLogger = () => console.log('Hi!')
+
+console.log(isFunction(myLogger)) // true
+console.log(isFunction({ myLogger })) // false
+console.log(isFunction('myLogger')) // false
+```

package/src/media/functional/functional-basic/functions/isInDom/isInDom.en.mdx

@@ -0,0 +1,21 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isInDom - Check if element is in DOM'/>
+
+# `isInDom`
+
+Checks if an element is still in the DOM tree.
+
+**Parameters:**
+- `element: ElementOrString<E>` — selectors for matching or an Element.
+
+**Returns:**
+`boolean` — `true` if the element is in the DOM, otherwise `false`.
+
+```typescript
+import { isInDom } from '@dxtmisha/functional-basic'
+
+const div = document.createElement('div')
+document.body.appendChild(div)
+console.log(isInDom(div)) // true
+```

package/src/media/functional/functional-basic/functions/isInDom/isInDom.ru.mdx

@@ -0,0 +1,21 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isInDom - Проверка наличия элемента в DOM'/>
+
+# `isInDom`
+
+Проверяет, находится ли еще элемент в дереве DOM.
+
+**Параметры:**
+- `element: ElementOrString<E>` — селекторов для сопоставления или Element.
+
+**Возвращает:**
+`boolean` — `true`, если элемент находится в DOM, иначе `false`.
+
+```typescript
+import { isInDom } from '@dxtmisha/functional-basic'
+
+const div = document.createElement('div')
+document.body.appendChild(div)
+console.log(isInDom(div)) // true
+```

package/src/media/functional/functional-basic/functions/isInDom/isInDom.vi.mdx

@@ -0,0 +1,21 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isInDom - Kiểm tra xem phần tử có trong DOM không'/>
+
+# `isInDom`
+
+Kiểm tra xem một phần tử có còn trong cây DOM hay không.
+
+**Tham số:**
+- `element: ElementOrString<E>` — bộ chọn để khớp hoặc một Element.
+
+**Trả về:**
+`boolean` — `true` nếu phần tử có trong DOM, ngược lại là `false`.
+
+```typescript
+import { isInDom } from '@dxtmisha/functional-basic'
+
+const div = document.createElement('div')
+document.body.appendChild(div)
+console.log(isInDom(div)) // true
+```

package/src/media/functional/functional-basic/functions/isInput/isInput.en.mdx

@@ -0,0 +1,23 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isInput - Check for input element'/>
+
+# `isInput`
+
+Checks if the element is an input field (`input`, `textarea`, `select`) or an element with the `contenteditable` attribute.
+
+**Parameters:**
+- `element: HTMLElement | EventTarget | null` — the element to check.
+
+**Returns:**
+`boolean` — `true` if the element is an input field or editable, otherwise `false`.
+
+```typescript
+import { isInput } from '@dxtmisha/functional-basic'
+
+const input = document.createElement('input')
+isInput(input) // true
+
+const div = document.createElement('div')
+isInput(div) // false
+```

package/src/media/functional/functional-basic/functions/isInput/isInput.ru.mdx

@@ -0,0 +1,23 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isInput - Проверка на элемент ввода'/>
+
+# `isInput`
+
+Проверяет, является ли элемент полем ввода (`input`, `textarea`, `select`) или элементом с атрибутом `contenteditable`.
+
+**Параметры:**
+- `element: HTMLElement | EventTarget | null` — проверяемый элемент.
+
+**Возвращает:**
+`boolean` — `true`, если элемент является полем ввода или редактируемым, иначе `false`.
+
+```typescript
+import { isInput } from '@dxtmisha/functional-basic'
+
+const input = document.createElement('input')
+isInput(input) // true
+
+const div = document.createElement('div')
+isInput(div) // false
+```

package/src/media/functional/functional-basic/functions/isInput/isInput.vi.mdx

@@ -0,0 +1,23 @@
+import {Meta} from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isInput - Kiểm tra phần tử đầu vào'/>
+
+# `isInput`
+
+Kiểm tra xem phần tử có phải là trường nhập liệu (`input`, `textarea`, `select`) hoặc phần tử có thuộc tính `contenteditable` hay không.
+
+**Tham số:**
+- `element: HTMLElement | EventTarget | null` — phần tử cần kiểm tra.
+
+**Trả về:**
+`boolean` — `true` nếu phần tử là trường nhập liệu hoặc có thể chỉnh sửa, ngược lại là `false`.
+
+```typescript
+import { isInput } from '@dxtmisha/functional-basic'
+
+const input = document.createElement('input')
+isInput(input) // true
+
+const div = document.createElement('div')
+isInput(div) // false
+```

package/src/media/functional/functional-basic/functions/isIntegerBetween/isIntegerBetween.en.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isIntegerBetween - Check value within integer bounds'/>
+
+# `isIntegerBetween`
+
+Inspects whether a targeted float or integer actively rests within a specifically demarcated integer interval bounds.
+
+The threshold is established by flooring the foundational `between` input parameter. The function secures a true match exactly when the checking measurement is comprehensively greater than or equal to the grounded lower boundary, whilst being strictly inferior to the successive integer step.
+
+Formula representation: `floor(between) <= value < floor(between) + 1`
+
+**Parameters:**
+- `value: number` — The comparative number undergoing the test.
+- `between: number` — The base origin dictating the interval bounds via mathematical floor rounding.
+
+**Returns:**
+`boolean` — Evaluates to `true` whenever the measurement comfortably exists within the outlined mathematical floor span.
+
+```typescript
+import { isIntegerBetween } from '@dxtmisha/functional-basic'
+
+// Formed Interval: [5, 6)
+console.log(isIntegerBetween(5.2, 5.8)) // true (Math.floor(5.8) = 5)
+console.log(isIntegerBetween(5.99, 5))  // true
+console.log(isIntegerBetween(6, 5))     // false
+```

package/src/media/functional/functional-basic/functions/isIntegerBetween/isIntegerBetween.ru.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isIntegerBetween - Проверка вхождения в целочисленный интервал'/>
+
+# `isIntegerBetween`
+
+Проверяет, находится ли заданное число в пределах определенного целочисленного интервала. 
+
+Интервал определяется путем округления в меньшую сторону базового значения (`between`). Функция вернет истину, если проверяемое число больше или равно нижней границе (целому числу), но строго меньше следующего целого числа. 
+
+Формула: `floor(between) <= value < floor(between) + 1`
+
+**Параметры:**
+- `value: number` — Проверяемое число.
+- `between: number` — Базовое число, определяющее интервал после округления вниз.
+
+**Возвращает:**
+`boolean` — `true`, если число находится в заданном целочисленном диапазоне.
+
+```typescript
+import { isIntegerBetween } from '@dxtmisha/functional-basic'
+
+// Интервал [5, 6)
+console.log(isIntegerBetween(5.2, 5.8)) // true (Math.floor(5.8) = 5)
+console.log(isIntegerBetween(5.99, 5))  // true
+console.log(isIntegerBetween(6, 5))     // false
+```

package/src/media/functional/functional-basic/functions/isIntegerBetween/isIntegerBetween.vi.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isIntegerBetween - Kiểm tra lọt khe số nguyên'/>
+
+# `isIntegerBetween`
+
+Rà soát cẩn thận xem một con số cụ thể có đang lọt lỏm ngay bên trong lằn ranh phân cách thuộc một phạm vi số nguyên đã được xác lập hay không.
+
+Biên độ rào chắn sẽ được cắm mốc bằng cách làm tròn xuống trị số trung tâm (`between`). Hàm chỉ xác thực thành công khi con số đưa vào đem ra đọ kiếm có độ lớn hơn hoặc bằng mức sàn giới hạn dưới, đồng thời buộc phải mang trị số vĩnh viễn nhỏ hơn mốc số nguyên nối tiếp ngay ngay liền kề sau đó.
+
+Tóm tắt công thức toán học: `floor(between) <= value < floor(between) + 1`
+
+**Tham số:**
+- `value: number` — Trị giá được điền lên để kiểm thử.
+- `between: number` — Con số chủ đạo để ấn định khoanh vùng phạm vi (qua áp dụng thuật toán làm tròn xuống).
+
+**Trả về:**
+`boolean` — Tín hiệu trả về `true` miễn sao trị số nằm gọn trong khoảng không gian vòng đệm số lượng đã khoanh vùng.
+
+```typescript
+import { isIntegerBetween } from '@dxtmisha/functional-basic'
+
+// Không gian kẹp: [5, 6)
+console.log(isIntegerBetween(5.2, 5.8)) // true (Math.floor(5.8) = 5)
+console.log(isIntegerBetween(5.99, 5))  // true
+console.log(isIntegerBetween(6, 5))     // false
+```

package/src/media/functional/functional-basic/functions/isNull/isNull.en.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isNull - Check for null or undefined'/>
+
+# `isNull`
+
+An explicit, stringent utility focused entirely on confirming if a presented variable strictly equals either `null` or `undefined`.
+
+Distinguished from a conventional negative falsy check like `!value` (which intercepts valid zeroes `0`, vacuous strings `''`, and `false` toggles), this function deliberately sidesteps those values, honing in flawlessly on absent definitions.
+
+**Parameters:**
+- `value: T` — Any inclusive subject variable requested to be verified.
+
+**Returns:**
+`boolean` — Returns `true` uniformly whenever confronted with a raw `null` or an isolated `undefined` marker. It likewise fulfills the responsibility as a TypeScript type guard, securely minimizing the scope to `Undefined` (`null | undefined`).
+
+```typescript
+import { isNull } from '@dxtmisha/functional-basic'
+
+console.log(isNull(null)) // true
+console.log(isNull(undefined)) // true
+
+// Routine falsy traps revert as false logically
+console.log(isNull(0)) // false
+console.log(isNull('')) // false
+console.log(isNull(false)) // false
+```

package/src/media/functional/functional-basic/functions/isNull/isNull.ru.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isNull - Проверка на null или undefined'/>
+
+# `isNull`
+
+Конкретная и строгая проверка значения на соответствие исключительно `null` или `undefined`. 
+
+В отличие от обычной проверки `!value` (где строка `''`, число `0` и булево `false` также приведут к прохождению условия), эта функция отфильтрует все ложные (falsy) значения и оставит только те, которые фактически не определены.
+
+**Параметры:**
+- `value: T` — Любое проверяемое значение.
+
+**Возвращает:**
+`boolean` — Вернет `true`, если переменная равна `null` либо `undefined`. Функция также выступает как type guard TypeScript, сужающий тип переменной до `Undefined` (`null | undefined`).
+
+```typescript
+import { isNull } from '@dxtmisha/functional-basic'
+
+console.log(isNull(null)) // true
+console.log(isNull(undefined)) // true
+
+// Другие falsy значения возвращают false
+console.log(isNull(0)) // false
+console.log(isNull('')) // false
+console.log(isNull(false)) // false
+```

package/src/media/functional/functional-basic/functions/isNull/isNull.vi.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isNull - Kiểm định null hoặc undefined'/>
+
+# `isNull`
+
+Một chiêu thức thẩm định hết mực khắt khe, duy chỉ theo dấu nhắm thẳng vào duy nhất hai định mục đó là thông số `null` hoặc `undefined`.
+
+Thoát ly hẳn hoàn toàn ra khỏi cách phủ định falsy phổ cập đi kèm như kiểu `!value` (có thể vô tình bắt nhầm cả con số `0`, dải xâu chuỗi rỗng thênh thang `''`, hay ngay cả boolean lật ngược `false`), hàm logic đơn độc này sẽ nhẹ nhàng lánh sang mọi thứ tạp nham đó và chiếu thẳng cốt lỗi vào một vùng không chứa bất kì cái gì cả.
+
+**Tham số:**
+- `value: T` — Giá trị bất luận loại nào được bệ lên bàn mổ soi thử độ tồn tại.
+
+**Trả về:**
+`boolean` — Gõ thông điệp `true` bất cứ kì khoảnh khắc nào đối diện bằng nhãn trúng tâm phác hoạ `null` hay mã `undefined`. Trợ thủ siêu phàm này cùng đút túi chức năng bộ bảo vệ type guard TypeScript để cắt chặt giới hạn ép khuôn theo cấu kiện `Undefined` (`null | undefined`).
+
+```typescript
+import { isNull } from '@dxtmisha/functional-basic'
+
+console.log(isNull(null)) // true
+console.log(isNull(undefined)) // true
+
+// Cạm bẫy giá trị falsy khác vẫn ra kết quả false
+console.log(isNull(0)) // false
+console.log(isNull('')) // false
+console.log(isNull(false)) // false
+```

package/src/media/functional/functional-basic/functions/isNumber/isNumber.en.mdx

@@ -0,0 +1,28 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isNumber - Check if value is a number'/>
+
+# `isNumber`
+
+A versatile utility engineered to ascertain if an incoming argument acts effectively as a valid numerical entity.
+
+This evaluation effortlessly handles the native numeric typing (`typeof value === 'number'`), meaning it natively clears primitive numbers (inclusive of unique types like `NaN`). Simultaneously, it expands validation to test strings by running a robust RegEx check ensuring that the entirety of the string constitutes a valid numeric format (including negative values and fractional decimals).
+
+**Parameters:**
+- `value: any` — The arbitrary data item to screen.
+
+**Returns:**
+`boolean` — Emits `true` if the subject naturally belongs to the quantitative number type or if it's a completely digital string structure. Displays `false` in every alternative state.
+
+```typescript
+import { isNumber } from '@dxtmisha/functional-basic'
+
+console.log(isNumber(150)) // true
+console.log(isNumber(3.14)) // true
+console.log(isNumber('720')) // true (Numeric String allowed natively)
+
+console.log(isNumber('-50')) // true (Negative numbers are supported)
+console.log(isNumber('3.14')) // true (Decimals are allowed too)
+console.log(isNumber('15a')) // false (Fails due to alphanumeric content)
+console.log(isNumber(null)) // false
+```

package/src/media/functional/functional-basic/functions/isNumber/isNumber.ru.mdx

@@ -0,0 +1,28 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isNumber - Проверка на число'/>
+
+# `isNumber`
+
+Универсальная утилита для проверки, может ли переданное значение квалифицироваться как число. 
+
+Она корректно распознает как классический тип числа `typeof value === 'number'` (включая особые случаи, такие как `NaN` или отрицательные значения), так и строковые представления чисел, убедившись с помощью регулярного выражения `regex`, что переданная строка содержит корректный числовой формат (включая целые, отрицательные и дробные числа).
+
+**Параметры:**
+- `value: any` — Любое тестируемое значение.
+
+**Возвращает:**
+`boolean` — Вернет `true`, если объект данных относится к математическим числам либо если строка состоит только из цифр. В противном случае вернет `false`.
+
+```typescript
+import { isNumber } from '@dxtmisha/functional-basic'
+
+console.log(isNumber(150)) // true
+console.log(isNumber(3.14)) // true
+console.log(isNumber('720')) // true (Строка, содержащая только цифры)
+
+console.log(isNumber('-50')) // true (Отрицательные числа поддерживаются)
+console.log(isNumber('3.14')) // true (Дробные числа тоже)
+console.log(isNumber('15a')) // false (Содержит букву)
+console.log(isNumber(null)) // false
+```

package/src/media/functional/functional-basic/functions/isNumber/isNumber.vi.mdx

@@ -0,0 +1,28 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isNumber - Kiểm tra tính chất con số'/>
+
+# `isNumber`
+
+Tiện ích chuyên biệt có khả năng nhìn thấu vấn đề liệu một yếu tố đưa qua phân tích trần định có hoàn toàn được cấu trúc dưới tư cách một bảng mạch thể loại con số chuẩn xác hay không.
+
+Tính năng hoạt động tương thích hoàn hảo kiểu loại cấu thành `typeof value === 'number'` nên mặc định cho qua các con số dương, số âm và kể cả thông số dị dạng toán học như `NaN`. Phi thường hơn, nó nhận thu và xử lý tốt ngay cả những xâu chuỗi văn bản thông qua thuật toán giải mã RegEx để bóc xem phần tử chuỗi truyền vào thực sự mang cấu trúc định dạng chuẩn số hay không (ủng hộ cả số âm và số có phần thập phân).
+
+**Tham số:**
+- `value: any` — Mức giá trị thập cẩm bất kỳ để khảo sát.
+
+**Trả về:**
+`boolean` — Giải phóng biến kiểm tra `true` nếu nguồn căn thuộc thể trạng chữ số lý thuyết hay hệ thống dải văn bản cấu tạo chỉ bởi số liệu đơn thuần. Sẽ cho ra `false` khi có bất trắc nào dính lẫn kí tự ngoại vi ngoài chữ số.
+
+```typescript
+import { isNumber } from '@dxtmisha/functional-basic'
+
+console.log(isNumber(150)) // true
+console.log(isNumber(3.14)) // true
+console.log(isNumber('720')) // true (Chấp thuận dòng chuỗi số liệu)
+
+console.log(isNumber('-50')) // true (Hỗ trợ chuỗi chứa số âm)
+console.log(isNumber('3.14')) // true (Hỗ trợ cấu trúc số thập phân)
+console.log(isNumber('15a')) // false (Vì pha trộn lẫn với kí tự chữ a)
+console.log(isNumber(null)) // false
+```

package/src/media/functional/functional-basic/functions/isObject/isObject.en.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isObject - Check if value is an object'/>
+
+# `isObject`
+
+A foundational utility explicitly formulated for performing safe, immediate checks regarding whether a given argument legitimately constitutes an object.
+
+In pure JavaScript logic, `typeof null` fundamentally yields the notorious `'object'` string result, inadvertently instigating phantom bugs. `isObject` expertly navigates around this notorious quirk by initiating a truthy checkpoint (`Boolean(value)`) completely shielding execution paths from `null` or undefined pitfalls prior to affirming the exact object type condition. Take caution to realize that structural arrays (`[]`) count as standard objects under JS protocols, so they successfully yield `true` here.
+
+**Parameters:**
+- `value: T` — Any inclusive subject evaluation target variable.
+
+**Returns:**
+`boolean` — Yields `true` solely if the entity demonstrates fundamental object classification (including collections like arrays). Defaults to generating `false` outputs across null bindings, isolated variables, primitives, and actionable functions. Acts simultaneously as a strict TypeGuard reducing typings to `Record<any, any>`.
+
+```typescript
+import { isObject } from '@dxtmisha/functional-basic'
+
+console.log(isObject({ id: 1 })) // true
+console.log(isObject([1, 2, 3])) // true (Arrays are strictly typed as objects underlying JS!)
+
+// Safeguarded boundaries rejecting familiar JS snags
+console.log(isObject(null)) // false
+console.log(isObject(100)) // false
+console.log(isObject('string')) // false
+```

package/src/media/functional/functional-basic/functions/isObject/isObject.ru.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isObject - Проверка на объект'/>
+
+# `isObject`
+
+Базовая утилита, предназначенная для быстрой и безопасной проверки того, является ли значение истинно объектом.
+
+В JavaScript определение типов работает с нюансами: оператор `typeof null` возвращает строку `'object'`, что зачастую ведет к скрытым ошибкам. Эта функция обходит эту проблему, предварительно проверяя значение на truthiness (`Boolean(value)`), чтобы навсегда отсечь `null` и другие ложные идентификаторы, после чего проводит строгую проверку типа. Обратите внимание, что массивы (`[]`) в JavaScript также являются объектами и поэтому дадут результат `true`.
+
+**Параметры:**
+- `value: T` — Проверяемое значение.
+
+**Возвращает:**
+`boolean` — Вернет `true`, когда значение является экземпляром объекта (в том числе массивом). Вернет `false` для любых примитивов, `null`, `undefined` и функций. Выступает в качестве защитника типа (type guard), сужая тип до `Record<any, any>`.
+
+```typescript
+import { isObject } from '@dxtmisha/functional-basic'
+
+console.log(isObject({ id: 1 })) // true
+console.log(isObject([1, 2, 3])) // true (Массивы в JS - это технически объекты!)
+
+// Строгая проверка исключает сюрпризы JS
+console.log(isObject(null)) // false
+console.log(isObject(100)) // false
+console.log(isObject('string')) // false
+```

package/src/media/functional/functional-basic/functions/isObject/isObject.vi.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/vi/functional-basic/Functions/isObject - Khảo sát bản chất đối tượng'/>
+
+# `isObject`
+
+Công cụ tiện nghi cấp cơ sở rèn đúc chuyên cho nhu cầu tra soát nhanh gọn và an toàn để chốt chắc chắn một biến truyền vào có thực thể thuộc dòng tộc đối tượng object thuần hay không.
+
+Vì đặc thù lạ lùng của mã JavaScript, câu lệnh `typeof null` luôn giở mặt báo ra chữ `'object'`, đây vốn dĩ luôn là nguyên nhân chôn giấu bao rủi ro trục trặc mờ ám. Vượt qua yếu huyệt này, hàm kiểm tra bật lên màng bảo mật rà quét truthy gắt gao (`Boolean(value)`) nhằm triệt tiêu thẳng cánh cái nhãn `null` dối trá và sau đó bắt đầu điều tra tính xác định object nguyên nghĩa. Xin chú ý cặn kẽ vì các mảng (`[]`) rễ gốc trong Javascript mặc định coi là một dạng đối tượng phái sinh nên thử nghiệm lên tính năng này thì vẫn vạch ra `true`.
+
+**Tham số:**
+- `value: T` — Giá trị đưa tới thực nghiệm khảo lược thông số.
+
+**Trả về:**
+`boolean` — Phát nhượng hồi thư `true` nếu thể xác định đúng khớp đối tượng hoặc mảng liên kết (arrays). Đáp số lại chỉ toàn `false` văng vào mặt nhóm tham số kiểu vô ngã `null`, đơn nguyên primitives, hay khối định luật functions. Cùng vận hành làm bức thành rào cản Type Guard khoanh thu vùng định loại xuống `Record<any, any>`.
+
+```typescript
+import { isObject } from '@dxtmisha/functional-basic'
+
+console.log(isObject({ id: 1 })) // true
+console.log(isObject([1, 2, 3])) // true (Các mảng danh sách đều có chung bản chất là đối tượng ẩn sau Javascript!)
+
+// Thanh trừng triệt để ma trận cạm bẫy JS
+console.log(isObject(null)) // false
+console.log(isObject(100)) // false
+console.log(isObject('string')) // false
+```

package/src/media/functional/functional-basic/functions/isObjectNotArray/isObjectNotArray.en.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/en/functional-basic/Functions/isObjectNotArray - Strict object verification'/>
+
+# `isObjectNotArray`
+
+Executes an advanced screening operation directly ensuring the tested item constitutes a textbook plain object structure `{}` (Record) while being **assuredly devoid of any array traits**.
+
+Following the intrinsic principle that the elementary `isObject` utility registers `true` inherently when probing arrays (due to JavaScript's rudimentary heritage), this precise function rectifies that quirk. By fusing foundational `isObject(value)` authentication mechanics with a robust `!Array.isArray(value)` safeguard mechanism, arrays are systematically disqualified.
+
+**Parameters:**
+- `value: T` — Any element waiting for inspection.
+
+**Returns:**
+`boolean` — Generates `true` solely corresponding to authentic objects structured as `{ key: 'value' }`. Yields `false` automatically when combating arrays `[]`, elusive nulls, functional instances, or standard primitive values. Employs reliable type guarding capabilities that carefully extract the pure Object Record architecture while discarding intersecting null, undefined or array overlaps.
+
+```typescript
+import { isObjectNotArray } from '@dxtmisha/functional-basic'
+
+// Successful validation boundaries
+console.log(isObjectNotArray({ id: 1, name: 'Test' })) // true
+
+// Scenarios safely bypassed without tripping false positives
+console.log(isObjectNotArray([1, 2, 3])) // false (Array defense shield actively rejects arrays!)
+console.log(isObjectNotArray(null)) // false
+console.log(isObjectNotArray('string')) // false
+```

package/src/media/functional/functional-basic/functions/isObjectNotArray/isObjectNotArray.ru.mdx

@@ -0,0 +1,27 @@
+import { Meta } from '@storybook/addon-docs/blocks'
+
+<Meta title='@dxtmisha/ru/functional-basic/Functions/isObjectNotArray - Проверка на строгий объект'/>
+
+# `isObjectNotArray`
+
+Выполняет расширенную проверку значения, чтобы убедиться, что оно является классическим объектом `{}` (Record) и при этом **гарантированно не является массивом**.
+
+Поскольку функция базовая утилита `isObject` возвращает `true` даже для массивов (согласно специфике типов JavaScript), данная функция решает эту проблему, комбинируя оригинальную логику `isObject(value)` со строгой проверкой `!Array.isArray(value)`. 
+
+**Параметры:**
+- `value: T` — Проверяемое значение.
+
+**Возвращает:**
+`boolean` — Вернет `true` исключительно для истинных объектов `{ key: 'value' }`. Вернет `false` для массивов `[]`, null, функций и всех примитивных типов данных. Выступает в качестве защитника типа (type guard), извлекая тип формы объекта и исключая возможные массивы или пустые значения (null/undefined).
+
+```typescript
+import { isObjectNotArray } from '@dxtmisha/functional-basic'
+
+// Успешная валидация
+console.log(isObjectNotArray({ id: 1, name: 'Test' })) // true
+
+// Типичные сценарии, где функция отфильтрует "ненужные" объекты
+console.log(isObjectNotArray([1, 2, 3])) // false (Защита от массивов работает!)
+console.log(isObjectNotArray(null)) // false
+console.log(isObjectNotArray('string')) // false
+```