@mirta/basics 0.3.4 → 0.4.0

package/dist/fuzzy/index.mjs

@@ -0,0 +1,557 @@
+/**
+ * Порог длины входной строки.
+ *
+ * Строки длиннее этого значения автоматически отклоняются,
+ * чтобы не допустить перегрузку памяти.
+ *
+ * @since 0.4.0
+ *
+ **/
+const INPUT_LENGTH_THRESHOLD = 500;
+
+/**
+ * Нормализует абсолютное расстояние редактирования в относительные метрики.
+ *
+ * @param steps - Количество шагов
+ * @param length - Длина строки
+ * @returns Относительное расстояние
+ *
+ * @since 0.4.0
+ *
+ **/
+function normalizeDistance(steps, length) {
+    const relative = length === 0 ? 0 : steps / length;
+    const similarity = 1 - relative;
+    return { steps, relative, similarity };
+}
+/**
+ * Создаёт матрицу размером `(sizeX + 1) × (sizeY + 1)`.
+ *
+ * @param sizeX - Размер по оси X
+ * @param sizeY - Размер по оси Y
+ * @param defaultValue - Значение по умолчанию
+ * @returns Матрица
+ *
+ * @since 0.4.0
+ *
+ **/
+function createMatrix(sizeX, sizeY, defaultValue) {
+    const matrix = new Array(sizeX + 1);
+    for (let i = 0; i <= sizeX; i++) {
+        const row = new Array(sizeY + 1);
+        for (let j = 0; j <= sizeY; j++) {
+            row[j] = defaultValue;
+        }
+        matrix[i] = row;
+    }
+    return matrix;
+}
+/**
+ * Вычисляет расстояние Дамерау-Левенштейна между двумя строками.
+ *
+ * Сложность: `O(n × m)` 💥 Экспоненциальный рост.
+ *
+ * @param from Первая строка
+ * @param to Вторая строка
+ * @param maxDistance Максимальное расстояние для расчёта.
+ *                    Если превышено, расстояние возвращается как `Infinity`.
+ *
+ * @since 0.4.0
+ *
+ **/
+function damerauLevenshtein(from, to, maxDistance) {
+    const lenFrom = from.length;
+    const lenTo = to.length;
+    // Предотвращает перегрузку памяти, если строки слишком длинные.
+    if (lenFrom > INPUT_LENGTH_THRESHOLD || lenTo > INPUT_LENGTH_THRESHOLD)
+        return { steps: Infinity, relative: Infinity, similarity: -Infinity };
+    const maxLength = Math.max(lenFrom, lenTo);
+    // Эффективный лимит: если maxDistance не задан, используем maxLength + 1
+    const effectiveLimit = maxDistance ?? maxLength + 1;
+    // Ранний выход: если разница в длинах больше limit
+    if (Math.abs(lenFrom - lenTo) > effectiveLimit)
+        return { steps: Infinity, relative: Infinity, similarity: -Infinity };
+    if (lenFrom === 0)
+        return lenTo > effectiveLimit
+            ? { steps: Infinity, relative: Infinity, similarity: -Infinity }
+            : normalizeDistance(lenTo, maxLength);
+    if (lenTo === 0)
+        return lenFrom > effectiveLimit
+            ? { steps: Infinity, relative: Infinity, similarity: -Infinity }
+            : normalizeDistance(lenFrom, maxLength);
+    // Создаём и заполняем матрицу размером (lenFrom + 1) × (lenTo + 1)
+    const matrix = createMatrix(lenFrom, lenTo, Infinity);
+    for (let i = 0; i <= lenFrom; i++)
+        matrix[i][0] = i;
+    for (let j = 0; j <= lenTo; j++)
+        matrix[0][j] = j;
+    for (let i = 1; i <= lenFrom; i++) {
+        // Оптимизация: рассматриваем только ячейки в пределах возможного расстояния
+        const jStart = Math.max(1, i - effectiveLimit);
+        const jEnd = Math.min(lenTo, i + effectiveLimit);
+        for (let j = jStart; j <= jEnd; j++) {
+            const cost = from[i - 1] === to[j - 1] ? 0 : 1;
+            let min = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+            // Транспозиция: перестановка двух соседних символов
+            if (i > 1
+                && j > 1
+                && from[i - 1] === to[j - 2]
+                && from[i - 2] === to[j - 1]) {
+                const transposition = matrix[i - 2][j - 2] + 1;
+                if (transposition < min)
+                    min = transposition;
+            }
+            matrix[i][j] = min;
+        }
+    }
+    const steps = matrix[lenFrom][lenTo];
+    // Если задан maxDistance и фактическое расстояние превышает его,
+    // считаем строки "слишком далёкими" и возвращаем Infinity.
+    //
+    if (maxDistance !== undefined && steps > maxDistance)
+        return { steps: Infinity, relative: Infinity, similarity: -Infinity };
+    return normalizeDistance(steps, maxLength);
+}
+
+/**
+ * Дерево правил Daitch-Mokotoff.
+ * Каждое значение — массив `[начало, перед гласной, иначе]`
+ *
+ * @since 0.4.0
+ *
+ **/
+const codes = Object.freeze({
+    A: {
+        0: [0, -1, -1],
+        I: [[0, 1, -1]],
+        J: [[0, 1, -1]],
+        Y: [[0, 1, -1]],
+        U: [[0, 7, -1]],
+    },
+    B: [[7, 7, 7]],
+    C: {
+        0: [5, 5, 5], // латиница
+        1: [4, 4, 4], // кириллица
+        Z: { 0: [4, 4, 4], S: [[4, 4, 4]] },
+        S: { 0: [4, 4, 4], Z: [[4, 4, 4]] },
+        K: [
+            [5, 5, 5], // латиница
+            [45, 45, 45], // кириллица
+        ],
+        H: {
+            0: [5, 5, 5],
+            1: [4, 4, 4],
+            S: [[5, 54, 54]],
+        },
+    },
+    D: {
+        0: [3, 3, 3],
+        T: [[3, 3, 3]],
+        Z: { 0: [4, 4, 4], H: [[4, 4, 4]], S: [[4, 4, 4]] },
+        S: { 0: [4, 4, 4], H: [[4, 4, 4]], Z: [[4, 4, 4]] },
+        R: { S: [[4, 4, 4]], Z: [[4, 4, 4]] },
+    },
+    E: {
+        0: [0, -1, -1],
+        I: [[0, 1, -1]],
+        J: [[0, 1, -1]],
+        Y: [[0, 1, -1]],
+        U: [[1, 1, -1]],
+        W: [[1, 1, -1]],
+    },
+    F: {
+        0: [7, 7, 7],
+        B: [[7, 7, 7]],
+    },
+    G: [[5, 5, 5]],
+    H: [[5, 5, -1]],
+    I: {
+        0: [0, -1, -1],
+        A: [[1, -1, -1]],
+        E: [[1, -1, -1]],
+        O: [[1, -1, -1]],
+        U: [[1, -1, -1]],
+    },
+    J: [[4, 4, 4]],
+    K: {
+        0: [5, 5, 5],
+        H: [[5, 5, 5]],
+        S: [[5, 54, 54]],
+    },
+    L: [[8, 8, 8]],
+    M: {
+        0: [6, 6, 6],
+        N: [[66, 66, 66]],
+    },
+    N: {
+        0: [6, 6, 6],
+        M: [[66, 66, 66]],
+    },
+    O: {
+        0: [0, -1, -1],
+        I: [[0, 1, -1]],
+        J: [[0, 1, -1]],
+        Y: [[0, 1, -1]],
+    },
+    P: {
+        0: [7, 7, 7],
+        F: [[7, 7, 7]],
+        H: [[7, 7, 7]],
+    },
+    Q: [[5, 5, 5]],
+    R: {
+        0: [9, 9, 9],
+        Z: [[94, 94, 94], [94, 94, 94]],
+        S: [[94, 94, 94], [94, 94, 94]],
+    },
+    S: {
+        0: [4, 4, 4],
+        Z: { 0: [4, 4, 4], T: [[2, 43, 43]], C: { Z: [[2, 4, 4]], S: [[2, 4, 4]] }, D: [[2, 43, 43]] },
+        D: [[2, 43, 43]],
+        T: { 0: [2, 43, 43], R: { Z: [[2, 4, 4]], S: [[2, 4, 4]] }, C: { H: [[2, 4, 4]] }, S: { H: [[2, 4, 4]], C: { H: [[2, 4, 4]] } } },
+        C: { 0: [2, 4, 4], H: { 0: [4, 4, 4], T: { 0: [2, 43, 43], S: { C: { H: [[2, 4, 4]] }, H: [[2, 4, 4]] }, C: { H: [[2, 4, 4]] } }, D: [[2, 43, 43]] } },
+        H: { 0: [4, 4, 4], T: { 0: [2, 43, 43], C: { H: [[2, 4, 4]] }, S: { H: [[2, 4, 4]] } }, C: { H: [[2, 4, 4]] }, D: [[2, 43, 43]] },
+    },
+    T: {
+        0: [3, 3, 3],
+        C: { 0: [4, 4, 4], H: [[4, 4, 4]] },
+        Z: { 0: [4, 4, 4], S: [[4, 4, 4]] },
+        S: { 0: [4, 4, 4], Z: [[4, 4, 4]], H: [[4, 4, 4]], C: { H: [[4, 4, 4]] } },
+        T: { S: { 0: [4, 4, 4], Z: [[4, 4, 4]], C: { H: [[4, 4, 4]] } }, C: { H: [[4, 4, 4]] }, Z: [[4, 4, 4]] },
+        H: [[3, 3, 3]],
+        R: { Z: [[4, 4, 4]], S: [[4, 4, 4]] },
+    },
+    U: {
+        0: [0, -1, -1],
+        E: [[0, -1, -1]],
+        I: [[0, 1, -1]],
+        J: [[0, 1, -1]],
+        Y: [[0, 1, -1]],
+    },
+    V: [[7, 7, 7]],
+    W: [[7, 7, 7]],
+    X: [[5, 54, 54]],
+    Y: [[1, -1, -1]],
+    Z: {
+        0: [4, 4, 4],
+        D: { 0: [2, 43, 43], Z: { 0: [2, 4, 4], H: [[2, 4, 4]] } },
+        H: { 0: [4, 4, 4], D: { 0: [2, 43, 43], Z: { H: [[2, 4, 4]] } } },
+        S: { 0: [4, 4, 4], H: [[4, 4, 4]], C: { H: [[4, 4, 4]] } },
+    },
+});
+
+function translit(input) {
+    const map = {
+        'А': 'A',
+        'Б': 'B',
+        'В': 'V',
+        'Г': 'G',
+        'Д': 'D',
+        'Е': 'E',
+        'Ё': 'YO',
+        'Ж': 'ZH',
+        'З': 'Z',
+        'И': 'I',
+        'Й': 'I',
+        'К': 'K',
+        'Л': 'L',
+        'М': 'M',
+        'Н': 'N',
+        'О': 'O',
+        'П': 'P',
+        'Р': 'R',
+        'С': 'S',
+        'Т': 'T',
+        'У': 'U',
+        'Ф': 'F',
+        'Х': 'H',
+        'Ц': 'CZ',
+        'Ч': 'CH',
+        'Ш': 'SH',
+        'Щ': 'SCH',
+        'Ъ': '\'',
+        'Ы': 'I',
+        'Ь': '\'',
+        'Э': 'E',
+        'Ю': 'YU',
+        'Я': 'YA',
+    };
+    let result = '';
+    for (const char of input) {
+        result += map[char] ?? char;
+    }
+    // Постобработка: CZI → CI, CZE → CE и т.д.
+    return result
+        .replace(/CZI/g, 'CI')
+        .replace(/CZE/g, 'CE')
+        .replace(/CZY/g, 'CY')
+        .replace(/CZJ/g, 'CJ');
+}
+
+/**
+ * Подготавливает строку: очищает, приводит к верхнему регистру,
+ * транслитерирует кириллицу и удаляет не-буквенные символы.
+ *
+ * @since 0.4.0
+ *
+ **/
+function prepareInput(input) {
+    if (!input)
+        return { word: undefined, isCyrillic: false };
+    let word = input
+        .trim()
+        .toUpperCase();
+    const isCyrillic = /[А-ЯЁ]/.test(word);
+    // Транслитерация кириллицы
+    if (isCyrillic)
+        word = translit(word);
+    // Удаляем всё, кроме букв
+    word = word.replace(/[^A-Z]/g, '');
+    return {
+        word: word,
+        isCyrillic,
+    };
+}
+/**
+ * Возвращает правило кодирования: [0] — для латиницы, [1] — для кириллицы.
+ *
+ * @since 0.4.0
+ *
+ **/
+function getRule(node, isCyrillic) {
+    if (isCyrillic && '1' in node)
+        return node[1];
+    return node[0];
+}
+/**
+ * Выбирает код из правила [начало, перед_гласной, иначе]:
+ * - Если в начале слова — [0]
+ * - Если следующий символ — гласная (A,E,I,O,U) — [1]
+ * - Иначе — [2]
+ *
+ * @since 0.4.0
+ *
+ **/
+function selectCode(codeSet, word, position, offset) {
+    if (position === 0)
+        return codeSet[0];
+    const nextChar = word[position + offset];
+    if (nextChar && 'AEIOU'.includes(nextChar))
+        return codeSet[1];
+    return codeSet[2];
+}
+function padRight(str, length, char) {
+    while (str.length < length)
+        str += char;
+    return str.slice(0, length);
+}
+/**
+ * Упрощённая реализация алгоритма Daitch-Mokotoff для фонетического кодирования.
+ *
+ * Сложность: `O(n)` — один проход по строке.
+ *
+ * Преобразует строки в 6-значные коды, устойчивые к опечаткам, транслитерации и диалектным различиям.
+ * Поддерживает кириллицу через транслитерацию.
+ *
+ * @param input - Входная строка (может быть `null` / `undefined`)
+ * @returns 6-значный фонетический код
+ *
+ * @since 0.4.0
+ *
+ **/
+function daitchMokotoffLite(input) {
+    const { word, isCyrillic } = prepareInput(input);
+    if (!word)
+        return '000000';
+    let i = 0;
+    let prev = -1; // Предыдущий добавленный код (для избежания дублей)
+    let lastNode;
+    let currentNode;
+    let result = '';
+    // Основной цикл: обработка по символам с учётом контекстных правил
+    while (i < word.length) {
+        // Начинаем с узла, соответствующего текущему символу
+        currentNode = lastNode = codes[word[i]];
+        let j = 1; // длина текущего совпавшего токена
+        // Поиск самого длинного совпадения (до 6 символов вперёд)
+        for (let k = 1; k < 7; k++) {
+            const char = word[i + k];
+            if (!char || !currentNode[char])
+                break;
+            currentNode = currentNode[char];
+            // Если текущий узел содержит правило (массив кодов) — фиксируем
+            if (currentNode[0]) {
+                lastNode = currentNode;
+                j = k + 1; // обновляем длину
+            }
+        }
+        // Выбираем код в зависимости от позиции и следующего символа
+        const code = selectCode(
+        // Выбираем правило: [0] — латиница, [1] — кириллица
+        getRule(lastNode, isCyrillic), word, i, j);
+        // console.log({
+        //   word,
+        //   char: word[i],
+        //   rule: getRule(lastNode, isCyrillic),
+        //   code,
+        //   j,
+        //   nextChar: word[i + j],
+        // })
+        // Добавляем код, только если он не -1 и не дублирует предыдущий
+        if (code !== -1 && code !== prev)
+            result += String(code);
+        prev = code;
+        i += j; // пропускаем обработанные символы
+    }
+    // Дополняем результат нулями до 6 символов
+    return padRight(result, 6, '0');
+}
+
+/**
+ * Строит множество триграмм для строки.
+ * Добавляет __ в начало и __ в конец.
+ *
+ * Пример: 'abc' → ['__A', '_AB', 'ABC', 'BC_', 'C__']
+ *
+ * @param input - входная строка
+ * @returns Record<TrigramChunk, boolean> — множество триграмм
+ *
+ * @since 0.4.0
+ *
+ **/
+function buildTrigrams(input) {
+    const padded = `__${input.toUpperCase()}__`;
+    const chunks = {};
+    for (let i = 0; i < padded.length - 2; i++) {
+        chunks[padded.slice(i, i + 3)] = true;
+    }
+    return Object.freeze(chunks);
+}
+
+/**
+ * Вычисляет коэффициент подобия Жаккара между двумя наборами триграмм.
+ *
+ * Принимает:
+ * - строку (`from`) → построит триграммы
+ * - или уже построенные триграммы (`from`)
+ *
+ * @param from Исходная строка или её триграммы
+ * @param to Целевая строка
+ * @returns Коэффициент подобия [0..1]
+ *
+ * @since 0.4.0
+ *
+ **/
+function trigramSimilarity(from, to) {
+    let fromTrigrams = {};
+    if (typeof from === 'string') {
+        if (from.length === 0 || to.length === 0)
+            return 0;
+        if (from === to)
+            return 1;
+        fromTrigrams = buildTrigrams(from);
+    }
+    else {
+        if (to.length === 0)
+            return 0;
+        fromTrigrams = from;
+    }
+    const toTrigrams = buildTrigrams(to);
+    let unionScore = 0;
+    let intersectionScore = 0;
+    for (const trigram in fromTrigrams) {
+        if (toTrigrams[trigram])
+            intersectionScore++;
+        unionScore++;
+    }
+    for (const trigram in toTrigrams) {
+        if (!fromTrigrams[trigram])
+            unionScore++;
+    }
+    if (!unionScore)
+        return 0;
+    return intersectionScore / unionScore;
+}
+
+const normalize = (input) => translit(input.toUpperCase());
+function sumWeights(weights = {}) {
+    return (weights.phonetic ?? 0) + (weights.trigram ?? 0) + (weights.levenshtein ?? 0);
+}
+/**
+ * Предлагает наиболее близкое значение из списка допустимых,
+ * используя алгоритм Дамерау-Левенштейна для учёта опечаток.
+ *
+ * Функция предназначена для реализации подсказок вроде:
+ * "Вы имели в виду 'release'?", когда пользователь ввёл 'releas'.
+ *
+ * @param input Введённая пользователем строка, возможно, с опечаткой
+ * @param targetValues Список корректных, допустимых значений (например, команды, флаги)
+ * @param options Настройки нечёткого поиска
+ * @returns Наиболее близкое значение из `knownValues` или `undefined`, если совпадений нет
+ *
+ * @example
+ * ```ts
+ * suggestClosest('releas', ['release', 'publish']) // → 'release'
+ * suggestClosest('релиз', ['release', 'publish'])  // → 'release'
+ * ```
+ * @since 0.4.0
+ *
+ **/
+function suggestClosest(input, targetValues, options = {}) {
+    const { maxDistance = 2, weights = { phonetic: 0.5, trigram: 0.3, levenshtein: 0.2 }, } = options;
+    const inputNorm = normalize(input);
+    let candidates = [];
+    if (!inputNorm)
+        return undefined;
+    for (const value of targetValues) {
+        // Ранний выход - прямое соответствие.
+        if (input === value)
+            return value;
+        const valueNorm = normalize(value);
+        // Ранний выход - прямое соответствие.
+        if (inputNorm === valueNorm)
+            return value;
+        candidates.push({
+            value: value,
+            valueNorm: valueNorm,
+            phonetic: daitchMokotoffLite(value),
+            triScore: 0,
+        });
+    }
+    // Предвычисляем фонетический код и триграммы для ввода
+    const inputPhonetic = daitchMokotoffLite(input);
+    const inputTrigrams = buildTrigrams(inputNorm);
+    const phoneticCandidates = candidates.filter(c => c.phonetic === inputPhonetic);
+    // Замена кандидатов на фонетические, если есть прямые совпадения
+    // Если нет фонетических совпадений — используем все
+    //
+    if (phoneticCandidates.length > 0)
+        candidates = phoneticCandidates;
+    candidates = candidates.map((c) => {
+        c.triScore = trigramSimilarity(inputTrigrams, c.valueNorm);
+        return c;
+    });
+    const top10 = candidates
+        .sort((a, b) => b.triScore - a.triScore)
+        .slice(0, 10);
+    const totalWeight = sumWeights(weights);
+    const normWeight = (weight) => (totalWeight === 0 ? 0 : (weight ?? 0) / totalWeight);
+    let bestScore = -1;
+    let bestValue;
+    for (const candidate of top10) {
+        const { similarity: levScore } = damerauLevenshtein(inputNorm, candidate.valueNorm, maxDistance);
+        if (levScore <= 0)
+            continue; // Пропускаем, если расстояние слишком большое.
+        const phoneticScore = candidate.phonetic === inputPhonetic ? 1 : 0;
+        const score = phoneticScore * normWeight(weights.phonetic)
+            + candidate.triScore * normWeight(weights.trigram)
+            + levScore * normWeight(weights.levenshtein);
+        if (score > bestScore) {
+            bestScore = score;
+            bestValue = candidate.value;
+        }
+    }
+    return bestValue;
+}
+
+export { daitchMokotoffLite, damerauLevenshtein, suggestClosest };

package/dist/guards.mjs

@@ -0,0 +1,133 @@
+/**
+ * Проверяет, является ли переданное значение строковым примитивом (`string`).
+ *
+ * @param value - Значение, которое необходимо проверить.
+ * @returns `true`, если значение является строкой (`string`), иначе `false`.
+ *
+ * @example
+ * ```ts
+ * isString('hello'); // true
+ * isString(123);     // false
+ * ```
+ * @since 0.0.2
+ *
+ **/
+const isString = (value) => typeof value === 'string';
+/**
+ * Проверяет, является ли переданное значение числовым примитивом (`number`), не равным `NaN`.
+ *
+ * @param value - Значение, которое необходимо проверить.
+ * @returns `true`, если значение является числом (`number`) и не является `NaN`, иначе `false`.
+ *
+ * @example
+ * ```ts
+ * isNumber(42)   // true
+ * isNumber('42') // false
+ * isNumber(NaN)  // false
+ * ```
+ * @since 0.0.2
+ *
+ **/
+const isNumber = (value) => typeof value === 'number' && !isNaN(value);
+/**
+ * Проверяет, является ли переданное значение булевым примитивом (`boolean`).
+ *
+ * @param value - Значение, которое необходимо проверить.
+ * @returns `true`, если значение является булевым примитивом (`true` или `false`), иначе `false`.
+ *
+ * @remarks
+ * Не возвращает `true` для объектов `Boolean`, даже если они обёрнуты.
+ *
+ * @example
+ *
+ * ```ts
+ * isBoolean(true)              // true
+ * isBoolean(false)             // true
+ * isBoolean(1)                 // false
+ * isBoolean('true')            // false
+ * isBoolean(new Boolean(true)) // false (это объект, не примитив)
+ * ```
+ * @since 0.0.2
+ *
+ **/
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/**
+ * Проверяет, является ли переданное значение функцией.
+ *
+ * @param value - Значение, которое необходимо проверить.
+ * @returns `true`, если значение является функцией (включая стрелочные функции, функции-объявления, методы и т.д.), иначе `false`.
+ *
+ * @example
+ * ```ts
+ * isFunction(() => {});      // true
+ * isFunction(function() {}); // true
+ * isFunction(Math.max);      // true
+ * isFunction(class {});      // true (в JS классы — это функции)
+ * isFunction({});            // false
+ * isFunction('function');    // false
+ * ```
+ * @since 0.1.0
+ *
+ **/
+const isFunction = (value) => typeof value === 'function';
+/**
+ * Проверяет, является ли значение объектом —
+ * имеет тип `object` и не равно `null`.
+ *
+ * @remarks
+ * Проходят массивы и все объектные типы, включая
+ * встроенные (`Date`, `Map`, `Set`, `RegExp` и прочие).
+ *
+ * @param value - Проверяемое значение.
+ * @returns `true`, если это объект.
+ *
+ * @example
+ * ```ts
+ * isObject({})       // true
+ * isObject([])       // true
+ *
+ * isObject(() => {}) // false
+ * isObject(null)     // false
+ * isObject('hello')  // false
+ * isObject(42)       // false
+ * ```
+ * @since 0.4.0
+ */
+const isObject = (value) => value !== null && typeof value === 'object';
+/**
+ * Проверяет, является ли значение "обычным объектом" —
+ * имеет прототип `Object.prototype` или `null`.
+ *
+ * @remarks
+ * Не проходят массивы и встроенные типы (`Date`, `Map`, `Set`, `RegExp` и прочие).
+ *
+ * Не пройдёт и `Object.create({})`, т.к. экземпляр _унаследован_ от обычного объекта `{}`.
+ *
+ * @param value - Проверяемое значение.
+ *
+ * @returns `true`, если это обычный объект.
+ *
+ * @example
+ * ```ts
+ * isPlainObject({})                  // true
+ * isPlainObject({ a: 1, b: 2 })      // true
+ * isPlainObject(Object.create(null)) // true
+ *
+ * isPlainObject(Object.create({}))   // false
+ * isPlainObject(new Date())          // false
+ * isPlainObject(() => {})            // false
+ * isPlainObject([])                  // false
+ * ```
+ * @since 0.4.0
+ *
+ **/
+const isPlainObject = (value) => {
+    if (!isObject(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+};
+
+export { isNumber as a, isBoolean as b, isFunction as c, isObject as d, isPlainObject as e, isString as i };