@duplojs/utils 1.4.40 → 1.4.42

package/dist/array/types/index.d.ts

@@ -7,5 +7,5 @@ export * from "./mergeUnionTuple";
 export * from "./extractTuple";
 export * from "./excludeTuple";
 export * from "./createTuple";
-export * from "./ArrayCoalescing";
+export * from "./arrayCoalescing";
 export * from "./joinTuple";

package/dist/clean/constraint/base.d.ts

@@ -79,7 +79,7 @@ export interface ConstraintHandler<GenericName extends string = string, GenericP
 }
 declare const CreateConstrainedTypeError_base: new (params: {
     "@DuplojsUtilsError/create-constrained-type-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../..").KindDefinition<"create-constrained-type-error", unknown>, unknown> & Kind<import("../..").KindDefinition<"@DuplojsUtilsError/create-constrained-type-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../..").KindDefinition<"create-constrained-type-error", unknown>, unknown> & Kind<import("../..").KindDefinition<"@DuplojsUtilsError/create-constrained-type-error", unknown>, unknown>;
 export declare class CreateConstrainedTypeError extends CreateConstrainedTypeError_base {
     constrainedTypeName: string;
     data: unknown;

package/dist/clean/entity.d.ts

@@ -115,7 +115,7 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
 }
 declare const CreateEntityError_base: new (params: {
     "@DuplojsUtilsError/create-entity-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../common").KindDefinition<"create-entity-error", unknown>, unknown> & Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-entity-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../common").KindDefinition<"create-entity-error", unknown>, unknown> & Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-entity-error", unknown>, unknown>;
 export declare class CreateEntityError extends CreateEntityError_base {
     rawProperties: EntityRawProperties;
     dataParserError: DDataParser.DataParserError;

package/dist/clean/newType.d.ts

@@ -87,7 +87,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
 }
 declare const CreateNewTypeError_base: new (params: {
     "@DuplojsUtilsError/create-new-type-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("..").KindDefinition<"create-new-type-error", unknown>, unknown> & Kind<import("..").KindDefinition<"@DuplojsUtilsError/create-new-type-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("..").KindDefinition<"create-new-type-error", unknown>, unknown> & Kind<import("..").KindDefinition<"@DuplojsUtilsError/create-new-type-error", unknown>, unknown>;
 export declare class CreateNewTypeError extends CreateNewTypeError_base {
     newTypeName: string;
     data: unknown;

package/dist/clean/primitive/base.d.ts

@@ -67,7 +67,7 @@ export interface PrimitiveHandler<GenericValue extends EligiblePrimitive = Eligi
 }
 declare const CreatePrimitiveError_base: new (params: {
     "@DuplojsUtilsError/create-primitive-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../../common").KindDefinition<"create-primitive-error", unknown>, unknown> & Kind<import("../../common").KindDefinition<"@DuplojsUtilsError/create-primitive-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../../common").KindDefinition<"create-primitive-error", unknown>, unknown> & Kind<import("../../common").KindDefinition<"@DuplojsUtilsError/create-primitive-error", unknown>, unknown>;
 export declare class CreatePrimitiveError extends CreatePrimitiveError_base {
     data: unknown;
     dataParserError: DDataParser.DataParserError;

package/dist/common/asserts.d.ts

@@ -1,6 +1,6 @@
 declare const AssertsError_base: new (params: {
     "@DuplojsUtilsError/asserts-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"asserts-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/asserts-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"asserts-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/asserts-error", unknown>, unknown>;
 export declare class AssertsError extends AssertsError_base {
     value: unknown;
     constructor(value: unknown);

package/dist/common/builder.d.ts

@@ -25,7 +25,7 @@ export interface BuilderHandler<GenericBuilder extends Builder = Builder> {
 }
 declare const MissingBuilderMethodsError_base: new (params: {
     "@DuplojsUtilsError/missing-builder-methods-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/missing-builder-methods-error", unknown>, unknown> & Kind<import("./kind").KindDefinition<"missing-builder-methods-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/missing-builder-methods-error", unknown>, unknown> & Kind<import("./kind").KindDefinition<"missing-builder-methods-error", unknown>, unknown>;
 export declare class MissingBuilderMethodsError extends MissingBuilderMethodsError_base {
     method: string;
     constructor(method: string);

package/dist/common/index.d.ts

@@ -72,3 +72,4 @@ export * from "./hasKinds";
 export * from "./toCurriedPredicate";
 export * from "./pipeCall";
 export * from "./asserts";
+export * as Path from "./path";

package/dist/common/kind.d.ts

@@ -141,6 +141,6 @@ export declare function createKindNamespace<GenericNamespace extends string>(nam
 export type KindHeritageConstructorParams<GenericKindHandler extends KindHandler> = {
     [KindHandler in GenericKindHandler as KindHandler["definition"]["name"]]: KindHandler["definition"]["value"];
 } extends infer InferredResult extends object ? PartialKeys<InferredResult, GetPropsWithValue<InferredResult, unknown>> : never;
-export declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler, GenericParent extends AnyConstructor = AnyConstructor<unknown[], never>>(uniqueName: GenericUniqueName & ForbiddenKindCharacters<GenericUniqueName>, kind: GenericKindHandler | GenericKindHandler[], parent?: GenericParent): new (...args: And<[IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true>, IsEqual<InstanceType<GenericParent>, never>]> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>, ...parentArgs: IsEqual<ConstructorParameters<GenericParent>, unknown[]> extends true ? [parentParams?: ConstructorParameters<GenericParent>] : [parentParams: ConstructorParameters<GenericParent>]]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>> | InstanceType<GenericParent>>;
+export declare function kindHeritage<GenericUniqueName extends string, GenericKindHandler extends KindHandler, GenericParent extends AnyConstructor = AnyConstructor<unknown[], never>>(uniqueName: GenericUniqueName & ForbiddenKindCharacters<GenericUniqueName>, kind: GenericKindHandler | GenericKindHandler[], parent?: GenericParent): new (...args: And<[IsEqual<GenericKindHandler extends KindHandler ? IsEqual<GenericKindHandler["definition"]["value"], unknown> : never, true>, IsEqual<InstanceType<GenericParent>, never>]> extends true ? [params?: KindHeritageConstructorParams<GenericKindHandler>] : [params: KindHeritageConstructorParams<GenericKindHandler>, ...parentArgs: IsEqual<ConstructorParameters<GenericParent>, unknown[]> extends true ? [parentParams?: readonly [...ConstructorParameters<GenericParent>]] : [parentParams: readonly [...ConstructorParameters<GenericParent>]]]) => UnionToIntersection<(GenericKindHandler extends KindHandler ? Kind<GenericKindHandler["definition"]> : never) | Kind<KindDefinition<GenericUniqueName, unknown>> | InstanceType<GenericParent>>;
 export declare function isRuntimeKind(value: string): boolean;
 export {};

package/dist/common/path/getBaseName.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var split = require('../../string/split.cjs');
+var findLast = require('../../array/findLast.cjs');
+var length = require('../../string/length.cjs');
+var endsWith = require('../../string/endsWith.cjs');
+var slice = require('../../string/slice.cjs');
+
+/**
+ * {@include common/path/getBaseName/index.md}
+ */
+function getBaseName(path, params) {
+    const segments = split.split(path, "/");
+    const lastSegment = findLast.findLast(segments, (value) => length.length(value) > 0) ?? null;
+    if (!lastSegment || lastSegment === "..") {
+        return null;
+    }
+    if (params?.extension && endsWith.endsWith(lastSegment, params?.extension)) {
+        const extensionLength = length.length(params.extension);
+        return slice.slice(lastSegment, 0, -extensionLength);
+    }
+    return lastSegment;
+}
+
+exports.getBaseName = getBaseName;

package/dist/common/path/getBaseName.d.ts

@@ -0,0 +1,26 @@
+interface GetBaseNameParams {
+    extension?: string;
+}
+/**
+ * Returns the last non-empty segment of a path, optionally without an extension.
+ * 
+ * **Supported call styles:**
+ * - Classic: `getBaseName(path, params?)` -> returns the base name or null
+ * 
+ * It ignores trailing slashes and returns null when the path has no segment or when the last segment is `..`.
+ * When an extension is provided, it is removed only if it matches the end of the base name.
+ * 
+ * ```ts
+ * const defaultResult = Path.getBaseName("/foo/bar.txt");
+ * // defaultResult: "bar.txt"
+ * const withoutExtResult = Path.getBaseName("/foo/bar.txt", { extension: ".txt" });
+ * // withoutExtResult: "bar"
+ * const nullResult = Path.getBaseName("..");
+ * // nullResult: null
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path/getBaseName
+ * 
+ */
+export declare function getBaseName<GenericPath extends string>(path: GenericPath, params?: GetBaseNameParams): string | null;
+export {};

package/dist/common/path/getBaseName.mjs

@@ -0,0 +1,23 @@
+import { split } from '../../string/split.mjs';
+import { findLast } from '../../array/findLast.mjs';
+import { length } from '../../string/length.mjs';
+import { endsWith } from '../../string/endsWith.mjs';
+import { slice } from '../../string/slice.mjs';
+
+/**
+ * {@include common/path/getBaseName/index.md}
+ */
+function getBaseName(path, params) {
+    const segments = split(path, "/");
+    const lastSegment = findLast(segments, (value) => length(value) > 0) ?? null;
+    if (!lastSegment || lastSegment === "..") {
+        return null;
+    }
+    if (params?.extension && endsWith(lastSegment, params?.extension)) {
+        const extensionLength = length(params.extension);
+        return slice(lastSegment, 0, -extensionLength);
+    }
+    return lastSegment;
+}
+
+export { getBaseName };

package/dist/common/path/getExtensionName.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var minElements = require('../../array/minElements.cjs');
+
+const extensionNameRegex = /\.([^./]+)$/;
+/**
+ * {@include common/path/getExtensionName/index.md}
+ */
+function getExtensionName(path) {
+    const match = extensionNameRegex.exec(path);
+    if (!!match && minElements.minElements(match, 2)) {
+        return match[1];
+    }
+    return null;
+}
+
+exports.getExtensionName = getExtensionName;

package/dist/common/path/getExtensionName.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns the last extension of a path, without the leading dot.
+ * 
+ * **Supported call styles:**
+ * - Classic: `getExtensionName(path)` -> returns the extension or null
+ * 
+ * It returns null when no extension is found, when the path ends with a dot, or when the path is `..`.
+ * 
+ * ```ts
+ * const txtResult = Path.getExtensionName("/foo/bar.txt");
+ * // txtResult: "txt"
+ * const tarResult = Path.getExtensionName("archive.tar.gz");
+ * // tarResult: "gz"
+ * const dotResult = Path.getExtensionName("file.");
+ * // dotResult: null
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path/getExtensionName
+ * 
+ */
+export declare function getExtensionName<GenericPath extends string>(path: GenericPath): string | null;

package/dist/common/path/getExtensionName.mjs

@@ -0,0 +1,15 @@
+import { minElements } from '../../array/minElements.mjs';
+
+const extensionNameRegex = /\.([^./]+)$/;
+/**
+ * {@include common/path/getExtensionName/index.md}
+ */
+function getExtensionName(path) {
+    const match = extensionNameRegex.exec(path);
+    if (!!match && minElements(match, 2)) {
+        return match[1];
+    }
+    return null;
+}
+
+export { getExtensionName };

package/dist/common/path/getParentFolderPath.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var pipe = require('../pipe.cjs');
+var isAbsolute = require('./isAbsolute.cjs');
+var slice = require('../../array/slice.cjs');
+var split = require('../../string/split.cjs');
+var replace = require('../../string/replace.cjs');
+var join = require('../../array/join.cjs');
+
+/**
+ * {@include common/path/getParentFolderPath/index.md}
+ */
+function getParentFolderPath(path) {
+    const segments = pipe.pipe(path, replace.replace(/\/$/, ""), split.split("/"), slice.slice(0, -1));
+    return join.join(segments, "/")
+        || (isAbsolute.isAbsolute(path)
+            ? "/"
+            : ".");
+}
+
+exports.getParentFolderPath = getParentFolderPath;

package/dist/common/path/getParentFolderPath.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns the parent folder path of a POSIX path.
+ * 
+ * **Supported call styles:**
+ * - Classic: `getParentFolderPath(path)` -> returns the parent folder
+ * 
+ * It removes a trailing slash, drops the last segment, and falls back to `/` for absolute paths or `.` for relative paths when needed.
+ * 
+ * ```ts
+ * const result = Path.getParentFolderPath("/foo/bar/baz");
+ * // result: "/foo/bar"
+ * const trailingResult = Path.getParentFolderPath("/foo/bar/");
+ * // trailingResult: "/foo"
+ * const relativeResult = Path.getParentFolderPath("foo");
+ * // relativeResult: "."
+ * const absoluteResult = Path.getParentFolderPath("/foo");
+ * // absoluteResult: "/"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path/getParentFolderPath
+ * 
+ */
+export declare function getParentFolderPath<GenericPath extends string>(path: GenericPath): string;

package/dist/common/path/getParentFolderPath.mjs

@@ -0,0 +1,19 @@
+import { pipe } from '../pipe.mjs';
+import { isAbsolute } from './isAbsolute.mjs';
+import { slice } from '../../array/slice.mjs';
+import { split } from '../../string/split.mjs';
+import { replace } from '../../string/replace.mjs';
+import { join } from '../../array/join.mjs';
+
+/**
+ * {@include common/path/getParentFolderPath/index.md}
+ */
+function getParentFolderPath(path) {
+    const segments = pipe(path, replace(/\/$/, ""), split("/"), slice(0, -1));
+    return join(segments, "/")
+        || (isAbsolute(path)
+            ? "/"
+            : ".");
+}
+
+export { getParentFolderPath };

package/dist/common/path/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var isAbsolute = require('./isAbsolute.cjs');
+var getParentFolderPath = require('./getParentFolderPath.cjs');
+var getBaseName = require('./getBaseName.cjs');
+var getExtensionName = require('./getExtensionName.cjs');
+var resolveFrom = require('./resolveFrom.cjs');
+var resolveRelative = require('./resolveRelative.cjs');
+
+/**
+ * {@include common/path/index.md}
+ */
+
+exports.isAbsolute = isAbsolute.isAbsolute;
+exports.getParentFolderPath = getParentFolderPath.getParentFolderPath;
+exports.getBaseName = getBaseName.getBaseName;
+exports.getExtensionName = getExtensionName.getExtensionName;
+exports.resolveFrom = resolveFrom.resolveFrom;
+exports.resolveRelative = resolveRelative.resolveRelative;

package/dist/common/path/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Path utilities to resolve and inspect POSIX paths.
+ * They preserve input strings and return new values.
+ * 
+ * **How to import:**
+ * - From the main common namespace
+ * - Via direct import for tree-shaking
+ * 
+ * ```ts
+ * import { Path } from "@duplojs/utils";
+ * import * as Path from "@duplojs/utils/common/path";
+ * ```
+ * 
+ * What you will find in this namespace:
+ * - checks (`Path.isAbsolute`)
+ * - resolution (`Path.resolveFrom`, `Path.resolveRelative`)
+ * - path parsing (`Path.getParentFolderPath`, `Path.getBaseName`, `Path.getExtensionName`)
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path
+ * 
+ */
+export * from "./isAbsolute";
+export * from "./getParentFolderPath";
+export * from "./getBaseName";
+export * from "./getExtensionName";
+export * from "./resolveFrom";
+export * from "./resolveRelative";

package/dist/common/path/index.mjs

@@ -0,0 +1,10 @@
+export { isAbsolute } from './isAbsolute.mjs';
+export { getParentFolderPath } from './getParentFolderPath.mjs';
+export { getBaseName } from './getBaseName.mjs';
+export { getExtensionName } from './getExtensionName.mjs';
+export { resolveFrom } from './resolveFrom.mjs';
+export { resolveRelative } from './resolveRelative.mjs';
+
+/**
+ * {@include common/path/index.md}
+ */

package/dist/common/path/isAbsolute.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var startsWith = require('../../string/startsWith.cjs');
+var test = require('../../string/test.cjs');
+
+const isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+/**
+ * {@include common/path/isAbsolute/index.md}
+ */
+function isAbsolute(path) {
+    return startsWith.startsWith(path, "/")
+        && !test.test(path, isRelativeRegex);
+}
+
+exports.isAbsolute = isAbsolute;

package/dist/common/path/isAbsolute.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Checks whether a path is absolute (POSIX).
+ * 
+ * **Supported call styles:**
+ * - Classic: `isAbsolute(path)` -> returns a boolean
+ * 
+ * It returns true when the path starts with `/` and does not contain `..` segments.
+ * 
+ * ```ts
+ * const absolutePath = Path.isAbsolute("/var/log");
+ * // absolutePath: true
+ * const parentTraversal = Path.isAbsolute("/var/../log");
+ * // parentTraversal: false
+ * const relativePath = Path.isAbsolute("var/log");
+ * // relativePath: false
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path/isAbsolute
+ * 
+ */
+export declare function isAbsolute<GenericPath extends string>(path: GenericPath): boolean;

package/dist/common/path/isAbsolute.mjs

@@ -0,0 +1,13 @@
+import { startsWith } from '../../string/startsWith.mjs';
+import { test } from '../../string/test.mjs';
+
+const isRelativeRegex = /(^|\/)\.\.(?=\/|$)/;
+/**
+ * {@include common/path/isAbsolute/index.md}
+ */
+function isAbsolute(path) {
+    return startsWith(path, "/")
+        && !test(path, isRelativeRegex);
+}
+
+export { isAbsolute };

package/dist/common/path/resolveFrom.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var isAbsolute = require('./isAbsolute.cjs');
+var resolveRelative = require('./resolveRelative.cjs');
+var success = require('../../either/right/success.cjs');
+var fail = require('../../either/left/fail.cjs');
+
+/**
+ * {@include common/path/resolveFrom/index.md}
+ */
+function resolveFrom(origin, segments) {
+    const result = resolveRelative.resolveRelative([origin, ...segments]);
+    return isAbsolute.isAbsolute(result)
+        ? success.success(result)
+        : fail.fail();
+}
+
+exports.resolveFrom = resolveFrom;

package/dist/common/path/resolveFrom.d.ts

@@ -0,0 +1,27 @@
+import * as DEither from "../../either";
+import type { AnyTuple } from "../types";
+/**
+ * Resolves a list of path segments from an origin and returns an Either.
+ * 
+ * **Supported call styles:**
+ * - Classic: `resolveFrom(origin, segments)` -> returns an Either
+ * 
+ * Segments are resolved in order using `resolveRelative`.
+ * The result is an `Either` that is `success` only when the resolved path is absolute; otherwise it returns `fail`.
+ * 
+ * ```ts
+ * const absoluteResult = Path.resolveFrom("/root", ["alpha", "beta"]);
+ * // absoluteResult: DEither.success<"/root/alpha/beta">
+ * const result = unwrap(absoluteResult);
+ * // result: "/root/alpha/beta"
+ * 
+ * const overrideResult = Path.resolveFrom("gamma", ["alpha", "/root", "beta"]);
+ * // overrideResult: DEither.success<"/root/beta">
+ * const relativeResult = Path.resolveFrom("alpha", ["..", ".."]);
+ * // relativeResult: DEither.fail
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveFrom
+ * 
+ */
+export declare function resolveFrom<GenericSegment extends string>(origin: string, segments: AnyTuple<GenericSegment>): DEither.EitherFail | DEither.EitherSuccess<string>;

package/dist/common/path/resolveFrom.mjs

@@ -0,0 +1,16 @@
+import { isAbsolute } from './isAbsolute.mjs';
+import { resolveRelative } from './resolveRelative.mjs';
+import { success } from '../../either/right/success.mjs';
+import { fail } from '../../either/left/fail.mjs';
+
+/**
+ * {@include common/path/resolveFrom/index.md}
+ */
+function resolveFrom(origin, segments) {
+    const result = resolveRelative([origin, ...segments]);
+    return isAbsolute(result)
+        ? success(result)
+        : fail();
+}
+
+export { resolveFrom };

package/dist/common/path/resolveRelative.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+const segmentTrailingRegex = /\/$/;
+const segmentRelativeRegex = /^(.\/)/;
+/**
+ * {@include common/path/resolveRelative/index.md}
+ */
+function resolveRelative(segments) {
+    let clearedPath = "";
+    for (const segment of segments) {
+        if (segment.length === 0) {
+            continue;
+        }
+        if (segment === "/") {
+            clearedPath = segment;
+            continue;
+        }
+        const formattedSegment = segment
+            .replace(segmentTrailingRegex, "")
+            .replace(segmentRelativeRegex, "");
+        if (formattedSegment.startsWith("/")) {
+            clearedPath = formattedSegment;
+            continue;
+        }
+        if (clearedPath === "/") {
+            clearedPath += formattedSegment;
+        }
+        else {
+            clearedPath += `/${formattedSegment}`;
+        }
+    }
+    const dotResult = [];
+    const result = [];
+    for (const element of clearedPath.split("/")) {
+        if (element === "..") {
+            const deletedElement = result.pop();
+            if (!deletedElement) {
+                dotResult.push(element);
+            }
+        }
+        else {
+            result.push(element);
+        }
+    }
+    if (dotResult.length === 0) {
+        return result.join("/");
+    }
+    return `${dotResult.join("/")}/${result.join("/")}`;
+}
+
+exports.resolveRelative = resolveRelative;

package/dist/common/path/resolveRelative.d.ts

@@ -0,0 +1,23 @@
+import type { AnyTuple } from "../types";
+/**
+ * Resolves path segments into a single POSIX-like path.
+ * 
+ * **Supported call styles:**
+ * - Classic: `resolveRelative(segments)` -> returns the resolved path
+ * 
+ * Empty segments are ignored, trailing slashes and leading `./` are removed, and absolute segments reset the base.
+ * `..` segments remove previous segments and may remain leading when resolving above root.
+ * 
+ * ```ts
+ * const basicResult = Path.resolveRelative(["alpha", "beta"]);
+ * // basicResult: "/alpha/beta"
+ * const overrideResult = Path.resolveRelative(["alpha", "/root", "beta"]);
+ * // overrideResult: "/root/beta"
+ * const parentResult = Path.resolveRelative(["alpha", "..", "..", "beta"]);
+ * // parentResult: "../beta"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/common/path/resolveRelative
+ * 
+ */
+export declare function resolveRelative<GenericSegment extends string>(segments: AnyTuple<GenericSegment>): string;

package/dist/common/path/resolveRelative.mjs

@@ -0,0 +1,49 @@
+const segmentTrailingRegex = /\/$/;
+const segmentRelativeRegex = /^(.\/)/;
+/**
+ * {@include common/path/resolveRelative/index.md}
+ */
+function resolveRelative(segments) {
+    let clearedPath = "";
+    for (const segment of segments) {
+        if (segment.length === 0) {
+            continue;
+        }
+        if (segment === "/") {
+            clearedPath = segment;
+            continue;
+        }
+        const formattedSegment = segment
+            .replace(segmentTrailingRegex, "")
+            .replace(segmentRelativeRegex, "");
+        if (formattedSegment.startsWith("/")) {
+            clearedPath = formattedSegment;
+            continue;
+        }
+        if (clearedPath === "/") {
+            clearedPath += formattedSegment;
+        }
+        else {
+            clearedPath += `/${formattedSegment}`;
+        }
+    }
+    const dotResult = [];
+    const result = [];
+    for (const element of clearedPath.split("/")) {
+        if (element === "..") {
+            const deletedElement = result.pop();
+            if (!deletedElement) {
+                dotResult.push(element);
+            }
+        }
+        else {
+            result.push(element);
+        }
+    }
+    if (dotResult.length === 0) {
+        return result.join("/");
+    }
+    return `${dotResult.join("/")}/${result.join("/")}`;
+}
+
+export { resolveRelative };

package/dist/common/stringToBytes.d.ts

@@ -1,6 +1,6 @@
 declare const InvalidBytesInStringError_base: new (params: {
     "@DuplojsUtilsError/missing-builder-methods-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"invalid-bytes-in-string-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/missing-builder-methods-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"invalid-bytes-in-string-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/missing-builder-methods-error", unknown>, unknown>;
 export declare class InvalidBytesInStringError extends InvalidBytesInStringError_base {
     input: string;
     constructor(input: string);

package/dist/common/stringToMillisecond.d.ts

@@ -1,6 +1,6 @@
 declare const InvalidMillisecondInStringError_base: new (params: {
     "@DuplojsUtilsError/missing-builder-methods-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/missing-builder-methods-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"invalid-millisecond-in-string-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("./kind").Kind<import("./kind").KindDefinition<"@DuplojsUtilsError/missing-builder-methods-error", unknown>, unknown> & import("./kind").Kind<import("./kind").KindDefinition<"invalid-millisecond-in-string-error", unknown>, unknown>;
 export declare class InvalidMillisecondInStringError extends InvalidMillisecondInStringError_base {
     input: string;
     constructor(input: string);

package/dist/date/createOrThrow.d.ts

@@ -1,7 +1,7 @@
 import type { TheDate, SpoolingDate } from "./types";
 declare const CreateTheDateError_base: new (params: {
     "@DuplojsUtilsError/create-the-date-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-date-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-date-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-date-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-date-error", unknown>, unknown>;
 export declare class CreateTheDateError extends CreateTheDateError_base {
     input: string | Date | number | SpoolingDate;
     constructor(input: string | Date | number | SpoolingDate);

package/dist/date/createTimeOrThrow.d.ts

@@ -1,7 +1,7 @@
 import type { SpoolingTime, TheTime } from "./types";
 declare const CreateTheTimeError_base: new (params: {
     "@DuplojsUtilsError/create-the-time-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-time-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-time-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-time-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-time-error", unknown>, unknown>;
 export declare class CreateTheTimeError extends CreateTheTimeError_base {
     input: TheTime | number | SpoolingTime;
     constructor(input: TheTime | number | SpoolingTime);

package/dist/index.cjs

@@ -12,6 +12,7 @@ var index$8 = require('./dataParser/parsers/coerce/index.cjs');
 var index$9 = require('./dataParser/extended/index.cjs');
 var index$a = require('./date/index.cjs');
 var index$b = require('./clean/index.cjs');
+var index$c = require('./common/path/index.cjs');
 var addWrappedProperties = require('./common/addWrappedProperties.cjs');
 var asyncPipe = require('./common/asyncPipe.cjs');
 var clone = require('./common/clone.cjs');
@@ -88,6 +89,7 @@ exports.D = index$a;
 exports.DDate = index$a;
 exports.C = index$b;
 exports.DClean = index$b;
+exports.Path = index$c;
 exports.addWrappedProperties = addWrappedProperties.addWrappedProperties;
 exports.asyncPipe = asyncPipe.asyncPipe;
 exports.clone = clone.clone;

package/dist/index.mjs

@@ -34,6 +34,8 @@ export { index$a as DDate };
 import * as index$b from './clean/index.mjs';
 export { index$b as C };
 export { index$b as DClean };
+import * as index$c from './common/path/index.mjs';
+export { index$c as Path };
 export { addWrappedProperties } from './common/addWrappedProperties.mjs';
 export { asyncPipe } from './common/asyncPipe.mjs';
 export { clone } from './common/clone.mjs';

package/dist/metadata.json

@@ -139,7 +139,7 @@
           "name": "types",
           "files": [
             {
-              "name": "ArrayCoalescing.d.ts"
+              "name": "arrayCoalescing.d.ts"
             },
             {
               "name": "atTuple.d.ts"
@@ -999,6 +999,74 @@
     {
       "name": "common",
       "files": [
+        {
+          "name": "path",
+          "files": [
+            {
+              "name": "getBaseName.cjs"
+            },
+            {
+              "name": "getBaseName.d.ts"
+            },
+            {
+              "name": "getBaseName.mjs"
+            },
+            {
+              "name": "getExtensionName.cjs"
+            },
+            {
+              "name": "getExtensionName.d.ts"
+            },
+            {
+              "name": "getExtensionName.mjs"
+            },
+            {
+              "name": "getParentFolderPath.cjs"
+            },
+            {
+              "name": "getParentFolderPath.d.ts"
+            },
+            {
+              "name": "getParentFolderPath.mjs"
+            },
+            {
+              "name": "index.cjs"
+            },
+            {
+              "name": "index.d.ts"
+            },
+            {
+              "name": "index.mjs"
+            },
+            {
+              "name": "isAbsolute.cjs"
+            },
+            {
+              "name": "isAbsolute.d.ts"
+            },
+            {
+              "name": "isAbsolute.mjs"
+            },
+            {
+              "name": "resolveFrom.cjs"
+            },
+            {
+              "name": "resolveFrom.d.ts"
+            },
+            {
+              "name": "resolveFrom.mjs"
+            },
+            {
+              "name": "resolveRelative.cjs"
+            },
+            {
+              "name": "resolveRelative.d.ts"
+            },
+            {
+              "name": "resolveRelative.mjs"
+            }
+          ]
+        },
         {
           "name": "types",
           "files": [

package/dist/pattern/match/builder.d.ts

@@ -21,7 +21,7 @@ export interface MatchBuilder<GenericValue extends unknown = never, GenericResul
 }
 declare const InvalidExhaustivePatternError_base: new (params: {
     "@DuplojsUtilsError/invalid-exhaustive-pattern-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../../common").Kind<import("../../common").KindDefinition<"invalid-exhaustive-pattern-error", unknown>, unknown> & import("../../common").Kind<import("../../common").KindDefinition<"@DuplojsUtilsError/invalid-exhaustive-pattern-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../../common").Kind<import("../../common").KindDefinition<"invalid-exhaustive-pattern-error", unknown>, unknown> & import("../../common").Kind<import("../../common").KindDefinition<"@DuplojsUtilsError/invalid-exhaustive-pattern-error", unknown>, unknown>;
 export declare class InvalidExhaustivePatternError extends InvalidExhaustivePatternError_base {
     input: unknown;
     constructor(input: unknown);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.40",
+  "version": "1.4.42",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"