@goodbyenjn/utils 26.2.0 → 26.4.0

package/dist/chunks/chunk-704a1835.d.ts

@@ -0,0 +1,174 @@
+import { d as SyncFn, s as AsyncFn, t as index_d_exports } from "./chunk-3c6f28c7.js";
+
+//#region src/result/types.d.ts
+type ExtractOkTypes<T extends readonly Result[]> = { [K in keyof T]: T[K] extends Result<infer U, unknown> ? U : never };
+type ExtractErrTypes<T extends readonly Result[]> = { [K in keyof T]: T[K] extends Result<unknown, infer E> ? E : never };
+type InferOkType<R> = R extends Result<infer T, unknown> ? T : never;
+type InferErrType<R> = R extends Result<unknown, infer E> ? E : never;
+type ResultAll<T extends readonly Result[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
+type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
+type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
+type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
+type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
+type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
+type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
+type IsLiteralArray<T> = T extends {
+  length: infer L;
+} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
+type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
+//#endregion
+//#region src/result/result.d.ts
+type Ok<T = unknown> = Result<T, never>;
+type Err<E = unknown> = Result<never, E>;
+declare class Result<T = unknown, E = unknown> {
+  #private;
+  static is(value: unknown): value is Result;
+  static ok(): Ok<void>;
+  static ok<T>(value: T): Ok<T>;
+  static err(): Err<void>;
+  static err<E>(error: E): Err<E>;
+  /**
+   * Creates a `Result` from a function or a promise, catching any thrown errors or rejected promises.
+   */
+  static try<T, E = unknown>(fn: SyncFn<T>): Result<T, E>;
+  static try<T>(fn: SyncFn<T>, onThrow: ErrorConstructor): Result<T, Error>;
+  static try<T, E>(fn: SyncFn<T>, onThrow: (error: unknown) => E): Result<T, E>;
+  static try<T, E = unknown>(fn: AsyncFn<T>): Promise<Result<Awaited<T>, E>>;
+  static try<T>(fn: AsyncFn<T>, onThrowOrReject: ErrorConstructor): Promise<Result<Awaited<T>, Error>>;
+  static try<T, E>(fn: AsyncFn<T>, onThrowOrReject: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
+  static try<T, E = unknown>(promise: PromiseLike<T>): Promise<Result<Awaited<T>, E>>;
+  static try<T>(promise: PromiseLike<T>, onReject: ErrorConstructor): Promise<Result<Awaited<T>, Error>>;
+  static try<T, E>(promise: PromiseLike<T>, onReject: (error: unknown) => E): Promise<Result<Awaited<T>, E>>;
+  /**
+   * Wraps a function and returns a new function that always returns a `Result`, catching any thrown errors or rejected promises.
+   */
+  static wrap<A extends any[], T, E = unknown>(fn: SyncFn<T, A>): SyncFn<Result<T, E>, A>;
+  static wrap<A extends any[], T>(fn: SyncFn<T, A>, onThrow: ErrorConstructor): SyncFn<Result<T, Error>, A>;
+  static wrap<A extends any[], T, E>(fn: SyncFn<T, A>, onThrow: (error: unknown) => E): SyncFn<Result<T, E>, A>;
+  static wrap<A extends any[], T, E = unknown>(fn: AsyncFn<T, A>): AsyncFn<Result<Awaited<T>, E>, A>;
+  static wrap<A extends any[], T>(fn: AsyncFn<T, A>, onThrowOrReject: ErrorConstructor): AsyncFn<Result<Awaited<T>, Error>, A>;
+  static wrap<A extends any[], T, E>(fn: AsyncFn<T, A>, onThrowOrReject: (error: unknown) => E): AsyncFn<Result<Awaited<T>, E>, A>;
+  /**
+   * Combines multiple `Result` instances into one `Result` containing an array of all `Ok` values,
+   * or the first `Err` encountered
+   */
+  static all<T extends index_d_exports.NonEmptyTuple<Result>>(results: T): ResultAll<T>;
+  static all<T extends readonly Result[]>(results: T): ResultAll<T>;
+  /**
+   * Wraps a generator function where `yield` can return `Err` values early.
+   * If the generator completes, the returned value is wrapped in `Ok`.
+   */
+  static gen<T, E, This>(body: (this: This) => Iterator<Err<E>, Result<T, E> | T>, self?: This): Result<T, E>;
+  static gen<YieldErr extends Err, ReturnResult extends Result | any, This>(body: (this: This) => Iterator<YieldErr, ReturnResult>, self?: This): Result<ReturnResult extends Result ? InferOkType<ReturnResult> : ReturnResult, InferErrType<YieldErr> | (ReturnResult extends Result ? InferErrType<ReturnResult> : never)>;
+  static gen<T, E, This>(body: (this: This) => AsyncIterator<Err<E>, Result<T, E> | T>, self?: This): Promise<Result<T, E>>;
+  static gen<YieldErr extends Err, ReturnResult extends Result | any, This>(body: (this: This) => AsyncIterator<YieldErr, ReturnResult>, self?: This): Promise<Result<ReturnResult extends Result ? InferOkType<ReturnResult> : ReturnResult, InferErrType<YieldErr> | (ReturnResult extends Result ? InferErrType<ReturnResult> : never)>>;
+  private ok;
+  private value;
+  private error;
+  private get contexts();
+  private constructor();
+  /**
+   * Check if `Result` is `OK`
+   */
+  isOk(): this is Ok<T>;
+  /**
+   * Check if `Result` is `OK` and the value matches the predicate
+   */
+  isOkAnd(predicate: (value: T) => boolean): this is Ok<T>;
+  /**
+   * Check if `Result` is `Err`
+   */
+  isErr(): this is Err<E>;
+  /**
+   * Check if `Result` is `Err` and the error matches the predicate
+   */
+  isErrAnd(predicate: (error: E) => boolean): this is Err<E>;
+  /**
+   * Maps `Result<T, E>` to `Result<U, E>` or `Promise<Result<U, E>>`
+   */
+  map<U>(fn: (value: T) => U): Result<U, E>;
+  map<U>(fn: (value: T) => Promise<U>): Promise<Result<U, E>>;
+  /**
+   * Maps `Result<T, E>` to `Result<T, F>` or `Promise<Result<T, F>>`
+   */
+  mapErr<F>(fn: (error: E) => F): Result<T, F>;
+  mapErr<F>(fn: (error: E) => Promise<F>): Promise<Result<T, F>>;
+  /**
+   * Returns given `result` if `Result` is `Ok`, otherwise returns `Result` directly
+   */
+  and<R extends Result<unknown, E>>(result: R): Result<InferOkType<R>, E>;
+  and<U>(result: Result<U, E>): Result<U, E>;
+  and<R extends Promise<Result<unknown, E>>>(result: R): Promise<Result<InferOkType<R>, E>>;
+  and<U>(result: Promise<Result<U, E>>): Promise<Result<U, E>>;
+  /**
+   * Maps `Result<T, E>` to `Result<U, E | F>` or `Promise<Result<U, E | F>>` with a function
+   */
+  andThen<R extends Result>(fn: (value: T) => R): Result<InferOkType<R>, InferErrType<R> | E>;
+  andThen<U, F>(fn: (value: T) => Result<U, F>): Result<U, E | F>;
+  andThen<R extends Promise<Result>>(fn: (value: T) => R): Promise<Result<InferOkType<R>, InferErrType<R> | E>>;
+  andThen<U, F>(fn: (value: T) => Promise<Result<U, F>>): Promise<Result<U, E | F>>;
+  /**
+   * Returns given `result` if `Result` is `Err`, otherwise returns `Result` directly
+   */
+  or<R extends Result<T, unknown>>(result: R): Result<T, InferErrType<R>>;
+  or<F>(result: Result<T, F>): Result<T, F>;
+  or<R extends Promise<Result<T, unknown>>>(result: R): Promise<Result<T, InferErrType<R>>>;
+  or<F>(result: Promise<Result<T, F>>): Promise<Result<T, F>>;
+  /**
+   * Maps `Result<T, E>` to `Result<T | U, F>` or `Promise<Result<U, E | F>>` with a function
+   */
+  orElse<R extends Result>(fn: (error: E) => R): Result<InferOkType<R> | T, InferErrType<R>>;
+  orElse<U, F>(fn: (error: E) => Result<U, F>): Result<T | U, F>;
+  orElse<R extends Promise<Result>>(fn: (error: E) => R): Promise<Result<InferOkType<R> | T, InferErrType<R>>>;
+  orElse<U, F>(fn: (error: E) => Promise<Result<U, F>>): Promise<Result<T | U, F>>;
+  /**
+   * Calls the function with the value if `Result` is `Ok` and returns the result unchanged
+   */
+  inspect(fn: (value: T) => unknown): Result<T, E>;
+  /**
+   * Calls the function with the error if `Result` is `Err` and returns the result unchanged
+   */
+  inspectErr(fn: (error: E) => unknown): Result<T, E>;
+  /**
+   * Unwrap the `Ok` value, or throw an error if `Result` is `Err`
+   */
+  unwrap(message?: string | null): T;
+  /**
+   * Unwrap the `Err` value, or throw an error if `Result` is `Ok`
+   */
+  unwrapErr(message?: string | null): E;
+  /**
+   * Unwrap the `Ok` value, or return the provided value if `Result` is `Err`
+   */
+  unwrapOr(defaultValue: T): T;
+  /**
+   * Unwrap the `Ok` value, or compute it from a function if `Result` is `Err`
+   */
+  unwrapOrElse(defaultValueGetter: (error: E) => T): T;
+  /**
+   * Matches the `Result` variant and executes the corresponding function
+   */
+  match<U, F = U>(ok: (value: T) => U, err: (error: E) => F): U | F;
+  /**
+   * Returns an iterable object that yields the `Ok` value and `Err` value
+   */
+  iter(): [ok: true, error: never, value: T] | [ok: false, error: E, value: never];
+  [Symbol.iterator](): Iterator<Err<E>, T>;
+  context(context: string): this;
+}
+declare const ok: typeof Result.ok;
+declare const err: typeof Result.err;
+//#endregion
+//#region src/result/error.d.ts
+declare class ResultError extends Error {
+  #private;
+  static is(value: unknown): value is ResultError;
+  static fmt(result: Result, message?: string): string;
+  constructor(result: Result, message?: string, caller?: Function);
+  get msg(): string;
+  get contexts(): string[];
+  toString(): string;
+}
+//#endregion
+export { err as a, ExtractOkTypes as c, ResultAll as d, Result as i, InferErrType as l, Err as n, ok as o, Ok as r, ExtractErrTypes as s, ResultError as t, InferOkType as u };

package/dist/chunks/chunk-7ffde8d4.js

@@ -0,0 +1,43 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+export { __toESM as i, __exportAll as n, __reExport as r, __commonJSMin as t };

package/dist/chunks/chunk-b61db0a7.js

@@ -0,0 +1,27 @@
+import { add, addProp, allPass, anyPass, capitalize, ceil, chunk, clamp, clone, concat, conditional, constant, countBy, debounce, defaultTo, difference, differenceWith, divide, doNothing, drop, dropFirstBy, dropLast, dropLastWhile, dropWhile, endsWith, entries, evolve, filter, find, findIndex, findLast, findLastIndex, first, firstBy, flat, flatMap, floor, forEach, forEachObj, fromEntries, fromKeys, funnel, groupBy, groupByProp, hasAtLeast, hasSubObject, identity, indexBy, intersection, intersectionWith, invert, isArray, isBigInt, isBoolean, isDate, isDeepEqual, isDefined, isEmpty, isEmptyish, isError, isFunction, isIncludedIn, isNonNull, isNonNullish, isNot, isNullish, isNumber, isObjectType, isObjectType as isObjectType$1, isPlainObject, isPromise, isShallowEqual, isStrictEqual, isString, isSymbol, isTruthy, join, keys, last, length, map, mapKeys, mapToObj, mapValues, mapWithFeedback, mean, meanBy, median, merge, mergeAll, mergeDeep, multiply, nthBy, objOf, omit, omitBy, once, only, partialBind, partialLastBind, partition, pathOr, pick, pickBy, pipe, piped, product, prop, pullObject, purry, purry as purry$1, randomBigInt, randomInteger, randomString, range, rankBy, reduce, reverse, round, sample, set, setPath, shuffle, sliceString, sort, sortBy, sortedIndex, sortedIndexBy, sortedIndexWith, sortedLastIndex, sortedLastIndexBy, splice, split, splitAt, splitWhen, startsWith, stringToPath, subtract, sum, sumBy, swapIndices, swapProps, take, takeFirstBy, takeLast, takeLastWhile, takeWhile, tap, times, toCamelCase, toKebabCase, toLowerCase, toSnakeCase, toTitleCase, toUpperCase, truncate, uncapitalize, unique, uniqueBy, uniqueWith, values, when, zip, zipWith } from "remeda";
+import { accumulateAsync as accumulateP, accumulateSync as accumulate, awaitAll, buffer, chunkAsync as chunkP, compose, concatAsync as concatP, concurrency, differenceAsync as differenceP, differenceByAsync as differenceByP, differenceBySync as differenceBy, differenceWithAsync as differenceWithP, dropAsync as dropP, everyAsync as everyP, everySync as every, executeAsync as executeP, executeSync as execute, filterAsync as filterP, findAsync as findP, flatMapAsync as flatMapP, flattenAsync as flattenP, flattenSync as flatten, forEachAsync as forEachP, intersectionAsync as intersectionP, intersectionByAsync as intersectionByP, intersectionBySync as intersectionBy, intersectionWithAsync as intersectionWithP, mapAsync as mapP, peekAsync as peekP, peekSync as peek, reduceAsync as reduceP, serializeAsync as serializeP, serializeSync as serialize, someAsync as someP, someSync as some, takeAsync as takeP, throttle, toArrayAsync as toArrayP, toArraySync as toArray, toIteratorAsync as toIteratorP, toIteratorSync as toIterator, uniqueAsync as uniqueP, uniqueByAsync as uniqueByP, uniqueWithAsync as uniqueWithP } from "rotery";
+
+//#region src/remeda/hasOwnProperty.ts
+function hasOwnProperty(...args) {
+	return purry(hasOwnPropertyImplementation, args);
+}
+function hasOwnPropertyImplementation(data, properties) {
+	if (!isObjectType(data)) return false;
+	for (const property of properties) if (!Object.hasOwn(data, property)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/remeda/isFunction.ts
+function isFunction$1(data) {
+	return typeof data === "function";
+}
+
+//#endregion
+//#region src/remeda/isPromiseLike.ts
+function isPromiseLike(data) {
+	return isObjectType(data) && isFunction(data.then) && Object.getOwnPropertyDescriptor(data, "then")?.get === void 0;
+}
+
+//#endregion
+export { firstBy as $, sortedIndexWith as $n, mapKeys as $t, divide as A, purry$1 as An, toTitleCase as Ar, isDefined as At, every as B, sample as Bn, values as Br, isObjectType$1 as Bt, defaultTo as C, pick as Cn, toArrayP as Cr, intersectionWithP as Ct, differenceP as D, product as Dn, toKebabCase as Dr, isBoolean as Dt, differenceByP as E, piped as En, toIteratorP as Er, isBigInt as Et, dropLastWhile as F, rankBy as Fn, uniqueBy as Fr, isNonNull as Ft, filter as G, shuffle as Gn, isFunction$1 as Gr, isString as Gt, evolve as H, serializeP as Hn, zip as Hr, isPromise as Ht, dropP as I, reduce as In, uniqueByP as Ir, isNonNullish as It, findIndex as J, someP as Jn, join as Jt, filterP as K, sliceString as Kn, hasOwnProperty as Kr, isSymbol as Kt, dropWhile as L, reduceP as Ln, uniqueP as Lr, isNot as Lt, drop as M, randomInteger as Mn, truncate as Mr, isEmptyish as Mt, dropFirstBy as N, randomString as Nn, uncapitalize as Nr, isError as Nt, differenceWith as O, prop as On, toLowerCase as Or, isDate as Ot, dropLast as P, range as Pn, unique as Pr, isIncludedIn as Pt, first as Q, sortedIndexBy as Qn, map as Qt, endsWith as R, reverse as Rn, uniqueWith as Rr, isNullish as Rt, debounce as S, peekP as Sn, toArray as Sr, intersectionWith as St, differenceBy as T, pipe as Tn, toIterator as Tr, isArray as Tt, execute as U, set as Un, zipWith as Ur, isShallowEqual as Ut, everyP as V, serialize as Vn, when as Vr, isPlainObject as Vt, executeP as W, setPath as Wn, isPromiseLike as Wr, isStrictEqual as Wt, findLastIndex as X, sortBy as Xn, last as Xt, findLast as Y, sort as Yn, keys as Yt, findP as Z, sortedIndex as Zn, length as Zt, concatP as _, partialBind as _n, takeP as _r, indexBy as _t, allPass as a, meanBy as an, splitWhen as ar, floor as at, constant as b, pathOr as bn, throttle as br, intersectionByP as bt, buffer as c, mergeAll as cn, subtract as cr, forEachP as ct, chunk as d, nthBy as dn, swapIndices as dr, funnel as dt, mapP as en, sortedLastIndex as er, flat as et, chunkP as f, objOf as fn, swapProps as fr, groupBy as ft, concat as g, only as gn, takeLastWhile as gr, identity as gt, compose as h, once as hn, takeLast as hr, hasSubObject as ht, addProp as i, mean as in, splitAt as ir, flattenP as it, doNothing as j, randomBigInt as jn, toUpperCase as jr, isEmpty as jt, differenceWithP as k, pullObject as kn, toSnakeCase as kr, isDeepEqual as kt, capitalize as l, mergeDeep as ln, sum as lr, fromEntries as lt, clone as m, omitBy as mn, takeFirstBy as mr, hasAtLeast as mt, accumulateP as n, mapValues as nn, splice as nr, flatMapP as nt, anyPass as o, median as on, startsWith as or, forEach as ot, clamp as p, omit as pn, take as pr, groupByProp as pt, find as q, some as qn, isTruthy as qt, add as r, mapWithFeedback as rn, split as rr, flatten as rt, awaitAll as s, merge as sn, stringToPath as sr, forEachObj as st, accumulate as t, mapToObj as tn, sortedLastIndexBy as tr, flatMap as tt, ceil as u, multiply as un, sumBy as ur, fromKeys as ut, concurrency as v, partialLastBind as vn, takeWhile as vr, intersection as vt, difference as w, pickBy as wn, toCamelCase as wr, invert as wt, countBy as x, peek as xn, times as xr, intersectionP as xt, conditional as y, partition as yn, tap as yr, intersectionBy as yt, entries as z, round as zn, uniqueWithP as zr, isNumber as zt };

package/dist/common.d.ts

@@ -1,5 +1,5 @@
-import { i as Result } from "./chunks/chunk-d1860346.js";
-import { ai as Fn, ri as AsyncFn } from "./chunks/chunk-e931fe39.js";
+import { i as Result } from "./chunks/chunk-704a1835.js";
+import { l as Fn, p as TemplateFn, s as AsyncFn } from "./chunks/chunk-3c6f28c7.js";
 
 //#region src/common/error.d.ts
 declare const normalizeError: (error: unknown, caller?: Function) => Error;
@@ -46,7 +46,7 @@ declare const scale: (value: number, inRange: [min: number, max: number], outRan
 //#endregion
 //#region src/common/parse.d.ts
 declare const parseKeyValuePairs: (input: string) => Record<string, string>;
-declare const parseValueToBoolean: (value: unknown, defaultValue: boolean) => boolean;
+declare const parseValueToBoolean: <T>(value: unknown, defaultValue: T | boolean) => T | boolean;
 //#endregion
 //#region src/common/promise.d.ts
 interface Singleton<T> {
@@ -94,13 +94,6 @@ declare const joinWithSlash: (...paths: string[]) => string;
 declare const splitWithSlash: (path: string) => string[];
 declare const splitByLineBreak: (str: string) => string[];
 declare const concatTemplateStrings: (template: TemplateStringsArray, values: any[]) => string;
-interface StringOrTemplateFunction {
-  (str: string): string;
-  (template: TemplateStringsArray, ...values: any[]): string;
-}
-interface UnindentFunction extends StringOrTemplateFunction {
-  (trimStart?: boolean, trimEnd?: boolean): StringOrTemplateFunction;
-}
 /**
  * @example
  * ```ts
@@ -122,11 +115,9 @@ interface UnindentFunction extends StringOrTemplateFunction {
  * const str3 = unindent(true, false)("  hello\n  world\n");
  * ```
  */
-declare const unindent: UnindentFunction;
-interface IndentFunction {
-  (indentNumber: number, trimStart?: boolean, trimEnd?: boolean): StringOrTemplateFunction;
-  (indentString: string, trimStart?: boolean, trimEnd?: boolean): StringOrTemplateFunction;
-}
+declare function unindent(str: string): string;
+declare function unindent(template: TemplateStringsArray, ...values: any[]): string;
+declare function unindent(trimStart?: boolean, trimEnd?: boolean): TemplateFn<string> & ((str: string) => string);
 /**
  * @example
  * ```ts
@@ -148,7 +139,8 @@ interface IndentFunction {
  * const str3 = indent(2, true, false)("hello\nworld\n");
  * ```
  */
-declare const indent: IndentFunction;
+declare function indent(indentNumber: number, trimStart?: boolean, trimEnd?: boolean): TemplateFn<string> & ((str: string) => string);
+declare function indent(indentString: string, trimStart?: boolean, trimEnd?: boolean): TemplateFn<string> & ((str: string) => string);
 /**
  * @example
  * ```

package/dist/common.js

@@ -1,3 +1,3 @@
-import { C as linear, D as safeParse, E as normalizeError, O as stringify, S as parseValueToBoolean, T as getErrorMessage, _ as createLock, a as concatTemplateStrings, b as sleep, c as joinWithSlash, d as split, f as splitByLineBreak, g as unindent, h as toForwardSlash, i as addSuffix, k as unsafeParse, l as removePrefix, m as template, n as throttle, o as indent, p as splitWithSlash, r as addPrefix, s as join, t as debounce, u as removeSuffix, v as createPromiseWithResolvers, w as scale, x as parseKeyValuePairs, y as createSingleton } from "./chunks/chunk-5ed3bc8a.js";
+import { C as linear, D as safeParse, E as normalizeError, O as stringify, S as parseValueToBoolean, T as getErrorMessage, _ as createLock, a as concatTemplateStrings, b as sleep, c as joinWithSlash, d as split, f as splitByLineBreak, g as unindent, h as toForwardSlash, i as addSuffix, k as unsafeParse, l as removePrefix, m as template, n as throttle, o as indent, p as splitWithSlash, r as addPrefix, s as join, t as debounce, u as removeSuffix, v as createPromiseWithResolvers, w as scale, x as parseKeyValuePairs, y as createSingleton } from "./chunks/chunk-486f65b0.js";
 
 export { addPrefix, addSuffix, concatTemplateStrings, createLock, createPromiseWithResolvers, createSingleton, debounce, getErrorMessage, indent, join, joinWithSlash, linear, normalizeError, unsafeParse as parse, parseKeyValuePairs, parseValueToBoolean, removePrefix, removeSuffix, safeParse, scale, sleep, split, splitByLineBreak, splitWithSlash, stringify, template, throttle, toForwardSlash, unindent };

package/dist/fs.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="node" />
-import { i as Result } from "./chunks/chunk-d1860346.js";
+import { i as Result } from "./chunks/chunk-704a1835.js";
 import * as nativeFs$1 from "fs";
 
 //#region node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.3/node_modules/fdir/dist/index.d.mts
-
 type FSLike = {
   readdir: typeof nativeFs$1.readdir;
   readdirSync: typeof nativeFs$1.readdirSync;
@@ -15,7 +14,6 @@ type FSLike = {
 //#endregion
 //#region node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.d.mts
 //#region src/utils.d.ts
-
 /**
 * Converts a path to a pattern depending on the platform.
 * Identical to {@link escapePath} on POSIX systems.
@@ -41,8 +39,7 @@ declare const escapePath: (path: string) => string;
 */
 declare function isDynamicPattern(pattern: string, options?: {
   caseSensitiveMatch: boolean;
-}): boolean;
-//#endregion
+}): boolean; //#endregion
 //#region src/index.d.ts
 interface GlobOptions$1 {
   /**