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

package/dist/path/index.cjs

@@ -1,17 +1,40 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_computeRelative = require("./computeRelative.cjs");
+const require_normalize = require("./normalize.cjs");
+const require_create = require("./create.cjs");
+const require_is = require("./is.cjs");
+const require_isAbsolute = require("./isAbsolute.cjs");
+const require_createAbsolute = require("./createAbsolute.cjs");
+const require_kind = require("./kind.cjs");
+const require_createAbsoluteOrThrow = require("./createAbsoluteOrThrow.cjs");
+const require_createOrThrow = require("./createOrThrow.cjs");
 const require_isSegment = require("./isSegment.cjs");
+const require_createSegment = require("./createSegment.cjs");
+const require_createSegmentOrThrow = require("./createSegmentOrThrow.cjs");
+const require_declareAbsolutePath = require("./declareAbsolutePath.cjs");
+const require_declarePath = require("./declarePath.cjs");
+const require_declareSegment = require("./declareSegment.cjs");
 const require_getBaseName = require("./getBaseName.cjs");
 const require_getExtensionName = require("./getExtensionName.cjs");
 const require_getParentFolderPath = require("./getParentFolderPath.cjs");
-const require_is = require("./is.cjs");
-const require_isAbsolute = require("./isAbsolute.cjs");
-const require_normalize = require("./normalize.cjs");
 const require_resolveRelative = require("./resolveRelative.cjs");
 const require_resolveFrom = require("./resolveFrom.cjs");
 //#region scripts/path/index.ts
 var path_exports = /* @__PURE__ */ require_runtime.__exportAll({
+	CreateAbsolutePathError: () => require_createAbsoluteOrThrow.CreateAbsolutePathError,
+	CreatePathError: () => require_createOrThrow.CreatePathError,
+	CreateSegmentPathError: () => require_createSegmentOrThrow.CreateSegmentPathError,
 	computeRelative: () => require_computeRelative.computeRelative,
+	create: () => require_create.create,
+	createAbsolute: () => require_createAbsolute.createAbsolute,
+	createAbsoluteOrThrow: () => require_createAbsoluteOrThrow.createAbsoluteOrThrow,
+	createKind: () => require_kind.createKind,
+	createOrThrow: () => require_createOrThrow.createOrThrow,
+	createSegment: () => require_createSegment.createSegment,
+	createSegmentOrThrow: () => require_createSegmentOrThrow.createSegmentOrThrow,
+	declareAbsolutePath: () => require_declareAbsolutePath.declareAbsolutePath,
+	declarePath: () => require_declarePath.declarePath,
+	declareSegment: () => require_declareSegment.declareSegment,
 	getBaseName: () => require_getBaseName.getBaseName,
 	getExtensionName: () => require_getExtensionName.getExtensionName,
 	getParentFolderPath: () => require_getParentFolderPath.getParentFolderPath,
@@ -23,7 +46,20 @@ var path_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	resolveRelative: () => require_resolveRelative.resolveRelative
 });
 //#endregion
+exports.CreateAbsolutePathError = require_createAbsoluteOrThrow.CreateAbsolutePathError;
+exports.CreatePathError = require_createOrThrow.CreatePathError;
+exports.CreateSegmentPathError = require_createSegmentOrThrow.CreateSegmentPathError;
 exports.computeRelative = require_computeRelative.computeRelative;
+exports.create = require_create.create;
+exports.createAbsolute = require_createAbsolute.createAbsolute;
+exports.createAbsoluteOrThrow = require_createAbsoluteOrThrow.createAbsoluteOrThrow;
+exports.createKind = require_kind.createKind;
+exports.createOrThrow = require_createOrThrow.createOrThrow;
+exports.createSegment = require_createSegment.createSegment;
+exports.createSegmentOrThrow = require_createSegmentOrThrow.createSegmentOrThrow;
+exports.declareAbsolutePath = require_declareAbsolutePath.declareAbsolutePath;
+exports.declarePath = require_declarePath.declarePath;
+exports.declareSegment = require_declareSegment.declareSegment;
 exports.getBaseName = require_getBaseName.getBaseName;
 exports.getExtensionName = require_getExtensionName.getExtensionName;
 exports.getParentFolderPath = require_getParentFolderPath.getParentFolderPath;

package/dist/path/index.d.ts

@@ -1,11 +1,21 @@
 export * from './computeRelative';
 export type * from './constraints';
+export * from './create';
+export * from './createAbsolute';
+export * from './createAbsoluteOrThrow';
+export * from './createOrThrow';
+export * from './createSegment';
+export * from './createSegmentOrThrow';
+export * from './declareAbsolutePath';
+export * from './declarePath';
+export * from './declareSegment';
 export * from './getBaseName';
 export * from './getExtensionName';
 export * from './getParentFolderPath';
 export * from './is';
 export * from './isAbsolute';
 export * from './isSegment';
+export * from './kind';
 export * from './normalize';
 export * from './resolveFrom';
 export * from './resolveRelative';

package/dist/path/index.mjs

@@ -1,17 +1,40 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { computeRelative } from "./computeRelative.mjs";
+import { normalize } from "./normalize.mjs";
+import { create } from "./create.mjs";
+import { is } from "./is.mjs";
+import { isAbsolute } from "./isAbsolute.mjs";
+import { createAbsolute } from "./createAbsolute.mjs";
+import { createKind } from "./kind.mjs";
+import { CreateAbsolutePathError, createAbsoluteOrThrow } from "./createAbsoluteOrThrow.mjs";
+import { CreatePathError, createOrThrow } from "./createOrThrow.mjs";
 import { isSegment } from "./isSegment.mjs";
+import { createSegment } from "./createSegment.mjs";
+import { CreateSegmentPathError, createSegmentOrThrow } from "./createSegmentOrThrow.mjs";
+import { declareAbsolutePath } from "./declareAbsolutePath.mjs";
+import { declarePath } from "./declarePath.mjs";
+import { declareSegment } from "./declareSegment.mjs";
 import { getBaseName } from "./getBaseName.mjs";
 import { getExtensionName } from "./getExtensionName.mjs";
 import { getParentFolderPath } from "./getParentFolderPath.mjs";
-import { is } from "./is.mjs";
-import { isAbsolute } from "./isAbsolute.mjs";
-import { normalize } from "./normalize.mjs";
 import { resolveRelative } from "./resolveRelative.mjs";
 import { resolveFrom } from "./resolveFrom.mjs";
 //#region scripts/path/index.ts
 var path_exports = /* @__PURE__ */ __exportAll({
+	CreateAbsolutePathError: () => CreateAbsolutePathError,
+	CreatePathError: () => CreatePathError,
+	CreateSegmentPathError: () => CreateSegmentPathError,
 	computeRelative: () => computeRelative,
+	create: () => create,
+	createAbsolute: () => createAbsolute,
+	createAbsoluteOrThrow: () => createAbsoluteOrThrow,
+	createKind: () => createKind,
+	createOrThrow: () => createOrThrow,
+	createSegment: () => createSegment,
+	createSegmentOrThrow: () => createSegmentOrThrow,
+	declareAbsolutePath: () => declareAbsolutePath,
+	declarePath: () => declarePath,
+	declareSegment: () => declareSegment,
 	getBaseName: () => getBaseName,
 	getExtensionName: () => getExtensionName,
 	getParentFolderPath: () => getParentFolderPath,
@@ -23,4 +46,4 @@ var path_exports = /* @__PURE__ */ __exportAll({
 	resolveRelative: () => resolveRelative
 });
 //#endregion
-export { computeRelative, getBaseName, getExtensionName, getParentFolderPath, is, isAbsolute, isSegment, normalize, path_exports, resolveFrom, resolveRelative };
+export { CreateAbsolutePathError, CreatePathError, CreateSegmentPathError, computeRelative, create, createAbsolute, createAbsoluteOrThrow, createKind, createOrThrow, createSegment, createSegmentOrThrow, declareAbsolutePath, declarePath, declareSegment, getBaseName, getExtensionName, getParentFolderPath, is, isAbsolute, isSegment, normalize, path_exports, resolveFrom, resolveRelative };

package/dist/path/kind.cjs

@@ -0,0 +1,4 @@
+//#region scripts/path/kind.ts
+const createKind = require("../kind/namespace.cjs").createNamespace("DuplojsLangPath");
+//#endregion
+exports.createKind = createKind;

package/dist/path/kind.d.ts

@@ -0,0 +1,2 @@
+import * as DKind from '../kind';
+export declare const createKind: <GenericName extends string, GenericKindValue extends unknown = unknown>(name: GenericName & import('../string').ForbiddenContain<GenericName, DKind.ForbiddenKindNameCharacter>) => DKind.Handler<DKind.Definition<`@DuplojsLangPath/${GenericName}`, GenericKindValue>>;

package/dist/path/kind.mjs

@@ -0,0 +1,5 @@
+import { createNamespace } from "../kind/namespace.mjs";
+//#region scripts/path/kind.ts
+const createKind = createNamespace("DuplojsLangPath");
+//#endregion
+export { createKind };

package/dist/pattern/index.cjs

@@ -16,6 +16,8 @@ const require_matchWithTaggedObject = require("./matchWithTaggedObject.cjs");
 const require_matchWithTaggedObjectOtherwise = require("./matchWithTaggedObjectOtherwise.cjs");
 const require_matchWithEntity = require("./matchWithEntity.cjs");
 const require_matchWithEntityOtherwise = require("./matchWithEntityOtherwise.cjs");
+const require_matchWithFact = require("./matchWithFact.cjs");
+const require_matchWithFactOtherwise = require("./matchWithFactOtherwise.cjs");
 //#region scripts/pattern/index.ts
 var pattern_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	InvalidExhaustivePatternError: () => require_builder.InvalidExhaustivePatternError,
@@ -26,6 +28,8 @@ var pattern_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	matchBuilder: () => require_builder.matchBuilder,
 	matchWithEntity: () => require_matchWithEntity.matchWithEntity,
 	matchWithEntityOtherwise: () => require_matchWithEntityOtherwise.matchWithEntityOtherwise,
+	matchWithFact: () => require_matchWithFact.matchWithFact,
+	matchWithFactOtherwise: () => require_matchWithFactOtherwise.matchWithFactOtherwise,
 	matchWithNumber: () => require_matchWithNumber.matchWithNumber,
 	matchWithNumberOtherwise: () => require_matchWithNumberOtherwise.matchWithNumberOtherwise,
 	matchWithString: () => require_matchWithString.matchWithString,
@@ -47,6 +51,8 @@ exports.match = require_index.match;
 exports.matchBuilder = require_builder.matchBuilder;
 exports.matchWithEntity = require_matchWithEntity.matchWithEntity;
 exports.matchWithEntityOtherwise = require_matchWithEntityOtherwise.matchWithEntityOtherwise;
+exports.matchWithFact = require_matchWithFact.matchWithFact;
+exports.matchWithFactOtherwise = require_matchWithFactOtherwise.matchWithFactOtherwise;
 exports.matchWithNumber = require_matchWithNumber.matchWithNumber;
 exports.matchWithNumberOtherwise = require_matchWithNumberOtherwise.matchWithNumberOtherwise;
 exports.matchWithString = require_matchWithString.matchWithString;

package/dist/pattern/index.d.ts

@@ -15,3 +15,5 @@ export * from './matchWithTaggedObject';
 export * from './matchWithTaggedObjectOtherwise';
 export * from './matchWithEntity';
 export * from './matchWithEntityOtherwise';
+export * from './matchWithFact';
+export * from './matchWithFactOtherwise';

package/dist/pattern/index.mjs

@@ -16,6 +16,8 @@ import { matchWithTaggedObject } from "./matchWithTaggedObject.mjs";
 import { matchWithTaggedObjectOtherwise } from "./matchWithTaggedObjectOtherwise.mjs";
 import { matchWithEntity } from "./matchWithEntity.mjs";
 import { matchWithEntityOtherwise } from "./matchWithEntityOtherwise.mjs";
+import { matchWithFact } from "./matchWithFact.mjs";
+import { matchWithFactOtherwise } from "./matchWithFactOtherwise.mjs";
 //#region scripts/pattern/index.ts
 var pattern_exports = /* @__PURE__ */ __exportAll({
 	InvalidExhaustivePatternError: () => InvalidExhaustivePatternError,
@@ -26,6 +28,8 @@ var pattern_exports = /* @__PURE__ */ __exportAll({
 	matchBuilder: () => matchBuilder,
 	matchWithEntity: () => matchWithEntity,
 	matchWithEntityOtherwise: () => matchWithEntityOtherwise,
+	matchWithFact: () => matchWithFact,
+	matchWithFactOtherwise: () => matchWithFactOtherwise,
 	matchWithNumber: () => matchWithNumber,
 	matchWithNumberOtherwise: () => matchWithNumberOtherwise,
 	matchWithString: () => matchWithString,
@@ -39,4 +43,4 @@ var pattern_exports = /* @__PURE__ */ __exportAll({
 	whenNot: () => whenNot
 });
 //#endregion
-export { InvalidExhaustivePatternError, exhaustive, isMatch, isResult, match, matchBuilder, matchWithEntity, matchWithEntityOtherwise, matchWithNumber, matchWithNumberOtherwise, matchWithString, matchWithStringOtherwise, matchWithTaggedObject, matchWithTaggedObjectOtherwise, otherwise, pattern_exports, result, union, when, whenNot };
+export { InvalidExhaustivePatternError, exhaustive, isMatch, isResult, match, matchBuilder, matchWithEntity, matchWithEntityOtherwise, matchWithFact, matchWithFactOtherwise, matchWithNumber, matchWithNumberOtherwise, matchWithString, matchWithStringOtherwise, matchWithTaggedObject, matchWithTaggedObjectOtherwise, otherwise, pattern_exports, result, union, when, whenNot };

package/dist/pattern/match/builder.cjs

@@ -12,7 +12,7 @@ var InvalidExhaustivePatternError = class extends require_parentClass.parentClas
 	}
 };
 const matchBuilder = require_justExec.justExec(() => {
-	const builder = require_builder.createBuilder("@duplojs/utils/pattern/match");
+	const builder = require_builder.createBuilder("@duplojs/lang/pattern/match");
 	builder.set("with", ({ args: [pattern, theFunction], accumulator, next }) => next({
 		...accumulator,
 		matchers: [...accumulator.matchers, {

package/dist/pattern/match/builder.mjs

@@ -12,7 +12,7 @@ var InvalidExhaustivePatternError = class extends parentClass(createKind("invali
 	}
 };
 const matchBuilder = justExec(() => {
-	const builder = createBuilder("@duplojs/utils/pattern/match");
+	const builder = createBuilder("@duplojs/lang/pattern/match");
 	builder.set("with", ({ args: [pattern, theFunction], accumulator, next }) => next({
 		...accumulator,
 		matchers: [...accumulator.matchers, {

package/dist/pattern/matchWithEntityOtherwise.d.ts

@@ -9,6 +9,6 @@ type ForbiddenMoreKey<GenericEntity extends DModeling.Entity, GenericMatcher ext
 type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
 type UnhandledEntity<GenericEntity extends DModeling.Entity, GenericMatcher extends object> = Exclude<GenericEntity, DModeling.ExtractByEntityName<GenericEntity, HandledKeys<GenericMatcher>>>;
 type RequireSimpleName<GenericEntity extends DModeling.Entity> = DString.RequireSimpleLiteral<DModeling.GetEntityName<GenericEntity>>;
-export declare function matchWithEntityOtherwise<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericEntity>, GenericMatcher>), otherwise: (value: UnhandledEntity<GenericEntity, GenericMatcher>) => GenericOutput): (input: GenericEntity & RequireSimpleName<GenericEntity>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
-export declare function matchWithEntityOtherwise<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>, GenericOutput>(input: GenericEntity & RequireSimpleName<GenericEntity>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<GenericEntity, GenericMatcher>), otherwise: (value: UnhandledEntity<GenericEntity, GenericMatcher>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithEntityOtherwise<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericEntity>, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<UnhandledEntity<GenericEntity, GenericMatcher>>) => GenericOutput): (input: GenericEntity & RequireSimpleName<GenericEntity>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithEntityOtherwise<GenericEntity extends DModeling.Entity, GenericMatcher extends ComputeMatcher<GenericEntity>, GenericOutput>(input: GenericEntity & RequireSimpleName<GenericEntity>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericEntity>, GenericMatcher> & ForbiddenMoreKey<GenericEntity, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<UnhandledEntity<GenericEntity, GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
 export {};

package/dist/pattern/matchWithFact.cjs

@@ -0,0 +1,12 @@
+const require_base = require("../modeling/fact/base.cjs");
+//#region scripts/pattern/matchWithFact.ts
+function matchWithFact(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => matcher[require_base.factKind.getValue(input).name](input);
+	}
+	const [input, matcher] = args;
+	return matcher[require_base.factKind.getValue(input).name](input, require_base.factKind.getValue(input).payload);
+}
+//#endregion
+exports.matchWithFact = matchWithFact;

package/dist/pattern/matchWithFact.d.ts

@@ -0,0 +1,12 @@
+import type * as DCommon from '../common';
+import * as DModeling from '../modeling';
+import type * as DObject from '../object';
+import type * as DString from '../string';
+type ComputeMatcher<GenericFact extends DModeling.Fact> = {
+    [Fact in GenericFact as DModeling.GetFactName<Fact>]: (value: Fact, payload: DModeling.GetFactPayload<Fact>) => unknown;
+};
+type ForbiddenMoreKey<GenericFact extends DModeling.Fact, GenericMatcher extends ComputeMatcher<GenericFact>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, DModeling.GetFactName<GenericFact>>, string>>;
+type RequireSimpleName<GenericFact extends DModeling.Fact> = DString.RequireSimpleLiteral<DModeling.GetFactName<GenericFact>>;
+export declare function matchWithFact<GenericFact extends DModeling.Fact, GenericMatcher extends ComputeMatcher<GenericFact>>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericFact>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericFact>, GenericMatcher>)): (input: GenericFact & RequireSimpleName<GenericFact>) => ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>>;
+export declare function matchWithFact<GenericFact extends DModeling.Fact, GenericMatcher extends ComputeMatcher<GenericFact>>(input: GenericFact & RequireSimpleName<GenericFact>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericFact>, GenericMatcher> & ForbiddenMoreKey<GenericFact, GenericMatcher>)): ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>>;
+export {};

package/dist/pattern/matchWithFact.mjs

@@ -0,0 +1,12 @@
+import { factKind } from "../modeling/fact/base.mjs";
+//#region scripts/pattern/matchWithFact.ts
+function matchWithFact(...args) {
+	if (args.length === 1) {
+		const [matcher] = args;
+		return (input) => matcher[factKind.getValue(input).name](input);
+	}
+	const [input, matcher] = args;
+	return matcher[factKind.getValue(input).name](input, factKind.getValue(input).payload);
+}
+//#endregion
+export { matchWithFact };

package/dist/pattern/matchWithFactOtherwise.cjs

@@ -0,0 +1,13 @@
+const require_base = require("../modeling/fact/base.cjs");
+//#region scripts/pattern/matchWithFactOtherwise.ts
+function matchWithFactOtherwise(...args) {
+	if (args.length === 2) {
+		const [matcher, otherwise] = args;
+		return (input) => matchWithFactOtherwise(input, matcher, otherwise);
+	}
+	const [input, matcher, otherwise] = args;
+	const factName = require_base.factKind.getValue(input).name;
+	return matcher[factName] === void 0 ? otherwise(input) : matcher[factName](input, require_base.factKind.getValue(input).payload);
+}
+//#endregion
+exports.matchWithFactOtherwise = matchWithFactOtherwise;

package/dist/pattern/matchWithFactOtherwise.d.ts

@@ -0,0 +1,14 @@
+import type * as DCommon from '../common';
+import * as DModeling from '../modeling';
+import type * as DObject from '../object';
+import type * as DString from '../string';
+type ComputeMatcher<GenericFact extends DModeling.Fact> = {
+    [Fact in GenericFact as DModeling.GetFactName<Fact>]?: (value: Fact, payload: DModeling.GetFactPayload<Fact>) => unknown;
+};
+type ForbiddenMoreKey<GenericFact extends DModeling.Fact, GenericMatcher extends ComputeMatcher<GenericFact>> = DObject.ForbiddenKey<GenericMatcher, Extract<Exclude<keyof GenericMatcher, DModeling.GetFactName<GenericFact>>, string>>;
+type HandledKeys<GenericMatcher extends object> = Extract<DObject.GetPropsWithValueExtends<GenericMatcher, DCommon.AnyFunction>, string>;
+type UnhandledFact<GenericFact extends DModeling.Fact, GenericMatcher extends object> = GenericFact extends DModeling.Fact ? DModeling.GetFactName<GenericFact> extends HandledKeys<GenericMatcher> ? never : GenericFact : never;
+type RequireSimpleName<GenericFact extends DModeling.Fact> = DString.RequireSimpleLiteral<DModeling.GetFactName<GenericFact>>;
+export declare function matchWithFactOtherwise<GenericFact extends DModeling.Fact, GenericMatcher extends ComputeMatcher<GenericFact>, GenericOutput>(matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericFact>, GenericMatcher> & ForbiddenMoreKey<NoInfer<GenericFact>, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<UnhandledFact<GenericFact, GenericMatcher>>) => GenericOutput): (input: GenericFact & RequireSimpleName<GenericFact>) => (ReturnType<Extract<NoInfer<GenericMatcher>[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export declare function matchWithFactOtherwise<GenericFact extends DModeling.Fact, GenericMatcher extends ComputeMatcher<GenericFact>, GenericOutput>(input: GenericFact & RequireSimpleName<GenericFact>, matcher: (DCommon.FixDeepFunctionInfer<ComputeMatcher<GenericFact>, GenericMatcher> & ForbiddenMoreKey<GenericFact, GenericMatcher>), otherwise: (value: DCommon.BreakGenericLink<UnhandledFact<GenericFact, GenericMatcher>>) => GenericOutput): (ReturnType<Extract<GenericMatcher[keyof GenericMatcher], DCommon.AnyFunction>> | GenericOutput);
+export {};

package/dist/pattern/matchWithFactOtherwise.mjs

@@ -0,0 +1,13 @@
+import { factKind } from "../modeling/fact/base.mjs";
+//#region scripts/pattern/matchWithFactOtherwise.ts
+function matchWithFactOtherwise(...args) {
+	if (args.length === 2) {
+		const [matcher, otherwise] = args;
+		return (input) => matchWithFactOtherwise(input, matcher, otherwise);
+	}
+	const [input, matcher, otherwise] = args;
+	const factName = factKind.getValue(input).name;
+	return matcher[factName] === void 0 ? otherwise(input) : matcher[factName](input, factKind.getValue(input).payload);
+}
+//#endregion
+export { matchWithFactOtherwise };

package/dist/pattern/matchWithNumberOtherwise.d.ts

@@ -6,6 +6,6 @@ type ComputeMatcher<GenericInput extends number> = DCommon.SimplifyType<{
 }>;
 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, 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 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/matchWithStringOtherwise.d.ts

@@ -6,6 +6,6 @@ type ComputeMatcher<GenericInput extends string> = DCommon.SimplifyType<{
 }>;
 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, 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 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/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

@@ -1,3 +1,5 @@
-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>;
+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/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[];