@duplojs/lang 0.0.1-beta.8 → 0.1.0-beta.1

package/dist/pattern/matchWithNumberOtherwise.d.ts

@@ -1,11 +1,11 @@
 import type * as DCommon from '../common';
 import type * as DNumber from '../number/types';
 import type * as DObject from '../object';
-type ComputeMatcher<GenericInput extends number> = {
+type ComputeMatcher<GenericInput extends number> = DCommon.SimplifyType<{
     [Prop in GenericInput]?: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>> = Exclude<keyof GenericMatcher, GenericInput> extends infer InferredKey ? DCommon.IsEqual<InferredKey, never> extends true ? unknown : DCommon.ComputedTypeError<`Key "${Extract<InferredKey, number>}" is forbidden.`> : never;
 type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, number>;
-export declare function matchWithNumberOtherwise<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
-export declare function matchWithNumberOtherwise<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithNumberOtherwise<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<Exclude<GenericInput, HandledKeys<GenericMatcher>>>) => GenericOutput): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>) => (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithNumberOtherwise<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<Exclude<GenericInput, HandledKeys<GenericMatcher>>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 export {};

package/dist/pattern/matchWithString.d.ts

@@ -1,10 +1,10 @@
 import type * as DCommon from '../common';
 import type * as DObject from '../object';
 import type * as DString from '../string/types';
-type ComputeMatcher<GenericInput extends string> = {
+type ComputeMatcher<GenericInput extends string> = DCommon.SimplifyType<{
     [Prop in GenericInput]: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GenericInput>, string>>;
-export declare function matchWithString<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>): (input: GenericInput & DString.RequireSimpleLiteral<GenericInput>) => ReturnType<NoInfer<GenericMatcher>[keyof GenericMatcher]>;
-export declare function matchWithString<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>>(input: GenericInput & DString.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>): ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithString<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): (input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>) => ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithString<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): ReturnType<GenericMatcher[keyof GenericMatcher]>;
 export {};

package/dist/pattern/matchWithStringOtherwise.d.ts

@@ -1,11 +1,11 @@
 import type * as DCommon from '../common';
 import type * as DObject from '../object';
 import type * as DString from '../string';
-type ComputeMatcher<GenericInput extends string> = {
+type ComputeMatcher<GenericInput extends string> = DCommon.SimplifyType<{
     [Prop in GenericInput]?: (value: Prop) => unknown;
-};
+}>;
 type ForbiddenMoreKey<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, GenericInput>, string>>;
 type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
-export declare function matchWithStringOtherwise<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (input: GenericInput & DString.RequireSimpleLiteral<GenericInput>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
-export declare function matchWithStringOtherwise<GenericInput extends string, GenericMatcher extends ComputeMatcher<GenericInput>, GenericOutput>(input: GenericInput & DString.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>, otherwise: (value: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithStringOtherwise<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<Exclude<GenericInput, HandledKeys<GenericMatcher>>>) => GenericOutput): (input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>) => (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithStringOtherwise<GenericInput extends string, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, string>, GenericMatcher extends ComputeMatcher<GenericClearInput>, GenericOutput extends unknown>(input: GenericInput & DString.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<Exclude<GenericInput, HandledKeys<GenericMatcher>>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 export {};

package/dist/pattern/matchWithTaggedObjectOtherwise.d.ts

@@ -9,6 +9,6 @@ type ForbiddenMoreKey<GenericTaggedObject extends DModeling.ObjectTag, GenericMa
 type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
 type UnhandledTaggedObject<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends object> = Exclude<GenericTaggedObject, DModeling.ObjectTag<HandledKeys<GenericMatcher>>>;
 type RequireLiteralTag<GenericTaggedObject extends DModeling.ObjectTag> = DString.RequireSimpleLiteral<DModeling.GetTagValue<GenericTaggedObject>>;
-export declare function matchWithTaggedObjectOtherwise<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericTaggedObject>, GenericMatcher>), otherwise: (value: UnhandledTaggedObject<GenericTaggedObject, GenericMatcher>) => GenericOutput): (input: GenericTaggedObject & RequireLiteralTag<GenericTaggedObject>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
-export declare function matchWithTaggedObjectOtherwise<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>, GenericOutput>(input: GenericTaggedObject & RequireLiteralTag<GenericTaggedObject>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<GenericTaggedObject, GenericMatcher>), otherwise: (value: UnhandledTaggedObject<GenericTaggedObject, GenericMatcher>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithTaggedObjectOtherwise<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericTaggedObject>, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<UnhandledTaggedObject<GenericTaggedObject, GenericMatcher>>) => GenericOutput): (input: GenericTaggedObject & RequireLiteralTag<GenericTaggedObject>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithTaggedObjectOtherwise<GenericTaggedObject extends DModeling.ObjectTag, GenericMatcher extends ComputeMatcher<GenericTaggedObject>, GenericOutput>(input: GenericTaggedObject & RequireLiteralTag<GenericTaggedObject>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericTaggedObject>, GenericMatcher> & ForbiddenMoreKey<GenericTaggedObject, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<UnhandledTaggedObject<GenericTaggedObject, GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 export {};

package/dist/pattern/types/complexUnMatchedValue/getIncompleteUnion.d.ts

@@ -19,7 +19,7 @@ export type GetIncompleteUnion<GenericInput extends unknown, GenericPatternValue
         [SubProp in Prop]: any;
     }>[Prop]>;
 }> : DCommon.IsEqual<InferredInput, never> extends true ? {} : {
-    "@duplojs/utils/{object}": true;
+    "@duplojs/lang/{object}": true;
 } : never) | ([
     DTuple.Unmatched<Extract<GenericInput, DCommon.AnyTuple>, Extract<GenericPatternValue, readonly any[]>>,
     Extract<GenericPatternValue, DCommon.AnyTuple | readonly []>
@@ -33,10 +33,10 @@ export type GetIncompleteUnion<GenericInput extends unknown, GenericPatternValue
     readonly [infer InferredInputFirst, ...infer InferredInputRest],
     readonly [infer InferredPatternValueFirst, ...infer InferredPatternValueRest]
 ] ? GetIncompleteUnion<InferredInputFirst, InferredPatternValueFirst> extends infer InferredResultFirst ? DObject.FlatObject<{
-    "@duplojs/utils/[tuple.first": InferredResultFirst;
-    "@duplojs/utils/tuple.rest]": GetIncompleteUnion<InferredInputRest, InferredPatternValueRest>;
+    "@duplojs/lang/[tuple.first": InferredResultFirst;
+    "@duplojs/lang/tuple.rest]": GetIncompleteUnion<InferredInputRest, InferredPatternValueRest>;
 }> : never : never : DCommon.IsEqual<InferredInput, never> extends true ? {} : {
-    "@duplojs/utils/[tuple]": true;
+    "@duplojs/lang/[tuple]": true;
 } : never) | ([
     Exclude<Extract<GenericInput, readonly any[]>, DCommon.AnyTuple>,
     Extract<GenericPatternValue, DCommon.AnyTuple>
@@ -50,8 +50,8 @@ export type GetIncompleteUnion<GenericInput extends unknown, GenericPatternValue
     infer InferredPatternValueFirst,
     ...infer InferredPatternValueRest
 ] ? GetIncompleteUnion<InferredInput[number], InferredPatternValueFirst> extends infer InferredResultFirst ? DObject.FlatObject<{
-    "@duplojs/utils/[array.first": InferredResultFirst;
-    "@duplojs/utils/array.rest]": DCommon.IsEqual<InferredResultFirst, {}> extends true ? GetIncompleteUnion<InferredInput, InferredPatternValueRest> : never;
+    "@duplojs/lang/[array.first": InferredResultFirst;
+    "@duplojs/lang/array.rest]": DCommon.IsEqual<InferredResultFirst, {}> extends true ? GetIncompleteUnion<InferredInput, InferredPatternValueRest> : never;
 }> : {} : {} : never) | ([
     Exclude<Extract<GenericInput, readonly any[]>, DCommon.AnyTuple>,
     Exclude<Extract<GenericPatternValue, readonly any[]>, DCommon.AnyTuple>
@@ -62,9 +62,9 @@ export type GetIncompleteUnion<GenericInput extends unknown, GenericPatternValue
     DCommon.IsEqual<InferredPatternValue, never>,
     DCommon.IsEqual<InferredInput, never>
 ]> extends true ? never : DCommon.IsEqual<Exclude<InferredInput[number], InferredPatternValue[number]>, never> extends true ? {} : {
-    "@duplojs/utils/[array]": true;
+    "@duplojs/lang/[array]": true;
 } : never) | (Extract<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? DCommon.IsEqual<InferredPatternValue, never> extends true ? never : {
-    "@duplojs/utils/{maybeAll}": true;
+    "@duplojs/lang/{maybeAll}": true;
 } : never) | ([
     Extract<GenericInput, readonly any[]>,
     Extract<GenericPatternValue, readonly []>

package/dist/string/capitalize.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
 import type * as DCommon from '../common';
 type CapitalizeOutput<GenericString extends string> = GenericString extends unknown ? ReapplyCompatiblesConstraints<GenericString, Capitalize<Extract<DCommon.RemoveConstraint<GenericString>, string>>, "minCharacters" | "lengthEqual"> : never;
-export declare function capitalize<GenericString extends string, GenericOutput = CapitalizeOutput<GenericString>>(string: GenericString): DCommon.BreakGenericLink<GenericOutput>;
+export declare function capitalize<GenericString extends string>(string: GenericString): CapitalizeOutput<GenericString>;
 export {};

package/dist/string/concat.d.ts

@@ -9,6 +9,6 @@ type RemoveStringConstraints<GenericStrings extends readonly string[]> = Generic
     ...RemoveStringConstraints<InferredRest>
 ] : string[];
 type ConcatOutput<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[] = []> = ReapplyCompatiblesConstraints<GenericString, `${Extract<DCommon.RemoveConstraint<GenericString>, string>}${Extract<DCommon.RemoveConstraint<GenericElement>, string>}${Join<RemoveStringConstraints<GenericElementsRest>>}`, "minCharacters">;
-export declare function concat<GenericString extends string, GenericElement extends string, GenericOutput = ConcatOutput<GenericString, GenericElement>>(element: GenericElement): (string: GenericString) => DCommon.BreakGenericLink<GenericOutput>;
-export declare function concat<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[], GenericOutput = ConcatOutput<GenericString, GenericElement, GenericElementsRest>>(string: GenericString, element: GenericElement, ...elementsRest: GenericElementsRest): DCommon.BreakGenericLink<GenericOutput>;
+export declare function concat<GenericString extends string, GenericElement extends string>(element: GenericElement): (string: GenericString) => DCommon.BreakGenericLink<ConcatOutput<GenericString, GenericElement>>;
+export declare function concat<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[]>(string: GenericString, element: GenericElement, ...elementsRest: GenericElementsRest): DCommon.BreakGenericLink<ConcatOutput<GenericString, GenericElement, GenericElementsRest>>;
 export {};

package/dist/string/constraints/allowedCharacters.d.ts

@@ -2,8 +2,8 @@ import type * as DCommon from '../../common';
 import type * as DObject from '../../object';
 export interface CharactersRangeStore {
 }
-export type CharactersRange = Extract<DObject.GetPropsWithValue<CharactersRangeStore, true>, string>;
+export type CharactersRange = Extract<DObject.GetPropsWithValueExtends<CharactersRangeStore, string>, string>;
 export type AllowedCharactersConstraintName = "string-allowed-characters";
-export interface AllowedCharacters<GenericCharactersRange extends CharactersRange = never> extends DCommon.Constraint<AllowedCharactersConstraintName, Record<GenericCharactersRange, unknown>> {
+export interface AllowedCharacters<GenericCharactersRange extends CharactersRange = never> extends DCommon.Constraint<AllowedCharactersConstraintName, () => Partial<Record<GenericCharactersRange, GenericCharactersRange>>> {
 }
-export type ExtractAllowedCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends AllowedCharacters ? (keyof GenericConstraint[DCommon.ConstraintSymbol][AllowedCharactersConstraintName]) extends infer InferredResult extends CharactersRange ? DCommon.UnionToIntersection<InferredResult extends any ? AllowedCharacters<InferredResult> : never> : GenericDefault : GenericDefault;
+export type ExtractAllowedCharacters<GenericConstraint extends unknown, GenericDefault extends unknown = never> = GenericConstraint extends AllowedCharacters ? (keyof ReturnType<GenericConstraint[DCommon.ConstraintSymbol][AllowedCharactersConstraintName]>) extends infer InferredResult extends CharactersRange ? DCommon.UnionToIntersection<InferredResult extends any ? DCommon.IsNever<InferredResult> extends true ? AllowedCharacters : AllowedCharacters<InferredResult> : never> : GenericDefault : GenericDefault;

package/dist/string/isComposedOf.cjs

@@ -3,7 +3,6 @@ const require_coalescing = require("../array/coalescing.cjs");
 const charactersRangeStore = /* @__PURE__ */ new Map([
 	["a-z", "a-z"],
 	["A-Z", "A-Z"],
-	["A-z", "A-z"],
 	["0-9", "0-9"]
 ]);
 function isComposedOf(...args) {

package/dist/string/isComposedOf.d.ts

@@ -2,13 +2,10 @@ import { AllowedCharacters, CharactersRange } from './constraints';
 import type * as DCommon from '../common';
 declare module "./constraints" {
     interface CharactersRangeStore {
-        "a-z": true;
-        "A-Z": true;
-        "A-z": true;
-        "0-9": true;
+        "a-z": "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+        "A-Z": "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+        "0-9": "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
     }
 }
-type ContainsIsComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange> = DCommon.UnionToIntersection<(GenericCharactersRange extends any ? AllowedCharacters<GenericCharactersRange> : never)> extends infer InferredConstraints extends DCommon.Constraint ? GenericValue extends InferredConstraints ? GenericValue : GenericValue & InferredConstraints : never;
-export declare function isComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>): (value: GenericValue) => value is ContainsIsComposedOf<GenericValue, GenericCharactersRange>;
-export declare function isComposedOf<GenericValue extends string, GenericCharactersRange extends CharactersRange>(value: GenericValue, charactersRange: DCommon.MaybeArray<GenericCharactersRange>): value is ContainsIsComposedOf<GenericValue, GenericCharactersRange>;
-export {};
+export declare function isComposedOf<GenericCharactersRange extends CharactersRange>(charactersRange: DCommon.MaybeArray<GenericCharactersRange>): (value: string) => value is string & AllowedCharacters<GenericCharactersRange>;
+export declare function isComposedOf<GenericCharactersRange extends CharactersRange>(value: string, charactersRange: DCommon.MaybeArray<GenericCharactersRange>): value is string & AllowedCharacters<GenericCharactersRange>;

package/dist/string/isComposedOf.mjs

@@ -3,7 +3,6 @@ import { coalescing } from "../array/coalescing.mjs";
 const charactersRangeStore = /* @__PURE__ */ new Map([
 	["a-z", "a-z"],
 	["A-Z", "A-Z"],
-	["A-z", "A-z"],
 	["0-9", "0-9"]
 ]);
 function isComposedOf(...args) {

package/dist/string/prepend.d.ts

@@ -9,6 +9,6 @@ type RemoveStringConstraints<GenericStrings extends readonly string[]> = Generic
     ...RemoveStringConstraints<InferredRest>
 ] : string[];
 type PrependOutput<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[] = []> = ReapplyCompatiblesConstraints<GenericString, `${Extract<DCommon.RemoveConstraint<GenericElement>, string>}${Join<RemoveStringConstraints<GenericElementsRest>>}${Extract<DCommon.RemoveConstraint<GenericString>, string>}`, "minCharacters">;
-export declare function prepend<GenericString extends string, GenericElement extends string, GenericOutput = PrependOutput<GenericString, GenericElement>>(element: GenericElement): (string: GenericString) => DCommon.BreakGenericLink<GenericOutput>;
-export declare function prepend<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[], GenericOutput = PrependOutput<GenericString, GenericElement, GenericElementsRest>>(string: GenericString, element: GenericElement, ...elementsRest: GenericElementsRest): DCommon.BreakGenericLink<GenericOutput>;
+export declare function prepend<GenericString extends string, GenericElement extends string>(element: GenericElement): (string: GenericString) => PrependOutput<GenericString, GenericElement>;
+export declare function prepend<GenericString extends string, GenericElement extends string, GenericElementsRest extends readonly string[]>(string: GenericString, element: GenericElement, ...elementsRest: GenericElementsRest): PrependOutput<GenericString, GenericElement, GenericElementsRest>;
 export {};

package/dist/string/split.cjs

@@ -5,6 +5,7 @@ function split(...args) {
 		return (string) => split(string, separator);
 	}
 	const [string, separator, params] = args;
+	if (string === "" && separator === "") return [""];
 	return string.split(separator, params?.limit);
 }
 //#endregion

package/dist/string/split.d.ts

@@ -19,8 +19,8 @@ type ComputeSplitOutput<GenericString extends string, GenericSeparator extends s
     DCommon.IsEqual<GenericString, string>,
     DCommon.IsEqual<GenericSeparator, "">,
     IsKeyPattern<GenericSeparator>
-]> extends true ? string[] & DArray.MinElements<ApplySplitLimit<1, GenericLimit>> : CountSplitGroups<GenericString, GenericSeparator> extends infer InferredGroupNumber extends number ? ApplySplitLimit<InferredGroupNumber, GenericLimit> extends infer InferredOutputLength extends number ? (string[] & DArray.MinElements<InferredOutputLength> & (IsKeyPattern<GenericString> extends true ? unknown : (DArray.LengthEqual<InferredOutputLength> & DArray.MaxElements<InferredOutputLength>))) : never : never;
+]> extends true ? readonly string[] & DArray.MinElements<ApplySplitLimit<1, GenericLimit>> : CountSplitGroups<GenericString, GenericSeparator> extends infer InferredGroupNumber extends number ? ApplySplitLimit<InferredGroupNumber, GenericLimit> extends infer InferredOutputLength extends number ? (readonly string[] & DArray.MinElements<InferredOutputLength> & (IsKeyPattern<GenericString> extends true ? unknown : (DArray.LengthEqual<InferredOutputLength> & DArray.MaxElements<InferredOutputLength>))) : never : never;
 type SplitOutput<GenericString extends string, GenericSeparator extends string, GenericLimit extends number = number> = GenericString extends Format<string> ? ComputeSplitOutput<Extract<DCommon.RemoveConstraint<ApplyFormat<GenericString>>, string>, GenericSeparator, GenericLimit> : ComputeSplitOutput<Extract<DCommon.RemoveConstraint<GenericString>, string>, GenericSeparator, GenericLimit>;
-export declare function split<GenericString extends string, GenericSeparator extends string, GenericOutput = SplitOutput<GenericString, GenericSeparator>>(separator: GenericSeparator | RegExp): (string: GenericString) => DCommon.BreakGenericLink<GenericOutput>;
-export declare function split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number, GenericOutput = SplitOutput<GenericString, GenericSeparator, GenericLimit>>(string: GenericString, separator: GenericSeparator | RegExp, params?: SplitParams<GenericLimit>): DCommon.BreakGenericLink<GenericOutput>;
+export declare function split<GenericString extends string, GenericSeparator extends string>(separator: GenericSeparator | RegExp): (string: GenericString) => SplitOutput<GenericString, GenericSeparator>;
+export declare function split<GenericString extends string, GenericSeparator extends string, GenericLimit extends number>(string: GenericString, separator: GenericSeparator | RegExp, params?: SplitParams<GenericLimit>): SplitOutput<GenericString, GenericSeparator, GenericLimit>;
 export {};

package/dist/string/split.mjs

@@ -5,6 +5,7 @@ function split(...args) {
 		return (string) => split(string, separator);
 	}
 	const [string, separator, params] = args;
+	if (string === "" && separator === "") return [""];
 	return string.split(separator, params?.limit);
 }
 //#endregion

package/dist/string/toLowerCase.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
 import type * as DCommon from '../common';
 type ToLowerCaseOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, Lowercase<Extract<DCommon.RemoveConstraint<GenericString>, string>>, "minCharacters">;
-export declare function toLowerCase<GenericString extends string, GenericOutput = ToLowerCaseOutput<GenericString>>(string: GenericString): DCommon.BreakGenericLink<GenericOutput>;
+export declare function toLowerCase<GenericString extends string>(string: GenericString): ToLowerCaseOutput<GenericString>;
 export {};

package/dist/string/toUpperCase.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
 import type * as DCommon from '../common';
 type ToUpperCaseOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, Uppercase<Extract<DCommon.RemoveConstraint<GenericString>, string>>, "minCharacters">;
-export declare function toUpperCase<GenericString extends string, GenericOutput = ToUpperCaseOutput<GenericString>>(string: GenericString): DCommon.BreakGenericLink<GenericOutput>;
+export declare function toUpperCase<GenericString extends string>(string: GenericString): ToUpperCaseOutput<GenericString>;
 export {};

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

@@ -0,0 +1,5 @@
+import { IsLiteral } from './isLiteral';
+type _IsAllowedTail<GenericValue extends string, GenericAllowed extends string> = GenericValue extends `${infer Char}${infer Rest}` ? Char extends GenericAllowed ? _IsAllowedTail<Rest, GenericAllowed> : false : true;
+type _IsAllowedString<GenericValue extends string, GenericAllowed extends string> = GenericValue extends `${infer InferredA}${infer InferredB}${infer InferredC}${infer InferredD}${infer InferredE}${infer InferredF}${infer InferredG}${infer InferredH}${infer InferredRest}` ? (InferredA | InferredB | InferredC | InferredD | InferredE | InferredF | InferredG | InferredH) extends GenericAllowed ? IsAllowedString<InferredRest, GenericAllowed> : false : _IsAllowedTail<GenericValue, GenericAllowed>;
+export type IsAllowedString<GenericValue extends string, GenericAllowed extends string> = IsLiteral<GenericValue> extends true ? _IsAllowedString<GenericValue, GenericAllowed> : false;
+export {};

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

@@ -1,3 +1,4 @@
+export type * from './IsAllowedString';
 export type * from './at';
 export type * from './countMinCharacters';
 export type * from './digit';

package/dist/string/uncapitalize.d.ts

@@ -1,5 +1,5 @@
 import { ReapplyCompatiblesConstraints } from './constraints';
 import type * as DCommon from '../common';
 type UncapitalizeOutput<GenericString extends string> = ReapplyCompatiblesConstraints<GenericString, Uncapitalize<Extract<DCommon.RemoveConstraint<GenericString>, string>>, "minCharacters">;
-export declare function uncapitalize<GenericString extends string, GenericOutput = UncapitalizeOutput<GenericString>>(string: GenericString): DCommon.BreakGenericLink<GenericOutput>;
+export declare function uncapitalize<GenericString extends string>(string: GenericString): UncapitalizeOutput<GenericString>;
 export {};

package/dist/tuple/types/map.d.ts

@@ -1 +1 @@
-export type Map<GenericArray extends readonly unknown[], GenericOutput extends unknown> = GenericArray extends readonly [] ? [] : GenericArray extends readonly [infer _InferredFirst, ...infer InferredRest] ? Map<InferredRest, GenericOutput> extends infer InferredResult extends readonly any[] ? [GenericOutput, ...InferredResult] : never : GenericOutput[];
+export type Map<GenericArray extends readonly unknown[], GenericOutput extends unknown> = GenericArray extends readonly [] ? readonly [] : GenericArray extends readonly [infer _InferredFirst, ...infer InferredRest] ? Map<InferredRest, GenericOutput> extends infer InferredResult extends readonly any[] ? readonly [GenericOutput, ...InferredResult] : never : readonly GenericOutput[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.8",
+  "version": "0.1.0-beta.1",
   "license": "MIT",
   "type": "module",
   "author": {
@@ -11,18 +11,11 @@
   "homepage": "https://lang.duplojs.dev/",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/duplojs/lang.git"
+    "url": "git+https://github.com/duplojs/ecosystem.git",
+    "directory": "packages/lang"
   },
-  "scripts": {
-    "build": "./.commands/build.sh",
-    "test:ut": "./.commands/test-ut.sh",
-    "test:ut:watch": "./.commands/test-ut.sh --watch",
-    "test:ut:update": "./.commands/test-ut.sh --update",
-    "test:types": "./.commands/test-types.sh",
-    "test:types:target": "./.commands/test-types-target.sh",
-    "test:lint": "./.commands/test-lint.sh",
-    "test:lint:fix": "./.commands/test-lint.sh --fix",
-    "prepare": "husky"
+  "bugs": {
+    "url": "https://github.com/duplojs/ecosystem/issues"
   },
   "sideEffects": false,
   "types": "./dist/index.d.ts",
@@ -114,26 +107,12 @@
     }
   },
   "devDependencies": {
-    "@duplojs/code-config": "0.1.0",
-    "@types/node": "24.1.0",
-    "husky": "9.1.7",
-    "rolldown": "1.2.4",
-    "unplugin-dts": "1.0.3",
-    "@typescript/typescript6": "6.0.2",
-    "tslib": "2.8.1",
-    "tsx": "4.23.12",
-    "tscw-config": "1.1.2",
-    "typescript": "7.0.2",
-    "vitest": "4.1.10",
-    "@vitest/coverage-istanbul": "4.1.10"
+    "@duplojs/code-config": "0.1.0-beta.1",
+    "@types/node": "24.13.3"
   },
-  "workspaces": [
-    "integrations",
-    "docs"
-  ],
   "files": [
     "dist",
-    "README.md"
+    "README"
   ],
   "keywords": [
     "typescript",
@@ -156,5 +135,12 @@
   ],
   "engines": {
     "node": ">=24.18.0"
+  },
+  "scripts": {
+    "build": "./.commands/build.sh",
+    "test:types": "./.commands/test-types.sh",
+    "test:types:target": "./.commands/test-types-target.sh",
+    "test:lint": "./.commands/test-lint.sh",
+    "test:lint:fix": "./.commands/test-lint.sh --fix"
   }
-}
+}

package/dist/dataStructure/common/errorInterpreter.cjs

@@ -1,45 +0,0 @@
-const require_base = require("../../kind/base.cjs");
-const require_entries = require("../../object/entries.cjs");
-const require_entry = require("../../object/entry.cjs");
-const require_map = require("../../array/map.cjs");
-const require_reduce = require("../../array/reduce.cjs");
-const require_pipe = require("../../common/pipe.cjs");
-const require_error = require("./error.cjs");
-//#region scripts/dataStructure/common/errorInterpreter.ts
-const kindNamespaceName = "DuplojsLangDataStructure";
-function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
-	const formattedStructureDictionary = require_pipe.pipe(structureDictionary, require_entries.entries, require_map.map(([key, value]) => require_entry.entry(`${require_base.keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
-	const getInterpretedMessageStructure = (structure) => require_reduce.reduce(formattedStructureDictionary, require_reduce.reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure)) : next(void 0));
-	const getInterpretedMessageCodec = (codec) => require_reduce.reduce(codecDictionary, require_reduce.reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message) : next(void 0));
-	return (error) => require_map.map(error.issues, (issue) => {
-		if (require_error.issueKind.has(issue)) {
-			const source = issue.getSource();
-			const subSource = issue.getSubSource?.();
-			return {
-				...issue,
-				interpretedMessage: {
-					source: source.definition.message,
-					subSource: subSource?.definition.message,
-					interpretedSource: getInterpretedMessageStructure(source),
-					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource)
-				}
-			};
-		}
-		if (require_error.encodeIssueKind.has(issue)) return {
-			...issue,
-			interpretedMessage: {
-				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
-			}
-		};
-		return {
-			...issue,
-			interpretedMessage: {
-				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
-			}
-		};
-	});
-}
-//#endregion
-exports.createErrorInterpreter = createErrorInterpreter;

package/dist/dataStructure/common/errorInterpreter.d.ts

@@ -1,32 +0,0 @@
-import { Structure, Structures } from '../structure';
-import { createKind } from '../kind';
-import { Type, Types } from '../type';
-import { Constraint, Constraints } from '../constraint';
-import { Error, DecodeIssue, EncodeIssue, Issue } from './error';
-import { Codec } from './codec';
-import * as DKind from '../../kind';
-import * as DCommon from '../../common';
-declare const kindNamespaceName: DKind.GetNamespaceName<typeof createKind>;
-type RemoveNamespace<GenericString> = GenericString extends `@${typeof kindNamespaceName}/${infer InferredKindName}` ? InferredKindName : never;
-export interface InterpretedMessage {
-    source?: string;
-    interpretedSource?: string;
-    subSource?: string;
-    interpretedSubSource?: string;
-}
-export interface InterpretedIssue extends Issue {
-    interpretedMessage: InterpretedMessage;
-}
-export interface InterpretedEncodedIssue extends EncodeIssue {
-    interpretedMessage: InterpretedMessage;
-}
-export interface InterpretedDecodedIssue extends DecodeIssue {
-    interpretedMessage: InterpretedMessage;
-}
-export type InterpretedIssues = (InterpretedIssue | InterpretedEncodedIssue | InterpretedDecodedIssue);
-type CreateDictionaryParams = DCommon.SimplifyTopLevel<Omit<{
-    [DataStructure in (Types | Structures | Constraints) as RemoveNamespace<DKind.GetName<DataStructure>>]?: (structure: DataStructure) => string;
-}, RemoveNamespace<DKind.GetName<Type>> | RemoveNamespace<DKind.GetName<Structure>> | RemoveNamespace<DKind.GetName<Constraint>>>>;
-export declare function createErrorInterpreter(structureDictionary?: CreateDictionaryParams, codecDictionary?: [Codec, string][]): (error: Error) => readonly InterpretedIssues[];
-export type ErrorInterpreter = ReturnType<typeof createErrorInterpreter>;
-export {};

package/dist/dataStructure/common/errorInterpreter.mjs

@@ -1,45 +0,0 @@
-import { keyKindPrefix } from "../../kind/base.mjs";
-import { entries } from "../../object/entries.mjs";
-import { entry } from "../../object/entry.mjs";
-import { map } from "../../array/map.mjs";
-import { reduce, reduceFrom } from "../../array/reduce.mjs";
-import { pipe } from "../../common/pipe.mjs";
-import { encodeIssueKind, issueKind } from "./error.mjs";
-//#region scripts/dataStructure/common/errorInterpreter.ts
-const kindNamespaceName = "DuplojsLangDataStructure";
-function createErrorInterpreter(structureDictionary = {}, codecDictionary = []) {
-	const formattedStructureDictionary = pipe(structureDictionary, entries, map(([key, value]) => entry(`${keyKindPrefix}@${kindNamespaceName}/${key}`, value)));
-	const getInterpretedMessageStructure = (structure) => reduce(formattedStructureDictionary, reduceFrom(void 0), ({ element: [key, getMessage], next, exit }) => getMessage && key in structure ? exit(getMessage(structure)) : next(void 0));
-	const getInterpretedMessageCodec = (codec) => reduce(codecDictionary, reduceFrom(void 0), ({ element: [currentCodec, message], next, exit }) => currentCodec === codec ? exit(message) : next(void 0));
-	return (error) => map(error.issues, (issue) => {
-		if (issueKind.has(issue)) {
-			const source = issue.getSource();
-			const subSource = issue.getSubSource?.();
-			return {
-				...issue,
-				interpretedMessage: {
-					source: source.definition.message,
-					subSource: subSource?.definition.message,
-					interpretedSource: getInterpretedMessageStructure(source),
-					interpretedSubSource: subSource && getInterpretedMessageStructure(subSource)
-				}
-			};
-		}
-		if (encodeIssueKind.has(issue)) return {
-			...issue,
-			interpretedMessage: {
-				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
-			}
-		};
-		return {
-			...issue,
-			interpretedMessage: {
-				source: issue.message,
-				interpretedSource: getInterpretedMessageCodec(issue.getSource())
-			}
-		};
-	});
-}
-//#endregion
-export { createErrorInterpreter };

package/dist/invocation/useCase.cjs

@@ -1,26 +0,0 @@
-const require_entries = require("../object/entries.cjs");
-const require_entry = require("../object/entry.cjs");
-const require_fromEntries = require("../object/fromEntries.cjs");
-const require_map = require("../array/map.cjs");
-const require_forward = require("../common/forward.cjs");
-const require_pipe = require("../common/pipe.cjs");
-const require_uncapitalize = require("../string/uncapitalize.cjs");
-//#region scripts/invocation/useCase.ts
-const useCaseHandlerKind = require("./kind.cjs").createKind("use-case-handler");
-function createUseCase(dependencies, getUseCase) {
-	return {
-		dependencies,
-		getUseCase: (injectedDependencies) => getUseCase(require_pipe.pipe(require_forward.forward(dependencies), require_entries.entries, require_map.map(([key, value]) => {
-			const formattedKey = require_uncapitalize.uncapitalize(key);
-			return require_entry.entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey] ? value.getUseCase(injectedDependencies) : injectedDependencies[formattedKey]);
-		}), require_fromEntries.fromEntries)),
-		[useCaseHandlerKind.runTimeKey]: null
-	};
-}
-function wireUseCases(useCases, ports) {
-	return require_pipe.pipe(useCases, require_entries.entries, require_map.map(([key, useCase]) => require_entry.entry(require_uncapitalize.uncapitalize(key), useCase.getUseCase(ports))), require_fromEntries.fromEntries);
-}
-//#endregion
-exports.createUseCase = createUseCase;
-exports.useCaseHandlerKind = useCaseHandlerKind;
-exports.wireUseCases = wireUseCases;

package/dist/invocation/useCase.d.ts

@@ -1,28 +0,0 @@
-import { PortHandler } from './port';
-import * as DCommon from '../common';
-import type * as DKind from '../kind';
-export type UseCaseDependencies = Record<string, UseCaseHandler | PortHandler>;
-export type UseCaseDependenciesValue<GenericDependencies extends UseCaseDependencies> = DCommon.SimplifyTopLevel<{
-    [Prop in keyof GenericDependencies as Uncapitalize<Extract<Prop, string>>]: GenericDependencies[Prop] extends PortHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
-}>;
-export type GetAllPorts<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
-    [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends PortHandler ? [
-        Uncapitalize<Extract<Prop, string>>,
-        ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
-    ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllPorts<GenericDependenciesValue[Prop]["dependencies"]> : never);
-})[keyof GenericDependenciesValue] : never;
-export declare const useCaseHandlerKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/use-case-handler", unknown>>;
-export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies = any, GenericUseCase extends (input: any) => any = any> extends DKind.Kind<typeof useCaseHandlerKind> {
-    dependencies: GenericDependencies;
-    getUseCase(ports: DCommon.SimplifyTopLevel<(GetAllPorts<GenericDependencies> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
-        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
-    } : never) & ({
-        [Prop in keyof GenericDependencies as GenericDependencies[Prop] extends UseCaseHandler ? Uncapitalize<Extract<Prop, string>> : never]?: GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
-    })>): GenericUseCase;
-}
-export declare function createUseCase<const GenericDependencies extends UseCaseDependencies, GenericUseCase extends (...args: any[]) => any>(dependencies: GenericDependencies, getUseCase: (dependenciesValue: UseCaseDependenciesValue<GenericDependencies>) => GenericUseCase): UseCaseHandler<GenericDependencies, GenericUseCase>;
-export declare function wireUseCases<GenericUseCases extends Record<string, UseCaseHandler>>(useCases: GenericUseCases, ports: DCommon.SimplifyTopLevel<DCommon.UnionToIntersection<{
-    [Prop in keyof GenericUseCases]: GetAllPorts<GenericUseCases[Prop]["dependencies"]> extends infer InferredEntriesDependenciesValue extends DCommon.ObjectEntry ? {
-        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
-    } : never;
-}[keyof GenericUseCases]>>): UseCaseDependenciesValue<GenericUseCases>;

package/dist/invocation/useCase.mjs

@@ -1,25 +0,0 @@
-import { entries } from "../object/entries.mjs";
-import { entry } from "../object/entry.mjs";
-import { fromEntries } from "../object/fromEntries.mjs";
-import { map } from "../array/map.mjs";
-import { forward } from "../common/forward.mjs";
-import { pipe } from "../common/pipe.mjs";
-import { uncapitalize } from "../string/uncapitalize.mjs";
-import { createKind } from "./kind.mjs";
-//#region scripts/invocation/useCase.ts
-const useCaseHandlerKind = createKind("use-case-handler");
-function createUseCase(dependencies, getUseCase) {
-	return {
-		dependencies,
-		getUseCase: (injectedDependencies) => getUseCase(pipe(forward(dependencies), entries, map(([key, value]) => {
-			const formattedKey = uncapitalize(key);
-			return entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey] ? value.getUseCase(injectedDependencies) : injectedDependencies[formattedKey]);
-		}), fromEntries)),
-		[useCaseHandlerKind.runTimeKey]: null
-	};
-}
-function wireUseCases(useCases, ports) {
-	return pipe(useCases, entries, map(([key, useCase]) => entry(uncapitalize(key), useCase.getUseCase(ports))), fromEntries);
-}
-//#endregion
-export { createUseCase, useCaseHandlerKind, wireUseCases };

package/dist/object/types/assignObjects.d.ts

@@ -1,2 +0,0 @@
-import type * as DCommon from '../../common';
-export type AssignObjects<GenericFirstObject extends object, GenericSecondObject extends object> = DCommon.SimplifyTopLevel<Omit<GenericFirstObject, keyof GenericSecondObject> & GenericSecondObject>;