es-toolkit 1.35.0 → 1.36.0-dev.1215

package/dist/_chunk/snakeCase-BtVEeB.js

@@ -1,75 +0,0 @@
-'use strict';
-
-function capitalize(str) {
-    return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase());
-}
-
-const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
-function words(str) {
-    return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
-}
-
-function camelCase(str) {
-    const words$1 = words(str);
-    if (words$1.length === 0) {
-        return '';
-    }
-    const [first, ...rest] = words$1;
-    return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`;
-}
-
-const deburrMap = new Map(Object.entries({
-    Æ: 'Ae',
-    Ð: 'D',
-    Ø: 'O',
-    Þ: 'Th',
-    ß: 'ss',
-    æ: 'ae',
-    ð: 'd',
-    ø: 'o',
-    þ: 'th',
-    Đ: 'D',
-    đ: 'd',
-    Ħ: 'H',
-    ħ: 'h',
-    ı: 'i',
-    IJ: 'IJ',
-    ij: 'ij',
-    ĸ: 'k',
-    Ŀ: 'L',
-    ŀ: 'l',
-    Ł: 'L',
-    ł: 'l',
-    ʼn: "'n",
-    Ŋ: 'N',
-    ŋ: 'n',
-    Œ: 'Oe',
-    œ: 'oe',
-    Ŧ: 'T',
-    ŧ: 't',
-    ſ: 's',
-}));
-function deburr(str) {
-    str = str.normalize('NFD');
-    let result = '';
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        if ((char >= '\u0300' && char <= '\u036f') || (char >= '\ufe20' && char <= '\ufe23')) {
-            continue;
-        }
-        result += deburrMap.get(char) ?? char;
-    }
-    return result;
-}
-
-function snakeCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toLowerCase()).join('_');
-}
-
-exports.CASE_SPLIT_PATTERN = CASE_SPLIT_PATTERN;
-exports.camelCase = camelCase;
-exports.capitalize = capitalize;
-exports.deburr = deburr;
-exports.snakeCase = snakeCase;
-exports.words = words;

package/dist/_chunk/toSnakeCaseKeys-BNpS71.js

@@ -1,569 +0,0 @@
-'use strict';
-
-const isPlainObject$1 = require('./isPlainObject-Xaozpc.js');
-require('./partialRight-B0_CSB.js');
-const snakeCase = require('./snakeCase-BtVEeB.js');
-
-function clone(obj) {
-    if (isPlainObject$1.isPrimitive(obj)) {
-        return obj;
-    }
-    if (Array.isArray(obj) ||
-        isPlainObject$1.isTypedArray(obj) ||
-        obj instanceof ArrayBuffer ||
-        (typeof SharedArrayBuffer !== 'undefined' && obj instanceof SharedArrayBuffer)) {
-        return obj.slice(0);
-    }
-    const prototype = Object.getPrototypeOf(obj);
-    const Constructor = prototype.constructor;
-    if (obj instanceof Date || obj instanceof Map || obj instanceof Set) {
-        return new Constructor(obj);
-    }
-    if (obj instanceof RegExp) {
-        const newRegExp = new Constructor(obj);
-        newRegExp.lastIndex = obj.lastIndex;
-        return newRegExp;
-    }
-    if (obj instanceof DataView) {
-        return new Constructor(obj.buffer.slice(0));
-    }
-    if (obj instanceof Error) {
-        const newError = new Constructor(obj.message);
-        newError.stack = obj.stack;
-        newError.name = obj.name;
-        newError.cause = obj.cause;
-        return newError;
-    }
-    if (typeof File !== 'undefined' && obj instanceof File) {
-        const newFile = new Constructor([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
-        return newFile;
-    }
-    if (typeof obj === 'object') {
-        const newObject = Object.create(prototype);
-        return Object.assign(newObject, obj);
-    }
-    return obj;
-}
-
-function cloneDeepWith(obj, cloneValue) {
-    return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue);
-}
-function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
-    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
-    if (cloned != null) {
-        return cloned;
-    }
-    if (isPlainObject$1.isPrimitive(valueToClone)) {
-        return valueToClone;
-    }
-    if (stack.has(valueToClone)) {
-        return stack.get(valueToClone);
-    }
-    if (Array.isArray(valueToClone)) {
-        const result = new Array(valueToClone.length);
-        stack.set(valueToClone, result);
-        for (let i = 0; i < valueToClone.length; i++) {
-            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
-        }
-        if (Object.hasOwn(valueToClone, 'index')) {
-            result.index = valueToClone.index;
-        }
-        if (Object.hasOwn(valueToClone, 'input')) {
-            result.input = valueToClone.input;
-        }
-        return result;
-    }
-    if (valueToClone instanceof Date) {
-        return new Date(valueToClone.getTime());
-    }
-    if (valueToClone instanceof RegExp) {
-        const result = new RegExp(valueToClone.source, valueToClone.flags);
-        result.lastIndex = valueToClone.lastIndex;
-        return result;
-    }
-    if (valueToClone instanceof Map) {
-        const result = new Map();
-        stack.set(valueToClone, result);
-        for (const [key, value] of valueToClone) {
-            result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
-        }
-        return result;
-    }
-    if (valueToClone instanceof Set) {
-        const result = new Set();
-        stack.set(valueToClone, result);
-        for (const value of valueToClone) {
-            result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue));
-        }
-        return result;
-    }
-    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
-        return valueToClone.subarray();
-    }
-    if (isPlainObject$1.isTypedArray(valueToClone)) {
-        const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length);
-        stack.set(valueToClone, result);
-        for (let i = 0; i < valueToClone.length; i++) {
-            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
-        }
-        return result;
-    }
-    if (valueToClone instanceof ArrayBuffer ||
-        (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) {
-        return valueToClone.slice(0);
-    }
-    if (valueToClone instanceof DataView) {
-        const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
-        stack.set(valueToClone, result);
-        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
-        return result;
-    }
-    if (typeof File !== 'undefined' && valueToClone instanceof File) {
-        const result = new File([valueToClone], valueToClone.name, {
-            type: valueToClone.type,
-        });
-        stack.set(valueToClone, result);
-        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
-        return result;
-    }
-    if (valueToClone instanceof Blob) {
-        const result = new Blob([valueToClone], { type: valueToClone.type });
-        stack.set(valueToClone, result);
-        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
-        return result;
-    }
-    if (valueToClone instanceof Error) {
-        const result = new valueToClone.constructor();
-        stack.set(valueToClone, result);
-        result.message = valueToClone.message;
-        result.name = valueToClone.name;
-        result.stack = valueToClone.stack;
-        result.cause = valueToClone.cause;
-        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
-        return result;
-    }
-    if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) {
-        const result = Object.create(Object.getPrototypeOf(valueToClone));
-        stack.set(valueToClone, result);
-        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
-        return result;
-    }
-    return valueToClone;
-}
-function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
-    const keys = [...Object.keys(source), ...isPlainObject$1.getSymbols(source)];
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const descriptor = Object.getOwnPropertyDescriptor(target, key);
-        if (descriptor == null || descriptor.writable) {
-            target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
-        }
-    }
-}
-function isCloneableObject(object) {
-    switch (isPlainObject$1.getTag(object)) {
-        case isPlainObject$1.argumentsTag:
-        case isPlainObject$1.arrayTag:
-        case isPlainObject$1.arrayBufferTag:
-        case isPlainObject$1.dataViewTag:
-        case isPlainObject$1.booleanTag:
-        case isPlainObject$1.dateTag:
-        case isPlainObject$1.float32ArrayTag:
-        case isPlainObject$1.float64ArrayTag:
-        case isPlainObject$1.int8ArrayTag:
-        case isPlainObject$1.int16ArrayTag:
-        case isPlainObject$1.int32ArrayTag:
-        case isPlainObject$1.mapTag:
-        case isPlainObject$1.numberTag:
-        case isPlainObject$1.objectTag:
-        case isPlainObject$1.regexpTag:
-        case isPlainObject$1.setTag:
-        case isPlainObject$1.stringTag:
-        case isPlainObject$1.symbolTag:
-        case isPlainObject$1.uint8ArrayTag:
-        case isPlainObject$1.uint8ClampedArrayTag:
-        case isPlainObject$1.uint16ArrayTag:
-        case isPlainObject$1.uint32ArrayTag: {
-            return true;
-        }
-        default: {
-            return false;
-        }
-    }
-}
-
-function cloneDeep(obj) {
-    return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
-}
-
-function findKey(obj, predicate) {
-    const keys = Object.keys(obj);
-    return keys.find(key => predicate(obj[key], key, obj));
-}
-
-function flattenObject(object, { delimiter = '.' } = {}) {
-    return flattenObjectImpl(object, '', delimiter);
-}
-function flattenObjectImpl(object, prefix = '', delimiter = '.') {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
-        if (isPlainObject$1.isPlainObject(value) && Object.keys(value).length > 0) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
-            continue;
-        }
-        if (Array.isArray(value)) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
-            continue;
-        }
-        result[prefixedKey] = value;
-    }
-    return result;
-}
-
-function invert(obj) {
-    const result = {};
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        result[value] = key;
-    }
-    return result;
-}
-
-function mapKeys(object, getNewKey) {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        result[getNewKey(value, key, object)] = value;
-    }
-    return result;
-}
-
-function mapValues(object, getNewValue) {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        result[key] = getNewValue(value, key, object);
-    }
-    return result;
-}
-
-function merge(target, source) {
-    const sourceKeys = Object.keys(source);
-    for (let i = 0; i < sourceKeys.length; i++) {
-        const key = sourceKeys[i];
-        const sourceValue = source[key];
-        const targetValue = target[key];
-        if (Array.isArray(sourceValue)) {
-            if (Array.isArray(targetValue)) {
-                target[key] = merge(targetValue, sourceValue);
-            }
-            else {
-                target[key] = merge([], sourceValue);
-            }
-        }
-        else if (isPlainObject$1.isPlainObject(sourceValue)) {
-            if (isPlainObject$1.isPlainObject(targetValue)) {
-                target[key] = merge(targetValue, sourceValue);
-            }
-            else {
-                target[key] = merge({}, sourceValue);
-            }
-        }
-        else if (targetValue === undefined || sourceValue !== undefined) {
-            target[key] = sourceValue;
-        }
-    }
-    return target;
-}
-
-function isObjectLike(value) {
-    return typeof value === 'object' && value !== null;
-}
-
-function omitBy(obj, shouldOmit) {
-    const result = {};
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        if (!shouldOmit(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-function isArray(value) {
-    return Array.isArray(value);
-}
-
-function bind(func, thisObj, ...partialArgs) {
-    const bound = function (...providedArgs) {
-        const args = [];
-        let startIndex = 0;
-        for (let i = 0; i < partialArgs.length; i++) {
-            const arg = partialArgs[i];
-            if (arg === bind.placeholder) {
-                args.push(providedArgs[startIndex++]);
-            }
-            else {
-                args.push(arg);
-            }
-        }
-        for (let i = startIndex; i < providedArgs.length; i++) {
-            args.push(providedArgs[i]);
-        }
-        if (this instanceof bound) {
-            return new func(...args);
-        }
-        return func.apply(thisObj, args);
-    };
-    return bound;
-}
-const bindPlaceholder = Symbol('bind.placeholder');
-bind.placeholder = bindPlaceholder;
-
-function bindKey(object, key, ...partialArgs) {
-    const bound = function (...providedArgs) {
-        const args = [];
-        let startIndex = 0;
-        for (let i = 0; i < partialArgs.length; i++) {
-            const arg = partialArgs[i];
-            if (arg === bindKey.placeholder) {
-                args.push(providedArgs[startIndex++]);
-            }
-            else {
-                args.push(arg);
-            }
-        }
-        for (let i = startIndex; i < providedArgs.length; i++) {
-            args.push(providedArgs[i]);
-        }
-        if (this instanceof bound) {
-            return new object[key](...args);
-        }
-        return object[key].apply(object, args);
-    };
-    return bound;
-}
-const bindKeyPlaceholder = Symbol('bindKey.placeholder');
-bindKey.placeholder = bindKeyPlaceholder;
-
-function curry(func, arity = func.length, guard) {
-    arity = guard ? func.length : arity;
-    arity = Number.parseInt(arity, 10);
-    if (Number.isNaN(arity) || arity < 1) {
-        arity = 0;
-    }
-    const wrapper = function (...partialArgs) {
-        const holders = partialArgs.filter(item => item === curry.placeholder);
-        const length = partialArgs.length - holders.length;
-        if (length < arity) {
-            return makeCurry(func, arity - length, partialArgs);
-        }
-        if (this instanceof wrapper) {
-            return new func(...partialArgs);
-        }
-        return func.apply(this, partialArgs);
-    };
-    wrapper.placeholder = curryPlaceholder;
-    return wrapper;
-}
-function makeCurry(func, arity, partialArgs) {
-    function wrapper(...providedArgs) {
-        const holders = providedArgs.filter(item => item === curry.placeholder);
-        const length = providedArgs.length - holders.length;
-        providedArgs = composeArgs$1(providedArgs, partialArgs);
-        if (length < arity) {
-            return makeCurry(func, arity - length, providedArgs);
-        }
-        if (this instanceof wrapper) {
-            return new func(...providedArgs);
-        }
-        return func.apply(this, providedArgs);
-    }
-    wrapper.placeholder = curryPlaceholder;
-    return wrapper;
-}
-function composeArgs$1(providedArgs, partialArgs) {
-    const args = [];
-    let startIndex = 0;
-    for (let i = 0; i < partialArgs.length; i++) {
-        const arg = partialArgs[i];
-        if (arg === curry.placeholder && startIndex < providedArgs.length) {
-            args.push(providedArgs[startIndex++]);
-        }
-        else {
-            args.push(arg);
-        }
-    }
-    for (let i = startIndex; i < providedArgs.length; i++) {
-        args.push(providedArgs[i]);
-    }
-    return args;
-}
-const curryPlaceholder = Symbol('curry.placeholder');
-curry.placeholder = curryPlaceholder;
-
-function curryRight(func, arity = func.length, guard) {
-    arity = guard ? func.length : arity;
-    arity = Number.parseInt(arity, 10);
-    if (Number.isNaN(arity) || arity < 1) {
-        arity = 0;
-    }
-    const wrapper = function (...partialArgs) {
-        const holders = partialArgs.filter(item => item === curryRight.placeholder);
-        const length = partialArgs.length - holders.length;
-        if (length < arity) {
-            return makeCurryRight(func, arity - length, partialArgs);
-        }
-        if (this instanceof wrapper) {
-            return new func(...partialArgs);
-        }
-        return func.apply(this, partialArgs);
-    };
-    wrapper.placeholder = curryRightPlaceholder;
-    return wrapper;
-}
-function makeCurryRight(func, arity, partialArgs) {
-    function wrapper(...providedArgs) {
-        const holders = providedArgs.filter(item => item === curryRight.placeholder);
-        const length = providedArgs.length - holders.length;
-        providedArgs = composeArgs(providedArgs, partialArgs);
-        if (length < arity) {
-            return makeCurryRight(func, arity - length, providedArgs);
-        }
-        if (this instanceof wrapper) {
-            return new func(...providedArgs);
-        }
-        return func.apply(this, providedArgs);
-    }
-    wrapper.placeholder = curryRightPlaceholder;
-    return wrapper;
-}
-function composeArgs(providedArgs, partialArgs) {
-    const placeholderLength = partialArgs.filter(arg => arg === curryRight.placeholder).length;
-    const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
-    const args = [];
-    let providedIndex = 0;
-    for (let i = 0; i < rangeLength; i++) {
-        args.push(providedArgs[providedIndex++]);
-    }
-    for (let i = 0; i < partialArgs.length; i++) {
-        const arg = partialArgs[i];
-        if (arg === curryRight.placeholder) {
-            if (providedIndex < providedArgs.length) {
-                args.push(providedArgs[providedIndex++]);
-            }
-            else {
-                args.push(arg);
-            }
-        }
-        else {
-            args.push(arg);
-        }
-    }
-    return args;
-}
-const curryRightPlaceholder = Symbol('curryRight.placeholder');
-curryRight.placeholder = curryRightPlaceholder;
-
-function isPlainObject(object) {
-    if (typeof object !== 'object') {
-        return false;
-    }
-    if (object == null) {
-        return false;
-    }
-    if (Object.getPrototypeOf(object) === null) {
-        return true;
-    }
-    if (Object.prototype.toString.call(object) !== '[object Object]') {
-        const tag = object[Symbol.toStringTag];
-        if (tag == null) {
-            return false;
-        }
-        const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
-        if (isTagReadonly) {
-            return false;
-        }
-        return object.toString() === `[object ${tag}]`;
-    }
-    let proto = object;
-    while (Object.getPrototypeOf(proto) !== null) {
-        proto = Object.getPrototypeOf(proto);
-    }
-    return Object.getPrototypeOf(object) === proto;
-}
-
-function toCamelCaseKeys(obj) {
-    if (isArray(obj)) {
-        return obj.map(item => toCamelCaseKeys(item));
-    }
-    if (isPlainObject(obj)) {
-        const result = {};
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const camelKey = snakeCase.camelCase(key);
-            const camelCaseKeys = toCamelCaseKeys(obj[key]);
-            result[camelKey] = camelCaseKeys;
-        }
-        return result;
-    }
-    return obj;
-}
-
-function toMerged(target, source) {
-    return merge(cloneDeep(target), source);
-}
-
-function toSnakeCaseKeys(obj) {
-    if (isArray(obj)) {
-        return obj.map(item => toSnakeCaseKeys(item));
-    }
-    if (isPlainObject(obj)) {
-        const result = {};
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const snakeKey = snakeCase.snakeCase(key);
-            const snakeCaseKeys = toSnakeCaseKeys(obj[key]);
-            result[snakeKey] = snakeCaseKeys;
-        }
-        return result;
-    }
-    return obj;
-}
-
-exports.bind = bind;
-exports.bindKey = bindKey;
-exports.clone = clone;
-exports.cloneDeep = cloneDeep;
-exports.cloneDeepWith = cloneDeepWith;
-exports.copyProperties = copyProperties;
-exports.curry = curry;
-exports.curryRight = curryRight;
-exports.findKey = findKey;
-exports.flattenObject = flattenObject;
-exports.invert = invert;
-exports.isArray = isArray;
-exports.isObjectLike = isObjectLike;
-exports.isPlainObject = isPlainObject;
-exports.mapKeys = mapKeys;
-exports.mapValues = mapValues;
-exports.merge = merge;
-exports.omitBy = omitBy;
-exports.toCamelCaseKeys = toCamelCaseKeys;
-exports.toMerged = toMerged;
-exports.toSnakeCaseKeys = toSnakeCaseKeys;