es-toolkit 1.50.0 → 1.51.0-dev.2065

package/dist/object/toPascalCaseKeys.d.ts

@@ -0,0 +1,52 @@
+import { ToPascalCaseKeys } from "../types/ToPascalCaseKeys.js";
+
+//#region src/object/toPascalCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to PascalCase.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to PascalCase format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to PascalCase.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toPascalCaseKeys(obj);
+ * // result will be { UserId: 1, FirstName: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toPascalCaseKeys(arr);
+ * // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toPascalCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   UserData: {
+ * //     UserId: 1,
+ * //     UserAddress: {
+ * //       StreetName: 'Main St',
+ * //       ZipCode: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toPascalCaseKeys<T>(obj: T): ToPascalCaseKeys<T>;
+//#endregion
+export { toPascalCaseKeys };

package/dist/object/toPascalCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_pascalCase = require("../string/pascalCase.js");
+//#region src/object/toPascalCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to PascalCase.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to PascalCase format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to PascalCase.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toPascalCaseKeys(obj);
+* // result will be { UserId: 1, FirstName: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toPascalCaseKeys(arr);
+* // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toPascalCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   UserData: {
+* //     UserId: 1,
+* //     UserAddress: {
+* //       StreetName: 'Main St',
+* //       ZipCode: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toPascalCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toPascalCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const pascalKey = require_pascalCase.pascalCase(key);
+			result[pascalKey] = toPascalCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toPascalCaseKeys = toPascalCaseKeys;

package/dist/object/toPascalCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { pascalCase } from "../string/pascalCase.mjs";
+//#region src/object/toPascalCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to PascalCase.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to PascalCase format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to PascalCase.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toPascalCaseKeys(obj);
+* // result will be { UserId: 1, FirstName: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toPascalCaseKeys(arr);
+* // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toPascalCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   UserData: {
+* //     UserId: 1,
+* //     UserAddress: {
+* //       StreetName: 'Main St',
+* //       ZipCode: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toPascalCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toPascalCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const pascalKey = pascalCase(key);
+			result[pascalKey] = toPascalCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toPascalCaseKeys };

package/dist/object/toSnakeCaseKeys.d.mts

@@ -1,7 +1,6 @@
+import { ToSnakeCaseKeys } from "../types/ToSnakeCaseKeys.mjs";
+
 //#region src/object/toSnakeCaseKeys.d.ts
-type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to snake_case.
  *

package/dist/object/toSnakeCaseKeys.d.ts

@@ -1,7 +1,6 @@
+import { ToSnakeCaseKeys } from "../types/ToSnakeCaseKeys.js";
+
 //#region src/object/toSnakeCaseKeys.d.ts
-type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to snake_case.
  *

package/dist/promise/index.d.mts

@@ -1,7 +1,8 @@
+import { limitAsync } from "./limitAsync.mjs";
 import { allKeyed } from "./allKeyed.mjs";
 import { delay } from "./delay.mjs";
 import { Mutex } from "./mutex.mjs";
 import { Semaphore } from "./semaphore.mjs";
 import { timeout } from "./timeout.mjs";
 import { withTimeout } from "./withTimeout.mjs";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.d.ts

@@ -1,7 +1,8 @@
+import { limitAsync } from "./limitAsync.js";
 import { allKeyed } from "./allKeyed.js";
 import { delay } from "./delay.js";
 import { Mutex } from "./mutex.js";
 import { Semaphore } from "./semaphore.js";
 import { timeout } from "./timeout.js";
 import { withTimeout } from "./withTimeout.js";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/index.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_semaphore = require("./semaphore.js");
+const require_limitAsync = require("./limitAsync.js");
 const require_delay = require("./delay.js");
 const require_allKeyed = require("./allKeyed.js");
 const require_mutex = require("./mutex.js");
@@ -9,5 +10,6 @@ exports.Mutex = require_mutex.Mutex;
 exports.Semaphore = require_semaphore.Semaphore;
 exports.allKeyed = require_allKeyed.allKeyed;
 exports.delay = require_delay.delay;
+exports.limitAsync = require_limitAsync.limitAsync;
 exports.timeout = require_timeout.timeout;
 exports.withTimeout = require_withTimeout.withTimeout;

package/dist/promise/index.mjs

@@ -1,7 +1,8 @@
 import { Semaphore } from "./semaphore.mjs";
+import { limitAsync } from "./limitAsync.mjs";
 import { delay } from "./delay.mjs";
 import { allKeyed } from "./allKeyed.mjs";
 import { Mutex } from "./mutex.mjs";
 import { timeout } from "./timeout.mjs";
 import { withTimeout } from "./withTimeout.mjs";
-export { Mutex, Semaphore, allKeyed, delay, timeout, withTimeout };
+export { Mutex, Semaphore, allKeyed, delay, limitAsync, timeout, withTimeout };

package/dist/promise/limitAsync.d.mts

@@ -0,0 +1,35 @@
+//#region src/promise/limitAsync.d.ts
+/**
+ * Wraps an async function to limit the number of concurrent executions.
+ *
+ * This function creates a wrapper around an async callback that ensures at most
+ * `concurrency` number of executions can run simultaneously. Additional calls will
+ * wait until a slot becomes available.
+ *
+ * @template F - The type of the async function to wrap.
+ * @param callback The async function to wrap with concurrency control.
+ * @param concurrency Maximum number of concurrent executions allowed.
+ * @returns A wrapped version of the callback with concurrency limiting.
+ * @example
+ * const limitedFetch = limitAsync(async (url) => {
+ *   return await fetch(url);
+ * }, 3);
+ *
+ * // Only 3 fetches will run concurrently
+ * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+ * await Promise.all(urls.map(url => limitedFetch(url)));
+ *
+ * @example
+ * const processItem = async (item) => {
+ *   // Expensive async operation
+ *   return await heavyComputation(item);
+ * };
+ *
+ * const limitedProcess = limitAsync(processItem, 2);
+ * const items = [1, 2, 3, 4, 5];
+ * // At most 2 items will be processed concurrently
+ * await Promise.all(items.map(item => limitedProcess(item)));
+ */
+declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+//#endregion
+export { limitAsync };

package/dist/promise/limitAsync.d.ts

@@ -0,0 +1,35 @@
+//#region src/promise/limitAsync.d.ts
+/**
+ * Wraps an async function to limit the number of concurrent executions.
+ *
+ * This function creates a wrapper around an async callback that ensures at most
+ * `concurrency` number of executions can run simultaneously. Additional calls will
+ * wait until a slot becomes available.
+ *
+ * @template F - The type of the async function to wrap.
+ * @param callback The async function to wrap with concurrency control.
+ * @param concurrency Maximum number of concurrent executions allowed.
+ * @returns A wrapped version of the callback with concurrency limiting.
+ * @example
+ * const limitedFetch = limitAsync(async (url) => {
+ *   return await fetch(url);
+ * }, 3);
+ *
+ * // Only 3 fetches will run concurrently
+ * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+ * await Promise.all(urls.map(url => limitedFetch(url)));
+ *
+ * @example
+ * const processItem = async (item) => {
+ *   // Expensive async operation
+ *   return await heavyComputation(item);
+ * };
+ *
+ * const limitedProcess = limitAsync(processItem, 2);
+ * const items = [1, 2, 3, 4, 5];
+ * // At most 2 items will be processed concurrently
+ * await Promise.all(items.map(item => limitedProcess(item)));
+ */
+declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+//#endregion
+export { limitAsync };

package/dist/promise/limitAsync.js

@@ -0,0 +1,46 @@
+const require_semaphore = require("./semaphore.js");
+//#region src/promise/limitAsync.ts
+/**
+* Wraps an async function to limit the number of concurrent executions.
+*
+* This function creates a wrapper around an async callback that ensures at most
+* `concurrency` number of executions can run simultaneously. Additional calls will
+* wait until a slot becomes available.
+*
+* @template F - The type of the async function to wrap.
+* @param callback The async function to wrap with concurrency control.
+* @param concurrency Maximum number of concurrent executions allowed.
+* @returns A wrapped version of the callback with concurrency limiting.
+* @example
+* const limitedFetch = limitAsync(async (url) => {
+*   return await fetch(url);
+* }, 3);
+*
+* // Only 3 fetches will run concurrently
+* const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+* await Promise.all(urls.map(url => limitedFetch(url)));
+*
+* @example
+* const processItem = async (item) => {
+*   // Expensive async operation
+*   return await heavyComputation(item);
+* };
+*
+* const limitedProcess = limitAsync(processItem, 2);
+* const items = [1, 2, 3, 4, 5];
+* // At most 2 items will be processed concurrently
+* await Promise.all(items.map(item => limitedProcess(item)));
+*/
+function limitAsync(callback, concurrency) {
+	const semaphore = new require_semaphore.Semaphore(concurrency);
+	return async function(...args) {
+		try {
+			await semaphore.acquire();
+			return await callback.apply(this, args);
+		} finally {
+			semaphore.release();
+		}
+	};
+}
+//#endregion
+exports.limitAsync = limitAsync;

package/dist/promise/limitAsync.mjs

@@ -0,0 +1,46 @@
+import { Semaphore } from "./semaphore.mjs";
+//#region src/promise/limitAsync.ts
+/**
+* Wraps an async function to limit the number of concurrent executions.
+*
+* This function creates a wrapper around an async callback that ensures at most
+* `concurrency` number of executions can run simultaneously. Additional calls will
+* wait until a slot becomes available.
+*
+* @template F - The type of the async function to wrap.
+* @param callback The async function to wrap with concurrency control.
+* @param concurrency Maximum number of concurrent executions allowed.
+* @returns A wrapped version of the callback with concurrency limiting.
+* @example
+* const limitedFetch = limitAsync(async (url) => {
+*   return await fetch(url);
+* }, 3);
+*
+* // Only 3 fetches will run concurrently
+* const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+* await Promise.all(urls.map(url => limitedFetch(url)));
+*
+* @example
+* const processItem = async (item) => {
+*   // Expensive async operation
+*   return await heavyComputation(item);
+* };
+*
+* const limitedProcess = limitAsync(processItem, 2);
+* const items = [1, 2, 3, 4, 5];
+* // At most 2 items will be processed concurrently
+* await Promise.all(items.map(item => limitedProcess(item)));
+*/
+function limitAsync(callback, concurrency) {
+	const semaphore = new Semaphore(concurrency);
+	return async function(...args) {
+		try {
+			await semaphore.acquire();
+			return await callback.apply(this, args);
+		} finally {
+			semaphore.release();
+		}
+	};
+}
+//#endregion
+export { limitAsync };

package/dist/string/dedent.d.mts

@@ -0,0 +1,37 @@
+//#region src/string/dedent.d.ts
+/**
+ * Removes common leading whitespace from each line of a multi-line string.
+ *
+ * This function can be used as a regular function, as a tagged template literal,
+ * or composed with another tag function (TC39 String.dedent proposal).
+ * It calculates the common indentation across all non-empty lines and removes it,
+ * preserving relative indentation differences between lines.
+ * The first and last lines are removed if they are empty or contain only whitespace.
+ *
+ * @param {string | TemplateStringsArray | Function} str - The string, template literal, or tag function to dedent.
+ * @param {unknown[]} values - The values to interpolate when used as a tagged template literal.
+ * @returns {string | Function} The dedented string, or a dedented tag function when composed.
+ *
+ * @example
+ * // As a regular function
+ * dedent("  hello\n  world"); // "hello\nworld"
+ *
+ * @example
+ * // As a tagged template literal
+ * dedent`
+ *   hello
+ *   world
+ * `; // "hello\nworld"
+ *
+ * @example
+ * // Tag composition
+ * const html = dedent((strings, ...values) => strings.join(''));
+ * html`
+ *   <div>Hello</div>
+ * `; // "<div>Hello</div>"
+ */
+declare function dedent(str: string): string;
+declare function dedent(str: TemplateStringsArray, ...values: unknown[]): string;
+declare function dedent<T>(tagFn: (strings: TemplateStringsArray, ...values: unknown[]) => T): (strings: TemplateStringsArray, ...values: unknown[]) => T;
+//#endregion
+export { dedent };

package/dist/string/dedent.d.ts

@@ -0,0 +1,37 @@
+//#region src/string/dedent.d.ts
+/**
+ * Removes common leading whitespace from each line of a multi-line string.
+ *
+ * This function can be used as a regular function, as a tagged template literal,
+ * or composed with another tag function (TC39 String.dedent proposal).
+ * It calculates the common indentation across all non-empty lines and removes it,
+ * preserving relative indentation differences between lines.
+ * The first and last lines are removed if they are empty or contain only whitespace.
+ *
+ * @param {string | TemplateStringsArray | Function} str - The string, template literal, or tag function to dedent.
+ * @param {unknown[]} values - The values to interpolate when used as a tagged template literal.
+ * @returns {string | Function} The dedented string, or a dedented tag function when composed.
+ *
+ * @example
+ * // As a regular function
+ * dedent("  hello\n  world"); // "hello\nworld"
+ *
+ * @example
+ * // As a tagged template literal
+ * dedent`
+ *   hello
+ *   world
+ * `; // "hello\nworld"
+ *
+ * @example
+ * // Tag composition
+ * const html = dedent((strings, ...values) => strings.join(''));
+ * html`
+ *   <div>Hello</div>
+ * `; // "<div>Hello</div>"
+ */
+declare function dedent(str: string): string;
+declare function dedent(str: TemplateStringsArray, ...values: unknown[]): string;
+declare function dedent<T>(tagFn: (strings: TemplateStringsArray, ...values: unknown[]) => T): (strings: TemplateStringsArray, ...values: unknown[]) => T;
+//#endregion
+export { dedent };

package/dist/string/dedent.js

@@ -0,0 +1,38 @@
+//#region src/string/dedent.ts
+function dedent(str, ...values) {
+	switch (typeof str) {
+		case "function": return function(strings, ...args) {
+			return str(dedentTemplateStringsArray(strings), ...args);
+		};
+		case "string": return dedentImpl(str);
+		default: {
+			let text = str[0];
+			for (let i = 0; i < values.length; i++) text += String(values[i]) + str[i + 1];
+			return dedentImpl(text);
+		}
+	}
+}
+function dedentTemplateStringsArray(strings) {
+	const parts = dedentImpl(strings.join("\0")).split("\0");
+	return Object.assign(parts, { raw: parts });
+}
+function dedentImpl(text) {
+	text = text.replace(/\r\n/g, "\n");
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[0].trim() === "") lines.shift();
+	if (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+	let commonIndent = Infinity;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.trim() === "") continue;
+		let indent = 0;
+		while (indent < line.length && (line[indent] === " " || line[indent] === "	")) indent++;
+		if (indent < commonIndent) commonIndent = indent;
+	}
+	if (commonIndent === Infinity) return "";
+	for (let i = 0; i < lines.length; i++) if (lines[i].trim() === "") lines[i] = "";
+	else lines[i] = lines[i].slice(commonIndent);
+	return lines.join("\n");
+}
+//#endregion
+exports.dedent = dedent;

package/dist/string/dedent.mjs

@@ -0,0 +1,38 @@
+//#region src/string/dedent.ts
+function dedent(str, ...values) {
+	switch (typeof str) {
+		case "function": return function(strings, ...args) {
+			return str(dedentTemplateStringsArray(strings), ...args);
+		};
+		case "string": return dedentImpl(str);
+		default: {
+			let text = str[0];
+			for (let i = 0; i < values.length; i++) text += String(values[i]) + str[i + 1];
+			return dedentImpl(text);
+		}
+	}
+}
+function dedentTemplateStringsArray(strings) {
+	const parts = dedentImpl(strings.join("\0")).split("\0");
+	return Object.assign(parts, { raw: parts });
+}
+function dedentImpl(text) {
+	text = text.replace(/\r\n/g, "\n");
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[0].trim() === "") lines.shift();
+	if (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+	let commonIndent = Infinity;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.trim() === "") continue;
+		let indent = 0;
+		while (indent < line.length && (line[indent] === " " || line[indent] === "	")) indent++;
+		if (indent < commonIndent) commonIndent = indent;
+	}
+	if (commonIndent === Infinity) return "";
+	for (let i = 0; i < lines.length; i++) if (lines[i].trim() === "") lines[i] = "";
+	else lines[i] = lines[i].slice(commonIndent);
+	return lines.join("\n");
+}
+//#endregion
+export { dedent };

package/dist/string/index.d.mts

@@ -2,6 +2,7 @@ import { camelCase } from "./camelCase.mjs";
 import { capitalize } from "./capitalize.mjs";
 import { constantCase } from "./constantCase.mjs";
 import { deburr } from "./deburr.mjs";
+import { dedent } from "./dedent.mjs";
 import { escape } from "./escape.mjs";
 import { escapeRegExp } from "./escapeRegExp.mjs";
 import { kebabCase } from "./kebabCase.mjs";
@@ -19,4 +20,4 @@ import { unescape } from "./unescape.mjs";
 import { upperCase } from "./upperCase.mjs";
 import { upperFirst } from "./upperFirst.mjs";
 import { words } from "./words.mjs";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/string/index.d.ts

@@ -2,6 +2,7 @@ import { camelCase } from "./camelCase.js";
 import { capitalize } from "./capitalize.js";
 import { constantCase } from "./constantCase.js";
 import { deburr } from "./deburr.js";
+import { dedent } from "./dedent.js";
 import { escape } from "./escape.js";
 import { escapeRegExp } from "./escapeRegExp.js";
 import { kebabCase } from "./kebabCase.js";
@@ -19,4 +20,4 @@ import { unescape } from "./unescape.js";
 import { upperCase } from "./upperCase.js";
 import { upperFirst } from "./upperFirst.js";
 import { words } from "./words.js";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/string/index.js

@@ -2,16 +2,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_capitalize = require("./capitalize.js");
 const require_words = require("./words.js");
 const require_camelCase = require("./camelCase.js");
-const require_snakeCase = require("./snakeCase.js");
 const require_constantCase = require("./constantCase.js");
+const require_kebabCase = require("./kebabCase.js");
+const require_pascalCase = require("./pascalCase.js");
+const require_snakeCase = require("./snakeCase.js");
 const require_deburr = require("./deburr.js");
+const require_dedent = require("./dedent.js");
 const require_escape = require("./escape.js");
 const require_escapeRegExp = require("./escapeRegExp.js");
-const require_kebabCase = require("./kebabCase.js");
 const require_lowerCase = require("./lowerCase.js");
 const require_lowerFirst = require("./lowerFirst.js");
 const require_pad = require("./pad.js");
-const require_pascalCase = require("./pascalCase.js");
 const require_reverseString = require("./reverseString.js");
 const require_startCase = require("./startCase.js");
 const require_trimEnd = require("./trimEnd.js");
@@ -24,6 +25,7 @@ exports.camelCase = require_camelCase.camelCase;
 exports.capitalize = require_capitalize.capitalize;
 exports.constantCase = require_constantCase.constantCase;
 exports.deburr = require_deburr.deburr;
+exports.dedent = require_dedent.dedent;
 exports.escape = require_escape.escape;
 exports.escapeRegExp = require_escapeRegExp.escapeRegExp;
 exports.kebabCase = require_kebabCase.kebabCase;

package/dist/string/index.mjs

@@ -1,16 +1,17 @@
 import { capitalize } from "./capitalize.mjs";
 import { words } from "./words.mjs";
 import { camelCase } from "./camelCase.mjs";
-import { snakeCase } from "./snakeCase.mjs";
 import { constantCase } from "./constantCase.mjs";
+import { kebabCase } from "./kebabCase.mjs";
+import { pascalCase } from "./pascalCase.mjs";
+import { snakeCase } from "./snakeCase.mjs";
 import { deburr } from "./deburr.mjs";
+import { dedent } from "./dedent.mjs";
 import { escape } from "./escape.mjs";
 import { escapeRegExp } from "./escapeRegExp.mjs";
-import { kebabCase } from "./kebabCase.mjs";
 import { lowerCase } from "./lowerCase.mjs";
 import { lowerFirst } from "./lowerFirst.mjs";
 import { pad } from "./pad.mjs";
-import { pascalCase } from "./pascalCase.mjs";
 import { reverseString } from "./reverseString.mjs";
 import { startCase } from "./startCase.mjs";
 import { trimEnd } from "./trimEnd.mjs";
@@ -19,4 +20,4 @@ import { trim } from "./trim.mjs";
 import { unescape } from "./unescape.mjs";
 import { upperCase } from "./upperCase.mjs";
 import { upperFirst } from "./upperFirst.mjs";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };