moderndash 0.0.8 → 0.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Maximilian Dewald
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,586 @@
+/**
+ * Creates an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.
+ *
+ * @category Array
+ * @returns Returns the new array of chunks.
+ * @param chunkSize - The array to process.
+ * @param array - The length of each chunk
+ * @example
+ * chunk(2, ['a', 'b', 'c', 'd'])
+ * // => [['a', 'b'], ['c', 'd']]
+ *
+ * chunk(3, ['a', 'b', 'c', 'd'])
+ * // => [['a', 'b', 'c'], ['d']]
+ */
+declare function chunk<TInput>(chunkSize: number, array: TInput[]): TInput[][];
+
+type MinimumTwoArrays<T> = [T[], T[], ...T[][]];
+type IterateeFunction<T> = (value: T) => unknown;
+type PropertyShorthand<T> = keyof T;
+type RecordKey = string | number | symbol;
+type Collection<T> = T[] | Record<RecordKey, T>;
+type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+
+/**
+ * Creates an array of `array` values not included in the other given arrays. The order and references of result values are determined by the first array.
+ *
+ * **Note:** Unlike `pullAll`, this method returns a new array.
+ *
+ * @category Array
+ * @param arrays - First array is inspected, others are excluded.
+ * @returns Returns the new array of filtered values.
+ * @example
+ * difference([2, 1], [2, 3])
+ * // =\> [1]
+ */
+declare function difference<T>(...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * This method is like `difference` except that it accepts `iteratee` which
+ * is invoked for each element of `array` and `values` to generate the criterion
+ * by which they're compared. The order and references of result values are
+ * determined by the first array.
+ *
+ * **Note:** Unlike `pullAllBy`, this method returns a new array.
+ *
+ * @category Array
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @param arrays - First array to inspect. Others are excluded.
+
+ * @returns Returns the new array of filtered values.
+ * @example
+ * differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
+ * // => [1.2]
+ * differenceBy('x', [{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }])
+ * // => [{ 'x': 2 }]
+ */
+declare function differenceBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * This method is like `difference` except that it accepts `comparator`
+ * which is invoked to compare elements of `array` to `values`. The order and
+ * references of result values are determined by the first array. The comparator
+ * is invoked with two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `pullAllWith`, this method returns a new array.
+ *
+ * @category Array
+ * @param comparator - The comparator invoked per element.
+ * @param arrays - First array to inspect. Others are excluded.
+ * @returns Returns the new array of filtered values.
+ * @example
+ * differenceWith(isEqual, [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], [{ 'x': 1, 'y': 2 }])
+ * // => [{ 'x': 2, 'y': 1 }]
+ */
+declare function differenceWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * Creates a slice of `array` excluding elements dropped from the end.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate - The function invoked per iteration.
+ * @param array - The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': false },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': true }
+ * ]
+ *
+ * dropRightWhile(({ active }) => active, users)
+ * // => objects for ['barney']
+ */
+declare function dropRightWhile<T>(predicate: (value: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates a slice of `array` excluding elements dropped from the beginning.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate - The function invoked per iteration.
+ * @param array - The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': true },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': false }
+ * ]
+ *
+ * dropWhile(({ active }) => active, users)
+ * // => objects for ['pebbles']
+ */
+declare function dropWhile<T>(predicate: (value: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates an array of unique values that are included in all given arrays.
+ * The order and references of result values are determined by the first array.
+ *
+ * @category Array
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of intersecting values.
+ * @example
+ * intersection([2, 1], [2, 3])
+ * // => [2]
+ */
+declare function intersection<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * This method is like `intersection` except that it accepts `iteratee`
+ * which is invoked for each element of each `arrays` to generate the criterion
+ * by which they're compared. The order and references of result values are
+ * determined by the first array. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @category Array
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of intersecting values.
+ * @example
+ * intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
+ * // => [2.1]
+ */
+declare function intersectionBy<TInput>(iteratee: IterateeFunction<TInput> | PropertyShorthand<TInput>, ...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * This method is like `intersection` except that it accepts `comparator`
+ * which is invoked to compare elements of `arrays`. The order and references
+ * of result values are determined by the first array. The comparator is
+ * invoked with two arguments: (arrVal, othVal).
+ *
+ * @category Array
+ * @param comparator - The comparator invoked per element.
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of intersecting values.
+ * @example
+ * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
+ *
+ * intersectionWith(isEqual, objects, others)
+ * // => [{ 'x': 1, 'y': 2 }]
+ */
+declare function intersectionWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * Gets a random element from `array`.
+ *
+ * @category Array
+ * @param array - The array to sample.
+ * @returns Returns the random element.
+ * @example
+ * sample([1, 2, 3, 4])
+ * // => 2
+ */
+declare function sample<T>(array: T[]): T | undefined;
+
+/**
+ * Gets `n` random elements at unique keys from `array` up to the
+ * size of `array`.
+ *
+ * @category Array
+ * @param size The number of elements to sample.
+ * @param array The array to sample.
+ * @returns Returns the random elements.
+ * @example
+ * sampleSize([1, 2, 3], 2)
+ * // => [3, 1]
+ *
+ * sampleSize([1, 2, 3], 4)
+ * // => [2, 3, 1]
+ */
+declare function sampleSize<TInput>(size: number, array: TInput[]): TInput[];
+
+/**
+ * Creates an array of shuffled values, using a version of the
+ * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
+ *
+ * @since 0.1.0
+ * @category Array
+ * @param array - The array or object to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ * @example
+ * shuffle([1, 2, 3, 4])
+ * // => [4, 1, 3, 2]
+ */
+declare function shuffle<TInput>(array: TInput[]): TInput[];
+
+/**
+ * Creates a slice of `array` with elements taken from the end. Elements are
+ * taken until `predicate` returns falsey. The predicate is invoked with
+ * three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate - The function invoked per iteration.
+ * @param array - The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': false },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': true }
+ * ]
+ *
+ * takeRightWhile(({ active }) => active, users)
+ * // => objects for ['fred', 'pebbles']
+ */
+declare function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates a slice of `array` with elements taken from the beginning. Elements
+ * are taken until `predicate` returns falsey. The predicate is invoked with
+ * three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate The function invoked per iteration.
+ * @param array The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': true },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': false }
+ * ]
+ *
+ * takeWhile(({ active }) => active, users)
+ * // => objects for ['barney', 'fred']
+ */
+declare function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates an array of unique values, in order, from all given arrays using for equality comparisons.
+ *
+ * @category Array
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of combined values.
+ * @example
+ * union([2, 3], [1, 2])
+ * // => [2, 3, 1]
+ */
+declare function union<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * This method is like `union` except that it accepts `iteratee` which is
+ * invoked for each element of each `arrays` to generate the criterion by
+ * which uniqueness is computed. Result values are chosen from the first
+ * array in which the value occurs. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @category Array
+ * @param arrays - The arrays to inspect.
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @returns Returns the new array of combined values.
+ * @example
+ * unionBy(Math.floor, [2.1], [1.2, 2.3])
+ * // => [2.1, 1.2]
+ */
+declare function unionBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * This method is like `union` except that it accepts `comparator` which
+ * is invoked to compare elements of `arrays`. Result values are chosen from
+ * the first array in which the value occurs. The comparator is invoked
+ * with two arguments: (arrVal, othVal).
+ *
+ * @category Array
+ * @param comparator - The comparator invoked per element.
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of combined values.
+ * @example
+ * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
+ *
+ * unionWith(isEqual, objects, others)
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
+ */
+declare function unionWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, ...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * Creates a duplicate-free version of an array, in which only the first occurrence of each element is kept.
+ * The order of result values is determined by the order they occur in the array.
+ *
+ * @category Array
+ * @param array - The array to inspect.
+ * @returns Returns the new duplicate free array.
+ * @example
+ * uniq([2, 1, 2])
+ * // => [2, 1]
+ */
+declare function uniq<TInput>(array: TInput[]): TInput[];
+
+/**
+ * This method is like `uniq` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * uniqueness is computed. The order of result values is determined by the
+ * order they occur in the array.
+ *
+ * @category Array
+ * @param array - The array to inspect.
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @returns Returns the new duplicate free array.
+ * @example
+ * uniqBy(Math.floor, [2.1, 1.2, 2.3])
+ * // => [2.1, 1.2]
+ */
+declare function uniqBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, array: T[]): T[];
+
+/**
+ * This method is like `uniq` except that it accepts `comparator` which is invoked to compare elements of `array`.
+ * The order of result values is determined by the order they occur in the array.
+ *
+ * @category Array
+ * @param array - The array to inspect.
+ * @param comparator - The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ * @example
+ * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]
+ *
+ * uniqWith(isEqual, objects)
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ */
+declare function uniqWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, array: TInput[]): TInput[];
+
+/**
+ * This method is like `zip` except that it accepts an array of grouped
+ * elements and creates an array regrouping the elements to their pre-zip configuration.
+ *
+ * @category Array
+ * @param array - The array of grouped elements to process.
+ * @returns Returns the new array of regrouped elements.
+ * @example
+ * const zipped = zip(['a', 'b'], [1, 2], [true, false])
+ * // => [['a', 1, true], ['b', 2, false]]
+ *
+ * unzip(zipped)
+ * // => [['a', 'b'], [1, 2], [true, false]]
+ */
+declare function unzip<TInput extends unknown[]>(array: TInput[]): TInput[];
+
+/**
+ * This method is like `unzip` except that it accepts `iteratee` to specify
+ * how regrouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @category Array
+ * @param iteratee - The function to combine regrouped values.
+ * @param array - The array of grouped elements to process.
+ * @returns Returns the new array of regrouped elements.
+ * @example
+ * const zipped = zip([1, 2], [10, 20], [100, 200])
+ * // => [[1, 10, 100], [2, 20, 200]]
+ *
+ * unzipWith(add, zipped)
+ * // => [3, 30, 300]
+ */
+declare function unzipWith<TInput extends unknown[], TOutput>(iteratee: (...t: TInput) => TOutput, array: TInput[]): TOutput[];
+
+/**
+ * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
+ * the second of which contains the second elements of the given arrays, and so on.
+ *
+ * @category Array
+ * @param arrays - The arrays to process.
+ * @returns Returns the new array of grouped elements.
+ * @example
+ * zip(['a', 'b'], [1, 2], [true, false])
+ * // => [['a', 1, true], ['b', 2, false]]
+ */
+declare function zip<TInput>(...arrays: TInput[][]): TInput[][];
+
+type UnZip<A extends readonly unknown[]> = {
+    [K in keyof A]: readonly A[K][];
+};
+/**
+ * This method is like `zip` except that it accepts `iteratee` to specify
+ * how grouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @category Array
+ * @param combineFunc - The function to combine grouped values.
+ * @param arrays - The arrays to process.
+ * @returns Returns the new array of grouped elements.
+ * @example
+ * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c)
+ * // => [111, 222]
+ */
+declare function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args: Args) => TOutput, ...arrays: UnZip<Args>): TOutput[];
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the number of times the key was returned by `iteratee`.
+ *
+ * @category Collection
+ * @param iteratee - The iteratee to transform keys.
+ * @param collection - The array or object to iterate over.
+ * @returns Returns the composed aggregate object.
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'active': true },
+ *   { 'user': 'betty', 'active': true },
+ *   { 'user': 'fred', 'active': false }
+ * ]
+ *
+ * countBy(value => value.active, users);
+ * // => { 'true': 2, 'false': 1 }
+ */
+declare function countBy<TInput, TKey extends RecordKey>(iteratee: (value: TInput) => TKey, collection: Collection<TInput>): Record<TKey, number>;
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The order of grouped values
+ * is determined by the order they occur in `collection`. The corresponding
+ * value of each key is an array of elements responsible for generating the
+ * key.
+ *
+ * @category Collection
+ * @param collection The array or object to iterate over.
+ * @param iteratee The iteratee to transform keys.
+ * @returns Returns the composed aggregate object.
+ * @example
+ *
+ * groupBy(Math.floor, [6.1, 4.2, 6.3])
+ * // => { '4': [4.2], '6': [6.1, 6.3] }
+ */
+declare function groupBy<T, U extends RecordKey>(iteratee: (value: T) => U, collection: Collection<T>): Record<U, T[]>;
+
+declare function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[];
+
+/**
+ * The opposite of `before`. This method creates a function that invokes `func` once it's called `n` or more times.
+ *
+ * @category Function
+ * @param n The number of calls before `func` is invoked.
+ * @param func The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const caution = () => alert("Caution!");
+ *
+ * // Display alert only after it has been called 5 times
+ * after(5, caution)
+ */
+declare function after<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
+
+/**
+ * Creates a function that invokes `func`, with the `this` binding and arguments
+ * of the created function, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @category Function
+ * @param n - The number of calls at which `func` is no longer invoked.
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const caution = () => alert("Caution!");
+ *
+ * // Only call caution two times
+ * before(2, caution)
+ */
+declare function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc;
+
+declare function debounce<T extends (...args: Parameters<T>) => ReturnType<T>>(fn: T, wait?: number, options?: {
+    leading?: boolean;
+    maxWait?: number;
+    trailing?: boolean;
+}): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+
+type Cache = Map<string | symbol, unknown>;
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, all arguments
+ * provided to the memoized function are used as the map cache key.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @category Function
+ * @param func - The function to have its output memoized.
+ * @param resolver - The function to resolve the cache key.
+ * @returns  Returns the new memoized function.
+ * @example
+ * const object = \{ 'a': 1, 'b': 2 \}
+ *
+ * const values = memoize(values)
+ * values(object)
+ * // => [1, 2]
+ *
+ * values(object)
+ * // => [1, 2]
+ *
+ * object.a = 2
+ * values(object)
+ * // => [2, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b'])
+ * values(object)
+ * // => ['a', 'b']
+ *
+ * // Replace `memoize.Cache`.
+ * memoize.Cache = WeakMap
+ */
+declare function memoize<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
+    cache: Cache;
+};
+
+declare function once<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(func: TFunc): TFunc;
+
+declare function throttle<T extends (...args: Parameters<T>) => ReturnType<T>>(func: T, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+
+declare function isEmpty(value: unknown): boolean;
+
+declare function isEqual(value1: unknown, value2: unknown): boolean;
+
+declare function isEqualWith<T>(customizer: (value: T) => unknown, a: T, b: T): boolean;
+
+declare function isPlainObject(value: unknown): value is object;
+
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @category Object
+ * @param object The source object.
+ * @param keys The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * const object = { 'a': 1, 'b': '2', 'c': 3 }
+ *
+ * pick(object, ['a', 'c'])
+ * // => { 'a': 1, 'c': 3 }
+ */
+declare function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K>;
+
+declare function camelCase(str: string): string;
+
+declare function capitalize(str: string): string;
+
+declare function deburr(str: string): string;
+
+declare function escape(str: string): string;
+
+declare function escapeRegExp(str: string): string;
+
+declare function kebabCase(str: string): string;
+
+declare function pascalCase(str: string): string;
+
+declare function snakeCase(str: string): string;
+
+declare function startCase(str: string): string;
+
+declare function stripSpecialChars(str: string): string;
+
+declare function unescapeHTML(html: string): string;
+
+export { Collection, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, unescapeHTML, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };