@fedify/fedify 1.6.0-dev.808 → 1.6.0-dev.810

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/medianBy.js

@@ -0,0 +1,25 @@
+import { median } from './median.js';
+/**
+ * Calculates the median of an array of elements when applying
+ * the `getValue` function to each element.
+ *
+ * The median is the middle value of a sorted array.
+ * If the array has an odd number of elements, the median is the middle value.
+ * If the array has an even number of elements, it returns the average of the two middle values.
+ *
+ * If the array is empty, this function returns `NaN`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the median.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The median of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }, { a: 5 }], x => x.a); // Returns: 3
+ * medianBy([{ a: 1 }, { a: 2 }, { a: 3 }, { a: 4 }], x => x.a); // Returns: 2.5
+ * medianBy([], x => x.a); // Returns: NaN
+ */
+export function medianBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return median(nums);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/random.js

@@ -0,0 +1,23 @@
+/**
+ * Generate a random number within the given range.
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result1 = random(0, 5); // Returns a random number between 0 and 5.
+ * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown.
+ * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.
+ */
+export function random(minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('Invalid input: The maximum value must be greater than the minimum value.');
+    }
+    return Math.random() * (maximum - minimum) + minimum;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/randomInt.js

@@ -0,0 +1,18 @@
+import { random } from './random.js';
+/**
+ * Generates a random integer between minimum (inclusive) and maximum (exclusive).
+ *
+ * If only one argument is provided, a number between `0` and the given number is returned.
+ *
+ * @param {number} minimum - The lower bound (inclusive).
+ * @param {number} maximum - The upper bound (exclusive).
+ * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).
+ * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.
+ *
+ * @example
+ * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)
+ * const result2 = randomInt(5, 0); // This will throw an error
+ */
+export function randomInt(minimum, maximum) {
+    return Math.floor(random(minimum, maximum));
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/range.js

@@ -0,0 +1,32 @@
+/**
+ * Returns an array of numbers from `start` (inclusive) to `end` (exclusive), incrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `start` (inclusive) to `end` (exclusive) with the specified `step`.
+ * @throws {Error} Throws an error if the step value is not a non-zero integer.
+ *
+ * @example
+ * // Returns [0, 1, 2, 3]
+ * range(4);
+ *
+ * @example
+ * // Returns [0, -1, -2, -3]
+ * range(0, -4, -1);
+ */
+export function range(start, end, step = 1) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + i * step;
+    }
+    return result;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/rangeRight.js

@@ -0,0 +1,32 @@
+/**
+ * Returns an array of numbers from `end` (exclusive) to `start` (inclusive), decrementing by `step`.
+ *
+ * @param {number} start - The starting number of the range (inclusive).
+ * @param {number} end - The end number of the range (exclusive).
+ * @param {number} step - The step value for the range.
+ * @returns {number[]} An array of numbers from `end` (exclusive) to `start` (inclusive) with the specified `step`.
+ * @throws {Error} Throws an error if the step value is not a non-zero integer.
+ *
+ * @example
+ * // Returns [3, 2, 1, 0]
+ * rangeRight(4);
+ *
+ * @example
+ * // Returns [-3, -2, -1, 0]
+ * rangeRight(0, -4, -1);
+ */
+export function rangeRight(start, end, step = 1) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + (length - i - 1) * step;
+    }
+    return result;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/round.js

@@ -0,0 +1,24 @@
+/**
+ * Rounds a number to a specified precision.
+ *
+ * This function takes a number and an optional precision value, and returns the number rounded
+ * to the specified number of decimal places.
+ *
+ * @param {number} value - The number to round.
+ * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0.
+ * @returns {number} The rounded number.
+ * @throws {Error} Throws an error if `Precision` is not integer.
+ *
+ * @example
+ * const result1 = round(1.2345); // result1 will be 1
+ * const result2 = round(1.2345, 2); // result2 will be 1.23
+ * const result3 = round(1.2345, 3); // result3 will be 1.235
+ * const result4 = round(1.2345, 3.1); // This will throw an error
+ */
+export function round(value, precision = 0) {
+    if (!Number.isInteger(precision)) {
+        throw new Error('Precision must be an integer.');
+    }
+    const multiplier = Math.pow(10, precision);
+    return Math.round(value * multiplier) / multiplier;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/sum.js

@@ -0,0 +1,20 @@
+/**
+ * Calculates the sum of an array of numbers.
+ *
+ * This function takes an array of numbers and returns the sum of all the elements in the array.
+ *
+ * @param {number[]} nums - An array of numbers to be summed.
+ * @returns {number} The sum of all the numbers in the array.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * const result = sum(numbers);
+ * // result will be 15
+ */
+export function sum(nums) {
+    let result = 0;
+    for (let i = 0; i < nums.length; i++) {
+        result += nums[i];
+    }
+    return result;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/math/sumBy.js

@@ -0,0 +1,22 @@
+/**
+ * Calculates the sum of an array of numbers when applying
+ * the `getValue` function to each element.
+ *
+ * If the array is empty, this function returns `0`.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items An array to calculate the sum.
+ * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
+ * @returns {number} The sum of all the numbers as determined by the `getValue` function.
+ *
+ * @example
+ * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 6
+ * sumBy([], x => x.a); // Returns: 0
+ */
+export function sumBy(items, getValue) {
+    let result = 0;
+    for (let i = 0; i < items.length; i++) {
+        result += getValue(items[i]);
+    }
+    return result;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/clone.js

@@ -0,0 +1,70 @@
+import { isPrimitive } from '../predicate/isPrimitive.js';
+import { isTypedArray } from '../predicate/isTypedArray.js';
+/**
+ * Creates a shallow clone of the given object.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @returns {T} - A shallow clone of the given object.
+ *
+ * @example
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ */
+export function clone(obj) {
+    if (isPrimitive(obj)) {
+        return obj;
+    }
+    if (Array.isArray(obj) ||
+        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;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/cloneDeep.js

@@ -0,0 +1,50 @@
+import { cloneDeepWithImpl } from './cloneDeepWith.js';
+/**
+ * Creates a deep clone of the given object.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @returns {T} - A deep clone of the given object.
+ *
+ * @example
+ * // Clone a primitive values
+ * const num = 29;
+ * const clonedNum = clone(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num) ; // true
+ *
+ * @example
+ * // Clone an array
+ * const arr = [1, 2, 3];
+ * const clonedArr = clone(arr);
+ * console.log(clonedArr); // [1, 2, 3]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an array with nested objects
+ * const arr = [1, { a: 1 }, [1, 2, 3]];
+ * const clonedArr = clone(arr);
+ * arr[1].a = 2;
+ * console.log(arr); // [2, { a: 2 }, [1, 2, 3]]
+ * console.log(clonedArr); // [1, { a: 1 }, [1, 2, 3]]
+ * console.log(clonedArr === arr); // false
+ *
+ * @example
+ * // Clone an object
+ * const obj = { a: 1, b: 'es-toolkit', c: [1, 2, 3] };
+ * const clonedObj = clone(obj);
+ * console.log(clonedObj); // { a: 1, b: 'es-toolkit', c: [1, 2, 3] }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an object with nested objects
+ * const obj = { a: 1, b: { c: 1 } };
+ * const clonedObj = clone(obj);
+ * obj.b.c = 2;
+ * console.log(obj); // { a: 1, b: { c: 2 } }
+ * console.log(clonedObj); // { a: 1, b: { c: 1 } }
+ * console.log(clonedObj === obj); // false
+ */
+export function cloneDeep(obj) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/cloneDeepWith.js

@@ -0,0 +1,201 @@
+import { getSymbols } from '../compat/_internal/getSymbols.js';
+import { getTag } from '../compat/_internal/getTag.js';
+import { argumentsTag, arrayBufferTag, arrayTag, booleanTag, dataViewTag, dateTag, float32ArrayTag, float64ArrayTag, int8ArrayTag, int16ArrayTag, int32ArrayTag, mapTag, numberTag, objectTag, regexpTag, setTag, stringTag, symbolTag, uint8ArrayTag, uint8ClampedArrayTag, uint16ArrayTag, uint32ArrayTag, } from '../compat/_internal/tags.js';
+import { isPrimitive } from '../predicate/isPrimitive.js';
+import { isTypedArray } from '../predicate/isTypedArray.js';
+/**
+ * Deeply clones the given object.
+ *
+ * You can customize the deep cloning process using the `cloneValue` function.
+ * The function takes the current value `value`, the property name `key`, and the entire object `obj` as arguments.
+ * If the function returns a value, that value is used;
+ * if it returns `undefined`, the default cloning method is used.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to clone.
+ * @param {Function} [cloneValue] - A function to customize the cloning process.
+ * @returns {T} - A deep clone of the given object.
+ *
+ * @example
+ * // Clone a primitive value
+ * const num = 29;
+ * const clonedNum = cloneDeepWith(num);
+ * console.log(clonedNum); // 29
+ * console.log(clonedNum === num); // true
+ *
+ * @example
+ * // Clone an object with a customizer
+ * const obj = { a: 1, b: 2 };
+ * const clonedObj = cloneDeepWith(obj, (value) => {
+ *   if (typeof value === 'number') {
+ *     return value * 2; // Double the number
+ *   }
+ * });
+ * console.log(clonedObj); // { a: 2, b: 4 }
+ * console.log(clonedObj === obj); // false
+ *
+ * @example
+ * // Clone an array with a customizer
+ * const arr = [1, 2, 3];
+ * const clonedArr = cloneDeepWith(arr, (value) => {
+ *   return value + 1; // Increment each value
+ * });
+ * console.log(clonedArr); // [2, 3, 4]
+ * console.log(clonedArr === arr); // false
+ */
+export function cloneDeepWith(obj, cloneValue) {
+    return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue);
+}
+export function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
+    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+    if (cloned != null) {
+        return cloned;
+    }
+    if (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);
+        }
+        // For RegExpArrays
+        if (Object.hasOwn(valueToClone, 'index')) {
+            // eslint-disable-next-line
+            // @ts-ignore
+            result.index = valueToClone.index;
+        }
+        if (Object.hasOwn(valueToClone, 'input')) {
+            // eslint-disable-next-line
+            // @ts-ignore
+            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;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return valueToClone.subarray();
+    }
+    if (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;
+    }
+    // For legacy NodeJS support
+    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;
+}
+export function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+    const keys = [...Object.keys(source), ...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 (getTag(object)) {
+        case argumentsTag:
+        case arrayTag:
+        case arrayBufferTag:
+        case dataViewTag:
+        case booleanTag:
+        case dateTag:
+        case float32ArrayTag:
+        case float64ArrayTag:
+        case int8ArrayTag:
+        case int16ArrayTag:
+        case int32ArrayTag:
+        case mapTag:
+        case numberTag:
+        case objectTag:
+        case regexpTag:
+        case setTag:
+        case stringTag:
+        case symbolTag:
+        case uint8ArrayTag:
+        case uint8ClampedArrayTag:
+        case uint16ArrayTag:
+        case uint32ArrayTag: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/findKey.js

@@ -0,0 +1,22 @@
+/**
+ * Finds the key of the first element in the object that satisfies the provided testing function.
+ *
+ * @param {T} obj - The object to search.
+ * @param {(value: T[keyof T], key: keyof T, obj: T) => boolean} predicate - The function to execute on each value in the object. It takes three arguments:
+ *   - value: The current value being processed in the object.
+ *   - key: The key of the current value being processed in the object.
+ *   - obj: The object that findKey was called upon.
+ * @returns {keyof T | undefined} The key of the first element in the object that passes the test, or undefined if no element passes.
+ *
+ * @example
+ * const users = {
+ *   'barney':  { 'age': 36, 'active': true },
+ *   'fred':    { 'age': 40, 'active': false },
+ *   'pebbles': { 'age': 1,  'active': true }
+ * };
+ * findKey(users, function(o) { return o.age < 40; }); => 'barney'
+ */
+export function findKey(obj, predicate) {
+    const keys = Object.keys(obj);
+    return keys.find(key => predicate(obj[key], key, obj));
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/flattenObject.js

@@ -0,0 +1,49 @@
+import { isPlainObject } from '../predicate/isPlainObject.js';
+/**
+ * Flattens a nested object into a single level object with delimiter-separated keys.
+ *
+ * @param {object} object - The object to flatten.
+ * @param {string} [options.delimiter='.'] - The delimiter to use between nested keys.
+ * @returns {Record<string, any>} - The flattened object.
+ *
+ * @example
+ * const nestedObject = {
+ *   a: {
+ *     b: {
+ *       c: 1
+ *     }
+ *   },
+ *   d: [2, 3]
+ * };
+ *
+ * const flattened = flattenObject(nestedObject);
+ * console.log(flattened);
+ * // Output:
+ * // {
+ * //   'a.b.c': 1,
+ * //   'd.0': 2,
+ * //   'd.1': 3
+ * // }
+ */
+export 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(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;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/index.js

@@ -0,0 +1,17 @@
+export { clone } from './clone.js';
+export { cloneDeep } from './cloneDeep.js';
+export { cloneDeepWith } from './cloneDeepWith.js';
+export { findKey } from './findKey.js';
+export { flattenObject } from './flattenObject.js';
+export { invert } from './invert.js';
+export { mapKeys } from './mapKeys.js';
+export { mapValues } from './mapValues.js';
+export { merge } from './merge.js';
+export { mergeWith } from './mergeWith.js';
+export { omit } from './omit.js';
+export { omitBy } from './omitBy.js';
+export { pick } from './pick.js';
+export { pickBy } from './pickBy.js';
+export { toCamelCaseKeys } from './toCamelCaseKeys.js';
+export { toMerged } from './toMerged.js';
+export { toSnakeCaseKeys } from './toSnakeCaseKeys.js';

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/invert.js

@@ -0,0 +1,28 @@
+/**
+ * Inverts the keys and values of an object. The keys of the input object become the values of the output object and vice versa.
+ *
+ * This function takes an object and creates a new object by inverting its keys and values. If the input object has duplicate values,
+ * the key of the last occurrence will be used as the value for the new key in the output object. It effectively creates a reverse mapping
+ * of the input object's key-value pairs.
+ *
+ * @template K - Type of the keys in the input object (string, number, symbol)
+ * @template V - Type of the values in the input object (string, number, symbol)
+ * @param {Record<K, V>} obj - The input object whose keys and values are to be inverted
+ * @returns {Record<V, K>} - A new object with keys and values inverted
+ *
+ * @example
+ * invert({ a: 1, b: 2, c: 3 }); // { 1: 'a', 2: 'b', 3: 'c' }
+ * invert({ 1: 'a', 2: 'b', 3: 'c' }); // { a: '1', b: '2', c: '3' }
+ * invert({ a: 1, 2: 'b', c: 3, 4: 'd' }); // { 1: 'a', b: '2', 3: 'c', d: '4' }
+ * invert({ a: Symbol('sym1'), b: Symbol('sym2') }); // { [Symbol('sym1')]: 'a', [Symbol('sym2')]: 'b' }
+ */
+export 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;
+}

package/esm/deps/jsr.io/@es-toolkit/es-toolkit/1.38.0/src/object/mapKeys.js

@@ -0,0 +1,27 @@
+/**
+ * Creates a new object with the same values as the given object, but with keys generated
+ * by running each own enumerable property of the object through the iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the new keys generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => K} getNewKey - The function invoked per own enumerable property.
+ * @returns {Record<K, T[keyof T]>} - Returns the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = mapKeys(obj, (value, key) => key + value);
+ * console.log(result); // { a1: 1, b2: 2 }
+ */
+export 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;
+}