@duplojs/lang 0.0.1-beta.4 → 0.0.1-beta.6

package/dist/path/resolveRelative.d.ts

@@ -1,3 +1,10 @@
-import { Path } from './constraints';
+import { Absolute, Path, Segment } from './constraints';
 import { RequireSegments } from './types';
-export declare function resolveRelative<const GenericSegments extends readonly (string & Path)[]>(segments: GenericSegments & RequireSegments<GenericSegments>): string & Path;
+import type * as DCommon from '../common';
+type HasAbsolutePath<GenericSegments extends readonly (string & (Path | Absolute | Segment))[]> = DCommon.ContainExtends<{
+    [Prop in keyof GenericSegments]: [DCommon.IsExtends<GenericSegments[Prop], Absolute>];
+}[Extract<keyof GenericSegments, number>], [
+    true
+]>;
+export declare function resolveRelative<const GenericSegments extends readonly (string & (Path | Absolute | Segment))[]>(segments: GenericSegments & RequireSegments<GenericSegments>): string & Path & (DCommon.BreakGenericLink<HasAbsolutePath<GenericSegments> extends true ? Absolute : unknown>);
+export {};

package/dist/path/resolveRelative.mjs

@@ -1,26 +1,23 @@
 //#region scripts/path/resolveRelative.ts
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(.\/)/;
-function resolveRelative(segments) {
-	let clearedPath = "";
-	for (const segment of segments) {
-		if (segment.length === 0) continue;
-		else if (segment === "/") {
-			clearedPath = segment;
-			continue;
+function resolveRelative(paths) {
+	let absolute = false;
+	const result = [];
+	for (const path of paths) {
+		if (path === ".") continue;
+		if (path.startsWith("/")) {
+			absolute = true;
+			result.length = 0;
+		}
+		for (const segment of path.split("/")) {
+			if (segment === "") continue;
+			if (segment === "..") {
+				if (result.length && result.at(-1) !== "..") result.pop();
+				else if (!absolute) result.push("..");
+			} else result.push(segment);
 		}
-		const formattedSegment = segment.replace(segmentTrailingRegex, "").replace(segmentRelativeRegex, "");
-		if (formattedSegment.startsWith("/") || clearedPath === "") clearedPath = formattedSegment;
-		else if (clearedPath === "/") clearedPath += formattedSegment;
-		else clearedPath += `/${formattedSegment}`;
 	}
-	const dotResult = [];
-	const result = [];
-	for (const element of clearedPath.split("/")) if (element === "..") {
-		if (!result.pop()) dotResult.push(element);
-	} else result.push(element);
-	if (dotResult.length === 0) return result.join("/");
-	return `${dotResult.join("/")}/${result.join("/")}`;
+	if (absolute) return `/${result.join("/")}`;
+	return result.join("/") || ".";
 }
 //#endregion
 export { resolveRelative };

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

@@ -1 +1,7 @@
+export type * from './isLiteralAbsolutePath';
+export type * from './isLiteralPath';
+export type * from './isLiteralSegmentPath';
+export type * from './requireLiteralAbsolutePath';
+export type * from './requireLiteralPath';
+export type * from './requireLiteralSegmentPath';
 export type * from './requireSegments';

package/dist/path/types/isLiteralAbsolutePath.d.ts

@@ -0,0 +1,2 @@
+import { IsLiteralPath } from './isLiteralPath';
+export type IsLiteralAbsolutePath<GenericValue extends string> = IsLiteralPath<GenericValue> extends true ? GenericValue extends `/${string}` ? true : false : false;

package/dist/path/types/isLiteralPath.d.ts

@@ -0,0 +1,20 @@
+import type * as DCommon from '../../common';
+import type * as DString from '../../string';
+type CheckSegment<GenericSegment extends readonly string[], GenericDotIsPass extends boolean, GenericIsFirst extends boolean = true> = GenericSegment extends readonly [] ? true : GenericSegment extends readonly [
+    infer InferredFirst extends string,
+    ...infer InferredRest extends readonly string[]
+] ? DCommon.Or<[
+    DCommon.IsEqual<".", InferredFirst>,
+    DString.Includes<InferredFirst, "/">,
+    DString.Includes<InferredFirst, "\0">,
+    DCommon.And<[
+        DCommon.IsEqual<GenericIsFirst, false>,
+        DCommon.IsEqual<"", InferredFirst>
+    ]>,
+    DCommon.And<[
+        DCommon.IsEqual<GenericDotIsPass, true>,
+        DCommon.IsEqual<"..", InferredFirst>
+    ]>
+]> extends true ? false : CheckSegment<InferredRest, DCommon.Not<DCommon.IsEqual<InferredFirst, "..">>, false> : false;
+export type IsLiteralPath<GenericValue extends string> = DString.IsLiteral<GenericValue> extends true ? GenericValue extends "" ? false : GenericValue extends "/" ? true : GenericValue extends "." ? true : DString.Split<GenericValue, "/"> extends infer InferredResult extends readonly string[] ? CheckSegment<InferredResult, false> : never : false;
+export {};

package/dist/path/types/isLiteralSegmentPath.d.ts

@@ -0,0 +1,9 @@
+import type * as DCommon from '../../common';
+import type * as DString from '../../string';
+export type IsLiteralSegmentPath<GenericValue extends string> = DString.IsLiteral<GenericValue> extends true ? DCommon.Not<DCommon.Or<[
+    DCommon.IsEqual<GenericValue, ".">,
+    DCommon.IsEqual<GenericValue, "..">,
+    DCommon.IsEqual<GenericValue, "">,
+    DString.Includes<GenericValue, "/">,
+    DString.Includes<GenericValue, "\0">
+]>> : false;

package/dist/path/types/requireLiteralAbsolutePath.d.ts

@@ -0,0 +1,3 @@
+import { IsLiteralAbsolutePath } from './isLiteralAbsolutePath';
+import type * as DCommon from '../../common';
+export type RequireLiteralAbsolutePath<GenericValue extends string> = IsLiteralAbsolutePath<GenericValue> extends true ? unknown : DCommon.ComputedTypeError<"Value is not a absolute path.">;

package/dist/path/types/requireLiteralPath.d.ts

@@ -0,0 +1,3 @@
+import { IsLiteralPath } from './isLiteralPath';
+import type * as DCommon from '../../common';
+export type RequireLiteralPath<GenericValue extends string> = IsLiteralPath<GenericValue> extends true ? unknown : DCommon.ComputedTypeError<"Value is not a path.">;

package/dist/path/types/requireLiteralSegmentPath.d.ts

@@ -0,0 +1,3 @@
+import { IsLiteralSegmentPath } from './isLiteralSegmentPath';
+import type * as DCommon from '../../common';
+export type RequireLiteralSegmentPath<GenericValue extends string> = IsLiteralSegmentPath<GenericValue> extends true ? unknown : DCommon.ComputedTypeError<"Value is not a segment path.">;

package/dist/string/index.cjs

@@ -9,7 +9,6 @@ const require_extractAll = require("./extractAll.cjs");
 const require_first = require("./first.cjs");
 const require_includes = require("./includes.cjs");
 const require_indexOf = require("./indexOf.cjs");
-const require_infer = require("./infer.cjs");
 const require_isComposedOf = require("./isComposedOf.cjs");
 const require_isEmail = require("./isEmail.cjs");
 const require_isIn = require("./isIn.cjs");
@@ -63,7 +62,6 @@ var string_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	first: () => require_first.first,
 	includes: () => require_includes.includes,
 	indexOf: () => require_indexOf.indexOf,
-	infer: () => require_infer.infer,
 	isComposedOf: () => require_isComposedOf.isComposedOf,
 	isEmail: () => require_isEmail.isEmail,
 	isIn: () => require_isIn.isIn,
@@ -118,7 +116,6 @@ exports.extractAll = require_extractAll.extractAll;
 exports.first = require_first.first;
 exports.includes = require_includes.includes;
 exports.indexOf = require_indexOf.indexOf;
-exports.infer = require_infer.infer;
 exports.isComposedOf = require_isComposedOf.isComposedOf;
 exports.isEmail = require_isEmail.isEmail;
 exports.isIn = require_isIn.isIn;

package/dist/string/index.d.ts

@@ -9,7 +9,6 @@ export * from './extractAll';
 export * from './first';
 export * from './includes';
 export * from './indexOf';
-export * from './infer';
 export * from './isComposedOf';
 export * from './isEmail';
 export * from './isIn';

package/dist/string/index.mjs

@@ -9,7 +9,6 @@ import { extractAll } from "./extractAll.mjs";
 import { first } from "./first.mjs";
 import { includes } from "./includes.mjs";
 import { indexOf } from "./indexOf.mjs";
-import { infer } from "./infer.mjs";
 import { isComposedOf } from "./isComposedOf.mjs";
 import { emailRegex, isEmail } from "./isEmail.mjs";
 import { isIn } from "./isIn.mjs";
@@ -63,7 +62,6 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	first: () => first,
 	includes: () => includes,
 	indexOf: () => indexOf,
-	infer: () => infer,
 	isComposedOf: () => isComposedOf,
 	isEmail: () => isEmail,
 	isIn: () => isIn,
@@ -107,4 +105,4 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	uuidRegex: () => uuidRegex
 });
 //#endregion
-export { at, capitalize, charAt, concat, emailRegex, endsWith, extract, extractAll, first, includes, indexOf, infer, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isTrimmed, isUrl, isUuid, join, last, lastIndexOf, length, lengthEqual, maxCharacters, minCharacters, normalize, padEnd, padStart, pop, prepend, repeat, replace, replaceAll, search, shift, slice, sort, sortCompare, split, startsWith, string_exports, stringify, substring, test, to, toLowerCase, toUpperCase, trim, trimEnd, trimStart, uncapitalize, uuidRegex };
+export { at, capitalize, charAt, concat, emailRegex, endsWith, extract, extractAll, first, includes, indexOf, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isTrimmed, isUrl, isUuid, join, last, lastIndexOf, length, lengthEqual, maxCharacters, minCharacters, normalize, padEnd, padStart, pop, prepend, repeat, replace, replaceAll, search, shift, slice, sort, sortCompare, split, startsWith, string_exports, stringify, substring, test, to, toLowerCase, toUpperCase, trim, trimEnd, trimStart, uncapitalize, uuidRegex };

package/dist/string/types/split.d.ts

@@ -2,7 +2,7 @@ import { Includes } from './includes';
 import { IsKeyPattern } from './isKeyPattern';
 import type * as DCommon from '../../common';
 import type * as DTuple from '../../tuple';
-type _Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends readonly string[] = []> = GenericString extends `${infer InferredBefore}${GenericSeparator}${infer InferredAfter}` ? IsKeyPattern<InferredBefore> extends true ? GenericLastResult : readonly [...GenericLastResult, InferredBefore] extends infer InferredResult extends readonly any[] ? DCommon.IsEqual<InferredAfter, ""> extends true ? InferredResult : DCommon.IsEqual<InferredResult["length"], 250> extends true ? Includes<InferredAfter, GenericSeparator> extends true ? readonly [...InferredResult, ...string[]] : InferredResult : DCommon.IsEqual<InferredResult["length"], GenericLimit> extends true ? InferredResult : _Split<InferredAfter, GenericSeparator, GenericLimit, InferredResult> : never : readonly [...GenericLastResult, GenericString];
+type _Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number, GenericLastResult extends readonly string[] = []> = GenericString extends `${infer InferredBefore}${GenericSeparator}${infer InferredAfter}` ? IsKeyPattern<InferredBefore> extends true ? GenericLastResult : readonly [...GenericLastResult, InferredBefore] extends infer InferredResult extends readonly any[] ? DCommon.IsEqual<InferredAfter, ""> extends true ? DCommon.IsEqual<GenericSeparator, ""> extends true ? InferredResult : readonly [...InferredResult, InferredAfter] : DCommon.IsEqual<InferredResult["length"], 250> extends true ? Includes<InferredAfter, GenericSeparator> extends true ? readonly [...InferredResult, ...string[]] : InferredResult : DCommon.IsEqual<InferredResult["length"], GenericLimit> extends true ? InferredResult : _Split<InferredAfter, GenericSeparator, GenericLimit, InferredResult> : never : readonly [...GenericLastResult, GenericString];
 export type Split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number> = DCommon.IsEqual<GenericLimit, 0> extends true ? readonly [] : IsKeyPattern<GenericSeparator> extends true ? readonly [string, ...string[]] : IsKeyPattern<GenericString> extends true ? readonly [
     ...DTuple.Create<string, DTuple.CountMinElement<_Split<GenericString, GenericSeparator, GenericLimit>>>,
     ...string[]

package/dist/tuple/from.cjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+exports.from = from;

package/dist/tuple/from.d.ts

@@ -0,0 +1,8 @@
+import { Create } from './types';
+import type * as DArray from '../array';
+type FromOutput<GenericArray extends readonly unknown[]> = DArray.ExtractLengthEqual<GenericArray, unknown> extends DArray.LengthEqual<infer InferredLength extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, Create<GenericArray[number], InferredLength>, "maxElements"> : DArray.ExtractMinElements<GenericArray, unknown> extends DArray.MinElements<infer InferredMin extends number> ? DArray.ReapplyCompatiblesConstraints<GenericArray, readonly [
+    ...Create<GenericArray[number], InferredMin>,
+    ...GenericArray[number][]
+], "maxElements"> : GenericArray;
+export declare function from<GenericArray extends readonly unknown[]>(source: GenericArray): FromOutput<GenericArray>;
+export {};

package/dist/tuple/from.mjs

@@ -0,0 +1,6 @@
+//#region scripts/tuple/from.ts
+function from(source) {
+	return source;
+}
+//#endregion
+export { from };

package/dist/tuple/index.cjs

@@ -1,8 +1,13 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_map = require("./map.cjs");
+const require_from = require("./from.cjs");
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({ map: () => require_map.map });
+var tuple_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	from: () => require_from.from,
+	map: () => require_map.map
+});
 //#endregion
+exports.from = require_from.from;
 exports.map = require_map.map;
 Object.defineProperty(exports, "tuple_exports", {
 	enumerable: true,

package/dist/tuple/index.d.ts

@@ -1,2 +1,3 @@
 export type * from './types';
 export * from './map';
+export * from './from';

package/dist/tuple/index.mjs

@@ -1,6 +1,10 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { map } from "./map.mjs";
+import { from } from "./from.mjs";
 //#region scripts/tuple/index.ts
-var tuple_exports = /* @__PURE__ */ __exportAll({ map: () => map });
+var tuple_exports = /* @__PURE__ */ __exportAll({
+	from: () => from,
+	map: () => map
+});
 //#endregion
-export { map, tuple_exports };
+export { from, map, tuple_exports };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.4",
+  "version": "0.0.1-beta.6",
   "license": "MIT",
   "type": "module",
   "author": {

package/dist/array/infer.d.ts

@@ -1,14 +0,0 @@
-import { MaxElements, MinElements, LengthEqual, ComputeMaxElementsCompatibility, ComputeMinElementsCompatibility, ComputeLengthEqualCompatibility } from './constraints';
-import type * as DCommon from '../common';
-import type * as DTuple from '../tuple';
-type ComputeCompatibilityOutputConstraint<GenericOutput extends readonly unknown[], GenericInput extends readonly unknown[]> = (DCommon.Or<[
-    DCommon.IsNever<GenericOutput>,
-    DCommon.IsNever<GenericInput>
-]> extends true ? unknown : GenericOutput extends unknown ? ((ComputeMaxElementsCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MaxElements<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxElements<${InferredResult["to"]}> because constraint MaxElements<${InferredResult["from"]}> from the value is more than.`> : never) | (ComputeMinElementsCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MinElements<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinElements<${InferredResult["to"]}> because constraint MinElements<${InferredResult["from"]}> from the value is less than.`> : never) | (ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
-export declare function infer<GenericOutput extends readonly unknown[], const GenericInput extends readonly [
-    ...Extract<DCommon.RemoveConstraint<GenericOutput>, readonly unknown[]>
-] = never, GenericConstraint = ComputeCompatibilityOutputConstraint<GenericOutput, GenericInput>>(input: (GenericInput & DTuple.Require<GenericInput> & DCommon.ForbiddenUnion<GenericInput> & DCommon.BreakGenericLink<DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>> extends true ? GenericConstraint : unknown>)): DCommon.Or<[
-    DCommon.IsNever<GenericInput>,
-    DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>>
-]> extends true ? GenericOutput : DCommon.BreakGenericLink<GenericInput & GenericConstraint>;
-export {};

package/dist/array/infer.mjs

@@ -1,6 +0,0 @@
-//#region scripts/array/infer.ts
-function infer(input) {
-	return input;
-}
-//#endregion
-export { infer };

package/dist/number/infer.cjs

@@ -1,6 +0,0 @@
-//#region scripts/number/infer.ts
-function infer(input) {
-	return input;
-}
-//#endregion
-exports.infer = infer;

package/dist/number/infer.d.ts

@@ -1,12 +0,0 @@
-import { ComputeGreaterThanCompatibility, ComputeGreaterThanOrEqualCompatibility, ComputeLessThanCompatibility, ComputeLessThanOrEqualCompatibility, GreaterThan, GreaterThanOrEqual, Integer, LessThan, LessThanOrEqual, NotZero, Safe } from './constraints';
-import { IsZero, IsInteger, RequireLiteral, IsSafe } from './types';
-import type * as DCommon from '../common';
-type ComputeOutputBranchConstraint<GenericOutput extends number, GenericInput extends number> = (DCommon.Or<[
-    DCommon.IsNever<GenericOutput>,
-    DCommon.IsNever<GenericInput>
-]> extends true ? unknown : GenericOutput extends unknown ? ((ComputeGreaterThanCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GreaterThan<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on GreaterThan<${InferredResult["to"]}> because value ${InferredResult["from"]} is less than or equal.`> : never) | (ComputeGreaterThanOrEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? GreaterThanOrEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on GreaterThanOrEqual<${InferredResult["to"]}> because value ${InferredResult["from"]} is less than.`> : never) | (ComputeLessThanCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? LessThan<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LessThan<${InferredResult["to"]}> because value ${InferredResult["from"]} is greater than or equal.`> : never) | (ComputeLessThanOrEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? LessThanOrEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LessThanOrEqual<${InferredResult["to"]}> because value ${InferredResult["from"]} is greater than.`> : never) | (DCommon.IsExtends<GenericOutput, Integer> extends true ? IsInteger<GenericInput> extends true ? Integer : DCommon.ComputedTypeError<`Impossible to cast on Integer because value ${GenericInput} is not an integer.`> : never) | (DCommon.IsExtends<GenericOutput, NotZero> extends true ? IsZero<GenericInput> extends true ? DCommon.ComputedTypeError<"Impossible to cast on NotZero because value is equal to zero."> : NotZero : never) | (DCommon.IsExtends<GenericOutput, Safe> extends true ? IsSafe<GenericInput> extends true ? Safe : DCommon.ComputedTypeError<`Impossible to cast on Safe because value ${GenericInput} is not safe.`> : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
-export declare function infer<GenericOutput extends number, const GenericInput extends Extract<DCommon.RemoveConstraint<GenericOutput>, number> = never, GenericConstraint = ComputeOutputBranchConstraint<GenericOutput, GenericInput>>(input: (GenericInput & RequireLiteral<GenericInput> & DCommon.ForbiddenUnion<GenericInput> & DCommon.BreakGenericLink<DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>> extends true ? GenericConstraint : unknown>)): DCommon.Or<[
-    DCommon.IsNever<GenericInput>,
-    DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>>
-]> extends true ? GenericOutput : DCommon.BreakGenericLink<GenericInput & GenericConstraint>;
-export {};

package/dist/number/infer.mjs

@@ -1,6 +0,0 @@
-//#region scripts/number/infer.ts
-function infer(input) {
-	return input;
-}
-//#endregion
-export { infer };

package/dist/path/fix.cjs

@@ -1,8 +0,0 @@
-//#region scripts/path/fix.ts
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(\.\/)/;
-function fix(path) {
-	return path.replace(segmentTrailingRegex, "").replace(segmentRelativeRegex, "");
-}
-//#endregion
-exports.fix = fix;

package/dist/path/fix.d.ts

@@ -1 +0,0 @@
-export declare function fix<GenericPath extends string>(path: GenericPath): string;

package/dist/path/fix.mjs

@@ -1,8 +0,0 @@
-//#region scripts/path/fix.ts
-const segmentTrailingRegex = /\/$/;
-const segmentRelativeRegex = /^(\.\/)/;
-function fix(path) {
-	return path.replace(segmentTrailingRegex, "").replace(segmentRelativeRegex, "");
-}
-//#endregion
-export { fix };

package/dist/string/infer.cjs

@@ -1,6 +0,0 @@
-//#region scripts/string/infer.ts
-function infer(input) {
-	return input;
-}
-//#endregion
-exports.infer = infer;

package/dist/string/infer.d.ts

@@ -1,12 +0,0 @@
-import { MaxCharacters, MinCharacters, LengthEqual, ComputeMaxCharactersCompatibility, ComputeMinCharactersCompatibility, ComputeLengthEqualCompatibility } from './constraints';
-import { RequireLiteral } from './types';
-import type * as DCommon from '../common';
-type ComputeCompatibilityOutputConstraint<GenericOutput extends string, GenericInput extends string> = (DCommon.Or<[
-    DCommon.IsNever<GenericOutput>,
-    DCommon.IsNever<GenericInput>
-]> extends true ? unknown : GenericOutput extends unknown ? ((ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never) | (ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never) | (ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never)) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
-export declare function infer<GenericOutput extends string, const GenericInput extends Extract<DCommon.RemoveConstraint<GenericOutput>, string> = never, GenericConstraint = ComputeCompatibilityOutputConstraint<GenericOutput, GenericInput>>(input: (GenericInput & RequireLiteral<GenericInput> & DCommon.ForbiddenUnion<GenericInput> & DCommon.BreakGenericLink<DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>> extends true ? GenericConstraint : unknown>)): DCommon.Or<[
-    DCommon.IsNever<GenericInput>,
-    DCommon.ContainExtends<GenericConstraint, DCommon.ComputedTypeError<string>>
-]> extends true ? GenericOutput : DCommon.BreakGenericLink<GenericInput & GenericConstraint>;
-export {};