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

package/dist/path/createAbsoluteOrThrow.cjs

@@ -0,0 +1,22 @@
+const require_parentClass = require("../kind/parentClass.cjs");
+const require_is = require("../either/left/is.cjs");
+const require_unwrap = require("../either/left/unwrap.cjs");
+const require_unwrap$1 = require("../either/right/unwrap.cjs");
+const require_createAbsolute = require("./createAbsolute.cjs");
+const require_kind = require("./kind.cjs");
+//#region scripts/path/createAbsoluteOrThrow.ts
+var CreateAbsolutePathError = class extends require_parentClass.parentClass(require_kind.createKind("create-absolute-path-error"), Error) {
+	value;
+	constructor(value) {
+		super(null, `Invalid absolute path: ${value}`);
+		this.value = value;
+	}
+};
+function createAbsoluteOrThrow(value) {
+	const result = require_createAbsolute.createAbsolute(value);
+	if (require_is.isLeft(result)) throw new CreateAbsolutePathError(require_unwrap.unwrapLeft(result));
+	return require_unwrap$1.unwrapRight(result);
+}
+//#endregion
+exports.CreateAbsolutePathError = CreateAbsolutePathError;
+exports.createAbsoluteOrThrow = createAbsoluteOrThrow;

package/dist/path/createAbsoluteOrThrow.d.ts

@@ -0,0 +1,9 @@
+import { Absolute } from './constraints';
+import * as DKind from '../kind';
+declare const CreateAbsolutePathError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangPath/create-absolute-path-error", unknown>>, ErrorConstructor>;
+export declare class CreateAbsolutePathError extends CreateAbsolutePathError_base {
+    value: string;
+    constructor(value: string);
+}
+export declare function createAbsoluteOrThrow(value: string): string & Absolute;
+export {};

package/dist/path/createAbsoluteOrThrow.mjs

@@ -0,0 +1,21 @@
+import { parentClass } from "../kind/parentClass.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { unwrapLeft } from "../either/left/unwrap.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { createAbsolute } from "./createAbsolute.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/path/createAbsoluteOrThrow.ts
+var CreateAbsolutePathError = class extends parentClass(createKind("create-absolute-path-error"), Error) {
+	value;
+	constructor(value) {
+		super(null, `Invalid absolute path: ${value}`);
+		this.value = value;
+	}
+};
+function createAbsoluteOrThrow(value) {
+	const result = createAbsolute(value);
+	if (isLeft(result)) throw new CreateAbsolutePathError(unwrapLeft(result));
+	return unwrapRight(result);
+}
+//#endregion
+export { CreateAbsolutePathError, createAbsoluteOrThrow };

package/dist/path/createOrThrow.cjs

@@ -0,0 +1,22 @@
+const require_parentClass = require("../kind/parentClass.cjs");
+const require_is = require("../either/left/is.cjs");
+const require_unwrap = require("../either/left/unwrap.cjs");
+const require_unwrap$1 = require("../either/right/unwrap.cjs");
+const require_create = require("./create.cjs");
+const require_kind = require("./kind.cjs");
+//#region scripts/path/createOrThrow.ts
+var CreatePathError = class extends require_parentClass.parentClass(require_kind.createKind("create-path-error"), Error) {
+	value;
+	constructor(value) {
+		super(null, `Invalid path: ${value}`);
+		this.value = value;
+	}
+};
+function createOrThrow(value) {
+	const result = require_create.create(value);
+	if (require_is.isLeft(result)) throw new CreatePathError(require_unwrap.unwrapLeft(result));
+	return require_unwrap$1.unwrapRight(result);
+}
+//#endregion
+exports.CreatePathError = CreatePathError;
+exports.createOrThrow = createOrThrow;

package/dist/path/createOrThrow.d.ts

@@ -0,0 +1,9 @@
+import { Path } from './constraints';
+import * as DKind from '../kind';
+declare const CreatePathError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangPath/create-path-error", unknown>>, ErrorConstructor>;
+export declare class CreatePathError extends CreatePathError_base {
+    value: string;
+    constructor(value: string);
+}
+export declare function createOrThrow(value: string): string & Path;
+export {};

package/dist/path/createOrThrow.mjs

@@ -0,0 +1,21 @@
+import { parentClass } from "../kind/parentClass.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { unwrapLeft } from "../either/left/unwrap.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { create } from "./create.mjs";
+import { createKind } from "./kind.mjs";
+//#region scripts/path/createOrThrow.ts
+var CreatePathError = class extends parentClass(createKind("create-path-error"), Error) {
+	value;
+	constructor(value) {
+		super(null, `Invalid path: ${value}`);
+		this.value = value;
+	}
+};
+function createOrThrow(value) {
+	const result = create(value);
+	if (isLeft(result)) throw new CreatePathError(unwrapLeft(result));
+	return unwrapRight(result);
+}
+//#endregion
+export { CreatePathError, createOrThrow };

package/dist/path/createSegment.cjs

@@ -0,0 +1,12 @@
+const require_error = require("../either/left/error.cjs");
+const require_success = require("../either/right/success.cjs");
+const require_normalize = require("./normalize.cjs");
+const require_isSegment = require("./isSegment.cjs");
+//#region scripts/path/createSegment.ts
+function createSegment(value) {
+	const result = require_normalize.normalize(value);
+	if (result && require_isSegment.isSegment(result)) return require_success.success(result);
+	return require_error.error(value);
+}
+//#endregion
+exports.createSegment = createSegment;

package/dist/path/createSegment.d.ts

@@ -0,0 +1,3 @@
+import { Segment } from './constraints';
+import * as DEither from '../either';
+export declare function createSegment(value: string): (DEither.Success<string & Segment> | DEither.Error<string>);

package/dist/path/createSegment.mjs

@@ -0,0 +1,12 @@
+import { error } from "../either/left/error.mjs";
+import { success } from "../either/right/success.mjs";
+import { normalize } from "./normalize.mjs";
+import { isSegment } from "./isSegment.mjs";
+//#region scripts/path/createSegment.ts
+function createSegment(value) {
+	const result = normalize(value);
+	if (result && isSegment(result)) return success(result);
+	return error(value);
+}
+//#endregion
+export { createSegment };

package/dist/path/createSegmentOrThrow.cjs

@@ -0,0 +1,22 @@
+const require_parentClass = require("../kind/parentClass.cjs");
+const require_is = require("../either/left/is.cjs");
+const require_unwrap = require("../either/left/unwrap.cjs");
+const require_unwrap$1 = require("../either/right/unwrap.cjs");
+const require_kind = require("./kind.cjs");
+const require_createSegment = require("./createSegment.cjs");
+//#region scripts/path/createSegmentOrThrow.ts
+var CreateSegmentPathError = class extends require_parentClass.parentClass(require_kind.createKind("create-segment-path-error"), Error) {
+	value;
+	constructor(value) {
+		super(null, `Invalid segment path: ${value}`);
+		this.value = value;
+	}
+};
+function createSegmentOrThrow(value) {
+	const result = require_createSegment.createSegment(value);
+	if (require_is.isLeft(result)) throw new CreateSegmentPathError(require_unwrap.unwrapLeft(result));
+	return require_unwrap$1.unwrapRight(result);
+}
+//#endregion
+exports.CreateSegmentPathError = CreateSegmentPathError;
+exports.createSegmentOrThrow = createSegmentOrThrow;

package/dist/path/createSegmentOrThrow.d.ts

@@ -0,0 +1,9 @@
+import { Segment } from './constraints';
+import * as DKind from '../kind';
+declare const CreateSegmentPathError_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangPath/create-segment-path-error", unknown>>, ErrorConstructor>;
+export declare class CreateSegmentPathError extends CreateSegmentPathError_base {
+    value: string;
+    constructor(value: string);
+}
+export declare function createSegmentOrThrow(value: string): string & Segment;
+export {};

package/dist/path/createSegmentOrThrow.mjs

@@ -0,0 +1,21 @@
+import { parentClass } from "../kind/parentClass.mjs";
+import { isLeft } from "../either/left/is.mjs";
+import { unwrapLeft } from "../either/left/unwrap.mjs";
+import { unwrapRight } from "../either/right/unwrap.mjs";
+import { createKind } from "./kind.mjs";
+import { createSegment } from "./createSegment.mjs";
+//#region scripts/path/createSegmentOrThrow.ts
+var CreateSegmentPathError = class extends parentClass(createKind("create-segment-path-error"), Error) {
+	value;
+	constructor(value) {
+		super(null, `Invalid segment path: ${value}`);
+		this.value = value;
+	}
+};
+function createSegmentOrThrow(value) {
+	const result = createSegment(value);
+	if (isLeft(result)) throw new CreateSegmentPathError(unwrapLeft(result));
+	return unwrapRight(result);
+}
+//#endregion
+export { CreateSegmentPathError, createSegmentOrThrow };

package/dist/path/declareAbsolutePath.cjs

@@ -0,0 +1,6 @@
+//#region scripts/path/declareAbsolutePath.ts
+function declareAbsolutePath(value) {
+	return value;
+}
+//#endregion
+exports.declareAbsolutePath = declareAbsolutePath;

package/dist/path/declareAbsolutePath.d.ts

@@ -0,0 +1,3 @@
+import { Absolute } from './constraints';
+import { RequireLiteralAbsolutePath } from './types';
+export declare function declareAbsolutePath<GenericValue extends string>(value: (GenericValue & RequireLiteralAbsolutePath<GenericValue>)): GenericValue & Absolute;

package/dist/path/declareAbsolutePath.mjs

@@ -0,0 +1,6 @@
+//#region scripts/path/declareAbsolutePath.ts
+function declareAbsolutePath(value) {
+	return value;
+}
+//#endregion
+export { declareAbsolutePath };

package/dist/path/declarePath.cjs

@@ -0,0 +1,6 @@
+//#region scripts/path/declarePath.ts
+function declarePath(value) {
+	return value;
+}
+//#endregion
+exports.declarePath = declarePath;

package/dist/path/declarePath.d.ts

@@ -0,0 +1,3 @@
+import { Path } from './constraints';
+import { RequireLiteralPath } from './types';
+export declare function declarePath<GenericValue extends string>(value: (GenericValue & RequireLiteralPath<GenericValue>)): GenericValue & Path;

package/dist/path/declarePath.mjs

@@ -0,0 +1,6 @@
+//#region scripts/path/declarePath.ts
+function declarePath(value) {
+	return value;
+}
+//#endregion
+export { declarePath };

package/dist/path/declareSegment.cjs

@@ -0,0 +1,6 @@
+//#region scripts/path/declareSegment.ts
+function declareSegment(value) {
+	return value;
+}
+//#endregion
+exports.declareSegment = declareSegment;

package/dist/path/declareSegment.d.ts

@@ -0,0 +1,3 @@
+import { Segment } from './constraints';
+import { RequireLiteralSegmentPath } from './types';
+export declare function declareSegment<GenericValue extends string>(value: (GenericValue & RequireLiteralSegmentPath<GenericValue>)): GenericValue & Segment;

package/dist/path/declareSegment.mjs

@@ -0,0 +1,6 @@
+//#region scripts/path/declareSegment.ts
+function declareSegment(value) {
+	return value;
+}
+//#endregion
+export { declareSegment };

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/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 {};