@duplojs/lang 0.0.1-beta.7 → 0.0.1-beta.9

package/dist/modeling/taggedObject/base.cjs

@@ -1,6 +1,10 @@
+const require_parentClass = require("../../kind/parentClass.cjs");
 const require_isSimple = require("../../object/isSimple.cjs");
 const require_create = require("../../either/left/create.cjs");
+const require_is = require("../../either/left/is.cjs");
 const require_create$1 = require("../../either/right/create.cjs");
+const require_unwrap = require("../../either/left/unwrap.cjs");
+const require_unwrap$1 = require("../../either/right/unwrap.cjs");
 const require_justExec = require("../../common/justExec.cjs");
 const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
 const require_error = require("../../dataStructure/common/error.cjs");
@@ -11,6 +15,13 @@ const require_kind = require("../kind.cjs");
 //#region scripts/modeling/taggedObject/base.ts
 const objectTagKind = require_kind.createKind("object-tag");
 const taggedObjectStructureKind = require_kind.createKind("tagged-object-structure");
+var EncodeTaggedObjectError = class extends require_parentClass.parentClass(require_kind.createKind("encode-tagged-object-error"), Error) {
+	error;
+	constructor(error) {
+		super(void 0, "An error occurred while encoding a TaggedObject. This can only happen if you are bypassing the type system.");
+		this.error = error;
+	}
+};
 const TaggedObjectStructure = require_base.createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
 	inner: require_object.ObjectStructure({
 		...shape,
@@ -70,7 +81,7 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 			return require_create$1.right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => require_justExec.justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = require_error.createGetErrorHandler();
 		const formattedData = require_isSimple.isSimple(data) ? {
 			...data,
@@ -78,9 +89,15 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 		} : data;
 		if (await self.executeCheck(formattedData, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
 		return require_create$1.right("map-success", formattedData);
-	})
+	},
+	encodeTaggedObject: async (self, codecs, data) => {
+		const result = await self.asyncEncode(codecs, data);
+		if (require_is.isLeft(result)) throw new EncodeTaggedObjectError(require_unwrap.unwrapLeft(result));
+		return require_unwrap$1.unwrapRight(result);
+	}
 }));
 //#endregion
+exports.EncodeTaggedObjectError = EncodeTaggedObjectError;
 exports.TaggedObjectStructure = TaggedObjectStructure;
 exports.objectTagKind = objectTagKind;
 exports.taggedObjectStructureKind = taggedObjectStructureKind;

package/dist/modeling/taggedObject/base.d.ts

@@ -1,5 +1,5 @@
 import { NewType, NewTypeMap } from '../newType';
-import type * as DKind from '../../kind';
+import * as DKind from '../../kind';
 import * as DCommon from '../../common';
 import * as DEither from '../../either';
 import * as DDataStructure from '../../dataStructure';
@@ -36,7 +36,7 @@ export type TaggedObjectMap<GenericValue extends unknown, GenericRawValue = DCom
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: TaggedObjectMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
-export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
+export interface TaggedObjectStructure<out GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
     "new"(properties: DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject>>): GenericTaggedObject;
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
@@ -45,5 +45,12 @@ export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = O
     asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
     asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
     asyncMap(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    encodeTaggedObject<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.StructureValue<this>): Promise<DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>>;
+}
+declare const EncodeTaggedObjectError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangModeling/encode-tagged-object-error", unknown>>, ErrorConstructor>;
+export declare class EncodeTaggedObjectError extends EncodeTaggedObjectError_base {
+    error: DDataStructure.Error;
+    constructor(error: DDataStructure.Error);
 }
 export declare const TaggedObjectStructure: <GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape) => TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;
+export {};

package/dist/modeling/taggedObject/base.mjs

@@ -1,6 +1,10 @@
+import { parentClass } from "../../kind/parentClass.mjs";
 import { isSimple } from "../../object/isSimple.mjs";
 import { left } from "../../either/left/create.mjs";
+import { isLeft } from "../../either/left/is.mjs";
 import { right } from "../../either/right/create.mjs";
+import { unwrapLeft } from "../../either/left/unwrap.mjs";
+import { unwrapRight } from "../../either/right/unwrap.mjs";
 import { justExec } from "../../common/justExec.mjs";
 import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
 import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
@@ -11,6 +15,13 @@ import { createKind } from "../kind.mjs";
 //#region scripts/modeling/taggedObject/base.ts
 const objectTagKind = createKind("object-tag");
 const taggedObjectStructureKind = createKind("tagged-object-structure");
+var EncodeTaggedObjectError = class extends parentClass(createKind("encode-tagged-object-error"), Error) {
+	error;
+	constructor(error) {
+		super(void 0, "An error occurred while encoding a TaggedObject. This can only happen if you are bypassing the type system.");
+		this.error = error;
+	}
+};
 const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init }) => (name, shape) => init({
 	inner: ObjectStructure({
 		...shape,
@@ -70,7 +81,7 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 			return right("map-success", result);
 		});
 	},
-	asyncMap: (self, data) => justExec(async () => {
+	asyncMap: async (self, data) => {
 		const errorHandler = createGetErrorHandler();
 		const formattedData = isSimple(data) ? {
 			...data,
@@ -78,7 +89,12 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 		} : data;
 		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
 		return right("map-success", formattedData);
-	})
+	},
+	encodeTaggedObject: async (self, codecs, data) => {
+		const result = await self.asyncEncode(codecs, data);
+		if (isLeft(result)) throw new EncodeTaggedObjectError(unwrapLeft(result));
+		return unwrapRight(result);
+	}
 }));
 //#endregion
-export { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };
+export { EncodeTaggedObjectError, TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };

package/dist/number/types/isGreater.d.ts

@@ -25,13 +25,13 @@ type CheckIsGreater<GreaterSplitValue extends DCommon.AnyTuple<DString.Digit>, G
     infer InferredRestSplitValue extends DCommon.AnyTuple<DString.Digit>,
     infer InferredRestSplitReference extends DCommon.AnyTuple<FigureGreaterThanTableValue>
 ] ? CheckIsGreater<InferredRestSplitValue, InferredRestSplitReference> : never : false;
-type toStringDecimal<GenericValue extends number> = `${GenericValue}` extends `${DString.Number}.${DString.Number}` ? `${GenericValue}` : `${GenericValue}.0`;
+type toStringDecimal<GenericValue extends number> = `${GenericValue}` extends `${DString.NumberInString}.${DString.NumberInString}` ? `${GenericValue}` : `${GenericValue}.0`;
 type PrepareValues<GenericValue extends number, GenericReference extends number> = readonly [
     toStringDecimal<GenericValue>,
     toStringDecimal<GenericReference>
 ] extends readonly [
-    `${infer InferredValueInteger extends DString.Number}.${infer InferredValueDecimals extends DString.Number}`,
-    `${infer InferredReferenceInteger extends DString.Number}.${infer InferredReferenceDecimals extends DString.Number}`
+    `${infer InferredValueInteger extends DString.NumberInString}.${infer InferredValueDecimals extends DString.NumberInString}`,
+    `${infer InferredReferenceInteger extends DString.NumberInString}.${infer InferredReferenceDecimals extends DString.NumberInString}`
 ] ? DCommon.And<[
     DCommon.IsEqual<InferredValueDecimals, "0">,
     DCommon.IsEqual<InferredReferenceDecimals, "0">
@@ -52,8 +52,8 @@ type PrepareValues<GenericValue extends number, GenericReference extends number>
     `${infer InferredResultReference}`
 ] ? readonly [`${InferredResultValue}`, `${InferredResultReference}`] : never : never : readonly [InferredValueInteger, InferredReferenceInteger] : never;
 type ComputeIsGreater<GenericValue extends number, GenericReference extends number> = PrepareValues<GenericValue, GenericReference> extends readonly [
-    infer InferredValue extends DString.Number,
-    infer InferredReference extends DString.Number
+    infer InferredValue extends DString.NumberInString,
+    infer InferredReference extends DString.NumberInString
 ] ? DCommon.And<[
     DString.Includes<InferredValue, "-">,
     DCommon.Not<DString.Includes<InferredReference, "-">>

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

@@ -0,0 +1,3 @@
+import { GetPropsWithValueExtends } from './getPropsWithValueExtends';
+import type * as DCommon from '../../common';
+export type ForbiddenUndefinedProps<GenericObject extends object> = DCommon.IsNever<GetPropsWithValueExtends<GenericObject, undefined>> extends true ? unknown : DCommon.ComputedTypeError<"Having \"undefined\" values for properties is not allowed.">;

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

@@ -1,11 +1,12 @@
 export type * from './assignObjects';
-export type * from './everyCombination';
 export type * from './deepPartial';
 export type * from './deepReadonly';
 export type * from './deepRemoveReadonly';
 export type * from './deepRequired';
+export type * from './everyCombination';
 export type * from './flatObject';
 export type * from './forbiddenKey';
+export type * from './forbiddenUndefinedProps';
 export type * from './getPropsWithValue';
 export type * from './getPropsWithValueExtends';
 export type * from './partialKeys';

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

@@ -2,12 +2,12 @@ import type * as DCommon from '../../common';
 type CreateShape<GenericResult extends unknown, GenericProp extends keyof any> = GenericResult extends any ? {
     [RemapProp in GenericProp]: GenericResult;
 } : never;
-export type Split<GenericValue extends unknown, GenericMax extends number = 10, GenericAccumulator extends readonly never[] = readonly []> = GenericValue extends object ? GenericAccumulator["length"] extends GenericMax ? GenericValue : {
+export type Split<GenericValue extends unknown, GenericMax extends number = 10, GenericAccumulator extends readonly never[] = readonly []> = GenericValue extends unknown ? DCommon.IsObject<GenericValue> extends true ? GenericAccumulator["length"] extends GenericMax ? GenericValue : {
     [Prop in keyof GenericValue]: DCommon.NeverCoalescing<CreateShape<Split<GenericValue[Prop], GenericMax, [
         ...GenericAccumulator,
         never
     ]>, Prop>, {
         [RemapProp in Prop]: never;
     }>;
-}[keyof GenericValue] : GenericValue;
+}[keyof GenericValue] : GenericValue : never;
 export {};

package/dist/pattern/matchWithNumber.d.ts

@@ -1,9 +1,9 @@
 import type * as DCommon from '../common';
 import type * as DNumber from '../number/types';
-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;
-export declare function matchWithNumber<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>>(matcher: GenericMatcher & ComputeMatcher<NoInfer<GenericInput>> & ForbiddenMoreKey<NoInfer<GenericInput>, GenericMatcher>): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>) => ReturnType<NoInfer<GenericMatcher>[keyof GenericMatcher]>;
-export declare function matchWithNumber<GenericInput extends number, GenericMatcher extends ComputeMatcher<GenericInput>>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericInput>, matcher: DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericInput>, GenericMatcher> & ForbiddenMoreKey<GenericInput, GenericMatcher>): ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithNumber<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): (input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>) => ReturnType<GenericMatcher[keyof GenericMatcher]>;
+export declare function matchWithNumber<GenericInput extends number, GenericClearInput extends Extract<DCommon.RemoveConstraint<GenericInput>, number>, GenericMatcher extends ComputeMatcher<GenericClearInput>>(input: GenericInput & DNumber.RequireSimpleLiteral<GenericClearInput>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericClearInput>, GenericMatcher> & ForbiddenMoreKey<GenericClearInput, GenericMatcher>)): ReturnType<GenericMatcher[keyof GenericMatcher]>;
 export {};

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: 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: 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: 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: Exclude<GenericInput, HandledKeys<GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 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/constraints/index.d.ts

@@ -1,4 +1,3 @@
-export type * from './types';
 export type * from './allowedCharacters';
 export type * from './email';
 export type * from './format';
@@ -6,6 +5,8 @@ export type * from './lengthEqual';
 export type * from './maxCharacters';
 export type * from './minCharacters';
 export type * from './notEmpty';
+export type * from './number';
 export type * from './trimmed';
+export type * from './types';
 export type * from './url';
 export type * from './uuid';

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

@@ -0,0 +1,4 @@
+import { NumberInString } from '../types';
+import { Format } from './format';
+export interface Number extends Format<"number", NumberInString> {
+}

package/dist/string/index.cjs

@@ -14,6 +14,7 @@ const require_isEmail = require("./isEmail.cjs");
 const require_isIn = require("./isIn.cjs");
 const require_isKeyof = require("./isKeyof.cjs");
 const require_isNotEmpty = require("./isNotEmpty.cjs");
+const require_isNumber = require("./isNumber.cjs");
 const require_isUrl = require("./isUrl.cjs");
 const require_isUuid = require("./isUuid.cjs");
 const require_join = require("./join.cjs");
@@ -67,6 +68,7 @@ var string_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	isIn: () => require_isIn.isIn,
 	isKeyof: () => require_isKeyof.isKeyof,
 	isNotEmpty: () => require_isNotEmpty.isNotEmpty,
+	isNumber: () => require_isNumber.isNumber,
 	isTrimmed: () => require_is.isTrimmed,
 	isUrl: () => require_isUrl.isUrl,
 	isUuid: () => require_isUuid.isUuid,
@@ -121,6 +123,7 @@ exports.isEmail = require_isEmail.isEmail;
 exports.isIn = require_isIn.isIn;
 exports.isKeyof = require_isKeyof.isKeyof;
 exports.isNotEmpty = require_isNotEmpty.isNotEmpty;
+exports.isNumber = require_isNumber.isNumber;
 exports.isTrimmed = require_is.isTrimmed;
 exports.isUrl = require_isUrl.isUrl;
 exports.isUuid = require_isUuid.isUuid;

package/dist/string/index.d.ts

@@ -14,6 +14,7 @@ export * from './isEmail';
 export * from './isIn';
 export * from './isKeyof';
 export * from './isNotEmpty';
+export * from './isNumber';
 export * from './isUrl';
 export * from './isUuid';
 export * from './join';

package/dist/string/index.mjs

@@ -14,6 +14,7 @@ import { emailRegex, isEmail } from "./isEmail.mjs";
 import { isIn } from "./isIn.mjs";
 import { isKeyof } from "./isKeyof.mjs";
 import { isNotEmpty } from "./isNotEmpty.mjs";
+import { isNumber } from "./isNumber.mjs";
 import { isUrl } from "./isUrl.mjs";
 import { isUuid, uuidRegex } from "./isUuid.mjs";
 import { join } from "./join.mjs";
@@ -67,6 +68,7 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	isIn: () => isIn,
 	isKeyof: () => isKeyof,
 	isNotEmpty: () => isNotEmpty,
+	isNumber: () => isNumber,
 	isTrimmed: () => isTrimmed,
 	isUrl: () => isUrl,
 	isUuid: () => isUuid,
@@ -105,4 +107,4 @@ var string_exports = /* @__PURE__ */ __exportAll({
 	uuidRegex: () => uuidRegex
 });
 //#endregion
-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 };
+export { at, capitalize, charAt, concat, emailRegex, endsWith, extract, extractAll, first, includes, indexOf, isComposedOf, isEmail, isIn, isKeyof, isNotEmpty, isNumber, 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/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/isNumber.cjs

@@ -0,0 +1,7 @@
+//#region scripts/string/isNumber.ts
+const numberRegex = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?$/i;
+function isNumber(string) {
+	return numberRegex.test(string);
+}
+//#endregion
+exports.isNumber = isNumber;

package/dist/string/isNumber.d.ts

@@ -0,0 +1,5 @@
+import { Number } from './constraints';
+import { NumberInString } from './types';
+type ComputeResult<GenericValue extends string> = GenericValue extends Number ? GenericValue : GenericValue extends NumberInString ? GenericValue : GenericValue & Number;
+export declare function isNumber<GenericValue extends string>(string: GenericValue): string is ComputeResult<GenericValue>;
+export {};

package/dist/string/isNumber.mjs

@@ -0,0 +1,7 @@
+//#region scripts/string/isNumber.ts
+const numberRegex = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?$/i;
+function isNumber(string) {
+	return numberRegex.test(string);
+}
+//#endregion
+export { isNumber };

package/dist/string/to.d.ts

@@ -1,3 +1,10 @@
-type Primitive = (string | boolean | null | number | undefined | bigint);
-export declare function to<GenericValue extends Primitive>(value: GenericValue): `${GenericValue}`;
+import { Number } from './constraints';
+import type * as DNumber from '../number';
+type Stringifyable = (null | undefined | {
+    toString(): string;
+});
+type ComputeResult<GenericValue extends Stringifyable> = GenericValue extends number ? DNumber.IsLiteral<GenericValue> extends true ? `${GenericValue}` : string & Number : GenericValue extends (string | boolean | null | undefined | bigint) ? `${GenericValue}` : GenericValue extends {
+    toString(): string;
+} ? ReturnType<GenericValue["toString"]> : never;
+export declare function to<GenericValue extends Stringifyable>(value: GenericValue): ComputeResult<GenericValue>;
 export {};

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

@@ -0,0 +1,3 @@
+type IsAllowedTail<GenericValue extends string, GenericAllowed extends string> = GenericValue extends `${infer Char}${infer Rest}` ? Char extends GenericAllowed ? IsAllowedTail<Rest, GenericAllowed> : false : true;
+export 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 {};

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

@@ -1,3 +1,5 @@
+export type * from './IsAllowedString';
+export type * from './at';
 export type * from './countMinCharacters';
 export type * from './digit';
 export type * from './endsWith';
@@ -5,12 +7,14 @@ export type * from './first';
 export type * from './forbiddenContain';
 export type * from './forbiddenString';
 export type * from './includes';
+export type * from './isKeyPattern';
 export type * from './isLiteral';
+export type * from './isTemplateLiteral';
 export type * from './join';
 export type * from './last';
 export type * from './length';
 export type * from './normalizeForm';
-export type * from './number';
+export type * from './numberInString';
 export type * from './pop';
 export type * from './replace';
 export type * from './requireLiteral';
@@ -18,7 +22,3 @@ export type * from './requireSimpleLiteral';
 export type * from './shift';
 export type * from './split';
 export type * from './startsWith';
-export type * from './isKeyPattern';
-export type * from './at';
-export type * from './first';
-export type * from './last';

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

@@ -0,0 +1 @@
+export type NumberInString = `${number}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.7",
+  "version": "0.0.1-beta.9",
   "license": "MIT",
   "type": "module",
   "author": {
@@ -19,6 +19,7 @@
     "test:ut:watch": "./.commands/test-ut.sh --watch",
     "test:ut:update": "./.commands/test-ut.sh --update",
     "test:types": "./.commands/test-types.sh",
+    "test:types:lib": "./.commands/test-types-lib.sh",
     "test:types:target": "./.commands/test-types-target.sh",
     "test:lint": "./.commands/test-lint.sh",
     "test:lint:fix": "./.commands/test-lint.sh --fix",
@@ -128,7 +129,6 @@
     "@vitest/coverage-istanbul": "4.1.10"
   },
   "workspaces": [
-    "integrations",
     "docs"
   ],
   "files": [

package/dist/dataStructure/common/codec.mjs

@@ -1,26 +0,0 @@
-import { callThen } from "../../common/callThen.mjs";
-import { memo } from "../../common/memo.mjs";
-import { createKind } from "../kind.mjs";
-import { ErrorSymbol } from "./resultSymbol.mjs";
-//#region scripts/dataStructure/common/codec.ts
-const codecKind = createKind("codec");
-const codecsKind = createKind("codecs");
-function createCodec(fundamentalType, predicateEncode, encode, decode) {
-	const self = {
-		fundamentalType,
-		predicateEncode: (data) => predicateEncode(data),
-		encode: (data, errorHandler) => callThen(encode(data, self, errorHandler), (encodedData) => encodedData === ErrorSymbol ? ErrorSymbol : callThen(predicateEncode(encodedData), (result) => result === false ? errorHandler?.().addEncodeIssue(self, encodedData) ?? ErrorSymbol : encodedData)),
-		decode: (data, errorHandler) => callThen(predicateEncode(data), (result) => result === false ? errorHandler?.().addDecodeIssue(self, data) ?? ErrorSymbol : decode(data, self, errorHandler)),
-		[codecKind.runTimeKey]: null
-	};
-	return self;
-}
-function createCodecs(definition) {
-	return {
-		context: memo(() => new Map(Object.values(definition).map((codec) => [codec.fundamentalType, codec]))),
-		definition,
-		[codecsKind.runTimeKey]: null
-	};
-}
-//#endregion
-export { codecKind, codecsKind, createCodec, createCodecs };

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>;