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

package/dist/object/assign.d.ts

@@ -1,4 +1,4 @@
-import { AssignObjects } from './types';
+import { Assign } from './types';
 import type * as DCommon from '../common';
-export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(value: GenericValue): (object: GenericObject) => AssignObjects<GenericObject, GenericValue>;
-export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(object: GenericObject, value: GenericValue): AssignObjects<GenericObject, GenericValue>;
+export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(value: GenericValue): (object: GenericObject) => Assign<GenericObject, GenericValue>;
+export declare function assign<GenericObject extends object, GenericValue extends Partial<Record<keyof GenericObject, unknown>> & DCommon.AnyObject>(object: GenericObject, value: GenericValue): Assign<GenericObject, GenericValue>;

package/dist/object/deepOverride.cjs

@@ -0,0 +1,33 @@
+const require_isSimple = require("./isSimple.cjs");
+const require_justExec = require("../common/justExec.cjs");
+//#region scripts/object/deepOverride.ts
+function deepOverride(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (object) => deepOverride(object, value);
+	}
+	const [object, initialValue] = args;
+	return require_justExec.justExec(function override(value = initialValue, currentValue = object) {
+		if (value === void 0) return currentValue;
+		if (Array.isArray(value)) {
+			if (!Array.isArray(currentValue)) return currentValue;
+			const result = [...currentValue];
+			const commonLength = Math.min(currentValue.length, value.length);
+			for (let index = 0; index < commonLength; index++) {
+				const overrideValue = value[index];
+				if (overrideValue !== void 0) result[index] = override(overrideValue, currentValue[index]);
+			}
+			return result;
+		}
+		if (require_isSimple.isSimple(value)) {
+			if (!require_isSimple.isSimple(currentValue)) return currentValue;
+			return Object.entries(value).reduce((result, [key, overrideValue]) => {
+				if (overrideValue !== void 0) result[key] = override(overrideValue, result[key]);
+				return result;
+			}, { ...currentValue });
+		}
+		return value;
+	});
+}
+//#endregion
+exports.deepOverride = deepOverride;

package/dist/object/deepOverride.d.ts

@@ -0,0 +1,20 @@
+import { HasKeySignature, keyofWithoutSignature } from './types';
+import * as DCommon from '../common';
+import type * as DKind from '../kind';
+type DeepOverrideParameter<GenericValue extends unknown> = (GenericValue extends unknown ? readonly [
+    GenericValue,
+    DCommon.RemoveConstraint<GenericValue>
+] : never) extends infer InferredItem extends readonly [unknown, unknown] ? DCommon.IsUnion<Extract<InferredItem[1], object>> extends true ? Exclude<InferredItem[1], object> | undefined : InferredItem extends unknown ? InferredItem[1] extends DCommon.AnyFunction ? InferredItem[0] : InferredItem[1] extends object ? InferredItem[0] extends DCommon.Constraint ? undefined : InferredItem[1] extends readonly unknown[] ? InferredItem[1] extends readonly [
+    infer InferredFirst,
+    ...infer InferredRest
+] ? readonly [
+    DeepOverrideParameter<InferredFirst> | undefined,
+    ...Extract<DeepOverrideParameter<InferredRest>, readonly unknown[]>
+] : InferredItem[1] extends readonly [] ? readonly [] : readonly (DeepOverrideParameter<InferredItem[1][number]> | undefined)[] : DCommon.SimplifyTopLevel<{
+    readonly [Prop in Exclude<keyofWithoutSignature<InferredItem[1]>, DKind.KeySymbol>]?: DeepOverrideParameter<InferredItem[1][Prop]> | undefined;
+} & (HasKeySignature<InferredItem[1]> extends true ? {
+    readonly [key: string]: InferredItem[1][keyof InferredItem[1]];
+} : unknown)> : InferredItem[0] | undefined : never : never;
+export declare function deepOverride<GenericObject extends object>(value: NoInfer<DeepOverrideParameter<GenericObject>>): (object: GenericObject) => GenericObject;
+export declare function deepOverride<GenericObject extends object>(object: GenericObject, value: NoInfer<DeepOverrideParameter<GenericObject>>): GenericObject;
+export {};

package/dist/object/deepOverride.mjs

@@ -0,0 +1,33 @@
+import { isSimple } from "./isSimple.mjs";
+import { justExec } from "../common/justExec.mjs";
+//#region scripts/object/deepOverride.ts
+function deepOverride(...args) {
+	if (args.length === 1) {
+		const [value] = args;
+		return (object) => deepOverride(object, value);
+	}
+	const [object, initialValue] = args;
+	return justExec(function override(value = initialValue, currentValue = object) {
+		if (value === void 0) return currentValue;
+		if (Array.isArray(value)) {
+			if (!Array.isArray(currentValue)) return currentValue;
+			const result = [...currentValue];
+			const commonLength = Math.min(currentValue.length, value.length);
+			for (let index = 0; index < commonLength; index++) {
+				const overrideValue = value[index];
+				if (overrideValue !== void 0) result[index] = override(overrideValue, currentValue[index]);
+			}
+			return result;
+		}
+		if (isSimple(value)) {
+			if (!isSimple(currentValue)) return currentValue;
+			return Object.entries(value).reduce((result, [key, overrideValue]) => {
+				if (overrideValue !== void 0) result[key] = override(overrideValue, result[key]);
+				return result;
+			}, { ...currentValue });
+		}
+		return value;
+	});
+}
+//#endregion
+export { deepOverride };

package/dist/object/entries.d.ts

@@ -1,9 +1,9 @@
 import type * as DString from '../string';
 import type * as DCommon from '../common';
-export type GetEntry<GenericKey extends DCommon.ObjectKey, GenericValue extends unknown> = GenericValue extends any ? GenericKey extends string | number ? [`${GenericKey}`, GenericValue] : never : never;
-export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? [DString.Number, GenericObject[number]][] : DCommon.IsEqual<GenericObject, object> extends true ? [string, DCommon.AnyValue][] : ({
+export type GetEntry<GenericKey extends DCommon.ObjectKey, GenericValue extends unknown> = GenericValue extends any ? GenericKey extends string | number ? readonly [`${GenericKey}`, GenericValue] : never : never;
+export type GetEntries<GenericObject extends object> = GenericObject extends readonly any[] ? readonly (readonly [DString.Number, GenericObject[number]])[] : DCommon.IsEqual<GenericObject, object> extends true ? readonly [string, DCommon.AnyValue][] : ({
     [Prop in keyof GenericObject]-?: GetEntry<Prop, GenericObject[Prop]>;
-}[keyof GenericObject]) extends infer InferredResult extends DCommon.ObjectEntry ? DCommon.IsEqual<InferredResult, never> extends true ? [] : InferredResult[] : never;
+}[keyof GenericObject]) extends infer InferredResult extends DCommon.ObjectEntry ? DCommon.IsEqual<InferredResult, never> extends true ? readonly [] : readonly InferredResult[] : never;
 export declare function entries<GenericObject extends object>(object: GenericObject): DCommon.SimplifyTopLevel<GetEntries<GenericObject>>;
 export declare namespace entries {
     var unsafe: {

package/dist/object/index.cjs

@@ -1,6 +1,8 @@
 const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 const require_assign = require("./assign.cjs");
 const require_countKeys = require("./countKeys.cjs");
+const require_isSimple = require("./isSimple.cjs");
+const require_deepOverride = require("./deepOverride.cjs");
 const require_getDeepProperty = require("./getDeepProperty.cjs");
 const require_deepDiscriminate = require("./deepDiscriminate.cjs");
 const require_discriminate = require("./discriminate.cjs");
@@ -11,7 +13,6 @@ const require_entry = require("./entry.cjs");
 const require_fromEntries = require("./fromEntries.cjs");
 const require_getProperty = require("./getProperty.cjs");
 const require_hasKeys = require("./hasKeys.cjs");
-const require_isSimple = require("./isSimple.cjs");
 const require_keys = require("./keys.cjs");
 const require_omit = require("./omit.cjs");
 const require_override = require("./override.cjs");
@@ -25,6 +26,7 @@ var object_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	assign: () => require_assign.assign,
 	countKeys: () => require_countKeys.countKeys,
 	deepDiscriminate: () => require_deepDiscriminate.deepDiscriminate,
+	deepOverride: () => require_deepOverride.deepOverride,
 	discriminate: () => require_discriminate.discriminate,
 	discriminateEntryKey: () => require_discriminateEntryKey.discriminateEntryKey,
 	discriminateEntryValue: () => require_discriminateEntryValue.discriminateEntryValue,
@@ -48,6 +50,7 @@ var object_exports = /* @__PURE__ */ require_runtime.__exportAll({
 exports.assign = require_assign.assign;
 exports.countKeys = require_countKeys.countKeys;
 exports.deepDiscriminate = require_deepDiscriminate.deepDiscriminate;
+exports.deepOverride = require_deepOverride.deepOverride;
 exports.discriminate = require_discriminate.discriminate;
 exports.discriminateEntryKey = require_discriminateEntryKey.discriminateEntryKey;
 exports.discriminateEntryValue = require_discriminateEntryValue.discriminateEntryValue;

package/dist/object/index.d.ts

@@ -1,5 +1,6 @@
 export * from './assign';
 export * from './countKeys';
+export * from './deepOverride';
 export * from './deepDiscriminate';
 export * from './discriminate';
 export * from './discriminateEntryKey';

package/dist/object/index.mjs

@@ -1,6 +1,8 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.mjs";
 import { assign } from "./assign.mjs";
 import { countKeys } from "./countKeys.mjs";
+import { isSimple } from "./isSimple.mjs";
+import { deepOverride } from "./deepOverride.mjs";
 import { getDeepProperty } from "./getDeepProperty.mjs";
 import { deepDiscriminate } from "./deepDiscriminate.mjs";
 import { discriminate } from "./discriminate.mjs";
@@ -11,7 +13,6 @@ import { entry } from "./entry.mjs";
 import { fromEntries } from "./fromEntries.mjs";
 import { getProperty } from "./getProperty.mjs";
 import { hasKeys } from "./hasKeys.mjs";
-import { isSimple } from "./isSimple.mjs";
 import { keys } from "./keys.mjs";
 import { omit } from "./omit.mjs";
 import { override } from "./override.mjs";
@@ -25,6 +26,7 @@ var object_exports = /* @__PURE__ */ __exportAll({
 	assign: () => assign,
 	countKeys: () => countKeys,
 	deepDiscriminate: () => deepDiscriminate,
+	deepOverride: () => deepOverride,
 	discriminate: () => discriminate,
 	discriminateEntryKey: () => discriminateEntryKey,
 	discriminateEntryValue: () => discriminateEntryValue,
@@ -45,4 +47,4 @@ var object_exports = /* @__PURE__ */ __exportAll({
 	values: () => values
 });
 //#endregion
-export { assign, countKeys, deepDiscriminate, discriminate, discriminateEntryKey, discriminateEntryValue, entries, entry, fromEntries, getDeepProperty, getProperty, hasKeys, isSimple, keys, object_exports, omit, override, pick, to, transformProperties, transformProperty, values };
+export { assign, countKeys, deepDiscriminate, deepOverride, discriminate, discriminateEntryKey, discriminateEntryValue, entries, entry, fromEntries, getDeepProperty, getProperty, hasKeys, isSimple, keys, object_exports, omit, override, pick, to, transformProperties, transformProperty, values };

package/dist/object/isSimple.cjs

@@ -1,6 +1,6 @@
 //#region scripts/object/isSimple.ts
 function isSimple(input) {
-	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor.name === "Object");
+	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor?.name === "Object");
 }
 //#endregion
 exports.isSimple = isSimple;

package/dist/object/isSimple.mjs

@@ -1,6 +1,6 @@
 //#region scripts/object/isSimple.ts
 function isSimple(input) {
-	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor.name === "Object");
+	return typeof input === "object" && input !== null && (input.constructor === void 0 || input.constructor?.name === "Object");
 }
 //#endregion
 export { isSimple };

package/dist/object/keys.d.ts

@@ -1 +1 @@
-export declare function keys<GenericObject extends object>(object: GenericObject): `${Exclude<keyof GenericObject, symbol>}`[];
+export declare function keys<GenericObject extends object>(object: GenericObject): readonly `${Exclude<keyof GenericObject, symbol>}`[];

package/dist/object/override.cjs

@@ -5,7 +5,7 @@ function override(...args) {
 		return (object) => override(object, value);
 	}
 	const [object, value] = args;
-	return Object.entries(value).reduce((acc, [key, value]) => {
+	return Object.entries(value ?? {}).reduce((acc, [key, value]) => {
 		if (value !== void 0) acc[key] = value;
 		return acc;
 	}, { ...object });

package/dist/object/override.d.ts

@@ -1,2 +1,5 @@
-export declare function override<GenericObject extends object>(value: Partial<NoInfer<GenericObject>>): (object: GenericObject) => GenericObject;
-export declare function override<GenericObject extends object>(object: GenericObject, value: Partial<NoInfer<GenericObject>>): GenericObject;
+import type * as DCommon from '../common';
+type OverrideParameter<GenericValue extends object> = DCommon.IsUnion<GenericValue> extends true ? undefined : Partial<GenericValue>;
+export declare function override<GenericObject extends object>(value: OverrideParameter<GenericObject>): (object: GenericObject) => GenericObject;
+export declare function override<GenericObject extends object>(object: GenericObject, value: OverrideParameter<GenericObject>): GenericObject;
+export {};

package/dist/object/override.mjs

@@ -5,7 +5,7 @@ function override(...args) {
 		return (object) => override(object, value);
 	}
 	const [object, value] = args;
-	return Object.entries(value).reduce((acc, [key, value]) => {
+	return Object.entries(value ?? {}).reduce((acc, [key, value]) => {
 		if (value !== void 0) acc[key] = value;
 		return acc;
 	}, { ...object });

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

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

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

@@ -1,2 +1,2 @@
 import type * as DCommon from '../../common';
-export type ForbiddenKey<GenericObject extends object, GenericKey extends string> = (GenericKey extends keyof GenericObject ? DCommon.ComputedTypeError<`Key "${GenericKey}" is forbidden.`> : never) extends infer InferredResult ? DCommon.IsEqual<InferredResult, never> extends true ? unknown : InferredResult : never;
+export type ForbiddenKey<GenericObject extends object, GenericKey extends string | number> = DCommon.IsNever<GenericKey> extends true ? unknown : (`${GenericKey}` extends `${Extract<keyof GenericObject, string | number>}` ? DCommon.ComputedTypeError<`Key "${GenericKey}" is forbidden.`> : never) extends infer InferredResult ? DCommon.IsEqual<InferredResult, never> extends true ? unknown : InferredResult : never;

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

@@ -0,0 +1 @@
+export type HasKeySignature<GenericValue extends object> = string extends keyof GenericValue ? true : number extends keyof GenericValue ? true : symbol extends keyof GenericValue ? true : false;

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

@@ -1,4 +1,4 @@
-export type * from './assignObjects';
+export type * from './assign';
 export type * from './deepPartial';
 export type * from './deepReadonly';
 export type * from './deepRemoveReadonly';
@@ -9,6 +9,9 @@ export type * from './forbiddenKey';
 export type * from './forbiddenUndefinedProps';
 export type * from './getPropsWithValue';
 export type * from './getPropsWithValueExtends';
+export type * from './hasKeySignature';
+export type * from './keyofWithoutSignature';
+export type * from './override';
 export type * from './partialKeys';
 export type * from './requireAtLeastOne';
 export type * from './requiredKeys';

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

@@ -0,0 +1,3 @@
+export type keyofWithoutSignature<GenericValue extends object> = keyof {
+    [Prop in keyof GenericValue as string extends Prop ? never : number extends Prop ? never : symbol extends Prop ? never : Prop]: GenericValue[Prop];
+};

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

@@ -0,0 +1,4 @@
+import type * as DCommon from '../../common';
+export type Override<GenericInput extends object, GenericNewValue extends Partial<GenericInput>> = DCommon.SimplifyTopLevel<{
+    [Prop in keyof GenericInput]: Prop extends keyof GenericNewValue ? GenericNewValue[Prop] extends infer InferredNewValue ? InferredNewValue extends undefined ? GenericInput[Prop] : InferredNewValue : never : GenericInput[Prop];
+}>;

package/dist/object/values.d.ts

@@ -1,2 +1,2 @@
 import type * as DCommon from '../common';
-export declare function values<GenericObject extends Record<string, DCommon.AnyValue>>(object: GenericObject): GenericObject[keyof GenericObject][];
+export declare function values<GenericObject extends Record<string, DCommon.AnyValue>>(object: GenericObject): readonly GenericObject[keyof GenericObject][];

package/dist/path/create.cjs

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

package/dist/path/create.d.ts

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

package/dist/path/create.mjs

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

package/dist/path/createAbsolute.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_isAbsolute = require("./isAbsolute.cjs");
+//#region scripts/path/createAbsolute.ts
+function createAbsolute(value) {
+	const result = require_normalize.normalize(value);
+	if (result && require_isAbsolute.isAbsolute(result)) return require_success.success(result);
+	return require_error.error(value);
+}
+//#endregion
+exports.createAbsolute = createAbsolute;

package/dist/path/createAbsolute.d.ts

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

package/dist/path/createAbsolute.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 { isAbsolute } from "./isAbsolute.mjs";
+//#region scripts/path/createAbsolute.ts
+function createAbsolute(value) {
+	const result = normalize(value);
+	if (result && isAbsolute(result)) return success(result);
+	return error(value);
+}
+//#endregion
+export { createAbsolute };

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