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

package/dist/array/index.cjs

@@ -43,7 +43,6 @@ const require_shift = require("./shift.cjs");
 const require_unshift = require("./unshift.cjs");
 const require_insert$2 = require("./insert.cjs");
 const require_reverse = require("./reverse.cjs");
-const require_infer = require("./infer.cjs");
 const require_notIncludes = require("./notIncludes.cjs");
 const require_findLast = require("./findLast.cjs");
 const require_findLastIndex = require("./findLastIndex.cjs");
@@ -82,7 +81,6 @@ var array_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	groupOutput: () => require_group.groupOutput,
 	includes: () => require_includes.includes,
 	indexOf: () => require_indexOf.indexOf,
-	infer: () => require_infer.infer,
 	insert: () => require_insert$2.insert,
 	is: () => require_is.is,
 	isLastIndex: () => require_isLastIndex.isLastIndex,
@@ -149,7 +147,6 @@ exports.group = require_group.group;
 exports.groupOutput = require_group.groupOutput;
 exports.includes = require_includes.includes;
 exports.indexOf = require_indexOf.indexOf;
-exports.infer = require_infer.infer;
 exports.insert = require_insert$2.insert;
 exports.is = require_is.is;
 exports.isLastIndex = require_isLastIndex.isLastIndex;

package/dist/array/index.d.ts

@@ -37,7 +37,6 @@ export * from './shift';
 export * from './unshift';
 export * from './insert';
 export * from './reverse';
-export * from './infer';
 export * from './notIncludes';
 export * from './findLast';
 export * from './findLastIndex';

package/dist/array/index.mjs

@@ -43,7 +43,6 @@ import { shift } from "./shift.mjs";
 import { unshift } from "./unshift.mjs";
 import { insert } from "./insert.mjs";
 import { reverse } from "./reverse.mjs";
-import { infer } from "./infer.mjs";
 import { notIncludes } from "./notIncludes.mjs";
 import { findLast } from "./findLast.mjs";
 import { findLastIndex } from "./findLastIndex.mjs";
@@ -82,7 +81,6 @@ var array_exports = /* @__PURE__ */ __exportAll({
 	groupOutput: () => groupOutput,
 	includes: () => includes,
 	indexOf: () => indexOf,
-	infer: () => infer,
 	insert: () => insert,
 	is: () => is,
 	isLastIndex: () => isLastIndex,
@@ -116,4 +114,4 @@ var array_exports = /* @__PURE__ */ __exportAll({
 	unshift: () => unshift
 });
 //#endregion
-export { array_exports, at, chunk, coalescing, concat, copyWithin, createKind, every, fill, fillAll, filter, find, findAndReplace, findAndSpliceDelete, findAndSpliceInsert, findAndSpliceReplace, findDuplicates, findIndex, findLast, findLastIndex, first, flat, flatMap, from, group, groupOutput, includes, indexOf, infer, insert, is, isLastIndex, last, lastIndexOf, length, lengthEqual, map, maxElements, minElements, notIncludes, pop, prepend, push, reduce, reduceFrom, reduceKind, reduceRight, reduceTools, reverse, select, selectTools, set, shift, slice, some, sort, spliceDelete, spliceInsert, spliceReplace, unshift };
+export { array_exports, at, chunk, coalescing, concat, copyWithin, createKind, every, fill, fillAll, filter, find, findAndReplace, findAndSpliceDelete, findAndSpliceInsert, findAndSpliceReplace, findDuplicates, findIndex, findLast, findLastIndex, first, flat, flatMap, from, group, groupOutput, includes, indexOf, insert, is, isLastIndex, last, lastIndexOf, length, lengthEqual, map, maxElements, minElements, notIncludes, pop, prepend, push, reduce, reduceFrom, reduceKind, reduceRight, reduceTools, reverse, select, selectTools, set, shift, slice, some, sort, spliceDelete, spliceInsert, spliceReplace, unshift };

package/dist/common/constraint/cast/number.d.ts

@@ -7,4 +7,19 @@ export interface ComputeCastConstraintNumberRule<GenericValue extends number, Ge
     greaterThanOrEqual: GenericExpectedConstraint extends DNumber.GreaterThanOrEqual<number> ? DCommon.NeverCoalescing<(DNumber.ComputeGreaterThanOrEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractGreaterThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on GreaterThanOrEqual<${InferredResult["to"]}> because constraint GreaterThan<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on GreaterThanOrEqual<${InferredResult["to"]}> because constraint GreaterThanOrEqual<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on GreaterThanOrEqual because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
     lessThan: GenericExpectedConstraint extends DNumber.LessThan<number> ? DCommon.NeverCoalescing<(DNumber.ComputeLessThanCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractLessThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on LessThan<${InferredResult["to"]}> because constraint LessThan<${InferredResult["from"]}> from the value is greater than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on LessThan<${InferredResult["to"]}> because constraint LessThanOrEqual<${InferredResult["from"]}> from the value is greater than or equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LessThan because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
     lessThanOrEqual: GenericExpectedConstraint extends DNumber.LessThanOrEqual<number> ? DCommon.NeverCoalescing<(DNumber.ComputeLessThanOrEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DNumber.ExtractLessThanOrEqual<GenericValue>> extends true ? CastError<`Impossible to cast on LessThanOrEqual<${InferredResult["to"]}> because constraint LessThan<${InferredResult["from"]}> from the value is greater than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on LessThanOrEqual<${InferredResult["to"]}> because constraint LessThanOrEqual<${InferredResult["from"]}> from the value is greater than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LessThanOrEqual because value does not have compatible constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    integer: GenericExpectedConstraint extends DNumber.Integer ? DCommon.Or<[
+        DNumber.IsInteger<GenericValue>,
+        DCommon.IsExtends<GenericValue, DNumber.Integer>
+    ]> extends true ? unknown : CastError<`Impossible to cast on Integer because value ${GenericValue} is not an integer.`, GenericValue, GenericExpectedConstraint> : never;
+    notZero: GenericExpectedConstraint extends DNumber.NotZero ? DCommon.Or<[
+        DCommon.And<[
+            DCommon.Not<DNumber.IsZero<GenericValue>>,
+            DNumber.IsLiteral<GenericValue>
+        ]>,
+        DCommon.IsExtends<GenericValue, DNumber.NotZero>
+    ]> extends true ? unknown : CastError<`Impossible to cast on NotZero because value ${GenericValue} is equal to zero.`, GenericValue, GenericExpectedConstraint> : never;
+    safe: GenericExpectedConstraint extends DNumber.Safe ? DCommon.Or<[
+        DNumber.IsSafe<GenericValue>,
+        DCommon.IsExtends<GenericValue, DNumber.Safe>
+    ]> extends true ? unknown : CastError<`Impossible to cast on Safe because value ${GenericValue} is not safe.`, GenericValue, GenericExpectedConstraint> : never;
 }

package/dist/common/constraint/cast/string.d.ts

@@ -2,8 +2,21 @@ import { CastError } from './error';
 import { CompatibilityConstraintResult, BaseConstraint } from '../types';
 import type * as DString from '../../../string';
 import type * as DCommon from '../..';
+import type * as DPath from '../../../path';
 export interface ComputeCastConstraintStringRule<GenericValue extends string, GenericExpectedConstraint extends BaseConstraint> {
     maxCharacters: GenericExpectedConstraint extends DString.MaxCharacters<number> ? DCommon.NeverCoalescing<(DString.ComputeMaxCharactersCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DString.ExtractLengthEqual<GenericValue>> extends true ? CastError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is more than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on MaxCharacters because value does not have MaxCharacters constraint.", GenericValue, GenericExpectedConstraint>> : never;
     minCharacters: GenericExpectedConstraint extends DString.MinCharacters<number> ? DCommon.NeverCoalescing<(DString.ComputeMinCharactersCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : DCommon.IsNever<DString.ExtractLengthEqual<GenericValue>> extends true ? CastError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : CastError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is less than.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on MinCharacters because value does not have MinCharacters constraint.", GenericValue, GenericExpectedConstraint>> : never;
     lengthEqual: GenericExpectedConstraint extends DString.LengthEqual<number> ? DCommon.NeverCoalescing<(DString.ComputeLengthEqualCompatibility<GenericValue, GenericExpectedConstraint, unknown> extends infer InferredResult extends CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends CompatibilityConstraintResult<true> ? unknown : CastError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`, GenericValue, GenericExpectedConstraint> : never), CastError<"Impossible to cast on LengthEqual because value does not have LengthEqual constraint.", GenericValue, GenericExpectedConstraint>> : never;
+    path: DCommon.IsExtends<GenericExpectedConstraint, DPath.Path> extends true ? DCommon.Or<[
+        DPath.IsLiteralPath<GenericValue>,
+        DCommon.IsExtends<GenericValue, DPath.Path | DPath.Absolute | DPath.Segment>
+    ]> extends true ? unknown : CastError<`Impossible to cast on Path because value ${GenericValue} is not path.`, GenericValue, GenericExpectedConstraint> : never;
+    absolutePath: DCommon.IsExtends<GenericExpectedConstraint, DPath.Absolute> extends true ? DCommon.Or<[
+        DPath.IsLiteralAbsolutePath<GenericValue>,
+        DCommon.IsExtends<GenericValue, DPath.Absolute>
+    ]> extends true ? unknown : CastError<`Impossible to cast on AbsolutePath because value ${GenericValue} is not absolute path.`, GenericValue, GenericExpectedConstraint> : never;
+    segment: DCommon.IsExtends<GenericExpectedConstraint, DPath.Segment> extends true ? DCommon.Or<[
+        DPath.IsLiteralSegmentPath<GenericValue>,
+        DCommon.IsExtends<GenericValue, DPath.Segment>
+    ]> extends true ? unknown : CastError<`Impossible to cast on SegmentPath because value ${GenericValue} is not segment path.`, GenericValue, GenericExpectedConstraint> : never;
 }

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

@@ -1,3 +1,4 @@
 export * from './cast';
+export * from './infer';
 export * from './remove';
 export * from './types';

package/dist/common/constraint/infer/array.d.ts

@@ -0,0 +1,7 @@
+import type * as DArray from '../../../array';
+import type * as DCommon from '../..';
+export interface ComputeInferConstraintArrayRule<GenericInput extends readonly unknown[], GenericOutput extends unknown> {
+    maxElements: DArray.ComputeMaxElementsCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DArray.MaxElements<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxElements<${InferredResult["to"]}> because constraint MaxElements<${InferredResult["from"]}> from the value is more than.`> : never;
+    minElements: DArray.ComputeMinElementsCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DArray.MinElements<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinElements<${InferredResult["to"]}> because constraint MinElements<${InferredResult["from"]}> from the value is less than.`> : never;
+    lengthEqual: DArray.ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DArray.LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never;
+}

package/dist/{array/infer.cjs → common/constraint/infer/index.cjs}

@@ -1,4 +1,4 @@
-//#region scripts/array/infer.ts
+//#region scripts/common/constraint/infer/index.ts
 function infer(input) {
 	return input;
 }

package/dist/common/constraint/infer/index.d.ts

@@ -0,0 +1,26 @@
+import { ComputeInferConstraintArrayRule } from './array';
+import { ComputeInferConstraintNumberRule } from './number';
+import { ComputeInferConstraintStringRule } from './string';
+import type * as DCommon from '../..';
+import type * as DNumber from '../../../number';
+import type * as DObject from '../../../object';
+import type * as DString from '../../../string';
+import type * as DTuple from '../../../tuple';
+export type * from './array';
+export type * from './number';
+export type * from './string';
+export interface ComputeInferConstraintRule<GenericInput extends unknown, GenericOutput extends unknown> {
+    string: GenericInput extends string ? DObject.Values<ComputeInferConstraintStringRule<GenericInput, GenericOutput>> : never;
+    number: GenericInput extends number ? DObject.Values<ComputeInferConstraintNumberRule<GenericInput, GenericOutput>> : never;
+    array: GenericInput extends readonly unknown[] ? DObject.Values<ComputeInferConstraintArrayRule<GenericInput, GenericOutput>> : never;
+}
+export type ComputeInferConstraint<GenericInput extends unknown, GenericOutput extends unknown> = DCommon.Or<[
+    DCommon.IsNever<GenericInput>,
+    DCommon.IsNever<GenericOutput>
+]> extends true ? unknown : (GenericInput extends unknown ? (GenericOutput extends unknown ? DObject.Values<ComputeInferConstraintRule<GenericInput, GenericOutput>> extends infer InferredResult ? DCommon.ContainExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? Extract<InferredResult, DCommon.ComputedTypeError<string>> : GenericInput & DCommon.UnionToIntersection<InferredResult> : never : never) extends infer InferredResult ? DCommon.IsExtends<InferredResult, DCommon.ComputedTypeError<string>> extends true ? InferredResult : Extract<InferredResult, DCommon.BaseConstraint> : never : never) extends infer InferredResult ? DCommon.IsExtends<InferredResult, DCommon.BaseConstraint> extends true ? Extract<InferredResult, DCommon.BaseConstraint> : InferredResult : never;
+export type SupportedOutputInfer = (string | readonly unknown[] | number);
+type ComputeInferInputRequirement<GenericInput extends unknown> = GenericInput extends string ? DString.RequireLiteral<GenericInput> : GenericInput extends number ? DNumber.RequireLiteral<GenericInput> : GenericInput extends readonly unknown[] ? DTuple.Require<GenericInput> : never;
+export declare function infer<GenericOutput extends SupportedOutputInfer, const GenericInput extends DCommon.RemoveConstraint<GenericOutput> = never, GenericComputedOutput = ComputeInferConstraint<GenericInput, GenericOutput>>(input: (GenericInput & ComputeInferInputRequirement<GenericInput> & DCommon.BreakGenericLink<DCommon.NeverCoalescing<GenericComputedOutput extends DCommon.ComputedTypeError<string> ? GenericComputedOutput : never, unknown>>)): DCommon.Or<[
+    DCommon.IsNever<GenericInput>,
+    DCommon.ContainExtends<GenericComputedOutput, DCommon.ComputedTypeError<string>>
+]> extends true ? GenericOutput : DCommon.BreakGenericLink<DCommon.NeverCoalescing<GenericComputedOutput, GenericInput>>;

package/dist/{string/infer.mjs → common/constraint/infer/index.mjs}

@@ -1,4 +1,4 @@
-//#region scripts/string/infer.ts
+//#region scripts/common/constraint/infer/index.ts
 function infer(input) {
 	return input;
 }

package/dist/common/constraint/infer/number.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from '../..';
+import type * as DNumber from '../../../number';
+export interface ComputeInferConstraintNumberRule<GenericInput extends number, GenericOutput extends unknown> {
+    greaterThan: DNumber.ComputeGreaterThanCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DNumber.GreaterThan<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on GreaterThan<${InferredResult["to"]}> because value ${InferredResult["from"]} is less than or equal.`> : never;
+    greaterThanOrEqual: DNumber.ComputeGreaterThanOrEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DNumber.GreaterThanOrEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on GreaterThanOrEqual<${InferredResult["to"]}> because value ${InferredResult["from"]} is less than.`> : never;
+    lessThan: DNumber.ComputeLessThanCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DNumber.LessThan<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LessThan<${InferredResult["to"]}> because value ${InferredResult["from"]} is greater than or equal.`> : never;
+    lessThanOrEqual: DNumber.ComputeLessThanOrEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DNumber.LessThanOrEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LessThanOrEqual<${InferredResult["to"]}> because value ${InferredResult["from"]} is greater than.`> : never;
+    integer: DCommon.IsExtends<GenericOutput, DNumber.Integer> extends true ? DNumber.IsInteger<GenericInput> extends true ? DNumber.Integer : DCommon.ComputedTypeError<`Impossible to cast on Integer because value ${GenericInput} is not an integer.`> : never;
+    notZero: DCommon.IsExtends<GenericOutput, DNumber.NotZero> extends true ? DNumber.IsZero<GenericInput> extends true ? DCommon.ComputedTypeError<`Impossible to cast on NotZero because value ${GenericInput} is equal to zero.`> : DNumber.NotZero : never;
+    safe: DCommon.IsExtends<GenericOutput, DNumber.Safe> extends true ? DNumber.IsSafe<GenericInput> extends true ? DNumber.Safe : DCommon.ComputedTypeError<`Impossible to cast on Safe because value ${GenericInput} is not safe.`> : never;
+}

package/dist/common/constraint/infer/string.d.ts

@@ -0,0 +1,11 @@
+import type * as DCommon from '../..';
+import type * as DString from '../../../string';
+import type * as DPath from '../../../path';
+export interface ComputeInferConstraintStringRule<GenericInput extends string, GenericOutput extends unknown> {
+    maxCharacters: DString.ComputeMaxCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MaxCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MaxCharacters<${InferredResult["to"]}> because constraint MaxCharacters<${InferredResult["from"]}> from the value is more than.`> : never;
+    minCharacters: DString.ComputeMinCharactersCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.MinCharacters<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on MinCharacters<${InferredResult["to"]}> because constraint MinCharacters<${InferredResult["from"]}> from the value is less than.`> : never;
+    lengthEqual: DString.ComputeLengthEqualCompatibility<GenericInput, GenericOutput, unknown> extends infer InferredResult extends DCommon.CompatibilityConstraintResult<boolean, number, number> ? InferredResult extends DCommon.CompatibilityConstraintResult<true> ? DString.LengthEqual<InferredResult["to"]> : DCommon.ComputedTypeError<`Impossible to cast on LengthEqual<${InferredResult["to"]}> because constraint LengthEqual<${InferredResult["from"]}> from the value is not equal.`> : never;
+    path: DCommon.IsExtends<GenericOutput, DPath.Path> extends true ? DPath.IsLiteralPath<GenericInput> extends true ? DPath.Path : DCommon.ComputedTypeError<`Impossible to cast on Path because value ${GenericInput} is not path.`> : never;
+    absolutePath: DCommon.IsExtends<GenericOutput, DPath.Absolute> extends true ? DPath.IsLiteralAbsolutePath<GenericInput> extends true ? DPath.Absolute : DCommon.ComputedTypeError<`Impossible to cast on AbsolutePath because value ${GenericInput} is not absolute path.`> : never;
+    segment: DCommon.IsExtends<GenericOutput, DPath.Segment> extends true ? DPath.IsLiteralSegmentPath<GenericInput> extends true ? DPath.Segment : DCommon.ComputedTypeError<`Impossible to cast on SegmentPath because value ${GenericInput} is not segment path.`> : never;
+}

package/dist/common/index.cjs

@@ -13,6 +13,7 @@ const require_builder = require("./builder.cjs");
 const require_callThen = require("./callThen.cjs");
 const require_clone = require("./clone.cjs");
 const require_index = require("./constraint/cast/index.cjs");
+const require_index$1 = require("./constraint/infer/index.cjs");
 const require_remove = require("./constraint/remove.cjs");
 const require_detachObjectMethod = require("./detachObjectMethod.cjs");
 const require_enum = require("./enum.cjs");
@@ -87,6 +88,7 @@ var common_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	forward: () => require_forward.forward,
 	forwardAsserts: () => require_forwardAsserts.forwardAsserts,
 	forwardLog: () => require_forwardLog.forwardLog,
+	infer: () => require_index$1.infer,
 	innerPipe: () => require_innerPipe.innerPipe,
 	instanceOf: () => require_instanceOf.instanceOf,
 	isType: () => require_isType.isType,
@@ -161,6 +163,7 @@ exports.falsy = require_falsy.falsy;
 exports.forward = require_forward.forward;
 exports.forwardAsserts = require_forwardAsserts.forwardAsserts;
 exports.forwardLog = require_forwardLog.forwardLog;
+exports.infer = require_index$1.infer;
 exports.innerPipe = require_innerPipe.innerPipe;
 exports.instanceOf = require_instanceOf.instanceOf;
 exports.isType = require_isType.isType;

package/dist/common/index.mjs

@@ -13,6 +13,7 @@ import { MissingBuilderMethodsError, builderKind, createBuilder } from "./builde
 import { callThen } from "./callThen.mjs";
 import { clone } from "./clone.mjs";
 import { cast, shameOnYou } from "./constraint/cast/index.mjs";
+import { infer } from "./constraint/infer/index.mjs";
 import { removeConstraint } from "./constraint/remove.mjs";
 import { detachObjectMethod } from "./detachObjectMethod.mjs";
 import { createEnum } from "./enum.mjs";
@@ -87,6 +88,7 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	forward: () => forward,
 	forwardAsserts: () => forwardAsserts,
 	forwardLog: () => forwardLog,
+	infer: () => infer,
 	innerPipe: () => innerPipe,
 	instanceOf: () => instanceOf,
 	isType: () => isType,
@@ -123,4 +125,4 @@ var common_exports = /* @__PURE__ */ __exportAll({
 	whenNot: () => whenNot
 });
 //#endregion
-export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };
+export { AssertsError, InvalidBytesInStringError, InvalidMillisecondInStringError, MissingBuilderMethodsError, TheFormData, and, asserts, asyncInnerPipe, asyncLoop, asyncPipe, bindPrototypeMethods, builderKind, callThen, cast, clone, common_exports, createAsyncRetry, createBuilder, createEnum, createExternalPromise, createFormData, createGlobalStore, createInterpolation, createKind, createQueue, createTransformer, detachObjectMethod, equal, escapeRegExp, falsy, forward, forwardAsserts, forwardLog, infer, innerPipe, instanceOf, isType, justExec, justReturn, loop, memo, memoObject, memoPromise, mimeType, or, pipe, pipeCall, prepareAsyncPipe, preparePipe, promiseAll, promiseObject, queueKind, removeConstraint, shameOnYou, simpleClone, stringToBytes, stringToMillisecond, timeout, toCurriedPredicate, toJSON, toNative, toRegExp, transformer, truthy, useAsyncRetry, when, whenElse, whenNot };

package/dist/dataStructure/constraint/defaults/absolutePath.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_isAbsolute = require("../../../path/isAbsolute.cjs");
+//#region scripts/dataStructure/constraint/defaults/absolutePath.ts
+const absolutePathConstraintKind = require_kind.createKind("absolute-path-constraint");
+const AbsolutePathConstraint = require_base.createConstraint(absolutePathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isAbsolute.isAbsolute(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.AbsolutePathConstraint = AbsolutePathConstraint;
+exports.absolutePathConstraintKind = absolutePathConstraintKind;

package/dist/dataStructure/constraint/defaults/absolutePath.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const absolutePathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/absolute-path-constraint", unknown>>;
+export interface AbsolutePathConstraintDefinition extends ConstraintDefinition {
+}
+export interface AbsolutePathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Absolute, AbsolutePathConstraintDefinition> & DKind.Kind<typeof absolutePathConstraintKind>> {
+}
+export declare const AbsolutePathConstraint: () => AbsolutePathConstraint;

package/dist/dataStructure/constraint/defaults/absolutePath.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { isAbsolute } from "../../../path/isAbsolute.mjs";
+//#region scripts/dataStructure/constraint/defaults/absolutePath.ts
+const absolutePathConstraintKind = createKind("absolute-path-constraint");
+const AbsolutePathConstraint = createConstraint(absolutePathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isAbsolute(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { AbsolutePathConstraint, absolutePathConstraintKind };

package/dist/dataStructure/constraint/defaults/index.d.ts

@@ -1,3 +1,4 @@
+export * from './absolutePath';
 export * from './allowedCharacters';
 export * from './arrayLengthEqual';
 export * from './betweenThan';
@@ -18,9 +19,11 @@ export * from './negative';
 export * from './notEmpty';
 export * from './notZero';
 export * from './odd';
+export * from './path';
 export * from './positive';
 export * from './refine';
 export * from './safe';
+export * from './segmentPath';
 export * from './strictNegative';
 export * from './strictPositive';
 export * from './stringLengthEqual';

package/dist/dataStructure/constraint/defaults/path.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_is = require("../../../path/is.cjs");
+//#region scripts/dataStructure/constraint/defaults/path.ts
+const pathConstraintKind = require_kind.createKind("path-constraint");
+const PathConstraint = require_base.createConstraint(pathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_is.is(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.PathConstraint = PathConstraint;
+exports.pathConstraintKind = pathConstraintKind;

package/dist/dataStructure/constraint/defaults/path.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const pathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/path-constraint", unknown>>;
+export interface PathConstraintDefinition extends ConstraintDefinition {
+}
+export interface PathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Path, PathConstraintDefinition> & DKind.Kind<typeof pathConstraintKind>> {
+}
+export declare const PathConstraint: () => PathConstraint;

package/dist/dataStructure/constraint/defaults/path.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { is } from "../../../path/is.mjs";
+//#region scripts/dataStructure/constraint/defaults/path.ts
+const pathConstraintKind = createKind("path-constraint");
+const PathConstraint = createConstraint(pathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => is(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { PathConstraint, pathConstraintKind };

package/dist/dataStructure/constraint/defaults/segmentPath.cjs

@@ -0,0 +1,13 @@
+const require_kind = require("../../kind.cjs");
+const require_resultSymbol = require("../../common/resultSymbol.cjs");
+const require_base = require("../base.cjs");
+const require_isSegment = require("../../../path/isSegment.cjs");
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = require_kind.createKind("segment-path-constraint");
+const SegmentPathConstraint = require_base.createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => require_isSegment.isSegment(data) ? require_resultSymbol.SuccessSymbol : require_resultSymbol.ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+exports.SegmentPathConstraint = SegmentPathConstraint;
+exports.segmentPathConstraintKind = segmentPathConstraintKind;

package/dist/dataStructure/constraint/defaults/segmentPath.d.ts

@@ -0,0 +1,10 @@
+import { ConstraintDefinition, Constraint } from '../base';
+import type * as DCommon from '../../../common';
+import type * as DKind from '../../../kind';
+import * as DPath from '../../../path';
+export declare const segmentPathConstraintKind: DKind.Handler<DKind.Definition<"@DuplojsLangDataStructure/segment-path-constraint", unknown>>;
+export interface SegmentPathConstraintDefinition extends ConstraintDefinition {
+}
+export interface SegmentPathConstraint extends DCommon.Forward<Constraint<string, string & DPath.Segment, SegmentPathConstraintDefinition> & DKind.Kind<typeof segmentPathConstraintKind>> {
+}
+export declare const SegmentPathConstraint: () => SegmentPathConstraint;

package/dist/dataStructure/constraint/defaults/segmentPath.mjs

@@ -0,0 +1,12 @@
+import { createKind } from "../../kind.mjs";
+import { ErrorSymbol, SuccessSymbol } from "../../common/resultSymbol.mjs";
+import { createConstraint } from "../base.mjs";
+import { isSegment } from "../../../path/isSegment.mjs";
+//#region scripts/dataStructure/constraint/defaults/segmentPath.ts
+const segmentPathConstraintKind = createKind("segment-path-constraint");
+const SegmentPathConstraint = createConstraint(segmentPathConstraintKind, ({ init }) => () => init({}, {
+	executeCheck: (_self, data) => isSegment(data) ? SuccessSymbol : ErrorSymbol,
+	isAsynchronous: () => false
+}));
+//#endregion
+export { SegmentPathConstraint, segmentPathConstraintKind };

package/dist/dataStructure/constraint/types/constraints.d.ts

@@ -30,6 +30,9 @@ export interface ConstraintsStore {
     greaterThanOrEqual: DDefaults.GreaterThanOrEqualConstraint;
     lessThan: DDefaults.LessThanConstraint;
     lessThanOrEqual: DDefaults.LessThanOrEqualConstraint;
+    absolutePath: DDefaults.AbsolutePathConstraint;
+    path: DDefaults.PathConstraint;
+    segmentPath: DDefaults.SegmentPathConstraint;
     refine: DDefaults.RefineConstraint;
 }
 export type Constraints = Extract<ConstraintsStore[keyof ConstraintsStore], Constraint>;

package/dist/dataStructure/helpers/absolutePath.cjs

@@ -0,0 +1,7 @@
+const require_absolutePath = require("../constraint/defaults/absolutePath.cjs");
+//#region scripts/dataStructure/helpers/absolutePath.ts
+function absolutePath() {
+	return require_absolutePath.AbsolutePathConstraint();
+}
+//#endregion
+exports.absolutePath = absolutePath;

package/dist/dataStructure/helpers/absolutePath.d.ts

@@ -0,0 +1,2 @@
+import { AbsolutePathConstraint } from '../constraint';
+export declare function absolutePath(): AbsolutePathConstraint;

package/dist/dataStructure/helpers/absolutePath.mjs

@@ -0,0 +1,7 @@
+import { AbsolutePathConstraint } from "../constraint/defaults/absolutePath.mjs";
+//#region scripts/dataStructure/helpers/absolutePath.ts
+function absolutePath() {
+	return AbsolutePathConstraint();
+}
+//#endregion
+export { absolutePath };

package/dist/dataStructure/helpers/index.d.ts

@@ -1,3 +1,4 @@
+export * from './absolutePath';
 export * from './allowedCharacters';
 export * from './array';
 export * from './arrayLengthEqual';
@@ -33,11 +34,13 @@ export * from './object';
 export * from './odd';
 export * from './optional';
 export * from './partial';
+export * from './path';
 export * from './positive';
 export * from './record';
 export * from './refine';
 export * from './required';
 export * from './safe';
+export * from './segmentPath';
 export * from './string';
 export * from './strictNegative';
 export * from './strictPositive';

package/dist/dataStructure/helpers/path.cjs

@@ -0,0 +1,7 @@
+const require_path = require("../constraint/defaults/path.cjs");
+//#region scripts/dataStructure/helpers/path.ts
+function path() {
+	return require_path.PathConstraint();
+}
+//#endregion
+exports.path = path;

package/dist/dataStructure/helpers/path.d.ts

@@ -0,0 +1,2 @@
+import { PathConstraint } from '../constraint';
+export declare function path(): PathConstraint;

package/dist/dataStructure/helpers/path.mjs

@@ -0,0 +1,7 @@
+import { PathConstraint } from "../constraint/defaults/path.mjs";
+//#region scripts/dataStructure/helpers/path.ts
+function path() {
+	return PathConstraint();
+}
+//#endregion
+export { path };

package/dist/dataStructure/helpers/segmentPath.cjs

@@ -0,0 +1,7 @@
+const require_segmentPath = require("../constraint/defaults/segmentPath.cjs");
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return require_segmentPath.SegmentPathConstraint();
+}
+//#endregion
+exports.segmentPath = segmentPath;

package/dist/dataStructure/helpers/segmentPath.d.ts

@@ -0,0 +1,2 @@
+import { SegmentPathConstraint } from '../constraint';
+export declare function segmentPath(): SegmentPathConstraint;

package/dist/dataStructure/helpers/segmentPath.mjs

@@ -0,0 +1,7 @@
+import { SegmentPathConstraint } from "../constraint/defaults/segmentPath.mjs";
+//#region scripts/dataStructure/helpers/segmentPath.ts
+function segmentPath() {
+	return SegmentPathConstraint();
+}
+//#endregion
+export { segmentPath };